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 } MonoRuntimeCallbacks;
 572
 573 /* used to free a dynamic method */
 574 typedef void        (*MonoFreeMethodFunc)        (MonoDomain *domain, MonoMethod *method);
 575
 576 /* Used to initialize the method pointers inside vtables */
 577 typedef gboolean    (*MonoInitVTableFunc)    (MonoVTable *vtable);
 578
 579 void mono_set_pending_exception (MonoException *exc) MONO_INTERNAL;
 580
 581 /* remoting and async support */
 582
 583 MonoAsyncResult *
 584 mono_async_result_new       (MonoDomain *domain, HANDLE handle,
 585                              MonoObject *state, gpointer data, MonoObject *object_data) MONO_INTERNAL;
 586
 587 MonoWaitHandle *
 588 mono_wait_handle_new        (MonoDomain *domain, HANDLE handle) MONO_INTERNAL;
 589
 590 HANDLE
 591 mono_wait_handle_get_handle (MonoWaitHandle *handle) MONO_INTERNAL;
 592
 593 void
 594 mono_message_init           (MonoDomain *domain, MonoMethodMessage *this_obj,
 595                              MonoReflectionMethod *method, MonoArray *out_args) MONO_INTERNAL;
 596
 597 MonoObject *
 598 mono_remoting_invoke        (MonoObject *real_proxy, MonoMethodMessage *msg,
 599                              MonoObject **exc, MonoArray **out_args) MONO_INTERNAL;
 600
 601 MonoObject *
 602 mono_message_invoke         (MonoObject *target, MonoMethodMessage *msg,
 603                              MonoObject **exc, MonoArray **out_args) MONO_INTERNAL;
 604
 605 MonoMethodMessage *
 606 mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
 607                               MonoDelegate **cb, MonoObject **state) MONO_INTERNAL;
 608
 609 void
 610 mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args) MONO_INTERNAL;
 611
 612 void
 613 mono_delegate_ctor_with_method (MonoObject *this, MonoObject *target, gpointer addr, MonoMethod *method) MONO_INTERNAL;
 614
 615 void
 616 mono_delegate_ctor          (MonoObject *this_obj, MonoObject *target, gpointer addr) MONO_INTERNAL;
 617
 618 void*
 619 mono_class_get_allocation_ftn (MonoVTable *vtable, gboolean for_box, gboolean *pass_size_in_words) MONO_INTERNAL;
 620
 621 void
 622 mono_runtime_free_method    (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL;
 623
 624 /* runtime initialization functions */
 625 typedef void (*MonoExceptionFunc) (MonoException *ex);
 626
 627 void
 628 mono_install_handler        (MonoExceptionFunc func) MONO_INTERNAL;
 629
 630 void
 631 mono_install_runtime_invoke (MonoInvokeFunc func) MONO_INTERNAL;
 632
 633 void
 634 mono_install_compile_method (MonoCompileFunc func) MONO_INTERNAL;
 635
 636 void
 637 mono_install_free_method    (MonoFreeMethodFunc func) MONO_INTERNAL;
 638
 639 void
 640 mono_install_callbacks      (MonoRuntimeCallbacks *cbs) MONO_INTERNAL;
 641
 642 MonoRuntimeCallbacks*
 643 mono_get_runtime_callbacks (void) MONO_INTERNAL;
 644
 645 void
 646 mono_type_initialization_init (void) MONO_INTERNAL;
 647
 648 void
 649 mono_type_initialization_cleanup (void) MONO_INTERNAL;
 650
 651 int
 652 mono_thread_kill           (MonoInternalThread *thread, int signal) MONO_INTERNAL;
 653
 654 guint32
 655 mono_thread_get_tls_key    (void) MONO_INTERNAL;
 656
 657 gint32
 658 mono_thread_get_tls_offset (void) MONO_INTERNAL;
 659
 660 guint32
 661 mono_domain_get_tls_key    (void) MONO_INTERNAL;
 662
 663 gint32
 664 mono_domain_get_tls_offset (void) MONO_INTERNAL;
 665
 666 /* Reflection and Reflection.Emit support */
 667
 668 /*
 669  * Handling System.Type objects:
 670  *
 671  *   Fields defined as System.Type in managed code should be defined as MonoObject*
 672  * in unmanaged structures, and the monotype_cast () function should be used for
 673  * casting them to MonoReflectionType* to avoid crashes/security issues when
 674  * encountering instances of user defined subclasses of System.Type.
 675  */
 676
 677 #define IS_MONOTYPE(obj) (!(obj) || (((MonoObject*)(obj))->vtable->klass->image == mono_defaults.corlib && ((MonoReflectionType*)(obj))->type != NULL))
 678
 679 /*
 680  * Make sure the argument, which should be a System.Type is a System.MonoType object
 681  * or equivalent, and not an instance of
 682  * a user defined subclass of System.Type. This should be used in places were throwing
 683  * an exception is safe.
 684  */
 685 #define CHECK_MONOTYPE(obj) do { \
 686         if (!IS_MONOTYPE (obj)) \
 687                 mono_raise_exception (mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported")); \
 688         } while (0)
 689
 690 /* This should be used for accessing members of Type[] arrays */
 691 #define mono_type_array_get(arr,index) monotype_cast (mono_array_get ((arr), gpointer, (index)))
 692
 693 /*
 694  * Cast an object to MonoReflectionType, making sure it is a System.MonoType or
 695  * a subclass of it.
 696  */
 697 static inline MonoReflectionType*
 698 monotype_cast (MonoObject *obj)
 699 {
 700         g_assert (IS_MONOTYPE (obj));
 701
 702         return (MonoReflectionType*)obj;
 703 }
 704
 705 /*
 706  * The following structure must match the C# implementation in our corlib.
 707  */
 708
 709 struct _MonoReflectionMethod {
 710         MonoObject object;
 711         MonoMethod *method;
 712         MonoString *name;
 713         MonoReflectionType *reftype;
 714 };
 715
 716 typedef struct _MonoReflectionGenericMethod MonoReflectionGenericMethod;
 717 struct _MonoReflectionGenericMethod {
 718         MonoReflectionMethod method;
 719 };
 720
 721 struct _MonoDelegate {
 722         MonoObject object;
 723         /* The compiled code of the target method */
 724         gpointer method_ptr;
 725         /* The invoke code */
 726         gpointer invoke_impl;
 727         MonoObject *target;
 728         MonoMethod *method;
 729         gpointer delegate_trampoline;
 730         /*
 731          * If non-NULL, this points to a memory location which stores the address of
 732          * the compiled code of the method, or NULL if it is not yet compiled.
 733          */
 734         guint8 **method_code;
 735         MonoReflectionMethod *method_info;
 736         MonoReflectionMethod *original_method_info;
 737         MonoObject *data;
 738 };
 739
 740 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
 741 struct _MonoMulticastDelegate {
 742         MonoDelegate delegate;
 743         MonoMulticastDelegate *prev;
 744 };
 745
 746 struct _MonoReflectionField {
 747         MonoObject object;
 748         MonoClass *klass;
 749         MonoClassField *field;
 750         MonoString *name;
 751         MonoReflectionType *type;
 752         guint32 attrs;
 753 };
 754
 755 struct _MonoReflectionProperty {
 756         MonoObject object;
 757         MonoClass *klass;
 758         MonoProperty *property;
 759 };
 760
 761 /*This is System.EventInfo*/
 762 struct _MonoReflectionEvent {
 763         MonoObject object;
 764         MonoObject *cached_add_event;
 765 };
 766
 767 typedef struct {
 768         MonoReflectionEvent object;
 769         MonoClass *klass;
 770         MonoEvent *event;
 771 } MonoReflectionMonoEvent;
 772
 773 typedef struct {
 774         MonoObject object;
 775         MonoReflectionType *ClassImpl;
 776         MonoObject *DefaultValueImpl;
 777         MonoObject *MemberImpl;
 778         MonoString *NameImpl;
 779         gint32 PositionImpl;
 780         guint32 AttrsImpl;
 781         MonoObject *MarshalAsImpl;
 782 } MonoReflectionParameter;
 783
 784 struct _MonoReflectionMethodBody {
 785         MonoObject object;
 786         MonoArray *clauses;
 787         MonoArray *locals;
 788         MonoArray *il;
 789         MonoBoolean init_locals;
 790         guint32 local_var_sig_token;
 791         guint32 max_stack;
 792 };
 793
 794 struct _MonoReflectionAssembly {
 795         MonoObject object;
 796         MonoAssembly *assembly;
 797         MonoObject *resolve_event_holder;
 798         /* CAS related */
 799         MonoObject *evidence;   /* Evidence */
 800         MonoObject *minimum;    /* PermissionSet - for SecurityAction.RequestMinimum */
 801         MonoObject *optional;   /* PermissionSet - for SecurityAction.RequestOptional */
 802         MonoObject *refuse;     /* PermissionSet - for SecurityAction.RequestRefuse */
 803         MonoObject *granted;    /* PermissionSet - for the resolved assembly granted permissions */
 804         MonoObject *denied;     /* PermissionSet - for the resolved assembly denied permissions */
 805         /* */
 806         MonoBoolean from_byte_array;
 807         MonoString *name;
 808 };
 809
 810 typedef struct {
 811         MonoReflectionType *utype;
 812         MonoArray *values;
 813         MonoArray *names;
 814 } MonoEnumInfo;
 815
 816 typedef struct {
 817         MonoReflectionType *parent;
 818         MonoReflectionType *ret;
 819         guint32 attrs;
 820         guint32 implattrs;
 821         guint32 callconv;
 822 } MonoMethodInfo;
 823
 824 typedef struct {
 825         MonoReflectionType *parent;
 826         MonoReflectionType *declaring_type;
 827         MonoString *name;
 828         MonoReflectionMethod *get;
 829         MonoReflectionMethod *set;
 830         guint32 attrs;
 831 } MonoPropertyInfo;
 832
 833 typedef struct {
 834         MonoReflectionType *declaring_type;
 835         MonoReflectionType *reflected_type;
 836         MonoString *name;
 837         MonoReflectionMethod *add_method;
 838         MonoReflectionMethod *remove_method;
 839         MonoReflectionMethod *raise_method;
 840         guint32 attrs;
 841         MonoArray *other_methods;
 842 } MonoEventInfo;
 843
 844 typedef struct {
 845         MonoString *name;
 846         MonoString *name_space;
 847         MonoReflectionType *etype;
 848         MonoReflectionType *nested_in;
 849         MonoReflectionAssembly *assembly;
 850         guint32 rank;
 851         MonoBoolean isprimitive;
 852 } MonoTypeInfo;
 853
 854 typedef struct {
 855         MonoObject *member;
 856         gint32 code_pos;
 857 } MonoReflectionILTokenInfo;
 858
 859 typedef struct {
 860         MonoObject object;
 861         MonoArray *code;
 862         gint32 code_len;
 863         gint32 max_stack;
 864         gint32 cur_stack;
 865         MonoArray *locals;
 866         MonoArray *ex_handlers;
 867         gint32 num_token_fixups;
 868         MonoArray *token_fixups;
 869 } MonoReflectionILGen;
 870
 871 typedef struct {
 872         MonoArray *handlers;
 873         gint32 start;
 874         gint32 len;
 875         gint32 label;
 876 } MonoILExceptionInfo;
 877
 878 typedef struct {
 879         MonoObject *extype;
 880         gint32 type;
 881         gint32 start;
 882         gint32 len;
 883         gint32 filter_offset;
 884 } MonoILExceptionBlock;
 885
 886 typedef struct {
 887         MonoObject object;
 888         MonoObject *catch_type;
 889         gint32 filter_offset;
 890         gint32 flags;
 891         gint32 try_offset;
 892         gint32 try_length;
 893         gint32 handler_offset;
 894         gint32 handler_length;
 895 } MonoReflectionExceptionHandlingClause;
 896
 897 typedef struct {
 898         MonoObject object;
 899         MonoReflectionType *local_type;
 900         MonoBoolean is_pinned;
 901         guint16 local_index;
 902 } MonoReflectionLocalVariableInfo;
 903
 904 typedef struct {
 905         /*
 906          * Must have the same layout as MonoReflectionLocalVariableInfo, since
 907          * LocalBuilder inherits from it under net 2.0.
 908          */
 909         MonoObject object;
 910         MonoObject *type;
 911         MonoBoolean is_pinned;
 912         guint16 local_index;
 913         MonoString *name;
 914 } MonoReflectionLocalBuilder;
 915
 916 typedef struct {
 917         MonoObject object;
 918         gint32 count;
 919         gint32 type;
 920         gint32 eltype;
 921         MonoString *guid;
 922         MonoString *mcookie;
 923         MonoString *marshaltype;
 924         MonoObject *marshaltyperef;
 925         gint32 param_num;
 926         MonoBoolean has_size;
 927 } MonoReflectionMarshal;
 928
 929 typedef struct {
 930         MonoObject object;
 931         MonoObject* methodb;
 932         MonoString *name;
 933         MonoArray *cattrs;
 934         MonoReflectionMarshal *marshal_info;
 935         guint32 attrs;
 936         int position;
 937         guint32 table_idx;
 938         MonoObject *def_value;
 939 } MonoReflectionParamBuilder;
 940
 941 typedef struct {
 942         MonoObject object;
 943         MonoMethod *mhandle;
 944         MonoReflectionILGen *ilgen;
 945         MonoArray *parameters;
 946         guint32 attrs;
 947         guint32 iattrs;
 948         guint32 table_idx;
 949         guint32 call_conv;
 950         MonoObject *type;
 951         MonoArray *pinfo;
 952         MonoArray *cattrs;
 953         MonoBoolean init_locals;
 954         MonoArray *param_modreq;
 955         MonoArray *param_modopt;
 956         MonoArray *permissions;
 957 } MonoReflectionCtorBuilder;
 958
 959 typedef struct {
 960         MonoObject object;
 961         MonoMethod *mhandle;
 962         MonoObject *rtype;
 963         MonoArray *parameters;
 964         guint32 attrs;
 965         guint32 iattrs;
 966         MonoString *name;
 967         guint32 table_idx;
 968         MonoArray *code;
 969         MonoReflectionILGen *ilgen;
 970         MonoObject *type;
 971         MonoArray *pinfo;
 972         MonoArray *cattrs;
 973         MonoReflectionMethod *override_method;
 974         MonoString *dll;
 975         MonoString *dllentry;
 976         guint32 charset;
 977         guint32 extra_flags;
 978         guint32 native_cc;
 979         guint32 call_conv;
 980         MonoBoolean init_locals;
 981         MonoGenericContainer *generic_container;
 982         MonoArray *generic_params;
 983         MonoArray *return_modreq;
 984         MonoArray *return_modopt;
 985         MonoArray *param_modreq;
 986         MonoArray *param_modopt;
 987         MonoArray *permissions;
 988 } MonoReflectionMethodBuilder;
 989
 990 typedef struct {
 991         MonoObject object;
 992         MonoMethod *mhandle;
 993         MonoReflectionType *parent;
 994         MonoReflectionType *ret;
 995         MonoArray *parameters;
 996         MonoString *name;
 997         guint32 table_idx;
 998         guint32 call_conv;
 999 } MonoReflectionArrayMethod;
1000
1001 typedef struct {
1002         MonoArray *data;
1003         MonoString *name;
1004         MonoString *filename;
1005         guint32 attrs;
1006         guint32 offset;
1007         MonoObject *stream;
1008 } MonoReflectionResource;
1009
1010 typedef struct {
1011         guint32 res_type;
1012         guint32 res_id;
1013         guint32 lang_id;
1014         MonoArray *res_data;
1015 } MonoReflectionWin32Resource;
1016
1017 typedef struct {
1018         guint32 action;
1019         MonoString *pset;
1020 } MonoReflectionPermissionSet;
1021
1022 typedef struct {
1023         MonoReflectionAssembly assembly;
1024         MonoDynamicAssembly *dynamic_assembly;
1025         MonoReflectionMethod *entry_point;
1026         MonoArray *modules;
1027         MonoString *name;
1028         MonoString *dir;
1029         MonoArray *cattrs;
1030         MonoArray *resources;
1031         MonoArray *public_key;
1032         MonoString *version;
1033         MonoString *culture;
1034         guint32 algid;
1035         guint32 flags;
1036         guint32 pekind;
1037         MonoBoolean delay_sign;
1038         guint32 access;
1039         MonoArray *loaded_modules;
1040         MonoArray *win32_resources;
1041         /* CAS related */
1042         MonoArray *permissions_minimum;
1043         MonoArray *permissions_optional;
1044         MonoArray *permissions_refused;
1045         gint32 pe_kind;
1046         gint32 machine;
1047         MonoBoolean corlib_internal;
1048         MonoArray *type_forwarders;
1049         MonoArray *pktoken; /* as hexadecimal byte[] */
1050 } MonoReflectionAssemblyBuilder;
1051
1052 typedef struct {
1053         MonoObject object;
1054         guint32 attrs;
1055         MonoObject *type;
1056         MonoString *name;
1057         MonoObject *def_value;
1058         gint32 offset;
1059         gint32 table_idx;
1060         MonoReflectionType *typeb;
1061         MonoArray *rva_data;
1062         MonoArray *cattrs;
1063         MonoReflectionMarshal *marshal_info;
1064         MonoClassField *handle;
1065         MonoArray *modreq;
1066         MonoArray *modopt;
1067 } MonoReflectionFieldBuilder;
1068
1069 typedef struct {
1070         MonoObject object;
1071         guint32 attrs;
1072         MonoString *name;
1073         MonoObject *type;
1074         MonoArray *parameters;
1075         MonoArray *cattrs;
1076         MonoObject *def_value;
1077         MonoReflectionMethodBuilder *set_method;
1078         MonoReflectionMethodBuilder *get_method;
1079         gint32 table_idx;
1080         MonoObject *type_builder;
1081         MonoArray *returnModReq;
1082         MonoArray *returnModOpt;
1083         MonoArray *paramModReq;
1084         MonoArray *paramModOpt;
1085         guint32 call_conv;
1086 } MonoReflectionPropertyBuilder;
1087
1088 struct _MonoReflectionModule {
1089         MonoObject      obj;
1090         MonoImage  *image;
1091         MonoReflectionAssembly *assembly;
1092         MonoString *fqname;
1093         MonoString *name;
1094         MonoString *scopename;
1095         MonoBoolean is_resource;
1096         guint32 token;
1097 };
1098
1099 typedef struct {
1100         MonoReflectionModule module;
1101         MonoDynamicImage *dynamic_image;
1102         gint32     num_types;
1103         MonoArray *types;
1104         MonoArray *cattrs;
1105         MonoArray *guid;
1106         guint32    table_idx;
1107         MonoReflectionAssemblyBuilder *assemblyb;
1108         MonoArray *global_methods;
1109         MonoArray *global_fields;
1110         gboolean is_main;
1111         MonoArray *resources;
1112 } MonoReflectionModuleBuilder;
1113
1114 typedef struct {
1115         MonoReflectionType type;
1116         MonoString *name;
1117         MonoString *nspace;
1118         MonoObject *parent;
1119         MonoReflectionType *nesting_type;
1120         MonoArray *interfaces;
1121         gint32     num_methods;
1122         MonoArray *methods;
1123         MonoArray *ctors;
1124         MonoArray *properties;
1125         gint32     num_fields;
1126         MonoArray *fields;
1127         MonoArray *events;
1128         MonoArray *cattrs;
1129         MonoArray *subtypes;
1130         guint32 attrs;
1131         guint32 table_idx;
1132         MonoReflectionModuleBuilder *module;
1133         gint32 class_size;
1134         gint32 packing_size;
1135         MonoGenericContainer *generic_container;
1136         MonoArray *generic_params;
1137         MonoArray *permissions;
1138         MonoReflectionType *created;
1139 } MonoReflectionTypeBuilder;
1140
1141 typedef struct {
1142         MonoReflectionType type;
1143         MonoReflectionType *element_type;
1144         int rank;
1145 } MonoReflectionArrayType;
1146
1147 typedef struct {
1148         MonoReflectionType type;
1149         MonoReflectionType *element_type;
1150 } MonoReflectionDerivedType;
1151
1152 typedef struct {
1153         MonoReflectionType type;
1154         MonoReflectionTypeBuilder *tbuilder;
1155         MonoReflectionMethodBuilder *mbuilder;
1156         MonoString *name;
1157         guint32 index;
1158         MonoReflectionType *base_type;
1159         MonoArray *iface_constraints;
1160         MonoArray *cattrs;
1161         guint32 attrs;
1162 } MonoReflectionGenericParam;
1163
1164 typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass;
1165 struct _MonoReflectionGenericClass {
1166         MonoReflectionType type;
1167         MonoReflectionType *generic_type; /*Can be either a MonoType or a TypeBuilder*/
1168         MonoArray *type_arguments;
1169         guint32 initialized;
1170 };
1171
1172 typedef struct {
1173         MonoObject  obj;
1174         MonoString *name;
1175         MonoString *codebase;
1176         gint32 major, minor, build, revision;
1177         MonoObject  *cultureInfo;
1178         guint32     flags;
1179         guint32     hashalg;
1180         MonoObject  *keypair;
1181         MonoArray   *publicKey;
1182         MonoArray   *keyToken;
1183         guint32     versioncompat;
1184         MonoObject *version;
1185         guint32     processor_architecture;
1186 } MonoReflectionAssemblyName;
1187
1188 typedef struct {
1189         MonoObject  obj;
1190         MonoString *name;
1191         MonoReflectionType *type;
1192         MonoReflectionTypeBuilder *typeb;
1193         MonoArray *cattrs;
1194         MonoReflectionMethodBuilder *add_method;
1195         MonoReflectionMethodBuilder *remove_method;
1196         MonoReflectionMethodBuilder *raise_method;
1197         MonoArray *other_methods;
1198         guint32 attrs;
1199         guint32 table_idx;
1200 } MonoReflectionEventBuilder;
1201
1202 typedef struct {
1203         MonoObject  obj;
1204         MonoReflectionMethod *ctor;
1205         MonoArray *data;
1206 } MonoReflectionCustomAttr;
1207
1208 typedef struct {
1209         MonoObject object;
1210         gint32 call_conv;
1211         gint32 charset;
1212         MonoString *dll;
1213         MonoString *entry_point;
1214         MonoBoolean exact_spelling;
1215         MonoBoolean preserve_sig;
1216         MonoBoolean set_last_error;
1217         MonoBoolean best_fit_mapping;
1218         MonoBoolean throw_on_unmappable;
1219 } MonoReflectionDllImportAttribute;
1220
1221 typedef struct {
1222         MonoObject object;
1223         gint32 call_conv;
1224         gint32 charset;
1225         MonoBoolean set_last_error;
1226         MonoBoolean best_fit_mapping;
1227         MonoBoolean throw_on_unmappable;
1228 } MonoReflectionUnmanagedFunctionPointerAttribute;
1229
1230 typedef struct {
1231         MonoObject object;
1232         MonoString *guid;
1233 } MonoReflectionGuidAttribute;
1234
1235 typedef struct {
1236         MonoObject object;
1237         MonoMethod *mhandle;
1238         MonoString *name;
1239         MonoReflectionType *rtype;
1240         MonoArray *parameters;
1241         guint32 attrs;
1242         guint32 call_conv;
1243         MonoReflectionModule *module;
1244         MonoBoolean skip_visibility;
1245         MonoBoolean init_locals;
1246         MonoReflectionILGen *ilgen;
1247         gint32 nrefs;
1248         MonoArray *refs;
1249         GSList *referenced_by;
1250         MonoReflectionType *owner;
1251 } MonoReflectionDynamicMethod;
1252
1253 typedef struct {
1254         MonoObject object;
1255         MonoReflectionModuleBuilder *module;
1256         MonoArray *arguments;
1257         guint32 type;
1258         MonoReflectionType *return_type;
1259         guint32 call_conv;
1260         guint32 unmanaged_call_conv;
1261         MonoArray *modreqs;
1262         MonoArray *modopts;
1263 } MonoReflectionSigHelper;
1264
1265 typedef struct {
1266         MonoObject object;
1267         MonoReflectionGenericClass *inst;
1268         MonoObject *fb; /*can be either a MonoField or a FieldBuilder*/
1269 } MonoReflectionFieldOnTypeBuilderInst;
1270
1271 typedef struct {
1272         MonoObject object;
1273         MonoReflectionGenericClass *inst;
1274         MonoObject *cb; /*can be either a MonoCMethod or ConstructorBuilder*/
1275 } MonoReflectionCtorOnTypeBuilderInst;
1276
1277 typedef struct {
1278         MonoObject object;
1279         MonoReflectionType *inst;
1280         MonoObject *mb; /*can be either a MonoMethod or MethodBuilder*/
1281         MonoArray *method_args;
1282         MonoReflectionMethodBuilder *generic_method_definition;
1283 } MonoReflectionMethodOnTypeBuilderInst;
1284
1285 typedef struct {
1286         MonoObject object;
1287         MonoBoolean visible;
1288 } MonoReflectionComVisibleAttribute;
1289
1290 enum {
1291         RESOURCE_LOCATION_EMBEDDED = 1,
1292         RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
1293         RESOURCE_LOCATION_IN_MANIFEST = 4
1294 };
1295
1296 typedef struct {
1297         MonoObject object;
1298         MonoReflectionAssembly *assembly;
1299         MonoString *filename;
1300         guint32 location;
1301 } MonoManifestResourceInfo;
1302
1303 /* A boxed IntPtr */
1304 typedef struct {
1305         MonoObject object;
1306         gpointer m_value;
1307 } MonoIntPtr;
1308
1309 /* Keep in sync with System.GenericParameterAttributes */
1310 typedef enum {
1311         GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT         = 0,
1312         GENERIC_PARAMETER_ATTRIBUTE_COVARIANT           = 1,
1313         GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT       = 2,
1314         GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK       = 3,
1315
1316         GENERIC_PARAMETER_ATTRIBUTE_NO_SPECIAL_CONSTRAINT       = 0,
1317         GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT   = 4,
1318         GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT       = 8,
1319         GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT      = 16,
1320         GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK    = 28
1321 } GenericParameterAttributes;
1322
1323 typedef struct {
1324         MonoType *type;
1325         MonoClassField *field;
1326         MonoProperty *prop;
1327 } CattrNamedArg;
1328
1329 void          mono_image_create_pefile (MonoReflectionModuleBuilder *module, HANDLE file) MONO_INTERNAL;
1330 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly) MONO_INTERNAL;
1331 MonoReflectionModule * mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name) MONO_INTERNAL;
1332 guint32       mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str) MONO_INTERNAL;
1333 guint32       mono_image_create_token  (MonoDynamicImage *assembly, MonoObject *obj, gboolean create_methodspec, gboolean register_token) MONO_INTERNAL;
1334 guint32       mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types) MONO_INTERNAL;
1335 void          mono_image_module_basic_init (MonoReflectionModuleBuilder *module) MONO_INTERNAL;
1336 void          mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj) MONO_INTERNAL;
1337 void          mono_dynamic_image_free (MonoDynamicImage *image) MONO_INTERNAL;
1338 void          mono_image_set_wrappers_type (MonoReflectionModuleBuilder *mb, MonoReflectionType *type) MONO_INTERNAL;
1339
1340 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb) MONO_INTERNAL;
1341
1342 void        mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb) MONO_INTERNAL;
1343
1344 void        mono_reflection_setup_generic_class   (MonoReflectionTypeBuilder *tb) MONO_INTERNAL;
1345
1346 void        mono_reflection_create_generic_class  (MonoReflectionTypeBuilder *tb) MONO_INTERNAL;
1347
1348 MonoReflectionType* mono_reflection_create_runtime_class  (MonoReflectionTypeBuilder *tb) MONO_INTERNAL;
1349
1350 void        mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides) MONO_INTERNAL;
1351
1352 void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m) MONO_INTERNAL;
1353 void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod *mb) MONO_INTERNAL;
1354
1355 void        mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam) MONO_INTERNAL;
1356 void        mono_reflection_create_unmanaged_type (MonoReflectionType *type) MONO_INTERNAL;
1357 void        mono_reflection_register_with_runtime (MonoReflectionType *type) MONO_INTERNAL;
1358
1359 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;
1360 MonoMethodSignature * mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token) MONO_INTERNAL;
1361
1362 MonoArray* mono_param_get_objects_internal  (MonoDomain *domain, MonoMethod *method, MonoClass *refclass) MONO_INTERNAL;
1363
1364 MonoClass*
1365 mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic) MONO_INTERNAL;
1366 MonoType*
1367 mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types) MONO_INTERNAL;
1368 MonoReflectionMethod*
1369 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types) MONO_INTERNAL;
1370 void
1371 mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *methods, MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events) MONO_INTERNAL;
1372 MonoReflectionEvent *
1373 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb) MONO_INTERNAL;
1374
1375 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig) MONO_INTERNAL;
1376
1377 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig) MONO_INTERNAL;
1378
1379 MonoReflectionMarshal* mono_reflection_marshal_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec) MONO_INTERNAL;
1380
1381 gpointer
1382 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context) MONO_INTERNAL;
1383
1384 gboolean
1385 mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass) MONO_INTERNAL;
1386
1387 gboolean
1388 mono_reflection_is_valid_dynamic_token (MonoDynamicImage *image, guint32 token) MONO_INTERNAL;
1389
1390 void
1391 mono_reflection_resolve_custom_attribute_data (MonoReflectionMethod *method, MonoReflectionAssembly *assembly, gpointer data, guint32 data_length, MonoArray **ctor_args, MonoArray ** named_args) MONO_INTERNAL;
1392
1393 MonoType*
1394 mono_reflection_type_get_handle (MonoReflectionType *ref) MONO_INTERNAL;
1395
1396 void
1397 mono_reflection_free_dynamic_generic_class (MonoGenericClass *gclass) MONO_INTERNAL;
1398
1399 void
1400 mono_image_build_metadata (MonoReflectionModuleBuilder *module) MONO_INTERNAL;
1401
1402 int
1403 mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value) MONO_INTERNAL;
1404
1405 void
1406 mono_release_type_locks (MonoInternalThread *thread) MONO_INTERNAL;
1407
1408 char *
1409 mono_string_to_utf8_mp  (MonoMemPool *mp, MonoString *s, MonoError *error) MONO_INTERNAL;
1410
1411 char *
1412 mono_string_to_utf8_image (MonoImage *image, MonoString *s, MonoError *error) MONO_INTERNAL;
1413
1414
1415 MonoArray*
1416 mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array) MONO_INTERNAL;
1417
1418 void
1419 mono_array_full_copy (MonoArray *src, MonoArray *dest) MONO_INTERNAL;
1420
1421 gboolean
1422 mono_array_calc_byte_len (MonoClass *class, uintptr_t len, uintptr_t *res) MONO_INTERNAL;
1423
1424 gpointer
1425 mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxy *real_proxy) MONO_INTERNAL;
1426
1427 void
1428 mono_upgrade_remote_class (MonoDomain *domain, MonoObject *tproxy, MonoClass *klass) MONO_INTERNAL;
1429
1430 gpointer
1431 mono_create_ftnptr (MonoDomain *domain, gpointer addr) MONO_INTERNAL;
1432
1433 gpointer
1434 mono_get_addr_from_ftnptr (gpointer descr) MONO_INTERNAL;
1435
1436 void
1437 mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass) MONO_INTERNAL;
1438
1439 MonoObject*
1440 mono_nullable_box (guint8 *buf, MonoClass *klass) MONO_INTERNAL;
1441
1442 #ifdef MONO_SMALL_CONFIG
1443 #define MONO_IMT_SIZE 9
1444 #else
1445 #define MONO_IMT_SIZE 19
1446 #endif
1447
1448 typedef union {
1449         int vtable_slot;
1450         gpointer target_code;
1451 } MonoImtItemValue;
1452
1453 typedef struct _MonoImtBuilderEntry {
1454         gpointer key;
1455         struct _MonoImtBuilderEntry *next;
1456         MonoImtItemValue value;
1457         int children;
1458         guint8 has_target_code : 1;
1459 } MonoImtBuilderEntry;
1460
1461 typedef struct _MonoIMTCheckItem MonoIMTCheckItem;
1462
1463 struct _MonoIMTCheckItem {
1464         gpointer          key;
1465         int               check_target_idx;
1466         MonoImtItemValue  value;
1467         guint8           *jmp_code;
1468         guint8           *code_target;
1469         guint8            is_equals;
1470         guint8            compare_done;
1471         guint8            chunk_size;
1472         guint8            short_branch;
1473         guint8            has_target_code;
1474 };
1475
1476 typedef gpointer (*MonoImtThunkBuilder) (MonoVTable *vtable, MonoDomain *domain,
1477                 MonoIMTCheckItem **imt_entries, int count, gpointer fail_trunk);
1478
1479 void
1480 mono_install_imt_thunk_builder (MonoImtThunkBuilder func) MONO_INTERNAL;
1481
1482 void
1483 mono_vtable_build_imt_slot (MonoVTable* vtable, int imt_slot) MONO_INTERNAL;
1484
1485 guint32
1486 mono_method_get_imt_slot (MonoMethod *method) MONO_INTERNAL;
1487
1488 void
1489 mono_method_add_generic_virtual_invocation (MonoDomain *domain, MonoVTable *vtable,
1490                                                                                         gpointer *vtable_slot,
1491                                                                                         MonoMethod *method, gpointer code) MONO_INTERNAL;
1492
1493 gpointer
1494 mono_method_alloc_generic_virtual_thunk (MonoDomain *domain, int size) MONO_INTERNAL;
1495
1496 typedef enum {
1497         MONO_UNHANDLED_POLICY_LEGACY,
1498         MONO_UNHANDLED_POLICY_CURRENT
1499 } MonoRuntimeUnhandledExceptionPolicy;
1500
1501 MonoRuntimeUnhandledExceptionPolicy
1502 mono_runtime_unhandled_exception_policy_get (void) MONO_INTERNAL;
1503 void
1504 mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy) MONO_INTERNAL;
1505
1506 MonoVTable *
1507 mono_class_try_get_vtable (MonoDomain *domain, MonoClass *class) MONO_INTERNAL;
1508
1509 MonoException *
1510 mono_runtime_class_init_full (MonoVTable *vtable, gboolean raise_exception) MONO_INTERNAL;
1511
1512 void
1513 mono_method_clear_object (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL;
1514
1515 void
1516 mono_class_compute_gc_descriptor (MonoClass *class) MONO_INTERNAL;
1517
1518 MonoObject*
1519 mono_object_xdomain_representation (MonoObject *obj, MonoDomain *target_domain, MonoObject **exc) MONO_INTERNAL;
1520
1521 gboolean
1522 mono_class_is_reflection_method_or_constructor (MonoClass *class) MONO_INTERNAL;
1523
1524 MonoObject *
1525 mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob) MONO_INTERNAL;
1526
1527 gpointer
1528 mono_class_get_ref_info (MonoClass *klass) MONO_INTERNAL;
1529
1530 void
1531 mono_class_set_ref_info (MonoClass *klass, gpointer obj) MONO_INTERNAL;
1532
1533 void
1534 mono_class_free_ref_info (MonoClass *klass) MONO_INTERNAL;
1535
1536 MonoObject *
1537 mono_object_new_pinned (MonoDomain *domain, MonoClass *klass) MONO_INTERNAL;
1538
1539 void
1540 mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value) MONO_INTERNAL;
1541
1542 #endif /* __MONO_OBJECT_INTERNALS_H__ */
1543
1544