mono/metadata/object-internals.h

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