shitty boehm is dereferencing 0x20 for some stupid reason

src/runtime/call/call.c

@@ -157,13 +157,8 @@ void run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
       runtime(new_stackFrame.translated, new_stackFrame.state,
               new_stackFrame.stack, err);
     } else {
-      if (((*state->currentStackFramePointer)->depth + 1) % STACKFRAME_CHUNKS ==
-          0) {
-        *state->currentStackFramePointer =
-            ar_alloc(sizeof(StackFrame) * STACKFRAME_CHUNKS);
-      } else {
-        *state->currentStackFramePointer = *state->currentStackFramePointer + 1;
-      }
+      *state->currentStackFramePointer =
+            ar_alloc(sizeof(StackFrame));
       **state->currentStackFramePointer = new_stackFrame;
       if ((*state->currentStackFramePointer)->depth >= 10000) {
         double logval =

src/runtime/internals/hashmap/hashmap.c

@@ -9,6 +9,7 @@
 #include "../../../memory.h"
 #include <gc/gc.h>
 #include <stddef.h>
+#include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>

src/runtime/objects/string/string.c

@@ -21,8 +21,6 @@ ArgonObject *new_string_object(char *data, size_t length, uint64_t prehash,
                     new_number_object_from_num_and_den(length, 1));
   object->type = TYPE_STRING;
   object->value.as_str.data = ar_alloc_atomic(length);
-  printf("%zu, %p\n", length,data);
-  printf("%.*s\n", (int)length,data);
   memcpy(object->value.as_str.data, data, length);
   object->value.as_str.prehash = prehash;
   object->value.as_str.hash_computed = hash;

src/runtime/runtime.c

@@ -626,7 +626,6 @@ static inline void load_const(Translated *translated, RuntimeState *state) {
   uint64_t to_register = pop_byte(translated, state);
   size_t length = pop_bytecode(translated, state);
   uint64_t offset = pop_bytecode(translated, state);
-  printf("offset %zu\n", offset);
   ArgonObject *object = new_string_object(arena_get(&translated->constants, offset), length, 0, 0);
   state->registers[to_register] = object;
 }
@@ -689,7 +688,7 @@ Stack *create_scope(Stack *prev) {
   return stack;
 }
 
-void runtime(Translated translated, RuntimeState state, Stack *stack,
+void runtime(Translated _translated, RuntimeState _state, Stack *stack,
              ArErr *err) {
   static void *dispatch_table[] = {
       [OP_LOAD_STRING] = &&DO_LOAD_STRING,
@@ -714,11 +713,11 @@ void runtime(Translated translated, RuntimeState state, Stack *stack,
       [OP_ADDITION] = &&DO_ADDITION,
       [OP_SUBTRACTION] = &&DO_SUBTRACTION,
       [OP_LOAD_ACCESS_FUNCTION] = &&DO_LOAD_ACCESS_FUNCTION};
-  state.head = 0;
+  _state.head = 0;
 
   StackFrame *currentStackFrame =
-      ar_alloc(sizeof(StackFrame) * STACKFRAME_CHUNKS);
-  *currentStackFrame = (StackFrame){translated, state, stack, NULL, 0};
+      ar_alloc(sizeof(StackFrame));
+  *currentStackFrame = (StackFrame){_translated, _state, stack, NULL, 0};
   currentStackFrame->state.currentStackFramePointer = &currentStackFrame;
   while (currentStackFrame) {
     while (likely(currentStackFrame->state.head <
@@ -727,7 +726,6 @@ void runtime(Translated translated, RuntimeState state, Stack *stack,
       Translated *translated = &currentStackFrame->translated;
       RuntimeState *state = &currentStackFrame->state;
       uint8_t instruction = pop_byte(translated, state);
-      printf("opcode: %d\n",instruction);
       goto *dispatch_table[instruction];
     DO_LOAD_NULL:
       state->registers[pop_byte(translated, state)] = ARGON_NULL;
@@ -945,4 +943,4 @@ void runtime(Translated translated, RuntimeState state, Stack *stack,
     }
     currentStackFrame = currentStackFrame->previousStackFrame;
   }
-}
+}

src/runtime/runtime.h

@@ -10,8 +10,9 @@
 #include "../translator/translator.h"
 #include "internals/dynamic_array_armem/darray_armem.h"
 #include "internals/hashmap/hashmap.h"
+#include <stdio.h>
 
-#define likely(x)   __builtin_expect(!!(x), 1)
+#define likely(x) __builtin_expect(!!(x), 1)
 #define unlikely(x) __builtin_expect(!!(x), 0)
 
 extern ArgonObject *ARGON_METHOD_TYPE;
@@ -57,8 +58,6 @@ typedef struct StackFrame {
   uint64_t depth;
 } StackFrame;
 
-#define STACKFRAME_CHUNKS 64
-
 void bootstrap_types();
 
 extern struct hashmap *runtime_hash_table;
@@ -68,22 +67,23 @@ uint64_t runtime_hash(const void *data, size_t len, uint64_t prehash);
 void bootstrap_globals();
 
 static inline void *arena_get(ConstantArena *arena, size_t offset) {
-  return (char*)arena->data + offset;
+  return (char *)arena->data + offset;
 }
 
 static inline uint8_t pop_byte(Translated *translated, RuntimeState *state) {
-  return ((uint8_t *)(translated->bytecode.data))[state->head++];
+  return *(((uint8_t *)(translated->bytecode.data)) + state->head++);
 }
 
-static inline uint64_t pop_bytecode(Translated *translated, RuntimeState *state) {
-    uint64_t *ptr = (uint64_t *)((uint8_t*)translated->bytecode.data + state->head);
-    uint64_t value = *ptr;
-    state->head += 8;
-    return value;
+static inline uint64_t pop_bytecode(Translated *translated,
+                                    RuntimeState *state) {
+  uint64_t *ptr =
+      (uint64_t *)((uint8_t *)translated->bytecode.data + state->head);
+  state->head += 8;
+  return *ptr;
 }
 
 static inline void run_instruction(Translated *translated, RuntimeState *state,
-                                    struct Stack **stack, ArErr*err);
+                                   struct Stack **stack, ArErr *err);
 
 RuntimeState init_runtime_state(Translated translated, char *path);