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 void
 559 mono_gstring_append_thread_name (GString*, MonoInternalThread*);
 560
 561
 562 #ifdef ENABLE_NETCORE
 563 /*
 564  * There is only one thread object, MonoInternalThread is aliased to MonoThread,
 565  * thread->internal_thread points to itself.
 566  */
 567 struct _MonoThread {
 568 #else
 569 struct _MonoInternalThread {
 570 #endif
 571         // FIXME: Mechanize keeping this in sync with managed.
 572         MonoObject  obj;
 573         volatile int lock_thread_id; /* to be used as the pre-shifted thread id in thin locks. Used for appdomain_ref push/pop */
 574         MonoThreadHandle *handle;
 575         gpointer native_handle;
 576         gunichar2  *name;
 577         guint32     name_len;
 578         guint32     state;      /* must be accessed while longlived->synch_cs is locked */
 579         MonoException *abort_exc;
 580         int abort_state_handle;
 581         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 */
 582         gsize debugger_thread; // FIXME switch to bool as soon as CI testing with corlib version bump works
 583         gpointer *static_data;
 584         struct _MonoThreadInfo *thread_info;
 585         MonoAppContext *current_appcontext;
 586         MonoThread *root_domain_thread;
 587         MonoObject *_serialized_principal;
 588         int _serialized_principal_version;
 589         gpointer appdomain_refs;
 590         /* This is modified using atomic ops, so keep it a gint32 */
 591         gint32 __interruption_requested;
 592         /* data that must live as long as this managed object is not finalized
 593          * or as long as the underlying thread is attached, whichever is
 594          * longer */
 595         MonoLongLivedThreadData *longlived;
 596         MonoBoolean threadpool_thread;
 597         MonoBoolean thread_interrupt_requested;
 598         int stack_size;
 599         guint8  apartment_state;
 600         gint32 critical_region_level;
 601         gint32 managed_id;
 602         guint32 small_id;
 603         MonoThreadManageCallback manage_callback;
 604         gsize    flags;
 605         gpointer thread_pinning_ref;
 606         gsize __abort_protected_block_count;
 607         gint32 priority;
 608         GPtrArray *owned_mutexes;
 609         MonoOSEvent *suspended;
 610         gint32 self_suspended; // TRUE | FALSE
 611         gsize thread_state;
 612
 613 #ifdef ENABLE_NETCORE
 614         struct _MonoThread *internal_thread;
 615         MonoObject *start_obj;
 616         MonoException *pending_exception;
 617 #else
 618         void* unused [3]; // same size as netcore
 619 #endif
 620         /* This is used only to check that we are in sync between the representation
 621          * of MonoInternalThread in native and InternalThread in managed
 622          *
 623          * DO NOT RENAME! DO NOT ADD FIELDS AFTER! */
 624         gpointer last;
 625 };
 626
 627 #ifdef ENABLE_NETCORE
 628 #define _MonoInternalThread _MonoThread
 629 #else
 630 struct _MonoThread {
 631         MonoObject obj;
 632         MonoInternalThread *internal_thread;
 633         MonoObject *start_obj;
 634         MonoException *pending_exception;
 635 };
 636 #endif
 637
 638 typedef struct {
 639         guint32 state;
 640         MonoObject *additional;
 641 } MonoStreamingContext;
 642
 643 #if !ENABLE_NETCORE
 644 typedef struct {
 645         MonoObject obj;
 646         MonoBoolean readOnly;
 647         MonoString *AMDesignator;
 648         MonoString *PMDesignator;
 649         MonoString *DateSeparator;
 650         MonoString *TimeSeparator;
 651         MonoString *ShortDatePattern;
 652         MonoString *LongDatePattern;
 653         MonoString *ShortTimePattern;
 654         MonoString *LongTimePattern;
 655         MonoString *MonthDayPattern;
 656         MonoString *YearMonthPattern;
 657         guint32 FirstDayOfWeek;
 658         guint32 CalendarWeekRule;
 659         MonoArray *AbbreviatedDayNames;
 660         MonoArray *DayNames;
 661         MonoArray *MonthNames;
 662         MonoArray *GenitiveMonthNames;
 663         MonoArray *AbbreviatedMonthNames;
 664         MonoArray *GenitiveAbbreviatedMonthNames;
 665         MonoArray *ShortDatePatterns;
 666         MonoArray *LongDatePatterns;
 667         MonoArray *ShortTimePatterns;
 668         MonoArray *LongTimePatterns;
 669         MonoArray *MonthDayPatterns;
 670         MonoArray *YearMonthPatterns;
 671         MonoArray *ShortestDayNames;
 672 } MonoDateTimeFormatInfo;
 673
 674 typedef struct
 675 {
 676         MonoObject obj;
 677         MonoArray *numberGroupSizes;
 678         MonoArray *currencyGroupSizes;
 679         MonoArray *percentGroupSizes;
 680         MonoString *positiveSign;
 681         MonoString *negativeSign;
 682         MonoString *numberDecimalSeparator;
 683         MonoString *numberGroupSeparator;
 684         MonoString *currencyGroupSeparator;
 685         MonoString *currencyDecimalSeparator;
 686         MonoString *currencySymbol;
 687         MonoString *ansiCurrencySymbol; /* unused */
 688         MonoString *naNSymbol;
 689         MonoString *positiveInfinitySymbol;
 690         MonoString *negativeInfinitySymbol;
 691         MonoString *percentDecimalSeparator;
 692         MonoString *percentGroupSeparator;
 693         MonoString *percentSymbol;
 694         MonoString *perMilleSymbol;
 695         MonoString *nativeDigits; /* unused */
 696         gint32 dataItem; /* unused */
 697         guint32 numberDecimalDigits;
 698         gint32 currencyDecimalDigits;
 699         gint32 currencyPositivePattern;
 700         gint32 currencyNegativePattern;
 701         gint32 numberNegativePattern;
 702         gint32 percentPositivePattern;
 703         gint32 percentNegativePattern;
 704         gint32 percentDecimalDigits;
 705 } MonoNumberFormatInfo;
 706
 707 typedef struct {
 708         MonoObject obj;
 709         gint32 lcid;
 710         MonoString *icu_name;
 711         gpointer ICU_collator;
 712 } MonoCompareInfo;
 713
 714 typedef struct {
 715         MonoObject obj;
 716         MonoString *NativeName;
 717         MonoArray *ShortDatePatterns;
 718         MonoArray *YearMonthPatterns;
 719         MonoArray *LongDatePatterns;
 720         MonoString *MonthDayPattern;
 721
 722         MonoArray *EraNames;
 723         MonoArray *AbbreviatedEraNames;
 724         MonoArray *AbbreviatedEnglishEraNames;
 725         MonoArray *DayNames;
 726         MonoArray *AbbreviatedDayNames;
 727         MonoArray *SuperShortDayNames;
 728         MonoArray *MonthNames;
 729         MonoArray *AbbreviatedMonthNames;
 730         MonoArray *GenitiveMonthNames;
 731         MonoArray *GenitiveAbbreviatedMonthNames;
 732 } MonoCalendarData;
 733
 734 TYPED_HANDLE_DECL (MonoCalendarData);
 735
 736 typedef struct {
 737         MonoObject obj;
 738         MonoString *AMDesignator;
 739         MonoString *PMDesignator;
 740         MonoString *TimeSeparator;
 741         MonoArray *LongTimePatterns;
 742         MonoArray *ShortTimePatterns;
 743         guint32 FirstDayOfWeek;
 744         guint32 CalendarWeekRule;
 745 } MonoCultureData;
 746
 747 TYPED_HANDLE_DECL (MonoCultureData);
 748
 749 typedef struct {
 750         MonoObject obj;
 751         MonoBoolean is_read_only;
 752         gint32 lcid;
 753         gint32 parent_lcid;
 754         gint32 datetime_index;
 755         gint32 number_index;
 756         gint32 calendar_type;
 757         MonoBoolean use_user_override;
 758         MonoNumberFormatInfo *number_format;
 759         MonoDateTimeFormatInfo *datetime_format;
 760         MonoObject *textinfo;
 761         MonoString *name;
 762         MonoString *englishname;
 763         MonoString *nativename;
 764         MonoString *iso3lang;
 765         MonoString *iso2lang;
 766         MonoString *win3lang;
 767         MonoString *territory;
 768         MonoArray *native_calendar_names;
 769         MonoCompareInfo *compareinfo;
 770         const void* text_info_data;
 771 } MonoCultureInfo;
 772
 773 TYPED_HANDLE_DECL (MonoCultureInfo);
 774
 775 typedef struct {
 776         MonoObject obj;
 777         gint32 geo_id;
 778         MonoString *iso2name;
 779         MonoString *iso3name;
 780         MonoString *win3name;
 781         MonoString *english_name;
 782         MonoString *native_name;
 783         MonoString *currency_symbol;
 784         MonoString *iso_currency_symbol;
 785         MonoString *currency_english_name;
 786         MonoString *currency_native_name;
 787 } MonoRegionInfo;
 788
 789 TYPED_HANDLE_DECL (MonoRegionInfo);
 790
 791 #endif /* !ENABLE_NETCORE */
 792
 793 typedef struct {
 794         MonoObject object;
 795         guint32 intType;
 796 } MonoInterfaceTypeAttribute;
 797
 798 /* Safely access System.Delegate from native code */
 799 TYPED_HANDLE_DECL (MonoDelegate);
 800
 801 /*
 802  * Callbacks supplied by the runtime and called by the modules in metadata/
 803  * This interface is easier to extend than adding a new function type +
 804  * a new 'install' function for every callback.
 805  */
 806 typedef struct {
 807         gpointer (*create_ftnptr) (MonoDomain *domain, gpointer addr);
 808         gpointer (*get_addr_from_ftnptr) (gpointer descr);
 809         char*    (*get_runtime_build_info) (void);
 810         const char*    (*get_runtime_build_version) (void);
 811         gpointer (*get_vtable_trampoline) (MonoVTable *vtable, int slot_index);
 812         gpointer (*get_imt_trampoline) (MonoVTable *vtable, int imt_slot_index);
 813         gboolean (*imt_entry_inited) (MonoVTable *vtable, int imt_slot_index);
 814         void     (*set_cast_details) (MonoClass *from, MonoClass *to);
 815         void     (*debug_log) (int level, MonoStringHandle category, MonoStringHandle message);
 816         gboolean (*debug_log_is_enabled) (void);
 817         void     (*init_delegate) (MonoDelegateHandle delegate, MonoError *error);
 818         MonoObject* (*runtime_invoke) (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError *error);
 819         void*    (*compile_method) (MonoMethod *method, MonoError *error);
 820         gpointer (*create_jump_trampoline) (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper, MonoError *error);
 821         gpointer (*create_jit_trampoline) (MonoDomain *domain, MonoMethod *method, MonoError *error);
 822         /* used to free a dynamic method */
 823         void     (*free_method) (MonoDomain *domain, MonoMethod *method);
 824         gpointer (*create_remoting_trampoline) (MonoDomain *domain, MonoMethod *method, MonoRemotingTarget target, MonoError *error);
 825         gpointer (*create_delegate_trampoline) (MonoDomain *domain, MonoClass *klass);
 826         gpointer (*interp_get_remoting_invoke) (MonoMethod *method, gpointer imethod, MonoError *error);
 827         GHashTable *(*get_weak_field_indexes) (MonoImage *image);
 828         void     (*install_state_summarizer) (void);
 829         gboolean (*is_interpreter_enabled) (void);
 830 } MonoRuntimeCallbacks;
 831
 832 typedef gboolean (*MonoInternalStackWalk) (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data);
 833 typedef gboolean (*MonoInternalExceptionFrameWalk) (MonoMethod *method, gpointer ip, size_t native_offset, gboolean managed, gpointer user_data);
 834
 835 typedef struct {
 836         void (*mono_walk_stack_with_ctx) (MonoInternalStackWalk func, MonoContext *ctx, MonoUnwindOptions options, void *user_data);
 837         void (*mono_walk_stack_with_state) (MonoInternalStackWalk func, MonoThreadUnwindState *state, MonoUnwindOptions options, void *user_data);
 838         void (*mono_raise_exception) (MonoException *ex);
 839         void (*mono_raise_exception_with_ctx) (MonoException *ex, MonoContext *ctx);
 840         gboolean (*mono_exception_walk_trace) (MonoException *ex, MonoInternalExceptionFrameWalk func, gpointer user_data);
 841         gboolean (*mono_install_handler_block_guard) (MonoThreadUnwindState *unwind_state);
 842         void (*mono_uninstall_current_handler_block_guard) (void);
 843         gboolean (*mono_current_thread_has_handle_block_guard) (void);
 844         gboolean (*mono_above_abort_threshold) (void);
 845         void (*mono_clear_abort_threshold) (void);
 846         void (*mono_reraise_exception) (MonoException *ex);
 847         void (*mono_summarize_managed_stack) (MonoThreadSummary *out);
 848         void (*mono_summarize_unmanaged_stack) (MonoThreadSummary *out);
 849         void (*mono_summarize_exception) (MonoException *exc, MonoThreadSummary *out);
 850         void (*mono_register_native_library) (const char *module_path, const char *module_name);
 851 } MonoRuntimeExceptionHandlingCallbacks;
 852
 853 MONO_COLD void mono_set_pending_exception (MonoException *exc);
 854
 855 /* remoting and async support */
 856
 857 MonoAsyncResult *
 858 mono_async_result_new       (MonoDomain *domain, gpointer handle,
 859                              MonoObject *state, gpointer data, MonoObject *object_data, MonoError *error);
 860 ICALL_EXPORT
 861 MonoObject *
 862 ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *ares);
 863
 864 MonoWaitHandle *
 865 mono_wait_handle_new        (MonoDomain *domain, gpointer handle, MonoError *error);
 866
 867 gpointer
 868 mono_wait_handle_get_handle (MonoWaitHandle *handle);
 869
 870 gboolean
 871 mono_message_init           (MonoDomain *domain, MonoMethodMessage *this_obj,
 872                              MonoReflectionMethod *method, MonoArray *out_args, MonoError *error);
 873
 874 MonoObject *
 875 mono_message_invoke         (MonoObject *target, MonoMethodMessage *msg,
 876                              MonoObject **exc, MonoArray **out_args, MonoError *error);
 877
 878 MonoMethodMessage *
 879 mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
 880                               MonoDelegate **cb, MonoObject **state, MonoError *error);
 881
 882 void
 883 mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args, MonoError *error);
 884
 885 gboolean
 886 mono_delegate_ctor_with_method (MonoObjectHandle this_obj, MonoObjectHandle target, gpointer addr, MonoMethod *method, MonoError *error);
 887
 888 gboolean
 889 mono_delegate_ctor          (MonoObjectHandle this_obj, MonoObjectHandle target, gpointer addr, MonoError *error);
 890
 891 MonoMethod *
 892 mono_get_delegate_invoke_checked (MonoClass *klass, MonoError *error);
 893
 894 MonoMethod *
 895 mono_get_delegate_begin_invoke_checked (MonoClass *klass, MonoError *error);
 896
 897 MonoMethod *
 898 mono_get_delegate_end_invoke_checked (MonoClass *klass, MonoError *error);
 899
 900 void
 901 mono_runtime_free_method    (MonoDomain *domain, MonoMethod *method);
 902
 903 void
 904 mono_install_callbacks      (MonoRuntimeCallbacks *cbs);
 905
 906 MonoRuntimeCallbacks*
 907 mono_get_runtime_callbacks (void);
 908
 909 void
 910 mono_install_eh_callbacks (MonoRuntimeExceptionHandlingCallbacks *cbs);
 911
 912 MonoRuntimeExceptionHandlingCallbacks *
 913 mono_get_eh_callbacks (void);
 914
 915 void
 916 mono_raise_exception_deprecated (MonoException *ex);
 917
 918 void
 919 mono_reraise_exception_deprecated (MonoException *ex);
 920
 921 void
 922 mono_raise_exception_with_context (MonoException *ex, MonoContext *ctx);
 923
 924 void
 925 mono_type_initialization_init (void);
 926
 927 void
 928 mono_type_initialization_cleanup (void);
 929
 930 int
 931 mono_thread_kill           (MonoInternalThread *thread, int signal);
 932
 933 MonoNativeTlsKey
 934 mono_thread_get_tls_key    (void);
 935
 936 gint32
 937 mono_thread_get_tls_offset (void);
 938
 939 MonoNativeTlsKey
 940 mono_domain_get_tls_key    (void);
 941
 942 gint32
 943 mono_domain_get_tls_offset (void);
 944
 945 /* Reflection and Reflection.Emit support */
 946
 947 /*
 948  * Handling System.Type objects:
 949  *
 950  *   Fields defined as System.Type in managed code should be defined as MonoObject*
 951  * in unmanaged structures, and the monotype_cast () function should be used for
 952  * casting them to MonoReflectionType* to avoid crashes/security issues when
 953  * encountering instances of user defined subclasses of System.Type.
 954  */
 955
 956 #define IS_MONOTYPE(obj) (!(obj) || (m_class_get_image (mono_object_class ((obj))) == mono_defaults.corlib && ((MonoReflectionType*)(obj))->type != NULL))
 957
 958 #define IS_MONOTYPE_HANDLE(obj) IS_MONOTYPE (MONO_HANDLE_RAW (obj))
 959
 960 /* This should be used for accessing members of Type[] arrays */
 961 #define mono_type_array_get(arr,index) monotype_cast (mono_array_get_internal ((arr), gpointer, (index)))
 962
 963 /*
 964  * Cast an object to MonoReflectionType, making sure it is a System.MonoType or
 965  * a subclass of it.
 966  */
 967 static inline MonoReflectionType*
 968 monotype_cast (MonoObject *obj)
 969 {
 970         g_assert (IS_MONOTYPE (obj));
 971
 972         return (MonoReflectionType*)obj;
 973 }
 974
 975 /*
 976  * The following structure must match the C# implementation in our corlib.
 977  */
 978
 979 struct _MonoReflectionMethod {
 980         MonoObject object;
 981         MonoMethod *method;
 982         MonoString *name;
 983         MonoReflectionType *reftype;
 984 };
 985
 986 /* Safely access System.Reflection.MonoMethod from native code */
 987 TYPED_HANDLE_DECL (MonoReflectionMethod);
 988
 989 struct _MonoDelegate {
 990         MonoObject object;
 991         /* The compiled code of the target method */
 992         gpointer method_ptr;
 993         /* The invoke code */
 994         gpointer invoke_impl;
 995         MonoObject *target;
 996         MonoMethod *method;
 997         gpointer delegate_trampoline;
 998         /* Extra argument passed to the target method in llvmonly mode */
 999         gpointer extra_arg;
1000         /*
1001          * If non-NULL, this points to a memory location which stores the address of
1002          * the compiled code of the method, or NULL if it is not yet compiled.
1003          */
1004         guint8 **method_code;
1005         gpointer interp_method;
1006         /* Interp method that is executed when invoking the delegate */
1007         gpointer interp_invoke_impl;
1008         MonoReflectionMethod *method_info;
1009         MonoReflectionMethod *original_method_info;
1010         MonoObject *data;
1011         MonoBoolean method_is_virtual;
1012 };
1013
1014 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
1015 struct _MonoMulticastDelegate {
1016         MonoDelegate delegate;
1017         MonoArray *delegates;
1018 };
1019
1020 /* Safely access System.MulticastDelegate from native code */
1021 TYPED_HANDLE_DECL (MonoMulticastDelegate);
1022
1023 struct _MonoReflectionField {
1024         MonoObject object;
1025         MonoClass *klass;
1026         MonoClassField *field;
1027         MonoString *name;
1028         MonoReflectionType *type;
1029         guint32 attrs;
1030 };
1031
1032 /* Safely access System.Reflection.MonoField from native code */
1033 TYPED_HANDLE_DECL (MonoReflectionField);
1034
1035 struct _MonoReflectionProperty {
1036         MonoObject object;
1037         MonoClass *klass;
1038         MonoProperty *property;
1039 };
1040
1041 /* Safely access System.Reflection.MonoProperty from native code */
1042 TYPED_HANDLE_DECL (MonoReflectionProperty);
1043
1044 /*This is System.EventInfo*/
1045 struct _MonoReflectionEvent {
1046         MonoObject object;
1047 #ifndef ENABLE_NETCORE
1048         MonoObject *cached_add_event;
1049 #endif
1050 };
1051
1052 /* Safely access System.Reflection.EventInfo from native code */
1053 TYPED_HANDLE_DECL (MonoReflectionEvent);
1054
1055 typedef struct {
1056         MonoReflectionEvent object;
1057         MonoClass *klass;
1058         MonoEvent *event;
1059 } MonoReflectionMonoEvent;
1060
1061 /* Safely access Systme.Reflection.MonoEvent from native code */
1062 TYPED_HANDLE_DECL (MonoReflectionMonoEvent);
1063
1064 typedef struct {
1065         MonoObject object;
1066 } MonoReflectionParameter;
1067
1068 /* Safely access System.Reflection.ParameterInfo from native code */
1069 TYPED_HANDLE_DECL (MonoReflectionParameter);
1070
1071 struct _MonoReflectionMethodBody {
1072         MonoObject object;
1073 };
1074
1075 /* Safely access System.Reflection.MethodBody from native code */
1076 TYPED_HANDLE_DECL (MonoReflectionMethodBody);
1077
1078 /* System.RuntimeAssembly */
1079 struct _MonoReflectionAssembly {
1080         MonoObject object;
1081         MonoAssembly *assembly;
1082         /* CAS related */
1083         MonoObject *evidence;   /* Evidence */
1084 };
1085
1086 typedef struct {
1087         MonoReflectionType *utype;
1088         MonoArray *values;
1089         MonoArray *names;
1090 } MonoEnumInfo;
1091
1092 typedef struct {
1093         MonoReflectionType *parent;
1094         MonoReflectionType *ret;
1095         guint32 attrs;
1096         guint32 implattrs;
1097         guint32 callconv;
1098 } MonoMethodInfo;
1099
1100 typedef struct {
1101         MonoReflectionType *parent;
1102         MonoReflectionType *declaring_type;
1103         MonoString *name;
1104         MonoReflectionMethod *get;
1105         MonoReflectionMethod *set;
1106         guint32 attrs;
1107 } MonoPropertyInfo;
1108
1109 typedef struct {
1110         MonoReflectionType *declaring_type;
1111         MonoReflectionType *reflected_type;
1112         MonoString *name;
1113         MonoReflectionMethod *add_method;
1114         MonoReflectionMethod *remove_method;
1115         MonoReflectionMethod *raise_method;
1116         guint32 attrs;
1117         MonoArray *other_methods;
1118 } MonoEventInfo;
1119
1120 typedef struct {
1121         MonoString *name;
1122         MonoString *name_space;
1123         MonoReflectionType *etype;
1124         MonoReflectionType *nested_in;
1125         MonoReflectionAssembly *assembly;
1126         guint32 rank;
1127         MonoBoolean isprimitive;
1128 } MonoTypeInfo;
1129
1130 typedef struct {
1131         MonoObject *member;
1132         gint32 code_pos;
1133 } MonoReflectionILTokenInfo;
1134
1135 typedef struct {
1136         MonoObject object;
1137         MonoArray *code;
1138         gint32 code_len;
1139         gint32 max_stack;
1140         gint32 cur_stack;
1141         MonoArray *locals;
1142         MonoArray *ex_handlers;
1143         gint32 num_token_fixups;
1144         MonoArray *token_fixups;
1145 } MonoReflectionILGen;
1146
1147 typedef struct {
1148         MonoArray *handlers;
1149         gint32 start;
1150         gint32 len;
1151         gint32 label;
1152 } MonoILExceptionInfo;
1153
1154 typedef struct {
1155         MonoObject *extype;
1156         gint32 type;
1157         gint32 start;
1158         gint32 len;
1159         gint32 filter_offset;
1160 } MonoILExceptionBlock;
1161
1162 typedef struct {
1163         MonoObject object;
1164         MonoObject *catch_type;
1165         gint32 filter_offset;
1166         gint32 flags;
1167         gint32 try_offset;
1168         gint32 try_length;
1169         gint32 handler_offset;
1170         gint32 handler_length;
1171 } MonoReflectionExceptionHandlingClause;
1172
1173
1174 /* Safely access System.Reflection.ExceptionHandlingClause from native code */
1175 TYPED_HANDLE_DECL (MonoReflectionExceptionHandlingClause);
1176
1177 typedef struct {
1178         MonoObject object;
1179         MonoReflectionType *local_type;
1180         MonoBoolean is_pinned;
1181         guint16 local_index;
1182 } MonoReflectionLocalVariableInfo;
1183
1184 /* Safely access System.Reflection.LocalVariableInfo from native code */
1185 TYPED_HANDLE_DECL (MonoReflectionLocalVariableInfo);
1186
1187 typedef struct {
1188         /*
1189          * Must have the same layout as MonoReflectionLocalVariableInfo, since
1190          * LocalBuilder inherits from it under net 2.0.
1191          */
1192         MonoObject object;
1193         MonoObject *type;
1194         MonoBoolean is_pinned;
1195         guint16 local_index;
1196         MonoString *name;
1197 } MonoReflectionLocalBuilder;
1198
1199 typedef struct {
1200         MonoObject object;
1201         gint32 count;
1202         gint32 type;
1203         gint32 eltype;
1204         MonoString *guid;
1205         MonoString *mcookie;
1206         MonoString *marshaltype;
1207         MonoObject *marshaltyperef;
1208         gint32 param_num;
1209         MonoBoolean has_size;
1210 } MonoReflectionMarshal;
1211
1212 typedef struct {
1213         MonoObject object;
1214         MonoObject* methodb;
1215         MonoString *name;
1216         MonoArray *cattrs;
1217         MonoReflectionMarshal *marshal_info;
1218         guint32 attrs;
1219         int position;
1220         guint32 table_idx;
1221         MonoObject *def_value;
1222 } MonoReflectionParamBuilder;
1223
1224 typedef struct {
1225         MonoObject object;
1226         MonoMethod *mhandle;
1227         MonoReflectionILGen *ilgen;
1228         MonoArray *parameters;
1229         guint32 attrs;
1230         guint32 iattrs;
1231         guint32 table_idx;
1232         guint32 call_conv;
1233         MonoObject *type;
1234         MonoArray *pinfo;
1235         MonoArray *cattrs;
1236         MonoBoolean init_locals;
1237         MonoArray *param_modreq;
1238         MonoArray *param_modopt;
1239         MonoArray *permissions;
1240 } MonoReflectionCtorBuilder;
1241
1242 /* Safely access System.Reflection.Emit.ConstructorBuilder from native code */
1243 TYPED_HANDLE_DECL (MonoReflectionCtorBuilder);
1244
1245 typedef struct {
1246         MonoObject object;
1247         MonoMethod *mhandle;
1248         MonoObject *rtype;
1249         MonoArray *parameters;
1250         guint32 attrs;
1251         guint32 iattrs;
1252         MonoString *name;
1253         guint32 table_idx;
1254         MonoArray *code;
1255         MonoReflectionILGen *ilgen;
1256         MonoObject *type;
1257         MonoArray *pinfo;
1258         MonoArray *cattrs;
1259         MonoArray *override_methods;
1260         MonoString *dll;
1261         MonoString *dllentry;
1262         guint32 charset;
1263         guint32 extra_flags;
1264         guint32 native_cc;
1265         guint32 call_conv;
1266         MonoBoolean init_locals;
1267         MonoGenericContainer *generic_container;
1268         MonoArray *generic_params;
1269         MonoArray *return_modreq;
1270         MonoArray *return_modopt;
1271         MonoArray *param_modreq;
1272         MonoArray *param_modopt;
1273         MonoArray *permissions;
1274 } MonoReflectionMethodBuilder;
1275
1276 /* Safely access System.Reflection.Emit.MethodBuilder from native code */
1277 TYPED_HANDLE_DECL (MonoReflectionMethodBuilder);
1278
1279 typedef struct {
1280         MonoObject object;
1281         MonoMethod *mhandle;
1282         MonoReflectionType *parent;
1283         MonoReflectionType *ret;
1284         MonoArray *parameters;
1285         MonoString *name;
1286         guint32 table_idx;
1287         guint32 call_conv;
1288 } MonoReflectionArrayMethod;
1289
1290 /* Safely access System.Reflection.Emit.MonoArrayMethod from native code */
1291 TYPED_HANDLE_DECL (MonoReflectionArrayMethod);
1292
1293 typedef struct {
1294         MonoArray *data;
1295         MonoString *name;
1296         MonoString *filename;
1297         guint32 attrs;
1298         guint32 offset;
1299         MonoObject *stream;
1300 } MonoReflectionResource;
1301
1302 typedef struct {
1303         guint32 res_type;
1304         guint32 res_id;
1305         guint32 lang_id;
1306         MonoArray *res_data;
1307 } MonoReflectionWin32Resource;
1308
1309 typedef struct {
1310         guint32 action;
1311         MonoString *pset;
1312 } MonoReflectionPermissionSet;
1313
1314 typedef struct {
1315         MonoReflectionAssembly assembly;
1316         MonoDynamicAssembly *dynamic_assembly;
1317         MonoReflectionMethod *entry_point;
1318         MonoArray *modules;
1319         MonoString *name;
1320         MonoString *dir;
1321         MonoArray *cattrs;
1322         MonoArray *resources;
1323         MonoArray *public_key;
1324         MonoString *version;
1325         MonoString *culture;
1326         guint32 algid;
1327         guint32 flags;
1328         guint32 pekind;
1329         MonoBoolean delay_sign;
1330         guint32 access;
1331         MonoArray *loaded_modules;
1332         MonoArray *win32_resources;
1333         /* CAS related */
1334         MonoArray *permissions_minimum;
1335         MonoArray *permissions_optional;
1336         MonoArray *permissions_refused;
1337         gint32 pe_kind;
1338         gint32 machine;
1339         MonoBoolean corlib_internal;
1340         MonoArray *type_forwarders;
1341         MonoArray *pktoken; /* as hexadecimal byte[] */
1342 } MonoReflectionAssemblyBuilder;
1343
1344 /* Safely access System.Reflection.Emit.AssemblyBuilder from native code */
1345 TYPED_HANDLE_DECL (MonoReflectionAssemblyBuilder);
1346
1347 typedef struct {
1348         MonoObject object;
1349         guint32 attrs;
1350         MonoObject *type;
1351         MonoString *name;
1352         MonoObject *def_value;
1353         gint32 offset;
1354         MonoReflectionType *typeb;
1355         MonoArray *rva_data;
1356         MonoArray *cattrs;
1357         MonoReflectionMarshal *marshal_info;
1358         MonoClassField *handle;
1359         MonoArray *modreq;
1360         MonoArray *modopt;
1361 } MonoReflectionFieldBuilder;
1362
1363 /* Safely access System.Reflection.Emit.FieldBuilder from native code */
1364 TYPED_HANDLE_DECL (MonoReflectionFieldBuilder);
1365
1366 typedef struct {
1367         MonoObject object;
1368         guint32 attrs;
1369         MonoString *name;
1370         MonoObject *type;
1371         MonoArray *parameters;
1372         MonoArray *cattrs;
1373         MonoObject *def_value;
1374         MonoReflectionMethodBuilder *set_method;
1375         MonoReflectionMethodBuilder *get_method;
1376         gint32 table_idx;
1377         MonoObject *type_builder;
1378         MonoArray *returnModReq;
1379         MonoArray *returnModOpt;
1380         MonoArray *paramModReq;
1381         MonoArray *paramModOpt;
1382         guint32 call_conv;
1383 } MonoReflectionPropertyBuilder;
1384
1385 /* System.RuntimeModule */
1386 struct _MonoReflectionModule {
1387         MonoObject      obj;
1388         MonoImage  *image;
1389         MonoReflectionAssembly *assembly;
1390         MonoString *fqname;
1391         MonoString *name;
1392         MonoString *scopename;
1393         MonoBoolean is_resource;
1394         guint32 token;
1395 };
1396
1397 /* Safely access System.Reflection.Module from native code */
1398 TYPED_HANDLE_DECL (MonoReflectionModule);
1399
1400 typedef struct {
1401         MonoReflectionModule module;
1402         MonoDynamicImage *dynamic_image;
1403         gint32     num_types;
1404         MonoArray *types;
1405         MonoArray *cattrs;
1406         MonoArray *guid;
1407         guint32    table_idx;
1408         MonoReflectionAssemblyBuilder *assemblyb;
1409         MonoArray *global_methods;
1410         MonoArray *global_fields;
1411         gboolean is_main;
1412         MonoArray *resources;
1413         GHashTable *unparented_classes;
1414         MonoArray *table_indexes;
1415 } MonoReflectionModuleBuilder;
1416
1417 /* Safely acess System.Reflection.Emit.ModuleBuidler from native code */
1418 TYPED_HANDLE_DECL (MonoReflectionModuleBuilder);
1419
1420 typedef enum {
1421         MonoTypeBuilderNew = 0,
1422         MonoTypeBuilderEntered = 1,
1423         MonoTypeBuilderFinished = 2
1424 } MonoTypeBuilderState;
1425
1426 struct _MonoReflectionTypeBuilder {
1427         MonoReflectionType type;
1428         MonoString *name;
1429         MonoString *nspace;
1430         MonoObject *parent;
1431         MonoReflectionType *nesting_type;
1432         MonoArray *interfaces;
1433         gint32     num_methods;
1434         MonoArray *methods;
1435         MonoArray *ctors;
1436         MonoArray *properties;
1437         gint32     num_fields;
1438         MonoArray *fields;
1439         MonoArray *events;
1440         MonoArray *cattrs;
1441         MonoArray *subtypes;
1442         guint32 attrs;
1443         guint32 table_idx;
1444         MonoReflectionModuleBuilder *module;
1445         gint32 class_size;
1446         gint32 packing_size;
1447         MonoGenericContainer *generic_container;
1448         MonoArray *generic_params;
1449         MonoArray *permissions;
1450         MonoReflectionType *created;
1451         gint32 state;
1452 };
1453
1454 typedef struct {
1455         MonoReflectionType type;
1456         MonoReflectionType *element_type;
1457         gint32 rank;
1458 } MonoReflectionArrayType;
1459
1460 /* Safely access System.Reflection.Emit.ArrayType (in DerivedTypes.cs) from native code */
1461 TYPED_HANDLE_DECL (MonoReflectionArrayType);
1462
1463 typedef struct {
1464         MonoReflectionType type;
1465         MonoReflectionType *element_type;
1466 } MonoReflectionDerivedType;
1467
1468 /* Safely access System.Reflection.Emit.SymbolType and subclasses (in DerivedTypes.cs) from native code */
1469 TYPED_HANDLE_DECL (MonoReflectionDerivedType);
1470
1471 typedef struct {
1472         MonoReflectionType type;
1473         MonoReflectionTypeBuilder *tbuilder;
1474         MonoReflectionMethodBuilder *mbuilder;
1475         MonoString *name;
1476         guint32 index;
1477         MonoReflectionType *base_type;
1478         MonoArray *iface_constraints;
1479         MonoArray *cattrs;
1480         guint32 attrs;
1481 } MonoReflectionGenericParam;
1482
1483 /* Safely access System.Reflection.Emit.GenericTypeParameterBuilder from native code */
1484 TYPED_HANDLE_DECL (MonoReflectionGenericParam);
1485
1486 typedef struct {
1487         MonoReflectionType type;
1488         MonoReflectionTypeBuilder *tb;
1489 } MonoReflectionEnumBuilder;
1490
1491 /* Safely access System.Reflection.Emit.EnumBuilder from native code */
1492 TYPED_HANDLE_DECL (MonoReflectionEnumBuilder);
1493
1494 typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass;
1495 struct _MonoReflectionGenericClass {
1496         MonoReflectionType type;
1497         MonoReflectionType *generic_type; /*Can be either a MonoType or a TypeBuilder*/
1498         MonoArray *type_arguments;
1499 };
1500
1501 /* Safely access System.Reflection.Emit.TypeBuilderInstantiation from native code */
1502 TYPED_HANDLE_DECL (MonoReflectionGenericClass);
1503
1504 typedef struct {
1505         MonoObject  obj;
1506         MonoString *name;
1507         MonoString *codebase;
1508         gint32 major, minor, build, revision;
1509         MonoObject  *cultureInfo;
1510         guint32     flags;
1511         guint32     hashalg;
1512         MonoObject  *keypair;
1513         MonoArray   *publicKey;
1514         MonoArray   *keyToken;
1515         guint32     versioncompat;
1516         MonoObject *version;
1517         guint32     processor_architecture;
1518 } MonoReflectionAssemblyName;
1519
1520 /* Safely access System.Reflection.AssemblyName from native code */
1521 TYPED_HANDLE_DECL (MonoReflectionAssemblyName);
1522
1523 typedef struct {
1524         MonoObject  obj;
1525         MonoString *name;
1526         MonoReflectionType *type;
1527         MonoReflectionTypeBuilder *typeb;
1528         MonoArray *cattrs;
1529         MonoReflectionMethodBuilder *add_method;
1530         MonoReflectionMethodBuilder *remove_method;
1531         MonoReflectionMethodBuilder *raise_method;
1532         MonoArray *other_methods;
1533         guint32 attrs;
1534         guint32 table_idx;
1535 } MonoReflectionEventBuilder;
1536
1537 typedef struct {
1538         MonoObject  obj;
1539         MonoReflectionMethod *ctor;
1540         MonoArray *data;
1541 } MonoReflectionCustomAttr;
1542
1543 TYPED_HANDLE_DECL (MonoReflectionCustomAttr);
1544
1545 #if ENABLE_NETCORE
1546 typedef struct {
1547         MonoObject object;
1548         guint32 utype;
1549         gint32 safe_array_subtype;
1550         MonoReflectionType *marshal_safe_array_user_defined_subtype;
1551         gint32 IidParameterIndex;
1552         guint32 array_subtype;
1553         gint16 size_param_index;
1554         gint32 size_const;
1555         MonoString *marshal_type;
1556         MonoReflectionType *marshal_type_ref;
1557         MonoString *marshal_cookie;
1558 } MonoReflectionMarshalAsAttribute;
1559 #else
1560 typedef struct {
1561         MonoObject object;
1562         MonoString *marshal_cookie;
1563         MonoString *marshal_type;
1564         MonoReflectionType *marshal_type_ref;
1565         MonoReflectionType *marshal_safe_array_user_defined_subtype;
1566         guint32 utype;
1567         guint32 array_subtype;
1568         gint32 safe_array_subtype;
1569         gint32 size_const;
1570         gint32 IidParameterIndex;
1571         gint16 size_param_index;
1572 } MonoReflectionMarshalAsAttribute;
1573 #endif
1574
1575 /* Safely access System.Runtime.InteropServices.MarshalAsAttribute */
1576 TYPED_HANDLE_DECL (MonoReflectionMarshalAsAttribute);
1577
1578 typedef struct {
1579         MonoObject object;
1580         gint32 call_conv;
1581         gint32 charset;
1582         MonoBoolean best_fit_mapping;
1583         MonoBoolean throw_on_unmappable;
1584         MonoBoolean set_last_error;
1585 } MonoReflectionUnmanagedFunctionPointerAttribute;
1586
1587 typedef struct {
1588         MonoObject object;
1589         MonoString *guid;
1590 } MonoReflectionGuidAttribute;
1591
1592 typedef struct {
1593         MonoObject object;
1594         MonoMethod *mhandle;
1595         MonoString *name;
1596         MonoReflectionType *rtype;
1597         MonoArray *parameters;
1598         guint32 attrs;
1599         guint32 call_conv;
1600         MonoReflectionModule *module;
1601         MonoBoolean skip_visibility;
1602         MonoBoolean init_locals;
1603         MonoReflectionILGen *ilgen;
1604         gint32 nrefs;
1605         MonoArray *refs;
1606         GSList *referenced_by;
1607         MonoReflectionType *owner;
1608 } MonoReflectionDynamicMethod;
1609
1610 /* Safely access System.Reflection.Emit.DynamicMethod from native code */
1611 TYPED_HANDLE_DECL (MonoReflectionDynamicMethod);
1612
1613 typedef struct {
1614         MonoObject object;
1615         MonoReflectionModuleBuilder *module;
1616         MonoArray *arguments;
1617         guint32 type;
1618         MonoReflectionType *return_type;
1619         guint32 call_conv;
1620         guint32 unmanaged_call_conv;
1621         MonoArray *modreqs;
1622         MonoArray *modopts;
1623 } MonoReflectionSigHelper;
1624
1625 /* Safely access System.Reflection.Emit.SignatureHelper from native code */
1626 TYPED_HANDLE_DECL (MonoReflectionSigHelper);
1627
1628 typedef struct {
1629         MonoObject object;
1630         MonoBoolean visible;
1631 } MonoReflectionComVisibleAttribute;
1632
1633 enum {
1634         RESOURCE_LOCATION_EMBEDDED = 1,
1635         RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
1636         RESOURCE_LOCATION_IN_MANIFEST = 4
1637 };
1638
1639 typedef struct {
1640         MonoObject object;
1641         MonoReflectionAssembly *assembly;
1642         MonoString *filename;
1643         guint32 location;
1644 } MonoManifestResourceInfo;
1645
1646 /* Safely access System.Reflection.ManifestResourceInfo from native code */
1647 TYPED_HANDLE_DECL (MonoManifestResourceInfo);
1648
1649 /* A boxed IntPtr */
1650 typedef struct {
1651         MonoObject object;
1652         gpointer m_value;
1653 } MonoIntPtr;
1654
1655 /* Keep in sync with System.GenericParameterAttributes */
1656 typedef enum {
1657         GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT         = 0,
1658         GENERIC_PARAMETER_ATTRIBUTE_COVARIANT           = 1,
1659         GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT       = 2,
1660         GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK       = 3,
1661
1662         GENERIC_PARAMETER_ATTRIBUTE_NO_SPECIAL_CONSTRAINT       = 0,
1663         GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT   = 4,
1664         GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT       = 8,
1665         GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT      = 16,
1666         GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK    = 28
1667 } GenericParameterAttributes;
1668
1669 typedef struct {
1670         MonoType *type;
1671         MonoClassField *field;
1672         MonoProperty *prop;
1673 } CattrNamedArg;
1674
1675 /* All MonoInternalThread instances should be pinned, so it's safe to use the raw ptr.  However
1676  * for uniformity, icall wrapping will make handles anyway.  So this is the method for getting the payload.
1677  */
1678 static inline MonoInternalThread*
1679 mono_internal_thread_handle_ptr (MonoInternalThreadHandle h)
1680 {
1681         /* The SUPPRESS here prevents a Centrinel warning due to merely seeing this
1682          * function definition.  Callees will still get a warning unless we
1683          * attach a suppress attribute to the declaration.
1684          */
1685         return MONO_HANDLE_SUPPRESS (MONO_HANDLE_RAW (h));
1686 }
1687
1688 gboolean          mono_image_create_pefile (MonoReflectionModuleBuilder *module, gpointer file, MonoError *error);
1689 guint32       mono_image_insert_string (MonoReflectionModuleBuilderHandle module, MonoStringHandle str, MonoError *error);
1690 guint32       mono_image_create_token  (MonoDynamicImage *assembly, MonoObjectHandle obj, gboolean create_methodspec, gboolean register_token, MonoError *error);
1691 void          mono_dynamic_image_free (MonoDynamicImage *image);
1692 void          mono_dynamic_image_free_image (MonoDynamicImage *image);
1693 void          mono_dynamic_image_release_gc_roots (MonoDynamicImage *image);
1694
1695 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb);
1696
1697 void        mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides, MonoError *error);
1698
1699 void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod *mb);
1700
1701 ICALL_EXPORT
1702 void
1703 ves_icall_SymbolType_create_unmanaged_type (MonoReflectionType *type);
1704
1705 void        mono_reflection_register_with_runtime (MonoReflectionType *type);
1706
1707 void        mono_reflection_create_custom_attr_data_args (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len, MonoArray **typed_args_out, MonoArray **named_args_out, CattrNamedArg **named_arg_info, MonoError *error);
1708 MonoMethodSignature * mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token, MonoError *error);
1709
1710 MonoArrayHandle mono_param_get_objects_internal  (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error);
1711
1712 MonoClass*
1713 mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic);
1714 MonoType*
1715 mono_reflection_bind_generic_parameters (MonoReflectionTypeHandle type, int type_argc, MonoType **types, MonoError *error);
1716 void
1717 mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields);
1718
1719 ICALL_EXPORT
1720 MonoReflectionEvent *
1721 ves_icall_TypeBuilder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb);
1722
1723 MonoReflectionMarshalAsAttributeHandle
1724 mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec, MonoError *error);
1725
1726 gpointer
1727 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context, MonoError *error);
1728
1729 gboolean
1730 mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass, MonoError *error);
1731
1732 ICALL_EXPORT
1733 void
1734 ves_icall_System_Reflection_CustomAttributeData_ResolveArgumentsInternal (MonoReflectionMethod *method, MonoReflectionAssembly *assembly, gpointer data, guint32 data_length, MonoArray **ctor_args, MonoArray ** named_args);
1735
1736 gboolean
1737 mono_image_build_metadata (MonoReflectionModuleBuilder *module, MonoError *error);
1738
1739 int
1740 mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value, MonoError *error);
1741
1742 gboolean
1743 mono_metadata_read_constant_value (const char *blob, MonoTypeEnum type, void *value, MonoError *error);
1744
1745 char*
1746 mono_string_from_blob (const char *str, MonoError *error);
1747
1748 void
1749 mono_release_type_locks (MonoInternalThread *thread);
1750
1751 /**
1752  * mono_string_handle_length:
1753  * \param s \c MonoString
1754  * \returns the length in characters of the string
1755  */
1756 #ifdef ENABLE_CHECKED_BUILD_GC
1757
1758 int
1759 mono_string_handle_length (MonoStringHandle s);
1760
1761 #else
1762
1763 #define mono_string_handle_length(s) (MONO_HANDLE_GETVAL ((s), length))
1764
1765 #endif
1766
1767 char *
1768 mono_string_handle_to_utf8 (MonoStringHandle s, MonoError *error);
1769
1770 char *
1771 mono_string_to_utf8_image (MonoImage *image, MonoStringHandle s, MonoError *error);
1772
1773 MonoArrayHandle
1774 mono_array_clone_in_domain (MonoDomain *domain, MonoArrayHandle array, MonoError *error);
1775
1776 MonoArray*
1777 mono_array_clone_checked (MonoArray *array, MonoError *error);
1778
1779 void
1780 mono_array_full_copy (MonoArray *src, MonoArray *dest);
1781
1782 gboolean
1783 mono_array_calc_byte_len (MonoClass *klass, uintptr_t len, uintptr_t *res);
1784
1785 MonoArray*
1786 mono_array_new_checked (MonoDomain *domain, MonoClass *eclass, uintptr_t n, MonoError *error);
1787
1788 MonoArray*
1789 mono_array_new_full_checked (MonoDomain *domain, MonoClass *array_class, uintptr_t *lengths, intptr_t *lower_bounds, MonoError *error);
1790
1791 MonoArray*
1792 mono_array_new_specific_checked (MonoVTable *vtable, uintptr_t n, MonoError *error);
1793
1794 MonoArrayHandle
1795 mono_array_new_specific_handle (MonoVTable *vtable, uintptr_t n, MonoError *error);
1796
1797 ICALL_EXPORT
1798 MonoArray*
1799 ves_icall_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n);
1800
1801 ICALL_EXPORT
1802 MonoArray*
1803 ves_icall_array_new_specific (MonoVTable *vtable, uintptr_t n);
1804
1805 #ifndef DISABLE_REMOTING
1806 MonoRemoteClass*
1807 mono_remote_class (MonoDomain *domain, MonoStringHandle class_name, MonoClass *proxy_class, MonoError *error);
1808
1809 gboolean
1810 mono_remote_class_is_interface_proxy (MonoRemoteClass *remote_class);
1811
1812 MonoObject *
1813 mono_remoting_invoke (MonoObject *real_proxy, MonoMethodMessage *msg, MonoObject **exc, MonoArray **out_args, MonoError *error);
1814
1815 gpointer
1816 mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxyHandle real_proxy, MonoError *error);
1817
1818 gboolean
1819 mono_upgrade_remote_class (MonoDomain *domain, MonoObjectHandle tproxy, MonoClass *klass, MonoError *error);
1820
1821 void*
1822 mono_load_remote_field_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void **res, MonoError *error);
1823
1824 MonoObject *
1825 mono_load_remote_field_new_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoError *error);
1826
1827 gboolean
1828 mono_store_remote_field_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void* val, MonoError *error);
1829
1830 gboolean
1831 mono_store_remote_field_new_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg, MonoError *error);
1832
1833
1834 #endif
1835
1836 gpointer
1837 mono_create_ftnptr (MonoDomain *domain, gpointer addr);
1838
1839 gpointer
1840 mono_get_addr_from_ftnptr (gpointer descr);
1841
1842 void
1843 mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass);
1844
1845 void
1846 mono_nullable_init_from_handle (guint8 *buf, MonoObjectHandle value, MonoClass *klass);
1847
1848 void
1849 mono_nullable_init_unboxed (guint8 *buf, gpointer value, MonoClass *klass);
1850
1851 MonoObject *
1852 mono_value_box_checked (MonoDomain *domain, MonoClass *klass, void* val, MonoError *error);
1853
1854 MonoObjectHandle
1855 mono_value_box_handle (MonoDomain *domain, MonoClass *klass, gpointer val, MonoError *error);
1856
1857 MonoObject*
1858 mono_nullable_box (gpointer buf, MonoClass *klass, MonoError *error);
1859
1860 MonoObjectHandle
1861 mono_nullable_box_handle (gpointer buf, MonoClass *klass, MonoError *error);
1862
1863 // A code size optimization (source and object) equivalent to MONO_HANDLE_NEW (MonoObject, NULL);
1864 MonoObjectHandle
1865 mono_new_null (void);
1866
1867 #ifdef MONO_SMALL_CONFIG
1868 #define MONO_IMT_SIZE 9
1869 #else
1870 #define MONO_IMT_SIZE 19
1871 #endif
1872
1873 typedef union {
1874         int vtable_slot;
1875         gpointer target_code;
1876 } MonoImtItemValue;
1877
1878 typedef struct _MonoImtBuilderEntry {
1879         gpointer key;
1880         struct _MonoImtBuilderEntry *next;
1881         MonoImtItemValue value;
1882         int children;
1883         guint8 has_target_code : 1;
1884 } MonoImtBuilderEntry;
1885
1886 typedef struct _MonoIMTCheckItem MonoIMTCheckItem;
1887
1888 struct _MonoIMTCheckItem {
1889         gpointer          key;
1890         int               check_target_idx;
1891         MonoImtItemValue  value;
1892         guint8           *jmp_code;
1893         guint8           *code_target;
1894         guint8            is_equals;
1895         guint8            compare_done;
1896         guint8            chunk_size;
1897         guint8            short_branch;
1898         guint8            has_target_code;
1899 };
1900
1901 typedef gpointer (*MonoImtTrampolineBuilder) (MonoVTable *vtable, MonoDomain *domain,
1902                 MonoIMTCheckItem **imt_entries, int count, gpointer fail_trunk);
1903
1904 void
1905 mono_install_imt_trampoline_builder (MonoImtTrampolineBuilder func);
1906
1907 void
1908 mono_set_always_build_imt_trampolines (gboolean value);
1909
1910 void
1911 mono_vtable_build_imt_slot (MonoVTable* vtable, int imt_slot);
1912
1913 guint32
1914 mono_method_get_imt_slot (MonoMethod *method);
1915
1916 void
1917 mono_method_add_generic_virtual_invocation (MonoDomain *domain, MonoVTable *vtable,
1918                                                                                         gpointer *vtable_slot,
1919                                                                                         MonoMethod *method, gpointer code);
1920
1921 gpointer
1922 mono_method_alloc_generic_virtual_trampoline (MonoDomain *domain, int size);
1923
1924 #define mono_method_alloc_generic_virtual_trampoline(domain, size) (g_cast (mono_method_alloc_generic_virtual_trampoline ((domain), (size))))
1925
1926 typedef enum {
1927         MONO_UNHANDLED_POLICY_LEGACY,
1928         MONO_UNHANDLED_POLICY_CURRENT
1929 } MonoRuntimeUnhandledExceptionPolicy;
1930
1931 MonoRuntimeUnhandledExceptionPolicy
1932 mono_runtime_unhandled_exception_policy_get (void);
1933 void
1934 mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy);
1935
1936 void
1937 mono_unhandled_exception_checked (MonoObjectHandle exc, MonoError *error);
1938
1939 MonoVTable *
1940 mono_class_try_get_vtable (MonoDomain *domain, MonoClass *klass);
1941
1942 gboolean
1943 mono_runtime_run_module_cctor (MonoImage *image, MonoDomain *domain, MonoError *error);
1944
1945 gboolean
1946 mono_runtime_class_init_full (MonoVTable *vtable, MonoError *error);
1947
1948 void
1949 mono_method_clear_object (MonoDomain *domain, MonoMethod *method);
1950
1951 gsize*
1952 mono_class_compute_bitmap (MonoClass *klass, gsize *bitmap, int size, int offset, int *max_set, gboolean static_fields);
1953
1954 MonoObjectHandle
1955 mono_object_xdomain_representation (MonoObjectHandle obj, MonoDomain *target_domain, MonoError *error);
1956
1957 gboolean
1958 mono_class_is_reflection_method_or_constructor (MonoClass *klass);
1959
1960 MonoObject *
1961 mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob, MonoError *error);
1962
1963 gboolean
1964 mono_class_has_ref_info (MonoClass *klass);
1965
1966 MonoReflectionTypeBuilder*
1967 mono_class_get_ref_info_raw (MonoClass *klass);
1968
1969 void
1970 mono_class_set_ref_info (MonoClass *klass, MonoObjectHandle obj);
1971
1972 void
1973 mono_class_free_ref_info (MonoClass *klass);
1974
1975 MonoObject *
1976 mono_object_new_pinned (MonoDomain *domain, MonoClass *klass, MonoError *error);
1977
1978 MonoObjectHandle
1979 mono_object_new_pinned_handle (MonoDomain *domain, MonoClass *klass, MonoError *error);
1980
1981 MonoObject *
1982 mono_object_new_specific_checked (MonoVTable *vtable, MonoError *error);
1983
1984 ICALL_EXPORT
1985 MonoObject *
1986 ves_icall_object_new (MonoDomain *domain, MonoClass *klass);
1987
1988 ICALL_EXPORT
1989 MonoObject *
1990 ves_icall_object_new_specific (MonoVTable *vtable);
1991
1992 MonoObject *
1993 mono_object_new_alloc_specific_checked (MonoVTable *vtable, MonoError *error);
1994
1995 void
1996 mono_field_get_value_internal (MonoObject *obj, MonoClassField *field, void *value);
1997
1998 void
1999 mono_field_static_get_value_checked (MonoVTable *vt, MonoClassField *field, void *value, MonoError *error);
2000
2001 void
2002 mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value, MonoError *error);
2003
2004 MonoMethod*
2005 mono_object_handle_get_virtual_method (MonoObjectHandle obj, MonoMethod *method, MonoError *error);
2006
2007 /* exported, used by the debugger */
2008 MONO_API void *
2009 mono_vtable_get_static_field_data (MonoVTable *vt);
2010
2011 MonoObject *
2012 mono_field_get_value_object_checked (MonoDomain *domain, MonoClassField *field, MonoObject *obj, MonoError *error);
2013
2014 MonoObjectHandle
2015 mono_static_field_get_value_handle (MonoDomain *domain, MonoClassField *field, MonoError *error);
2016
2017 gboolean
2018 mono_property_set_value_handle (MonoProperty *prop, MonoObjectHandle obj, void **params, MonoError *error);
2019
2020 MonoObject*
2021 mono_property_get_value_checked (MonoProperty *prop, void *obj, void **params, MonoError *error);
2022
2023 MonoString*
2024 mono_object_try_to_string (MonoObject *obj, MonoObject **exc, MonoError *error);
2025
2026 char *
2027 mono_string_to_utf8_ignore (MonoString *s);
2028
2029 gboolean
2030 mono_monitor_is_il_fastpath_wrapper (MonoMethod *method);
2031
2032 MonoStringHandle
2033 mono_string_is_interned_lookup (MonoStringHandle str, gboolean insert, MonoError *error);
2034
2035 /**
2036  * mono_string_intern_checked:
2037  * \param str String to intern
2038  * \param error set on error.
2039  * Interns the string passed.
2040  * \returns The interned string. On failure returns NULL and sets \p error
2041  */
2042 #define mono_string_intern_checked(str, error) (mono_string_is_interned_lookup ((str), TRUE, (error)))
2043
2044 /**
2045  * mono_string_is_interned_internal:
2046  * \param o String to probe
2047  * \returns Whether the string has been interned.
2048  */
2049 #define mono_string_is_interned_internal(str, error) (mono_string_is_interned_lookup ((str), FALSE, (error)))
2050
2051 char *
2052 mono_exception_handle_get_native_backtrace (MonoExceptionHandle exc);
2053
2054 char *
2055 mono_exception_get_managed_backtrace (MonoException *exc);
2056
2057 void
2058 mono_copy_value (MonoType *type, void *dest, void *value, int deref_pointer);
2059
2060 void
2061 mono_error_raise_exception_deprecated (MonoError *target_error);
2062
2063 gboolean
2064 mono_error_set_pending_exception_slow (MonoError *error);
2065
2066 static inline gboolean
2067 mono_error_set_pending_exception (MonoError *error)
2068 {
2069         return is_ok (error) ? FALSE : mono_error_set_pending_exception_slow (error);
2070 }
2071
2072 MonoArray *
2073 mono_glist_to_array (GList *list, MonoClass *eclass, MonoError *error);
2074
2075 MonoObject *
2076 mono_object_new_checked (MonoDomain *domain, MonoClass *klass, MonoError *error);
2077
2078 MonoObjectHandle
2079 mono_object_new_handle (MonoDomain *domain, MonoClass *klass, MonoError *error);
2080
2081 // This function skips handling of remoting and COM.
2082 // "alloc" means "less".
2083 MonoObjectHandle
2084 mono_object_new_alloc_by_vtable (MonoVTable *vtable, MonoError *error);
2085
2086 MonoObject*
2087 mono_object_new_mature (MonoVTable *vtable, MonoError *error);
2088
2089 MonoObjectHandle
2090 mono_object_new_handle_mature (MonoVTable *vtable, MonoError *error);
2091
2092 MonoObject *
2093 mono_object_clone_checked (MonoObject *obj, MonoError *error);
2094
2095 MonoObjectHandle
2096 mono_object_clone_handle (MonoObjectHandle obj, MonoError *error);
2097
2098 MonoObject *
2099 mono_object_isinst_checked (MonoObject *obj, MonoClass *klass, MonoError *error);
2100
2101 MonoObjectHandle
2102 mono_object_handle_isinst (MonoObjectHandle obj, MonoClass *klass, MonoError *error);
2103
2104 MonoObjectHandle
2105 mono_object_handle_isinst_mbyref (MonoObjectHandle obj, MonoClass *klass, MonoError *error);
2106
2107 gboolean
2108 mono_object_handle_isinst_mbyref_raw (MonoObjectHandle obj, MonoClass *klass, MonoError *error);
2109
2110 MonoStringHandle
2111 mono_string_new_size_handle (MonoDomain *domain, gint32 len, MonoError *error);
2112
2113 MonoString*
2114 mono_string_new_len_checked (MonoDomain *domain, const char *text, guint length, MonoError *error);
2115
2116 MonoString *
2117 mono_string_new_size_checked (MonoDomain *domain, gint32 len, MonoError *error);
2118
2119 MonoString*
2120 mono_ldstr_checked (MonoDomain *domain, MonoImage *image, uint32_t str_index, MonoError *error);
2121
2122 MonoStringHandle
2123 mono_ldstr_handle (MonoDomain *domain, MonoImage *image, uint32_t str_index, MonoError *error);
2124
2125 MONO_PROFILER_API MonoString*
2126 mono_string_new_checked (MonoDomain *domain, const char *text, MonoError *merror);
2127
2128 MonoString*
2129 mono_string_new_wtf8_len_checked (MonoDomain *domain, const char *text, guint length, MonoError *error);
2130
2131 MonoString *
2132 mono_string_new_utf16_checked (MonoDomain *domain, const gunichar2 *text, gint32 len, MonoError *error);
2133
2134 MonoStringHandle
2135 mono_string_new_utf16_handle (MonoDomain *domain, const gunichar2 *text, gint32 len, MonoError *error);
2136
2137 MonoStringHandle
2138 mono_string_new_utf8_len (MonoDomain *domain, const char *text, guint length, MonoError *error);
2139
2140 MonoString *
2141 mono_string_from_utf16_checked (const mono_unichar2 *data, MonoError *error);
2142
2143 MonoString *
2144 mono_string_from_utf32_checked (const mono_unichar4 *data, MonoError *error);
2145
2146 char*
2147 mono_ldstr_utf8 (MonoImage *image, guint32 idx, MonoError *error);
2148
2149 char*
2150 mono_utf16_to_utf8 (const mono_unichar2 *s, gsize slength, MonoError *error);
2151
2152 char*
2153 mono_utf16_to_utf8len (const mono_unichar2 *s, gsize slength, gsize *utf8_length, MonoError *error);
2154
2155 gboolean
2156 mono_runtime_object_init_checked (MonoObject *this_obj, MonoError *error);
2157
2158 MONO_PROFILER_API MonoObject*
2159 mono_runtime_try_invoke (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError *error);
2160
2161 // The exc parameter is deliberately missing and so far this has proven to reduce code duplication.
2162 // In particular, if an exception is returned from underlying otherwise succeeded call,
2163 // is set into the MonoError with mono_error_set_exception_instance.
2164 // The result is that caller need only check MonoError.
2165 MonoObjectHandle
2166 mono_runtime_try_invoke_handle (MonoMethod *method, MonoObjectHandle obj, void **params, MonoError* error);
2167
2168 MonoObject*
2169 mono_runtime_invoke_checked (MonoMethod *method, void *obj, void **params, MonoError *error);
2170
2171 MonoObjectHandle
2172 mono_runtime_invoke_handle (MonoMethod *method, MonoObjectHandle obj, void **params, MonoError* error);
2173
2174 void
2175 mono_runtime_invoke_handle_void (MonoMethod *method, MonoObjectHandle obj, void **params, MonoError* error);
2176
2177 MonoObject*
2178 mono_runtime_try_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
2179                                MonoObject **exc, MonoError *error);
2180
2181 MonoObject*
2182 mono_runtime_invoke_array_checked (MonoMethod *method, void *obj, MonoArray *params,
2183                                    MonoError *error);
2184
2185 void*
2186 mono_compile_method_checked (MonoMethod *method, MonoError *error);
2187
2188 MonoObject*
2189 mono_runtime_delegate_try_invoke (MonoObject *delegate, void **params,
2190                                   MonoObject **exc, MonoError *error);
2191
2192 MonoObject*
2193 mono_runtime_delegate_invoke_checked (MonoObject *delegate, void **params,
2194                                       MonoError *error);
2195
2196 MonoArrayHandle
2197 mono_runtime_get_main_args_handle (MonoError *error);
2198
2199 int
2200 mono_runtime_run_main_checked (MonoMethod *method, int argc, char* argv[],
2201                                MonoError *error);
2202
2203 int
2204 mono_runtime_try_run_main (MonoMethod *method, int argc, char* argv[],
2205                            MonoObject **exc);
2206
2207 int
2208 mono_runtime_exec_main_checked (MonoMethod *method, MonoArray *args, MonoError *error);
2209
2210 int
2211 mono_runtime_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc);
2212
2213 ICALL_EXPORT
2214 void
2215 ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, gpointer file);
2216
2217 ICALL_EXPORT
2218 void
2219 ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb);
2220
2221 ICALL_EXPORT
2222 MonoArray*
2223 ves_icall_CustomAttributeBuilder_GetBlob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues);
2224
2225 MonoAssembly*
2226 mono_try_assembly_resolve_handle (MonoDomain *domain, MonoStringHandle fname, MonoAssembly *requesting, gboolean refonly, MonoError *error);
2227
2228 gboolean
2229 mono_runtime_object_init_handle (MonoObjectHandle this_obj, MonoError *error);
2230
2231 /* GC write barriers support */
2232 void
2233 mono_gc_wbarrier_object_copy_handle (MonoObjectHandle obj, MonoObjectHandle src);
2234
2235 MonoMethod*
2236 mono_class_get_virtual_method (MonoClass *klass, MonoMethod *method, gboolean is_proxy, MonoError *error);
2237
2238 MonoStringHandle
2239 mono_string_empty_handle (MonoDomain *domain);
2240
2241 gpointer
2242 mono_object_get_data (MonoObject *o);
2243
2244 #define mono_handle_get_data_unsafe(handle) ((gpointer)((guint8*)MONO_HANDLE_RAW (handle) + MONO_ABI_SIZEOF (MonoObject)))
2245
2246 gpointer
2247 mono_vtype_get_field_addr (gpointer vtype, MonoClassField *field);
2248
2249 #define MONO_OBJECT_SETREF_INTERNAL(obj,fieldname,value) do {   \
2250                 mono_gc_wbarrier_set_field_internal ((MonoObject*)(obj), &((obj)->fieldname), (MonoObject*)value);      \
2251                 /*(obj)->fieldname = (value);*/ \
2252         } while (0)
2253
2254 /* This should be used if 's' can reside on the heap */
2255 #define MONO_STRUCT_SETREF_INTERNAL(s,field,value) do { \
2256         mono_gc_wbarrier_generic_store_internal (&((s)->field), (MonoObject*)(value)); \
2257     } while (0)
2258
2259 mono_unichar2*
2260 mono_string_chars_internal (MonoString *s);
2261
2262 int
2263 mono_string_length_internal (MonoString *s);
2264
2265 MonoString*
2266 mono_string_empty_internal (MonoDomain *domain);
2267
2268 char *
2269 mono_string_to_utf8len (MonoStringHandle s, gsize *utf8len, MonoError *error);
2270
2271 char*
2272 mono_string_to_utf8_checked_internal (MonoString *string_obj, MonoError *error);
2273
2274 mono_bool
2275 mono_string_equal_internal (MonoString *s1, MonoString *s2);
2276
2277 unsigned
2278 mono_string_hash_internal (MonoString *s);
2279
2280 ICALL_EXPORT
2281 int
2282 mono_object_hash_internal (MonoObject* obj);
2283
2284 void
2285 mono_value_copy_internal (void* dest, /*const*/ void* src, MonoClass *klass);
2286
2287 void
2288 mono_value_copy_array_internal (MonoArray *dest, int dest_idx, const void* src, int count);
2289
2290 MONO_PROFILER_API MonoVTable* mono_object_get_vtable_internal (MonoObject *obj);
2291
2292 MonoDomain*
2293 mono_object_get_domain_internal (MonoObject *obj);
2294
2295 void*
2296 mono_object_unbox_internal (MonoObject *obj);
2297
2298 ICALL_EXPORT
2299 void
2300 mono_monitor_exit_internal (MonoObject *obj);
2301
2302 MONO_PROFILER_API unsigned mono_object_get_size_internal (MonoObject *o);
2303
2304 MONO_PROFILER_API MonoDomain* mono_vtable_domain_internal (MonoVTable *vtable);
2305
2306 MONO_PROFILER_API MonoClass* mono_vtable_class_internal (MonoVTable *vtable);
2307
2308 MonoMethod*
2309 mono_object_get_virtual_method_internal (MonoObject *obj, MonoMethod *method);
2310
2311 MonoMethod*
2312 mono_get_delegate_invoke_internal (MonoClass *klass);
2313
2314 MonoMethod*
2315 mono_get_delegate_begin_invoke_internal (MonoClass *klass);
2316
2317 MonoMethod*
2318 mono_get_delegate_end_invoke_internal (MonoClass *klass);
2319
2320 void
2321 mono_unhandled_exception_internal (MonoObject *exc);
2322
2323 void
2324 mono_print_unhandled_exception_internal (MonoObject *exc);
2325
2326 void
2327 mono_raise_exception_internal (MonoException *ex);
2328
2329 void
2330 mono_field_set_value_internal (MonoObject *obj, MonoClassField *field, void *value);
2331
2332 void
2333 mono_field_static_set_value_internal (MonoVTable *vt, MonoClassField *field, void *value);
2334
2335 void
2336 mono_field_get_value_internal (MonoObject *obj, MonoClassField *field, void *value);
2337
2338 MonoMethod* mono_get_context_capture_method (void);
2339
2340 guint8*
2341 mono_runtime_get_aotid_arr (void);
2342
2343 /* GC handles support
2344  *
2345  * A handle can be created to refer to a managed object and either prevent it
2346  * from being garbage collected or moved or to be able to know if it has been
2347  * collected or not (weak references).
2348  * mono_gchandle_new () is used to prevent an object from being garbage collected
2349  * until mono_gchandle_free() is called. Use a TRUE value for the pinned argument to
2350  * prevent the object from being moved (this should be avoided as much as possible
2351  * and this should be used only for shorts periods of time or performance will suffer).
2352  * To create a weakref use mono_gchandle_new_weakref (): track_resurrection should
2353  * usually be false (see the GC docs for more details).
2354  * mono_gchandle_get_target () can be used to get the object referenced by both kinds
2355  * of handle: for a weakref handle, if an object has been collected, it will return NULL.
2356  */
2357 uint32_t
2358 mono_gchandle_new_internal (MonoObject *obj, mono_bool pinned);
2359
2360 uint32_t
2361 mono_gchandle_new_weakref_internal (MonoObject *obj, mono_bool track_resurrection);
2362
2363 MonoObject*
2364 mono_gchandle_get_target_internal (uint32_t gchandle);
2365
2366 void mono_gchandle_free_internal (uint32_t gchandle);
2367
2368 /* Reference queue support
2369  *
2370  * A reference queue is used to get notifications of when objects are collected.
2371  * Call mono_gc_reference_queue_new to create a new queue and pass the callback that
2372  * will be invoked when registered objects are collected.
2373  * Call mono_gc_reference_queue_add to register a pair of objects and data within a queue.
2374  * The callback will be triggered once an object is both unreachable and finalized.
2375  */
2376 MonoReferenceQueue*
2377 mono_gc_reference_queue_new_internal (mono_reference_queue_callback callback);
2378
2379 void
2380 mono_gc_reference_queue_free_internal (MonoReferenceQueue *queue);
2381
2382 mono_bool
2383 mono_gc_reference_queue_add_internal (MonoReferenceQueue *queue, MonoObject *obj, void *user_data);
2384
2385 #define mono_gc_reference_queue_add_handle(queue, obj, user_data) \
2386         (mono_gc_reference_queue_add_internal ((queue), MONO_HANDLE_RAW (MONO_HANDLE_CAST (MonoObject, obj)), (user_data)))
2387
2388 /* GC write barriers support */
2389 void
2390 mono_gc_wbarrier_set_field_internal (MonoObject *obj, void* field_ptr, MonoObject* value);
2391
2392 void
2393 mono_gc_wbarrier_set_arrayref_internal  (MonoArray *arr, void* slot_ptr, MonoObject* value);
2394
2395 void
2396 mono_gc_wbarrier_arrayref_copy_internal (void* dest_ptr, void* src_ptr, int count);
2397
2398 void
2399 mono_gc_wbarrier_generic_store_internal (void* ptr, MonoObject* value);
2400
2401 void
2402 mono_gc_wbarrier_generic_store_atomic_internal (void *ptr, MonoObject *value);
2403
2404 void
2405 mono_gc_wbarrier_generic_nostore_internal (void* ptr);
2406
2407 void
2408 mono_gc_wbarrier_value_copy_internal (void* dest, /*const*/ void* src, int count, MonoClass *klass);
2409
2410 void
2411 mono_gc_wbarrier_object_copy_internal (MonoObject* obj, MonoObject *src);
2412
2413 #endif /* __MONO_OBJECT_INTERNALS_H__ */