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