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