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