mono/metadata/handle.h

   1 /*
   2  * handle.h: Handle to object in native code
   3  *
   4  * Authors:
   5  *  - Ludovic Henry <ludovic@xamarin.com>
   6  *  - Aleksey Klieger <aleksey.klieger@xamarin.com>
   7  *  - Rodrigo Kumpera <kumpera@xamarin.com>
   8  *
   9  * Copyright 2016 Dot net foundation.
  10  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  11  */
  12
  13 #ifndef __MONO_HANDLE_H__
  14 #define __MONO_HANDLE_H__
  15
  16 #include <config.h>
  17 #include <glib.h>
  18
  19 #include <mono/metadata/object.h>
  20 #include <mono/metadata/class.h>
  21 #include <mono/utils/mono-error-internals.h>
  22 #include <mono/utils/mono-threads.h>
  23 #include <mono/utils/checked-build.h>
  24
  25 G_BEGIN_DECLS
  26
  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 struct _HandleChunk {
  54         int size; //number of bytes
  55         HandleChunk *prev, *next;
  56         MonoObject *objects [OBJECTS_PER_HANDLES_CHUNK];
  57 };
  58
  59 typedef struct {
  60         HandleChunk *top; //alloc from here
  61         HandleChunk *bottom; //scan from here
  62 } HandleStack;
  63
  64 typedef struct {
  65         int size;
  66         HandleChunk *chunk;
  67 } HandleStackMark;
  68
  69 typedef void *MonoRawHandle;
  70
  71 typedef void (*GcScanFunc) (gpointer*, gpointer);
  72
  73
  74 MonoRawHandle mono_handle_new (MonoObject *object);
  75
  76 void mono_handle_stack_scan (HandleStack *stack, GcScanFunc func, gpointer gc_data);
  77 HandleStack* mono_handle_stack_alloc (void);
  78 void mono_handle_stack_free (HandleStack *handlestack);
  79 MonoRawHandle mono_stack_mark_pop_value (MonoThreadInfo *info, HandleStackMark *stackmark, MonoRawHandle value);
  80 void mono_stack_mark_record_size (MonoThreadInfo *info, HandleStackMark *stackmark, const char *func_name);
  81
  82 static inline void
  83 mono_stack_mark_init (MonoThreadInfo *info, HandleStackMark *stackmark)
  84 {
  85         HandleStack *handles = (HandleStack *)info->handle_stack;
  86         stackmark->size = handles->top->size;
  87         stackmark->chunk = handles->top;
  88 }
  89
  90 static inline void
  91 mono_stack_mark_pop (MonoThreadInfo *info, HandleStackMark *stackmark)
  92 {
  93         HandleStack *handles = (HandleStack *)info->handle_stack;
  94         handles->top->size = stackmark->size;
  95         mono_memory_write_barrier ();
  96         handles->top = stackmark->chunk;
  97 }
  98
  99 /*
 100 Icall macros
 101 */
 102 #define SETUP_ICALL_COMMON      \
 103         do { \
 104                 MonoError error;        \
 105                 MonoThreadInfo *__info = mono_thread_info_current ();   \
 106                 error_init (&error);    \
 107
 108 #define CLEAR_ICALL_COMMON      \
 109         mono_error_set_pending_exception (&error);
 110
 111 #define SETUP_ICALL_FRAME       \
 112         HandleStackMark __mark; \
 113         mono_stack_mark_init (__info, &__mark);
 114
 115 #define CLEAR_ICALL_FRAME       \
 116         mono_stack_mark_record_size (__info, &__mark, __FUNCTION__);    \
 117         mono_stack_mark_pop (__info, &__mark);
 118
 119 #ifdef MONO_NEEDS_STACK_WATERMARK
 120
 121 static void
 122 mono_thread_info_pop_stack_mark (MonoThreadInfo *info, void *old_mark)
 123 {
 124         info->stack_mark = old_mark;
 125 }
 126
 127 static void*
 128 mono_thread_info_push_stack_mark (MonoThreadInfo *info, void *mark)
 129 {
 130         void *old = info->stack_mark;
 131         info->stack_mark = mark;
 132         return old;
 133 }
 134
 135 #define SETUP_STACK_WATERMARK   \
 136         int __dummy;    \
 137         __builtin_unwind_init ();       \
 138         void *__old_stack_mark = mono_thread_info_push_stack_mark (__info, &__dummy);
 139
 140 #define CLEAR_STACK_WATERMARK   \
 141         mono_thread_info_pop_stack_mark (__info, __old_stack_mark);
 142
 143 #else
 144 #define SETUP_STACK_WATERMARK
 145 #define CLEAR_STACK_WATERMARK
 146 #endif
 147
 148 #define ICALL_ENTRY()   \
 149         SETUP_ICALL_COMMON      \
 150         SETUP_ICALL_FRAME       \
 151         SETUP_STACK_WATERMARK
 152
 153 #define ICALL_RETURN()  \
 154         do {    \
 155                 CLEAR_STACK_WATERMARK   \
 156                 CLEAR_ICALL_COMMON      \
 157                 CLEAR_ICALL_FRAME       \
 158                 return; \
 159         } while (0); } while (0)
 160
 161 #define ICALL_RETURN_VAL(VAL)   \
 162         do {    \
 163                 CLEAR_STACK_WATERMARK   \
 164                 CLEAR_ICALL_COMMON      \
 165                 CLEAR_ICALL_FRAME       \
 166                 return VAL;     \
 167         } while (0); } while (0)
 168
 169 #define ICALL_RETURN_OBJ(HANDLE)        \
 170         do {    \
 171                 CLEAR_STACK_WATERMARK   \
 172                 CLEAR_ICALL_COMMON      \
 173                 void* __ret = MONO_HANDLE_RAW (HANDLE); \
 174                 CLEAR_ICALL_FRAME       \
 175                 return __ret;   \
 176         } while (0); } while (0)
 177
 178 /*
 179 Handle macros/functions
 180 */
 181
 182 #ifdef ENABLE_CHECKED_BUILD
 183 void mono_handle_verify (MonoRawHandle handle);
 184 #define HANDLE_INVARIANTS(H) mono_handle_verify((void*)(H))
 185 #else
 186 #define HANDLE_INVARIANTS(H) (0)
 187 #endif
 188
 189 #define TYPED_HANDLE_PAYLOAD_NAME(TYPE) TYPE ## HandlePayload
 190 #define TYPED_HANDLE_NAME(TYPE) TYPE ## Handle
 191
 192 /*
 193  * TYPED_HANDLE_DECL(SomeType):
 194  *   Expands to a decl for handles to SomeType and to an internal payload struct.
 195  *
 196  * For example, TYPED_HANDLE_DECL(MonoObject) (see below) expands to:
 197  *
 198  * typedef struct {
 199  *   MonoObject *__obj;
 200  * } MonoObjectHandlePayload;
 201  *
 202  * typedef MonoObjectHandlePayload* MonoObjectHandle;
 203  */
 204 #define TYPED_HANDLE_DECL(TYPE) typedef struct { TYPE *__obj; } TYPED_HANDLE_PAYLOAD_NAME (TYPE) ; typedef TYPED_HANDLE_PAYLOAD_NAME (TYPE) * TYPED_HANDLE_NAME (TYPE)
 205 /* Have to double expand because MONO_STRUCT_OFFSET is doing token pasting on cross-compilers. */
 206 #define MONO_HANDLE_PAYLOAD_OFFSET_(PayloadType) MONO_STRUCT_OFFSET(PayloadType, __obj)
 207 #define MONO_HANDLE_PAYLOAD_OFFSET(TYPE) MONO_HANDLE_PAYLOAD_OFFSET_(TYPED_HANDLE_PAYLOAD_NAME (TYPE))
 208
 209 #define MONO_HANDLE_INIT ((void*) mono_null_value_handle)
 210 #define NULL_HANDLE mono_null_value_handle
 211
 212 //XXX add functions to get/set raw, set field, set field to null, set array, set array to null
 213 #define MONO_HANDLE_RAW(HANDLE) (HANDLE_INVARIANTS (HANDLE), ((HANDLE)->__obj))
 214 #define MONO_HANDLE_DCL(TYPE, NAME) TYPED_HANDLE_NAME(TYPE) NAME = (TYPED_HANDLE_NAME(TYPE))(mono_handle_new ((MonoObject*)(NAME ## _raw)))
 215 #define MONO_HANDLE_NEW(TYPE, VALUE) (TYPED_HANDLE_NAME(TYPE))( mono_handle_new ((MonoObject*)(VALUE)) )
 216 #define MONO_HANDLE_CAST(TYPE, VALUE) (TYPED_HANDLE_NAME(TYPE))( VALUE )
 217
 218 /*
 219 WARNING WARNING WARNING
 220
 221 The following functions require a particular evaluation ordering to ensure correctness.
 222 We must not have exposed handles while any sort of evaluation is happening as that very evaluation might trigger
 223 a safepoint and break us.
 224
 225 This is why we evaluate index and value before any call to MONO_HANDLE_RAW or other functions that deal with naked objects.
 226 */
 227 #define MONO_HANDLE_SETRAW(HANDLE, FIELD, VALUE) do {   \
 228                 MonoObject *__val = (MonoObject*)(VALUE);       \
 229                 MONO_OBJECT_SETREF (MONO_HANDLE_RAW (HANDLE), FIELD, __val);    \
 230         } while (0);
 231
 232 #define MONO_HANDLE_SET(HANDLE, FIELD, VALUE) do {      \
 233                 MonoObjectHandle __val = MONO_HANDLE_CAST (MonoObject, VALUE);  \
 234                 MONO_OBJECT_SETREF (MONO_HANDLE_RAW (HANDLE), FIELD, MONO_HANDLE_RAW (__val));  \
 235         } while (0);
 236
 237 /* VS doesn't support typeof :( :( :( */
 238 #define MONO_HANDLE_SETVAL(HANDLE, FIELD, TYPE, VALUE) do {     \
 239                 TYPE __val = (VALUE);   \
 240                 MONO_HANDLE_RAW (HANDLE)->FIELD = __val;        \
 241          } while (0)
 242
 243 #define MONO_HANDLE_ARRAY_SETREF(HANDLE, IDX, VALUE) do {       \
 244                 int __idx = (IDX);      \
 245                 MonoObjectHandle __val = MONO_HANDLE_CAST (MonoObject, VALUE);          \
 246                 mono_array_setref_fast (MONO_HANDLE_RAW (HANDLE), __idx, MONO_HANDLE_RAW (__val));      \
 247         } while (0)
 248
 249 #define MONO_HANDLE_ARRAY_SETRAW(HANDLE, IDX, VALUE) do {       \
 250                 int __idx = (IDX);      \
 251                 MonoObject *__val = (MonoObject*)(VALUE);       \
 252                 mono_array_setref_fast (MONO_HANDLE_RAW (HANDLE), __idx, __val);        \
 253         } while (0)
 254
 255
 256 #define MONO_HANDLE_DOMAIN(HANDLE) (mono_object_domain (MONO_HANDLE_RAW (MONO_HANDLE_CAST (MonoObject, HANDLE))))
 257
 258 /* Baked typed handles we all want */
 259 TYPED_HANDLE_DECL (MonoString);
 260 TYPED_HANDLE_DECL (MonoArray);
 261 TYPED_HANDLE_DECL (MonoObject);
 262
 263 #define NULL_HANDLE_STRING MONO_HANDLE_CAST(MonoString, NULL_HANDLE)
 264
 265 /*
 266 This is the constant for a handle that points nowhere.
 267 Init values to it.
 268 */
 269 extern const MonoObjectHandle mono_null_value_handle;
 270
 271
 272 //FIXME this should go somewhere else
 273 MonoStringHandle mono_string_new_handle (MonoDomain *domain, const char *data, MonoError *error);
 274 MonoArrayHandle mono_array_new_handle (MonoDomain *domain, MonoClass *eclass, uintptr_t n, MonoError *error);
 275
 276 G_END_DECLS
 277
 278 #endif /* __MONO_HANDLE_H__ */