mono/metadata/handle.h

   1 /**
   2  * \file
   3  * Handle to object in native code
   4  *
   5  * Authors:
   6  *  - Ludovic Henry <ludovic@xamarin.com>
   7  *  - Aleksey Klieger <aleksey.klieger@xamarin.com>
   8  *  - Rodrigo Kumpera <kumpera@xamarin.com>
   9  *
  10  * Copyright 2016 Dot net foundation.
  11  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  12  */
  13
  14 #ifndef __MONO_HANDLE_H__
  15 #define __MONO_HANDLE_H__
  16
  17 #include <config.h>
  18 #include <glib.h>
  19
  20 #include <mono/metadata/object.h>
  21 #include <mono/metadata/class.h>
  22 #include <mono/utils/mono-error-internals.h>
  23 #include <mono/utils/mono-threads.h>
  24 #include <mono/utils/checked-build.h>
  25
  26 G_BEGIN_DECLS
  27
  28 /*
  29 Handle stack.
  30
  31 The handle stack is designed so it's efficient to pop a large amount of entries at once.
  32 The stack is made out of a series of fixed size segments.
  33
  34 To do bulk operations you use a stack mark.
  35
  36 */
  37
  38 /*
  39 3 is the number of fields besides the data in the struct;
  40 128 words makes each chunk 512 or 1024 bytes each
  41 */
  42 #define OBJECTS_PER_HANDLES_CHUNK (128 - 3)
  43
  44 /*
  45 Whether this config needs stack watermark recording to know where to start scanning from.
  46 */
  47 #ifdef HOST_WATCHOS
  48 #define MONO_NEEDS_STACK_WATERMARK 1
  49 #endif
  50
  51 typedef struct _HandleChunk HandleChunk;
  52
  53 /* define MONO_HANDLE_TRACK_OWNER to store the file and line number of each call to MONO_HANDLE_NEW
  54  * in the handle stack.  (This doubles the amount of memory used for handles, so it's only useful for debugging).
  55  */
  56 /*#define MONO_HANDLE_TRACK_OWNER*/
  57
  58 /* define MONO_HANDLE_TRACK_SP to record the C stack pointer at the time of each HANDLE_FUNCTION_ENTER and
  59  * to ensure that when a new handle is allocated the previous newest handle is not lower in the stack.
  60  * This is useful to catch missing HANDLE_FUNCTION_ENTER / HANDLE_FUNCTION_RETURN pairs which could cause
  61  * handle leaks.
  62  */
  63 /*#define MONO_HANDLE_TRACK_SP*/
  64
  65 typedef struct {
  66         gpointer o; /* MonoObject ptr or interior ptr */
  67 #ifdef MONO_HANDLE_TRACK_OWNER
  68         const char *owner;
  69         gpointer backtrace_ips[7]; /* result of backtrace () at time of allocation */
  70 #endif
  71 #ifdef MONO_HANDLE_TRACK_SP
  72         gpointer alloc_sp; /* sp from HandleStack:stackmark_sp at time of allocation */
  73 #endif
  74 } HandleChunkElem;
  75
  76 struct _HandleChunk {
  77         int size; //number of handles
  78         HandleChunk *prev, *next;
  79         HandleChunkElem elems [OBJECTS_PER_HANDLES_CHUNK];
  80 };
  81
  82 typedef struct {
  83         HandleChunk *top; //alloc from here
  84         HandleChunk *bottom; //scan from here
  85 #ifdef MONO_HANDLE_TRACK_SP
  86         gpointer stackmark_sp; // C stack pointer top when from most recent mono_stack_mark_init
  87 #endif
  88         /* Chunk for storing interior pointers. Not extended right now */
  89         HandleChunk *interior;
  90 } HandleStack;
  91
  92 // Keep this in sync with RuntimeStructs.cs
  93 typedef struct {
  94         int size, interior_size;
  95         HandleChunk *chunk;
  96 #ifdef MONO_HANDLE_TRACK_SP
  97         gpointer prev_sp; // C stack pointer from prior mono_stack_mark_init
  98 #endif
  99 } HandleStackMark;
 100
 101 typedef void *MonoRawHandle;
 102
 103 typedef void (*GcScanFunc) (gpointer*, gpointer);
 104
 105
 106 #ifndef MONO_HANDLE_TRACK_OWNER
 107 MonoRawHandle mono_handle_new (MonoObject *object);
 108 MonoRawHandle mono_handle_new_full (gpointer rawptr, gboolean interior);
 109 MonoRawHandle mono_handle_new_interior (gpointer rawptr);
 110 #else
 111 MonoRawHandle mono_handle_new (MonoObject *object, const char* owner);
 112 MonoRawHandle mono_handle_new_full (gpointer rawptr, gboolean interior, const char *owner);
 113 MonoRawHandle mono_handle_new_interior (gpointer rawptr, const char *owner);
 114 #endif
 115
 116 void mono_handle_stack_scan (HandleStack *stack, GcScanFunc func, gpointer gc_data, gboolean precise);
 117 gboolean mono_handle_stack_is_empty (HandleStack *stack);
 118 HandleStack* mono_handle_stack_alloc (void);
 119 void mono_handle_stack_free (HandleStack *handlestack);
 120 MonoRawHandle mono_stack_mark_pop_value (MonoThreadInfo *info, HandleStackMark *stackmark, MonoRawHandle value);
 121 void mono_stack_mark_record_size (MonoThreadInfo *info, HandleStackMark *stackmark, const char *func_name);
 122 void mono_handle_stack_free_domain (HandleStack *stack, MonoDomain *domain);
 123
 124 #ifdef MONO_HANDLE_TRACK_SP
 125 void mono_handle_chunk_leak_check (HandleStack *handles);
 126 #endif
 127
 128 static inline void
 129 mono_stack_mark_init (MonoThreadInfo *info, HandleStackMark *stackmark)
 130 {
 131 #ifdef MONO_HANDLE_TRACK_SP
 132         gpointer sptop = (gpointer)(intptr_t)&stackmark;
 133 #endif
 134         HandleStack *handles = (HandleStack *)info->handle_stack;
 135         stackmark->size = handles->top->size;
 136         stackmark->chunk = handles->top;
 137         stackmark->interior_size = handles->interior->size;
 138 #ifdef MONO_HANDLE_TRACK_SP
 139         stackmark->prev_sp = handles->stackmark_sp;
 140         handles->stackmark_sp = sptop;
 141 #endif
 142 }
 143
 144 static inline void
 145 mono_stack_mark_pop (MonoThreadInfo *info, HandleStackMark *stackmark)
 146 {
 147         HandleStack *handles = (HandleStack *)info->handle_stack;
 148         HandleChunk *old_top = stackmark->chunk;
 149         old_top->size = stackmark->size;
 150         mono_memory_write_barrier ();
 151         handles->top = old_top;
 152         handles->interior->size = stackmark->interior_size;
 153 #ifdef MONO_HANDLE_TRACK_SP
 154         mono_memory_write_barrier (); /* write to top before prev_sp */
 155         handles->stackmark_sp = stackmark->prev_sp;
 156 #endif
 157 }
 158
 159 /*
 160 Icall macros
 161 */
 162 #define SETUP_ICALL_COMMON      \
 163         do { \
 164                 MonoError error;        \
 165                 MonoThreadInfo *__info = mono_thread_info_current ();   \
 166                 error_init (&error);    \
 167
 168 #define CLEAR_ICALL_COMMON      \
 169         mono_error_set_pending_exception (&error);
 170
 171 #define SETUP_ICALL_FRAME       \
 172         HandleStackMark __mark; \
 173         mono_stack_mark_init (__info, &__mark);
 174
 175 #define CLEAR_ICALL_FRAME       \
 176         mono_stack_mark_record_size (__info, &__mark, __FUNCTION__);    \
 177         mono_stack_mark_pop (__info, &__mark);
 178
 179 #define CLEAR_ICALL_FRAME_VALUE(RESULT, HANDLE)                         \
 180         mono_stack_mark_record_size (__info, &__mark, __FUNCTION__);    \
 181         (RESULT) = mono_stack_mark_pop_value (__info, &__mark, (HANDLE));
 182
 183
 184 #define HANDLE_FUNCTION_ENTER() do {                            \
 185         MonoThreadInfo *__info = mono_thread_info_current ();   \
 186         SETUP_ICALL_FRAME                                       \
 187
 188 #define HANDLE_FUNCTION_RETURN()                \
 189         CLEAR_ICALL_FRAME;                      \
 190         } while (0)
 191
 192 #define HANDLE_FUNCTION_RETURN_VAL(VAL)         \
 193         CLEAR_ICALL_FRAME;                      \
 194         return (VAL);                           \
 195         } while (0)
 196
 197 #define HANDLE_FUNCTION_RETURN_OBJ(HANDLE)                      \
 198         do {                                                    \
 199                 void* __result = (MONO_HANDLE_RAW (HANDLE));    \
 200                 CLEAR_ICALL_FRAME;                              \
 201                 return __result;                                \
 202         } while (0); } while (0);
 203
 204 #define HANDLE_FUNCTION_RETURN_REF(TYPE, HANDLE)                        \
 205         do {                                                            \
 206                 MonoRawHandle __result;                                 \
 207                 CLEAR_ICALL_FRAME_VALUE (__result, ((MonoRawHandle) (HANDLE))); \
 208                 return MONO_HANDLE_CAST (TYPE, __result);               \
 209         } while (0); } while (0);
 210
 211 #ifdef MONO_NEEDS_STACK_WATERMARK
 212
 213 static void
 214 mono_thread_info_pop_stack_mark (MonoThreadInfo *info, void *old_mark)
 215 {
 216         info->stack_mark = old_mark;
 217 }
 218
 219 static void*
 220 mono_thread_info_push_stack_mark (MonoThreadInfo *info, void *mark)
 221 {
 222         void *old = info->stack_mark;
 223         info->stack_mark = mark;
 224         return old;
 225 }
 226
 227 #define SETUP_STACK_WATERMARK   \
 228         int __dummy;    \
 229         __builtin_unwind_init ();       \
 230         void *__old_stack_mark = mono_thread_info_push_stack_mark (__info, &__dummy);
 231
 232 #define CLEAR_STACK_WATERMARK   \
 233         mono_thread_info_pop_stack_mark (__info, __old_stack_mark);
 234
 235 #else
 236 #define SETUP_STACK_WATERMARK
 237 #define CLEAR_STACK_WATERMARK
 238 #endif
 239
 240 #define ICALL_ENTRY()   \
 241         SETUP_ICALL_COMMON      \
 242         SETUP_ICALL_FRAME       \
 243         SETUP_STACK_WATERMARK
 244
 245 #define ICALL_RETURN()  \
 246         do {    \
 247                 CLEAR_STACK_WATERMARK   \
 248                 CLEAR_ICALL_COMMON      \
 249                 CLEAR_ICALL_FRAME       \
 250                 return; \
 251         } while (0); } while (0)
 252
 253 #define ICALL_RETURN_VAL(VAL)   \
 254         do {    \
 255                 CLEAR_STACK_WATERMARK   \
 256                 CLEAR_ICALL_COMMON      \
 257                 CLEAR_ICALL_FRAME       \
 258                 return VAL;     \
 259         } while (0); } while (0)
 260
 261 #define ICALL_RETURN_OBJ(HANDLE)        \
 262         do {    \
 263                 CLEAR_STACK_WATERMARK   \
 264                 CLEAR_ICALL_COMMON      \
 265                 void* __ret = MONO_HANDLE_RAW (HANDLE); \
 266                 CLEAR_ICALL_FRAME       \
 267                 return __ret;   \
 268         } while (0); } while (0)
 269
 270 /*
 271 Handle macros/functions
 272 */
 273
 274 #ifdef ENABLE_CHECKED_BUILD
 275 void mono_handle_verify (MonoRawHandle handle);
 276 #define HANDLE_INVARIANTS(H) mono_handle_verify((void*)(H))
 277 #else
 278 #define HANDLE_INVARIANTS(H) (0)
 279 #endif
 280
 281 #define TYPED_HANDLE_PAYLOAD_NAME(TYPE) TYPE ## HandlePayload
 282 #define TYPED_HANDLE_NAME(TYPE) TYPE ## Handle
 283 #define TYPED_OUT_HANDLE_NAME(TYPE) TYPE ## HandleOut
 284
 285 #ifdef MONO_HANDLE_TRACK_OWNER
 286 #define STRINGIFY_(x) #x
 287 #define STRINGIFY(x) STRINGIFY_(x)
 288 #define HANDLE_OWNER_STRINGIFY(file,lineno) (const char*) (file ":" STRINGIFY(lineno))
 289 #endif
 290
 291
 292 /*
 293  * TYPED_HANDLE_DECL(SomeType):
 294  *   Expands to a decl for handles to SomeType and to an internal payload struct.
 295  *
 296  * For example, TYPED_HANDLE_DECL(MonoObject) (see below) expands to:
 297  *
 298  * typedef struct {
 299  *   MonoObject *__raw;
 300  * } MonoObjectHandlePayload;
 301  *
 302  * typedef MonoObjectHandlePayload* MonoObjectHandle;
 303  * typedef MonoObjectHandlePayload* MonoObjectHandleOut;
 304  */
 305 #define TYPED_HANDLE_DECL(TYPE)                                         \
 306         typedef struct { TYPE *__raw; } TYPED_HANDLE_PAYLOAD_NAME (TYPE) ; \
 307         typedef TYPED_HANDLE_PAYLOAD_NAME (TYPE) * TYPED_HANDLE_NAME (TYPE); \
 308         typedef TYPED_HANDLE_PAYLOAD_NAME (TYPE) * TYPED_OUT_HANDLE_NAME (TYPE)
 309 /*
 310  * TYPED_VALUE_HANDLE_DECL(SomeType):
 311  *   Expands to a decl for handles to SomeType (which is a managed valuetype (likely a struct) of some sort) and to an internal payload struct.
 312  * For example TYPED_HANDLE_DECL(MonoMethodInfo) expands to:
 313  *
 314  * typedef struct {
 315  *   MonoMethodInfo *__raw;
 316  * } MonoMethodInfoHandlePayload;
 317  * typedef MonoMethodInfoHandlePayload* MonoMethodInfoHandle;
 318  */
 319 #define TYPED_VALUE_HANDLE_DECL(TYPE) TYPED_HANDLE_DECL(TYPE)
 320
 321 /* Have to double expand because MONO_STRUCT_OFFSET is doing token pasting on cross-compilers. */
 322 #define MONO_HANDLE_PAYLOAD_OFFSET_(PayloadType) MONO_STRUCT_OFFSET(PayloadType, __raw)
 323 #define MONO_HANDLE_PAYLOAD_OFFSET(TYPE) MONO_HANDLE_PAYLOAD_OFFSET_(TYPED_HANDLE_PAYLOAD_NAME (TYPE))
 324
 325 #define MONO_HANDLE_INIT ((void*) mono_null_value_handle)
 326 #define NULL_HANDLE mono_null_value_handle
 327
 328 //XXX add functions to get/set raw, set field, set field to null, set array, set array to null
 329 #define MONO_HANDLE_RAW(HANDLE) (HANDLE_INVARIANTS (HANDLE), ((HANDLE)->__raw))
 330 #define MONO_HANDLE_DCL(TYPE, NAME) TYPED_HANDLE_NAME(TYPE) NAME = MONO_HANDLE_NEW (TYPE, (NAME ## _raw))
 331
 332 #ifndef MONO_HANDLE_TRACK_OWNER
 333 #define MONO_HANDLE_NEW(TYPE, VALUE) (TYPED_HANDLE_NAME(TYPE))( mono_handle_new ((MonoObject*)(VALUE)) )
 334 #else
 335 #define MONO_HANDLE_NEW(TYPE, VALUE) (TYPED_HANDLE_NAME(TYPE))( mono_handle_new ((MonoObject*)(VALUE), HANDLE_OWNER_STRINGIFY(__FILE__, __LINE__)))
 336 #endif
 337
 338 #define MONO_HANDLE_CAST(TYPE, VALUE) (TYPED_HANDLE_NAME(TYPE))( VALUE )
 339
 340 #define MONO_HANDLE_IS_NULL(HANDLE) (MONO_HANDLE_RAW(HANDLE) == NULL)
 341
 342
 343 /*
 344 WARNING WARNING WARNING
 345
 346 The following functions require a particular evaluation ordering to ensure correctness.
 347 We must not have exposed handles while any sort of evaluation is happening as that very evaluation might trigger
 348 a safepoint and break us.
 349
 350 This is why we evaluate index and value before any call to MONO_HANDLE_RAW or other functions that deal with naked objects.
 351 */
 352 #define MONO_HANDLE_SETRAW(HANDLE, FIELD, VALUE) do {   \
 353                 MonoObject *__val = (MonoObject*)(VALUE);       \
 354                 MONO_OBJECT_SETREF (MONO_HANDLE_RAW (HANDLE), FIELD, __val);    \
 355         } while (0)
 356
 357 #define MONO_HANDLE_SET(HANDLE, FIELD, VALUE) do {      \
 358                 MonoObjectHandle __val = MONO_HANDLE_CAST (MonoObject, VALUE);  \
 359                 MONO_OBJECT_SETREF (MONO_HANDLE_RAW (HANDLE), FIELD, MONO_HANDLE_RAW (__val));  \
 360         } while (0)
 361
 362 /* N.B. RESULT is evaluated before HANDLE */
 363 #define MONO_HANDLE_GET(RESULT, HANDLE, FIELD) do {                     \
 364                 MonoObjectHandle __dest = MONO_HANDLE_CAST(MonoObject, RESULT); \
 365                 mono_gc_wbarrier_generic_store (&__dest->__raw,  (MonoObject*)(MONO_HANDLE_RAW(HANDLE)->FIELD)); \
 366         } while (0)
 367
 368 #define MONO_HANDLE_NEW_GET(TYPE,HANDLE,FIELD) (MONO_HANDLE_NEW(TYPE,MONO_HANDLE_RAW(HANDLE)->FIELD))
 369
 370 #define MONO_HANDLE_GETVAL(HANDLE, FIELD) (MONO_HANDLE_RAW(HANDLE)->FIELD)
 371
 372 /* VS doesn't support typeof :( :( :( */
 373 #define MONO_HANDLE_SETVAL(HANDLE, FIELD, TYPE, VALUE) do {     \
 374                 TYPE __val = (VALUE);   \
 375                 MONO_HANDLE_RAW (HANDLE)->FIELD = __val;        \
 376          } while (0)
 377
 378 #define MONO_HANDLE_ARRAY_SETREF(HANDLE, IDX, VALUE) do {       \
 379                 int __idx = (IDX);      \
 380                 MonoObjectHandle __val = MONO_HANDLE_CAST (MonoObject, VALUE);          \
 381                 mono_array_setref_fast (MONO_HANDLE_RAW (HANDLE), __idx, MONO_HANDLE_RAW (__val));      \
 382         } while (0)
 383
 384 #define MONO_HANDLE_ARRAY_SETVAL(HANDLE, TYPE, IDX, VALUE) do {         \
 385                 int __idx = (IDX);                                      \
 386                 TYPE __val = (VALUE);                   \
 387                 mono_array_set (MONO_HANDLE_RAW (HANDLE), TYPE, __idx, __val); \
 388         } while (0)
 389
 390 #define MONO_HANDLE_ARRAY_SETRAW(HANDLE, IDX, VALUE) do {       \
 391                 int __idx = (IDX);      \
 392                 MonoObject *__val = (MonoObject*)(VALUE);       \
 393                 mono_array_setref_fast (MONO_HANDLE_RAW (HANDLE), __idx, __val); \
 394         } while (0)
 395
 396 /* N.B. DEST is evaluated AFTER all the other arguments */
 397 #define MONO_HANDLE_ARRAY_GETVAL(DEST, HANDLE, TYPE, IDX) do {          \
 398                 MonoArrayHandle __arr = (HANDLE);                       \
 399                 int __idx = (IDX);                                      \
 400                 TYPE __result = mono_array_get (MONO_HANDLE_RAW(__arr), TYPE, __idx); \
 401                 (DEST) =  __result;                                     \
 402         } while (0)
 403
 404 #define MONO_HANDLE_ARRAY_GETREF(DEST, HANDLE, IDX) do {                \
 405                 mono_handle_array_getref (MONO_HANDLE_CAST(MonoObject, (DEST)), (HANDLE), (IDX)); \
 406         } while (0)
 407
 408 #define MONO_HANDLE_ASSIGN(DESTH, SRCH)                         \
 409         mono_handle_assign (MONO_HANDLE_CAST (MonoObject, (DESTH)), MONO_HANDLE_CAST(MonoObject, (SRCH)))
 410
 411 #define MONO_HANDLE_DOMAIN(HANDLE) (mono_object_domain (MONO_HANDLE_RAW (MONO_HANDLE_CAST (MonoObject, HANDLE))))
 412
 413 /* Given an object and a MonoClassField, return the value (must be non-object)
 414  * of the field.  It's the caller's responsibility to check that the object is
 415  * of the correct class. */
 416 #define MONO_HANDLE_GET_FIELD_VAL(HANDLE,TYPE,FIELD) *(TYPE *)(mono_handle_unsafe_field_addr (MONO_HANDLE_CAST (MonoObject, (HANDLE)), (FIELD)))
 417
 418 #define MONO_HANDLE_NEW_GET_FIELD(HANDLE,TYPE,FIELD) MONO_HANDLE_NEW (TYPE, *(TYPE**)(mono_handle_unsafe_field_addr (MONO_HANDLE_CAST (MonoObject, (HANDLE)), (FIELD))))
 419
 420 #define MONO_HANDLE_SET_FIELD_VAL(HANDLE,TYPE,FIELD,VAL) do {           \
 421                 MonoObjectHandle __obj = (HANDLE);                      \
 422                 MonoClassField *__field = (FIELD);                      \
 423                 TYPE __value = (VAL);                                   \
 424                 *(TYPE*)(mono_handle_unsafe_field_addr (__obj, __field)) = __value; \
 425         } while (0)
 426
 427 #define MONO_HANDLE_SET_FIELD_REF(HANDLE,FIELD,VALH) do {               \
 428                 MonoObjectHandle __obj = MONO_HANDLE_CAST (MonoObject, (HANDLE)); \
 429                 MonoClassField *__field = (FIELD);                      \
 430                 MonoObjectHandle __value = MONO_HANDLE_CAST (MonoObject, (VALH)); \
 431                 mono_gc_wbarrier_generic_store (mono_handle_unsafe_field_addr (__obj, __field), MONO_HANDLE_RAW (__value)); \
 432         } while (0)
 433
 434 /* Baked typed handles we all want */
 435 TYPED_HANDLE_DECL (MonoString);
 436 TYPED_HANDLE_DECL (MonoArray);
 437 TYPED_HANDLE_DECL (MonoObject);
 438 TYPED_HANDLE_DECL (MonoException);
 439 TYPED_HANDLE_DECL (MonoAppContext);
 440
 441 /* Unfortunately MonoThreadHandle is already a typedef used for something unrelated.  So
 442  * the coop handle for MonoThread* is MonoThreadObjectHandle.
 443  */
 444 typedef MonoThread MonoThreadObject;
 445 TYPED_HANDLE_DECL (MonoThreadObject);
 446
 447 #define NULL_HANDLE_STRING MONO_HANDLE_CAST(MonoString, NULL_HANDLE)
 448
 449 /*
 450 This is the constant for a handle that points nowhere.
 451 Init values to it.
 452 */
 453 extern const MonoObjectHandle mono_null_value_handle;
 454
 455 static inline void
 456 mono_handle_assign (MonoObjectHandleOut dest, MonoObjectHandle src)
 457 {
 458         mono_gc_wbarrier_generic_store (&dest->__raw, src ? MONO_HANDLE_RAW(src) : NULL);
 459 }
 460
 461 /* It is unsafe to call this function directly - it does not pin the handle!  Use MONO_HANDLE_GET_FIELD_VAL(). */
 462 static inline gchar*
 463 mono_handle_unsafe_field_addr (MonoObjectHandle h, MonoClassField *field)
 464 {
 465         return ((gchar *)MONO_HANDLE_RAW (h)) + field->offset;
 466 }
 467
 468 //FIXME this should go somewhere else
 469 MonoStringHandle mono_string_new_handle (MonoDomain *domain, const char *data, MonoError *error);
 470 MonoArrayHandle mono_array_new_handle (MonoDomain *domain, MonoClass *eclass, uintptr_t n, MonoError *error);
 471 MonoArrayHandle
 472 mono_array_new_full_handle (MonoDomain *domain, MonoClass *array_class, uintptr_t *lengths, intptr_t *lower_bounds, MonoError *error);
 473
 474
 475 uintptr_t mono_array_handle_length (MonoArrayHandle arr);
 476
 477 static inline void
 478 mono_handle_array_getref (MonoObjectHandleOut dest, MonoArrayHandle array, uintptr_t index)
 479 {
 480         mono_gc_wbarrier_generic_store (&dest->__raw, mono_array_get (MONO_HANDLE_RAW (array),gpointer, index));
 481 }
 482
 483 #define mono_handle_class(o) mono_object_class (MONO_HANDLE_RAW (o))
 484
 485 /* Local handles to global GC handles and back */
 486
 487 uint32_t
 488 mono_gchandle_from_handle (MonoObjectHandle handle, mono_bool pinned);
 489
 490 MonoObjectHandle
 491 mono_gchandle_get_target_handle (uint32_t gchandle);
 492
 493 void
 494 mono_array_handle_memcpy_refs (MonoArrayHandle dest, uintptr_t dest_idx, MonoArrayHandle src, uintptr_t src_idx, uintptr_t len);
 495
 496 /* Pins the MonoArray using a gchandle and returns a pointer to the
 497  * element with the given index (where each element is of the given
 498  * size.  Call mono_gchandle_free to unpin.
 499  */
 500 gpointer
 501 mono_array_handle_pin_with_size (MonoArrayHandle handle, int size, uintptr_t index, uint32_t *gchandle);
 502
 503 #define MONO_ARRAY_HANDLE_PIN(handle,type,index,gchandle_out) mono_array_handle_pin_with_size (MONO_HANDLE_CAST(MonoArray,(handle)), sizeof (type), (index), (gchandle_out))
 504
 505 gunichar2 *
 506 mono_string_handle_pin_chars (MonoStringHandle s, uint32_t *gchandle_out);
 507
 508 gpointer
 509 mono_object_handle_pin_unbox (MonoObjectHandle boxed_valuetype_obj, uint32_t *gchandle_out);
 510
 511 void
 512 mono_error_set_exception_handle (MonoError *error, MonoExceptionHandle exc);
 513
 514 MonoAppContextHandle
 515 mono_context_get_handle (void);
 516
 517 void
 518 mono_context_set_handle (MonoAppContextHandle new_context);
 519
 520 G_END_DECLS
 521
 522 #endif /* __MONO_HANDLE_H__ */