mono/metadata/object-internals.h

   1 #ifndef __MONO_OBJECT_INTERNALS_H__
   2 #define __MONO_OBJECT_INTERNALS_H__
   3
   4 #include <mono/metadata/object.h>
   5 #include <mono/metadata/threads.h>
   6 #include <mono/metadata/reflection.h>
   7 #include <mono/metadata/mempool.h>
   8 #include <mono/io-layer/io-layer.h>
   9 #include "mono/utils/mono-compiler.h"
  10
  11 /*
  12  * We should find a better place for this stuff. We can't put it in mono-compiler.h,
  13  * since that is included by libgc.
  14  */
  15 #ifndef G_LIKELY
  16 #define G_LIKELY(a) (a)
  17 #define G_UNLIKELY(a) (a)
  18 #endif
  19
  20 /*
  21  * glib defines this macro and uses it in the definition of G_LIKELY, and thus,
  22  * g_assert (). The macro expands to a complex piece of code, preventing some
  23  * gcc versions like 4.3.0 from handling the __builtin_expect construct properly,
  24  * causing the generation of the unlikely branch into the middle of the code.
  25  */
  26 #ifdef _G_BOOLEAN_EXPR
  27 #undef _G_BOOLEAN_EXPR
  28 #define _G_BOOLEAN_EXPR(expr) (gsize)(expr)
  29 #endif
  30
  31 #if 1
  32 #ifdef __GNUC__
  33 #define mono_assert(expr)                  G_STMT_START{                  \
  34      if (!(expr))                                                         \
  35        {                                                                  \
  36                 MonoException *ex;                                        \
  37                 char *msg = g_strdup_printf ("file %s: line %d (%s): "    \
  38                 "assertion failed: (%s)", __FILE__, __LINE__,             \
  39                 __PRETTY_FUNCTION__, #expr);                              \
  40                 ex = mono_get_exception_execution_engine (msg);           \
  41                 g_free (msg);                                             \
  42                 mono_raise_exception (ex);                                \
  43        };                               }G_STMT_END
  44
  45 #define mono_assert_not_reached()                 G_STMT_START{           \
  46      MonoException *ex;                                                   \
  47      char *msg = g_strdup_printf ("file %s: line %d (%s): "               \
  48      "should not be reached", __FILE__, __LINE__, __PRETTY_FUNCTION__);   \
  49      ex = mono_get_exception_execution_engine (msg);                      \
  50      g_free (msg);                                                        \
  51      mono_raise_exception (ex);                                           \
  52 }G_STMT_END
  53 #else /* not GNUC */
  54 #define mono_assert(expr)                  G_STMT_START{                  \
  55      if (!(expr))                                                         \
  56        {                                                                  \
  57                 MonoException *ex;                                        \
  58                 char *msg = g_strdup_printf ("file %s: line %d: "         \
  59                 "assertion failed: (%s)", __FILE__, __LINE__,             \
  60                 #expr);                                                   \
  61                 ex = mono_get_exception_execution_engine (msg);           \
  62                 g_free (msg);                                             \
  63                 mono_raise_exception (ex);                                \
  64        };                               }G_STMT_END
  65
  66 #define mono_assert_not_reached()                 G_STMT_START{           \
  67      MonoException *ex;                                                   \
  68      char *msg = g_strdup_printf ("file %s: line %d): "                   \
  69      "should not be reached", __FILE__, __LINE__);                        \
  70      ex = mono_get_exception_execution_engine (msg);                      \
  71      g_free (msg);                                                        \
  72      mono_raise_exception (ex);                                           \
  73 }G_STMT_END
  74 #endif
  75 #else
  76 #define mono_assert(expr) g_assert(expr)
  77 #define mono_assert_not_reached() g_assert_not_reached()
  78 #endif
  79
  80 #define MONO_CHECK_ARG(arg, expr)               G_STMT_START{             \
  81      if (!(expr))                                                         \
  82        {                                                                  \
  83                 MonoException *ex;                                        \
  84                 char *msg = g_strdup_printf ("assertion `%s' failed",     \
  85                 #expr);                                                   \
  86                 if (arg) {} /* check if the name exists */                \
  87                 ex = mono_get_exception_argument (#arg, msg);             \
  88                 g_free (msg);                                             \
  89                 mono_raise_exception (ex);                                \
  90        };                               }G_STMT_END
  91
  92 #define MONO_CHECK_ARG_NULL(arg)            G_STMT_START{                 \
  93      if (arg == NULL)                                                     \
  94        {                                                                  \
  95                 MonoException *ex;                                        \
  96                 if (arg) {} /* check if the name exists */                \
  97                 ex = mono_get_exception_argument_null (#arg);             \
  98                 mono_raise_exception (ex);                                \
  99        };                               }G_STMT_END
 100
 101
 102 /* 16 == default capacity */
 103 #define mono_stringbuilder_capacity(sb) ((sb)->str ? ((sb)->str->length) : 16)
 104
 105 typedef struct {
 106         MonoObject obj;
 107         MonoObject *identity;
 108 } MonoMarshalByRefObject;
 109
 110 /* This is a copy of System.AppDomain */
 111 struct _MonoAppDomain {
 112         MonoMarshalByRefObject mbr;
 113         MonoDomain *data;
 114 };
 115
 116 typedef struct {
 117         MonoObject object;
 118         gint32 length;
 119         MonoString *str;
 120         MonoString *cached_str;
 121         gint32 max_capacity;
 122 } MonoStringBuilder;
 123
 124 typedef struct {
 125         MonoType *type;
 126         gpointer  value;
 127         MonoClass *klass;
 128 } MonoTypedRef;
 129
 130 typedef struct {
 131         gpointer args;
 132 } MonoArgumentHandle;
 133
 134 typedef struct {
 135         MonoMethodSignature *sig;
 136         gpointer args;
 137         gint32 next_arg;
 138         gint32 num_args;
 139 } MonoArgIterator;
 140
 141 struct _MonoException {
 142         MonoObject object;
 143         /* Stores the IPs and the generic sharing infos
 144            (vtable/MRGCTX) of the frames. */
 145         MonoArray  *trace_ips;
 146         MonoObject *inner_ex;
 147         MonoString *message;
 148         MonoString *help_link;
 149         MonoString *class_name;
 150         MonoString *stack_trace;
 151         MonoString *remote_stack_trace;
 152         gint32      remote_stack_index;
 153         gint32      hresult;
 154         MonoString *source;
 155         MonoObject *_data;
 156 };
 157
 158 typedef struct {
 159         MonoException base;
 160 } MonoSystemException;
 161
 162 typedef struct {
 163         MonoSystemException base;
 164         MonoString *param_name;
 165 } MonoArgumentException;
 166
 167 typedef struct {
 168         MonoSystemException base;
 169         MonoString *msg;
 170         MonoString *type_name;
 171 } MonoTypeLoadException;
 172
 173 typedef struct {
 174         MonoObject   object;
 175         MonoObject  *async_state;
 176         MonoObject  *handle;
 177         MonoObject  *async_delegate;
 178         gpointer    *data;
 179         MonoObject  *object_data;
 180         MonoBoolean  sync_completed;
 181         MonoBoolean  completed;
 182         MonoBoolean  endinvoke_called;
 183         MonoObject  *async_callback;
 184         MonoObject  *execution_context;
 185         MonoObject  *original_context;
 186 } MonoAsyncResult;
 187
 188 typedef struct {
 189         MonoMarshalByRefObject object;
 190         gpointer     handle;
 191         MonoBoolean  disposed;
 192 } MonoWaitHandle;
 193
 194 /* This is a copy of System.Runtime.Remoting.Messaging.CallType */
 195 typedef enum {
 196         CallType_Sync = 0,
 197         CallType_BeginInvoke = 1,
 198         CallType_EndInvoke = 2,
 199         CallType_OneWay = 3
 200 } MonoCallType;
 201
 202 struct _MonoReflectionType {
 203         MonoObject object;
 204         MonoType  *type;
 205 };
 206
 207 typedef struct {
 208         MonoObject  object;
 209         MonoReflectionType *class_to_proxy;
 210         MonoObject *context;
 211         MonoObject *unwrapped_server;
 212         gint32      target_domain_id;
 213         MonoString *target_uri;
 214         MonoObject *object_identity;
 215         MonoObject *obj_TP;
 216         MonoObject *stub_data;
 217 } MonoRealProxy;
 218
 219 typedef struct {
 220         MonoMarshalByRefObject object;
 221         gpointer iunknown;
 222         GHashTable* itf_hash;
 223 } MonoComObject;
 224
 225 typedef struct {
 226         MonoRealProxy real_proxy;
 227         MonoComObject *com_object;
 228         gint32 ref_count;
 229 } MonoComInteropProxy;
 230
 231 typedef struct {
 232         MonoObject       object;
 233         MonoRealProxy   *rp;
 234         MonoRemoteClass *remote_class;
 235         MonoBoolean      custom_type_info;
 236 } MonoTransparentProxy;
 237
 238 typedef struct {
 239         MonoObject obj;
 240         MonoReflectionMethod *method;
 241         MonoArray  *args;
 242         MonoArray  *names;
 243         MonoArray  *arg_types;
 244         MonoObject *ctx;
 245         MonoObject *rval;
 246         MonoObject *exc;
 247         MonoAsyncResult *async_result;
 248         guint32     call_type;
 249 } MonoMethodMessage;
 250
 251 typedef struct {
 252         MonoObject obj;
 253         gint32 il_offset;
 254         gint32 native_offset;
 255         MonoReflectionMethod *method;
 256         MonoString *filename;
 257         gint32 line;
 258         gint32 column;
 259         MonoString *internal_method_name;
 260 } MonoStackFrame;
 261
 262 struct _MonoThread {
 263         MonoObject  obj;
 264         int         lock_thread_id; /* to be used as the pre-shifted thread id in thin locks */
 265         HANDLE      handle;
 266         MonoArray  *cached_culture_info;
 267         gpointer    unused1;
 268         MonoBoolean threadpool_thread;
 269         gunichar2  *name;
 270         guint32     name_len;
 271         guint32     state;
 272         MonoException *abort_exc;
 273         MonoObject *abort_state;
 274         guint64 tid;    /* This is accessed as a gsize in the code (so it can hold a 64bit pointer on systems that need it), but needs to reserve 64 bits of space on all machines as it corresponds to a field in managed code */
 275         HANDLE      start_notify;
 276         gpointer stack_ptr;
 277         gpointer *static_data;
 278         gpointer jit_data;
 279         gpointer lock_data;
 280         MonoAppContext *current_appcontext;
 281         int stack_size;
 282         MonoObject *start_obj;
 283         GSList *appdomain_refs;
 284         /* This is modified using atomic ops, so keep it a gint32 */
 285         gint32 interruption_requested;
 286         gpointer suspend_event;
 287         gpointer suspended_event;
 288         gpointer resume_event;
 289         CRITICAL_SECTION *synch_cs;
 290         guint8* serialized_culture_info;
 291         guint32 serialized_culture_info_len;
 292         guint8* serialized_ui_culture_info;
 293         guint32 serialized_ui_culture_info_len;
 294         MonoObject *execution_context;
 295         MonoBoolean thread_dump_requested;
 296         gpointer end_stack; /* This is only used when running in the debugger. */
 297         MonoBoolean thread_interrupt_requested;
 298         guint8  apartment_state;
 299         gint32 critical_region_level;
 300         guint32 small_id; /* A small, unique id, used for the hazard pointer table. */
 301         MonoThreadManageCallback manage_callback;
 302         MonoException *pending_exception;
 303         /*
 304          * These fields are used to avoid having to increment corlib versions
 305          * when a new field is added to the unmanaged MonoThread structure.
 306          */
 307         gpointer unused2;
 308         gpointer unused3;
 309         gpointer unused4;
 310         gpointer unused5;
 311         gpointer unused6;
 312 };
 313
 314 typedef struct {
 315         MonoString *name;
 316         MonoReflectionType *type;
 317         MonoObject *value;
 318 } MonoSerializationEntry;
 319
 320 typedef struct {
 321         guint32 state;
 322         MonoObject *additional;
 323 } MonoStreamingContext;
 324
 325 typedef struct {
 326         MonoObject obj;
 327         MonoBoolean readOnly;
 328         MonoString *AMDesignator;
 329         MonoString *PMDesignator;
 330         MonoString *DateSeparator;
 331         MonoString *TimeSeparator;
 332         MonoString *ShortDatePattern;
 333         MonoString *LongDatePattern;
 334         MonoString *ShortTimePattern;
 335         MonoString *LongTimePattern;
 336         MonoString *MonthDayPattern;
 337         MonoString *YearMonthPattern;
 338         MonoString *FullDateTimePattern;
 339         MonoString *RFC1123Pattern;
 340         MonoString *SortableDateTimePattern;
 341         MonoString *UniversalSortableDateTimePattern;
 342         guint32 FirstDayOfWeek;
 343         MonoObject *Calendar;
 344         guint32 CalendarWeekRule;
 345         MonoArray *AbbreviatedDayNames;
 346         MonoArray *DayNames;
 347         MonoArray *MonthNames;
 348         MonoArray *AbbreviatedMonthNames;
 349         MonoArray *ShortDatePatterns;
 350         MonoArray *LongDatePatterns;
 351         MonoArray *ShortTimePatterns;
 352         MonoArray *LongTimePatterns;
 353         MonoArray *MonthDayPatterns;
 354         MonoArray *YearMonthPatterns;
 355         MonoArray *shortDayNames;
 356 } MonoDateTimeFormatInfo;
 357
 358 typedef struct
 359 {
 360         MonoObject obj;
 361         MonoBoolean readOnly;
 362         MonoString *decimalFormats;
 363         MonoString *currencyFormats;
 364         MonoString *percentFormats;
 365         MonoString *digitPattern;
 366         MonoString *zeroPattern;
 367         gint32 currencyDecimalDigits;
 368         MonoString *currencyDecimalSeparator;
 369         MonoString *currencyGroupSeparator;
 370         MonoArray *currencyGroupSizes;
 371         gint32 currencyNegativePattern;
 372         gint32 currencyPositivePattern;
 373         MonoString *currencySymbol;
 374         MonoString *naNSymbol;
 375         MonoString *negativeInfinitySymbol;
 376         MonoString *negativeSign;
 377         guint32 numberDecimalDigits;
 378         MonoString *numberDecimalSeparator;
 379         MonoString *numberGroupSeparator;
 380         MonoArray *numberGroupSizes;
 381         gint32 numberNegativePattern;
 382         gint32 percentDecimalDigits;
 383         MonoString *percentDecimalSeparator;
 384         MonoString *percentGroupSeparator;
 385         MonoArray *percentGroupSizes;
 386         gint32 percentNegativePattern;
 387         gint32 percentPositivePattern;
 388         MonoString *percentSymbol;
 389         MonoString *perMilleSymbol;
 390         MonoString *positiveInfinitySymbol;
 391         MonoString *positiveSign;
 392 } MonoNumberFormatInfo;
 393
 394 typedef struct {
 395         MonoObject obj;
 396         gint32 lcid;
 397         MonoString *icu_name;
 398         gpointer ICU_collator;
 399 } MonoCompareInfo;
 400
 401 typedef struct {
 402         MonoObject obj;
 403         MonoBoolean is_read_only;
 404         gint32 lcid;
 405         gint32 parent_lcid;
 406         gint32 specific_lcid;
 407         gint32 datetime_index;
 408         gint32 number_index;
 409         MonoBoolean use_user_override;
 410         MonoNumberFormatInfo *number_format;
 411         MonoDateTimeFormatInfo *datetime_format;
 412         MonoObject *textinfo;
 413         MonoString *name;
 414         MonoString *displayname;
 415         MonoString *englishname;
 416         MonoString *nativename;
 417         MonoString *iso3lang;
 418         MonoString *iso2lang;
 419         MonoString *icu_name;
 420         MonoString *win3lang;
 421         MonoString *territory;
 422         MonoCompareInfo *compareinfo;
 423         const gint32 *calendar_data;
 424         const void* text_info_data;
 425 } MonoCultureInfo;
 426
 427 typedef struct {
 428         MonoObject obj;
 429         gint32 region_id;
 430         MonoString *iso2name;
 431         MonoString *iso3name;
 432         MonoString *win3name;
 433         MonoString *english_name;
 434         MonoString *currency_symbol;
 435         MonoString *iso_currency_symbol;
 436         MonoString *currency_english_name;
 437 } MonoRegionInfo;
 438
 439 typedef struct {
 440         MonoObject obj;
 441         MonoString *str;
 442         gint32 options;
 443         MonoArray *key;
 444         gint32 lcid;
 445 } MonoSortKey;
 446
 447 typedef struct {
 448         MonoObject object;
 449         guint32 intType;
 450 } MonoInterfaceTypeAttribute;
 451
 452 /* used to free a dynamic method */
 453 typedef void        (*MonoFreeMethodFunc)        (MonoDomain *domain, MonoMethod *method);
 454
 455 /* Used to initialize the method pointers inside vtables */
 456 typedef gboolean    (*MonoInitVTableFunc)    (MonoVTable *vtable);
 457
 458 void mono_set_pending_exception (MonoException *exc) MONO_INTERNAL;
 459
 460 /* remoting and async support */
 461
 462 MonoAsyncResult *
 463 mono_async_result_new       (MonoDomain *domain, HANDLE handle,
 464                              MonoObject *state, gpointer data, MonoObject *object_data) MONO_INTERNAL;
 465
 466 MonoWaitHandle *
 467 mono_wait_handle_new        (MonoDomain *domain, HANDLE handle) MONO_INTERNAL;
 468
 469 HANDLE
 470 mono_wait_handle_get_handle (MonoWaitHandle *handle) MONO_INTERNAL;
 471
 472 void
 473 mono_message_init           (MonoDomain *domain, MonoMethodMessage *this_obj,
 474                              MonoReflectionMethod *method, MonoArray *out_args) MONO_INTERNAL;
 475
 476 MonoObject *
 477 mono_remoting_invoke        (MonoObject *real_proxy, MonoMethodMessage *msg,
 478                              MonoObject **exc, MonoArray **out_args) MONO_INTERNAL;
 479
 480 MonoObject *
 481 mono_message_invoke         (MonoObject *target, MonoMethodMessage *msg,
 482                              MonoObject **exc, MonoArray **out_args) MONO_INTERNAL;
 483
 484 MonoMethodMessage *
 485 mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
 486                               MonoDelegate **cb, MonoObject **state) MONO_INTERNAL;
 487
 488 void
 489 mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args) MONO_INTERNAL;
 490
 491 void
 492 mono_delegate_ctor_with_method (MonoObject *this, MonoObject *target, gpointer addr, MonoMethod *method) MONO_INTERNAL;
 493
 494 void
 495 mono_delegate_ctor          (MonoObject *this_obj, MonoObject *target, gpointer addr) MONO_INTERNAL;
 496
 497 void*
 498 mono_class_get_allocation_ftn (MonoVTable *vtable, gboolean for_box, gboolean *pass_size_in_words) MONO_INTERNAL;
 499
 500 void
 501 mono_runtime_free_method    (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL;
 502
 503 /* runtime initialization functions */
 504 typedef void (*MonoExceptionFunc) (MonoException *ex);
 505
 506 void
 507 mono_install_handler        (MonoExceptionFunc func) MONO_INTERNAL;
 508
 509 void
 510 mono_install_runtime_invoke (MonoInvokeFunc func) MONO_INTERNAL;
 511
 512 void
 513 mono_install_compile_method (MonoCompileFunc func) MONO_INTERNAL;
 514
 515 void
 516 mono_install_free_method    (MonoFreeMethodFunc func) MONO_INTERNAL;
 517
 518 void
 519 mono_type_initialization_init (void) MONO_INTERNAL;
 520
 521 void
 522 mono_type_initialization_cleanup (void) MONO_INTERNAL;
 523
 524 guint32
 525 mono_thread_get_tls_key    (void) MONO_INTERNAL;
 526
 527 gint32
 528 mono_thread_get_tls_offset (void) MONO_INTERNAL;
 529
 530 guint32
 531 mono_domain_get_tls_key    (void) MONO_INTERNAL;
 532
 533 gint32
 534 mono_domain_get_tls_offset (void) MONO_INTERNAL;
 535
 536 /* Reflection and Reflection.Emit support */
 537
 538 /*
 539  * The following structure must match the C# implementation in our corlib.
 540  */
 541
 542 struct _MonoReflectionMethod {
 543         MonoObject object;
 544         MonoMethod *method;
 545         MonoString *name;
 546         MonoReflectionType *reftype;
 547 };
 548
 549 typedef struct _MonoReflectionGenericMethod MonoReflectionGenericMethod;
 550 struct _MonoReflectionGenericMethod {
 551         MonoReflectionMethod method;
 552 };
 553
 554 struct _MonoDelegate {
 555         MonoObject object;
 556         /* The compiled code of the target method */
 557         gpointer method_ptr;
 558         /* The invoke code */
 559         gpointer invoke_impl;
 560         MonoObject *target;
 561         MonoMethod *method;
 562         gpointer delegate_trampoline;
 563         /*
 564          * If non-NULL, this points to a memory location which stores the address of
 565          * the compiled code of the method, or NULL if it is not yet compiled.
 566          */
 567         guint8 **method_code;
 568         MonoReflectionMethod *method_info;
 569         MonoReflectionMethod *original_method_info;
 570         MonoObject *data;
 571 };
 572
 573 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
 574 struct _MonoMulticastDelegate {
 575         MonoDelegate delegate;
 576         MonoMulticastDelegate *prev;
 577 };
 578
 579 struct _MonoReflectionField {
 580         MonoObject object;
 581         MonoClass *klass;
 582         MonoClassField *field;
 583         MonoString *name;
 584         MonoReflectionType *type;
 585         guint32 attrs;
 586 };
 587
 588 struct _MonoReflectionProperty {
 589         MonoObject object;
 590         MonoClass *klass;
 591         MonoProperty *property;
 592 };
 593
 594 struct _MonoReflectionEvent {
 595         MonoObject object;
 596         MonoClass *klass;
 597         MonoEvent *event;
 598 };
 599
 600 typedef struct {
 601         MonoObject object;
 602         MonoReflectionType *ClassImpl;
 603         MonoObject *DefaultValueImpl;
 604         MonoObject *MemberImpl;
 605         MonoString *NameImpl;
 606         gint32 PositionImpl;
 607         guint32 AttrsImpl;
 608         MonoObject *MarshalAsImpl;
 609 } MonoReflectionParameter;
 610
 611 struct _MonoReflectionMethodBody {
 612         MonoObject object;
 613         MonoArray *clauses;
 614         MonoArray *locals;
 615         MonoArray *il;
 616         MonoBoolean init_locals;
 617         guint32 local_var_sig_token;
 618         guint32 max_stack;
 619 };
 620
 621 struct _MonoReflectionAssembly {
 622         MonoObject object;
 623         MonoAssembly *assembly;
 624         MonoObject *resolve_event_holder;
 625         /* CAS related */
 626         MonoObject *evidence;   /* Evidence */
 627         MonoObject *minimum;    /* PermissionSet - for SecurityAction.RequestMinimum */
 628         MonoObject *optional;   /* PermissionSet - for SecurityAction.RequestOptional */
 629         MonoObject *refuse;     /* PermissionSet - for SecurityAction.RequestRefuse */
 630         MonoObject *granted;    /* PermissionSet - for the resolved assembly granted permissions */
 631         MonoObject *denied;     /* PermissionSet - for the resolved assembly denied permissions */
 632         /* */
 633         MonoBoolean from_byte_array;
 634         MonoString *name;
 635 };
 636
 637 typedef struct {
 638         MonoReflectionType *utype;
 639         MonoArray *values;
 640         MonoArray *names;
 641 } MonoEnumInfo;
 642
 643 typedef struct {
 644         MonoReflectionType *parent;
 645         MonoReflectionType *ret;
 646         guint32 attrs;
 647         guint32 implattrs;
 648         guint32 callconv;
 649 } MonoMethodInfo;
 650
 651 typedef struct {
 652         MonoReflectionType *parent;
 653         MonoString *name;
 654         MonoReflectionMethod *get;
 655         MonoReflectionMethod *set;
 656         guint32 attrs;
 657 } MonoPropertyInfo;
 658
 659 typedef struct {
 660         MonoReflectionType *declaring_type;
 661         MonoReflectionType *reflected_type;
 662         MonoString *name;
 663         MonoReflectionMethod *add_method;
 664         MonoReflectionMethod *remove_method;
 665         MonoReflectionMethod *raise_method;
 666         guint32 attrs;
 667         MonoArray *other_methods;
 668 } MonoEventInfo;
 669
 670 typedef struct {
 671         MonoString *name;
 672         MonoString *name_space;
 673         MonoReflectionType *etype;
 674         MonoReflectionType *nested_in;
 675         MonoReflectionAssembly *assembly;
 676         guint32 rank;
 677         MonoBoolean isprimitive;
 678 } MonoTypeInfo;
 679
 680 typedef struct {
 681         MonoObject *member;
 682         gint32 code_pos;
 683 } MonoReflectionILTokenInfo;
 684
 685 typedef struct {
 686         MonoObject object;
 687         MonoArray *code;
 688         gint32 code_len;
 689         gint32 max_stack;
 690         gint32 cur_stack;
 691         MonoArray *locals;
 692         MonoArray *ex_handlers;
 693         gint32 num_token_fixups;
 694         MonoArray *token_fixups;
 695 } MonoReflectionILGen;
 696
 697 typedef struct {
 698         MonoArray *handlers;
 699         gint32 start;
 700         gint32 len;
 701         gint32 label;
 702 } MonoILExceptionInfo;
 703
 704 typedef struct {
 705         MonoReflectionType *extype;
 706         gint32 type;
 707         gint32 start;
 708         gint32 len;
 709         gint32 filter_offset;
 710 } MonoILExceptionBlock;
 711
 712 typedef struct {
 713         MonoObject object;
 714         MonoReflectionType *catch_type;
 715         gint32 filter_offset;
 716         gint32 flags;
 717         gint32 try_offset;
 718         gint32 try_length;
 719         gint32 handler_offset;
 720         gint32 handler_length;
 721 } MonoReflectionExceptionHandlingClause;
 722
 723 typedef struct {
 724         MonoObject object;
 725         MonoReflectionType *local_type;
 726         MonoBoolean is_pinned;
 727         guint16 local_index;
 728 } MonoReflectionLocalVariableInfo;
 729
 730 typedef struct {
 731         /*
 732          * Must have the same layout as MonoReflectionLocalVariableInfo, since
 733          * LocalBuilder inherits from it under net 2.0.
 734          */
 735         MonoObject object;
 736         MonoReflectionType *type;
 737         MonoBoolean is_pinned;
 738         guint16 local_index;
 739         MonoString *name;
 740 } MonoReflectionLocalBuilder;
 741
 742 typedef struct {
 743         MonoObject object;
 744         gint32 count;
 745         gint32 type;
 746         gint32 eltype;
 747         MonoString *guid;
 748         MonoString *mcookie;
 749         MonoString *marshaltype;
 750         MonoReflectionType *marshaltyperef;
 751         gint32 param_num;
 752         MonoBoolean has_size;
 753 } MonoReflectionMarshal;
 754
 755 typedef struct {
 756         MonoObject object;
 757         MonoObject* methodb;
 758         MonoString *name;
 759         MonoArray *cattrs;
 760         MonoReflectionMarshal *marshal_info;
 761         guint32 attrs;
 762         int position;
 763         guint32 table_idx;
 764         MonoObject *def_value;
 765 } MonoReflectionParamBuilder;
 766
 767 typedef struct {
 768         MonoObject object;
 769         MonoMethod *mhandle;
 770         MonoReflectionILGen *ilgen;
 771         MonoArray *parameters;
 772         guint32 attrs;
 773         guint32 iattrs;
 774         guint32 table_idx;
 775         guint32 call_conv;
 776         MonoObject *type;
 777         MonoArray *pinfo;
 778         MonoArray *cattrs;
 779         MonoBoolean init_locals;
 780         MonoArray *param_modreq;
 781         MonoArray *param_modopt;
 782         MonoArray *permissions;
 783 } MonoReflectionCtorBuilder;
 784
 785 typedef struct {
 786         MonoObject object;
 787         MonoMethod *mhandle;
 788         MonoReflectionType *rtype;
 789         MonoArray *parameters;
 790         guint32 attrs;
 791         guint32 iattrs;
 792         MonoString *name;
 793         guint32 table_idx;
 794         MonoArray *code;
 795         MonoReflectionILGen *ilgen;
 796         MonoObject *type;
 797         MonoArray *pinfo;
 798         MonoArray *cattrs;
 799         MonoReflectionMethod *override_method;
 800         MonoString *dll;
 801         MonoString *dllentry;
 802         guint32 charset;
 803         guint32 extra_flags;
 804         guint32 native_cc;
 805         guint32 call_conv;
 806         MonoBoolean init_locals;
 807         MonoGenericContainer *generic_container;
 808         MonoArray *generic_params;
 809         MonoArray *return_modreq;
 810         MonoArray *return_modopt;
 811         MonoArray *param_modreq;
 812         MonoArray *param_modopt;
 813         MonoArray *permissions;
 814 } MonoReflectionMethodBuilder;
 815
 816 typedef struct {
 817         MonoObject object;
 818         MonoMethod *mhandle;
 819         MonoReflectionType *parent;
 820         MonoReflectionType *ret;
 821         MonoArray *parameters;
 822         MonoString *name;
 823         guint32 table_idx;
 824         guint32 call_conv;
 825 } MonoReflectionArrayMethod;
 826
 827 typedef struct {
 828         MonoArray *data;
 829         MonoString *name;
 830         MonoString *filename;
 831         guint32 attrs;
 832         guint32 offset;
 833         MonoObject *stream;
 834 } MonoReflectionResource;
 835
 836 typedef struct {
 837         guint32 res_type;
 838         guint32 res_id;
 839         guint32 lang_id;
 840         MonoArray *res_data;
 841 } MonoReflectionWin32Resource;
 842
 843 typedef struct {
 844         guint32 action;
 845         MonoString *pset;
 846 } MonoReflectionPermissionSet;
 847
 848 typedef struct {
 849         MonoReflectionAssembly assembly;
 850         MonoDynamicAssembly *dynamic_assembly;
 851         MonoReflectionMethod *entry_point;
 852         MonoArray *modules;
 853         MonoString *name;
 854         MonoString *dir;
 855         MonoArray *cattrs;
 856         MonoArray *resources;
 857         MonoArray *public_key;
 858         MonoString *version;
 859         MonoString *culture;
 860         guint32 algid;
 861         guint32 flags;
 862         guint32 pekind;
 863         MonoBoolean delay_sign;
 864         guint32 access;
 865         MonoArray *loaded_modules;
 866         MonoArray *win32_resources;
 867         /* CAS related */
 868         MonoArray *permissions_minimum;
 869         MonoArray *permissions_optional;
 870         MonoArray *permissions_refused;
 871         gint32 pe_kind;
 872         gint32 machine;
 873         MonoBoolean corlib_internal;
 874         MonoArray *type_forwarders;
 875 } MonoReflectionAssemblyBuilder;
 876
 877 typedef struct {
 878         MonoObject object;
 879         guint32 attrs;
 880         MonoReflectionType *type;
 881         MonoString *name;
 882         MonoObject *def_value;
 883         gint32 offset;
 884         gint32 table_idx;
 885         MonoReflectionType *typeb;
 886         MonoArray *rva_data;
 887         MonoArray *cattrs;
 888         MonoReflectionMarshal *marshal_info;
 889         MonoClassField *handle;
 890         MonoArray *modreq;
 891         MonoArray *modopt;
 892 } MonoReflectionFieldBuilder;
 893
 894 typedef struct {
 895         MonoObject object;
 896         guint32 attrs;
 897         MonoString *name;
 898         MonoReflectionType *type;
 899         MonoArray *parameters;
 900         MonoArray *cattrs;
 901         MonoObject *def_value;
 902         MonoReflectionMethodBuilder *set_method;
 903         MonoReflectionMethodBuilder *get_method;
 904         gint32 table_idx;
 905 } MonoReflectionPropertyBuilder;
 906
 907 struct _MonoReflectionModule {
 908         MonoObject      obj;
 909         MonoImage  *image;
 910         MonoReflectionAssembly *assembly;
 911         MonoString *fqname;
 912         MonoString *name;
 913         MonoString *scopename;
 914         MonoBoolean is_resource;
 915         guint32 token;
 916 };
 917
 918 typedef struct {
 919         MonoReflectionModule module;
 920         MonoDynamicImage *dynamic_image;
 921         gint32     num_types;
 922         MonoArray *types;
 923         MonoArray *cattrs;
 924         MonoArray *guid;
 925         guint32    table_idx;
 926         MonoReflectionAssemblyBuilder *assemblyb;
 927         MonoArray *global_methods;
 928         MonoArray *global_fields;
 929         gboolean is_main;
 930         MonoArray *resources;
 931 } MonoReflectionModuleBuilder;
 932
 933 typedef struct {
 934         MonoReflectionType type;
 935         MonoString *name;
 936         MonoString *nspace;
 937         MonoReflectionType *parent;
 938         MonoReflectionType *nesting_type;
 939         MonoArray *interfaces;
 940         gint32     num_methods;
 941         MonoArray *methods;
 942         MonoArray *ctors;
 943         MonoArray *properties;
 944         gint32     num_fields;
 945         MonoArray *fields;
 946         MonoArray *events;
 947         MonoArray *cattrs;
 948         MonoArray *subtypes;
 949         guint32 attrs;
 950         guint32 table_idx;
 951         MonoReflectionModuleBuilder *module;
 952         gint32 class_size;
 953         gint32 packing_size;
 954         MonoGenericContainer *generic_container;
 955         MonoArray *generic_params;
 956         MonoArray *permissions;
 957         MonoReflectionType *created;
 958 } MonoReflectionTypeBuilder;
 959
 960 typedef struct {
 961         MonoReflectionType type;
 962         MonoReflectionTypeBuilder *tbuilder;
 963         MonoReflectionMethodBuilder *mbuilder;
 964         MonoString *name;
 965         guint32 index;
 966         MonoReflectionType *base_type;
 967         MonoArray *iface_constraints;
 968         MonoArray *cattrs;
 969         guint32 attrs;
 970 } MonoReflectionGenericParam;
 971
 972 typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass;
 973 struct _MonoReflectionGenericClass {
 974         MonoReflectionType type;
 975         MonoReflectionTypeBuilder *generic_type;
 976         guint32 initialized;
 977 };
 978
 979 typedef struct {
 980         MonoObject  obj;
 981         MonoString *name;
 982         MonoString *codebase;
 983         gint32 major, minor, build, revision;
 984         MonoObject  *cultureInfo;
 985         guint32     flags;
 986         guint32     hashalg;
 987         MonoObject  *keypair;
 988         MonoArray   *publicKey;
 989         MonoArray   *keyToken;
 990         guint32     versioncompat;
 991         MonoObject *version;
 992         guint32     processor_architecture;
 993 } MonoReflectionAssemblyName;
 994
 995 typedef struct {
 996         MonoObject  obj;
 997         MonoString *name;
 998         MonoReflectionType *type;
 999         MonoReflectionTypeBuilder *typeb;
1000         MonoArray *cattrs;
1001         MonoReflectionMethodBuilder *add_method;
1002         MonoReflectionMethodBuilder *remove_method;
1003         MonoReflectionMethodBuilder *raise_method;
1004         MonoArray *other_methods;
1005         guint32 attrs;
1006         guint32 table_idx;
1007 } MonoReflectionEventBuilder;
1008
1009 typedef struct {
1010         MonoObject  obj;
1011         MonoReflectionMethod *ctor;
1012         MonoArray *data;
1013 } MonoReflectionCustomAttr;
1014
1015 typedef struct {
1016         MonoObject object;
1017         gint32 call_conv;
1018         gint32 charset;
1019         MonoString *dll;
1020         MonoString *entry_point;
1021         MonoBoolean exact_spelling;
1022         MonoBoolean preserve_sig;
1023         MonoBoolean set_last_error;
1024         MonoBoolean best_fit_mapping;
1025         MonoBoolean throw_on_unmappable;
1026 } MonoReflectionDllImportAttribute;
1027
1028 typedef struct {
1029         MonoObject object;
1030         gint32 call_conv;
1031         gint32 charset;
1032         MonoBoolean set_last_error;
1033         MonoBoolean best_fit_mapping;
1034         MonoBoolean throw_on_unmappable;
1035 } MonoReflectionUnmanagedFunctionPointerAttribute;
1036
1037 typedef struct {
1038         MonoObject object;
1039         MonoString *guid;
1040 } MonoReflectionGuidAttribute;
1041
1042 typedef struct {
1043         MonoObject object;
1044         MonoMethod *mhandle;
1045         MonoString *name;
1046         MonoReflectionType *rtype;
1047         MonoArray *parameters;
1048         guint32 attrs;
1049         guint32 call_conv;
1050         MonoReflectionModule *module;
1051         MonoBoolean skip_visibility;
1052         MonoBoolean init_locals;
1053         MonoReflectionILGen *ilgen;
1054         gint32 nrefs;
1055         MonoArray *refs;
1056         GSList *referenced_by;
1057         MonoReflectionType *owner;
1058 } MonoReflectionDynamicMethod;
1059
1060 typedef struct {
1061         MonoObject object;
1062         MonoReflectionModuleBuilder *module;
1063         MonoArray *arguments;
1064         guint32 type;
1065         MonoReflectionType *return_type;
1066         guint32 call_conv;
1067         guint32 unmanaged_call_conv;
1068         MonoArray *modreqs;
1069         MonoArray *modopts;
1070 } MonoReflectionSigHelper;
1071
1072 typedef struct {
1073         MonoObject object;
1074         MonoReflectionGenericClass *inst;
1075         MonoReflectionFieldBuilder *fb;
1076 } MonoReflectionFieldOnTypeBuilderInst;
1077
1078 typedef struct {
1079         MonoObject object;
1080         MonoReflectionGenericClass *inst;
1081         MonoReflectionCtorBuilder *cb;
1082 } MonoReflectionCtorOnTypeBuilderInst;
1083
1084 typedef struct {
1085         MonoObject object;
1086         MonoReflectionGenericClass *inst;
1087         MonoReflectionMethodBuilder *mb;
1088 } MonoReflectionMethodOnTypeBuilderInst;
1089
1090 typedef struct {
1091         MonoObject object;
1092         MonoBoolean *visible;
1093 } MonoReflectionComVisibleAttribute;
1094
1095 enum {
1096         RESOURCE_LOCATION_EMBEDDED = 1,
1097         RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
1098         RESOURCE_LOCATION_IN_MANIFEST = 4
1099 };
1100
1101 typedef struct {
1102         MonoObject object;
1103         MonoReflectionAssembly *assembly;
1104         MonoString *filename;
1105         guint32 location;
1106 } MonoManifestResourceInfo;
1107
1108 /* Keep in sync with System.GenericParameterAttributes */
1109 typedef enum {
1110         GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT         = 0,
1111         GENERIC_PARAMETER_ATTRIBUTE_COVARIANT           = 1,
1112         GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT       = 2,
1113         GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK       = 3,
1114
1115         GENERIC_PARAMETER_ATTRIBUTE_NO_SPECIAL_CONSTRAINT       = 0,
1116         GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT   = 4,
1117         GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT       = 8,
1118         GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT      = 16,
1119         GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK    = 28
1120 } GenericParameterAttributes;
1121
1122 void          mono_image_create_pefile (MonoReflectionModuleBuilder *module, HANDLE file) MONO_INTERNAL;
1123 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly) MONO_INTERNAL;
1124 MonoReflectionModule * mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name) MONO_INTERNAL;
1125 guint32       mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str) MONO_INTERNAL;
1126 guint32       mono_image_create_token  (MonoDynamicImage *assembly, MonoObject *obj, gboolean create_methodspec, gboolean register_token) MONO_INTERNAL;
1127 guint32       mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types) MONO_INTERNAL;
1128 void          mono_image_module_basic_init (MonoReflectionModuleBuilder *module) MONO_INTERNAL;
1129 void          mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj) MONO_INTERNAL;
1130 void          mono_dynamic_image_free (MonoDynamicImage *image) MONO_INTERNAL;
1131
1132 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb) MONO_INTERNAL;
1133
1134 void        mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb) MONO_INTERNAL;
1135
1136 void        mono_reflection_setup_generic_class   (MonoReflectionTypeBuilder *tb) MONO_INTERNAL;
1137
1138 void        mono_reflection_create_generic_class  (MonoReflectionTypeBuilder *tb) MONO_INTERNAL;
1139
1140 MonoReflectionType* mono_reflection_create_runtime_class  (MonoReflectionTypeBuilder *tb) MONO_INTERNAL;
1141
1142 void        mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides) MONO_INTERNAL;
1143
1144 void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m) MONO_INTERNAL;
1145 void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod *mb) MONO_INTERNAL;
1146
1147 void        mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam) MONO_INTERNAL;
1148
1149 MonoClass*
1150 mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic) MONO_INTERNAL;
1151 MonoType*
1152 mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types) MONO_INTERNAL;
1153 MonoReflectionMethod*
1154 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types) MONO_INTERNAL;
1155 void
1156 mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *methods, MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events) MONO_INTERNAL;
1157 MonoReflectionEvent *
1158 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb) MONO_INTERNAL;
1159
1160 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig) MONO_INTERNAL;
1161
1162 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig) MONO_INTERNAL;
1163
1164 MonoReflectionMarshal* mono_reflection_marshal_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec) MONO_INTERNAL;
1165
1166 gpointer
1167 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context) MONO_INTERNAL;
1168
1169 gboolean
1170 mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass) MONO_INTERNAL;
1171
1172 gboolean
1173 mono_reflection_is_valid_dynamic_token (MonoDynamicImage *image, guint32 token) MONO_INTERNAL;
1174
1175 void
1176 mono_image_build_metadata (MonoReflectionModuleBuilder *module) MONO_INTERNAL;
1177
1178 int
1179 mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value) MONO_INTERNAL;
1180
1181 void
1182 mono_release_type_locks (MonoThread *thread) MONO_INTERNAL;
1183
1184 char *
1185 mono_string_to_utf8_mp  (MonoMemPool *mp, MonoString *s) MONO_INTERNAL;
1186
1187 MonoArray*
1188 mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array) MONO_INTERNAL;
1189
1190 void
1191 mono_array_full_copy (MonoArray *src, MonoArray *dest) MONO_INTERNAL;
1192
1193 gpointer
1194 mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxy *real_proxy) MONO_INTERNAL;
1195
1196 void
1197 mono_upgrade_remote_class (MonoDomain *domain, MonoObject *tproxy, MonoClass *klass) MONO_INTERNAL;
1198
1199 gpointer
1200 mono_create_ftnptr (MonoDomain *domain, gpointer addr) MONO_INTERNAL;
1201
1202 gpointer
1203 mono_get_addr_from_ftnptr (gpointer descr) MONO_INTERNAL;
1204
1205 void
1206 mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass) MONO_INTERNAL;
1207
1208 MonoObject*
1209 mono_nullable_box (guint8 *buf, MonoClass *klass) MONO_INTERNAL;
1210
1211 #define MONO_IMT_SIZE 19
1212
1213 typedef union {
1214         int vtable_slot;
1215         gpointer target_code;
1216 } MonoImtItemValue;
1217
1218 typedef struct _MonoImtBuilderEntry {
1219         gpointer key;
1220         struct _MonoImtBuilderEntry *next;
1221         MonoImtItemValue value;
1222         int children;
1223 } MonoImtBuilderEntry;
1224
1225 typedef struct _MonoIMTCheckItem MonoIMTCheckItem;
1226
1227 struct _MonoIMTCheckItem {
1228         gpointer          key;
1229         int               check_target_idx;
1230         MonoImtItemValue  value;
1231         guint8           *jmp_code;
1232         guint8           *code_target;
1233         guint8            is_equals;
1234         guint8            compare_done;
1235         guint8            chunk_size;
1236         guint8            short_branch;
1237 };
1238
1239 typedef gpointer (*MonoImtThunkBuilder) (MonoVTable *vtable, MonoDomain *domain,
1240                 MonoIMTCheckItem **imt_entries, int count, gpointer fail_trunk);
1241
1242 void
1243 mono_install_imt_thunk_builder (MonoImtThunkBuilder func) MONO_INTERNAL;
1244
1245 void
1246 mono_install_imt_trampoline (gpointer tramp) MONO_INTERNAL;
1247
1248 void
1249 mono_install_vtable_trampoline (gpointer tramp) MONO_INTERNAL;
1250
1251 void
1252 mono_vtable_build_imt_slot (MonoVTable* vtable, int imt_slot) MONO_INTERNAL;
1253
1254 guint32
1255 mono_method_get_imt_slot (MonoMethod *method) MONO_INTERNAL;
1256
1257 void
1258 mono_method_add_generic_virtual_invocation (MonoDomain *domain, gpointer *vtable_slot,
1259         MonoGenericInst *method_inst, gpointer code) MONO_INTERNAL;
1260
1261 gpointer
1262 mono_method_alloc_generic_virtual_thunk (MonoDomain *domain, int size) MONO_INTERNAL;
1263
1264 typedef enum {
1265         MONO_UNHANDLED_POLICY_LEGACY,
1266         MONO_UNHANDLED_POLICY_CURRENT
1267 } MonoRuntimeUnhandledExceptionPolicy;
1268
1269 MonoRuntimeUnhandledExceptionPolicy
1270 mono_runtime_unhandled_exception_policy_get (void) MONO_INTERNAL;
1271 void
1272 mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy) MONO_INTERNAL;
1273
1274 MonoVTable *
1275 mono_class_try_get_vtable (MonoDomain *domain, MonoClass *class) MONO_INTERNAL;
1276
1277 MonoException *
1278 mono_runtime_class_init_full (MonoVTable *vtable, gboolean raise_exception) MONO_INTERNAL;
1279
1280 #endif /* __MONO_OBJECT_INTERNALS_H__ */
1281