improve performance massively from 0.9 seconds to 0.38 seconds :)

Makefile

@@ -30,11 +30,11 @@ native: $(CFILES) $(LEXER_C) $(LEXER_H)
 
 debug: $(CFILES) $(LEXER_C) $(LEXER_H)
 	mkdir -p bin
-	gcc -g -O3 -o $(BINARY) $(CFILES) $(CFLAGS)
+	gcc -g -O0 -o $(BINARY) $(CFILES) $(CFLAGS)
 
 full-debug: $(CFILES) $(LEXER_C) $(LEXER_H)
 	mkdir -p bin
-	gcc -g -O0 -fsanitize=address -fno-omit-frame-pointer -o $(BINARY) $(CFILES) $(CFLAGS) ${LDFLAGS}
+	gcc -g -O3 -fsanitize=address -fno-omit-frame-pointer -o $(BINARY) $(CFILES) $(CFLAGS) ${LDFLAGS}
 
 optimised: $(CFILES) $(LEXER_C) $(LEXER_H)
 	mkdir -p bin

app.py

@@ -1,3 +1,4 @@
 i = 1000000
 while i:
+    print(i)
     i=i-1

src/arobject.h

@@ -49,6 +49,9 @@ typedef struct {
 
 struct string_struct {
   char *data;
+  uint64_t prehash;
+  uint64_t hash;
+  bool hash_computed;
   size_t length;
 };
 

src/hash_data/hash_data.c

@@ -40,9 +40,5 @@ uint64_t siphash64_bytes(const void *data, size_t len,const uint8_t hash_key[16]
   if (siphash(data, len, hash_key, out, sizeof(out)) != 0)
     return 0;
   
-  uint64_t hash = 0;
+  return *(uint64_t *)out;
-  for (int i = 0; i < 8; ++i)
-    hash |= ((uint64_t)out[i]) << (8 * i);
-
-  return hash;
 }

src/main.c

@@ -12,8 +12,9 @@
 #include "memory.h"
 #include "parser/parser.h"
 #include "returnTypes.h"
-#include "shell.h"
+#include "runtime/objects/object.h"
 #include "runtime/runtime.h"
+#include "shell.h"
 #include "translator/translator.h"
 
 #include "../external/xxhash/xxhash.h"
@@ -427,7 +428,8 @@ Translated load_argon_file(char *path, ArErr *err) {
   }
   hashmap_free(translated.constants.hashmap, NULL);
   Translated gc_translated = {
-      translated.registerCount, translated.registerAssignment,NULL, {}, {}, translated.path};
+      translated.registerCount, translated.registerAssignment, NULL, {}, {},
+      translated.path};
   gc_translated.bytecode.data = ar_alloc_atomic(translated.bytecode.capacity);
   memcpy(gc_translated.bytecode.data, translated.bytecode.data,
          translated.bytecode.capacity);
@@ -454,6 +456,7 @@ int main(int argc, char *argv[]) {
   ar_memory_init();
 
   generate_siphash_key(siphash_key);
+  init_built_in_field_hashes();
   bootstrap_types();
   bootstrap_globals();
   if (argc <= 1)
@@ -463,7 +466,7 @@ int main(int argc, char *argv[]) {
   char path[FILENAME_MAX];
   cwk_path_get_absolute(CWD, path_non_absolute, path, sizeof(path));
   free(CWD);
-  ArErr err=no_err;
+  ArErr err = no_err;
   Translated translated = load_argon_file(path, &err);
   if (err.exists) {
     output_err(err);
@@ -472,7 +475,7 @@ int main(int argc, char *argv[]) {
   clock_t start = clock(), end;
   RuntimeState state = init_runtime_state(translated, path);
   Stack *main_scope = create_scope(Global_Scope);
-  err = runtime(translated, state, main_scope);
+  runtime(translated, state, main_scope, &err);
 
   end = clock();
   double time_spent = (double)(end - start) / CLOCKS_PER_SEC;

src/runtime/access/access.c

@@ -18,12 +18,23 @@ ArgonObject *ARGON_TYPE_TYPE___get_attr__(size_t argc, ArgonObject **argv,
   bool check_field = argv[1] == ARGON_TRUE;
   if (check_field) {
     ArgonObject *access = argv[2];
-    ArgonObject *value = get_field_l(to_access, access->value.as_str.data,
+    uint64_t hash;
+    if (access->value.as_str.hash_computed) {
+      hash = access->value.as_str.hash;
+    } else {
+      hash =
+          runtime_hash(access->value.as_str.data, access->value.as_str.length,
+                       access->value.as_str.prehash);
+      access->value.as_str.hash = hash;
+      access->value.as_str.hash_computed = true;
+    }
+    ArgonObject *value = get_field_l(to_access, access->value.as_str.data, hash,
                                      access->value.as_str.length, true, false);
     if (value)
       return value;
-    ArgonObject *name = get_field_for_class(
+    ArgonObject *name = get_builtin_field_for_class(
-        get_field(to_access, "__class__", false, false), "__name__", to_access);
+        get_builtin_field(to_access, __class__, false, false), __name__,
+        to_access);
     *err = create_err(
         0, 0, 0, "", "Runtime Error", "'%.*s' object has no attribute '%.*s'",
         (int)name->value.as_str.length, name->value.as_str.data,

src/runtime/assignment/assignment.c

@@ -6,16 +6,15 @@
 
 #include "assignment.h"
 
-ArErr runtime_assignment(Translated *translated, RuntimeState *state,
+void runtime_assignment(Translated *translated, RuntimeState *state,
                          struct Stack *stack) {
   int64_t length = pop_bytecode(translated, state);
   int64_t offset = pop_bytecode(translated, state);
   int64_t prehash = pop_bytecode(translated, state);
   int64_t from_register = pop_byte(translated, state);
-  uint64_t hash =
+  void *data = arena_get(&translated->constants, offset);
-      runtime_hash(arena_get(&translated->constants, offset), length, prehash);
+  uint64_t hash = runtime_hash(data, length, prehash);
-  ArgonObject *key =
+  ArgonObject *key = new_string_object(data, length, prehash, hash);
-      new_string_object(arena_get(&translated->constants, offset), length);
   for (Stack *current_stack = stack; current_stack;
        current_stack = current_stack->prev) {
     ArgonObject *exists = hashmap_lookup_GC(current_stack->scope, hash);
@@ -26,5 +25,4 @@ ArErr runtime_assignment(Translated *translated, RuntimeState *state,
   }
   hashmap_insert_GC(stack->scope, hash, key, state->registers[from_register],
                     0);
-  return no_err;
 }

src/runtime/assignment/assignment.h

@@ -9,7 +9,7 @@
 #include "../runtime.h"
 #include "../objects/string/string.h"
 
-ArErr runtime_assignment(Translated *translated, RuntimeState *state,
+void runtime_assignment(Translated *translated, RuntimeState *state,
-                          struct Stack *stack);
+                         struct Stack *stack);
 
 #endif // runtime_assignment_H

src/runtime/call/call.c

@@ -19,8 +19,8 @@
 #ifndef _WIN32_WINNT
 #define _WIN32_WINNT 0x0602
 #endif
-#include <windows.h>
 #include <psapi.h>
+#include <windows.h>
 
 double get_memory_usage_mb() {
   PROCESS_MEMORY_COUNTERS pmc;
@@ -75,27 +75,28 @@ double get_memory_usage_mb() {
 
 ArgonObject *argon_call(ArgonObject *original_object, size_t argc,
                         ArgonObject **argv, ArErr *err, RuntimeState *state) {
-  *err = run_call(original_object, argc, argv, state, true);
+  run_call(original_object, argc, argv, state, true, err);
   return state->registers[0];
 }
 
-ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
+void run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
-               RuntimeState *state, bool CStackFrame) {
+              RuntimeState *state, bool CStackFrame, ArErr *err) {
   ArgonObject *object = original_object;
   if (object->type != TYPE_FUNCTION && object->type != TYPE_NATIVE_FUNCTION &&
       object->type != TYPE_METHOD) {
-    ArgonObject *call_method =
+    ArgonObject *call_method = get_builtin_field_for_class(
-        get_field_for_class(get_field(object, "__class__", false, false),
+        get_builtin_field(object, __class__, false, false), __call__,
-                            "__call__", original_object);
+        original_object);
     if (call_method) {
       object = call_method;
     }
   }
   if (object->type == TYPE_METHOD) {
     ArgonObject *binding_object =
-        get_field(object, "__binding__", false, false);
+        get_builtin_field(object, __binding__, false, false);
     if (binding_object) {
-      ArgonObject **new_call_args = ar_alloc(sizeof(ArgonObject *) * (argc + 1));
+      ArgonObject **new_call_args =
+          ar_alloc(sizeof(ArgonObject *) * (argc + 1));
       new_call_args[0] = binding_object;
       if (argc > 0) {
         memcpy(new_call_args + 1, argv, argc * sizeof(ArgonObject *));
@@ -104,18 +105,18 @@ ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
       argc++;
     }
     ArgonObject *function_object =
-        get_field(object, "__function__", false, false);
+        get_builtin_field(object, __function__, false, false);
     if (function_object)
       object = function_object;
   }
   if (object->type == TYPE_FUNCTION) {
     if (argc != object->value.argon_fn.number_of_parameters) {
-      ArgonObject *type_object_name =
+      ArgonObject *type_object_name = get_builtin_field_for_class(
-          get_field_for_class(get_field(object, "__class__", false, false),
+          get_builtin_field(object, __class__, false, false), __name__,
-                              "__name__", original_object);
+          original_object);
       ArgonObject *object_name =
-          get_field_for_class(object, "__name__", original_object);
+          get_builtin_field_for_class(object, __name__, original_object);
-      return create_err(
+      *err = create_err(
           state->source_location.line, state->source_location.column,
           state->source_location.length, state->path, "Type Error",
           "%.*s %.*s takes %" PRIu64 " argument(s) but %" PRIu64 " was given",
@@ -130,11 +131,12 @@ ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
       ArgonObject *value = argv[i];
       uint64_t hash = siphash64_bytes(key.data, key.length, siphash_key);
       hashmap_insert_GC(scope->scope, hash,
-                        new_string_object(key.data, key.length), value, 0);
+                        new_string_object(key.data, key.length, 0, hash), value,
+                        0);
     }
     StackFrame new_stackFrame = {
         {object->value.argon_fn.translated.registerCount,
-          object->value.argon_fn.translated.registerAssignment,
+         object->value.argon_fn.translated.registerAssignment,
          NULL,
          {object->value.argon_fn.bytecode, sizeof(uint8_t),
           object->value.argon_fn.bytecode_length,
@@ -152,7 +154,8 @@ ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
         *state->currentStackFramePointer,
         (*state->currentStackFramePointer)->depth + 1};
     if (CStackFrame) {
-      return runtime(new_stackFrame.translated, new_stackFrame.state, new_stackFrame.stack);
+      runtime(new_stackFrame.translated, new_stackFrame.state,
+              new_stackFrame.stack, err);
     } else {
       if (((*state->currentStackFramePointer)->depth + 1) % STACKFRAME_CHUNKS ==
           0) {
@@ -180,23 +183,22 @@ ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
           }
         }
       };
-      return no_err;
+      return;
     }
   } else if (object->type == TYPE_NATIVE_FUNCTION) {
-    ArErr err = no_err;
+    state->registers[0] = object->value.native_fn(argc, argv, err, state);
-    state->registers[0] = object->value.native_fn(argc, argv, &err, state);
+    if (err->exists && strlen(err->path) == 0) {
-    if (err.exists && strlen(err.path) == 0) {
+      err->line = state->source_location.line;
-      err.line = state->source_location.line;
+      err->column = state->source_location.column;
-      err.column = state->source_location.column;
+      err->length = state->source_location.length;
-      err.length = state->source_location.length;
+      err->path = state->path;
-      err.path = state->path;
     }
-    return err;
+    return;
   }
-  ArgonObject *type_object_name =
+  ArgonObject *type_object_name = get_builtin_field_for_class(
-      get_field_for_class(get_field(original_object, "__class__", false, false),
+      get_builtin_field(original_object, __class__, false, false), __name__,
-                          "__name__", original_object);
+      original_object);
-  return create_err(state->source_location.line, state->source_location.column,
+  *err = create_err(state->source_location.line, state->source_location.column,
                     state->source_location.length, state->path, "Type Error",
                     "'%.*s' object is not callable",
                     (int)type_object_name->value.as_str.length,

src/runtime/call/call.h

@@ -11,7 +11,7 @@
 ArgonObject *argon_call(ArgonObject *original_object, size_t argc,
                         ArgonObject **argv, ArErr *err, RuntimeState *state);
 
-ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
+void run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
-               RuntimeState *state, bool CStackFrame);
+              RuntimeState *state, bool CStackFrame, ArErr *err);
 
 #endif // runtime_call_H

src/runtime/declaration/declaration.c

@@ -6,18 +6,23 @@
 
 #include "declaration.h"
 
-ArErr runtime_declaration(Translated *translated, RuntimeState *state,
+void runtime_declaration(Translated *translated, RuntimeState *state,
-                          struct Stack *stack) {
+                         struct Stack *stack, ArErr *err) {
   int64_t length = pop_bytecode(translated, state);
   int64_t offset = pop_bytecode(translated, state);
   int64_t prehash = pop_bytecode(translated, state);
   int64_t from_register = pop_byte(translated, state);
-  uint64_t hash = runtime_hash(arena_get(&translated->constants, offset), length, prehash);
+  void *data = arena_get(&translated->constants, offset);
-  ArgonObject * exists = hashmap_lookup_GC(stack->scope, hash);
+  uint64_t hash = runtime_hash(data, length, prehash);
+  ArgonObject *exists = hashmap_lookup_GC(stack->scope, hash);
   if (exists) {
-    return create_err(state->source_location.line, state->source_location.column, state->source_location.length, state->path, "Runtime Error", "Identifier '%.*s' has already been declared in the current scope", length, arena_get(&translated->constants, offset));
+    *err = create_err(
+        state->source_location.line, state->source_location.column,
+        state->source_location.length, state->path, "Runtime Error",
+        "Identifier '%.*s' has already been declared in the current scope",
+        length, arena_get(&translated->constants, offset));
   }
-  ArgonObject * key = new_string_object(arena_get(&translated->constants, offset), length);
+  ArgonObject *key = new_string_object(data, length, prehash, hash);
-  hashmap_insert_GC(stack->scope, hash, key, state->registers[from_register], 0);
+  hashmap_insert_GC(stack->scope, hash, key, state->registers[from_register],
-  return no_err;
+                    0);
 }

src/runtime/declaration/declaration.h

@@ -9,7 +9,7 @@
 #include "../runtime.h"
 #include "../objects/string/string.h"
 
-ArErr runtime_declaration(Translated *translated, RuntimeState *state,
+void runtime_declaration(Translated *translated, RuntimeState *state,
-                          struct Stack *stack);
+                         struct Stack *stack, ArErr *err);
 
 #endif // runtime_declaration_H

src/runtime/objects/functions/functions.c

@@ -7,38 +7,43 @@
 #include "../../runtime.h"
 #include "../object.h"
 #include "../string/string.h"
-#include <stdio.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <string.h>
 
 ArgonObject *ARGON_FUNCTION_TYPE = NULL;
 
-ArgonObject *create_argon_native_function(char*name, native_fn native_fn) {
+ArgonObject *create_argon_native_function(char *name, native_fn native_fn) {
   ArgonObject *object = new_object();
-  add_field(object, "__class__", ARGON_FUNCTION_TYPE);
+  add_builtin_field(object, __class__, ARGON_FUNCTION_TYPE);
   object->type = TYPE_NATIVE_FUNCTION;
-  add_field(object, "__name__", new_string_object(name, strlen(name)));
+  add_builtin_field(object, __name__,
+                    new_string_object(name, strlen(name), 0, 0));
   object->value.native_fn = native_fn;
   return object;
 }
 
 void load_argon_function(Translated *translated, RuntimeState *state,
-                                 struct Stack *stack) {
+                         struct Stack *stack) {
   ArgonObject *object = new_object();
-  add_field(object, "__class__", ARGON_FUNCTION_TYPE);
+  add_builtin_field(object, __class__, ARGON_FUNCTION_TYPE);
   object->type = TYPE_FUNCTION;
   uint64_t offset = pop_bytecode(translated, state);
   uint64_t length = pop_bytecode(translated, state);
-  add_field(object, "__name__", new_string_object(arena_get(&translated->constants, offset), length));
+  add_builtin_field(object, __name__,
+                    new_string_object(arena_get(&translated->constants, offset),
+                                      length, 0, 0));
   object->value.argon_fn.translated = *translated;
   object->value.argon_fn.number_of_parameters = pop_bytecode(translated, state);
   object->value.argon_fn.parameters =
-      ar_alloc(object->value.argon_fn.number_of_parameters * sizeof(struct string_struct));
+      ar_alloc(object->value.argon_fn.number_of_parameters *
+               sizeof(struct string_struct));
   for (size_t i = 0; i < object->value.argon_fn.number_of_parameters; i++) {
     offset = pop_bytecode(translated, state);
     length = pop_bytecode(translated, state);
-    object->value.argon_fn.parameters[i].data = arena_get(&translated->constants, offset);
+    object->value.argon_fn.parameters[i].data =
+        arena_get(&translated->constants, offset);
     object->value.argon_fn.parameters[i].length = length;
   }
   offset = pop_bytecode(translated, state);
@@ -46,5 +51,5 @@ void load_argon_function(Translated *translated, RuntimeState *state,
   object->value.argon_fn.bytecode = arena_get(&translated->constants, offset);
   object->value.argon_fn.bytecode_length = length;
   object->value.argon_fn.stack = stack;
-  state->registers[0]=object;
+  state->registers[0] = object;
 }

src/runtime/objects/number/number.c

@@ -37,8 +37,8 @@ ArgonObject *ARGON_NUMBER_TYPE___new__(size_t argc, ArgonObject **argv,
   ArgonObject *object = argv[1];
 
   self->type = TYPE_STRING;
-  ArgonObject *boolean_convert_method = get_field_for_class(
+  ArgonObject *boolean_convert_method = get_builtin_field_for_class(
-      get_field(object, "__class__", false, false), "__number__", object);
+      get_builtin_field(object, __class__, false, false), __number__, object);
   if (boolean_convert_method) {
     ArgonObject *boolean_object =
         argon_call(boolean_convert_method, 0, NULL, err, state);
@@ -46,8 +46,8 @@ ArgonObject *ARGON_NUMBER_TYPE___new__(size_t argc, ArgonObject **argv,
       return ARGON_NULL;
     return boolean_object;
   }
-  ArgonObject *type_name = get_field_for_class(
+  ArgonObject *type_name = get_builtin_field_for_class(
-      get_field(object, "__class__", false, false), "__name__", object);
+      get_builtin_field(object, __class__, false, false), __name__, object);
   *err = create_err(
       0, 0, 0, "", "Runtime Error", "cannot convert type '%.*s' to number",
       type_name->value.as_str.length, type_name->value.as_str.data);
@@ -85,8 +85,8 @@ ArgonObject *ARGON_NUMBER_TYPE___add__(size_t argc, ArgonObject **argv,
     return ARGON_NULL;
   }
   if (argv[1]->type != TYPE_NUMBER) {
-    ArgonObject *type_name = get_field_for_class(
+    ArgonObject *type_name = get_builtin_field_for_class(
-        get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
+        get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
     *err = create_err(
         0, 0, 0, "", "Runtime Error",
         "__add__ cannot perform addition between a number and %.*s",
@@ -150,8 +150,8 @@ ArgonObject *ARGON_NUMBER_TYPE___subtract__(size_t argc, ArgonObject **argv,
   mpq_t r;
   mpq_init(r);
   if (argv[1]->type != TYPE_NUMBER) {
-    ArgonObject *type_name = get_field_for_class(
+    ArgonObject *type_name = get_builtin_field_for_class(
-        get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
+        get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
     *err = create_err(
         0, 0, 0, "", "Runtime Error",
         "__subtract__ cannot perform subtraction between number and %.*s",
@@ -216,8 +216,8 @@ ArgonObject *ARGON_NUMBER_TYPE___multiply__(size_t argc, ArgonObject **argv,
   mpq_t r;
   mpq_init(r);
   if (argv[1]->type != TYPE_NUMBER) {
-    ArgonObject *type_name = get_field_for_class(
+    ArgonObject *type_name = get_builtin_field_for_class(
-        get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
+        get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
     *err = create_err(
         0, 0, 0, "", "Runtime Error",
         "__multiply__ cannot perform multiplication between number and %.*s",
@@ -241,8 +241,8 @@ ArgonObject *ARGON_NUMBER_TYPE___division__(size_t argc, ArgonObject **argv,
   mpq_t r;
   mpq_init(r);
   if (argv[1]->type != TYPE_NUMBER) {
-    ArgonObject *type_name = get_field_for_class(
+    ArgonObject *type_name = get_builtin_field_for_class(
-        get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
+        get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
     *err = create_err(
         0, 0, 0, "", "Runtime Error",
         "__division__ cannot perform division between number and %.*s",
@@ -418,8 +418,8 @@ void init_small_ints() {
   for (uint64_t i = 0; i < UINT8_MAX * 2; i++) {
     small_ints[i].type = TYPE_NUMBER;
     small_ints[i].dict = createHashmap_GC();
-    add_field(&small_ints[i], "__class__", ARGON_NUMBER_TYPE);
+    add_builtin_field(&small_ints[i], __class__, ARGON_NUMBER_TYPE);
-    add_field(&small_ints[i], "__base__", BASE_CLASS);
+    add_builtin_field(&small_ints[i], __base__, BASE_CLASS);
     small_ints[i].value.as_number.is_int64 = true;
     small_ints[i].value.as_number.n.i64 = i;
     small_ints[i].as_bool = i;
@@ -428,28 +428,28 @@ void init_small_ints() {
 
 void create_ARGON_NUMBER_TYPE() {
   ARGON_NUMBER_TYPE = new_object();
-  add_field(ARGON_NUMBER_TYPE, "__name__",
+  add_builtin_field(ARGON_NUMBER_TYPE, __name__,
             new_string_object_null_terminated("number"));
-  add_field(
+  add_builtin_field(
-      ARGON_NUMBER_TYPE, "__string__",
+      ARGON_NUMBER_TYPE, __string__,
       create_argon_native_function("__string__", ARGON_NUMBER_TYPE___string__));
-  add_field(ARGON_NUMBER_TYPE, "__new__",
+  add_builtin_field(ARGON_NUMBER_TYPE, __new__,
             create_argon_native_function("__new__", ARGON_NUMBER_TYPE___new__));
-  add_field(
+  add_builtin_field(
-      ARGON_NUMBER_TYPE, "__number__",
+      ARGON_NUMBER_TYPE, __number__,
       create_argon_native_function("__number__", ARGON_NUMBER_TYPE___number__));
-  add_field(ARGON_NUMBER_TYPE, "__boolean__",
+  add_builtin_field(ARGON_NUMBER_TYPE, __boolean__,
             create_argon_native_function("__boolean__",
                                          ARGON_NUMBER_TYPE___boolean__));
-  add_field(ARGON_NUMBER_TYPE, "__add__",
+  add_builtin_field(ARGON_NUMBER_TYPE, __add__,
             create_argon_native_function("__add__", ARGON_NUMBER_TYPE___add__));
-  add_field(ARGON_NUMBER_TYPE, "__subtract__",
+  add_builtin_field(ARGON_NUMBER_TYPE, __subtract__,
             create_argon_native_function("__subtract__",
                                          ARGON_NUMBER_TYPE___subtract__));
-  add_field(ARGON_NUMBER_TYPE, "__multiply__",
+  add_builtin_field(ARGON_NUMBER_TYPE, __multiply__,
             create_argon_native_function("__multiply__",
                                          ARGON_NUMBER_TYPE___multiply__));
-  add_field(ARGON_NUMBER_TYPE, "__division__",
+  add_builtin_field(ARGON_NUMBER_TYPE, __division__,
             create_argon_native_function("__division__",
                                          ARGON_NUMBER_TYPE___division__));
   init_small_ints();
@@ -534,7 +534,7 @@ ArgonObject *new_number_object(mpq_t number) {
     return &small_ints[i64];
   }
   ArgonObject *object = new_object();
-  add_field(object, "__class__", ARGON_NUMBER_TYPE);
+  add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);
   object->type = TYPE_NUMBER;
   object->value.as_number.n.i64 = i64;
   object->value.as_number.is_int64 = is_int64;
@@ -552,7 +552,7 @@ ArgonObject *new_number_object_from_num_and_den(int64_t n, uint64_t d) {
     return &small_ints[(int8_t)n];
   }
   ArgonObject *object = new_object();
-  add_field(object, "__class__", ARGON_NUMBER_TYPE);
+  add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);
   object->type = TYPE_NUMBER;
   if (d == 1) {
     object->value.as_number.is_int64 = true;
@@ -577,7 +577,7 @@ ArgonObject *new_number_object_from_double(double d) {
     return &small_ints[(int8_t)i64];
   }
   ArgonObject *object = new_object();
-  add_field(object, "__class__", ARGON_NUMBER_TYPE);
+  add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);
   object->type = TYPE_NUMBER;
   object->value.as_number.n.i64 = i64;
   object->value.as_number.is_int64 = is_int64;

src/runtime/objects/object.c

@@ -15,42 +15,62 @@
 
 ArgonObject *BASE_CLASS = NULL;
 
+const char *built_in_field_names[BUILT_IN_FIELDS_COUNT] = {
+    "__base__",    "__class__",    "__name__",     "__add__",
+    "__string__",  "__subtract__", "__multiply__", "__division__",
+    "__new__",     "__init__",     "__boolean__",  "__get_attr__",
+    "__binding__", "__function__", "address",      "__call__",
+    "__number__",  "log"};
+
+uint64_t built_in_field_hashes[BUILT_IN_FIELDS_COUNT];
 
 ArgonObject *new_object() {
   ArgonObject *object = ar_alloc(sizeof(ArgonObject));
   object->type = TYPE_OBJECT;
   object->dict = createHashmap_GC();
-  add_field(object, "__class__", ARGON_TYPE_TYPE);
+  add_builtin_field(object, __class__, ARGON_TYPE_TYPE);
-  add_field(object, "__base__", BASE_CLASS);
+  add_builtin_field(object, __base__, BASE_CLASS);
   object->as_bool = true;
   return object;
 }
 
-void add_field(ArgonObject *target, char *name, ArgonObject *object) {
+void init_built_in_field_hashes() {
-  hashmap_insert_GC(target->dict,
+  for (int i = 0; i < BUILT_IN_FIELDS_COUNT; i++) {
-                    siphash64_bytes(name, strlen(name), siphash_key), name,
+    built_in_field_hashes[i] = siphash64_bytes(
-                    object, 0);
+        built_in_field_names[i], strlen(built_in_field_names[i]), siphash_key);
+  }
+}
+
+void add_builtin_field(ArgonObject *target, built_in_fields field,
+                       ArgonObject *object) {
+  hashmap_insert_GC(target->dict, built_in_field_hashes[field],
+                    (char *)built_in_field_names[field], object, 0);
+}
+
+void add_field(ArgonObject *target, char *name, uint64_t hash,
+               ArgonObject *object) {
+  hashmap_insert_GC(target->dict, hash, name, object, 0);
 }
 
 ArgonObject *bind_object_to_function(ArgonObject *object,
                                      ArgonObject *function) {
   ArgonObject *bound_method_wrapper = new_object();
   bound_method_wrapper->type = TYPE_METHOD;
-  add_field(bound_method_wrapper, "__class__", ARGON_METHOD_TYPE);
+  add_builtin_field(bound_method_wrapper, __class__, ARGON_METHOD_TYPE);
-  add_field(bound_method_wrapper, "__binding__", object);
+  add_builtin_field(bound_method_wrapper, __binding__, object);
-  add_field(bound_method_wrapper, "__function__", function);
+  add_builtin_field(bound_method_wrapper, __function__, function);
-  ArgonObject *function_name = get_field(function, "__name__", false, false);
+  ArgonObject *function_name =
+      get_builtin_field(function, __name__, false, false);
   if (function_name)
-    add_field(bound_method_wrapper, "__name__", function_name);
+    add_builtin_field(bound_method_wrapper, __name__, function_name);
   return bound_method_wrapper;
 }
 
 ArgonObject *get_field_for_class_l(ArgonObject *target, char *name,
-                                   size_t length, ArgonObject *binding_object) {
+                                   uint64_t hash, size_t length,
-  char *field = "__base__";
+                                   ArgonObject *binding_object) {
-  size_t field_size = strlen(field);
   while (target) {
-    ArgonObject *object = get_field_l(target, name, length, false, false);
+    ArgonObject *object = get_field_l(target, name, hash, length, false, false);
     if (object) {
       if ((object->type == TYPE_FUNCTION ||
            object->type == TYPE_NATIVE_FUNCTION) &&
@@ -59,35 +79,53 @@ ArgonObject *get_field_for_class_l(ArgonObject *target, char *name,
       }
       return object;
     }
-    target = get_field_l(target, field, field_size, false, false);
+    target = get_builtin_field(target, __base__, false, false);
   }
   return NULL;
 }
 
-ArgonObject *get_field_l(ArgonObject *target, char *name, size_t length,
+ArgonObject *get_field_l(ArgonObject *target, char *name, uint64_t hash,
-                         bool recursive, bool disable_method_wrapper) {
+                         size_t length, bool recursive,
-  if(!target|| !target->dict) return NULL;
+                         bool disable_method_wrapper) {
-  char *field = "__class__";
+  ArgonObject *object = hashmap_lookup_GC(target->dict, hash);
-  size_t field_size = strlen(field);
-  ArgonObject *object = hashmap_lookup_GC(
-      target->dict, siphash64_bytes(name, length, siphash_key));
   if (!recursive || object)
     return object;
   ArgonObject *binding = target;
   if (disable_method_wrapper)
     binding = NULL;
   return get_field_for_class_l(
-      hashmap_lookup_GC(target->dict,
+      hashmap_lookup_GC(target->dict, built_in_field_hashes[__class__]), name,
-                        siphash64_bytes(field, field_size, siphash_key)),
+      hash, length, binding);
-      name, length, binding);
 }
 
-ArgonObject *get_field(ArgonObject *target, char *name, bool recursive,
+ArgonObject *get_builtin_field_for_class(ArgonObject *target,
-                       bool disable_method_wrapper) {
+                                         built_in_fields field,
-  return get_field_l(target, name, strlen(name), recursive,
+                                         ArgonObject *binding_object) {
-                     disable_method_wrapper);
+  while (target) {
+    ArgonObject *object = get_builtin_field(target, field, false, false);
+    if (object) {
+      if ((object->type == TYPE_FUNCTION ||
+           object->type == TYPE_NATIVE_FUNCTION) &&
+          binding_object) {
+        object = bind_object_to_function(binding_object, object);
+      }
+      return object;
+    }
+    target = get_builtin_field(target, __base__, false, false);
+  }
+  return NULL;
 }
-ArgonObject *get_field_for_class(ArgonObject *target, char *name,
+
-                                 ArgonObject *binding_object) {
+ArgonObject *get_builtin_field(ArgonObject *target, built_in_fields field,
-  return get_field_for_class_l(target, name, strlen(name), binding_object);
+                               bool recursive, bool disable_method_wrapper) {
+  ArgonObject *object =
+      hashmap_lookup_GC(target->dict, built_in_field_hashes[field]);
+  if (!recursive || object)
+    return object;
+  ArgonObject *binding = target;
+  if (disable_method_wrapper)
+    binding = NULL;
+  return get_builtin_field_for_class(
+      hashmap_lookup_GC(target->dict, built_in_field_hashes[__class__]), field,
+      binding);
 }

src/runtime/objects/object.h

@@ -9,27 +9,59 @@
 #include "../internals/hashmap/hashmap.h"
 #include "../runtime.h"
 #include <stdbool.h>
+#include <string.h>
+
+typedef enum {
+  __base__,
+  __class__,
+  __name__,
+  __add__,
+  __string__,
+  __subtract__,
+  __multiply__,
+  __division__,
+  __new__,
+  __init__,
+  __boolean__,
+  __get_attr__,
+  __binding__,
+  __function__,
+  field__address,
+  __call__,
+  __number__,
+  field_log,
+  BUILT_IN_FIELDS_COUNT
+} built_in_fields;
+
+void init_built_in_field_hashes();
 
 extern ArgonObject *BASE_CLASS;
 
 typedef struct ArgonObject ArgonObject;
 ArgonObject *new_object();
 
-void add_field(ArgonObject *target, char *name, ArgonObject *object);
+void add_builtin_field(ArgonObject *target, built_in_fields field,
+                       ArgonObject *object);
+
+void add_field(ArgonObject *target, char *name, uint64_t hash,
+               ArgonObject *object);
 
 ArgonObject *bind_object_to_function(ArgonObject *object,
                                      ArgonObject *function);
 
 ArgonObject *get_field_for_class_l(ArgonObject *target, char *name,
-                                   size_t length, ArgonObject *binding_object);
+                                   uint64_t hash, size_t length,
+                                   ArgonObject *binding_object);
 
-ArgonObject *get_field_l(ArgonObject *target, char *name, size_t length,
+ArgonObject *get_field_l(ArgonObject *target, char *name, uint64_t hash,
-                         bool recursive, bool disable_method_wrapper);
+                         size_t length, bool recursive,
+                         bool disable_method_wrapper);
 
-ArgonObject *get_field_for_class(ArgonObject *target, char *name,
+ArgonObject *get_builtin_field_for_class(ArgonObject *target,
-                                 ArgonObject *binding_object);
+                                         built_in_fields field,
+                                         ArgonObject *binding_object);
 
-ArgonObject *get_field(ArgonObject *target, char *name, bool recursive,
+ArgonObject *get_builtin_field(ArgonObject *target, built_in_fields field,
-                       bool disable_method_wrapper);
+                               bool recursive, bool disable_method_wrapper);
 
 #endif // OBJECT_H

src/runtime/objects/string/string.c

@@ -4,28 +4,32 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
+#include "string.h"
+#include "../number/number.h"
 #include "../object.h"
 #include <stdint.h>
 #include <stdio.h>
-#include <stdio.h>
 #include <string.h>
-#include "string.h"
-#include "../number/number.h"
 
 ArgonObject *ARGON_STRING_TYPE = NULL;
 
-ArgonObject *new_string_object(char*data, size_t length) {
+ArgonObject *new_string_object(char *data, size_t length, uint64_t prehash,
-  ArgonObject * object = new_object();
+                               uint64_t hash) {
-  add_field(object, "__class__", ARGON_STRING_TYPE);
+  ArgonObject *object = new_object();
-  add_field(object, "length", new_number_object_from_num_and_den(length, 1));
+  add_builtin_field(object, __class__, ARGON_STRING_TYPE);
+  add_builtin_field(object, length,
+                    new_number_object_from_num_and_den(length, 1));
   object->type = TYPE_STRING;
   object->value.as_str.data = ar_alloc_atomic(length);
   memcpy(object->value.as_str.data, data, length);
+  object->value.as_str.prehash = prehash;
+  object->value.as_str.hash_computed = hash;
+  object->value.as_str.hash = hash;
   object->value.as_str.length = length;
   object->as_bool = length;
   return object;
 }
 
-ArgonObject *new_string_object_null_terminated(char*data) {
+ArgonObject *new_string_object_null_terminated(char *data) {
-  return new_string_object(data, strlen(data));
+  return new_string_object(data, strlen(data), 0, 0);
 }

src/runtime/objects/string/string.h

@@ -10,7 +10,7 @@
 
 extern ArgonObject *ARGON_STRING_TYPE;
 
-ArgonObject *new_string_object(char*data, size_t length);
+ArgonObject *new_string_object(char *data, size_t length, uint64_t prehash, uint64_t hash);
 
 ArgonObject *new_string_object_null_terminated(char*data);
 #endif // STRING_OBJ_H

src/runtime/objects/term/term.c

@@ -13,8 +13,8 @@ ArgonObject *term_log(size_t argc, ArgonObject **argv, ArErr *err,
   for (size_t i = 0; i < argc; i++) {
     if (i != 0)
       printf(" ");
-    ArgonObject *string_convert_method = get_field_for_class(
+    ArgonObject *string_convert_method = get_builtin_field_for_class(
-        get_field(argv[i], "__class__", false, false), "__string__", argv[i]);
+        get_builtin_field(argv[i], __class__, false, false), __string__, argv[i]);
 
     if (string_convert_method) {
       ArgonObject *string_object =

src/runtime/runtime.c

@@ -52,17 +52,19 @@ ArgonObject *ARGON_ADDITION_FUNCTION(size_t argc, ArgonObject **argv,
   }
   ArgonObject *output = argv[0];
   for (size_t i = 1; i < argc; i++) {
-    ArgonObject *__add__ = get_field_for_class(
+    ArgonObject *object__add__ = get_builtin_field_for_class(
-        get_field(output, "__class__", false, false), "__add__", output);
+        get_builtin_field(output, __class__, false, false), __add__, output);
-    if (!__add__) {
+    if (!object__add__) {
-      ArgonObject *cls___name__ = get_field(output, "__name__", true, false);
+      ArgonObject *cls___name__ =
+          get_builtin_field(output, __name__, true, false);
       *err = create_err(0, 0, 0, "", "Runtime Error",
                         "Object '%.*s' is missing __add__ method",
                         (int)cls___name__->value.as_str.length,
                         cls___name__->value.as_str.data);
       return ARGON_NULL;
     }
-    output = argon_call(__add__, 1, (ArgonObject *[]){argv[i]}, err, state);
+    output =
+        argon_call(object__add__, 1, (ArgonObject *[]){argv[i]}, err, state);
   }
   return output;
 }
@@ -77,18 +79,20 @@ ArgonObject *ARGON_SUBTRACTION_FUNCTION(size_t argc, ArgonObject **argv,
   }
   ArgonObject *output = argv[0];
   for (size_t i = 1; i < argc; i++) {
-    ArgonObject *__subtract__ = get_field_for_class(
+    ArgonObject *function__subtract__ = get_builtin_field_for_class(
-        get_field(output, "__class__", false, false), "__subtract__", output);
+        get_builtin_field(output, __class__, false, false), __subtract__,
-    if (!__subtract__) {
+        output);
-      ArgonObject *cls___name__ = get_field(output, "__name__", true, false);
+    if (!function__subtract__) {
+      ArgonObject *cls___name__ =
+          get_builtin_field(output, __name__, true, false);
       *err = create_err(0, 0, 0, "", "Runtime Error",
                         "Object '%.*s' is missing __subtract__ method",
                         (int)cls___name__->value.as_str.length,
                         cls___name__->value.as_str.data);
       return ARGON_NULL;
     }
-    output =
+    output = argon_call(function__subtract__, 1, (ArgonObject *[]){argv[i]},
-        argon_call(__subtract__, 1, (ArgonObject *[]){argv[i]}, err, state);
+                        err, state);
   }
   return output;
 }
@@ -103,18 +107,20 @@ ArgonObject *ARGON_MULTIPLY_FUNCTION(size_t argc, ArgonObject **argv,
   }
   ArgonObject *output = argv[0];
   for (size_t i = 1; i < argc; i++) {
-    ArgonObject *__multiply__ = get_field_for_class(
+    ArgonObject *function__multiply__ = get_builtin_field_for_class(
-        get_field(output, "__class__", false, false), "__multiply__", output);
+        get_builtin_field(output, __class__, false, false), __multiply__,
-    if (!__multiply__) {
+        output);
-      ArgonObject *cls___name__ = get_field(output, "__name__", true, false);
+    if (!function__multiply__) {
+      ArgonObject *cls___name__ =
+          get_builtin_field(output, __name__, true, false);
       *err = create_err(0, 0, 0, "", "Runtime Error",
                         "Object '%.*s' is missing __multiply__ method",
                         (int)cls___name__->value.as_str.length,
                         cls___name__->value.as_str.data);
       return ARGON_NULL;
     }
-    output =
+    output = argon_call(function__multiply__, 1, (ArgonObject *[]){argv[i]},
-        argon_call(__multiply__, 1, (ArgonObject *[]){argv[i]}, err, state);
+                        err, state);
   }
   return output;
 }
@@ -129,18 +135,20 @@ ArgonObject *ARGON_DIVISION_FUNCTION(size_t argc, ArgonObject **argv,
   }
   ArgonObject *output = argv[0];
   for (size_t i = 1; i < argc; i++) {
-    ArgonObject *__multiply__ = get_field_for_class(
+    ArgonObject *function__division__ = get_builtin_field_for_class(
-        get_field(output, "__class__", false, false), "__division__", output);
+        get_builtin_field(output, __class__, false, false), __division__,
-    if (!__multiply__) {
+        output);
-      ArgonObject *cls___name__ = get_field(output, "__name__", true, false);
+    if (!function__division__) {
+      ArgonObject *cls___name__ =
+          get_builtin_field(output, __name__, true, false);
       *err = create_err(0, 0, 0, "", "Runtime Error",
                         "Object '%.*s' is missing __division__ method",
                         (int)cls___name__->value.as_str.length,
                         cls___name__->value.as_str.data);
       return ARGON_NULL;
     }
-    output =
+    output = argon_call(function__division__, 1, (ArgonObject *[]){argv[i]},
-        argon_call(__multiply__, 1, (ArgonObject *[]){argv[i]}, err, state);
+                        err, state);
   }
   return output;
 }
@@ -156,14 +164,16 @@ ArgonObject *ARGON_TYPE_TYPE___call__(size_t argc, ArgonObject **argv,
   }
   ArgonObject *cls = argv[0];
   if (cls == ARGON_TYPE_TYPE && argc == 2) {
-    ArgonObject *cls_class = get_field(argv[1], "__class__", true, false);
+    ArgonObject *cls_class = get_builtin_field(argv[1], __class__, true, false);
     if (cls_class)
       return cls_class;
     return ARGON_NULL;
   }
-  ArgonObject *cls___new__ = get_field_for_class(argv[0], "__new__", NULL);
+  ArgonObject *cls___new__ =
+      get_builtin_field_for_class(argv[0], __new__, NULL);
   if (!cls___new__) {
-    ArgonObject *cls___name__ = get_field(argv[0], "__name__", true, false);
+    ArgonObject *cls___name__ =
+        get_builtin_field(argv[0], __name__, true, false);
     *err = create_err(
         0, 0, 0, "", "Runtime Error",
         "Object '%.*s' is missing __new__ method, so cannot be initialised",
@@ -181,9 +191,10 @@ ArgonObject *ARGON_TYPE_TYPE___call__(size_t argc, ArgonObject **argv,
       ARGON_TYPE_TYPE___call___args, err, state);
   if (new_object_class != ARGON_NULL && new_object_class == cls) {
     ArgonObject *cls___init__ =
-        get_field_for_class(argv[0], "__init__", new_object);
+        get_builtin_field_for_class(argv[0], __init__, new_object);
     if (!cls___init__) {
-      ArgonObject *cls___name__ = get_field(argv[0], "__name__", true, false);
+      ArgonObject *cls___name__ =
+          get_builtin_field(argv[0], __name__, true, false);
       *err = create_err(
           0, 0, 0, "", "Runtime Error",
           "Object '%.*s' is missing __init__ method, so cannot be initialised",
@@ -222,7 +233,7 @@ ArgonObject *BASE_CLASS___new__(size_t argc, ArgonObject **argv, ArErr *err,
     return ARGON_NULL;
   }
   ArgonObject *new_obj = new_object();
-  add_field(new_obj, "__class__", argv[0]);
+  add_builtin_field(new_obj, __class__, argv[0]);
   return new_obj;
 }
 
@@ -245,9 +256,10 @@ ArgonObject *BASE_CLASS___string__(size_t argc, ArgonObject **argv, ArErr *err,
                       "__string__ expects 1 arguments, got %" PRIu64, argc);
   }
 
-  ArgonObject *object_name = get_field_for_class(argv[0], "__name__", NULL);
+  ArgonObject *object_name =
-  ArgonObject *class_name = get_field_for_class(
+      get_builtin_field_for_class(argv[0], __name__, NULL);
-      get_field(argv[0], "__class__", false, false), "__name__", NULL);
+  ArgonObject *class_name = get_builtin_field_for_class(
+      get_builtin_field(argv[0], __class__, false, false), __name__, NULL);
 
   char buffer[100];
   if (class_name && object_name)
@@ -285,8 +297,8 @@ ArgonObject *ARGON_STRING_TYPE___init__(size_t argc, ArgonObject **argv,
   self->value.as_str.data = NULL;
   self->value.as_str.length = 0;
   self->type = TYPE_STRING;
-  ArgonObject *string_convert_method = get_field_for_class(
+  ArgonObject *string_convert_method = get_builtin_field_for_class(
-      get_field(object, "__class__", false, false), "__string__", object);
+      get_builtin_field(object, __class__, false, false), __string__, object);
   if (string_convert_method) {
     ArgonObject *string_object =
         argon_call(string_convert_method, 0, NULL, err, state);
@@ -312,8 +324,8 @@ ArgonObject *ARGON_BOOL_TYPE___new__(size_t argc, ArgonObject **argv,
   ArgonObject *object = argv[1];
 
   self->type = TYPE_STRING;
-  ArgonObject *boolean_convert_method = get_field_for_class(
+  ArgonObject *boolean_convert_method = get_builtin_field_for_class(
-      get_field(object, "__class__", false, false), "__boolean__", object);
+      get_builtin_field(object, __class__, false, false), __boolean__, object);
   if (boolean_convert_method) {
     ArgonObject *boolean_object =
         argon_call(boolean_convert_method, 0, NULL, err, state);
@@ -321,8 +333,8 @@ ArgonObject *ARGON_BOOL_TYPE___new__(size_t argc, ArgonObject **argv,
       return ARGON_NULL;
     return boolean_object;
   }
-  ArgonObject *type_name = get_field_for_class(
+  ArgonObject *type_name = get_builtin_field_for_class(
-      get_field(object, "__class__", false, false), "__name__", object);
+      get_builtin_field(object, __class__, false, false), __name__, object);
   *err = create_err(
       0, 0, 0, "", "Runtime Error", "cannot convert type '%.*s' to bool",
       type_name->value.as_str.length, type_name->value.as_str.data);
@@ -338,8 +350,8 @@ ArgonObject *ARGON_STRING_TYPE___add__(size_t argc, ArgonObject **argv,
     return ARGON_NULL;
   }
   if (argv[1]->type != TYPE_STRING) {
-    ArgonObject *type_name = get_field_for_class(
+    ArgonObject *type_name = get_builtin_field_for_class(
-        get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
+        get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
     *err = create_err(
         0, 0, 0, "", "Runtime Error",
         "__add__ cannot perform concatenation between a string and %.*s",
@@ -351,7 +363,7 @@ ArgonObject *ARGON_STRING_TYPE___add__(size_t argc, ArgonObject **argv,
   memcpy(concat, argv[0]->value.as_str.data, argv[0]->value.as_str.length);
   memcpy(concat + argv[0]->value.as_str.length, argv[1]->value.as_str.data,
          argv[1]->value.as_str.length);
-  ArgonObject *object = new_string_object(concat, length);
+  ArgonObject *object = new_string_object(concat, length, 0, 0);
   free(concat);
   return object;
 }
@@ -467,97 +479,104 @@ ArgonObject *ARGON_NULL_TYPE___string__(size_t argc, ArgonObject **argv,
 void bootstrap_types() {
   BASE_CLASS = new_object();
   ARGON_TYPE_TYPE = new_object();
-  add_field(ARGON_TYPE_TYPE, "__base__", BASE_CLASS);
+  add_builtin_field(ARGON_TYPE_TYPE, __base__, BASE_CLASS);
-  add_field(ARGON_TYPE_TYPE, "__class__", ARGON_TYPE_TYPE);
+  add_builtin_field(ARGON_TYPE_TYPE, __class__, ARGON_TYPE_TYPE);
 
   ARGON_NULL_TYPE = new_object();
-  add_field(ARGON_NULL_TYPE, "__base__", BASE_CLASS);
+  add_builtin_field(ARGON_NULL_TYPE, __base__, BASE_CLASS);
   ARGON_NULL = new_object();
-  add_field(ARGON_NULL, "__class__", ARGON_NULL_TYPE);
+  add_builtin_field(ARGON_NULL, __class__, ARGON_NULL_TYPE);
   ARGON_NULL->as_bool = false;
 
-  add_field(BASE_CLASS, "__base__", NULL);
+  add_builtin_field(BASE_CLASS, __base__, NULL);
-  add_field(BASE_CLASS, "__class__", ARGON_TYPE_TYPE);
+  add_builtin_field(BASE_CLASS, __class__, ARGON_TYPE_TYPE);
 
   ARGON_BOOL_TYPE = new_object();
-  add_field(ARGON_BOOL_TYPE, "__base__", BASE_CLASS);
+  add_builtin_field(ARGON_BOOL_TYPE, __base__, BASE_CLASS);
   ARGON_TRUE = new_object();
-  add_field(ARGON_TRUE, "__class__", ARGON_BOOL_TYPE);
+  add_builtin_field(ARGON_TRUE, __class__, ARGON_BOOL_TYPE);
   ARGON_FALSE = new_object();
-  add_field(ARGON_FALSE, "__class__", ARGON_BOOL_TYPE);
+  add_builtin_field(ARGON_FALSE, __class__, ARGON_BOOL_TYPE);
   ARGON_NULL->as_bool = false;
 
   ARGON_STRING_TYPE = new_object();
-  add_field(ARGON_STRING_TYPE, "__base__", BASE_CLASS);
+  add_builtin_field(ARGON_STRING_TYPE, __base__, BASE_CLASS);
 
-  add_field(ARGON_STRING_TYPE, "__name__",
+  add_builtin_field(ARGON_STRING_TYPE, __name__,
-            new_string_object_null_terminated("string"));
+                    new_string_object_null_terminated("string"));
-  add_field(BASE_CLASS, "__name__",
+  add_builtin_field(BASE_CLASS, __name__,
-            new_string_object_null_terminated("object"));
+                    new_string_object_null_terminated("object"));
-  add_field(ARGON_TYPE_TYPE, "__name__",
+  add_builtin_field(ARGON_TYPE_TYPE, __name__,
-            new_string_object_null_terminated("type"));
+                    new_string_object_null_terminated("type"));
-  add_field(ARGON_NULL_TYPE, "__name__",
+  add_builtin_field(ARGON_NULL_TYPE, __name__,
-            new_string_object_null_terminated("null_type"));
+                    new_string_object_null_terminated("null_type"));
-  add_field(ARGON_BOOL_TYPE, "__name__",
+  add_builtin_field(ARGON_BOOL_TYPE, __name__,
-            new_string_object_null_terminated("boolean"));
+                    new_string_object_null_terminated("boolean"));
 
   ARGON_FUNCTION_TYPE = new_object();
-  add_field(ARGON_FUNCTION_TYPE, "__base__", BASE_CLASS);
+  add_builtin_field(ARGON_FUNCTION_TYPE, __base__, BASE_CLASS);
-  add_field(ARGON_FUNCTION_TYPE, "__name__",
+  add_builtin_field(ARGON_FUNCTION_TYPE, __name__,
-            new_string_object_null_terminated("function"));
+                    new_string_object_null_terminated("function"));
 
   ARGON_METHOD_TYPE = new_object();
-  add_field(ARGON_METHOD_TYPE, "__base__", BASE_CLASS);
+  add_builtin_field(ARGON_METHOD_TYPE, __base__, BASE_CLASS);
-  add_field(ARGON_METHOD_TYPE, "__name__",
+  add_builtin_field(ARGON_METHOD_TYPE, __name__,
-            new_string_object_null_terminated("method"));
+                    new_string_object_null_terminated("method"));
   create_ARGON_NUMBER_TYPE();
 
-  add_field(BASE_CLASS, "__new__",
+  add_builtin_field(
-            create_argon_native_function("__new__", BASE_CLASS___new__));
+      BASE_CLASS, __new__,
-  add_field(BASE_CLASS, "address",
+      create_argon_native_function("__new__", BASE_CLASS___new__));
-            create_argon_native_function("address", BASE_CLASS_address));
+  add_builtin_field(
-  add_field(BASE_CLASS, "__init__",
+      BASE_CLASS, field__address,
-            create_argon_native_function("__init__", BASE_CLASS___new__));
+      create_argon_native_function("address", BASE_CLASS_address));
-  add_field(BASE_CLASS, "__string__",
+  add_builtin_field(
-            create_argon_native_function("__string__", BASE_CLASS___string__));
+      BASE_CLASS, __init__,
-  add_field(ARGON_TYPE_TYPE, "__call__",
+      create_argon_native_function("__init__", BASE_CLASS___new__));
-            create_argon_native_function("__call__", ARGON_TYPE_TYPE___call__));
+  add_builtin_field(
-  add_field(
+      BASE_CLASS, __string__,
-      ARGON_STRING_TYPE, "__init__",
+      create_argon_native_function("__string__", BASE_CLASS___string__));
+  add_builtin_field(
+      ARGON_TYPE_TYPE, __call__,
+      create_argon_native_function("__call__", ARGON_TYPE_TYPE___call__));
+  add_builtin_field(
+      ARGON_STRING_TYPE, __init__,
       create_argon_native_function("__init__", ARGON_STRING_TYPE___init__));
-  add_field(ARGON_STRING_TYPE, "__add__",
+  add_builtin_field(
-            create_argon_native_function("__add__", ARGON_STRING_TYPE___add__));
+      ARGON_STRING_TYPE, __add__,
-  add_field(
+      create_argon_native_function("__add__", ARGON_STRING_TYPE___add__));
-      ARGON_STRING_TYPE, "__number__",
+  add_builtin_field(
+      ARGON_STRING_TYPE, __number__,
       create_argon_native_function("__number__", ARGON_STRING_TYPE___number__));
-  add_field(
+  add_builtin_field(
-      ARGON_NULL_TYPE, "__boolean__",
+      ARGON_NULL_TYPE, __boolean__,
       create_argon_native_function("__boolean__", ARGON_NULL_TYPE___boolean__));
-  add_field(
+  add_builtin_field(
-      ARGON_NULL_TYPE, "__string__",
+      ARGON_NULL_TYPE, __string__,
       create_argon_native_function("__string__", ARGON_NULL_TYPE___string__));
-  add_field(
+  add_builtin_field(
-      ARGON_NULL_TYPE, "__number__",
+      ARGON_NULL_TYPE, __number__,
       create_argon_native_function("__number__", ARGON_NULL_TYPE___number__));
-  add_field(
+  add_builtin_field(
-      ARGON_STRING_TYPE, "__string__",
+      ARGON_STRING_TYPE, __string__,
       create_argon_native_function("__string__", ARGON_STRING_TYPE___string__));
-  add_field(ARGON_BOOL_TYPE, "__new__",
+  add_builtin_field(
-            create_argon_native_function("__new__", ARGON_BOOL_TYPE___new__));
+      ARGON_BOOL_TYPE, __new__,
-  add_field(
+      create_argon_native_function("__new__", ARGON_BOOL_TYPE___new__));
-      ARGON_BOOL_TYPE, "__boolean__",
+  add_builtin_field(
+      ARGON_BOOL_TYPE, __boolean__,
       create_argon_native_function("__boolean__", ARGON_BOOL_TYPE___boolean__));
-  add_field(ARGON_STRING_TYPE, "__boolean__",
+  add_builtin_field(ARGON_STRING_TYPE, __boolean__,
-            create_argon_native_function("__boolean__",
+                    create_argon_native_function(
-                                         ARGON_STRING_TYPE___boolean__));
+                        "__boolean__", ARGON_STRING_TYPE___boolean__));
-  add_field(
+  add_builtin_field(
-      BASE_CLASS, "__boolean__",
+      BASE_CLASS, __boolean__,
       create_argon_native_function("__boolean__", BASE_CLASS___boolean__));
-  add_field(
+  add_builtin_field(
-      ARGON_BOOL_TYPE, "__string__",
+      ARGON_BOOL_TYPE, __string__,
       create_argon_native_function("__string__", ARGON_BOOL_TYPE___string__));
-  add_field(
+  add_builtin_field(
-      ARGON_BOOL_TYPE, "__number__",
+      ARGON_BOOL_TYPE, __number__,
       create_argon_native_function("__number__", ARGON_BOOL_TYPE___number__));
   ACCESS_FUNCTION = create_argon_native_function("__get_attr__",
                                                  ARGON_TYPE_TYPE___get_attr__);
@@ -569,13 +588,13 @@ void bootstrap_types() {
       create_argon_native_function("multiply", ARGON_MULTIPLY_FUNCTION);
   DIVISION_FUNCTION =
       create_argon_native_function("division", ARGON_DIVISION_FUNCTION);
-  add_field(BASE_CLASS, "__get_attr__", ACCESS_FUNCTION);
+  add_builtin_field(BASE_CLASS, __get_attr__, ACCESS_FUNCTION);
 }
 
 void add_to_scope(Stack *stack, char *name, ArgonObject *value) {
   size_t length = strlen(name);
   uint64_t hash = siphash64_bytes(name, length, siphash_key);
-  ArgonObject *key = new_string_object(name, length);
+  ArgonObject *key = new_string_object(name, length, 0, 0);
   hashmap_insert_GC(stack->scope, hash, key, value, 0);
 }
 
@@ -591,8 +610,9 @@ void bootstrap_globals() {
   add_to_scope(Global_Scope, "division", DIVISION_FUNCTION);
 
   ArgonObject *argon_term = new_object();
-  add_field(argon_term, "__init__", ARGON_NULL);
+  add_builtin_field(argon_term, __init__, ARGON_NULL);
-  add_field(argon_term, "log", create_argon_native_function("log", term_log));
+  add_builtin_field(argon_term, field_log,
+                    create_argon_native_function("log", term_log));
   add_to_scope(Global_Scope, "term", argon_term);
 }
 
@@ -609,7 +629,7 @@ static inline void load_const(Translated *translated, RuntimeState *state) {
 
   void *data = ar_alloc_atomic(length);
   memcpy(data, arena_get(&translated->constants, offset), length);
-  ArgonObject *object = new_string_object(data, length);
+  ArgonObject *object = new_string_object(data, length, 0, 0);
   state->registers[to_register] = object;
 }
 
@@ -618,7 +638,7 @@ struct hashmap *runtime_hash_table = NULL;
 uint64_t runtime_hash(const void *data, size_t len, uint64_t prehash) {
   if (!runtime_hash_table) {
     runtime_hash_table = createHashmap();
-  } else {
+  } else if (prehash) {
     void *result = hashmap_lookup(runtime_hash_table, prehash);
     if (result) {
       return (uint64_t)result;
@@ -629,8 +649,8 @@ uint64_t runtime_hash(const void *data, size_t len, uint64_t prehash) {
   return hash;
 }
 
-static inline ArErr load_variable(Translated *translated, RuntimeState *state,
+static inline void load_variable(Translated *translated, RuntimeState *state,
-                                  struct Stack *stack) {
+                                 struct Stack *stack, ArErr *err) {
   int64_t length = pop_bytecode(translated, state);
   int64_t offset = pop_bytecode(translated, state);
   uint64_t prehash = pop_bytecode(translated, state);
@@ -641,72 +661,70 @@ static inline ArErr load_variable(Translated *translated, RuntimeState *state,
     ArgonObject *result = hashmap_lookup_GC(current_stack->scope, hash);
     if (result) {
       state->registers[0] = result;
-      return no_err;
+      return;
     }
     current_stack = current_stack->prev;
   }
-  ArErr err =
+  *err = create_err(state->source_location.line, state->source_location.column,
-      create_err(state->source_location.line, state->source_location.column,
+                    state->source_location.length, state->path, "Name Error",
-                 state->source_location.length, state->path, "Name Error",
+                    "name '%.*s' is not defined", (int)length,
-                 "name '%.*s' is not defined", (int)length,
+                    arena_get(&translated->constants, offset));
-                 arena_get(&translated->constants, offset));
+  return;
-  return err;
 }
 
-static inline ArErr run_instruction(Translated *translated, RuntimeState *state,
+static inline void run_instruction(Translated *translated, RuntimeState *state,
-                                    struct Stack **stack) {
+                                   struct Stack **stack, ArErr *err) {
-  static void *dispatch_table[] = {[OP_LOAD_STRING] = &&DO_LOAD_STRING,
+  static void *dispatch_table[] = {
-                                   [OP_DECLARE] = &&DO_DECLARE,
+      [OP_LOAD_STRING] = &&DO_LOAD_STRING,
-                                   [OP_LOAD_NULL] = &&DO_LOAD_NULL,
+      [OP_DECLARE] = &&DO_DECLARE,
-                                   [OP_LOAD_FUNCTION] = &&DO_LOAD_FUNCTION,
+      [OP_LOAD_NULL] = &&DO_LOAD_NULL,
-                                   [OP_IDENTIFIER] = &&DO_IDENTIFIER,
+      [OP_LOAD_FUNCTION] = &&DO_LOAD_FUNCTION,
-                                   [OP_BOOL] = &&DO_BOOL,
+      [OP_IDENTIFIER] = &&DO_IDENTIFIER,
-                                   [OP_JUMP_IF_FALSE] = &&DO_JUMP_IF_FALSE,
+      [OP_BOOL] = &&DO_BOOL,
-                                   [OP_JUMP] = &&DO_JUMP,
+      [OP_JUMP_IF_FALSE] = &&DO_JUMP_IF_FALSE,
-                                   [OP_NEW_SCOPE] = &&DO_NEW_SCOPE,
+      [OP_JUMP] = &&DO_JUMP,
-                                   [OP_POP_SCOPE] = &&DO_POP_SCOPE,
+      [OP_NEW_SCOPE] = &&DO_NEW_SCOPE,
-                                   [OP_INIT_CALL] = &&DO_INIT_CALL,
+      [OP_POP_SCOPE] = &&DO_POP_SCOPE,
-                                   [OP_INSERT_ARG] = &&DO_INSERT_ARG,
+      [OP_INIT_CALL] = &&DO_INIT_CALL,
-                                   [OP_CALL] = &&DO_CALL,
+      [OP_INSERT_ARG] = &&DO_INSERT_ARG,
-                                   [OP_SOURCE_LOCATION] = &&DO_SOURCE_LOCATION,
+      [OP_CALL] = &&DO_CALL,
-                                   [OP_LOAD_BOOL] = &&DO_LOAD_BOOL,
+      [OP_SOURCE_LOCATION] = &&DO_SOURCE_LOCATION,
-                                   [OP_LOAD_NUMBER] = &&DO_LOAD_NUMBER,
+      [OP_LOAD_BOOL] = &&DO_LOAD_BOOL,
-                                   [OP_ASSIGN] = &&DO_ASSIGN,
+      [OP_LOAD_NUMBER] = &&DO_LOAD_NUMBER,
-                                   [OP_COPY_TO_REGISTER] =
+      [OP_ASSIGN] = &&DO_ASSIGN,
-                                       &&DO_COPY_TO_REGISTER,
+      [OP_COPY_TO_REGISTER] = &&DO_COPY_TO_REGISTER,
-                                   [OP_ADDITION] = &&DO_ADDITION,
+      [OP_ADDITION] = &&DO_ADDITION,
-                                   [OP_SUBTRACTION] = &&DO_SUBTRACTION,
+      [OP_SUBTRACTION] = &&DO_SUBTRACTION,
-                                   [OP_LOAD_ACCESS_FUNCTION] = &&DO_LOAD_ACCESS_FUNCTION};
+      [OP_LOAD_ACCESS_FUNCTION] = &&DO_LOAD_ACCESS_FUNCTION};
   goto *dispatch_table[pop_byte(translated, state)];
 DO_LOAD_NULL:
   state->registers[pop_byte(translated, state)] = ARGON_NULL;
-  goto BREAK;
+  return;
 DO_LOAD_STRING:
   load_const(translated, state);
-  goto BREAK;
+  return;
 DO_LOAD_NUMBER:
   load_number(translated, state);
-  goto BREAK;
+  return;
 DO_LOAD_FUNCTION:
   load_argon_function(translated, state, *stack);
-  goto BREAK;
+  return;
 DO_IDENTIFIER:
-  return load_variable(translated, state, *stack);
+  return load_variable(translated, state, *stack, err);
 DO_DECLARE:
-  return runtime_declaration(translated, state, *stack);
+  return runtime_declaration(translated, state, *stack, err);
 DO_ASSIGN:
   return runtime_assignment(translated, state, *stack);
 DO_BOOL: {
   uint8_t to_register = pop_byte(translated, state);
-  if (state->registers[0]->type != TYPE_OBJECT) {
+  if (likely(state->registers[0]->type != TYPE_OBJECT)) {
     state->registers[to_register] =
         state->registers[0]->as_bool ? ARGON_TRUE : ARGON_FALSE;
-    goto BREAK;
+    return;
   }
-  ArErr err = no_err;
   ArgonObject *args[] = {ARGON_BOOL_TYPE, state->registers[0]};
-  state->registers[to_register] = ARGON_BOOL_TYPE___new__(2, args, &err, state);
+  state->registers[to_register] = ARGON_BOOL_TYPE___new__(2, args, err, state);
-  return err;
+  return;
 }
 DO_JUMP_IF_FALSE: {
   uint8_t from_register = pop_byte(translated, state);
@@ -714,17 +732,17 @@ DO_JUMP_IF_FALSE: {
   if (state->registers[from_register] == ARGON_FALSE) {
     state->head = to;
   }
-  goto BREAK;
+  return;
 }
 DO_JUMP:
   state->head = pop_bytecode(translated, state);
-  goto BREAK;
+  return;
 DO_NEW_SCOPE:
   *stack = create_scope(*stack);
-  goto BREAK;
+  return;
 DO_POP_SCOPE:
   *stack = (*stack)->prev;
-  goto BREAK;
+  return;
 DO_INIT_CALL: {
   size_t length = pop_bytecode(translated, state);
   call_instance call_instance = {state->call_instance, state->registers[0],
@@ -732,35 +750,34 @@ DO_INIT_CALL: {
                                  length};
   state->call_instance = ar_alloc(sizeof(call_instance));
   *state->call_instance = call_instance;
-  goto BREAK;
+  return;
 }
 DO_INSERT_ARG:;
   size_t index = pop_bytecode(translated, state);
   state->call_instance->args[index] = state->registers[0];
-  goto BREAK;
+  return;
 DO_CALL: {
-  ArErr err =
+  run_call(state->call_instance->to_call, state->call_instance->args_length,
-      run_call(state->call_instance->to_call, state->call_instance->args_length,
+           state->call_instance->args, state, false, err);
-               state->call_instance->args, state, false);
   state->call_instance = (*state->call_instance).previous;
-  return err;
+  return;
 }
 DO_SOURCE_LOCATION:
   state->source_location = (SourceLocation){pop_bytecode(translated, state),
                                             pop_bytecode(translated, state),
                                             pop_bytecode(translated, state)};
-  goto BREAK;
+  return;
 DO_LOAD_BOOL:
   state->registers[0] = pop_byte(translated, state) ? ARGON_TRUE : ARGON_FALSE;
-  goto BREAK;
+  return;
 DO_LOAD_ACCESS_FUNCTION:
   state->registers[0] = ACCESS_FUNCTION;
-  goto BREAK;
+  return;
 DO_COPY_TO_REGISTER: {
   uint8_t from_register = pop_byte(translated, state);
   uint64_t to_register = pop_byte(translated, state);
   state->registers[to_register] = state->registers[from_register];
-  goto BREAK;
+  return;
 }
 DO_ADDITION: {
   uint8_t registerA = pop_byte(translated, state);
@@ -770,8 +787,9 @@ DO_ADDITION: {
   ArgonObject *valueA = state->registers[registerA];
   ArgonObject *valueB = state->registers[registerB];
 
-  if (valueA->type == TYPE_NUMBER && valueB->type == TYPE_NUMBER) {
+  if (likely(valueA->type == TYPE_NUMBER && valueB->type == TYPE_NUMBER)) {
-    if (valueA->value.as_number.is_int64 && valueB->value.as_number.is_int64) {
+    if (likely(valueA->value.as_number.is_int64 &&
+               valueB->value.as_number.is_int64)) {
       int64_t a = valueA->value.as_number.n.i64;
       int64_t b = valueB->value.as_number.n.i64;
       bool gonna_overflow = (a > 0 && b > 0 && a > INT64_MAX - b) ||
@@ -779,7 +797,7 @@ DO_ADDITION: {
       if (!gonna_overflow) {
         state->registers[registerC] =
             new_number_object_from_num_and_den(a + b, 1);
-        goto BREAK;
+        return;
       }
       mpq_t a_GMP, b_GMP;
       mpq_init(a_GMP);
@@ -814,13 +832,12 @@ DO_ADDITION: {
       mpq_clear(a_GMP);
       mpq_clear(b_GMP);
     }
-    goto BREAK;
+    return;
   }
 
-  ArErr err = no_err;
   ArgonObject *args[] = {valueA, valueB};
-  state->registers[registerC] = ARGON_ADDITION_FUNCTION(2, args, &err, state);
+  state->registers[registerC] = ARGON_ADDITION_FUNCTION(2, args, err, state);
-  return err;
+  return;
 }
 DO_SUBTRACTION: {
   uint8_t registerA = pop_byte(translated, state);
@@ -830,8 +847,9 @@ DO_SUBTRACTION: {
   ArgonObject *valueA = state->registers[registerA];
   ArgonObject *valueB = state->registers[registerB];
 
-  if (valueA->type == TYPE_NUMBER && valueB->type == TYPE_NUMBER) {
+  if (likely(valueA->type == TYPE_NUMBER && valueB->type == TYPE_NUMBER)) {
-    if (valueA->value.as_number.is_int64 && valueB->value.as_number.is_int64) {
+    if (likely(valueA->value.as_number.is_int64 &&
+               valueB->value.as_number.is_int64)) {
       int64_t a = valueA->value.as_number.n.i64;
       int64_t b = valueB->value.as_number.n.i64;
       int64_t neg_a = -a;
@@ -840,7 +858,7 @@ DO_SUBTRACTION: {
       if (!gonna_overflow) {
         state->registers[registerC] =
             new_number_object_from_num_and_den(a - b, 1);
-        goto BREAK;
+        return;
       }
       mpq_t a_GMP, b_GMP;
       mpq_init(a_GMP);
@@ -875,17 +893,13 @@ DO_SUBTRACTION: {
       mpq_clear(a_GMP);
       mpq_clear(b_GMP);
     }
-    goto BREAK;
+    return;
   }
 
-  ArErr err = no_err;
   ArgonObject *args[] = {valueA, valueB};
-  state->registers[registerC] = ARGON_ADDITION_FUNCTION(2, args, &err, state);
+  state->registers[registerC] = ARGON_ADDITION_FUNCTION(2, args, err, state);
-  return err;
+  return;
 }
-
-BREAK:
-  return no_err;
 }
 
 RuntimeState init_runtime_state(Translated translated, char *path) {
@@ -907,23 +921,21 @@ Stack *create_scope(Stack *prev) {
   return stack;
 }
 
-ArErr runtime(Translated translated, RuntimeState state, Stack *stack) {
+void runtime(Translated translated, RuntimeState state, Stack *stack,
+             ArErr *err) {
   state.head = 0;
 
   StackFrame *currentStackFrame =
       ar_alloc(sizeof(StackFrame) * STACKFRAME_CHUNKS);
   *currentStackFrame = (StackFrame){translated, state, stack, NULL, 0};
   currentStackFrame->state.currentStackFramePointer = &currentStackFrame;
-  ArErr err = no_err;
   while (currentStackFrame) {
-    while (currentStackFrame->state.head <
+    while (likely(currentStackFrame->state.head <
-               currentStackFrame->translated.bytecode.size &&
+                      currentStackFrame->translated.bytecode.size &&
-           !err.exists) {
+                  !err->exists)) {
-      err =
+      run_instruction(&currentStackFrame->translated, &currentStackFrame->state,
-          run_instruction(&currentStackFrame->translated,
+                      &currentStackFrame->stack, err);
-                          &currentStackFrame->state, &currentStackFrame->stack);
     }
     currentStackFrame = currentStackFrame->previousStackFrame;
   }
-  return err;
 }

src/runtime/runtime.h

@@ -11,6 +11,9 @@
 #include "internals/dynamic_array_armem/darray_armem.h"
 #include "internals/hashmap/hashmap.h"
 
+#define likely(x)   __builtin_expect(!!(x), 1)
+#define unlikely(x) __builtin_expect(!!(x), 0)
+
 extern ArgonObject *ARGON_METHOD_TYPE;
 extern Stack *Global_Scope;
 
@@ -64,26 +67,29 @@ 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;
+}
+
 static inline uint8_t pop_byte(Translated *translated, RuntimeState *state) {
-  return *((uint8_t *)darray_get(&translated->bytecode, state->head++));
+  return ((uint8_t *)(translated->bytecode.data))[state->head++];
 }
 
-static inline uint64_t pop_bytecode(Translated *translated,
+static inline uint64_t pop_bytecode(Translated *translated, RuntimeState *state) {
-                                    RuntimeState *state) {
+    uint64_t *ptr = (uint64_t *)((uint8_t*)translated->bytecode.data + state->head);
-  uint64_t value = 0;
+    uint64_t value = *ptr;
-  for (int i = 0; i < 8; i++) {
+    state->head += 8;
-    value |= ((uint64_t)pop_byte(translated, state)) << (i * 8);
+    return value;
-  }
-  return value;
 }
 
-static inline ArErr run_instruction(Translated *translated, RuntimeState *state,
+static inline void run_instruction(Translated *translated, RuntimeState *state,
-                      struct Stack **stack);
+                                    struct Stack **stack, ArErr*err);
 
 RuntimeState init_runtime_state(Translated translated, char *path);
 
 Stack *create_scope(Stack *prev);
 
-ArErr runtime(Translated translated, RuntimeState state, Stack *stack);
+void runtime(Translated translated, RuntimeState state, Stack *stack,
+             ArErr *err);
 
 #endif // RUNTIME_H

src/shell.c

@@ -108,7 +108,7 @@ int execute_code(FILE *stream, char *path, Stack *scope,
   darray_free(&__translated.bytecode, NULL);
   free(__translated.constants.data);
   *runtime_state = init_runtime_state(translated, path);
-  err = runtime(translated, *runtime_state, scope);
+  runtime(translated, *runtime_state, scope, &err);
   if (err.exists) {
     output_err(err);
     return 1;

src/translator/translator.c

@@ -51,10 +51,6 @@ void arena_resize(ConstantArena *arena, size_t new_size) {
   arena->capacity = new_capacity;
 }
 
-void *arena_get(ConstantArena *arena, size_t offset) {
-  return arena->data + offset;
-}
-
 size_t arena_push(ConstantArena *arena, const void *data, size_t length) {
   uint64_t hash = siphash64_bytes(data, length, siphash_key);
 

src/translator/translator.h

@@ -40,8 +40,6 @@ typedef enum {
 
 void arena_resize(ConstantArena *arena, size_t new_size);
 
-void *arena_get(ConstantArena *arena, size_t offset);
-
 size_t arena_push(ConstantArena *arena, const void *data, size_t length);
 
 size_t push_instruction_byte(Translated *translator, uint8_t byte);