luhenry · lambdageek · Jan 6, 2016 · Jan 6, 2016 · Jan 6, 2016 · Jan 6, 2016
diff --git a/mono/metadata/Makefile.am b/mono/metadata/Makefile.am
@@ -217,7 +217,7 @@ common_sources = \
 	seq-points-data.c	\
 	handle.c	\
 	handle.h	\
-	handle-private.h
+	handle-arena.h
 
 
 # These source files have compile time dependencies on GC code

diff --git a/mono/metadata/boehm-gc.c b/mono/metadata/boehm-gc.c
@@ -1868,4 +1868,34 @@ mono_gchandle_free_domain (MonoDomain *domain)
 
 }
 
+/* Handle API specifics */
+
+MONO_HANDLE_TYPE (MonoObject)
+mono_handle_gc_alloc_obj (MonoVTable *vtable, size_t size, MonoError *error)
+{
+	/* FIXME: in case of OOM, an exception will be thown and we will unwind the native stack */
+	g_error ("not implemented");
+}
+
+MONO_HANDLE_TYPE (MonoArray)
+mono_handle_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length, MonoError *error)
+{
+	/* FIXME: in case of OOM, an exception will be thown and we will unwind the native stack */
+	g_error ("not implemented");
+}
+
+MONO_HANDLE_TYPE (MonoArray)
+mono_handle_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uintptr_t bounds_size, MonoError *error)
+{
+	/* FIXME: in case of OOM, an exception will be thown and we will unwind the native stack */
+	g_error ("not implemented");
+}
+
+MONO_HANDLE_TYPE (MonoString)
+mono_handle_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len, MonoError *error)
+{
+	/* FIXME: in case of OOM, an exception will be thown and we will unwind the native stack */
+	g_error ("not implemented");
+}
+
 #endif /* no Boehm GC */
diff --git a/mono/metadata/gc-internals.h b/mono/metadata/gc-internals.h
@@ -155,6 +155,12 @@ void* mono_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length
 void* mono_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len);
 MonoGCDescriptor mono_gc_make_descr_for_string (gsize *bitmap, int numbits);
 
+MONO_HANDLE_TYPE (MonoObject) mono_handle_gc_alloc_pinned_obj (MonoVTable *vtable, size_t size, MonoError *error);
+MONO_HANDLE_TYPE (MonoObject) mono_handle_gc_alloc_obj (MonoVTable *vtable, size_t size, MonoError *error);
+MONO_HANDLE_TYPE (MonoArray) mono_handle_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length, MonoError *error);
+MONO_HANDLE_TYPE (MonoArray) mono_handle_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uintptr_t bounds_size, MonoError *error);
+MONO_HANDLE_TYPE (MonoString) mono_handle_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len, MonoError *error);
+
 void  mono_gc_register_for_finalization (MonoObject *obj, void *user_data);
 void  mono_gc_add_memory_pressure (gint64 value);
 MONO_API int   mono_gc_register_root (char *start, size_t size, MonoGCDescriptor descr, MonoGCRootSource source, const char *msg);

diff --git a/mono/metadata/handle-arena.h b/mono/metadata/handle-arena.h
@@ -0,0 +1,55 @@
+#ifndef __MONO_HANDLE_PRIVATE_H__
+#define __MONO_HANDLE_PRIVATE_H__
+
+#include <mono/metadata/handle.h>
+
+typedef struct _MonoHandleArena MonoHandleArena;
+
+gsize
+mono_handle_arena_size (void);
+
+MonoHandle
+mono_handle_arena_new (MonoHandleArena *arena, MonoObject *obj);
+
+MonoHandle
+mono_handle_arena_elevate (MonoHandleArena *arena, MonoHandle handle);
+
+void
+mono_handle_arena_stack_push (MonoHandleArena **arena_stack, MonoHandleArena *arena);
+
+void
+mono_handle_arena_stack_pop (MonoHandleArena **arena_stack, MonoHandleArena *arena);
+
+void
+mono_handle_arena_initialize (MonoHandleArena **arena_stack);
+
+void
+mono_handle_arena_deinitialize (MonoHandleArena **arena_stack);
+
+MonoHandleArena*
+mono_handle_arena_current (void);
+
+MonoHandleArena**
+mono_handle_arena_current_addr (void);
+
+#define MONO_HANDLE_ARENA_PUSH()	\
+	do {	\
+		MonoHandleArena **__arena_stack = mono_handle_arena_current_addr ();	\
+		MonoHandleArena *__arena = (MonoHandleArena*) g_alloca (mono_handle_arena_size ());	\
+		mono_handle_arena_stack_push (__arena_stack, __arena)
+
+#define MONO_HANDLE_ARENA_POP	\
+		mono_handle_arena_stack_pop (__arena_stack, __arena);	\
+	} while (0)
+
+#define MONO_HANDLE_ARENA_POP_RETURN_UNSAFE(handle,ret)	\
+		(ret) = (handle)->__private_obj;	\
+		mono_handle_arena_stack_pop (__arena_stack, __arena);	\
+	} while (0)
+
+#define MONO_HANDLE_ARENA_POP_RETURN(handle,ret_handle)	\
+		*((MonoHandle**)(&(ret_handle))) = mono_handle_elevate ((MonoHandle*)(handle)); \
+		mono_handle_arena_stack_pop(__arena_stack, __arena);	\
+	} while (0)
+
+#endif/*__MONO_HANDLE_PRIVATE_H__*/
diff --git a/mono/metadata/handle-private.h b/mono/metadata/handle-private.h
diff --git a/mono/metadata/handle.c b/mono/metadata/handle.c
@@ -11,11 +11,12 @@
 #include <glib.h>
 
 #include <mono/metadata/handle.h>
-#include <mono/metadata/handle-private.h>
+#include <mono/metadata/handle-arena.h>
 #include <mono/metadata/object-internals.h>
 #include <mono/metadata/gc-internals.h>
 #include <mono/utils/atomic.h>
 #include <mono/utils/mono-lazy-init.h>
+#include <mono/utils/mono-threads.h>
 
 #define HANDLES_PER_CHUNK (16 - 2)
 
@@ -34,9 +35,7 @@ struct _MonoHandleArena {
 
 static mono_lazy_init_t arena_status = MONO_LAZY_INIT_STATUS_NOT_INITIALIZED;
 
-#ifdef HAVE_SGEN_GC
 static MonoGCDescriptor arena_desc = MONO_GC_DESCRIPTOR_NULL;
-#endif
 
 static MonoHandleArenaChunk *chunk_free_list = NULL;
 
@@ -82,15 +81,15 @@ handle_new (MonoHandleArena *arena, MonoObject *obj)
 	chunk = arena->chunk_last;
 
 	if (chunk->handles_size < HANDLES_PER_CHUNK) {
-		chunk->handles [chunk->handles_size].obj = obj;
+		chunk->handles [chunk->handles_size].__private_obj = obj;
 		chunk->handles_size += 1;
 
 		return &chunk->handles [chunk->handles_size - 1];
 	}
 
 	chunk = chunk->next = chunk_alloc ();
 
-	chunk->handles [0].obj = obj;
+	chunk->handles [0].__private_obj = obj;
 	chunk->handles_size = 1;
 
 	arena->chunk_last = chunk;
@@ -105,16 +104,6 @@ mono_handle_arena_new (MonoHandleArena *arena, MonoObject *obj)
 	return handle_new (arena, obj);
 }
 
-MonoHandle
-mono_handle_new (MonoObject *obj)
-{
-	/* TODO: finish implementation by placing an arena somewhere
-	 * in the current thread */
-	g_assert_not_reached ();
-	MonoHandleArena *arena = NULL;
-	return mono_handle_arena_new (arena, obj);
-}
-
 /*
  * Elevate the handle to the parent arena
  */
@@ -125,17 +114,7 @@ mono_handle_arena_elevate (MonoHandleArena *arena, MonoHandle handle)
 	g_assert (arena);
 	g_assert (arena->prev);
 
-	return handle_new (arena->prev, handle->obj);
-}
-
-MonoHandle
-mono_handle_elevate (MonoHandle handle)
-{
-	/* TODO: finish implementation by placing an arena somewhere
-	 * in the current thread */
-	g_assert_not_reached ();
-	MonoHandleArena *arena = NULL;
-	return mono_handle_arena_elevate (arena, handle);
+	return handle_new (arena->prev, handle->__private_obj);
 }
 
 gsize
@@ -190,8 +169,8 @@ arena_scan (gpointer addr, MonoGCMarkFunc mark_func, gpointer gc_data)
 	for (arena = *(MonoHandleArena**) addr; arena; arena = arena->prev) {
 		for (chunk = arena->chunk; chunk; chunk = chunk->next) {
 			for (i = 0; i < chunk->handles_size; ++i) {
-				if (chunk->handles [i].obj != NULL)
-					mark_func (&chunk->handles [i].obj, gc_data);
+				if (chunk->handles [i].__private_obj != NULL)
+					mark_func (&chunk->handles [i].__private_obj, gc_data);
 			}
 		}
 	}
@@ -200,25 +179,30 @@ arena_scan (gpointer addr, MonoGCMarkFunc mark_func, gpointer gc_data)
 static void
 initialize (void)
 {
-#ifdef HAVE_SGEN_GC
 	arena_desc = mono_gc_make_root_descr_user (arena_scan);
-#endif
 }
 
 void
 mono_handle_arena_initialize (MonoHandleArena **arena_stack)
 {
-#ifdef HAVE_SGEN_GC
 	mono_lazy_initialize (&arena_status, initialize);
 	mono_gc_register_root ((char*) arena_stack, sizeof (MonoHandleArena*), arena_desc, MONO_ROOT_SOURCE_HANDLE, "runtime threads handle arena");
-#endif
 }
 
 void
 mono_handle_arena_deinitialize (MonoHandleArena **arena_stack)
 {
-#ifdef HAVE_SGEN_GC
 	mono_gc_deregister_root ((char*) arena_stack);
-#endif
 }
 
+MonoHandleArena*
+mono_handle_arena_current (void)
+{
+	return (MonoHandleArena*) mono_thread_info_current ()->handle_arena;
+}
+
+MonoHandleArena**
+mono_handle_arena_current_addr (void)
+{
+	return (MonoHandleArena**) &mono_thread_info_current ()->handle_arena;
+}