Sketch in call stack region data structure.

Author: jnthn

build/Makefile.in

@@ -74,6 +74,7 @@ OBJECTS = src/core/callsite@obj@ \
           src/core/compunit@obj@ \
           src/core/bytecode@obj@ \
           src/core/frame@obj@ \
+          src/core/callstack@obj@ \
           src/core/validation@obj@ \
           src/core/bytecodedump@obj@ \
           src/core/threads@obj@ \
@@ -216,6 +217,7 @@ HEADERS = src/moar.h \
           src/core/interp.h \
           src/core/alloc.h \
           src/core/frame.h \
+          src/core/callstack.h \
           src/core/compunit.h \
           src/core/bytecode.h \
           src/core/ops.h \

src/core/callstack.c

@@ -0,0 +1,52 @@
+#include "moar.h"
+
+/* Allocates a new call stack region, not incorporated into the regions double
+ * linked list yet. */
+static MVMCallStackRegion * create_region() {
+    MVMCallStackRegion *region = MVM_malloc(MVM_CALLSTACK_REGIION_SIZE);
+    region->prev = region->next = NULL;
+    region->alloc = (char *)region + sizeof(MVMCallStackRegion);
+    region->alloc_limit = (char *)region + MVM_CALLSTACK_REGIION_SIZE;
+    return region;
+}
+
+/* Called upon thread creation to set up an initial callstack region for the
+ * thread. */
+void MVM_callstack_region_init(MVMThreadContext *tc) {
+    tc->stack_first = tc->stack_current = create_region();
+}
+
+/* Moves the current call stack region we're allocating/freeing in along to
+ * the next one in the region chain, allocating that next one if needed. */
+MVMCallStackRegion * MVM_callstack_region_next(MVMThreadContext *tc) {
+    MVMCallStackRegion *next_region = tc->stack_current->next;
+    if (!next_region) {
+        next_region = create_region();
+        tc->stack_current->next = next_region;
+        next_region->prev = tc->stack_current;
+    }
+    tc->stack_current = next_region;
+    return next_region;
+}
+
+/* Switches to the previous call stack region, if any. Otherwise, stays in
+ * the current region. */
+MVMCallStackRegion * MVM_callstack_region_prev(MVMThreadContext *tc) {
+    MVMCallStackRegion *prev_region = tc->stack_current->prev;
+    if (prev_region)
+        tc->stack_current = prev_region;
+    else
+        prev_region = tc->stack_current;
+    return prev_region;
+}
+
+/* Called at thread exit to destroy all callstack regions the thread has. */
+void MVM_callstack_region_destroy_all(MVMThreadContext *tc) {
+    MVMCallStackRegion *cur = tc->stack_first;
+    while (cur) {
+        MVMCallStackRegion *next = cur->next;
+        MVM_free(cur);
+        cur = next;
+    }
+    tc->stack_first = NULL;
+}

src/core/callstack.h

@@ -0,0 +1,32 @@
+/* A region of the call stack, used for call frames that have not escaped to
+ * the heap. */
+struct MVMCallStackRegion {
+    /* Next call stack region, which we start allocating in if this one is
+     * full. NULL if none has been allocated yet. */
+    MVMCallStackRegion *next;
+
+    /* Previous call stack region, if any. */
+    MVMCallStackRegion *prev;
+
+    /* The place we'll allocate the next frame. */
+    char *alloc;
+
+    /* The end of the allocatable region. */
+    char *alloc_limit;
+};
+
+/* The default size of a call stack region. */
+#define MVM_CALLSTACK_REGIION_SIZE 131072
+
+/* Checks if a frame is allocated on a call stack or on the heap. If it is on
+ * the call stack, then it will have zeroed flags (since heap-allocated frames
+ * always have the "I'm a heap frame" bit set). */
+MVM_STATIC_INLINE MVMuint32 MVM_FRAME_IS_ON_CALLSTACK(MVMThreadContext *tc, MVMFrame *frame) {
+    return frame->header.flags == 0;
+}
+
+/* Functions for working with call stack regions. */
+void MVM_callstack_region_init(MVMThreadContext *tc);
+MVMCallStackRegion * MVM_callstack_region_next(MVMThreadContext *tc);
+MVMCallStackRegion * MVM_callstack_region_prev(MVMThreadContext *tc);
+void MVM_callstack_region_destroy_all(MVMThreadContext *tc);

src/core/threadcontext.h

@@ -54,9 +54,6 @@ struct MVMThreadContext {
     /* Thread object representing the thread. */
     MVMThread *thread_obj;
 
-    /* The frame lying at the base of the current thread. */
-    MVMFrame *thread_entry_frame;
-
     /* Pointer to where the interpreter's current opcode is stored. */
     MVMuint8 **interp_cur_op;
 
@@ -71,9 +68,18 @@ struct MVMThreadContext {
      * is stored. */
     MVMCompUnit **interp_cu;
 
+    /* First call stack memory region, so we can traverse them for cleanup. */
+    MVMCallStackRegion *stack_first;
+
+    /* Current call stack region, which the next frame will be allocated in. */
+    MVMCallStackRegion *stack_current;
+
     /* The frame we're currently executing. */
     MVMFrame *cur_frame;
 
+    /* The frame lying at the base of the current thread. */
+    MVMFrame *thread_entry_frame;
+
     /* libuv event loop */
     uv_loop_t *loop;
 

src/moar.h

@@ -100,6 +100,7 @@ MVM_PUBLIC const MVMint32 MVM_jit_support(void);
 #include "core/exceptions.h"
 #include "core/alloc.h"
 #include "core/frame.h"
+#include "core/callstack.h"
 #include "core/validation.h"
 #include "core/bytecode.h"
 #include "core/bytecodedump.h"

src/types.h

@@ -17,6 +17,7 @@ typedef struct MVMCallCapture MVMCallCapture;
 typedef struct MVMCallCaptureBody MVMCallCaptureBody;
 typedef struct MVMCallsite MVMCallsite;
 typedef struct MVMCallsiteInterns MVMCallsiteInterns;
+typedef struct MVMCallStackRegion MVMCallStackRegion;
 typedef struct MVMCFunction MVMCFunction;
 typedef struct MVMCFunctionBody MVMCFunctionBody;
 typedef struct MVMCode MVMCode;