mono/metadata/object-internals.h

   1 /**
   2  * \file
   3  */
   4
   5 #ifndef __MONO_OBJECT_INTERNALS_H__
   6 #define __MONO_OBJECT_INTERNALS_H__
   7
   8 #include <mono/utils/mono-forward-internal.h>
   9 #include <mono/metadata/object-forward.h>
  10 #include <mono/metadata/handle-decl.h>
  11
  12 #include <mono/metadata/object.h>
  13 #include <mono/metadata/threads.h>
  14 #include <mono/metadata/reflection.h>
  15 #include <mono/metadata/mempool.h>
  16 #include <mono/metadata/class-internals.h>
  17 #include <mono/metadata/threads-types.h>
  18 #include <mono/metadata/handle.h>
  19 #include <mono/metadata/abi-details.h>
  20 #include "mono/utils/mono-compiler.h"
  21 #include "mono/utils/mono-error.h"
  22 #include "mono/utils/mono-error-internals.h"
  23 #include "mono/utils/mono-machine.h"
  24 #include "mono/utils/mono-stack-unwinding.h"
  25 #include "mono/utils/mono-tls.h"
  26 #include "mono/utils/mono-coop-mutex.h"
  27 #include <mono/metadata/icalls.h>
  28
  29 /* Use this as MONO_CHECK_ARG (arg,expr,) in functions returning void */
  30 #define MONO_CHECK_ARG(arg, expr, retval) do {                          \
  31         if (G_UNLIKELY (!(expr)))                                       \
  32         {                                                               \
  33                 if (0) { (void)(arg); } /* check if the name exists */  \
  34                 ERROR_DECL (error);                                     \
  35                 mono_error_set_argument_format (error, #arg, "assertion `%s' failed", #expr); \
  36                 mono_error_set_pending_exception (error);               \
  37                 return retval;                                          \
  38         }                                                               \
  39 } while (0)
  40
  41 #define MONO_CHECK_ARG_NULL_NAMED(arg, argname, retval) do {    \
  42         if (G_UNLIKELY (!(arg)))                                \
  43         {                                                       \
  44                 ERROR_DECL (error);                             \
  45                 mono_error_set_argument_null (error, (argname), "");    \
  46                 mono_error_set_pending_exception (error);       \
  47                 return retval;                                  \
  48         }                                                       \
  49 } while (0)
  50 /* Use this as MONO_CHECK_ARG_NULL (arg,) in functions returning void */
  51 #define MONO_CHECK_ARG_NULL(arg, retval) do {                   \
  52         if (G_UNLIKELY (!(arg)))                                \
  53         {                                                       \
  54                 mono_error_set_argument_null (error, #arg, ""); \
  55                 return retval;                                  \
  56         }                                                       \
  57 } while (0)
  58
  59 /* Use this as MONO_CHECK_ARG_NULL_HANDLE (arg,) in functions returning void */
  60 #define MONO_CHECK_ARG_NULL_HANDLE(arg, retval) do {            \
  61         if (G_UNLIKELY (MONO_HANDLE_IS_NULL (arg)))             \
  62         {                                                       \
  63                 mono_error_set_argument_null (error, #arg, ""); \
  64                 return retval;                                  \
  65         }                                                       \
  66 } while (0)
  67
  68 #define MONO_CHECK_ARG_NULL_HANDLE_NAMED(arg, argname, retval) do { \
  69         if (G_UNLIKELY (MONO_HANDLE_IS_NULL (arg)))             \
  70         {                                                       \
  71                 mono_error_set_argument_null (error, (argname), "");    \
  72                 return retval;                                  \
  73         }                                                       \
  74 } while (0)
  75
  76 /* Use this as MONO_CHECK_NULL (arg,) in functions returning void */
  77 #define MONO_CHECK_NULL(arg, retval) do {                       \
  78         if (G_UNLIKELY (!(arg)))                                \
  79         {                                                       \
  80                 ERROR_DECL (error);                             \
  81                 mono_error_set_null_reference (error);          \
  82                 mono_error_set_pending_exception (error);       \
  83                 return retval;                                  \
  84         }                                                       \
  85 } while (0)
  86
  87 /*
  88  * Macros which cache the results of lookups locally.
  89  * These should be used instead of the original versions, if the __GNUC__
  90  * restriction is acceptable.
  91  */
  92
  93 #ifdef __GNUC__
  94
  95 /* name should be a compile-time constant */
  96 #define mono_class_get_field_from_name_cached(klass,name) ({ \
  97                         static MonoClassField *tmp_field; \
  98                         if (!tmp_field) { \
  99                                 tmp_field = mono_class_get_field_from_name_full ((klass), (name), NULL); \
 100                                 g_assert (tmp_field); \
 101                         }; \
 102                         tmp_field; })
 103 /* eclass should be a run-time constant */
 104 #define mono_array_class_get_cached(eclass,rank) ({     \
 105                         static MonoClass *tmp_klass; \
 106                         if (!tmp_klass) { \
 107                                 tmp_klass = mono_class_create_array ((eclass), (rank)); \
 108                                 g_assert (tmp_klass); \
 109                         }; \
 110                         tmp_klass; })
 111 /* eclass should be a run-time constant */
 112 #define mono_array_new_cached(domain, eclass, size, error) ({   \
 113         MonoVTable *__vtable = mono_class_vtable_checked ((domain), mono_array_class_get_cached ((eclass), 1), (error)); \
 114         MonoArray *__arr = NULL;                                        \
 115         if (is_ok ((error)))                                            \
 116                 __arr = mono_array_new_specific_checked (__vtable, (size), (error)); \
 117         __arr; })
 118
 119 /* eclass should be a run-time constant */
 120 #define mono_array_new_cached_handle(domain, eclass, size, error) ({    \
 121         MonoVTable *__vtable = mono_class_vtable_checked ((domain), mono_array_class_get_cached ((eclass), 1), (error)); \
 122         MonoArrayHandle __arr = NULL_HANDLE_ARRAY;                      \
 123         if (is_ok ((error)))                                            \
 124                 __arr = mono_array_new_specific_handle (__vtable, (size), (error)); \
 125         __arr; })
 126
 127 #else
 128
 129 #define mono_class_get_field_from_name_cached(klass,name) mono_class_get_field_from_name ((klass), (name))
 130 #define mono_array_class_get_cached(eclass,rank) mono_class_create_array ((eclass), (rank))
 131 #define mono_array_new_cached(domain, eclass, size, error) mono_array_new_checked ((domain), (eclass), (size), (error))
 132 #define mono_array_new_cached_handle(domain, eclass, size, error) (mono_array_new_handle ((domain), (eclass), (size), (error)))
 133
 134 #endif
 135
 136 #ifdef MONO_BIG_ARRAYS
 137 typedef uint64_t mono_array_size_t;
 138 typedef int64_t mono_array_lower_bound_t;
 139 #define MONO_ARRAY_MAX_INDEX G_MAXINT64
 140 #define MONO_ARRAY_MAX_SIZE  G_MAXUINT64
 141 #else
 142 typedef uint32_t mono_array_size_t;
 143 typedef int32_t mono_array_lower_bound_t;
 144 #define MONO_ARRAY_MAX_INDEX ((int32_t) 0x7fffffff)
 145 #define MONO_ARRAY_MAX_SIZE  ((uint32_t) 0xffffffff)
 146 #endif
 147
 148 typedef struct {
 149         mono_array_size_t length;
 150         mono_array_lower_bound_t lower_bound;
 151 } MonoArrayBounds;
 152
 153 struct _MonoArray {
 154         MonoObject obj;
 155         /* bounds is NULL for szarrays */
 156         MonoArrayBounds *bounds;
 157         /* total number of elements of the array */
 158         mono_array_size_t max_length;
 159         /* we use mono_64bitaligned_t to ensure proper alignment on platforms that need it */
 160         mono_64bitaligned_t vector [MONO_ZERO_LEN_ARRAY];
 161 };
 162
 163 #define MONO_SIZEOF_MONO_ARRAY (MONO_STRUCT_OFFSET (MonoArray, vector))
 164
 165 struct _MonoString {
 166         MonoObject object;
 167         int32_t length;
 168         mono_unichar2 chars [MONO_ZERO_LEN_ARRAY];
 169 };
 170
 171 #define MONO_SIZEOF_MONO_STRING (MONO_STRUCT_OFFSET (MonoString, chars))
 172
 173 #define mono_object_class(obj) (((MonoObject*)(obj))->vtable->klass)
 174 #define mono_object_domain(obj) (((MonoObject*)(obj))->vtable->domain)
 175
 176 #define mono_string_chars_fast(s) ((mono_unichar2*)(s)->chars)
 177 #define mono_string_length_fast(s) ((s)->length)
 178
 179 /**
 180  * mono_array_length_internal:
 181  * \param array a \c MonoArray*
 182  * \returns the total number of elements in the array. This works for
 183  * both vectors and multidimensional arrays.
 184  */
 185 #define mono_array_length_internal(array) ((array)->max_length)
 186
 187 static inline
 188 uintptr_t
 189 mono_array_handle_length (MonoArrayHandle arr)
 190 {
 191         MONO_REQ_GC_UNSAFE_MODE;
 192
 193         return mono_array_length_internal (MONO_HANDLE_RAW (arr));
 194 }
 195
 196 // Equivalent to mono_array_addr_with_size, except:
 197 // 1. A macro instead of a function -- the types of size and index are open.
 198 // 2. mono_array_addr_with_size could, but does not, do GC mode transitions.
 199 #define mono_array_addr_with_size_fast(array,size,index) ( ((char*)(array)->vector) + (size) * (index) )
 200
 201 #define mono_array_addr_fast(array,type,index) ((type*)(void*) mono_array_addr_with_size_fast (array, sizeof (type), index))
 202 #define mono_array_get_fast(array,type,index) ( *(type*)mono_array_addr_fast ((array), type, (index)) )
 203 #define mono_array_set_fast(array,type,index,value)     \
 204         do {    \
 205                 type *__p = (type *) mono_array_addr_fast ((array), type, (index));     \
 206                 *__p = (value); \
 207         } while (0)
 208 #define mono_array_setref_fast(array,index,value)       \
 209         do {    \
 210                 void **__p = (void **) mono_array_addr_fast ((array), void*, (index));  \
 211                 mono_gc_wbarrier_set_arrayref_internal ((array), __p, (MonoObject*)(value));    \
 212                 /* *__p = (value);*/    \
 213         } while (0)
 214 #define mono_array_memcpy_refs_fast(dest,destidx,src,srcidx,count)      \
 215         do {    \
 216                 void **__p = (void **) mono_array_addr_fast ((dest), void*, (destidx)); \
 217                 void **__s = mono_array_addr_fast ((src), void*, (srcidx));     \
 218                 mono_gc_wbarrier_arrayref_copy_internal (__p, __s, (count));    \
 219         } while (0)
 220
 221 // _internal is like _fast, but preserves the preexisting subtlety of the closed types of things:
 222 //      int size
 223 //      uintptr_t idx
 224 // in order to mimic non-_internal but without the GC mode transitions, or at least,
 225 // to avoid the runtime using the embedding API, whether or not it has GC mode transitions.
 226 static inline char*
 227 mono_array_addr_with_size_internal (MonoArray *array, int size, uintptr_t idx)
 228 {
 229         return mono_array_addr_with_size_fast (array, size, idx);
 230 }
 231
 232 #define mono_array_addr_internal(array,type,index) ((type*)(void*) mono_array_addr_with_size_internal (array, sizeof (type), index))
 233 #define mono_array_get_internal(array,type,index) ( *(type*)mono_array_addr_internal ((array), type, (index)) )
 234 #define mono_array_set_internal(array,type,index,value) \
 235         do {    \
 236                 type *__p = (type *) mono_array_addr_internal ((array), type, (index)); \
 237                 *__p = (value); \
 238         } while (0)
 239 #define mono_array_setref_internal(array,index,value)   \
 240         do {    \
 241                 void **__p = (void **) mono_array_addr_internal ((array), void*, (index));      \
 242                 mono_gc_wbarrier_set_arrayref_internal ((array), __p, (MonoObject*)(value));    \
 243                 /* *__p = (value);*/    \
 244         } while (0)
 245 #define mono_array_memcpy_refs_internal(dest,destidx,src,srcidx,count)  \
 246         do {    \
 247                 void **__p = (void **) mono_array_addr_internal ((dest), void*, (destidx));     \
 248                 void **__s = mono_array_addr_internal ((src), void*, (srcidx)); \
 249                 mono_gc_wbarrier_arrayref_copy_internal (__p, __s, (count));    \
 250         } while (0)
 251
 252 static inline gboolean
 253 mono_handle_array_has_bounds (MonoArrayHandle arr)
 254 {
 255         return MONO_HANDLE_GETVAL (arr, bounds) != NULL;
 256 }
 257
 258 static inline void
 259 mono_handle_array_get_bounds_dim (MonoArrayHandle arr, gint32 dim, MonoArrayBounds *bounds)
 260 {
 261         *bounds = MONO_HANDLE_GETVAL (arr, bounds [dim]);
 262 }
 263
 264 typedef struct {
 265         MonoObject obj;
 266 #ifndef ENABLE_NETCORE
 267         MonoObject *identity;
 268 #endif
 269 } MonoMarshalByRefObject;
 270
 271 TYPED_HANDLE_DECL (MonoMarshalByRefObject);
 272
 273 /* This is a copy of System.AppDomain */
 274 struct _MonoAppDomain {
 275         MonoMarshalByRefObject mbr;
 276         MonoDomain *data;
 277 };
 278
 279 /* Safely access System.AppDomain from native code */
 280 TYPED_HANDLE_DECL (MonoAppDomain);
 281
 282 /* Safely access System.AppDomainSetup from native code.  (struct is in domain-internals.h) */
 283 TYPED_HANDLE_DECL (MonoAppDomainSetup);
 284
 285 typedef struct _MonoStringBuilder MonoStringBuilder;
 286 TYPED_HANDLE_DECL (MonoStringBuilder);
 287
 288 struct _MonoStringBuilder {
 289         MonoObject object;
 290         MonoArray  *chunkChars;
 291         MonoStringBuilder* chunkPrevious;      // Link to the block logically before this block
 292         int chunkLength;                  // The index in ChunkChars that represent the end of the block
 293         int chunkOffset;                  // The logial offset (sum of all characters in previous blocks)
 294         int maxCapacity;
 295 };
 296
 297 static inline int
 298 mono_string_builder_capacity (MonoStringBuilderHandle sbh)
 299 {
 300         MonoStringBuilder *sb = MONO_HANDLE_RAW (sbh);
 301         return sb->chunkOffset + sb->chunkChars->max_length;
 302 }
 303
 304 static inline int
 305 mono_string_builder_string_length (MonoStringBuilderHandle sbh)
 306 {
 307         MonoStringBuilder *sb = MONO_HANDLE_RAW (sbh);
 308         return sb->chunkOffset + sb->chunkLength;
 309 }
 310
 311 typedef struct {
 312         MonoType *type;
 313         gpointer  value;
 314         MonoClass *klass;
 315 } MonoTypedRef;
 316
 317 typedef struct {
 318         gpointer args;
 319 } MonoArgumentHandle;
 320
 321 typedef struct {
 322         MonoMethodSignature *sig;
 323         gpointer args;
 324         gint32 next_arg;
 325         gint32 num_args;
 326 } MonoArgIterator;
 327
 328 struct _MonoException {
 329         MonoObject object;
 330         MonoString *class_name;
 331         MonoString *message;
 332         MonoObject *_data;
 333         MonoObject *inner_ex;
 334         MonoString *help_link;
 335         /* Stores the IPs and the generic sharing infos
 336            (vtable/MRGCTX) of the frames. */
 337         MonoArray  *trace_ips;
 338         MonoString *stack_trace;
 339         MonoString *remote_stack_trace;
 340         gint32      remote_stack_index;
 341         /* Dynamic methods referenced by the stack trace */
 342         MonoObject *dynamic_methods;
 343         gint32      hresult;
 344         MonoString *source;
 345         MonoObject *serialization_manager;
 346         MonoObject *captured_traces;
 347         MonoArray  *native_trace_ips;
 348         gint32 caught_in_unmanaged;
 349 };
 350
 351 typedef struct {
 352         MonoException base;
 353 } MonoSystemException;
 354
 355 TYPED_HANDLE_DECL (MonoSystemException);
 356
 357 #ifndef ENABLE_NETCORE
 358 typedef struct {
 359         MonoSystemException base;
 360         MonoString *param_name;
 361 } MonoArgumentException;
 362 #endif
 363
 364 typedef struct {
 365         MonoObject   object;
 366         MonoObject  *async_state;
 367         MonoObject  *handle;
 368         MonoObject  *async_delegate;
 369         gpointer    *data;
 370         MonoObject  *object_data;
 371         MonoBoolean  sync_completed;
 372         MonoBoolean  completed;
 373         MonoBoolean  endinvoke_called;
 374         MonoObject  *async_callback;
 375         MonoObject  *execution_context;
 376         MonoObject  *original_context;
 377         gint64       add_time;
 378 } MonoAsyncResult;
 379
 380 TYPED_HANDLE_DECL (MonoAsyncResult);
 381
 382 typedef struct {
 383         MonoMarshalByRefObject object;
 384         gpointer     handle;
 385 } MonoWaitHandle;
 386
 387 TYPED_HANDLE_DECL (MonoWaitHandle);
 388
 389 /* This is a copy of System.Runtime.Remoting.Messaging.CallType */
 390 typedef enum {
 391         CallType_Sync = 0,
 392         CallType_BeginInvoke = 1,
 393         CallType_EndInvoke = 2,
 394         CallType_OneWay = 3
 395 } MonoCallType;
 396
 397 /* System.Threading.StackCrawlMark */
 398 /*
 399  * This type is used to identify the method where execution has entered
 400  * the BCL during stack walks. The outermost public method should
 401  * define it like this:
 402  * StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
 403  * and pass the stackMark as a byref argument down the call chain
 404  * until it reaches an icall.
 405  */
 406 typedef enum {
 407         STACK_CRAWL_ME = 0,
 408         STACK_CRAWL_CALLER = 1,
 409         STACK_CRAWL_CALLERS_CALLER = 2,
 410         STACK_CRAWL_THREAD = 3
 411 } MonoStackCrawlMark;
 412
 413 /* MonoSafeHandle is in class-internals.h. */
 414 /* Safely access System.Net.Sockets.SafeSocketHandle from native code */
 415 TYPED_HANDLE_DECL (MonoSafeHandle);
 416
 417 /* This corresponds to System.Type */
 418 struct _MonoReflectionType {
 419         MonoObject object;
 420         MonoType  *type;
 421 };
 422
 423 /* Safely access System.Type from native code */
 424 TYPED_HANDLE_DECL (MonoReflectionType);
 425
 426 /* This corresponds to System.RuntimeType */
 427 typedef struct {
 428         MonoReflectionType type;
 429         MonoObject *type_info;
 430 } MonoReflectionMonoType;
 431
 432 TYPED_HANDLE_DECL (MonoReflectionMonoType);
 433
 434 typedef struct {
 435         MonoObject  object;
 436         MonoReflectionType *class_to_proxy;
 437         MonoObject *context;
 438         MonoObject *unwrapped_server;
 439         gint32      target_domain_id;
 440         MonoString *target_uri;
 441         MonoObject *object_identity;
 442         MonoObject *obj_TP;
 443         MonoObject *stub_data;
 444 } MonoRealProxy;
 445
 446 /* Safely access System.Runtime.Remoting.Proxies.RealProxy from native code */
 447 TYPED_HANDLE_DECL (MonoRealProxy);
 448
 449 typedef struct _MonoIUnknown MonoIUnknown;
 450 typedef struct _MonoIUnknownVTable MonoIUnknownVTable;
 451
 452 /* STDCALL on windows, CDECL everywhere else to work with XPCOM and MainWin COM */
 453 #ifdef HOST_WIN32
 454 #define STDCALL __stdcall
 455 #else
 456 #define STDCALL
 457 #endif
 458
 459 struct _MonoIUnknownVTable
 460 {
 461         int (STDCALL *QueryInterface)(MonoIUnknown *pUnk, gconstpointer riid, gpointer* ppv);
 462         int (STDCALL *AddRef)(MonoIUnknown *pUnk);
 463         int (STDCALL *Release)(MonoIUnknown *pUnk);
 464 };
 465
 466 struct _MonoIUnknown
 467 {
 468         const MonoIUnknownVTable *vtable;
 469 };
 470
 471 typedef struct {
 472         MonoMarshalByRefObject object;
 473         MonoIUnknown *iunknown;
 474         GHashTable* itf_hash;
 475         MonoObject *synchronization_context;
 476 } MonoComObject;
 477
 478 TYPED_HANDLE_DECL (MonoComObject);
 479
 480 typedef struct {
 481         MonoRealProxy real_proxy;
 482         MonoComObject *com_object;
 483         gint32 ref_count;
 484 } MonoComInteropProxy;
 485
 486 TYPED_HANDLE_DECL (MonoComInteropProxy);
 487
 488 typedef struct {
 489         MonoObject       object;
 490         MonoRealProxy   *rp;
 491         MonoRemoteClass *remote_class;
 492         MonoBoolean      custom_type_info;
 493 } MonoTransparentProxy;
 494
 495 /* Safely access System.Runtime.Remoting.Proxies.TransparentProxy from native code */
 496 TYPED_HANDLE_DECL (MonoTransparentProxy);
 497
 498 typedef struct {
 499         MonoObject obj;
 500         MonoReflectionMethod *method;
 501         MonoArray  *args;
 502         MonoArray  *names;
 503         MonoArray  *arg_types;
 504         MonoObject *ctx;
 505         MonoObject *rval;
 506         MonoObject *exc;
 507         MonoAsyncResult *async_result;
 508         guint32     call_type;
 509 } MonoMethodMessage;
 510
 511 TYPED_HANDLE_DECL (MonoMethodMessage);
 512
 513 /* Keep in sync with the System.MonoAsyncCall */
 514 typedef struct {
 515         MonoObject object;
 516         MonoMethodMessage *msg;
 517         MonoMethod *cb_method;
 518         MonoDelegate *cb_target;
 519         MonoObject *state;
 520         MonoObject *res;
 521         MonoArray *out_args;
 522 } MonoAsyncCall;
 523
 524 TYPED_HANDLE_DECL (MonoAsyncCall);
 525
 526 typedef struct {
 527         MonoObject obj;
 528         MonoArray *frames;
 529         MonoArray *captured_traces;
 530         MonoBoolean debug_info;
 531 } MonoStackTrace;
 532
 533 TYPED_HANDLE_DECL (MonoStackTrace);
 534
 535 typedef struct {
 536         MonoObject obj;
 537         gint32 il_offset;
 538         gint32 native_offset;
 539         gint64 method_address;
 540         gint32 method_index;
 541         MonoReflectionMethod *method;
 542         MonoString *filename;
 543         gint32 line;
 544         gint32 column;
 545         MonoString *internal_method_name;
 546 } MonoStackFrame;
 547
 548 TYPED_HANDLE_DECL (MonoStackFrame);
 549
 550 typedef enum {
 551         MONO_THREAD_FLAG_DONT_MANAGE = 1, // Don't wait for or abort this thread
 552         MONO_THREAD_FLAG_NAME_SET = 2, // Thread name set from managed code
 553         MONO_THREAD_FLAG_APPDOMAIN_ABORT = 4, // Current requested abort originates from appdomain unload
 554 } MonoThreadFlags;
 555
 556 struct _MonoThreadInfo;
 557
 558 typedef struct MonoThreadName {
 559         char* volatile chars;      // null check outside of lock
 560         gsize volatile generation; // read outside of lock
 561         gint32 free;
 562         gint32 length;
 563 } MonoThreadName;
 564
 565 void
 566 mono_gstring_append_thread_name (GString*, MonoInternalThread*);
 567
 568
 569 #ifdef ENABLE_NETCORE
 570 /*
 571  * There is only one thread object, MonoInternalThread is aliased to MonoThread,
 572  * thread->internal_thread points to itself.
 573  */
 574 struct _MonoThread {
 575 #else
 576 struct _MonoInternalThread {
 577 #endif
 578         // FIXME: Mechanize keeping this in sync with managed.
 579         MonoObject  obj;
 580         volatile int lock_thread_id; /* to be used as the pre-shifted thread id in thin locks. Used for appdomain_ref push/pop */
 581         MonoThreadHandle *handle;
 582         gpointer native_handle;
 583         MonoThreadName name;
 584         guint32     state;      /* must be accessed while longlived->synch_cs is locked */
 585         MonoException *abort_exc;
 586         int abort_state_handle;
 587         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 */
 588         gsize debugger_thread; // FIXME switch to bool as soon as CI testing with corlib version bump works
 589         gpointer *static_data;
 590         struct _MonoThreadInfo *thread_info;
 591         MonoAppContext *current_appcontext;
 592         MonoThread *root_domain_thread;
 593         MonoObject *_serialized_principal;
 594         int _serialized_principal_version;
 595         gpointer appdomain_refs;
 596         /* This is modified using atomic ops, so keep it a gint32 */
 597         gint32 __interruption_requested;
 598         /* data that must live as long as this managed object is not finalized
 599          * or as long as the underlying thread is attached, whichever is
 600          * longer */
 601         MonoLongLivedThreadData *longlived;
 602         MonoBoolean threadpool_thread;
 603         MonoBoolean thread_interrupt_requested;
 604         int stack_size;
 605         guint8  apartment_state;
 606         gint32 critical_region_level;
 607         gint32 managed_id;
 608         guint32 small_id;
 609         MonoThreadManageCallback manage_callback;
 610         gsize    flags;
 611         gpointer thread_pinning_ref;
 612         gsize __abort_protected_block_count;
 613         gint32 priority;
 614         GPtrArray *owned_mutexes;
 615         MonoOSEvent *suspended;
 616         gint32 self_suspended; // TRUE | FALSE
 617         gsize thread_state;
 618
 619 #ifdef ENABLE_NETCORE
 620         struct _MonoThread *internal_thread;
 621         MonoObject *start_obj;
 622         MonoException *pending_exception;
 623 #else
 624         void* unused [3]; // same size as netcore
 625 #endif
 626         /* This is used only to check that we are in sync between the representation
 627          * of MonoInternalThread in native and InternalThread in managed
 628          *
 629          * DO NOT RENAME! DO NOT ADD FIELDS AFTER! */
 630         gpointer last;
 631 };
 632
 633 #ifdef ENABLE_NETCORE
 634 #define _MonoInternalThread _MonoThread
 635 #else
 636 struct _MonoThread {
 637         MonoObject obj;
 638         MonoInternalThread *internal_thread;
 639         MonoObject *start_obj;
 640         MonoException *pending_exception;
 641 };
 642 #endif
 643
 644 typedef struct {
 645         guint32 state;
 646         MonoObject *additional;
 647 } MonoStreamingContext;
 648
 649 #if !ENABLE_NETCORE
 650 typedef struct {
 651         MonoObject obj;
 652         MonoBoolean readOnly;
 653         MonoString *AMDesignator;
 654         MonoString *PMDesignator;
 655         MonoString *DateSeparator;
 656         MonoString *TimeSeparator;
 657         MonoString *ShortDatePattern;
 658         MonoString *LongDatePattern;
 659         MonoString *ShortTimePattern;
 660         MonoString *LongTimePattern;
 661         MonoString *MonthDayPattern;
 662         MonoString *YearMonthPattern;
 663         guint32 FirstDayOfWeek;
 664         guint32 CalendarWeekRule;
 665         MonoArray *AbbreviatedDayNames;
 666         MonoArray *DayNames;
 667         MonoArray *MonthNames;
 668         MonoArray *GenitiveMonthNames;
 669         MonoArray *AbbreviatedMonthNames;
 670         MonoArray *GenitiveAbbreviatedMonthNames;
 671         MonoArray *ShortDatePatterns;
 672         MonoArray *LongDatePatterns;
 673         MonoArray *ShortTimePatterns;
 674         MonoArray *LongTimePatterns;
 675         MonoArray *MonthDayPatterns;
 676         MonoArray *YearMonthPatterns;
 677         MonoArray *ShortestDayNames;
 678 } MonoDateTimeFormatInfo;
 679
 680 typedef struct
 681 {
 682         MonoObject obj;
 683         MonoArray *numberGroupSizes;
 684         MonoArray *currencyGroupSizes;
 685         MonoArray *percentGroupSizes;
 686         MonoString *positiveSign;
 687         MonoString *negativeSign;
 688         MonoString *numberDecimalSeparator;
 689         MonoString *numberGroupSeparator;
 690         MonoString *currencyGroupSeparator;
 691         MonoString *currencyDecimalSeparator;
 692         MonoString *currencySymbol;
 693         MonoString *ansiCurrencySymbol; /* unused */
 694         MonoString *naNSymbol;
 695         MonoString *positiveInfinitySymbol;
 696         MonoString *negativeInfinitySymbol;
 697         MonoString *percentDecimalSeparator;
 698         MonoString *percentGroupSeparator;
 699         MonoString *percentSymbol;
 700         MonoString *perMilleSymbol;
 701         MonoString *nativeDigits; /* unused */
 702         gint32 dataItem; /* unused */
 703         guint32 numberDecimalDigits;
 704         gint32 currencyDecimalDigits;
 705         gint32 currencyPositivePattern;
 706         gint32 currencyNegativePattern;
 707         gint32 numberNegativePattern;
 708         gint32 percentPositivePattern;
 709         gint32 percentNegativePattern;
 710         gint32 percentDecimalDigits;
 711 } MonoNumberFormatInfo;
 712
 713 typedef struct {
 714         MonoObject obj;
 715         gint32 lcid;
 716         MonoString *icu_name;
 717         gpointer ICU_collator;
 718 } MonoCompareInfo;
 719
 720 typedef struct {
 721         MonoObject obj;
 722         MonoString *NativeName;
 723         MonoArray *ShortDatePatterns;
 724         MonoArray *YearMonthPatterns;
 725         MonoArray *LongDatePatterns;
 726         MonoString *MonthDayPattern;
 727
 728         MonoArray *EraNames;
 729         MonoArray *AbbreviatedEraNames;
 730         MonoArray *AbbreviatedEnglishEraNames;
 731         MonoArray *DayNames;
 732         MonoArray *AbbreviatedDayNames;
 733         MonoArray *SuperShortDayNames;
 734         MonoArray *MonthNames;
 735         MonoArray *AbbreviatedMonthNames;
 736         MonoArray *GenitiveMonthNames;
 737         MonoArray *GenitiveAbbreviatedMonthNames;
 738 } MonoCalendarData;
 739
 740 TYPED_HANDLE_DECL (MonoCalendarData);
 741
 742 typedef struct {
 743         MonoObject obj;
 744         MonoString *AMDesignator;
 745         MonoString *PMDesignator;
 746         MonoString *TimeSeparator;
 747         MonoArray *LongTimePatterns;
 748         MonoArray *ShortTimePatterns;
 749         guint32 FirstDayOfWeek;
 750         guint32 CalendarWeekRule;
 751 } MonoCultureData;
 752
 753 TYPED_HANDLE_DECL (MonoCultureData);
 754
 755 typedef struct {
 756         MonoObject obj;
 757         MonoBoolean is_read_only;
 758         gint32 lcid;
 759         gint32 parent_lcid;
 760         gint32 datetime_index;
 761         gint32 number_index;
 762         gint32 calendar_type;
 763         MonoBoolean use_user_override;
 764         MonoNumberFormatInfo *number_format;
 765         MonoDateTimeFormatInfo *datetime_format;
 766         MonoObject *textinfo;
 767         MonoString *name;
 768         MonoString *englishname;
 769         MonoString *nativename;
 770         MonoString *iso3lang;
 771         MonoString *iso2lang;
 772         MonoString *win3lang;
 773         MonoString *territory;
 774         MonoArray *native_calendar_names;
 775         MonoCompareInfo *compareinfo;
 776         const void* text_info_data;
 777 } MonoCultureInfo;
 778
 779 TYPED_HANDLE_DECL (MonoCultureInfo);
 780
 781 typedef struct {
 782         MonoObject obj;
 783         gint32 geo_id;
 784         MonoString *iso2name;
 785         MonoString *iso3name;
 786         MonoString *win3name;
 787         MonoString *english_name;
 788         MonoString *native_name;
 789         MonoString *currency_symbol;
 790         MonoString *iso_currency_symbol;
 791         MonoString *currency_english_name;
 792         MonoString *currency_native_name;
 793 } MonoRegionInfo;
 794
 795 TYPED_HANDLE_DECL (MonoRegionInfo);
 796
 797 #endif /* !ENABLE_NETCORE */
 798
 799 typedef struct {
 800         MonoObject object;
 801         guint32 intType;
 802 } MonoInterfaceTypeAttribute;
 803
 804 /* Safely access System.Delegate from native code */
 805 TYPED_HANDLE_DECL (MonoDelegate);
 806
 807 /*
 808  * Callbacks supplied by the runtime and called by the modules in metadata/
 809  * This interface is easier to extend than adding a new function type +
 810  * a new 'install' function for every callback.
 811  */
 812 typedef struct {
 813         gpointer (*create_ftnptr) (MonoDomain *domain, gpointer addr);
 814         gpointer (*get_addr_from_ftnptr) (gpointer descr);
 815         char*    (*get_runtime_build_info) (void);
 816         const char*    (*get_runtime_build_version) (void);
 817         gpointer (*get_vtable_trampoline) (MonoVTable *vtable, int slot_index);
 818         gpointer (*get_imt_trampoline) (MonoVTable *vtable, int imt_slot_index);
 819         gboolean (*imt_entry_inited) (MonoVTable *vtable, int imt_slot_index);
 820         void     (*set_cast_details) (MonoClass *from, MonoClass *to);
 821         void     (*debug_log) (int level, MonoStringHandle category, MonoStringHandle message);
 822         gboolean (*debug_log_is_enabled) (void);
 823         void     (*init_delegate) (MonoDelegateHandle delegate, MonoError *error);
 824         MonoObject* (*runtime_invoke) (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError *error);
 825         void*    (*compile_method) (MonoMethod *method, MonoError *error);
 826         gpointer (*create_jump_trampoline) (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper, MonoError *error);
 827         gpointer (*create_jit_trampoline) (MonoDomain *domain, MonoMethod *method, MonoError *error);
 828         /* used to free a dynamic method */
 829         void     (*free_method) (MonoDomain *domain, MonoMethod *method);
 830         gpointer (*create_remoting_trampoline) (MonoDomain *domain, MonoMethod *method, MonoRemotingTarget target, MonoError *error);
 831         gpointer (*create_delegate_trampoline) (MonoDomain *domain, MonoClass *klass);
 832         gpointer (*interp_get_remoting_invoke) (MonoMethod *method, gpointer imethod, MonoError *error);
 833         GHashTable *(*get_weak_field_indexes) (MonoImage *image);
 834         void     (*install_state_summarizer) (void);
 835         gboolean (*is_interpreter_enabled) (void);
 836 } MonoRuntimeCallbacks;
 837
 838 typedef gboolean (*MonoInternalStackWalk) (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data);
 839 typedef gboolean (*MonoInternalExceptionFrameWalk) (MonoMethod *method, gpointer ip, size_t native_offset, gboolean managed, gpointer user_data);
 840
 841 typedef struct {
 842         void (*mono_walk_stack_with_ctx) (MonoInternalStackWalk func, MonoContext *ctx, MonoUnwindOptions options, void *user_data);
 843         void (*mono_walk_stack_with_state) (MonoInternalStackWalk func, MonoThreadUnwindState *state, MonoUnwindOptions options, void *user_data);
 844         void (*mono_raise_exception) (MonoException *ex);
 845         void (*mono_raise_exception_with_ctx) (MonoException *ex, MonoContext *ctx);
 846         gboolean (*mono_exception_walk_trace) (MonoException *ex, MonoInternalExceptionFrameWalk func, gpointer user_data);
 847         gboolean (*mono_install_handler_block_guard) (MonoThreadUnwindState *unwind_state);
 848         void (*mono_uninstall_current_handler_block_guard) (void);
 849         gboolean (*mono_current_thread_has_handle_block_guard) (void);
 850         gboolean (*mono_above_abort_threshold) (void);
 851         void (*mono_clear_abort_threshold) (void);
 852         void (*mono_reraise_exception) (MonoException *ex);
 853         void (*mono_summarize_managed_stack) (MonoThreadSummary *out);
 854         void (*mono_summarize_unmanaged_stack) (MonoThreadSummary *out);
 855         void (*mono_summarize_exception) (MonoException *exc, MonoThreadSummary *out);
 856         void (*mono_register_native_library) (const char *module_path, const char *module_name);
 857         void (*mono_allow_all_native_libraries) (void);
 858 } MonoRuntimeExceptionHandlingCallbacks;
 859
 860 MONO_COLD void mono_set_pending_exception (MonoException *exc);
 861
 862 /* remoting and async support */
 863
 864 MonoAsyncResult *
 865 mono_async_result_new       (MonoDomain *domain, gpointer handle,
 866                              MonoObject *state, gpointer data, MonoObject *object_data, MonoError *error);
 867 MonoWaitHandle *
 868 mono_wait_handle_new        (MonoDomain *domain, gpointer handle, MonoError *error);
 869
 870 gpointer
 871 mono_wait_handle_get_handle (MonoWaitHandle *handle);
 872
 873 gboolean
 874 mono_message_init           (MonoDomain *domain, MonoMethodMessage *this_obj,
 875                              MonoReflectionMethod *method, MonoArray *out_args, MonoError *error);
 876
 877 MonoMethodMessage *
 878 mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
 879                               MonoDelegate **cb, MonoObject **state, MonoError *error);
 880
 881 void
 882 mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args, MonoError *error);
 883
 884 gboolean
 885 mono_delegate_ctor_with_method (MonoObjectHandle this_obj, MonoObjectHandle target, gpointer addr, MonoMethod *method, MonoError *error);
 886
 887 gboolean
 888 mono_delegate_ctor          (MonoObjectHandle this_obj, MonoObjectHandle target, gpointer addr, MonoError *error);
 889
 890 MonoMethod *
 891 mono_get_delegate_invoke_checked (MonoClass *klass, MonoError *error);
 892
 893 MonoMethod *
 894 mono_get_delegate_begin_invoke_checked (MonoClass *klass, MonoError *error);
 895
 896 MonoMethod *
 897 mono_get_delegate_end_invoke_checked (MonoClass *klass, MonoError *error);
 898
 899 void
 900 mono_runtime_free_method    (MonoDomain *domain, MonoMethod *method);
 901
 902 void
 903 mono_install_callbacks      (MonoRuntimeCallbacks *cbs);
 904
 905 MonoRuntimeCallbacks*
 906 mono_get_runtime_callbacks (void);
 907
 908 void
 909 mono_install_eh_callbacks (MonoRuntimeExceptionHandlingCallbacks *cbs);
 910
 911 MonoRuntimeExceptionHandlingCallbacks *
 912 mono_get_eh_callbacks (void);
 913
 914 void
 915 mono_raise_exception_deprecated (MonoException *ex);
 916
 917 void
 918 mono_reraise_exception_deprecated (MonoException *ex);
 919
 920 void
 921 mono_raise_exception_with_context (MonoException *ex, MonoContext *ctx);
 922
 923 void
 924 mono_type_initialization_init (void);
 925
 926 void
 927 mono_type_initialization_cleanup (void);
 928
 929 int
 930 mono_thread_kill           (MonoInternalThread *thread, int signal);
 931
 932 MonoNativeTlsKey
 933 mono_thread_get_tls_key    (void);
 934
 935 gint32
 936 mono_thread_get_tls_offset (void);
 937
 938 MonoNativeTlsKey
 939 mono_domain_get_tls_key    (void);
 940
 941 gint32
 942 mono_domain_get_tls_offset (void);
 943
 944 /* Reflection and Reflection.Emit support */
 945
 946 /*
 947  * Handling System.Type objects:
 948  *
 949  *   Fields defined as System.Type in managed code should be defined as MonoObject*
 950  * in unmanaged structures, and the monotype_cast () function should be used for
 951  * casting them to MonoReflectionType* to avoid crashes/security issues when
 952  * encountering instances of user defined subclasses of System.Type.
 953  */
 954
 955 #define IS_MONOTYPE(obj) (!(obj) || (m_class_get_image (mono_object_class ((obj))) == mono_defaults.corlib && ((MonoReflectionType*)(obj))->type != NULL))
 956
 957 #define IS_MONOTYPE_HANDLE(obj) IS_MONOTYPE (MONO_HANDLE_RAW (obj))
 958
 959 /* This should be used for accessing members of Type[] arrays */
 960 #define mono_type_array_get(arr,index) monotype_cast (mono_array_get_internal ((arr), gpointer, (index)))
 961
 962 /*
 963  * Cast an object to MonoReflectionType, making sure it is a System.MonoType or
 964  * a subclass of it.
 965  */
 966 static inline MonoReflectionType*
 967 monotype_cast (MonoObject *obj)
 968 {
 969         g_assert (IS_MONOTYPE (obj));
 970
 971         return (MonoReflectionType*)obj;
 972 }
 973
 974 /*
 975  * The following structure must match the C# implementation in our corlib.
 976  */
 977
 978 struct _MonoReflectionMethod {
 979         MonoObject object;
 980         MonoMethod *method;
 981         MonoString *name;
 982         MonoReflectionType *reftype;
 983 };
 984
 985 /* Safely access System.Reflection.MonoMethod from native code */
 986 TYPED_HANDLE_DECL (MonoReflectionMethod);
 987
 988 struct _MonoDelegate {
 989         MonoObject object;
 990         /* The compiled code of the target method */
 991         gpointer method_ptr;
 992         /* The invoke code */
 993         gpointer invoke_impl;
 994         MonoObject *target;
 995         MonoMethod *method;
 996         gpointer delegate_trampoline;
 997         /* Extra argument passed to the target method in llvmonly mode */
 998         gpointer extra_arg;
 999         /*
1000          * If non-NULL, this points to a memory location which stores the address of
1001          * the compiled code of the method, or NULL if it is not yet compiled.
1002          */
1003         guint8 **method_code;
1004         gpointer interp_method;
1005         /* Interp method that is executed when invoking the delegate */
1006         gpointer interp_invoke_impl;
1007         MonoReflectionMethod *method_info;
1008         MonoReflectionMethod *original_method_info;
1009         MonoObject *data;
1010         MonoBoolean method_is_virtual;
1011 };
1012
1013 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
1014 struct _MonoMulticastDelegate {
1015         MonoDelegate delegate;
1016         MonoArray *delegates;
1017 };
1018
1019 /* Safely access System.MulticastDelegate from native code */
1020 TYPED_HANDLE_DECL (MonoMulticastDelegate);
1021
1022 struct _MonoReflectionField {
1023         MonoObject object;
1024         MonoClass *klass;
1025         MonoClassField *field;
1026         MonoString *name;
1027         MonoReflectionType *type;
1028         guint32 attrs;
1029 };
1030
1031 /* Safely access System.Reflection.MonoField from native code */
1032 TYPED_HANDLE_DECL (MonoReflectionField);
1033
1034 struct _MonoReflectionProperty {
1035         MonoObject object;
1036         MonoClass *klass;
1037         MonoProperty *property;
1038 };
1039
1040 /* Safely access System.Reflection.MonoProperty from native code */
1041 TYPED_HANDLE_DECL (MonoReflectionProperty);
1042
1043 /*This is System.EventInfo*/
1044 struct _MonoReflectionEvent {
1045         MonoObject object;
1046 #ifndef ENABLE_NETCORE
1047         MonoObject *cached_add_event;
1048 #endif
1049 };
1050
1051 /* Safely access System.Reflection.EventInfo from native code */
1052 TYPED_HANDLE_DECL (MonoReflectionEvent);
1053
1054 typedef struct {
1055         MonoReflectionEvent object;
1056         MonoClass *klass;
1057         MonoEvent *event;
1058 } MonoReflectionMonoEvent;
1059
1060 /* Safely access Systme.Reflection.MonoEvent from native code */
1061 TYPED_HANDLE_DECL (MonoReflectionMonoEvent);
1062
1063 typedef struct {
1064         MonoObject object;
1065 } MonoReflectionParameter;
1066
1067 /* Safely access System.Reflection.ParameterInfo from native code */
1068 TYPED_HANDLE_DECL (MonoReflectionParameter);
1069
1070 struct _MonoReflectionMethodBody {
1071         MonoObject object;
1072 };
1073
1074 /* Safely access System.Reflection.MethodBody from native code */
1075 TYPED_HANDLE_DECL (MonoReflectionMethodBody);
1076
1077 /* System.RuntimeAssembly */
1078 struct _MonoReflectionAssembly {
1079         MonoObject object;
1080         MonoAssembly *assembly;
1081         /* CAS related */
1082         MonoObject *evidence;   /* Evidence */
1083 };
1084
1085 typedef struct {
1086         MonoReflectionType *utype;
1087         MonoArray *values;
1088         MonoArray *names;
1089 } MonoEnumInfo;
1090
1091 typedef struct {
1092         MonoReflectionType *parent;
1093         MonoReflectionType *ret;
1094         guint32 attrs;
1095         guint32 implattrs;
1096         guint32 callconv;
1097 } MonoMethodInfo;
1098
1099 typedef struct {
1100         MonoReflectionType *parent;
1101         MonoReflectionType *declaring_type;
1102         MonoString *name;
1103         MonoReflectionMethod *get;
1104         MonoReflectionMethod *set;
1105         guint32 attrs;
1106 } MonoPropertyInfo;
1107
1108 typedef struct {
1109         MonoReflectionType *declaring_type;
1110         MonoReflectionType *reflected_type;
1111         MonoString *name;
1112         MonoReflectionMethod *add_method;
1113         MonoReflectionMethod *remove_method;
1114         MonoReflectionMethod *raise_method;
1115         guint32 attrs;
1116         MonoArray *other_methods;
1117 } MonoEventInfo;
1118
1119 typedef struct {
1120         MonoString *name;
1121         MonoString *name_space;
1122         MonoReflectionType *etype;
1123         MonoReflectionType *nested_in;
1124         MonoReflectionAssembly *assembly;
1125         guint32 rank;
1126         MonoBoolean isprimitive;
1127 } MonoTypeInfo;
1128
1129 typedef struct {
1130         MonoObject *member;
1131         gint32 code_pos;
1132 } MonoReflectionILTokenInfo;
1133
1134 typedef struct {
1135         MonoObject object;
1136         MonoArray *code;
1137         gint32 code_len;
1138         gint32 max_stack;
1139         gint32 cur_stack;
1140         MonoArray *locals;
1141         MonoArray *ex_handlers;
1142         gint32 num_token_fixups;
1143         MonoArray *token_fixups;
1144 } MonoReflectionILGen;
1145
1146 typedef struct {
1147         MonoArray *handlers;
1148         gint32 start;
1149         gint32 len;
1150         gint32 label;
1151 } MonoILExceptionInfo;
1152
1153 typedef struct {
1154         MonoObject *extype;
1155         gint32 type;
1156         gint32 start;
1157         gint32 len;
1158         gint32 filter_offset;
1159 } MonoILExceptionBlock;
1160
1161 typedef struct {
1162         MonoObject object;
1163         MonoObject *catch_type;
1164         gint32 filter_offset;
1165         gint32 flags;
1166         gint32 try_offset;
1167         gint32 try_length;
1168         gint32 handler_offset;
1169         gint32 handler_length;
1170 } MonoReflectionExceptionHandlingClause;
1171
1172
1173 /* Safely access System.Reflection.ExceptionHandlingClause from native code */
1174 TYPED_HANDLE_DECL (MonoReflectionExceptionHandlingClause);
1175
1176 typedef struct {
1177         MonoObject object;
1178         MonoReflectionType *local_type;
1179         MonoBoolean is_pinned;
1180         guint16 local_index;
1181 } MonoReflectionLocalVariableInfo;
1182
1183 /* Safely access System.Reflection.LocalVariableInfo from native code */
1184 TYPED_HANDLE_DECL (MonoReflectionLocalVariableInfo);
1185
1186 typedef struct {
1187         /*
1188          * Must have the same layout as MonoReflectionLocalVariableInfo, since
1189          * LocalBuilder inherits from it under net 2.0.
1190          */
1191         MonoObject object;
1192         MonoObject *type;
1193         MonoBoolean is_pinned;
1194         guint16 local_index;
1195         MonoString *name;
1196 } MonoReflectionLocalBuilder;
1197
1198 typedef struct {
1199         MonoObject object;
1200         gint32 count;
1201         gint32 type;
1202         gint32 eltype;
1203         MonoString *guid;
1204         MonoString *mcookie;
1205         MonoString *marshaltype;
1206         MonoObject *marshaltyperef;
1207         gint32 param_num;
1208         MonoBoolean has_size;
1209 } MonoReflectionMarshal;
1210
1211 typedef struct {
1212         MonoObject object;
1213         MonoObject* methodb;
1214         MonoString *name;
1215         MonoArray *cattrs;
1216         MonoReflectionMarshal *marshal_info;
1217         guint32 attrs;
1218         int position;
1219         guint32 table_idx;
1220         MonoObject *def_value;
1221 } MonoReflectionParamBuilder;
1222
1223 typedef struct {
1224         MonoObject object;
1225         MonoMethod *mhandle;
1226         MonoReflectionILGen *ilgen;
1227         MonoArray *parameters;
1228         guint32 attrs;
1229         guint32 iattrs;
1230         guint32 table_idx;
1231         guint32 call_conv;
1232         MonoObject *type;
1233         MonoArray *pinfo;
1234         MonoArray *cattrs;
1235         MonoBoolean init_locals;
1236         MonoArray *param_modreq;
1237         MonoArray *param_modopt;
1238         MonoArray *permissions;
1239 } MonoReflectionCtorBuilder;
1240
1241 /* Safely access System.Reflection.Emit.ConstructorBuilder from native code */
1242 TYPED_HANDLE_DECL (MonoReflectionCtorBuilder);
1243
1244 typedef struct {
1245         MonoObject object;
1246         MonoMethod *mhandle;
1247         MonoObject *rtype;
1248         MonoArray *parameters;
1249         guint32 attrs;
1250         guint32 iattrs;
1251         MonoString *name;
1252         guint32 table_idx;
1253         MonoArray *code;
1254         MonoReflectionILGen *ilgen;
1255         MonoObject *type;
1256         MonoArray *pinfo;
1257         MonoArray *cattrs;
1258         MonoArray *override_methods;
1259         MonoString *dll;
1260         MonoString *dllentry;
1261         guint32 charset;
1262         guint32 extra_flags;
1263         guint32 native_cc;
1264         guint32 call_conv;
1265         MonoBoolean init_locals;
1266         MonoGenericContainer *generic_container;
1267         MonoArray *generic_params;
1268         MonoArray *return_modreq;
1269         MonoArray *return_modopt;
1270         MonoArray *param_modreq;
1271         MonoArray *param_modopt;
1272         MonoArray *permissions;
1273 } MonoReflectionMethodBuilder;
1274
1275 /* Safely access System.Reflection.Emit.MethodBuilder from native code */
1276 TYPED_HANDLE_DECL (MonoReflectionMethodBuilder);
1277
1278 typedef struct {
1279         MonoObject object;
1280         MonoMethod *mhandle;
1281         MonoReflectionType *parent;
1282         MonoReflectionType *ret;
1283         MonoArray *parameters;
1284         MonoString *name;
1285         guint32 table_idx;
1286         guint32 call_conv;
1287 } MonoReflectionArrayMethod;
1288
1289 /* Safely access System.Reflection.Emit.MonoArrayMethod from native code */
1290 TYPED_HANDLE_DECL (MonoReflectionArrayMethod);
1291
1292 typedef struct {
1293         MonoArray *data;
1294         MonoString *name;
1295         MonoString *filename;
1296         guint32 attrs;
1297         guint32 offset;
1298         MonoObject *stream;
1299 } MonoReflectionResource;
1300
1301 typedef struct {
1302         guint32 res_type;
1303         guint32 res_id;
1304         guint32 lang_id;
1305         MonoArray *res_data;
1306 } MonoReflectionWin32Resource;
1307
1308 typedef struct {
1309         guint32 action;
1310         MonoString *pset;
1311 } MonoReflectionPermissionSet;
1312
1313 typedef struct {
1314         MonoReflectionAssembly assembly;
1315         MonoDynamicAssembly *dynamic_assembly;
1316         MonoReflectionMethod *entry_point;
1317         MonoArray *modules;
1318         MonoString *name;
1319         MonoString *dir;
1320         MonoArray *cattrs;
1321         MonoArray *resources;
1322         MonoArray *public_key;
1323         MonoString *version;
1324         MonoString *culture;
1325         guint32 algid;
1326         guint32 flags;
1327         guint32 pekind;
1328         MonoBoolean delay_sign;
1329         guint32 access;
1330         MonoArray *loaded_modules;
1331         MonoArray *win32_resources;
1332         /* CAS related */
1333         MonoArray *permissions_minimum;
1334         MonoArray *permissions_optional;
1335         MonoArray *permissions_refused;
1336         gint32 pe_kind;
1337         gint32 machine;
1338         MonoBoolean corlib_internal;
1339         MonoArray *type_forwarders;
1340         MonoArray *pktoken; /* as hexadecimal byte[] */
1341 } MonoReflectionAssemblyBuilder;
1342
1343 /* Safely access System.Reflection.Emit.AssemblyBuilder from native code */
1344 TYPED_HANDLE_DECL (MonoReflectionAssemblyBuilder);
1345
1346 typedef struct {
1347         MonoObject object;
1348         guint32 attrs;
1349         MonoObject *type;
1350         MonoString *name;
1351         MonoObject *def_value;
1352         gint32 offset;
1353         MonoReflectionType *typeb;
1354         MonoArray *rva_data;
1355         MonoArray *cattrs;
1356         MonoReflectionMarshal *marshal_info;
1357         MonoClassField *handle;
1358         MonoArray *modreq;
1359         MonoArray *modopt;
1360 } MonoReflectionFieldBuilder;
1361
1362 /* Safely access System.Reflection.Emit.FieldBuilder from native code */
1363 TYPED_HANDLE_DECL (MonoReflectionFieldBuilder);
1364
1365 typedef struct {
1366         MonoObject object;
1367         guint32 attrs;
1368         MonoString *name;
1369         MonoObject *type;
1370         MonoArray *parameters;
1371         MonoArray *cattrs;
1372         MonoObject *def_value;
1373         MonoReflectionMethodBuilder *set_method;
1374         MonoReflectionMethodBuilder *get_method;
1375         gint32 table_idx;
1376         MonoObject *type_builder;
1377         MonoArray *returnModReq;
1378         MonoArray *returnModOpt;
1379         MonoArray *paramModReq;
1380         MonoArray *paramModOpt;
1381         guint32 call_conv;
1382 } MonoReflectionPropertyBuilder;
1383
1384 /* System.RuntimeModule */
1385 struct _MonoReflectionModule {
1386         MonoObject      obj;
1387         MonoImage  *image;
1388         MonoReflectionAssembly *assembly;
1389         MonoString *fqname;
1390         MonoString *name;
1391         MonoString *scopename;
1392         MonoBoolean is_resource;
1393         guint32 token;
1394 };
1395
1396 /* Safely access System.Reflection.Module from native code */
1397 TYPED_HANDLE_DECL (MonoReflectionModule);
1398
1399 typedef struct {
1400         MonoReflectionModule module;
1401         MonoDynamicImage *dynamic_image;
1402         gint32     num_types;
1403         MonoArray *types;
1404         MonoArray *cattrs;
1405         MonoArray *guid;
1406         guint32    table_idx;
1407         MonoReflectionAssemblyBuilder *assemblyb;
1408         MonoArray *global_methods;
1409         MonoArray *global_fields;
1410         gboolean is_main;
1411         MonoArray *resources;
1412         GHashTable *unparented_classes;
1413         MonoArray *table_indexes;
1414 } MonoReflectionModuleBuilder;
1415
1416 /* Safely acess System.Reflection.Emit.ModuleBuidler from native code */
1417 TYPED_HANDLE_DECL (MonoReflectionModuleBuilder);
1418
1419 typedef enum {
1420         MonoTypeBuilderNew = 0,
1421         MonoTypeBuilderEntered = 1,
1422         MonoTypeBuilderFinished = 2
1423 } MonoTypeBuilderState;
1424
1425 struct _MonoReflectionTypeBuilder {
1426         MonoReflectionType type;
1427         MonoString *name;
1428         MonoString *nspace;
1429         MonoObject *parent;
1430         MonoReflectionType *nesting_type;
1431         MonoArray *interfaces;
1432         gint32     num_methods;
1433         MonoArray *methods;
1434         MonoArray *ctors;
1435         MonoArray *properties;
1436         gint32     num_fields;
1437         MonoArray *fields;
1438         MonoArray *events;
1439         MonoArray *cattrs;
1440         MonoArray *subtypes;
1441         guint32 attrs;
1442         guint32 table_idx;
1443         MonoReflectionModuleBuilder *module;
1444         gint32 class_size;
1445         gint32 packing_size;
1446         MonoGenericContainer *generic_container;
1447         MonoArray *generic_params;
1448         MonoArray *permissions;
1449         MonoReflectionType *created;
1450         gint32 state;
1451 };
1452
1453 typedef struct {
1454         MonoReflectionType type;
1455         MonoReflectionType *element_type;
1456         gint32 rank;
1457 } MonoReflectionArrayType;
1458
1459 /* Safely access System.Reflection.Emit.ArrayType (in DerivedTypes.cs) from native code */
1460 TYPED_HANDLE_DECL (MonoReflectionArrayType);
1461
1462 typedef struct {
1463         MonoReflectionType type;
1464         MonoReflectionType *element_type;
1465 } MonoReflectionDerivedType;
1466
1467 /* Safely access System.Reflection.Emit.SymbolType and subclasses (in DerivedTypes.cs) from native code */
1468 TYPED_HANDLE_DECL (MonoReflectionDerivedType);
1469
1470 typedef struct {
1471         MonoReflectionType type;
1472         MonoReflectionTypeBuilder *tbuilder;
1473         MonoReflectionMethodBuilder *mbuilder;
1474         MonoString *name;
1475         guint32 index;
1476         MonoReflectionType *base_type;
1477         MonoArray *iface_constraints;
1478         MonoArray *cattrs;
1479         guint32 attrs;
1480 } MonoReflectionGenericParam;
1481
1482 /* Safely access System.Reflection.Emit.GenericTypeParameterBuilder from native code */
1483 TYPED_HANDLE_DECL (MonoReflectionGenericParam);
1484
1485 typedef struct {
1486         MonoReflectionType type;
1487         MonoReflectionTypeBuilder *tb;
1488 } MonoReflectionEnumBuilder;
1489
1490 /* Safely access System.Reflection.Emit.EnumBuilder from native code */
1491 TYPED_HANDLE_DECL (MonoReflectionEnumBuilder);
1492
1493 typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass;
1494 struct _MonoReflectionGenericClass {
1495         MonoReflectionType type;
1496         MonoReflectionType *generic_type; /*Can be either a MonoType or a TypeBuilder*/
1497         MonoArray *type_arguments;
1498 };
1499
1500 /* Safely access System.Reflection.Emit.TypeBuilderInstantiation from native code */
1501 TYPED_HANDLE_DECL (MonoReflectionGenericClass);
1502
1503 typedef struct {
1504         MonoObject  obj;
1505         MonoString *name;
1506         MonoString *codebase;
1507         gint32 major, minor, build, revision;
1508         MonoObject  *cultureInfo;
1509         guint32     flags;
1510         guint32     hashalg;
1511         MonoObject  *keypair;
1512         MonoArray   *publicKey;
1513         MonoArray   *keyToken;
1514         guint32     versioncompat;
1515         MonoObject *version;
1516         guint32     processor_architecture;
1517 } MonoReflectionAssemblyName;
1518
1519 /* Safely access System.Reflection.AssemblyName from native code */
1520 TYPED_HANDLE_DECL (MonoReflectionAssemblyName);
1521
1522 typedef struct {
1523         MonoObject  obj;
1524         MonoString *name;
1525         MonoReflectionType *type;
1526         MonoReflectionTypeBuilder *typeb;
1527         MonoArray *cattrs;
1528         MonoReflectionMethodBuilder *add_method;
1529         MonoReflectionMethodBuilder *remove_method;
1530         MonoReflectionMethodBuilder *raise_method;
1531         MonoArray *other_methods;
1532         guint32 attrs;
1533         guint32 table_idx;
1534 } MonoReflectionEventBuilder;
1535
1536 typedef struct {
1537         MonoObject  obj;
1538         MonoReflectionMethod *ctor;
1539         MonoArray *data;
1540 } MonoReflectionCustomAttr;
1541
1542 TYPED_HANDLE_DECL (MonoReflectionCustomAttr);
1543
1544 #if ENABLE_NETCORE
1545 typedef struct {
1546         MonoObject object;
1547         guint32 utype;
1548         gint32 safe_array_subtype;
1549         MonoReflectionType *marshal_safe_array_user_defined_subtype;
1550         gint32 IidParameterIndex;
1551         guint32 array_subtype;
1552         gint16 size_param_index;
1553         gint32 size_const;
1554         MonoString *marshal_type;
1555         MonoReflectionType *marshal_type_ref;
1556         MonoString *marshal_cookie;
1557 } MonoReflectionMarshalAsAttribute;
1558 #else
1559 typedef struct {
1560         MonoObject object;
1561         MonoString *marshal_cookie;
1562         MonoString *marshal_type;
1563         MonoReflectionType *marshal_type_ref;
1564         MonoReflectionType *marshal_safe_array_user_defined_subtype;
1565         guint32 utype;
1566         guint32 array_subtype;
1567         gint32 safe_array_subtype;
1568         gint32 size_const;
1569         gint32 IidParameterIndex;
1570         gint16 size_param_index;
1571 } MonoReflectionMarshalAsAttribute;
1572 #endif
1573
1574 /* Safely access System.Runtime.InteropServices.MarshalAsAttribute */
1575 TYPED_HANDLE_DECL (MonoReflectionMarshalAsAttribute);
1576
1577 typedef struct {
1578         MonoObject object;
1579         gint32 call_conv;
1580         gint32 charset;
1581         MonoBoolean best_fit_mapping;
1582         MonoBoolean throw_on_unmappable;
1583         MonoBoolean set_last_error;
1584 } MonoReflectionUnmanagedFunctionPointerAttribute;
1585
1586 typedef struct {
1587         MonoObject object;
1588         MonoString *guid;
1589 } MonoReflectionGuidAttribute;
1590
1591 typedef struct {
1592         MonoObject object;
1593         MonoMethod *mhandle;
1594         MonoString *name;
1595         MonoReflectionType *rtype;
1596         MonoArray *parameters;
1597         guint32 attrs;
1598         guint32 call_conv;
1599         MonoReflectionModule *module;
1600         MonoBoolean skip_visibility;
1601         MonoBoolean init_locals;
1602         MonoReflectionILGen *ilgen;
1603         gint32 nrefs;
1604         MonoArray *refs;
1605         GSList *referenced_by;
1606         MonoReflectionType *owner;
1607 } MonoReflectionDynamicMethod;
1608
1609 /* Safely access System.Reflection.Emit.DynamicMethod from native code */
1610 TYPED_HANDLE_DECL (MonoReflectionDynamicMethod);
1611
1612 typedef struct {
1613         MonoObject object;
1614         MonoReflectionModuleBuilder *module;
1615         MonoArray *arguments;
1616         guint32 type;
1617         MonoReflectionType *return_type;
1618         guint32 call_conv;
1619         guint32 unmanaged_call_conv;
1620         MonoArray *modreqs;
1621         MonoArray *modopts;
1622 } MonoReflectionSigHelper;
1623
1624 /* Safely access System.Reflection.Emit.SignatureHelper from native code */
1625 TYPED_HANDLE_DECL (MonoReflectionSigHelper);
1626
1627 typedef struct {
1628         MonoObject object;
1629         MonoBoolean visible;
1630 } MonoReflectionComVisibleAttribute;
1631
1632 typedef struct {
1633         MonoObject object;
1634         MonoReflectionType *type;
1635 } MonoReflectionComDefaultInterfaceAttribute;
1636
1637 enum {
1638         RESOURCE_LOCATION_EMBEDDED = 1,
1639         RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
1640         RESOURCE_LOCATION_IN_MANIFEST = 4
1641 };
1642
1643 typedef struct {
1644         MonoObject object;
1645         MonoReflectionAssembly *assembly;
1646         MonoString *filename;
1647         guint32 location;
1648 } MonoManifestResourceInfo;
1649
1650 /* Safely access System.Reflection.ManifestResourceInfo from native code */
1651 TYPED_HANDLE_DECL (MonoManifestResourceInfo);
1652
1653 /* A boxed IntPtr */
1654 typedef struct {
1655         MonoObject object;
1656         gpointer m_value;
1657 } MonoIntPtr;
1658
1659 /* Keep in sync with System.GenericParameterAttributes */
1660 typedef enum {
1661         GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT         = 0,
1662         GENERIC_PARAMETER_ATTRIBUTE_COVARIANT           = 1,
1663         GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT       = 2,
1664         GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK       = 3,
1665
1666         GENERIC_PARAMETER_ATTRIBUTE_NO_SPECIAL_CONSTRAINT       = 0,
1667         GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT   = 4,
1668         GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT       = 8,
1669         GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT      = 16,
1670         GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK    = 28
1671 } GenericParameterAttributes;
1672
1673 typedef struct {
1674         MonoType *type;
1675         MonoClassField *field;
1676         MonoProperty *prop;
1677 } CattrNamedArg;
1678
1679 /* All MonoInternalThread instances should be pinned, so it's safe to use the raw ptr.  However
1680  * for uniformity, icall wrapping will make handles anyway.  So this is the method for getting the payload.
1681  */
1682 static inline MonoInternalThread*
1683 mono_internal_thread_handle_ptr (MonoInternalThreadHandle h)
1684 {
1685         /* The SUPPRESS here prevents a Centrinel warning due to merely seeing this
1686          * function definition.  Callees will still get a warning unless we
1687          * attach a suppress attribute to the declaration.
1688          */
1689         return MONO_HANDLE_SUPPRESS (MONO_HANDLE_RAW (h));
1690 }
1691
1692 gboolean          mono_image_create_pefile (MonoReflectionModuleBuilder *module, gpointer file, MonoError *error);
1693 guint32       mono_image_insert_string (MonoReflectionModuleBuilderHandle module, MonoStringHandle str, MonoError *error);
1694 guint32       mono_image_create_token  (MonoDynamicImage *assembly, MonoObjectHandle obj, gboolean create_methodspec, gboolean register_token, MonoError *error);
1695 void          mono_dynamic_image_free (MonoDynamicImage *image);
1696 void          mono_dynamic_image_free_image (MonoDynamicImage *image);
1697 void          mono_dynamic_image_release_gc_roots (MonoDynamicImage *image);
1698
1699 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb);
1700
1701 void        mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides, MonoError *error);
1702
1703 void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod *mb);
1704
1705 ICALL_EXPORT
1706 void
1707 ves_icall_SymbolType_create_unmanaged_type (MonoReflectionType *type);
1708
1709 void        mono_reflection_register_with_runtime (MonoReflectionType *type);
1710
1711 MonoMethodSignature * mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token, MonoError *error);
1712
1713 MonoArrayHandle mono_param_get_objects_internal  (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error);
1714
1715 MonoClass*
1716 mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic);
1717 MonoType*
1718 mono_reflection_bind_generic_parameters (MonoReflectionTypeHandle type, int type_argc, MonoType **types, MonoError *error);
1719 void
1720 mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields);
1721
1722 ICALL_EXPORT
1723 MonoReflectionEvent *
1724 ves_icall_TypeBuilder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb);
1725
1726 MonoReflectionMarshalAsAttributeHandle
1727 mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec, MonoError *error);
1728
1729 gpointer
1730 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context, MonoError *error);
1731
1732 gboolean
1733 mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass, MonoError *error);
1734
1735 gboolean
1736 mono_image_build_metadata (MonoReflectionModuleBuilder *module, MonoError *error);
1737
1738 int
1739 mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value, MonoError *error);
1740
1741 gboolean
1742 mono_metadata_read_constant_value (const char *blob, MonoTypeEnum type, void *value, MonoError *error);
1743
1744 char*
1745 mono_string_from_blob (const char *str, MonoError *error);
1746
1747 void
1748 mono_release_type_locks (MonoInternalThread *thread);
1749
1750 /**
1751  * mono_string_handle_length:
1752  * \param s \c MonoString
1753  * \returns the length in characters of the string
1754  */
1755 #ifdef ENABLE_CHECKED_BUILD_GC
1756
1757 int
1758 mono_string_handle_length (MonoStringHandle s);
1759
1760 #else
1761
1762 #define mono_string_handle_length(s) (MONO_HANDLE_GETVAL ((s), length))
1763
1764 #endif
1765
1766 char *
1767 mono_string_handle_to_utf8 (MonoStringHandle s, MonoError *error);
1768
1769 char *
1770 mono_string_to_utf8_image (MonoImage *image, MonoStringHandle s, MonoError *error);
1771
1772 MonoArrayHandle
1773 mono_array_clone_in_domain (MonoDomain *domain, MonoArrayHandle array, MonoError *error);
1774
1775 MonoArray*
1776 mono_array_clone_checked (MonoArray *array, MonoError *error);
1777
1778 void
1779 mono_array_full_copy (MonoArray *src, MonoArray *dest);
1780
1781 gboolean
1782 mono_array_calc_byte_len (MonoClass *klass, uintptr_t len, uintptr_t *res);
1783
1784 MonoArray*
1785 mono_array_new_checked (MonoDomain *domain, MonoClass *eclass, uintptr_t n, MonoError *error);
1786
1787 MonoArray*
1788 mono_array_new_full_checked (MonoDomain *domain, MonoClass *array_class, uintptr_t *lengths, intptr_t *lower_bounds, MonoError *error);
1789
1790 MonoArray*
1791 mono_array_new_specific_checked (MonoVTable *vtable, uintptr_t n, MonoError *error);
1792
1793 MonoArrayHandle
1794 mono_array_new_specific_handle (MonoVTable *vtable, uintptr_t n, MonoError *error);
1795
1796 ICALL_EXPORT
1797 MonoArray*
1798 ves_icall_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n);
1799
1800 ICALL_EXPORT
1801 MonoArray*
1802 ves_icall_array_new_specific (MonoVTable *vtable, uintptr_t n);
1803
1804 #ifndef DISABLE_REMOTING
1805 MonoRemoteClass*
1806 mono_remote_class (MonoDomain *domain, MonoStringHandle class_name, MonoClass *proxy_class, MonoError *error);
1807
1808 gboolean
1809 mono_remote_class_is_interface_proxy (MonoRemoteClass *remote_class);
1810
1811 MonoObject *
1812 mono_remoting_invoke (MonoObject *real_proxy, MonoMethodMessage *msg, MonoObject **exc, MonoArray **out_args, MonoError *error);
1813
1814 gpointer
1815 mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxyHandle real_proxy, MonoError *error);
1816
1817 gboolean
1818 mono_upgrade_remote_class (MonoDomain *domain, MonoObjectHandle tproxy, MonoClass *klass, MonoError *error);
1819
1820 void*
1821 mono_load_remote_field_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void **res, MonoError *error);
1822
1823 MonoObject *
1824 mono_load_remote_field_new_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoError *error);
1825
1826 gboolean
1827 mono_store_remote_field_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void* val, MonoError *error);
1828
1829 gboolean
1830 mono_store_remote_field_new_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg, MonoError *error);
1831
1832
1833 #endif
1834
1835 gpointer
1836 mono_create_ftnptr (MonoDomain *domain, gpointer addr);
1837
1838 gpointer
1839 mono_get_addr_from_ftnptr (gpointer descr);
1840
1841 void
1842 mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass);
1843
1844 void
1845 mono_nullable_init_from_handle (guint8 *buf, MonoObjectHandle value, MonoClass *klass);
1846
1847 void
1848 mono_nullable_init_unboxed (guint8 *buf, gpointer value, MonoClass *klass);
1849
1850 MonoObject *
1851 mono_value_box_checked (MonoDomain *domain, MonoClass *klass, void* val, MonoError *error);
1852
1853 MonoObjectHandle
1854 mono_value_box_handle (MonoDomain *domain, MonoClass *klass, gpointer val, MonoError *error);
1855
1856 MonoObject*
1857 mono_nullable_box (gpointer buf, MonoClass *klass, MonoError *error);
1858
1859 MonoObjectHandle
1860 mono_nullable_box_handle (gpointer buf, MonoClass *klass, MonoError *error);
1861
1862 // A code size optimization (source and object) equivalent to MONO_HANDLE_NEW (MonoObject, NULL);
1863 MonoObjectHandle
1864 mono_new_null (void);
1865
1866 #ifdef MONO_SMALL_CONFIG
1867 #define MONO_IMT_SIZE 9
1868 #else
1869 #define MONO_IMT_SIZE 19
1870 #endif
1871
1872 typedef union {
1873         int vtable_slot;
1874         gpointer target_code;
1875 } MonoImtItemValue;
1876
1877 typedef struct _MonoImtBuilderEntry {
1878         gpointer key;
1879         struct _MonoImtBuilderEntry *next;
1880         MonoImtItemValue value;
1881         int children;
1882         guint8 has_target_code : 1;
1883 } MonoImtBuilderEntry;
1884
1885 typedef struct _MonoIMTCheckItem MonoIMTCheckItem;
1886
1887 struct _MonoIMTCheckItem {
1888         gpointer          key;
1889         int               check_target_idx;
1890         MonoImtItemValue  value;
1891         guint8           *jmp_code;
1892         guint8           *code_target;
1893         guint8            is_equals;
1894         guint8            compare_done;
1895         guint8            chunk_size;
1896         guint8            short_branch;
1897         guint8            has_target_code;
1898 };
1899
1900 typedef gpointer (*MonoImtTrampolineBuilder) (MonoVTable *vtable, MonoDomain *domain,
1901                 MonoIMTCheckItem **imt_entries, int count, gpointer fail_trunk);
1902
1903 void
1904 mono_install_imt_trampoline_builder (MonoImtTrampolineBuilder func);
1905
1906 void
1907 mono_set_always_build_imt_trampolines (gboolean value);
1908
1909 void
1910 mono_vtable_build_imt_slot (MonoVTable* vtable, int imt_slot);
1911
1912 guint32
1913 mono_method_get_imt_slot (MonoMethod *method);
1914
1915 void
1916 mono_method_add_generic_virtual_invocation (MonoDomain *domain, MonoVTable *vtable,
1917                                                                                         gpointer *vtable_slot,
1918                                                                                         MonoMethod *method, gpointer code);
1919
1920 gpointer
1921 mono_method_alloc_generic_virtual_trampoline (MonoDomain *domain, int size);
1922
1923 #define mono_method_alloc_generic_virtual_trampoline(domain, size) (g_cast (mono_method_alloc_generic_virtual_trampoline ((domain), (size))))
1924
1925 typedef enum {
1926         MONO_UNHANDLED_POLICY_LEGACY,
1927         MONO_UNHANDLED_POLICY_CURRENT
1928 } MonoRuntimeUnhandledExceptionPolicy;
1929
1930 MonoRuntimeUnhandledExceptionPolicy
1931 mono_runtime_unhandled_exception_policy_get (void);
1932 void
1933 mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy);
1934
1935 void
1936 mono_unhandled_exception_checked (MonoObjectHandle exc, MonoError *error);
1937
1938 MonoVTable *
1939 mono_class_try_get_vtable (MonoDomain *domain, MonoClass *klass);
1940
1941 gboolean
1942 mono_runtime_run_module_cctor (MonoImage *image, MonoDomain *domain, MonoError *error);
1943
1944 gboolean
1945 mono_runtime_class_init_full (MonoVTable *vtable, MonoError *error);
1946
1947 void
1948 mono_method_clear_object (MonoDomain *domain, MonoMethod *method);
1949
1950 gsize*
1951 mono_class_compute_bitmap (MonoClass *klass, gsize *bitmap, int size, int offset, int *max_set, gboolean static_fields);
1952
1953 MonoObjectHandle
1954 mono_object_xdomain_representation (MonoObjectHandle obj, MonoDomain *target_domain, MonoError *error);
1955
1956 gboolean
1957 mono_class_is_reflection_method_or_constructor (MonoClass *klass);
1958
1959 MonoObject *
1960 mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob, MonoError *error);
1961
1962 gboolean
1963 mono_class_has_ref_info (MonoClass *klass);
1964
1965 MonoReflectionTypeBuilder*
1966 mono_class_get_ref_info_raw (MonoClass *klass);
1967
1968 void
1969 mono_class_set_ref_info (MonoClass *klass, MonoObjectHandle obj);
1970
1971 void
1972 mono_class_free_ref_info (MonoClass *klass);
1973
1974 MonoObject *
1975 mono_object_new_pinned (MonoDomain *domain, MonoClass *klass, MonoError *error);
1976
1977 MonoObjectHandle
1978 mono_object_new_pinned_handle (MonoDomain *domain, MonoClass *klass, MonoError *error);
1979
1980 MonoObject *
1981 mono_object_new_specific_checked (MonoVTable *vtable, MonoError *error);
1982
1983 ICALL_EXPORT
1984 MonoObject *
1985 ves_icall_object_new (MonoDomain *domain, MonoClass *klass);
1986
1987 ICALL_EXPORT
1988 MonoObject *
1989 ves_icall_object_new_specific (MonoVTable *vtable);
1990
1991 MonoObject *
1992 mono_object_new_alloc_specific_checked (MonoVTable *vtable, MonoError *error);
1993
1994 void
1995 mono_field_get_value_internal (MonoObject *obj, MonoClassField *field, void *value);
1996
1997 void
1998 mono_field_static_get_value_checked (MonoVTable *vt, MonoClassField *field, void *value, MonoError *error);
1999
2000 void
2001 mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value, MonoError *error);
2002
2003 MonoMethod*
2004 mono_object_handle_get_virtual_method (MonoObjectHandle obj, MonoMethod *method, MonoError *error);
2005
2006 /* exported, used by the debugger */
2007 MONO_API void *
2008 mono_vtable_get_static_field_data (MonoVTable *vt);
2009
2010 MonoObject *
2011 mono_field_get_value_object_checked (MonoDomain *domain, MonoClassField *field, MonoObject *obj, MonoError *error);
2012
2013 MonoObjectHandle
2014 mono_static_field_get_value_handle (MonoDomain *domain, MonoClassField *field, MonoError *error);
2015
2016 gboolean
2017 mono_property_set_value_handle (MonoProperty *prop, MonoObjectHandle obj, void **params, MonoError *error);
2018
2019 MonoObject*
2020 mono_property_get_value_checked (MonoProperty *prop, void *obj, void **params, MonoError *error);
2021
2022 MonoString*
2023 mono_object_try_to_string (MonoObject *obj, MonoObject **exc, MonoError *error);
2024
2025 char *
2026 mono_string_to_utf8_ignore (MonoString *s);
2027
2028 gboolean
2029 mono_monitor_is_il_fastpath_wrapper (MonoMethod *method);
2030
2031 MonoStringHandle
2032 mono_string_is_interned_lookup (MonoStringHandle str, gboolean insert, MonoError *error);
2033
2034 /**
2035  * mono_string_intern_checked:
2036  * \param str String to intern
2037  * \param error set on error.
2038  * Interns the string passed.
2039  * \returns The interned string. On failure returns NULL and sets \p error
2040  */
2041 #define mono_string_intern_checked(str, error) (mono_string_is_interned_lookup ((str), TRUE, (error)))
2042
2043 /**
2044  * mono_string_is_interned_internal:
2045  * \param o String to probe
2046  * \returns Whether the string has been interned.
2047  */
2048 #define mono_string_is_interned_internal(str, error) (mono_string_is_interned_lookup ((str), FALSE, (error)))
2049
2050 char *
2051 mono_exception_handle_get_native_backtrace (MonoExceptionHandle exc);
2052
2053 char *
2054 mono_exception_get_managed_backtrace (MonoException *exc);
2055
2056 void
2057 mono_copy_value (MonoType *type, void *dest, void *value, int deref_pointer);
2058
2059 void
2060 mono_error_raise_exception_deprecated (MonoError *target_error);
2061
2062 gboolean
2063 mono_error_set_pending_exception_slow (MonoError *error);
2064
2065 static inline gboolean
2066 mono_error_set_pending_exception (MonoError *error)
2067 {
2068         return is_ok (error) ? FALSE : mono_error_set_pending_exception_slow (error);
2069 }
2070
2071 MonoArray *
2072 mono_glist_to_array (GList *list, MonoClass *eclass, MonoError *error);
2073
2074 MonoObject *
2075 mono_object_new_checked (MonoDomain *domain, MonoClass *klass, MonoError *error);
2076
2077 MonoObjectHandle
2078 mono_object_new_handle (MonoDomain *domain, MonoClass *klass, MonoError *error);
2079
2080 // This function skips handling of remoting and COM.
2081 // "alloc" means "less".
2082 MonoObjectHandle
2083 mono_object_new_alloc_by_vtable (MonoVTable *vtable, MonoError *error);
2084
2085 MonoObject*
2086 mono_object_new_mature (MonoVTable *vtable, MonoError *error);
2087
2088 MonoObjectHandle
2089 mono_object_new_handle_mature (MonoVTable *vtable, MonoError *error);
2090
2091 MonoObject *
2092 mono_object_clone_checked (MonoObject *obj, MonoError *error);
2093
2094 MonoObjectHandle
2095 mono_object_clone_handle (MonoObjectHandle obj, MonoError *error);
2096
2097 MonoObject *
2098 mono_object_isinst_checked (MonoObject *obj, MonoClass *klass, MonoError *error);
2099
2100 MonoObjectHandle
2101 mono_object_handle_isinst (MonoObjectHandle obj, MonoClass *klass, MonoError *error);
2102
2103 MonoObjectHandle
2104 mono_object_handle_isinst_mbyref (MonoObjectHandle obj, MonoClass *klass, MonoError *error);
2105
2106 gboolean
2107 mono_object_handle_isinst_mbyref_raw (MonoObjectHandle obj, MonoClass *klass, MonoError *error);
2108
2109 MonoStringHandle
2110 mono_string_new_size_handle (MonoDomain *domain, gint32 len, MonoError *error);
2111
2112 MonoString*
2113 mono_string_new_len_checked (MonoDomain *domain, const char *text, guint length, MonoError *error);
2114
2115 MonoString *
2116 mono_string_new_size_checked (MonoDomain *domain, gint32 len, MonoError *error);
2117
2118 MonoString*
2119 mono_ldstr_checked (MonoDomain *domain, MonoImage *image, uint32_t str_index, MonoError *error);
2120
2121 MonoStringHandle
2122 mono_ldstr_handle (MonoDomain *domain, MonoImage *image, uint32_t str_index, MonoError *error);
2123
2124 MONO_PROFILER_API MonoString*
2125 mono_string_new_checked (MonoDomain *domain, const char *text, MonoError *merror);
2126
2127 MonoString*
2128 mono_string_new_wtf8_len_checked (MonoDomain *domain, const char *text, guint length, MonoError *error);
2129
2130 MonoString *
2131 mono_string_new_utf16_checked (MonoDomain *domain, const gunichar2 *text, gint32 len, MonoError *error);
2132
2133 MonoStringHandle
2134 mono_string_new_utf16_handle (MonoDomain *domain, const gunichar2 *text, gint32 len, MonoError *error);
2135
2136 MonoStringHandle
2137 mono_string_new_utf8_len (MonoDomain *domain, const char *text, guint length, MonoError *error);
2138
2139 MonoString *
2140 mono_string_from_utf16_checked (const mono_unichar2 *data, MonoError *error);
2141
2142 MonoString *
2143 mono_string_from_utf32_checked (const mono_unichar4 *data, MonoError *error);
2144
2145 char*
2146 mono_ldstr_utf8 (MonoImage *image, guint32 idx, MonoError *error);
2147
2148 char*
2149 mono_utf16_to_utf8 (const mono_unichar2 *s, gsize slength, MonoError *error);
2150
2151 char*
2152 mono_utf16_to_utf8len (const mono_unichar2 *s, gsize slength, gsize *utf8_length, MonoError *error);
2153
2154 gboolean
2155 mono_runtime_object_init_checked (MonoObject *this_obj, MonoError *error);
2156
2157 MONO_PROFILER_API MonoObject*
2158 mono_runtime_try_invoke (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError *error);
2159
2160 // The exc parameter is deliberately missing and so far this has proven to reduce code duplication.
2161 // In particular, if an exception is returned from underlying otherwise succeeded call,
2162 // is set into the MonoError with mono_error_set_exception_instance.
2163 // The result is that caller need only check MonoError.
2164 MonoObjectHandle
2165 mono_runtime_try_invoke_handle (MonoMethod *method, MonoObjectHandle obj, void **params, MonoError* error);
2166
2167 MonoObject*
2168 mono_runtime_invoke_checked (MonoMethod *method, void *obj, void **params, MonoError *error);
2169
2170 MonoObjectHandle
2171 mono_runtime_invoke_handle (MonoMethod *method, MonoObjectHandle obj, void **params, MonoError* error);
2172
2173 void
2174 mono_runtime_invoke_handle_void (MonoMethod *method, MonoObjectHandle obj, void **params, MonoError* error);
2175
2176 MonoObject*
2177 mono_runtime_try_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
2178                                MonoObject **exc, MonoError *error);
2179
2180 MonoObject*
2181 mono_runtime_invoke_array_checked (MonoMethod *method, void *obj, MonoArray *params,
2182                                    MonoError *error);
2183
2184 void*
2185 mono_compile_method_checked (MonoMethod *method, MonoError *error);
2186
2187 MonoObject*
2188 mono_runtime_delegate_try_invoke (MonoObject *delegate, void **params,
2189                                   MonoObject **exc, MonoError *error);
2190
2191 MonoObject*
2192 mono_runtime_delegate_invoke_checked (MonoObject *delegate, void **params,
2193                                       MonoError *error);
2194
2195 MonoArrayHandle
2196 mono_runtime_get_main_args_handle (MonoError *error);
2197
2198 int
2199 mono_runtime_run_main_checked (MonoMethod *method, int argc, char* argv[],
2200                                MonoError *error);
2201
2202 int
2203 mono_runtime_try_run_main (MonoMethod *method, int argc, char* argv[],
2204                            MonoObject **exc);
2205
2206 int
2207 mono_runtime_exec_main_checked (MonoMethod *method, MonoArray *args, MonoError *error);
2208
2209 int
2210 mono_runtime_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc);
2211
2212 MonoAssembly*
2213 mono_try_assembly_resolve_handle (MonoAssemblyLoadContext *alc, MonoStringHandle fname, MonoAssembly *requesting, gboolean refonly, MonoError *error);
2214
2215 gboolean
2216 mono_runtime_object_init_handle (MonoObjectHandle this_obj, MonoError *error);
2217
2218 /* GC write barriers support */
2219 void
2220 mono_gc_wbarrier_object_copy_handle (MonoObjectHandle obj, MonoObjectHandle src);
2221
2222 MonoMethod*
2223 mono_class_get_virtual_method (MonoClass *klass, MonoMethod *method, gboolean is_proxy, MonoError *error);
2224
2225 MonoStringHandle
2226 mono_string_empty_handle (MonoDomain *domain);
2227
2228 gpointer
2229 mono_object_get_data (MonoObject *o);
2230
2231 #define mono_handle_get_data_unsafe(handle) ((gpointer)((guint8*)MONO_HANDLE_RAW (handle) + MONO_ABI_SIZEOF (MonoObject)))
2232
2233 gpointer
2234 mono_vtype_get_field_addr (gpointer vtype, MonoClassField *field);
2235
2236 #define MONO_OBJECT_SETREF_INTERNAL(obj,fieldname,value) do {   \
2237                 mono_gc_wbarrier_set_field_internal ((MonoObject*)(obj), &((obj)->fieldname), (MonoObject*)value);      \
2238                 /*(obj)->fieldname = (value);*/ \
2239         } while (0)
2240
2241 /* This should be used if 's' can reside on the heap */
2242 #define MONO_STRUCT_SETREF_INTERNAL(s,field,value) do { \
2243         mono_gc_wbarrier_generic_store_internal (&((s)->field), (MonoObject*)(value)); \
2244     } while (0)
2245
2246 static inline gunichar2*
2247 mono_string_chars_internal (MonoString *s)
2248 {
2249         MONO_REQ_GC_UNSAFE_MODE;
2250         return s->chars;
2251 }
2252
2253 static inline int
2254 mono_string_length_internal (MonoString *s)
2255 {
2256         MONO_REQ_GC_UNSAFE_MODE;
2257         return s->length;
2258 }
2259
2260 MonoString*
2261 mono_string_empty_internal (MonoDomain *domain);
2262
2263 char *
2264 mono_string_to_utf8len (MonoStringHandle s, gsize *utf8len, MonoError *error);
2265
2266 char*
2267 mono_string_to_utf8_checked_internal (MonoString *string_obj, MonoError *error);
2268
2269 mono_bool
2270 mono_string_equal_internal (MonoString *s1, MonoString *s2);
2271
2272 unsigned
2273 mono_string_hash_internal (MonoString *s);
2274
2275 int
2276 mono_object_hash_internal (MonoObject* obj);
2277
2278 void
2279 mono_value_copy_internal (void* dest, const void* src, MonoClass *klass);
2280
2281 void
2282 mono_value_copy_array_internal (MonoArray *dest, int dest_idx, const void* src, int count);
2283
2284 MONO_PROFILER_API MonoVTable* mono_object_get_vtable_internal (MonoObject *obj);
2285
2286 MonoDomain*
2287 mono_object_get_domain_internal (MonoObject *obj);
2288
2289 void*
2290 mono_object_unbox_internal (MonoObject *obj);
2291
2292 ICALL_EXPORT
2293 void
2294 mono_monitor_exit_internal (MonoObject *obj);
2295
2296 MONO_PROFILER_API unsigned mono_object_get_size_internal (MonoObject *o);
2297
2298 MONO_PROFILER_API MonoDomain* mono_vtable_domain_internal (MonoVTable *vtable);
2299
2300 MONO_PROFILER_API MonoClass* mono_vtable_class_internal (MonoVTable *vtable);
2301
2302 MonoMethod*
2303 mono_object_get_virtual_method_internal (MonoObject *obj, MonoMethod *method);
2304
2305 MonoMethod*
2306 mono_get_delegate_invoke_internal (MonoClass *klass);
2307
2308 MonoMethod*
2309 mono_get_delegate_begin_invoke_internal (MonoClass *klass);
2310
2311 MonoMethod*
2312 mono_get_delegate_end_invoke_internal (MonoClass *klass);
2313
2314 void
2315 mono_unhandled_exception_internal (MonoObject *exc);
2316
2317 void
2318 mono_print_unhandled_exception_internal (MonoObject *exc);
2319
2320 void
2321 mono_raise_exception_internal (MonoException *ex);
2322
2323 void
2324 mono_field_set_value_internal (MonoObject *obj, MonoClassField *field, void *value);
2325
2326 void
2327 mono_field_static_set_value_internal (MonoVTable *vt, MonoClassField *field, void *value);
2328
2329 void
2330 mono_field_get_value_internal (MonoObject *obj, MonoClassField *field, void *value);
2331
2332 MonoMethod* mono_get_context_capture_method (void);
2333
2334 guint8*
2335 mono_runtime_get_aotid_arr (void);
2336
2337 /* GC handles support
2338  *
2339  * A handle can be created to refer to a managed object and either prevent it
2340  * from being garbage collected or moved or to be able to know if it has been
2341  * collected or not (weak references).
2342  * mono_gchandle_new () is used to prevent an object from being garbage collected
2343  * until mono_gchandle_free() is called. Use a TRUE value for the pinned argument to
2344  * prevent the object from being moved (this should be avoided as much as possible
2345  * and this should be used only for shorts periods of time or performance will suffer).
2346  * To create a weakref use mono_gchandle_new_weakref (): track_resurrection should
2347  * usually be false (see the GC docs for more details).
2348  * mono_gchandle_get_target () can be used to get the object referenced by both kinds
2349  * of handle: for a weakref handle, if an object has been collected, it will return NULL.
2350  */
2351 uint32_t
2352 mono_gchandle_new_internal (MonoObject *obj, mono_bool pinned);
2353
2354 uint32_t
2355 mono_gchandle_new_weakref_internal (MonoObject *obj, mono_bool track_resurrection);
2356
2357 MonoObject*
2358 mono_gchandle_get_target_internal (uint32_t gchandle);
2359
2360 void mono_gchandle_free_internal (uint32_t gchandle);
2361
2362 /* Reference queue support
2363  *
2364  * A reference queue is used to get notifications of when objects are collected.
2365  * Call mono_gc_reference_queue_new to create a new queue and pass the callback that
2366  * will be invoked when registered objects are collected.
2367  * Call mono_gc_reference_queue_add to register a pair of objects and data within a queue.
2368  * The callback will be triggered once an object is both unreachable and finalized.
2369  */
2370 MonoReferenceQueue*
2371 mono_gc_reference_queue_new_internal (mono_reference_queue_callback callback);
2372
2373 void
2374 mono_gc_reference_queue_free_internal (MonoReferenceQueue *queue);
2375
2376 mono_bool
2377 mono_gc_reference_queue_add_internal (MonoReferenceQueue *queue, MonoObject *obj, void *user_data);
2378
2379 #define mono_gc_reference_queue_add_handle(queue, obj, user_data) \
2380         (mono_gc_reference_queue_add_internal ((queue), MONO_HANDLE_RAW (MONO_HANDLE_CAST (MonoObject, obj)), (user_data)))
2381
2382 /* GC write barriers support */
2383 void
2384 mono_gc_wbarrier_set_field_internal (MonoObject *obj, void* field_ptr, MonoObject* value);
2385
2386 void
2387 mono_gc_wbarrier_set_arrayref_internal  (MonoArray *arr, void* slot_ptr, MonoObject* value);
2388
2389 void
2390 mono_gc_wbarrier_arrayref_copy_internal (void* dest_ptr, const void* src_ptr, int count);
2391
2392 void
2393 mono_gc_wbarrier_generic_store_internal (void volatile* ptr, MonoObject* value);
2394
2395 void
2396 mono_gc_wbarrier_generic_store_atomic_internal (void *ptr, MonoObject *value);
2397
2398 void
2399 mono_gc_wbarrier_generic_nostore_internal (void* ptr);
2400
2401 void
2402 mono_gc_wbarrier_value_copy_internal (void* dest, const void* src, int count, MonoClass *klass);
2403
2404 void
2405 mono_gc_wbarrier_object_copy_internal (MonoObject* obj, MonoObject *src);
2406
2407 #endif /* __MONO_OBJECT_INTERNALS_H__ */