Allow referencing code in imported file (right now for function calls, allow calling a function in another file)

35 files changed, 1054 insertions, 401 deletions

diff --git a/README.md b/README.md
index 2760c93..2668852 100644
--- a/README.md
+++ b/README.md
@@ -9,32 +9,45 @@ Files have to be in utf-8 format and can optionally have utf-8 BOM.
 ## Important
 Amalgam is not ready to be used yet.
 # Fast compilation
-Every stage of the compiler is multithreaded and data copy is kept to a minimal, for example tokenization
+Every stage of the compiler runs concurrently, each compiling different files. Memory copying is kept to a minimal, for example tokenization
 is done without storing tokens in a list. Almost all allocation is done using an arena allocator that
 is only cleaned up once (when the compiler is finished), and the data is allocated sequentially.
+Locks are only used in one place in the whole compilation stage, during @import statements.
 # Dependencies
 Right now only the C standard library (C89) is required for a release build. In the future dependency on the C standard library might be removed
 and then amalgam would have 0 dependencies.\
 python2 is needed for tests to run additional code analyzis.
+# Limits
+Amalgam places limits on code for performance reasons. These are the limits:
+
+* One file can't have more than 254 imports, have more than 2^16 functions or use more than 2^16 functions.
+* Every function can only use up to 2^16 registers and parameters (combined).
+* Every function can only have up to 128 parameters and 128 return values.
+* Exported and external function can only have 0 or 1 return values, as that is what C supports.
+
 # TODO
-Build with -nostdlib and replace use of libc with syscalls (on linux).\
-Don't parse files unless the variable they are assigned to (with @import) is used. This is useful when only using small parts of a library.
+* Build with -nostdlib and replace use of libc with syscalls (on linux).
+* Don't parse files unless the variable they are assigned to (with @import) is used. This is useful when only using small parts of a library.
 This could be done checking if an AST expression is referenced before evaluating it. There would then need to be a compile option
 that compiles everything even if not referenced, since another user of the program/library may use the functions that are not used in your program
-and they might have compile-issues.\
-Align machine code to word boundary for the start of functions. No need to pad with NOP, as functions return before the padding.\
-Use const to cleanup ANSI C style variable declarations, since const allows you to declare and assign variables on the same line.\
-Make the bytecode work with big endian. On a big endian machine, the bytecode should be converted to little endian
-to make work on little endian as little as possible, meaning it would be a small penality to use big endian.\
-Verify all members of an extern struct are extern as well. Verify all parameters are of extern types for extern functions.\
-Verify all code execution paths in a function return a value, if the function excepts return values.\
-Show compile error if the result of a function call is ignored.\
-Show compile error if function result type and assigned to variable have different types.\
-Show compile error if variables are assigned to but not used.\
-Push arguments in reverse order (right-to-left, cdecl) (in program.c, since on windows we will need to support stdcall which is left-to-right).\
-After tokenizing files, unload file data to disk if possible.\
-Parallelize program decoding, if there is an advantage to doing it.\
-Logical AND binop should skip expressions the moment the result becomes false.
+and they might have compile-issues.
+* Align machine code to word boundary for the start of functions. No need to pad with NOP, as functions return before the padding.
+* Use const to cleanup ANSI C style variable declarations, since const allows you to declare and assign variables on the same line.
+* Make the bytecode work with big endian. On a big endian machine, the bytecode should be converted to little endian
+to make work on little endian as little as possible, meaning it would be a small penality to use big endian.
+* Verify all members of an extern struct are extern as well. Verify all parameters are of extern types for extern functions.
+* Verify all code execution paths in a function return a value, if the function excepts return values.
+* Show compile error if the result of a function call is ignored.
+* Show compile error if variables are assigned to but not used.
+* Push arguments in reverse order (right-to-left, cdecl) (in program.c, since on windows we will need to support stdcall which is left-to-right).
+* After tokenizing files, unload file data to disk if possible.
+* Parallelize program decoding, if there is an advantage to doing it.
+* Logical AND binop should skip expressions the moment the result becomes false.
+* Reorder functions and imports by how they are used. Functions and imports that are used in some files
+should be in the bytecode before the files that they are used from, to reduce deferred function calls.
+* Document all limits.
+* To remove some overhead that external variables have on LhsExpr, make a ExternLhsExpr type.
+* Make function calls work for functions that return no value or returns multiple values.
 # Documents
 Documents are located under doc. The file doc/Documentation.md is generated from source files by running doc/doc_extract.py
 but there is no need to run this script unless you are modifying documentation in the source.
diff --git a/doc/Documentation.md b/doc/Documentation.md
index adb0bef..ca579a2 100644
--- a/doc/Documentation.md
+++ b/doc/Documentation.md
@@ -16,11 +16,14 @@ Instructions can be in 7 different formats:
 6.2 Opcode(u8) + register(i8) + intermediate(u16)\
 6.3 Opcode(u8) + register(i8) + data(u16)\
 6.4 Opcode(u8) + flags(u8) + num_local_var_reg(u16)
-7. 5 bytes: Opcode(u8) + index(u16) + num_args(u8) + register(i8)
+7. 5 bytes: Opcode(u8) + index(u8) + index(u16) + num_args(u8)
 ## Registers
 Registers have a range of 128. Local variables start from register 0 and increment while parameters start from -1
 and decrement. Registers have the scope of functions and reset after instructions reach a new function (AMAL_OP_FUNC_START).
 
+If import index for call and calle is 0, then that means the function resides in the same file the function call
+is being called from. Which means that import index 1 is actually import index 0 into the import list.
+
 # Compiler flow
 (Tokenize&parse -> Resolve AST -> Generate SSA -> Generate bytecode) -> Generate program\
 Each step except the last is done using multiple threads in parallel and the output of each step is used
@@ -29,7 +32,9 @@ and writing it to a file, which is an IO bottlenecked operation and it won't ben
 and may even lose performance because of it.
 
 # Bytecode
-The layout of the full bytecode is: Header (Intermediates Strings Functions External_Functions Exported_Functions Instructions)*
+The layout of the full bytecode is: Header (X Intermediates X Strings X Functions X External_Functions X Exported_Functions X Imports X Instructions)*\
+Where the X is a magic number to make it easier to find errors while decoding the bytecode.\
+The value of the magic number is @AMAL_BYTECODE_SECTION_MAGIC_NUMBER
 
 # Bytecode header
 ## Header layout
@@ -44,10 +49,10 @@ The versions in the header only changes for every release, not every change.
 
 # Bytecode intermediates
 ## Intermediates layout
-|Type        |Field             |Description                                                                    |
-|------------|------------------|-------------------------------------------------------------------------------|
-|u32         |Intermediates size|The size of the intermediates section, in bytes.                               |
-|Intermediate|Intermediate data |Multiple intermediates, where the total size is defined by @Intermediates size.|
+|Type          |Field             |Description                                                                    |
+|--------------|------------------|-------------------------------------------------------------------------------|
+|u32           |Intermediates size|The size of all intermediates, in bytes.                                       |
+|Intermediate[]|Intermediate data |Multiple intermediates, where the total size is defined by @Intermediates size.|
 
 ## Intermediate
 |Type|Field|Description                                         |
@@ -57,11 +62,11 @@ The versions in the header only changes for every release, not every change.
 
 # Bytecode strings
 ## Strings layout
-|Type  |Field            |Description                                                       |
-|------|-----------------|------------------------------------------------------------------|
-|u16   |Number of strings|The number of strings.                                            |
-|u32   |Strings size     |The size of the strings section, in bytes.                        |
-|String|Strings data     |Multiple strings, where the total size is defined by @Strings size|
+|Type    |Field            |Description                                                       |
+|--------|-----------------|------------------------------------------------------------------|
+|u16     |Number of strings|The number of strings.                                            |
+|u32     |Strings size     |The size of all strings, in bytes.                                |
+|String[]|Strings data     |Multiple strings, where the total size is defined by @Strings size|
 
 ## String
 |Type|Field|Description                                                                            |
@@ -70,33 +75,46 @@ The versions in the header only changes for every release, not every change.
 |u8* |Data|The data of the string, where the size is defined by @Size. Strings are null-terminated.|
 
 # Bytecode functions
-## Internal functions layout
-|Type|Field              |Description                      |
-|----|-------------------|---------------------------------|
-|u16 |Number of functions|The number of internal functions.|
+## Functions layout
+|Type      |Field     |Description                                                                           |
+|----------|----------|--------------------------------------------------------------------------------------|
+|u16       |num_funcs |The number of non-extern functions.                                                   |
+|u32       |funcs_size|The size of all functions, in bytes.                                                  |
+|Function[]|Functions |Multiple non-extern functions, where the number of functions is defined by @num_funcs.|
+
+## Function
+|Type|Field                    |Description                                                                                                             |
+|----|-------------------------|------------------------------------------------------------------------------------------------------------------------|
+|u32 |func_offset              |The offset in the program code (machine code) where the function starts. Is always 0 until the program has been started.|
+|u8  |num_params               |The number of parameters.                                                                                               |
+|u32 |params_num_pointers      |The number of pointers in the parameters.                                                                               |
+|u32 |params_fixed_size        |The size of all non-pointer type parameters, in bytes.                                                                  |
+|u8  |num_return_types         |The number of return values.                                                                                            |
+|u32 |return_types_num_pointers|The number of pointers in the return types.                                                                             |
+|u32 |return_types_fixed_size  |The size of all non-pointer type return types, in bytes.                                                                |
 
 # Bytecode external functions
 ## External functions layout
-|Type             |Field             |Description                                                                              |
-|-----------------|------------------|-----------------------------------------------------------------------------------------|
-|u16              |num_extern_func   |The number of external functions.                                                        |
-|u32              |extern_funcs_size |The size of the external functions section, in bytes.                                    |
-|External function|External functions|Multiple external functions, where the number of functions is defined by @num_extern_func|
+|Type               |Field             |Description                                                                              |
+|-------------------|------------------|-----------------------------------------------------------------------------------------|
+|u16                |num_extern_func   |The number of external functions.                                                        |
+|u32                |extern_funcs_size |The size of all external functions, in bytes.                                            |
+|External function[]|External functions|Multiple external functions, where the number of functions is defined by @num_extern_func|
 
 ## External function
-|Type|Field   |Description                                                                                          |
-|----|--------|-----------------------------------------------------------------------------------------------------|
-|u8  |num_args|The number of arguments the functions has.                                                           |
-|u8  |name_len|The length of the external function name, in bytes. Excluding the null-terminate character.          |
-|u8* |name    |The name of the external function, where the size is defined by @name_len. Names are null-terminated.|
+|Type|Field     |Description                                                                                          |
+|----|----------|-----------------------------------------------------------------------------------------------------|
+|u8  |num_params|The number of parameters the functions has.                                                          |
+|u8  |name_len  |The length of the external function name, in bytes. Excluding the null-terminate character.          |
+|u8[]|name      |The name of the external function, where the size is defined by @name_len. Names are null-terminated.|
 
 # Bytecode exported functions
 ## Exported functions layout
-|Type             |Field             |Description                                                                              |
-|-----------------|------------------|-----------------------------------------------------------------------------------------|
-|u16              |num_export_func   |The number of exported functions.                                                        |
-|u32              |export_funcs_size |The size of the exported functions section, in bytes.                                    |
-|Exported function|Exported functions|Multiple exported functions, where the number of functions is defined by @num_export_func|
+|Type               |Field             |Description                                                                              |
+|-------------------|------------------|-----------------------------------------------------------------------------------------|
+|u16                |num_export_func   |The number of exported functions.                                                        |
+|u32                |export_funcs_size |The size of all exported functions, in bytes.                                            |
+|Exported function[]|Exported functions|Multiple exported functions, where the number of functions is defined by @num_export_func|
 
 ## Exported function
 |Type|Field             |Description                                                                                                               |
@@ -104,7 +122,21 @@ The versions in the header only changes for every release, not every change.
 |u32 |instruction_offset|The offset in the instruction data where the exported function is defined. Is always 0 until the program has been started.|
 |u8  |num_args          |The number of arguments the functions has.                                                                                |
 |u8  |name_len          |The length of the exported function name, in bytes. Excluding the null-terminate character.                               |
-|u8* |name              |The name of the exported function, where the size is defined by @name_len. Names are null-terminated.                     |
+|u8[]|name              |The name of the exported function, where the size is defined by @name_len. Names are null-terminated.                     |
+
+# Bytecode imports
+## Imports layout
+|Type    |Field       |Description                                                              |
+|--------|------------|-------------------------------------------------------------------------|
+|u8      |num_imports |The number of imports.                                                   |
+|u32     |imports_size|The size of all imports, in bytes.                                       |
+|Import[]|Import      |Multiple imports, where the number of imports is defined by @num_imports.|
+
+## Import
+|Type|Field                |Description                                                                             |
+|----|---------------------|----------------------------------------------------------------------------------------|
+|u32 |function_index       |The index in the bytecode where function header begins for the imported file.           |
+|u32 |extern_function_index|The index in the bytecode where the extern function header begins for the imported file.|
 
 # Bytecode instructions
 ## Instructions layout
diff --git a/doc/IMPLEMENTATION.md b/doc/IMPLEMENTATION.md
deleted file mode 100644
index 387c6eb..0000000
--- a/doc/IMPLEMENTATION.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# Goal
-1. In the first stage the parser parses multiple files at the same time using multiple threads.
-The tokenization should be done without storing the tokens in a list (streaming) but AST needs to be stored in a list
-because the compiler needs to support out of order declarations.
-2. In the second stage the ast is handled using multiple threads. In this stage, variables, parameters
-and types are defined and resolved and if a type is defined after there is a reference to it,
-then the compiler first resolves that type. There are flags set to make sure there aren't recursive dependencies.
-3. In the third stage the resolved ast is used to create SSA form (static single assignment form). If optimization is
-enabled then then some inlining for ast is done by copying ast from functions to the places they are called from
-before the SSA is created.
-4. In the fourth stage the SSA form is used to create the bytecode. If optimization is enabled then the SSA form
-is optimized before creating the bytecode.
-5. If optimization is enabled then the bytecode is optimized.
-
-# Progress
-1. Parsing using multiple threads is done, but the parser is not finished.
-2. Resolving ast using multiple threads is done, but the ast resolver is not finished.
-3. Generating ssa using multiple threads is done, but the ssa generator is not finished.
-4. Generating bytecode using multiple threads is done, but the bytecode generator is not finished.
-Currently it generates C code.
-5. Not started.
\ No newline at end of file
diff --git a/executor/executor.h b/executor/executor.h
index a0be5c9..743500c 100644
--- a/executor/executor.h
+++ b/executor/executor.h
@@ -39,7 +39,8 @@ CHECK_RESULT int amal_exec_div(amal_executor *self, i8 dst_reg, i8 src_reg1, i8
 CHECK_RESULT int amal_exec_push(amal_executor *self, i8 reg);
 CHECK_RESULT int amal_exec_pushi(amal_executor *self, i64 imm);
 CHECK_RESULT int amal_exec_pushd(amal_executor *self, BufferView data);
-CHECK_RESULT int amal_exec_call(amal_executor *self, u16 func_index, u8 num_args, i8 dst_reg);
+CHECK_RESULT int amal_exec_call(amal_executor *self, u32 code_offset, u8 num_args, i8 dst_reg);
+void amal_exec_call_overwrite(amal_executor *self, u32 call_code_offset, i32 new_target_rel32);
 /*CHECK_RESULT int amal_exec_callr(i8 dst_reg, BufferView data);*/
 CHECK_RESULT int amal_exec_calle(amal_executor *self, void *func, u8 num_args, i8 dst_reg);
 CHECK_RESULT int amal_exec_cmp(amal_executor *self, i8 dst_reg, i8 src_reg1, i8 src_reg2);
diff --git a/executor/x86_64/asm.c b/executor/x86_64/asm.c
index c2b00ef..e29130e 100644
--- a/executor/x86_64/asm.c
+++ b/executor/x86_64/asm.c
@@ -218,24 +218,22 @@ int asm_execute(Asm *self, u32 offset) {
     /*asm_print_code_hex(self);*/
 
     /* TODO: Verify if this is valid on all platforms. According to ISO C standard it isn't? */
-    *(void**)(&func) = self->code + offset;
+    *(void**)(&func) = (u8*)self->code + offset;
     func();
     return 0;
 }
 
 /* TODO: See how this can be optimized */
 int asm_ensure_capacity(Asm *self, usize size) {
-    usize current_offset;
-    current_offset = (u8*)self->code_it - (u8*)self->code;
+    usize current_offset = (u8*)self->code_it - (u8*)self->code;
     if(current_offset + size > self->allocated_size) {
-        void *new_mem;
-        usize new_size;
-        new_size = self->allocated_size + am_pagesize();
-        new_mem = mmap(NULL, new_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-        if(self->code == MAP_FAILED)
+        usize new_size = self->allocated_size + am_pagesize();
+        void *new_mem = mmap(NULL, new_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+        if(new_mem == MAP_FAILED)
             return -errno;
 
         am_memcpy(new_mem, self->code, self->allocated_size);
+        munmap(self->code, self->allocated_size);
         self->code = new_mem;
         self->allocated_size = new_size;
         self->code_it = (u8*)self->code + current_offset;
@@ -435,7 +433,7 @@ void asm_callr(Asm *self, Reg64 reg) {
 
 /*
     Note: This is sometimes called with @relative 0 (will print call -5), in which case it's most likely a dummy call until the relative position
-    is later changed with @asm_override_call_rel32. TODO: Update the ins_end debug print to take that into account somehow
+    is later changed with @asm_overwrite_call_rel32. TODO: Update the ins_end debug print to take that into account somehow
 */
 void asm_call_rel32(Asm *self, i32 relative) {
     ins_start(self);
@@ -446,8 +444,8 @@ void asm_call_rel32(Asm *self, i32 relative) {
     ins_end(self, "call 0x%x", relative);
 }
 
-void asm_override_call_rel32(Asm *self, u32 asm_index, i32 new_relative) {
-    assert(*(u8*)(self->code + asm_index) == 0xE8);
+void asm_overwrite_call_rel32(Asm *self, u32 asm_index, i32 new_relative) {
+    assert(*((u8*)self->code + asm_index) == 0xE8);
     new_relative -= 5; /* In x86, the relative position starts from the next instruction */
     am_memcpy((u8*)self->code + asm_index + 1, &new_relative, sizeof(new_relative));
 }
@@ -480,7 +478,7 @@ void asm_sete_r(Asm *self, Reg64 dst) {
 
 /*
     Note: This is sometimes called with @relative INT32_MAX-(2 or 6) (will print jz 0x7ffffff9), in which case it's most likely a dummy
-    jump until the relative position is later changed with @asm_override_jcc_rel32.
+    jump until the relative position is later changed with @asm_overwrite_jcc_rel32.
     TODO: Update the ins_end debug print to take that into account somehow
 */
 void asm_jz(Asm *self, i32 relative) {
@@ -503,17 +501,17 @@ void asm_jz(Asm *self, i32 relative) {
     ins_end(self, "jz 0x%x", relative);
 }
 
-void asm_override_jcc_rel32(Asm *self, u32 asm_index, i32 new_relative) {
+void asm_overwrite_jcc_rel32(Asm *self, u32 asm_index, i32 new_relative) {
     /* +2 because rel32 variant of the jump instruction opcode is 2 bytes */
-    assert(*(u8*)(self->code + asm_index) == 0x0F);
-    assert(*(u8*)(self->code + asm_index + 1) == 0x84);
+    assert(*((u8*)self->code + asm_index) == 0x0F);
+    assert(*((u8*)self->code + asm_index + 1) == 0x84);
     new_relative -= 6; /* In x86, the relative position starts from the next instruction */
     am_memcpy((u8*)self->code + asm_index + 2, &new_relative, sizeof(new_relative));
 }
 
 /*
     Note: This is sometimes called with @relative INT32_MAX-(2 or 5) (will print jmp 0x7ffffffa), in which case it's most likely a dummy
-    jump until the relative position is later changed with @asm_override_jmp_rel32.
+    jump until the relative position is later changed with @asm_overwrite_jmp_rel32.
     TODO: Update the ins_end debug print to take that into account somehow
 */
 void asm_jmp(Asm *self, i32 relative) {
@@ -535,9 +533,9 @@ void asm_jmp(Asm *self, i32 relative) {
     ins_end(self, "jmp 0x%x", relative);
 }
 
-void asm_override_jmp_rel32(Asm *self, u32 asm_index, i32 new_relative) {
+void asm_overwrite_jmp_rel32(Asm *self, u32 asm_index, i32 new_relative) {
     /* +1 to skip instruction opcode */
-    assert(*(u8*)(self->code + asm_index) == 0xE9);
+    assert(*((u8*)self->code + asm_index) == 0xE9);
     new_relative -= 5; /* In x86, the relative position starts from the next instruction */
     am_memcpy((u8*)self->code + asm_index + 1, &new_relative, sizeof(new_relative));
 }
diff --git a/executor/x86_64/asm.h b/executor/x86_64/asm.h
index a3f1b5a..6ac74f4 100644
--- a/executor/x86_64/asm.h
+++ b/executor/x86_64/asm.h
@@ -88,7 +88,7 @@ void asm_callr(Asm *self, Reg64 reg);
     by this asm library itself.
 */
 void asm_call_rel32(Asm *self, i32 relative);
-void asm_override_call_rel32(Asm *self, u32 asm_index, i32 new_relative);
+void asm_overwrite_call_rel32(Asm *self, u32 asm_index, i32 new_relative);
 
 void asm_cmp_rm(Asm *self, Reg64 reg1, AsmPtr *reg2);
 /*
@@ -104,15 +104,15 @@ void asm_sete_r(Asm *self, Reg64 dst);
     by this asm library itself.
 */
 void asm_jz(Asm *self, i32 relative);
-/* Override conditional jump target */
-void asm_override_jcc_rel32(Asm *self, u32 asm_index, i32 new_relative);
+/* Overwrite conditional jump target */
+void asm_overwrite_jcc_rel32(Asm *self, u32 asm_index, i32 new_relative);
 /*
     In x86 assembly, the @relative position starts from the next instruction.
     This offset shouldn't be calculated by the caller and is instead managed
     by this asm library itself.
 */
 void asm_jmp(Asm *self, i32 relative);
-void asm_override_jmp_rel32(Asm *self, u32 asm_index, i32 new_relative);
+void asm_overwrite_jmp_rel32(Asm *self, u32 asm_index, i32 new_relative);
 
 
 
diff --git a/executor/x86_64/executor.c b/executor/x86_64/executor.c
index 9083e14..c442da8 100644
--- a/executor/x86_64/executor.c
+++ b/executor/x86_64/executor.c
@@ -1,6 +1,7 @@
 #include "../executor.h"
 #include "../../include/std/alloc.h"
 #include "../../include/std/buffer.h"
+#include "../../include/std/log.h"
 #include "asm.h"
 #include <assert.h>
 
@@ -19,29 +20,23 @@
 
 typedef struct {
     u32 asm_index;
-    u16 func_index;
-} CallDefer;
-
-typedef struct {
-    u32 asm_index;
     u16 target_label;
     bool condition;
 } JumpDefer;
 
 typedef struct {
     Asm asm;
-    usize *function_indices;
-    u16 num_functions;
     u16 func_counter;
-    Buffer/*CallDefer*/ call_defer;
     Buffer/*JumpDefer*/ jump_defer;
     u32 label_asm_index[MAX_LABELS];
     int label_counter;
 } amal_executor_impl;
 
+#define ASM_ENSURE_CAPACITY return_if_error(asm_ensure_capacity(&impl->asm, 256));
+
 #define IMPL_START \
     amal_executor_impl *impl = (amal_executor_impl*)self; \
-    return_if_error(asm_ensure_capacity(&impl->asm, 256));
+    ASM_ENSURE_CAPACITY
 
 /*
     @reg will be a positive value when accessing local variables, in which case the first
@@ -64,10 +59,7 @@ int amal_executor_init(amal_executor **self) {
     impl = (amal_executor_impl**)self;
     *impl = NULL;
     return_if_error(am_malloc(sizeof(amal_executor_impl), (void**)impl));
-    (*impl)->function_indices = NULL;
-    (*impl)->num_functions = 0;
     (*impl)->func_counter = 0;
-    ignore_result_int(buffer_init(&(*impl)->call_defer, NULL));
     ignore_result_int(buffer_init(&(*impl)->jump_defer, NULL));
     (*impl)->label_counter = 0;
     return asm_init(&(*impl)->asm);
@@ -76,8 +68,6 @@ int amal_executor_init(amal_executor **self) {
 void amal_executor_deinit(amal_executor *self) {
     amal_executor_impl *impl = (amal_executor_impl*)self;
     buffer_deinit(&impl->jump_defer);
-    buffer_deinit(&impl->call_defer);
-    am_free(impl->function_indices);
     asm_deinit(&impl->asm);
     am_free(impl);
 }
@@ -93,26 +83,13 @@ u32 amal_exec_get_code_offset(amal_executor *self) {
 }
 
 int amal_executor_instructions_start(amal_executor *self, u16 num_functions) {
-    amal_executor_impl *impl = (amal_executor_impl*)self;
-    return_if_error(am_realloc(impl->function_indices, num_functions * sizeof(usize), (void**)&impl->function_indices));
-    impl->num_functions = num_functions;
+    (void)self;
+    (void)num_functions;
     return 0;
 }
 
 int amal_executor_instructions_end(amal_executor *self) {
     amal_executor_impl *impl = (amal_executor_impl*)self;
-    CallDefer *call_defer = buffer_begin(&impl->call_defer);
-    CallDefer *call_defer_end = buffer_end(&impl->call_defer);
-    for(; call_defer != call_defer_end; ++call_defer) {
-        i32 func_offset;
-        if(call_defer->func_index >= impl->num_functions) {
-            amal_log_error("Program attempted to call a function that doesn't exist (index %u, while there are only %u functions)", call_defer->func_index, impl->num_functions);
-            return -1;
-        }
-        func_offset = (isize)impl->function_indices[call_defer->func_index] - (isize)call_defer->asm_index;
-        asm_override_call_rel32(&impl->asm, call_defer->asm_index, func_offset);
-    }
-    buffer_clear(&impl->call_defer);
     impl->func_counter = 0;
     return 0;
 }
@@ -299,25 +276,16 @@ int amal_exec_pushd(amal_executor *self, BufferView data) {
     return 0;
 }
 
-int amal_exec_call(amal_executor *self, u16 func_index, u8 num_args, i8 dst_reg) {
-    IMPL_START
+int amal_exec_call(amal_executor *self, u32 code_offset, u8 num_args, i8 dst_reg) {
+    amal_executor_impl *impl = (amal_executor_impl*)self;
     /* TODO: Preserve necessary registers before call? */
     /* TODO: This assumes all arguments are isize */
     /* Do the function call */
     isize asm_offset = asm_get_size(&impl->asm);
-    if(func_index < impl->func_counter) {
-        asm_call_rel32(&impl->asm, (isize)impl->function_indices[func_index] - asm_offset);
-    } else {
-        /*
-            The location of the function has not been defined yet. Use call instruction with dummy data and change
-            the location once the location to the function is known
-        */
-        CallDefer call_defer;
-        call_defer.asm_index = asm_offset;
-        call_defer.func_index = func_index;
-        return_if_error(buffer_append(&impl->call_defer, &call_defer, sizeof(call_defer)));
-        asm_call_rel32(&impl->asm, 0);
-    }
+    ASM_ENSURE_CAPACITY
+
+    assert(code_offset < asm_offset);
+    asm_call_rel32(&impl->asm, (isize)code_offset - asm_offset);
 
     /* Handle function result and cleanup */
     {
@@ -331,6 +299,11 @@ int amal_exec_call(amal_executor *self, u16 func_index, u8 num_args, i8 dst_reg)
     return 0;
 }
 
+void amal_exec_call_overwrite(amal_executor *self, u32 call_code_offset, i32 new_target_rel32) {
+    amal_executor_impl *impl = (amal_executor_impl*)self;
+    asm_overwrite_call_rel32(&impl->asm, call_code_offset, new_target_rel32);
+}
+
 const Reg64 SYS_V_PARAM_REGS[] = { RDI, RSI, RDX, RCX };
 
 /*
@@ -379,9 +352,9 @@ int amal_exec_callr(i8 dst_reg, BufferView data) {
 */
 
 int amal_exec_cmp(amal_executor *self, i8 dst_reg, i8 src_reg1, i8 src_reg2) {
+    AsmPtr dst, src1, src2;
     IMPL_START
 
-    AsmPtr dst, src1, src2;
     asm_ptr_init_disp(&dst, RBP, get_register_stack_offset(dst_reg));
     asm_ptr_init_disp(&src1, RBP, get_register_stack_offset(src_reg1));
     asm_ptr_init_disp(&src2, RBP, get_register_stack_offset(src_reg2));
@@ -424,8 +397,9 @@ int amal_exec_jz(amal_executor *self, i8 reg, u16 target_label) {
 }
 
 int amal_exec_jmp(amal_executor *self, u16 target_label) {
-    IMPL_START
+    amal_executor_impl *impl = (amal_executor_impl*)self;
     u32 asm_offset = asm_get_size(&impl->asm);
+    ASM_ENSURE_CAPACITY
     if(target_label < impl->label_counter) {
         asm_jmp(&impl->asm, (i32)impl->label_asm_index[target_label] - (i32)asm_offset);
         return 0;
@@ -466,7 +440,6 @@ int amal_exec_func_start(amal_executor *self, u16 num_regs) {
         64-bit Linux,BSD,Mac: RBX, RBP, R12-R15
     */
     IMPL_START
-    impl->function_indices[impl->func_counter++] = asm_get_size(&impl->asm);
     asm_pushr(&impl->asm, RBX);
     asm_pushr(&impl->asm, RBP);
     asm_mov_rr(&impl->asm, RBP, RSP);
@@ -475,10 +448,10 @@ int amal_exec_func_start(amal_executor *self, u16 num_regs) {
 }
 
 int amal_exec_func_end(amal_executor *self) {
-    IMPL_START
-
+    amal_executor_impl *impl = (amal_executor_impl*)self;
     JumpDefer *jump_defer = buffer_begin(&impl->jump_defer);
     JumpDefer *jump_defer_end = buffer_end(&impl->jump_defer);
+    ASM_ENSURE_CAPACITY
     for(; jump_defer != jump_defer_end; ++jump_defer) {
         i32 jump_offset;
         if(jump_defer->target_label >= impl->label_counter) {
@@ -487,9 +460,9 @@ int amal_exec_func_end(amal_executor *self) {
         }
         jump_offset = (isize)impl->label_asm_index[jump_defer->target_label] - (isize)jump_defer->asm_index;
         if(jump_defer->condition)
-            asm_override_jcc_rel32(&impl->asm, jump_defer->asm_index, jump_offset);
+            asm_overwrite_jcc_rel32(&impl->asm, jump_defer->asm_index, jump_offset);
         else
-            asm_override_jmp_rel32(&impl->asm, jump_defer->asm_index, jump_offset);
+            asm_overwrite_jmp_rel32(&impl->asm, jump_defer->asm_index, jump_offset);
     }
     buffer_clear(&impl->jump_defer);
     impl->label_counter = 0;
@@ -502,7 +475,7 @@ int amal_exec_func_end(amal_executor *self) {
 }
 
 int amal_exec_label(amal_executor *self) {
-    IMPL_START
+    amal_executor_impl *impl = (amal_executor_impl*)self;
     assert(impl->label_counter < MAX_LABELS);
     impl->label_asm_index[impl->label_counter++] = asm_get_size(&impl->asm);
     return 0;
diff --git a/include/ast.h b/include/ast.h
index edf225b..0c34d0b 100644
--- a/include/ast.h
+++ b/include/ast.h
@@ -23,7 +23,6 @@ typedef struct FunctionParameter FunctionParameter;
 typedef struct FunctionCall FunctionCall;
 typedef struct StructDecl StructDecl;
 typedef struct StructField StructField;
-typedef struct LhsExpr LhsExpr;
 typedef struct AssignmentExpr AssignmentExpr;
 typedef struct Import Import;
 typedef struct String String;
@@ -147,10 +146,16 @@ typedef struct {
 } VariableType;
 
 struct FileScopeReference {
-    Parser *parser;
+    Parser *parser; /* Borrowed, the parser that belongs to the same file as the FileScopeReference */
     Buffer canonical_path;
 };
 
+struct ParserFileScopeReference {
+    FileScopeReference *file_scope_ref;
+    /* Index in the parser import list. Used by bytecode to know which import an expression belongs to */
+    int import_index;
+};
+
 struct Variable {
     BufferView name;
     ScopeNamedObject resolved_var;
@@ -177,7 +182,7 @@ struct FunctionSignature {
 
 struct FunctionDecl {
     LhsExpr *lhs_expr; /* Borrowed from the LhsExpr that owns this FunctionDecl if it exists, otherwise NULL */
-    FunctionSignature *signature;
+    FunctionSignature *signature; /* TODO: Make this a non-pointer type? */
     Scope body;
     SsaFuncIndex ssa_func_index;
 };
@@ -188,7 +193,15 @@ struct FunctionCall {
 };
 
 struct StructDecl {
+    /*
+        TODO: Instead of having a scope body, use a body with only structdecl. This improves performance
+        and simplifies the code.
+    */
     Scope body;
+    /* The number of fields that are pointers or a type that is different on different platforms (i.e isize, usize, etc), recursive */
+    u32 fields_num_pointers;
+    /* The total size of all fields which are of a type that have the same size on all platforms (i.e u8, i32, etc), recursive */
+    u32 fields_fixed_size_bytes;
 };
 
 struct StructField {
@@ -232,7 +245,7 @@ struct AssignmentExpr {
 
 struct Import {
     BufferView path;
-    FileScopeReference *file_scope;
+    ParserFileScopeReference *file_scope;
 };
 
 struct String {
@@ -279,6 +292,11 @@ struct ReturnExpr {
 };
 
 typedef struct {
+    u32 num_pointers;
+    u32 fixed_size;
+} TypeSize;
+
+typedef struct {
     jmp_buf env;
     amal_compiler *compiler; /* Borrowed */
     Parser *parser; /* Borrowed. This is the parser that belongs to the thread */
@@ -303,6 +321,7 @@ void function_parameter_init(FunctionParameter *self);
 CHECK_RESULT int funcdecl_init(FunctionDecl *self, FunctionSignature *signature, Scope *parent, ArenaAllocator *allocator);
 CHECK_RESULT int funccall_init(FunctionCall *self, BufferView name, ArenaAllocator *allocator);
 CHECK_RESULT int structdecl_init(StructDecl *self, Scope *parent, ArenaAllocator *allocator);
+CHECK_RESULT int structdecl_add_field(StructDecl *self, StructField *field, ArenaAllocator *allocator);
 LhsExpr* structdecl_get_field_by_name(StructDecl *self, BufferView field_name);
 /* Copies @type */
 void structfield_init(StructField *self, BufferView name, VariableType *type);
@@ -318,14 +337,13 @@ CHECK_RESULT int else_if_statement_init(ElseIfStatement *self, Scope *parent, Ar
 CHECK_RESULT int while_statement_init(WhileStatement *self, Scope *parent, ArenaAllocator *allocator);
 void return_expr_init(ReturnExpr *self, Ast *rhs_expr);
 
+TypeSize resolved_type_get_byte_size(AstResolvedType *self);
+
 CHECK_RESULT int scope_init(Scope *self, Scope *parent, ArenaAllocator *allocator);
 CHECK_RESULT int file_scope_reference_init(FileScopeReference *self, BufferView canonical_path, ArenaAllocator *allocator);
 CHECK_RESULT int scope_add_child(Scope *self, Ast *child);
+
 /* longjump to compiler env on failure */
 void scope_resolve(Scope *self, AstCompilerContext *context);
 
-
-
-CHECK_RESULT bool resolved_type_is_func_decl(Ast *self);
-
 #endif
diff --git a/include/bytecode/bytecode.h b/include/bytecode/bytecode.h
index b1b5dda..c495d7a 100644
--- a/include/bytecode/bytecode.h
+++ b/include/bytecode/bytecode.h
@@ -26,11 +26,15 @@
     6.2 Opcode(u8) + register(i8) + intermediate(u16)\
     6.3 Opcode(u8) + register(i8) + data(u16)\
     6.4 Opcode(u8) + flags(u8) + num_local_var_reg(u16)
-    7. 5 bytes: Opcode(u8) + index(u16) + num_args(u8) + register(i8)
+    7. 5 bytes: Opcode(u8) + index(u8) + index(u16) + num_args(u8)
     # Registers
     Registers have a range of 128. Local variables start from register 0 and increment while parameters start from -1
     and decrement. Registers have the scope of functions and reset after instructions reach a new function (AMAL_OP_FUNC_START).
+
+    If import index for call and calle is 0, then that means the function resides in the same file the function call
+    is being called from. Which means that import index 1 is actually import index 0 into the import list.
 */
+/* Important: The number of fields in this enum can't exceed 255 */
 typedef enum {
     AMAL_OP_NOP,         /* No operation (do nothing). This can be used for patching code */
     AMAL_OP_SETZ,        /* setz reg                             - Set register value to 0 */
@@ -46,16 +50,17 @@ typedef enum {
     AMAL_OP_PUSH,        /* push reg                             - Push register onto stack */
     AMAL_OP_PUSHI,       /* pushi int                            - Push intermediate onto stack */
     AMAL_OP_PUSHD,       /* pushd data                           - Push data onto stack */
-    AMAL_OP_CALL,        /* call fi, num_args, dst               - Call a function using function index (fi) and num_args arguments. The result is stored in register dst. fi is u16 and num_args is u8 */
+    AMAL_OP_PUSH_RET,    /* push_ret reg                         - Push register onto stack as a return value of the next function call */
+    AMAL_OP_CALL,        /* call ii, fi, num_args                - Call a function in imported file (ii, import index) using function index (fi) and num_args arguments. ii is u8, fi is u16 and num_args is u8 */
     AMAL_OP_CALLR,       /* callr reg, num_args                  - Call a function using a register. Used for function pointers. num_args is u8 */
-    AMAL_OP_CALLE,       /* calle efi, num_args, dst             - Call an extern function using extern function index (efi) and num_args arguments. The result is stored in register dst. efi is u16 and num_args is u8 */
+    AMAL_OP_CALLE,       /* calle ii, efi, num_args              - Call an extern function in imported file (ii, import index) using extern function index (efi) and num_args arguments. ii is u8, efi is u16 and num_args is u8 */
     AMAL_OP_CMP,         /* cmp dst, reg1, reg2                  - Set dst to 1 if reg1 equals reg2, otherwise set it to 0 */
     AMAL_OP_JZ,          /* jz reg, label                        - Jump to label in the current function if reg is zero. label is u16 */
     AMAL_OP_JMP,         /* jmp label                            - Unconditional jump to label in the current function. label is u16 */
     AMAL_OP_RET,         /* ret reg                              - Return from the function with reg result */
     AMAL_OP_FUNC_START,  /* func_start flags, num_local_var_reg  - Start of a function which has @num_local_var_reg local variable registers allocated and has the flag @flag. @flag is u8 and @num_local_var_reg is u16 */
     AMAL_OP_FUNC_END,    /* func_end                             - End of a function. Implementation should do a ret here */
-    AMAL_OP_LABEL,       /* label                                - Label. This is the target of a jump instruction. Jump instructions only jump to labels in the same function scope */
+    AMAL_OP_LABEL        /* label                                - Label. This is the target of a jump instruction. Jump instructions only jump to labels in the same function scope */
 } AmalOpcode;
 
 #define AMAL_BYTECODE_MAGIC_NUMBER (u32)0xdec05eba
@@ -63,6 +68,8 @@ typedef enum {
 #define AMAL_BYTECODE_MINOR_VERSION 0
 #define AMAL_BYTECODE_PATCH_VERSION 0
 
+#define AMAL_BYTECODE_SECTION_MAGIC_NUMBER (u32)0x004005e4 /* "section\0" in ascii */
+
 #define AMAL_BYTECODE_NUM_REGISTERS 256
 
 typedef enum {
@@ -72,13 +79,40 @@ typedef enum {
 
 typedef u8 AmalOpcodeType;
 
+/* TODO: Make sure this pragma pack works on all platforms */
+#pragma pack(push, 1)
+typedef struct {
+    u32 func_offset;
+    u8 num_params;
+    u32 params_num_pointers;
+    u32 params_fixed_size;
+
+    u8 num_return_types;
+    u32 return_types_num_pointers;
+    u32 return_types_fixed_size;
+} BytecodeHeaderFunction;
+#pragma pack(pop)
+
+/* TODO: Make sure this pragma pack works on all platforms */
+#pragma pack(push, 1)
 typedef struct {
+    u32 function_index;
+    #define parser_index function_index
+    u32 extern_function_index;
+} BytecodeHeaderImport;
+#pragma pack(pop)
+
+struct Bytecode {
     Buffer/*<headers + instruction data>*/ data;
-} Bytecode;
+    usize import_index;     /* Reference inside @data where imports start */
+    u32 funcs_index;        /* Reference inside @data where funcs start */
+    u32 extern_funcs_index; /* Reference inside @data where extern funcs start */
+    u32 offset;             /* Offset that this bytecode starts from in the final program (all bytecodes combined) */
+};
 
 typedef struct {
     jmp_buf env;
-    Bytecode bytecode;
+    Bytecode *bytecode;
     Parser *parser; /* borrowed */
 } BytecodeCompilerContext;
 
diff --git a/include/defs.h b/include/defs.h
index 669d9c9..bb96421 100644
--- a/include/defs.h
+++ b/include/defs.h
@@ -5,8 +5,11 @@ typedef struct amal_compiler amal_compiler;
 typedef struct Parser Parser;
 typedef struct Scope Scope;
 typedef struct FileScopeReference FileScopeReference;
+typedef struct ParserFileScopeReference ParserFileScopeReference;
 typedef struct FunctionDecl FunctionDecl;
 typedef struct FunctionSignature FunctionSignature;
+typedef struct LhsExpr LhsExpr;
 typedef struct Tokenizer Tokenizer;
+typedef struct Bytecode Bytecode;
 
 #endif
diff --git a/include/parser.h b/include/parser.h
index 81895e1..ae5cfa6 100644
--- a/include/parser.h
+++ b/include/parser.h
@@ -4,7 +4,6 @@
 #include "std/buffer_view.h"
 #include "std/arena_allocator.h"
 #include "std/thread.h"
-#include "bytecode/bytecode.h"
 #include "tokenizer.h"
 #include "ast.h"
 #include "defs.h"
@@ -36,7 +35,14 @@ struct Parser {
     TokenizerError error;
     ErrorContext error_context;
     jmp_buf parse_env;
-    Bytecode bytecode;
+    Bytecode *bytecode;
+    Buffer/*<ParserFileScopeReference*>*/ imports;
+    HashMapType(BufferView, usize) imports_by_name; /* The value is an index inside @imports */
+    /*
+        Index in the compilers list of parsers. Used by bytecodes import header
+        to point to the index that contains references to another files variables.
+    */
+    u32 index; 
 };
 
 CHECK_RESULT int parser_init(Parser *self, amal_compiler *compiler, ArenaAllocator *allocator);
diff --git a/include/program.h b/include/program.h
index e3a4ac9..b398a3a 100644
--- a/include/program.h
+++ b/include/program.h
@@ -35,9 +35,13 @@
 #define AMAL_PROGRAM_INVALID_EXPORTED_FUNCTIONS_SIZE -23
 #define AMAL_PROGRAM_INSTRUCTION_INVALID_EXPORTED_FUNC_INDEX -24
 #define AMAL_PROGRAM_NO_MAIN_FUNC -25
+#define AMAL_PROGRAM_INVALID_IMPORTS -26
+#define AMAL_PROGRAM_SECTION_ERROR -27
 
 #define AMAL_PROGRAM_ARGS_SIZE_VARARGS -1
 
+#define AMAL_PROGRAM_MAX_RETURN_VALUES 128
+
 typedef struct {
     void *func;
     int args_byte_size; /* -1 if varargs (AMAL_PROGRAM_ARGS_SIZE_VARARGS) */
@@ -49,9 +53,11 @@ typedef struct {
     u32 *extern_func_indices;
     u8 *intermediates_start;  /* Reference inside @data */
     u8 *strings_start;        /* Reference inside @data */
+    u8 *funcs_start;          /* Reference inside @data */
     u8 *extern_funcs_start;   /* Reference inside @data */
     u8 *exported_funcs;       /* Reference inside @data */
     u8 *exported_funcs_end;   /* Reference inside @data */
+    u8 *imports_start;        /* Reference inside @data */
 
     usize read_index;
     u32 main_func_instruction_offset;
@@ -61,9 +67,14 @@ typedef struct {
     u16 num_functions;
     u16 num_extern_functions;
     u16 num_exported_functions;
+    u8 num_imports;
 
     ArenaAllocator allocator; /* Owned. Used by @extern_funcs_map */
     HashMapType(BufferView, ProgramExternFunc) extern_funcs_map;
+    /* key=((func_index<<32)&funcs_start), value=Buffer<u32=current_code_index> */
+    HashMapType(u64, Buffer) deferred_func_calls;
+    i8 return_values_stack[AMAL_PROGRAM_MAX_RETURN_VALUES];
+    int return_value_index;
 } amal_program;
 
 CHECK_RESULT int amal_program_init(amal_program *self);
diff --git a/include/ssa/ssa.h b/include/ssa/ssa.h
index 9d6949d..0b6501b 100644
--- a/include/ssa/ssa.h
+++ b/include/ssa/ssa.h
@@ -10,6 +10,7 @@
 
 #define SSA_ERR_EXTERN_FUNC_SIG_MISMATCH -20
 
+/* Important: The number of fields in this enum can't exceed 255 */
 typedef enum {
     SSA_ASSIGN_INTER,
     SSA_ASSIGN_STRING,
@@ -24,6 +25,7 @@ typedef enum {
     SSA_FUNC_START,
     SSA_FUNC_END,
     SSA_PUSH,
+    SSA_PUSH_RET,
     SSA_CALL,
     SSA_CALL_EXTERN,
     SSA_JUMP_ZERO,
@@ -55,6 +57,10 @@ typedef struct {
     BufferView name;
 } SsaExportFunc;
 
+typedef struct {
+    FunctionSignature *func_sig;
+} SsaFunc;
+
 typedef i16 JumpOffset;
 typedef i16 SsaRegister;
 typedef u16 SsaIntermediateIndex;
@@ -73,13 +79,15 @@ typedef struct {
     HashMapType(BufferView, SsaExternFuncIndex) extern_funcs_map;
     Buffer/*SsaExternFunc*/ extern_funcs;
     Buffer/*SsaExportFunc*/ export_funcs;
+    Buffer/*SsaFunc*/ funcs;
+
     SsaIntermediateIndex intermediate_counter;
     SsaStringIndex string_counter;
     SsaExternFuncIndex extern_func_counter;
     SsaExportFuncIndex export_func_counter;
+    SsaFuncIndex func_counter;
     SsaRegister reg_counter;
     SsaRegister param_counter;
-    SsaFuncIndex func_counter;
     SsaLabelIndex label_counter;
     Parser *parser; /* Borrowed */
 } Ssa;
@@ -102,14 +110,14 @@ typedef struct {
 
 typedef struct {
     u8 num_args;
-    SsaRegister result;
     FunctionDecl *func_decl;
+    u8 import_index;
 } SsaInsFuncCall;
 
 typedef struct {
     u8 num_args;
-    SsaRegister result;
-    SsaExternFuncIndex extern_func_index;
+    LhsExpr *func_decl_lhs;
+    int import_index;
 } SsaInsFuncCallExtern;
 
 typedef struct {
@@ -134,6 +142,8 @@ typedef struct {
     jmp_buf env;
     Ssa *ssa;
     amal_compiler *compiler;
+    /* 0 if the current scope belongs to the file, otherwise ParserFileScopeReference's import_index (the import file that contains the scope) */
+    u8 import_index;
 } SsaCompilerContext;
 
 /* longjump to context->env on failure */
diff --git a/include/std/buffer.h b/include/std/buffer.h
index d194881..3c2d79c 100644
--- a/include/std/buffer.h
+++ b/include/std/buffer.h
@@ -32,6 +32,8 @@ void* buffer_get(Buffer *self, usize index, usize type_size);
 CHECK_RESULT int buffer_pop(Buffer *self, void *data, usize size);
 /* Set buffer size to 0, doesn't change the capacity */
 void buffer_clear(Buffer *self);
+/* Also changes size if @new_capacity is less than buffer size */
+CHECK_RESULT int buffer_set_capacity(Buffer *self, usize new_capacity);
 void* buffer_begin(Buffer *self);
 void* buffer_end(Buffer *self);
 usize __buffer_get_size(Buffer *self, usize type_size);
diff --git a/include/std/buffer_view.h b/include/std/buffer_view.h
index 59a97d3..9c0a722 100644
--- a/include/std/buffer_view.h
+++ b/include/std/buffer_view.h
@@ -8,7 +8,7 @@ typedef struct {
     usize size;
 } BufferView;
 
-BufferView create_buffer_view_null();
+BufferView create_buffer_view_null(void);
 BufferView create_buffer_view(const char *data, usize size);
 bool buffer_view_equals(const BufferView *self, const BufferView *other);
 
diff --git a/include/std/hash_map.h b/include/std/hash_map.h
index c9e5b51..05755ce 100644
--- a/include/std/hash_map.h
+++ b/include/std/hash_map.h
@@ -35,6 +35,7 @@ CHECK_RESULT int hash_map_insert(HashMap *self, BufferView key, void *value);
     If @value is NULL, then the value is not copied and the functions works the same as @hash_map_contains
 */
 CHECK_RESULT bool hash_map_get(HashMap *self, BufferView key, void *value);
+CHECK_RESULT bool hash_map_get_ref(HashMap *self, BufferView key, void **value);
 CHECK_RESULT bool hash_map_contains(HashMap *self, BufferView key);
 
 int hash_map_compare_string(const void *a, const void *b);
diff --git a/include/std/log.h b/include/std/log.h
index cd376c6..12b52e1 100644
--- a/include/std/log.h
+++ b/include/std/log.h
@@ -3,7 +3,7 @@
 
 #include "defs.h"
 
-amal_mutex* amal_log_get_mutex();
+amal_mutex* amal_log_get_mutex(void);
 void amal_log_debug(const char *fmt, ...);
 void amal_log_error(const char *fmt, ...);
 void amal_log_info(const char *fmt, ...);
diff --git a/include/std/mem.h b/include/std/mem.h
index 2afce0d..1cc06bf 100644
--- a/include/std/mem.h
+++ b/include/std/mem.h
@@ -9,6 +9,6 @@ int am_memcmp(const void *lhs, const void *rhs, usize size);
 bool am_memeql(const void *lhs, const void *rhs, usize size);
 void am_memset(void *dest, int value, usize size);
 
-long am_pagesize();
+long am_pagesize(void);
 
 #endif
diff --git a/include/std/misc.h b/include/std/misc.h
index e89f1eb..a9bd5b6 100644
--- a/include/std/misc.h
+++ b/include/std/misc.h
@@ -21,8 +21,7 @@
 
 #define return_if_error(result) \
     do { \
-        int return_if_result; \
-        return_if_result = (result); \
+        int return_if_result = (result); \
         if(return_if_result != 0) { \
             return_if_debug_msg; \
             return return_if_result; \
@@ -31,6 +30,11 @@
 
 #define cleanup_if_error(result) do { if((result) != 0) { cleanup_if_debug_msg; goto cleanup; } } while(0)
 
+typedef struct {
+    int result;
+    void *data;
+} ResultMem;
+
 #if defined(__GNUC__) && __GNUC__ >= 4
 #define CHECK_RESULT __attribute__ ((warn_unused_result))
 #elif defined(_MSC_VER) && _MSC_VER >= 1700
diff --git a/include/std/thread.h b/include/std/thread.h
index 2765204..ae8fe39 100644
--- a/include/std/thread.h
+++ b/include/std/thread.h
@@ -43,9 +43,9 @@ CHECK_RESULT int amal_thread_deinit(amal_thread *self);
 CHECK_RESULT int amal_thread_detach(amal_thread *self);
 CHECK_RESULT int amal_thread_join(amal_thread *self, void **result);
 
-bool amal_thread_is_main();
+bool amal_thread_is_main(void);
 /* Returns 0 if the number of usable threads is unknown */
-int amal_get_usable_thread_count();
+int amal_get_usable_thread_count(void);
 
 CHECK_RESULT int amal_mutex_init(amal_mutex *self);
 void amal_mutex_deinit(amal_mutex *self);
diff --git a/src/ast.c b/src/ast.c
index 76cbf9c..912b9c7 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -296,9 +296,17 @@ int funccall_init(FunctionCall *self, BufferView name, ArenaAllocator *allocator
 }
 
 int structdecl_init(StructDecl *self, Scope *parent, ArenaAllocator *allocator) {
+    self->fields_num_pointers = 0;
+    self->fields_fixed_size_bytes = 0;
     return scope_init(&self->body, parent, allocator);
 }
 
+int structdecl_add_field(StructDecl *self, StructField *field, ArenaAllocator *allocator) {
+    Ast *body_obj;
+    return_if_error(ast_create(allocator, field, AST_STRUCT_FIELD, &body_obj));
+    return scope_add_child(&self->body, body_obj);
+}
+
 LhsExpr* structdecl_get_field_by_name(StructDecl *self, BufferView field_name) {
     Ast* result;
     if(!hash_map_get(&self->body.named_objects, field_name, &result))
@@ -431,17 +439,16 @@ void scope_resolve(Scope *self, AstCompilerContext *context) {
 }
 
 static void compiler_print_error(amal_compiler *compiler, const char *ref, const char *fmt, ...) {
-    Tokenizer *tokenizer = amal_compiler_find_tokenizer_by_code_reference(compiler, ref);
+    Tokenizer *tokenizer;
+    va_list args;
+    va_start(args, fmt);
+
+    tokenizer = amal_compiler_find_tokenizer_by_code_reference(compiler, ref);
     if(!tokenizer) {
         amal_log_error("Failed to find tokenizer for code reference %p. Is it an invalid reference?", ref ? ref : "(null)");
         return;
     }
-
-    va_list args;
-    va_start(args, fmt);
-    tokenizer_print_error_args(tokenizer,
-                               tokenizer_get_code_reference_index(tokenizer, ref),
-                               fmt, args);
+    tokenizer_print_error_args(tokenizer, tokenizer_get_code_reference_index(tokenizer, ref), fmt, args);
     va_end(args);
 }
 
@@ -672,19 +679,20 @@ static void import_resolve(Ast *ast, AstCompilerContext *context) {
     (void)context;
     self = ast->value.import;
     ast->resolve_data.type.type = RESOLVED_TYPE_LHS_EXPR;
-    ast->resolve_data.type.value.lhs_expr = &self->file_scope->parser->file_decl;
+    ast->resolve_data.type.value.lhs_expr = &self->file_scope->file_scope_ref->parser->file_decl;
 }
 
 static Scope* lhsexpr_get_scope(LhsExpr *self) {
-    AstValue value;
-    value = self->rhs_expr->value;
+    AstValue value = self->rhs_expr->value;
     switch(self->rhs_expr->type) {
         case AST_FUNCTION_DECL:
             return &value.func_decl->body;
         case AST_STRUCT_DECL:
             return &value.struct_decl->body;
         case AST_IMPORT:
-            return &value.import->file_scope->parser->struct_decl.body;
+            /* *import_index = 1 + value.import->file_scope->import_index;*/
+            assert(bool_false);
+            return &value.import->file_scope->file_scope_ref->parser->struct_decl.body;
         default:
             break;
     }
@@ -715,25 +723,11 @@ static void funcdecl_resolve(Ast *self, AstCompilerContext *context) {
     self->resolve_data.type.value.func_sig = self->value.func_decl->signature;
 }
 
-/*
-    Dont need to check if @self is resolved, since it will always be partially resolved when called from @funccall_resolve.
-    Meaning the resolve status wont be set to solved but the resolve type will be set.
-*/
-bool resolved_type_is_func_decl(Ast *self) {
-    LhsExpr *resolved_type;
-    if(self->resolve_data.type.type != RESOLVED_TYPE_LHS_EXPR)
-        return bool_false;
-    resolved_type = self->resolve_data.type.value.lhs_expr;
-    return (resolved_type->rhs_expr && resolved_type->rhs_expr->type == AST_FUNCTION_DECL) ||
-            resolved_type->type.type == VARIABLE_TYPE_SIGNATURE;
-}
-
 static void funccall_resolve(Ast *self, AstCompilerContext *context) {
-    FunctionCall *func_call;
     Ast **ast;
     Ast **ast_end;
 
-    func_call = self->value.func_call;
+    FunctionCall *func_call = self->value.func_call;
     variable_resolve(&func_call->func, context, &self->resolve_data.type);
     /* Attemping to use call syntax (variable_name ( ) ) with a variable that is not a function */
     if(self->resolve_data.type.type != RESOLVED_TYPE_FUNC_SIG) {
@@ -753,16 +747,46 @@ static void funccall_resolve(Ast *self, AstCompilerContext *context) {
     }
 }
 
+static TypeSize variable_type_get_byte_size(VariableType *self) {
+    TypeSize type_size;
+    type_size.num_pointers = 0;
+    type_size.fixed_size = 0;
+    switch(self->type) {
+        case VARIABLE_TYPE_NONE:
+            break;
+        case VARIABLE_TYPE_VARIABLE:
+            type_size = resolved_type_get_byte_size(&self->value.variable->resolved_var.resolve_data->type);
+            break;
+        case VARIABLE_TYPE_SIGNATURE:
+            type_size.num_pointers = 1;
+            break;
+    }
+    return type_size;
+}
+
 static void structdecl_resolve(Ast *self, AstCompilerContext *context) {
-    StructDecl *struct_decl;
-    struct_decl = self->value.struct_decl;
-    scope_resolve(&struct_decl->body, context);
+    StructDecl *struct_decl = self->value.struct_decl;
+    Scope *body = &struct_decl->body;
+    scope_resolve(body, context);
+
+    {
+        /*
+            Sum the size of all the fields into the struct, so the struct can know it's full size
+            without searching for it.
+            TODO: Exclude functions, but not function pointers.
+        */
+        Ast **ast = buffer_begin(&body->ast_objects);
+        Ast **ast_end = buffer_end(&body->ast_objects);
+        for(; ast != ast_end; ++ast) {
+            TypeSize type_size = variable_type_get_byte_size(&(*ast)->value.struct_field->type);
+            struct_decl->fields_num_pointers += type_size.num_pointers;
+            struct_decl->fields_fixed_size_bytes += type_size.fixed_size;
+        }
+    }
 }
 
 static void structfield_resolve(Ast *self, AstCompilerContext *context) {
-    /* TODO: Implement */
-    StructField *struct_field;
-    struct_field = self->value.struct_field;
+    StructField *struct_field = self->value.struct_field;
     variable_type_resolve(&struct_field->type, context, &self->resolve_data.type);
 }
 
@@ -806,12 +830,30 @@ static void binop_resolve_dot_access(Ast *ast, AstCompilerContext *context) {
         throw(AST_ERR);
     }
 
-    if(self->rhs->resolve_data.type.type != RESOLVED_TYPE_LHS_EXPR || !LHS_EXPR_IS_PUB(self->rhs->resolve_data.type.value.lhs_expr)) {
-        compiler_print_error(context->compiler, caller_code_ref.data, "Can't access non-public field \"%.*s\"", caller_code_ref.size, caller_code_ref.data);
-        /* TODO: use tokenizer_print_note, once it has been added */
-        /* TODO: Print type */
-        compiler_print_error(context->compiler, callee_code_ref.data, "Type was declared non-public here");
-        throw(AST_ERR);
+    {
+        bool invalid_dot_access = bool_true;
+        switch(self->rhs->resolve_data.type.type) {
+            case RESOLVED_TYPE_NONE:
+                assert(bool_false);
+                break;
+            case RESOLVED_TYPE_FUNC_SIG: {
+                FunctionSignature *func_sig = self->rhs->resolve_data.type.value.func_sig;
+                if(func_sig->func_decl && func_sig->func_decl->lhs_expr && LHS_EXPR_IS_PUB(func_sig->func_decl->lhs_expr))
+                    invalid_dot_access = bool_false;
+                break;
+            }
+            case RESOLVED_TYPE_LHS_EXPR:
+                invalid_dot_access = !LHS_EXPR_IS_PUB(self->rhs->resolve_data.type.value.lhs_expr);
+                break;
+        }
+
+        if(invalid_dot_access) {
+            compiler_print_error(context->compiler, caller_code_ref.data, "Can't access non-public field \"%.*s\"", caller_code_ref.size, caller_code_ref.data);
+            /* TODO: use tokenizer_print_note, once it has been added */
+            /* TODO: Print type */
+            compiler_print_error(context->compiler, callee_code_ref.data, "Type was declared non-public here");
+            throw(AST_ERR);
+        }
     }
 }
 
@@ -895,6 +937,37 @@ static void return_expr_resolve(ReturnExpr *self, AstCompilerContext *context) {
     ast_resolve(self->rhs_expr, context);
 }
 
+TypeSize resolved_type_get_byte_size(AstResolvedType *self) {
+    TypeSize type_size;
+    type_size.num_pointers = 0;
+    type_size.fixed_size = 0;
+    switch(self->type) {
+        case RESOLVED_TYPE_NONE:
+            break;
+        case RESOLVED_TYPE_LHS_EXPR: {
+            /* Resolved type until rhs is StructDecl or FunctionSignature */
+            LhsExpr *lhs_expr = self->value.lhs_expr;
+            if(lhs_expr->type.type != VARIABLE_TYPE_NONE)
+                type_size = variable_type_get_byte_size(&lhs_expr->type);
+            else {
+                assert(lhs_expr->rhs_expr);
+                if(lhs_expr->rhs_expr->type == AST_STRUCT_DECL) {
+                    StructDecl *struct_decl = lhs_expr->rhs_expr->value.struct_decl;
+                    type_size.num_pointers = struct_decl->fields_num_pointers;
+                    type_size.fixed_size = struct_decl->fields_fixed_size_bytes;
+                } else {
+                    type_size = resolved_type_get_byte_size(&lhs_expr->rhs_expr->resolve_data.type);
+                }
+            }
+            break;
+        }
+        case RESOLVED_TYPE_FUNC_SIG:
+            type_size.num_pointers = 1;
+            break;
+    }
+    return type_size;
+}
+
 void ast_resolve(Ast *self, AstCompilerContext *context) {
     assert(self);
     assert(context->parser);
diff --git a/src/bytecode/bytecode.c b/src/bytecode/bytecode.c
index 47d492c..0ee066c 100644
--- a/src/bytecode/bytecode.c
+++ b/src/bytecode/bytecode.c
@@ -20,11 +20,17 @@
     } while(0)
 
 int bytecode_init(Bytecode *self, ArenaAllocator *allocator) {
+    self->import_index = 0;
+    self->funcs_index = 0;
+    self->extern_funcs_index = 0;
+    self->offset = 0;
     return buffer_init(&self->data, allocator);
 }
 
 /*doc(Bytecode)
-The layout of the full bytecode is: Header (Intermediates Strings Functions External_Functions Exported_Functions Instructions)*
+The layout of the full bytecode is: Header (X Intermediates X Strings X Functions X External_Functions X Exported_Functions X Imports X Instructions)*\
+Where the X is a magic number to make it easier to find errors while decoding the bytecode.\
+The value of the magic number is @AMAL_BYTECODE_SECTION_MAGIC_NUMBER
 */
 
 CHECK_RESULT int buffer_append_header(Buffer *program_data) {
@@ -61,10 +67,10 @@ static CHECK_RESULT usize ssa_extract_data(u8 *instruction_data, void *result, u
 static void add_intermediates(BytecodeCompilerContext *self) {
     /*doc(Bytecode intermediates)
         # Intermediates layout
-        |Type        |Field             |Description                                                                    |
-        |------------|------------------|-------------------------------------------------------------------------------|
-        |u32         |Intermediates size|The size of the intermediates section, in bytes.                               |
-        |Intermediate|Intermediate data |Multiple intermediates, where the total size is defined by @Intermediates size.|
+        |Type          |Field             |Description                                                                    |
+        |--------------|------------------|-------------------------------------------------------------------------------|
+        |u32           |Intermediates size|The size of all intermediates, in bytes.                                       |
+        |Intermediate[]|Intermediate data |Multiple intermediates, where the total size is defined by @Intermediates size.|
 
         # Intermediate
         |Type|Field|Description                                         |
@@ -74,7 +80,7 @@ static void add_intermediates(BytecodeCompilerContext *self) {
     */
 
     Ssa *ssa = self->parser->ssa;
-    Buffer *instructions = &self->bytecode.data;
+    Buffer *instructions = &self->bytecode->data;
     SsaNumber *intermediate = buffer_begin(&ssa->intermediates);
     SsaNumber *intermediates_end = buffer_end(&ssa->intermediates);
     int i = 0;
@@ -93,11 +99,11 @@ static void add_intermediates(BytecodeCompilerContext *self) {
 static void add_strings(BytecodeCompilerContext *self) {
     /*doc(Bytecode strings)
         # Strings layout
-        |Type  |Field            |Description                                                       |
-        |------|-----------------|------------------------------------------------------------------|
-        |u16   |Number of strings|The number of strings.                                            |
-        |u32   |Strings size     |The size of the strings section, in bytes.                        |
-        |String|Strings data     |Multiple strings, where the total size is defined by @Strings size|
+        |Type    |Field            |Description                                                       |
+        |--------|-----------------|------------------------------------------------------------------|
+        |u16     |Number of strings|The number of strings.                                            |
+        |u32     |Strings size     |The size of all strings, in bytes.                                |
+        |String[]|Strings data     |Multiple strings, where the total size is defined by @Strings size|
 
         # String
         |Type|Field|Description                                                                            |
@@ -107,7 +113,7 @@ static void add_strings(BytecodeCompilerContext *self) {
     */
 
     Ssa *ssa = self->parser->ssa;
-    Buffer *instructions = &self->bytecode.data;
+    Buffer *instructions = &self->bytecode->data;
     BufferView *string = buffer_begin(&ssa->strings);
     BufferView *strings_end = buffer_end(&ssa->strings);
     u32 strings_size = 0;
@@ -128,36 +134,105 @@ static void add_strings(BytecodeCompilerContext *self) {
     }
 }
 
+static TypeSize function_signature_get_params_size(FunctionSignature *self) {
+    FunctionParameter *param = buffer_begin(&self->parameters);
+    FunctionParameter *param_end = buffer_end(&self->parameters);
+    TypeSize params_total_size;
+    params_total_size.num_pointers = 0;
+    params_total_size.fixed_size = 0;
+    for(; param != param_end; ++param) {
+        TypeSize param_size = resolved_type_get_byte_size(&param->resolve_data.type);
+        params_total_size.num_pointers += param_size.num_pointers;
+        params_total_size.fixed_size += param_size.fixed_size;
+    }
+    return params_total_size;
+}
+
+static TypeSize function_signature_get_return_types_size(FunctionSignature *self) {
+    FunctionReturnType *return_type = buffer_begin(&self->return_types);
+    FunctionReturnType *return_type_end = buffer_end(&self->return_types);
+    TypeSize return_types_total_size;
+    return_types_total_size.num_pointers = 0;
+    return_types_total_size.fixed_size = 0;
+    for(; return_type != return_type_end; ++return_type) {
+        TypeSize param_size = resolved_type_get_byte_size(&return_type->resolved_type);
+        return_types_total_size.num_pointers += param_size.num_pointers;
+        return_types_total_size.fixed_size += param_size.fixed_size;
+    }
+    return return_types_total_size;
+}
+
 static void add_functions(BytecodeCompilerContext *self) {
     /*doc(Bytecode functions)
-        # Internal functions layout
-        |Type|Field              |Description                      |
-        |----|-------------------|---------------------------------|
-        |u16 |Number of functions|The number of internal functions.|
+        # Functions layout
+        |Type      |Field     |Description                                                                           |
+        |----------|----------|--------------------------------------------------------------------------------------|
+        |u16       |num_funcs |The number of non-extern functions.                                                   |
+        |u32       |funcs_size|The size of all functions, in bytes.                                                  |
+        |Function[]|Functions |Multiple non-extern functions, where the number of functions is defined by @num_funcs.|
+
+        # Function
+        |Type|Field                    |Description                                                                                                             |
+        |----|-------------------------|------------------------------------------------------------------------------------------------------------------------|
+        |u32 |func_offset              |The offset in the program code (machine code) where the function starts. Is always 0 until the program has been started.|
+        |u8  |num_params               |The number of parameters.                                                                                               |
+        |u32 |params_num_pointers      |The number of pointers in the parameters.                                                                               |
+        |u32 |params_fixed_size        |The size of all non-pointer type parameters, in bytes.                                                                  |
+        |u8  |num_return_types         |The number of return values.                                                                                            |
+        |u32 |return_types_num_pointers|The number of pointers in the return types.                                                                             |
+        |u32 |return_types_fixed_size  |The size of all non-pointer type return types, in bytes.                                                                |
     */
 
-    assert(sizeof(SsaFuncIndex) == sizeof(u16) && "Program decoder needs to be updated since size of func index has changed");
-    throw_if_error(buffer_append(&self->bytecode.data, &self->parser->ssa->func_counter, sizeof(u16)));
+    Ssa *ssa = self->parser->ssa;
+    Buffer *instructions = &self->bytecode->data;
+    SsaFunc *func = buffer_begin(&ssa->funcs);
+    SsaFunc *func_end = buffer_end(&ssa->funcs);
+    u32 funcs_size = ssa->func_counter * sizeof(BytecodeHeaderFunction);
+    assert(sizeof(BytecodeHeaderFunction) == 22);
+
+    self->bytecode->funcs_index = instructions->size;
+    amal_log_debug("func index: %d", self->bytecode->funcs_index);
+    throw_if_error(buffer_expand(instructions, sizeof(u16) + sizeof(u32) + funcs_size));
+    throw_if_error(buffer_append(instructions, &ssa->func_counter, sizeof(u16)));
+    throw_if_error(buffer_append(instructions, &funcs_size, sizeof(u32)));
+    for(; func != func_end; ++func) {
+        BytecodeHeaderFunction header_func;
+        TypeSize params_total_size = function_signature_get_params_size(func->func_sig);
+        TypeSize return_types_total_size = function_signature_get_return_types_size(func->func_sig);
+
+        header_func.func_offset = 0;
+
+        header_func.num_params = buffer_get_size(&func->func_sig->parameters, FunctionParameter);
+        header_func.params_num_pointers = params_total_size.num_pointers;
+        header_func.params_fixed_size = params_total_size.fixed_size;
+
+        header_func.num_return_types = buffer_get_size(&func->func_sig->return_types, FunctionReturnType);
+        header_func.return_types_num_pointers = return_types_total_size.num_pointers;
+        header_func.return_types_fixed_size = return_types_total_size.fixed_size;
+        throw_if_error(buffer_append(instructions, &header_func, sizeof(header_func)));
+    }
+
+    assert(sizeof(ssa->func_counter) == sizeof(u16) && "Program decoder needs to be updated since size of func index has changed");
 }
 
 static void add_extern_functions(BytecodeCompilerContext *self) {
     /*doc(Bytecode external functions)
         # External functions layout
-        |Type             |Field             |Description                                                                              |
-        |-----------------|------------------|-----------------------------------------------------------------------------------------|
-        |u16              |num_extern_func   |The number of external functions.                                                        |
-        |u32              |extern_funcs_size |The size of the external functions section, in bytes.                                    |
-        |External function|External functions|Multiple external functions, where the number of functions is defined by @num_extern_func|
+        |Type               |Field             |Description                                                                              |
+        |-------------------|------------------|-----------------------------------------------------------------------------------------|
+        |u16                |num_extern_func   |The number of external functions.                                                        |
+        |u32                |extern_funcs_size |The size of all external functions, in bytes.                                            |
+        |External function[]|External functions|Multiple external functions, where the number of functions is defined by @num_extern_func|
 
         # External function
-        |Type|Field   |Description                                                                                          |
-        |----|--------|-----------------------------------------------------------------------------------------------------|
-        |u8  |num_args|The number of arguments the functions has.                                                           |
-        |u8  |name_len|The length of the external function name, in bytes. Excluding the null-terminate character.          |
-        |u8* |name    |The name of the external function, where the size is defined by @name_len. Names are null-terminated.|
+        |Type|Field     |Description                                                                                          |
+        |----|----------|-----------------------------------------------------------------------------------------------------|
+        |u8  |num_params|The number of parameters the functions has.                                                          |
+        |u8  |name_len  |The length of the external function name, in bytes. Excluding the null-terminate character.          |
+        |u8[]|name      |The name of the external function, where the size is defined by @name_len. Names are null-terminated.|
     */
     Ssa *ssa = self->parser->ssa;
-    Buffer *instructions = &self->bytecode.data;
+    Buffer *instructions = &self->bytecode->data;
     SsaExternFunc *extern_func = buffer_begin(&ssa->extern_funcs);
     SsaExternFunc *extern_func_end = buffer_end(&ssa->extern_funcs);
     u32 extern_funcs_size = 0;
@@ -167,14 +242,16 @@ static void add_extern_functions(BytecodeCompilerContext *self) {
     }
     extern_func = buffer_begin(&ssa->extern_funcs);
 
+    self->bytecode->extern_funcs_index = instructions->size;
     throw_if_error(buffer_expand(instructions, sizeof(u16) + sizeof(u32) + extern_funcs_size));
     throw_if_error(buffer_append(instructions, &ssa->extern_func_counter, sizeof(u16)));
     throw_if_error(buffer_append(instructions, &extern_funcs_size, sizeof(u32)));
     for(; extern_func != extern_func_end; ++extern_func) {
         const char null_s = '\0';
-        u8 num_args = buffer_get_size(&extern_func->func_sig->parameters, FunctionParameter);
-        throw_if_error(buffer_append(instructions, &num_args, sizeof(num_args)));
+        u8 num_params = buffer_get_size(&extern_func->func_sig->parameters, FunctionParameter);
+        throw_if_error(buffer_append(instructions, &num_params, sizeof(num_params)));
         /* TODO: Add namespace to the function name */
+        /* u8 is fine, because the max length of a variable is 255 */
         throw_if_error(buffer_append(instructions, &extern_func->name.size, sizeof(u8)));
         throw_if_error(buffer_append(instructions, extern_func->name.data, extern_func->name.size));
         throw_if_error(buffer_append(instructions, &null_s, sizeof(char)));
@@ -186,11 +263,11 @@ static void add_extern_functions(BytecodeCompilerContext *self) {
 static void add_export_functions(BytecodeCompilerContext *self) {
     /*doc(Bytecode exported functions)
         # Exported functions layout
-        |Type             |Field             |Description                                                                              |
-        |-----------------|------------------|-----------------------------------------------------------------------------------------|
-        |u16              |num_export_func   |The number of exported functions.                                                        |
-        |u32              |export_funcs_size |The size of the exported functions section, in bytes.                                    |
-        |Exported function|Exported functions|Multiple exported functions, where the number of functions is defined by @num_export_func|
+        |Type               |Field             |Description                                                                              |
+        |-------------------|------------------|-----------------------------------------------------------------------------------------|
+        |u16                |num_export_func   |The number of exported functions.                                                        |
+        |u32                |export_funcs_size |The size of all exported functions, in bytes.                                            |
+        |Exported function[]|Exported functions|Multiple exported functions, where the number of functions is defined by @num_export_func|
 
         # Exported function
         |Type|Field             |Description                                                                                                               |
@@ -198,10 +275,10 @@ static void add_export_functions(BytecodeCompilerContext *self) {
         |u32 |instruction_offset|The offset in the instruction data where the exported function is defined. Is always 0 until the program has been started.|
         |u8  |num_args          |The number of arguments the functions has.                                                                                |
         |u8  |name_len          |The length of the exported function name, in bytes. Excluding the null-terminate character.                               |
-        |u8* |name              |The name of the exported function, where the size is defined by @name_len. Names are null-terminated.                     |
+        |u8[]|name              |The name of the exported function, where the size is defined by @name_len. Names are null-terminated.                     |
     */
     Ssa *ssa = self->parser->ssa;
-    Buffer *instructions = &self->bytecode.data;
+    Buffer *instructions = &self->bytecode->data;
     SsaExportFunc *export_func = buffer_begin(&ssa->export_funcs);
     SsaExportFunc *export_func_end = buffer_end(&ssa->export_funcs);
     u32 export_funcs_size = 0;
@@ -228,8 +305,51 @@ static void add_export_functions(BytecodeCompilerContext *self) {
     assert(sizeof(SsaExportFuncIndex) == sizeof(u16) && "Program decoder needs to be updated since size of export func index has changed");
 }
 
+static void add_imports(BytecodeCompilerContext *self) {
+    /*doc(Bytecode imports)
+        # Imports layout
+        |Type    |Field       |Description                                                              |
+        |--------|------------|-------------------------------------------------------------------------|
+        |u8      |num_imports |The number of imports.                                                   |
+        |u32     |imports_size|The size of all imports, in bytes.                                       |
+        |Import[]|Import      |Multiple imports, where the number of imports is defined by @num_imports.|
+
+        # Import
+        |Type|Field                |Description                                                                             |
+        |----|---------------------|----------------------------------------------------------------------------------------|
+        |u32 |function_index       |The index in the bytecode where function header begins for the imported file.           |
+        |u32 |extern_function_index|The index in the bytecode where the extern function header begins for the imported file.|
+    */
+    Parser *parser = self->parser;
+    Buffer *instructions = &self->bytecode->data;
+    ParserFileScopeReference **import = buffer_begin(&parser->imports);
+    ParserFileScopeReference **import_end = buffer_end(&parser->imports);
+    u8 num_imports = 1 + (import_end - import);
+    u32 imports_size = num_imports * sizeof(BytecodeHeaderImport);
+    assert(sizeof(BytecodeHeaderImport) == 8);
+
+    self->bytecode->import_index = instructions->size;
+    throw_if_error(buffer_expand(instructions, sizeof(u8) + sizeof(u32) + imports_size));
+    throw_if_error(buffer_append(instructions, &num_imports, sizeof(num_imports)));
+    throw_if_error(buffer_append(instructions, &imports_size, sizeof(imports_size)));
+
+    /* The first import is always a reference to itself */
+    throw_if_error(buffer_append(instructions, &self->bytecode->funcs_index, sizeof(self->bytecode->funcs_index)));
+    throw_if_error(buffer_append(instructions, &self->bytecode->extern_funcs_index, sizeof(self->bytecode->extern_funcs_index)));
+    for(; import != import_end; ++import) {
+        /*
+            We don't know the index to the functions yet, so first fill them with the parser index that owns them
+            and after bytecode has been generated for each parser (file), modify these function indices
+            to point to the parsers function index in the bytecode.
+        */
+        u32 parser_index = (*import)->file_scope_ref->parser->index;
+        throw_if_error(buffer_append(instructions, &parser_index, sizeof(parser_index)));
+        throw_if_error(buffer_append(instructions, &parser_index, sizeof(parser_index)));
+    }
+}
+
 static void add_ins1(BytecodeCompilerContext *self, AmalOpcode opcode, const char *fmt) {
-    throw_if_error(buffer_append(&self->bytecode.data, &opcode, sizeof(AmalOpcodeType)));
+    throw_if_error(buffer_append(&self->bytecode->data, &opcode, sizeof(AmalOpcodeType)));
     if(fmt) {
         fprintf(stderr, fmt);
         fputc('\n', stderr);
@@ -237,7 +357,7 @@ static void add_ins1(BytecodeCompilerContext *self, AmalOpcode opcode, const cha
 }
 
 static void add_ins2(BytecodeCompilerContext *self, AmalOpcode opcode, i8 reg, const char *fmt) {
-    Buffer *instructions = &self->bytecode.data;
+    Buffer *instructions = &self->bytecode->data;
     size_t index = instructions->size;
     
     throw_if_error(buffer_append_empty(instructions, sizeof(AmalOpcodeType) + sizeof(reg)));
@@ -248,7 +368,7 @@ static void add_ins2(BytecodeCompilerContext *self, AmalOpcode opcode, i8 reg, c
 }
 
 static void add_ins3(BytecodeCompilerContext *self, AmalOpcode opcode, i8 dst_reg, i8 src_reg, const char *fmt) {
-    Buffer *instructions = &self->bytecode.data;
+    Buffer *instructions = &self->bytecode->data;
     size_t index = instructions->size;
     
     throw_if_error(buffer_append_empty(instructions, sizeof(AmalOpcodeType) + sizeof(dst_reg) + sizeof(src_reg)));
@@ -260,7 +380,7 @@ static void add_ins3(BytecodeCompilerContext *self, AmalOpcode opcode, i8 dst_re
 }
 
 static void add_ins4(BytecodeCompilerContext *self, AmalOpcode opcode, u16 data, const char *fmt) {
-    Buffer *instructions = &self->bytecode.data;
+    Buffer *instructions = &self->bytecode->data;
     size_t index = instructions->size;
     
     throw_if_error(buffer_append_empty(instructions, sizeof(AmalOpcodeType) + sizeof(data)));
@@ -271,7 +391,7 @@ static void add_ins4(BytecodeCompilerContext *self, AmalOpcode opcode, u16 data,
 }
 
 static void add_ins5(BytecodeCompilerContext *self, AmalOpcode opcode, i8 dst_reg, i8 reg1, i8 reg2, const char *fmt) {
-    Buffer *instructions = &self->bytecode.data;
+    Buffer *instructions = &self->bytecode->data;
     size_t index = instructions->size;
     
     throw_if_error(buffer_append_empty(instructions, sizeof(AmalOpcodeType) + sizeof(dst_reg) + sizeof(reg1) + sizeof(reg2)));
@@ -284,7 +404,7 @@ static void add_ins5(BytecodeCompilerContext *self, AmalOpcode opcode, i8 dst_re
 }
 
 static void add_ins6(BytecodeCompilerContext *self, AmalOpcode opcode, i8 dst_reg, u16 data, const char *fmt) {
-    Buffer *instructions = &self->bytecode.data;
+    Buffer *instructions = &self->bytecode->data;
     size_t index = instructions->size;
     
     throw_if_error(buffer_append_empty(instructions, sizeof(AmalOpcodeType) + sizeof(dst_reg) + sizeof(data)));
@@ -295,16 +415,16 @@ static void add_ins6(BytecodeCompilerContext *self, AmalOpcode opcode, i8 dst_re
     fputc('\n', stderr);
 }
 
-static void add_ins7(BytecodeCompilerContext *self, AmalOpcode opcode, u16 idx, i8 num_args, i8 dst_reg, const char *fmt) {
-    Buffer *instructions = &self->bytecode.data;
+static void add_ins7(BytecodeCompilerContext *self, AmalOpcode opcode, u8 import_index, u16 func_index, i8 num_args, const char *fmt) {
+    Buffer *instructions = &self->bytecode->data;
     size_t index = instructions->size;
     
-    throw_if_error(buffer_append_empty(instructions, sizeof(AmalOpcodeType) + sizeof(idx) + sizeof(num_args) + sizeof(dst_reg)));
+    throw_if_error(buffer_append_empty(instructions, sizeof(AmalOpcodeType) + sizeof(import_index) + sizeof(func_index) + sizeof(num_args)));
     instructions->data[index] = opcode;
-    memcpy(instructions->data + index + sizeof(AmalOpcodeType), &idx, sizeof(idx));
-    instructions->data[index + sizeof(AmalOpcodeType) + sizeof(idx)] = num_args;
-    instructions->data[index + sizeof(AmalOpcodeType) + sizeof(idx) + sizeof(num_args)] = dst_reg;
-    fprintf(stderr, fmt, idx, num_args, dst_reg);
+    memcpy(instructions->data + index + sizeof(AmalOpcodeType), &import_index, sizeof(import_index));
+    memcpy(instructions->data + index + sizeof(AmalOpcodeType) + sizeof(import_index), &func_index, sizeof(func_index));
+    memcpy(instructions->data + index + sizeof(AmalOpcodeType) + sizeof(import_index) + sizeof(func_index), &num_args, sizeof(num_args));
+    fprintf(stderr, fmt, import_index, func_index, num_args);
     fputc('\n', stderr);
 }
 
@@ -330,8 +450,8 @@ static void add_instructions(BytecodeCompilerContext *self) {
     u8 *instructions_end = buffer_end(&ssa->instructions);
     u16 label_counter = 0;
 
-    u32 num_instructions_index = self->bytecode.data.size;
-    throw_if_error(buffer_append_empty(&self->bytecode.data, sizeof(num_instructions_index)));
+    u32 num_instructions_index = self->bytecode->data.size;
+    throw_if_error(buffer_append_empty(&self->bytecode->data, sizeof(num_instructions_index)));
 
     /* TODO: Keep all registers under 256 */
     while(instruction != instructions_end) {
@@ -404,22 +524,21 @@ static void add_instructions(BytecodeCompilerContext *self) {
                 add_ins2(self, AMAL_OP_PUSH, reg, "push r%d");
                 break;
             }
+            case SSA_PUSH_RET: {
+                SsaRegister reg;
+                am_memcpy(&reg, instruction, sizeof(SsaRegister));
+                instruction += sizeof(SsaRegister);
+                add_ins2(self, AMAL_OP_PUSH_RET, reg, "push_ret r%d");
+                break;
+            }
             case SSA_CALL: {
-                /* 
-                    TODO: Using ssa_func_index only works correctly if the function was defined in the same
-                    file as the function call. To make this work with calling functions in other files,
-                    ssa_func_index should also have an offset index or something like that.
-                    So each file has it's own function list with indices and when they need to be combined in the end,
-                    the function indices can be increased by their block index (ssa_func_index + block index), where block index
-                    is defined as the size of all previous files' number of functions.
-                */
                 instruction += ssa_extract_data(instruction, &ssa_ins_func_call, sizeof(ssa_ins_func_call));
-                add_ins7(self, AMAL_OP_CALL, ssa_ins_func_call.func_decl->ssa_func_index, ssa_ins_func_call.num_args, ssa_ins_func_call.result, "call f%d, %d, r%d");
+                add_ins7(self, AMAL_OP_CALL, ssa_ins_func_call.import_index, ssa_ins_func_call.func_decl->ssa_func_index, ssa_ins_func_call.num_args, "call f(%d,%d), %d");
                 break;
             }
             case SSA_CALL_EXTERN: {
                 instruction += ssa_extract_data(instruction, &ssa_ins_func_call_extern, sizeof(ssa_ins_func_call_extern));
-                add_ins7(self, AMAL_OP_CALLE, ssa_ins_func_call_extern.extern_func_index, ssa_ins_func_call_extern.num_args, ssa_ins_func_call_extern.result, "calle ef%d, %d, r%d");
+                add_ins7(self, AMAL_OP_CALLE, ssa_ins_func_call_extern.import_index, ssa_ins_func_call_extern.func_decl_lhs->extern_index, ssa_ins_func_call_extern.num_args, "calle ef(%d,%d), %d");
                 break;
             }
             case SSA_JUMP_ZERO: {
@@ -450,16 +569,35 @@ static void add_instructions(BytecodeCompilerContext *self) {
     /* Prepend instructions with its size */
     {
         /* -sizeof to Remove the count itself from the size of the instructions size */
-        const u32 instructions_size = self->bytecode.data.size - num_instructions_index - sizeof(instructions_size);
-        am_memcpy(self->bytecode.data.data + num_instructions_index, &instructions_size, sizeof(instructions_size));
+        const u32 instructions_size = self->bytecode->data.size - num_instructions_index - sizeof(instructions_size);
+        am_memcpy(self->bytecode->data.data + num_instructions_index, &instructions_size, sizeof(instructions_size));
     }
 }
 
+static void add_section_magic_number(BytecodeCompilerContext *self) {
+    const u32 section_magic_number = AMAL_BYTECODE_SECTION_MAGIC_NUMBER;
+    throw_if_error(buffer_append(&self->bytecode->data, &section_magic_number, sizeof(section_magic_number)));
+}
+
 void generate_bytecode_from_ssa(BytecodeCompilerContext *self) {
+    add_section_magic_number(self);
     add_intermediates(self);
+
+    add_section_magic_number(self);
     add_strings(self);
+
+    add_section_magic_number(self);
     add_functions(self);
+
+    add_section_magic_number(self);
     add_extern_functions(self);
+
+    add_section_magic_number(self);
     add_export_functions(self);
+
+    add_section_magic_number(self);
+    add_imports(self);
+
+    add_section_magic_number(self);
     add_instructions(self);
 }
diff --git a/src/compiler.c b/src/compiler.c
index dbc1498..8dda1c6 100644
--- a/src/compiler.c
+++ b/src/compiler.c
@@ -25,13 +25,15 @@ static usize strnlen(const char *str, usize max_length) {
 }
 
 /* TODO: Allow to specify size and members? */
-static CHECK_RESULT int create_default_type(amal_compiler *compiler, const char *name, amal_default_type **default_type) {
+static CHECK_RESULT int create_default_type(amal_compiler *compiler, const char *name, u32 num_pointers, u32 fixed_size, amal_default_type **default_type) {
     StructDecl *struct_decl;
     Ast *expr;
     LhsExpr *lhs_expr;
 
     return_if_error(arena_allocator_alloc(&compiler->allocator, sizeof(StructDecl), (void**)&struct_decl));
     return_if_error(structdecl_init(struct_decl, &compiler->root_scope, &compiler->allocator));
+    struct_decl->fields_num_pointers = num_pointers;
+    struct_decl->fields_fixed_size_bytes = fixed_size;
 
     return_if_error(arena_allocator_alloc(&compiler->allocator, sizeof(amal_default_type), (void**)default_type));
     lhs_expr = &(*default_type)->lhs_expr;
@@ -45,20 +47,29 @@ static CHECK_RESULT int create_default_type(amal_compiler *compiler, const char
     return scope_add_child(&compiler->root_scope, expr);
 }
 
+static CHECK_RESULT int create_default_type_num_pointers(amal_compiler *compiler, const char *name, u32 num_pointers, amal_default_type **default_type) {
+    return create_default_type(compiler, name, num_pointers, 0, default_type);
+}
+
+static CHECK_RESULT int create_default_type_fixed_size(amal_compiler *compiler, const char *name, u32 byte_size, amal_default_type **default_type) {
+    return create_default_type(compiler, name, 0, byte_size, default_type);
+}
+
 static CHECK_RESULT int init_default_types(amal_compiler *compiler) {
-    return_if_error(create_default_type(compiler, "i8", &compiler->default_types.i8));
-    return_if_error(create_default_type(compiler, "i16", &compiler->default_types.i16));
-    return_if_error(create_default_type(compiler, "i32", &compiler->default_types.i32));
-    return_if_error(create_default_type(compiler, "i64", &compiler->default_types.i64));
-    return_if_error(create_default_type(compiler, "u8", &compiler->default_types.u8));
-    return_if_error(create_default_type(compiler, "u16", &compiler->default_types.u16));
-    return_if_error(create_default_type(compiler, "u32", &compiler->default_types.u32));
-    return_if_error(create_default_type(compiler, "u64", &compiler->default_types.u64));
-    return_if_error(create_default_type(compiler, "isize", &compiler->default_types.isize));
-    return_if_error(create_default_type(compiler, "usize", &compiler->default_types.usize));
-    return_if_error(create_default_type(compiler, "f32", &compiler->default_types.f32));
-    return_if_error(create_default_type(compiler, "f64", &compiler->default_types.f64));
-    return_if_error(create_default_type(compiler, "str", &compiler->default_types.str));
+    return_if_error(create_default_type_fixed_size(compiler, "i8", 1, &compiler->default_types.i8));
+    return_if_error(create_default_type_fixed_size(compiler, "i16", 2, &compiler->default_types.i16));
+    return_if_error(create_default_type_fixed_size(compiler, "i32", 3, &compiler->default_types.i32));
+    return_if_error(create_default_type_fixed_size(compiler, "i64", 4, &compiler->default_types.i64));
+    return_if_error(create_default_type_fixed_size(compiler, "u8", 1, &compiler->default_types.u8));
+    return_if_error(create_default_type_fixed_size(compiler, "u16", 2, &compiler->default_types.u16));
+    return_if_error(create_default_type_fixed_size(compiler, "u32", 3, &compiler->default_types.u32));
+    return_if_error(create_default_type_fixed_size(compiler, "u64", 4, &compiler->default_types.u64));
+    return_if_error(create_default_type_num_pointers(compiler, "isize", 1, &compiler->default_types.isize));
+    return_if_error(create_default_type_num_pointers(compiler, "usize", 1, &compiler->default_types.usize));
+    return_if_error(create_default_type_fixed_size(compiler, "f32", 4, &compiler->default_types.f32));
+    return_if_error(create_default_type_fixed_size(compiler, "f64", 8, &compiler->default_types.f64));
+    /* TODO: str should be a struct with the fields @data (ptr) and @size (usize) */
+    return_if_error(create_default_type_num_pointers(compiler, "str", 1, &compiler->default_types.str));
 
     compiler->default_types.arithmetic_types[0] = compiler->default_types.i8;
     compiler->default_types.arithmetic_types[1] = compiler->default_types.u8;
@@ -185,6 +196,7 @@ static CHECK_RESULT int amal_compiler_load_in_this_thread(amal_compiler *compile
     file_scope->parser = parser;
     return_if_error(parser_parse_file(parser, filepath));
     cleanup_if_error(amal_mutex_lock(&compiler->mutex, "amal_compiler_load_in_this_thread, add parser"));
+    parser->index = buffer_get_size(&compiler->parsers, Parser*);
     cleanup_if_error(buffer_append(&compiler->parsers, &parser, sizeof(parser)));
     amal_log_info("Finished parsing %.*s", filepath.size, filepath.data);
     result = AMAL_COMPILER_OK;
@@ -224,6 +236,7 @@ static CHECK_RESULT int thread_generate_ssa(Parser *parser) {
     return_if_error(arena_allocator_alloc(parser->allocator, sizeof(Ssa), (void**)&compiler_context.ssa));
     return_if_error(ssa_init(compiler_context.ssa, parser));
     compiler_context.compiler = parser->compiler;
+    compiler_context.import_index = 0;
     parser->ssa = compiler_context.ssa;
     amal_log_debug("Generating SSA for file: %.*s", parser->tokenizer.code_name.size, parser->tokenizer.code_name.data);
     result = setjmp(compiler_context.env);
@@ -238,7 +251,8 @@ static CHECK_RESULT int thread_generate_bytecode(Parser *parser) {
     BytecodeCompilerContext compiler_context;
     int result;
 
-    return_if_error(bytecode_init(&compiler_context.bytecode, parser->allocator));
+    return_if_error(arena_allocator_alloc(parser->allocator, sizeof(Bytecode), (void**)&compiler_context.bytecode));
+    return_if_error(bytecode_init(compiler_context.bytecode, parser->allocator));
     compiler_context.parser = parser;
     amal_log_debug("Generating bytecode for file: %.*s", parser->tokenizer.code_name.size, parser->tokenizer.code_name.data);
     result = setjmp(compiler_context.env);
@@ -320,14 +334,11 @@ static CHECK_RESULT int amal_compiler_dispatch_generic(amal_compiler *self, Thre
 }
 
 static CHECK_RESULT int amal_compiler_generate_program(amal_compiler *self) {
-    /*
-        TODO: Copying the bytecode to the program can be done using multiple threads.
-        Use self->threads for that.
-    */
+    /* TODO: Copying the bytecode to the program can be done using multiple threads */
     Parser **parser = buffer_begin(&self->parsers);
     Parser **parser_end = buffer_end(&self->parsers);
     for(; parser != parser_end; ++parser) {
-        return_if_error(amal_program_append_bytecode(self->program, &(*parser)->bytecode));
+        return_if_error(amal_program_append_bytecode(self->program, (*parser)->bytecode));
     }
     return 0;
 }
@@ -419,6 +430,47 @@ static CHECK_RESULT int validate_main_func(FileScopeReference *main_file_scope,
     return 0;
 }
 
+static void amal_compiler_parsers_set_bytecode_offsets(amal_compiler *self) {
+    /* magic number + major version + minor version + patch version */
+    u32 offset = sizeof(u32) + sizeof(u8) + sizeof(u8) + sizeof(u8);
+    Parser **parser = buffer_begin(&self->parsers);
+    Parser **parser_end = buffer_end(&self->parsers);
+    for(; parser != parser_end; ++parser) {
+        (*parser)->bytecode->offset = offset;
+        offset += (*parser)->bytecode->data.size;
+    }
+}
+
+/* TODO: Parallelize this? */
+static void amal_compiler_update_import_references(amal_compiler *self) {
+    Parser **parser_start = buffer_begin(&self->parsers);
+    Parser **parser = parser_start;
+    Parser **parser_end = buffer_end(&self->parsers);
+    amal_compiler_parsers_set_bytecode_offsets(self);
+
+    for(; parser != parser_end; ++parser) {
+        u8 *import_start = (u8*)(*parser)->bytecode->data.data + (*parser)->bytecode->import_index;
+        u8 num_imports = *import_start;
+        /* TODO: Remove these kinds of offset with sizeof. They are prone to hard-to-find bugs after code change */
+        BytecodeHeaderImport *header_import = (BytecodeHeaderImport*)(import_start + sizeof(u8) + sizeof(u32));
+        BytecodeHeaderImport *header_import_end = header_import + num_imports;
+
+        /*
+            The first import is the file itself and it already has function index,
+            but the index is localized to the function itself, so we need to add the offset
+            to the file itself as well.
+        */
+        header_import->function_index += (*parser)->bytecode->offset;
+        header_import->extern_function_index += (*parser)->bytecode->offset;
+        ++header_import;
+        for(; header_import != header_import_end; ++header_import) {
+            Parser *imported_parser = *(parser_start + header_import->parser_index);
+            header_import->function_index = imported_parser->bytecode->offset + imported_parser->bytecode->funcs_index;
+            header_import->extern_function_index = imported_parser->bytecode->offset + imported_parser->bytecode->extern_funcs_index;
+        }
+    }
+}
+
 int amal_compiler_internal_load_file(amal_compiler *self, const char *filepath, FileScopeReference **file_scope) {
     ThreadWorkData thread_work_data;
     bool main_job;
@@ -472,6 +524,7 @@ int amal_compiler_internal_load_file(amal_compiler *self, const char *filepath,
         amal_log_info("Finished generating SSA");
         
         return_if_error(amal_compiler_dispatch_generic(self, THREAD_WORK_GENERATE_BYTECODE));
+        amal_compiler_update_import_references(self);
         amal_log_info("Finished generating bytecode");
 
         return_if_error(amal_compiler_generate_program(self));
diff --git a/src/parser.c b/src/parser.c
index df326f0..01c1d9f 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -6,6 +6,7 @@
 #include "../include/std/mem.h"
 #include "../include/std/log.h"
 #include "../include/std/alloc.h"
+#include "../include/std/hash.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -21,14 +22,16 @@ do { \
 } while(0)
 
 #define VAR_MAX_LEN UINT8_MAX
+#define FUNC_MAX_PARAMS 128
+#define FUNC_MAX_RETURN_TYPES 128
 
 static CHECK_RESULT Ast* parser_parse_rhs(Parser *self);
 static CHECK_RESULT Ast* parser_parse_body(Parser *self);
-static CHECK_RESULT Ast* parser_parse_struct_body(Parser *self);
+static CHECK_RESULT StructField* parser_parse_struct_body(Parser *self);
 static CHECK_RESULT Ast* parser_parse_rhs_binop(Parser *self);
 static void parser_parse_var_type(Parser *self, VariableType *result);
 static void parser_parse_var_type_def(Parser *self, VariableType *result);
-static void parser_queue_file(Parser *self, BufferView path, FileScopeReference **file_scope);
+static void parser_queue_file(Parser *self, BufferView path, ParserFileScopeReference **parser_file_scope);
 
 int parser_init(Parser *self, amal_compiler *compiler, ArenaAllocator *allocator) {
     self->allocator = allocator;
@@ -38,12 +41,15 @@ int parser_init(Parser *self, amal_compiler *compiler, ArenaAllocator *allocator
     self->error.index = 0;
     self->error.str = NULL;
     self->error_context = ERROR_CONTEXT_NONE;
+    self->index = 0;
     return_if_error(structdecl_init(&self->struct_decl, &compiler->root_scope, allocator));
     lhsexpr_init(&self->file_decl, DECL_FLAG_EXTERN | DECL_FLAG_PUB | DECL_FLAG_CONST, create_buffer_view_null());
     return_if_error(ast_create(self->allocator, &self->struct_decl, AST_STRUCT_DECL, &self->file_decl.rhs_expr));
+    return_if_error(buffer_init(&self->imports, allocator));
+    return_if_error(hash_map_init(&self->imports_by_name, allocator, sizeof(usize), hash_map_compare_string, amal_hash_string));
     self->current_scope = &self->struct_decl.body;
     self->has_func_parent = bool_false;
-    am_memset(&self->bytecode, 0, sizeof(self->bytecode));
+    self->bytecode = NULL;
     return PARSER_OK;
 }
 
@@ -85,27 +91,24 @@ static void parser_parse_body_loop(Parser *self, Scope *scope, Token end_token)
 /*
 STRUCT_BODY_LOOP = '{' STRUCT_BODY* '}'
 */
-static void parser_parse_struct_body_loop(Parser *self, Scope *scope) {
+static void parser_parse_struct_body_loop(Parser *self, StructDecl *struct_decl) {
     int result;
     throw_if_error(tokenizer_accept(&self->tokenizer, TOK_OPEN_BRACE));
     for(;;) {
-        Ast *body_obj;
+        StructField *struct_field;
         bool is_end_token;
         throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_CLOSING_BRACE, &is_end_token));
         if(is_end_token)
             break;
         
-        body_obj = parser_parse_struct_body(self);
-        result = scope_add_child(scope, body_obj);
+        struct_field = parser_parse_struct_body(self);
+        result = structdecl_add_field(struct_decl, struct_field, self->allocator);
         if(result == 0) {
             continue;
         } else if(result == AST_ERR_DEF_DUP) {
-            /* TODO: Convert ast type to string for error message */
-            BufferView obj_name;
-            obj_name = ast_get_name(body_obj);
-            self->error = tokenizer_create_error(&self->tokenizer, 
-                                                tokenizer_get_code_reference_index(&self->tokenizer, obj_name.data),
-                                                "Variable with the name %.*s was declared twice in the struct", obj_name.size, obj_name.data);
+            self->error = tokenizer_create_error(&self->tokenizer,
+                                                tokenizer_get_code_reference_index(&self->tokenizer, struct_field->name.data),
+                                                "Variable with the name %.*s was declared twice in the struct", struct_field->name.size, struct_field->name.data);
             self->error_context = ERROR_CONTEXT_NONE;
             throw(result);
         } else {
@@ -183,18 +186,32 @@ static void parser_parse_function_return_types(Parser *self, FunctionSignature *
         if(var_type.type == VARIABLE_TYPE_NONE) {
             /* If function has no return types */
             if(return_type_index == 0)
-                return;
+                break;
             self->error = tokenizer_create_error(&self->tokenizer,
-                                                tokenizer_get_error_index(&self->tokenizer),
-                                                "Expected type or closure signature");
+                                                 tokenizer_get_error_index(&self->tokenizer),
+                                                 "Expected type or closure signature");
             throw(PARSER_UNEXPECTED_TOKEN);
         }
         throw_if_error(function_signature_add_return_type(func_sig, &var_type));
         throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_COMMA, &match));
         if(!match)
-            return;
+            break;
         ++return_type_index;
     }
+
+    if (buffer_get_size(&func_sig->parameters, FunctionParameter) > FUNC_MAX_PARAMS) {
+        self->error = tokenizer_create_error(&self->tokenizer,
+                                             tokenizer_get_error_index(&self->tokenizer),
+                                             "A closure can't have more than %d parameters", FUNC_MAX_PARAMS);
+        throw(PARSER_ERR);
+    }
+
+    if (buffer_get_size(&func_sig->return_types, FunctionReturnType) > FUNC_MAX_RETURN_TYPES) {
+        self->error = tokenizer_create_error(&self->tokenizer,
+                                             tokenizer_get_error_index(&self->tokenizer),
+                                             "A closure can't have more than %d return values", FUNC_MAX_RETURN_TYPES);
+        throw(PARSER_ERR);
+    }
 }
 
 /*
@@ -399,7 +416,7 @@ static CHECK_RESULT StructDecl* parser_parse_struct_decl(Parser *self) {
     throw_if_error(structdecl_init(result, self->current_scope, self->allocator));
 
     self->current_scope = &result->body;
-    parser_parse_struct_body_loop(self, self->current_scope);
+    parser_parse_struct_body_loop(self, result);
     self->current_scope = result->body.parent;
     return result;
 }
@@ -896,8 +913,7 @@ Ast* parser_parse_body(Parser *self) {
 /*
 STRUCT_BODY = TOK_IDENTIFIER VAR_TYPE_DEF ';'
 */
-Ast* parser_parse_struct_body(Parser *self) {
-    Ast *result;
+StructField* parser_parse_struct_body(Parser *self) {
     BufferView var_name;
     VariableType var_type;
     StructField *struct_field;
@@ -912,10 +928,9 @@ Ast* parser_parse_struct_body(Parser *self) {
         throw(PARSER_UNEXPECTED_TOKEN);
     }
     throw_if_error(tokenizer_accept(&self->tokenizer, TOK_SEMICOLON));
-    throw_if_error(arena_allocator_alloc(self->allocator, sizeof(LhsExpr), (void**)&struct_field));
+    throw_if_error(arena_allocator_alloc(self->allocator, sizeof(StructField), (void**)&struct_field));
     structfield_init(struct_field, var_name, &var_type);
-    throw_if_error(ast_create(self->allocator, struct_field, AST_STRUCT_FIELD, &result));
-    return result;
+    return struct_field;
 }
 
 /*
@@ -974,8 +989,9 @@ static CHECK_RESULT int file_path_join(BufferView directory, BufferView file, ch
 Path can be path to included library path (or system library path) in which case
 the path separator is a dot, otherwise the path separator is forward slash '/'
 */
-void parser_queue_file(Parser *self, BufferView path, FileScopeReference **file_scope) {
+void parser_queue_file(Parser *self, BufferView path, ParserFileScopeReference **parser_file_scope) {
     /* TODO: Parse special path (to include library path with dots) */
+    FileScopeReference *file_scope;
     BufferView file_directory;
     char *path_relative;
     int result;
@@ -983,7 +999,7 @@ void parser_queue_file(Parser *self, BufferView path, FileScopeReference **file_
     file_directory = file_get_parent_directory(self->tokenizer.code_name);
     throw_if_error(file_path_join(file_directory, path, &path_relative));
     /* We want buffer to be null-terminated but null character should not be included for the size */
-    result = amal_compiler_internal_load_file(self->compiler, path_relative, file_scope);
+    result = amal_compiler_internal_load_file(self->compiler, path_relative, &file_scope);
     if(result != 0) {
         self->error = tokenizer_create_error(&self->tokenizer, 
                                              tokenizer_get_code_reference_index(&self->tokenizer, path.data),
@@ -992,4 +1008,29 @@ void parser_queue_file(Parser *self, BufferView path, FileScopeReference **file_
         throw(result);
     }
     am_free(path_relative);
+
+    {
+        usize parser_file_scope_index;
+        int num_imports;
+        BufferView import_path_canonical = create_buffer_view(file_scope->canonical_path.data, file_scope->canonical_path.size);
+
+        if(hash_map_get(&self->imports_by_name, import_path_canonical, &parser_file_scope_index)) {
+            *parser_file_scope = buffer_get(&self->imports, parser_file_scope_index, sizeof(ParserFileScopeReference*));
+            return;
+        }
+
+        num_imports = buffer_get_size(&self->imports, ParserFileScopeReference*);
+        if(num_imports == 254) {
+            self->error = tokenizer_create_error(&self->tokenizer, 
+                                                 tokenizer_get_error_index(&self->tokenizer),
+                                                 "One file can't have more than 255 imports");
+            throw(PARSER_ERR);
+        }
+
+        throw_if_error(arena_allocator_alloc(self->allocator, sizeof(ParserFileScopeReference*), (void**)parser_file_scope));
+        (*parser_file_scope)->file_scope_ref = file_scope;
+        (*parser_file_scope)->import_index = num_imports;
+        throw_if_error(buffer_append(&self->imports, parser_file_scope, sizeof(ParserFileScopeReference*)));
+        throw_if_error(hash_map_insert(&self->imports_by_name, import_path_canonical, &parser_file_scope_index));
+    }
 }
diff --git a/src/program.c b/src/program.c
index eef49b6..a0a2407 100644
--- a/src/program.c
+++ b/src/program.c
@@ -1,4 +1,5 @@
 #include "../include/program.h"
+
 #include "../include/std/mem.h"
 #include "../include/std/hash.h"
 #include "../include/std/alloc.h"
@@ -29,6 +30,15 @@ typedef struct {
     NumberUnion value;
 } Number;
 
+static int hash_map_compare_u64(const void *a, const void *b) {
+    return *(u64*)a == *(u64*)b;
+}
+
+static usize hash_u64(const u8 *data, usize size) {
+    (void)size;
+    return *(u64*)data;
+}
+
 int amal_program_init(amal_program *self) {
     ignore_result_int(buffer_init(&self->data, NULL));
     self->string_indices                = NULL;
@@ -38,16 +48,20 @@ int amal_program_init(amal_program *self) {
     self->extern_funcs_start            = NULL;
     self->exported_funcs                = NULL;
     self->exported_funcs_end            = NULL;
+    self->imports_start                 = NULL;
     self->read_index                    = 0;
-    self->main_func_instruction_offset  = ~0U;
+    self->main_func_instruction_offset  = ~(u32)0U;
     self->num_intermediates             = 0;
     self->num_strings                   = 0;
     self->num_functions                 = 0;
     self->num_extern_functions          = 0;
     self->num_exported_functions        = 0;
+    self->num_imports                   = 0;
+    self->return_value_index            = 0;
 
     cleanup_if_error(arena_allocator_init(&self->allocator));
     cleanup_if_error(hash_map_init(&self->extern_funcs_map, &self->allocator, sizeof(ProgramExternFunc), hash_map_compare_string, amal_hash_string));
+    cleanup_if_error(hash_map_init(&self->deferred_func_calls, &self->allocator, sizeof(Buffer), hash_map_compare_u64, hash_u64));
     cleanup_if_error(buffer_append_header(&self->data));
     return 0;
 
@@ -60,6 +74,8 @@ void amal_program_deinit(amal_program *self) {
     arena_allocator_deinit(&self->allocator);
     am_free(self->extern_func_indices);
     am_free(self->string_indices);
+    self->extern_func_indices = NULL;
+    self->string_indices = NULL;
     if(self->data.data)
         buffer_deinit(&self->data);
 }
@@ -75,34 +91,46 @@ int amal_program_add_extern_func(amal_program *self, BufferView name, void *func
     return hash_map_insert(&self->extern_funcs_map, name, &extern_func);
 }
 
-static CHECK_RESULT int amal_program_get_extern_func_by_index(amal_program *self, u16 index, ProgramExternFunc *result) {
-    u8 *extern_func_ptr;
-    u8 num_args;
-    u8 func_name_len;
-    BufferView func_name;
-
-    if(index >= self->num_extern_functions) {
-        result->func = NULL;
-        result->args_byte_size = 0;
-        amal_log_error("Extern func index index %ld is out of range (%ld)", index, self->num_extern_functions);
-        return AMAL_PROGRAM_INSTRUCTION_INVALID_EXTERN_FUNC_INDEX;
+static u8* amal_program_get_extern_funcs_start_by_import_index(amal_program *self, u8 import_index) {
+    BytecodeHeaderImport *header_import = (BytecodeHeaderImport*)self->imports_start;
+    header_import += import_index;
+    return (u8*)self->data.data + header_import->extern_function_index;
+}
+
+typedef struct {
+    u8 num_params;
+    BufferView name;
+} BytecodeHeaderExternFunction;
+
+/* TODO: Optimize this */
+static void amal_program_get_header_extern_function_by_index(amal_program *self, u8 import_index, u16 index, BytecodeHeaderExternFunction *result) {
+    u32 i;
+    u8 *extern_funcs_start = amal_program_get_extern_funcs_start_by_import_index(self, import_index);
+    extern_funcs_start += sizeof(u16) + sizeof(u32);
+    for(i = 0; i < (u32)index; ++i) {
+        u8 name_len = *(extern_funcs_start + sizeof(u8));
+        /* +1 for the null-terminated character */
+        extern_funcs_start += sizeof(u8) + sizeof(u8) + name_len + 1;
     }
+    result->num_params = extern_funcs_start[0];
+    result->name.size = extern_funcs_start[1];
+    result->name.data = (const char*)extern_funcs_start + sizeof(u8) + sizeof(u8);
+}
 
-    extern_func_ptr = self->extern_funcs_start + self->extern_func_indices[index];
 
-    am_memcpy(&num_args, extern_func_ptr, sizeof(num_args));
-    am_memcpy(&func_name_len, extern_func_ptr + sizeof(num_args), sizeof(func_name_len));
-    func_name.size = func_name_len;
-    func_name.data = (const char*)(extern_func_ptr + sizeof(num_args) + sizeof(func_name_len));
+static CHECK_RESULT int amal_program_get_extern_func_by_index(amal_program *self, u8 import_index, u16 index, ProgramExternFunc *result) {
+    BytecodeHeaderExternFunction extern_func;
+    amal_program_get_header_extern_function_by_index(self, import_index, index, &extern_func);
     
-    if(!hash_map_get(&self->extern_funcs_map, func_name, result)) {
-        amal_log_error("No such extern function: %.*s", func_name.size, func_name.data);
+    if(!hash_map_get(&self->extern_funcs_map, extern_func.name, result)) {
+        amal_log_error("No such extern function: %.*s", extern_func.name.size, extern_func.name.data);
         return AMAL_PROGRAM_NO_SUCH_EXTERNAL_FUNCTION;
     }
     
     /* TODO: This assumes all arguments are of size sizeof(isize) */
-    if(result->args_byte_size != -1 && result->args_byte_size != num_args * (int)sizeof(isize)) {
-        amal_log_error("Extern function %.*s was registered to take %d byte(s), but the program says it takes %d byte(s)", func_name.size, func_name.data, result->args_byte_size, num_args * sizeof(isize));
+    if(result->args_byte_size != -1 && result->args_byte_size != extern_func.num_params * (int)sizeof(isize)) {
+        amal_log_error("Extern function %.*s was registered to take %d byte(s), but the program says it takes %d byte(s)",
+            extern_func.name.size, extern_func.name.data, result->args_byte_size, extern_func.num_params * sizeof(isize));
         return AMAL_PROGRAM_NO_SUCH_EXTERNAL_FUNCTION;
     }
     return 0;
@@ -125,7 +153,7 @@ static CHECK_RESULT int amal_program_set_exported_function_instruction_offset_ad
         num_args = self->exported_funcs[sizeof(instruction_offset)];
         func_name_size = self->exported_funcs[sizeof(instruction_offset) + sizeof(num_args)];
         self->exported_funcs += sizeof(instruction_offset) + sizeof(num_args) + sizeof(func_name_size);
-        if(self->main_func_instruction_offset == ~0U && func_name_size == 4 && am_memeql(self->exported_funcs, "main", 4))
+        if(self->main_func_instruction_offset == ~(u32)0U && func_name_size == 4 && am_memeql(self->exported_funcs, "main", 4))
             self->main_func_instruction_offset = instruction_offset;
 
         /* +1 to skip null-termination character */
@@ -191,10 +219,25 @@ static CHECK_RESULT bool amal_program_read_advance(amal_program *self, void *out
     return bool_true;
 }
 
+static CHECK_RESULT int amal_program_advance_section_magic_number(amal_program *self) {
+    u32 magic_number;
+    if(bytes_left_to_read(self) < sizeof(u32))
+        return AMAL_PROGRAM_SECTION_ERROR;
+    
+    am_memcpy(&magic_number, self->data.data + self->read_index, sizeof(magic_number));
+    if(magic_number != AMAL_BYTECODE_SECTION_MAGIC_NUMBER)
+        return AMAL_PROGRAM_SECTION_ERROR;
+    
+    self->read_index += sizeof(magic_number);
+    return 0;
+}
+
 static CHECK_RESULT int amal_program_read_intermediates(amal_program *self) {
     u32 intermediates_size;
     /*u32 read_end;*/
 
+    return_if_error(amal_program_advance_section_magic_number(self));
+
     if(bytes_left_to_read(self) < sizeof(intermediates_size)) {
         amal_log_error("Not enough space in program to intermediates size");
         return AMAL_PROGRAM_INVALID_INTERMEDIATES;
@@ -219,6 +262,8 @@ static CHECK_RESULT int amal_program_read_strings(amal_program *self) {
     u32 strings_size;
     u32 *string_index_ptr;
 
+    return_if_error(amal_program_advance_section_magic_number(self));
+
     if(!amal_program_read_advance(self, &self->num_strings, sizeof(u16)))
         return AMAL_PROGRAM_INVALID_STRINGS;
 
@@ -262,8 +307,18 @@ static CHECK_RESULT int amal_program_read_strings(amal_program *self) {
 }
 
 static CHECK_RESULT int amal_program_read_functions(amal_program *self) {
+    u32 funcs_size;
+
+    return_if_error(amal_program_advance_section_magic_number(self));
+
     if(!amal_program_read_advance(self, &self->num_functions, sizeof(u16)))
         return AMAL_PROGRAM_INVALID_FUNCTIONS;
+
+    if(!amal_program_read_advance(self, &funcs_size, sizeof(funcs_size)) || bytes_left_to_read(self) < funcs_size)
+        return AMAL_PROGRAM_INVALID_FUNCTIONS;
+
+    self->funcs_start = (u8*)(self->data.data + self->read_index);
+    self->read_index += funcs_size;
     return AMAL_PROGRAM_OK;
 }
 
@@ -271,6 +326,8 @@ static CHECK_RESULT int amal_program_read_external_functions(amal_program *self)
     u32 extern_funcs_size;
     u32 *extern_func_index_ptr;
 
+    return_if_error(amal_program_advance_section_magic_number(self));
+
     if(!amal_program_read_advance(self, &self->num_extern_functions, sizeof(u16)))
         return AMAL_PROGRAM_INVALID_EXTERNAL_FUNCTIONS;
 
@@ -291,17 +348,17 @@ static CHECK_RESULT int amal_program_read_external_functions(amal_program *self)
         const u32 read_end = read_start + extern_funcs_size;
         self->extern_funcs_start = (u8*)(self->data.data + self->read_index);
         while(self->read_index < read_end) {
-            u8 num_args;
+            u8 num_params;
             u8 func_name_size;
 
-            if(bytes_left_to_read(self) < sizeof(num_args) + sizeof(func_name_size))
+            if(bytes_left_to_read(self) < sizeof(num_params) + sizeof(func_name_size))
                 return AMAL_PROGRAM_INVALID_EXTERNAL_FUNCTIONS;
 
             *extern_func_index_ptr = self->read_index - read_start;
             ++extern_func_index_ptr;
-            num_args = self->data.data[self->read_index];
-            func_name_size = self->data.data[self->read_index + sizeof(num_args)];
-            self->read_index += sizeof(num_args) + sizeof(func_name_size);
+            num_params = self->data.data[self->read_index];
+            func_name_size = self->data.data[self->read_index + sizeof(num_params)];
+            self->read_index += sizeof(num_params) + sizeof(func_name_size);
 
             /* +1 to skip null-termination character */
             if(bytes_left_to_read(self) < func_name_size + 1U)
@@ -318,6 +375,8 @@ static CHECK_RESULT int amal_program_read_external_functions(amal_program *self)
 static CHECK_RESULT int amal_program_read_exported_functions(amal_program *self) {
     u32 export_funcs_size;
 
+    return_if_error(amal_program_advance_section_magic_number(self));
+
     if(!amal_program_read_advance(self, &self->num_exported_functions, sizeof(u16)))
         return AMAL_PROGRAM_INVALID_EXPORTED_FUNCTIONS;
 
@@ -337,6 +396,22 @@ static CHECK_RESULT int amal_program_read_exported_functions(amal_program *self)
     return AMAL_PROGRAM_OK;
 }
 
+static CHECK_RESULT int amal_program_read_imports(amal_program *self) {
+    u32 imports_size;
+
+    return_if_error(amal_program_advance_section_magic_number(self));
+
+    if(!amal_program_read_advance(self, &self->num_imports, sizeof(u8)))
+        return AMAL_PROGRAM_INVALID_IMPORTS;
+
+    if(!amal_program_read_advance(self, &imports_size, sizeof(imports_size)) || bytes_left_to_read(self) < imports_size)
+        return AMAL_PROGRAM_INVALID_IMPORTS;
+
+    self->imports_start = (u8*)(self->data.data + self->read_index);
+    self->read_index += imports_size;
+    return AMAL_PROGRAM_OK;
+}
+
 static CHECK_RESULT int amal_program_get_intermediate_by_index(amal_program *self, u16 index, Number *result) {
     if(index >= self->num_intermediates)
         return AMAL_PROGRAM_INSTRUCTION_INVALID_INTERMEDIATE_INDEX;
@@ -360,6 +435,48 @@ static CHECK_RESULT int amal_program_get_data_by_index(amal_program *self, u16 i
     return 0;
 }
 
+static u8* amal_program_get_funcs_start_by_import_index(amal_program *self, u8 import_index) {
+    BytecodeHeaderImport *header_import = (BytecodeHeaderImport*)self->imports_start;
+    header_import += import_index;
+    return (u8*)self->data.data + header_import->function_index;
+}
+
+static BytecodeHeaderFunction* amal_program_get_header_function_by_index(amal_program *self, u8 import_index, u16 index) {
+    u8 *funcs_start = amal_program_get_funcs_start_by_import_index(self, import_index);
+    BytecodeHeaderFunction *header_func = (BytecodeHeaderFunction*)(funcs_start + sizeof(u16) + sizeof(u32));
+    return header_func + index;
+}
+
+static u64 deferred_func_call_get_key(amal_program *self, u8 import_index, u16 func_index) {
+    BytecodeHeaderImport *header_import = (BytecodeHeaderImport*)self->imports_start;
+    header_import += import_index;
+    return ((u64)func_index << 32) | (u64)header_import->function_index;
+}
+
+static CHECK_RESULT int resolve_deferred_func_calls(amal_program *self, amal_executor *executor, u16 func_index) {
+    u64 key = deferred_func_call_get_key(self, 0, func_index);
+    BufferView key_mem = create_buffer_view((char*)&key, sizeof(key));
+    u32 current_code_offset = amal_exec_get_code_offset(executor);
+
+    Buffer* deferred_func_call_list;
+    if(!hash_map_get_ref(&self->deferred_func_calls, key_mem, (void**)&deferred_func_call_list))
+        return 0;
+    
+    {
+        u32 *code_offset = buffer_begin(deferred_func_call_list);
+        u32 *code_offset_end = buffer_end(deferred_func_call_list);
+        for(; code_offset != code_offset_end; ++code_offset) {
+            amal_exec_call_overwrite(executor, *code_offset, current_code_offset - *code_offset);
+        }
+        return buffer_set_capacity(deferred_func_call_list, 0);
+    }
+}
+
+static void header_func_set_offset(amal_program *self, u16 func_index, u32 code_offset) {
+    BytecodeHeaderFunction *header_func = ((BytecodeHeaderFunction*)self->funcs_start) + func_index;
+    header_func->func_offset = code_offset;
+}
+
 static CHECK_RESULT int amal_program_read_instructions(amal_program *self, amal_executor *executor) {
     u32 instructions_size;
     u32 read_start;
@@ -370,6 +487,9 @@ static CHECK_RESULT int amal_program_read_instructions(amal_program *self, amal_
     inside_func = bool_false;
     (void)inside_func;
     func_counter = 0;
+    self->return_value_index = 0;
+
+    return_if_error(amal_program_advance_section_magic_number(self));
 
     if(!amal_program_read_advance(self, &instructions_size, sizeof(instructions_size)))
         return AMAL_PROGRAM_INVALID_INSTRUCTIONS_SIZE;
@@ -484,14 +604,51 @@ static CHECK_RESULT int amal_program_read_instructions(amal_program *self, amal_
                 self->read_index += 2;
                 break;
             }
+            case AMAL_OP_PUSH_RET: {
+                /* TODO: Validate return value index doesn't go out of bounds? */
+                self->return_values_stack[self->return_value_index++] = self->data.data[self->read_index];
+                self->read_index += 1;
+                break;
+            }
             case AMAL_OP_CALL: {
+                u8 import_index;
                 u16 func_index;
                 u8 num_args;
+                BytecodeHeaderFunction *func_def;
                 i8 dst_reg;
-                am_memcpy(&func_index, self->data.data + self->read_index, sizeof(func_index));
-                num_args = self->data.data[self->read_index + sizeof(func_index)];
-                dst_reg = self->data.data[self->read_index + sizeof(func_index) + sizeof(num_args)];
-                return_if_error(amal_exec_call(executor, func_index, num_args, dst_reg));
+
+                am_memcpy(&import_index, self->data.data + self->read_index, sizeof(import_index));
+                am_memcpy(&func_index, self->data.data + self->read_index + sizeof(import_index), sizeof(func_index));
+                am_memcpy(&num_args, self->data.data + self->read_index + sizeof(import_index) + sizeof(func_index), sizeof(num_args));
+                func_def = amal_program_get_header_function_by_index(self, import_index, func_index);
+                assert(func_def->num_return_types == 1 && "TODO: Support 0 and more than 1 return values");
+                assert(self->return_value_index == 1);
+                dst_reg = self->return_values_stack[0];
+                self->return_value_index -= func_def->num_return_types;
+
+                if((char*)func_def < self->data.data + self->read_index) {
+                    return_if_error(amal_exec_call(executor, func_def->func_offset, num_args, dst_reg));
+                } else {
+                    /*
+                        The code for the function has not been generated yet (the function is defined after the current location).
+                        Make a dummy call and replace the call target after the function has been generated
+                    */
+                    u64 key = deferred_func_call_get_key(self, import_index, func_index);
+                    BufferView key_mem = create_buffer_view((char*)&key, sizeof(key));
+                    u32 code_offset = amal_exec_get_code_offset(executor);
+
+                    Buffer* deferred_func_call_list;
+                    if(hash_map_get_ref(&self->deferred_func_calls, key_mem, (void**)&deferred_func_call_list))
+                        return_if_error(buffer_append(deferred_func_call_list, &code_offset, sizeof(code_offset)));
+                    else {
+                        Buffer new_deferred_call_list;
+                        return_if_error(buffer_init(&new_deferred_call_list, &self->allocator));
+                        return_if_error(buffer_append(&new_deferred_call_list, &code_offset, sizeof(code_offset)));
+                        return_if_error(hash_map_insert(&self->deferred_func_calls, key_mem, &new_deferred_call_list));
+                    }
+                    /* Dummy call to offset 0, offset will be replace later when the target function hits AMAL_OP_FUNC_START */
+                    return_if_error(amal_exec_call(executor, 0, num_args, dst_reg));
+                }
                 self->read_index += 4;
                 break;
             }
@@ -500,16 +657,21 @@ static CHECK_RESULT int amal_program_read_instructions(amal_program *self, amal_
                 self->read_index += 2;
                 break;
             case AMAL_OP_CALLE: {
+                u8 import_index;
                 u16 extern_func_index;
                 u8 num_args;
                 i8 dst_reg;
-                am_memcpy(&extern_func_index, self->data.data + self->read_index, sizeof(extern_func_index));
-                num_args = self->data.data[self->read_index + sizeof(extern_func_index)];
-                dst_reg = self->data.data[self->read_index + sizeof(extern_func_index) + sizeof(num_args)];
+
+                am_memcpy(&import_index, self->data.data + self->read_index, sizeof(import_index));
+                am_memcpy(&extern_func_index, self->data.data + self->read_index + sizeof(import_index), sizeof(extern_func_index));
+                am_memcpy(&num_args, self->data.data + self->read_index + sizeof(import_index) + sizeof(extern_func_index), sizeof(num_args));
+                assert(self->return_value_index == 1 && "TODO: Support extern functions that don't return any value");
+                dst_reg = self->return_values_stack[0];
+                self->return_value_index = 0;
 
                 {
                     ProgramExternFunc extern_func;
-                    return_if_error(amal_program_get_extern_func_by_index(self, extern_func_index, &extern_func));
+                    return_if_error(amal_program_get_extern_func_by_index(self, import_index, extern_func_index, &extern_func));
                     return_if_error(amal_exec_calle(executor, extern_func.func, num_args, dst_reg));
                 }
                 self->read_index += 4;
@@ -549,6 +711,9 @@ static CHECK_RESULT int amal_program_read_instructions(amal_program *self, amal_
                 assert(!inside_func);
                 inside_func = bool_true;
                 assert(func_counter < self->num_functions);
+
+                header_func_set_offset(self, func_counter, amal_exec_get_code_offset(executor));
+                return_if_error(resolve_deferred_func_calls(self, executor, func_counter));
                 ++func_counter;
 
                 func_flags = self->data.data[self->read_index];
@@ -595,9 +760,10 @@ int amal_program_run(amal_program *self) {
         cleanup_if_error(amal_program_read_functions(self));
         cleanup_if_error(amal_program_read_external_functions(self));
         cleanup_if_error(amal_program_read_exported_functions(self));
+        cleanup_if_error(amal_program_read_imports(self));
         cleanup_if_error(amal_program_read_instructions(self, executor));
     }
-    if(self->main_func_instruction_offset == ~0U) {
+    if(self->main_func_instruction_offset == ~(u32)0U) {
         amal_log_error("The program is missing a main function");
         result = AMAL_PROGRAM_NO_MAIN_FUNC;
         goto cleanup;
diff --git a/src/ssa/ssa.c b/src/ssa/ssa.c
index 5c625b2..19aa036 100644
--- a/src/ssa/ssa.c
+++ b/src/ssa/ssa.c
@@ -26,6 +26,8 @@ do { \
 /* Max length of a string that fits in u16 */
 #define MAX_STRING_LENGTH UINT16_MAX
 
+static CHECK_RESULT SsaRegister variable_generate_ssa(Variable *self, SsaCompilerContext *context);
+
 static int compare_number(const void *a, const void *b) {
     const SsaNumber *lhs = a;
     const SsaNumber *rhs = b;
@@ -62,13 +64,14 @@ int ssa_init(Ssa *self, Parser *parser) {
     return_if_error(hash_map_init(&self->extern_funcs_map, parser->allocator, sizeof(SsaExternFuncIndex), hash_map_compare_string, amal_hash_string));
     return_if_error(buffer_init(&self->extern_funcs, parser->allocator));
     return_if_error(buffer_init(&self->export_funcs, parser->allocator));
+    return_if_error(buffer_init(&self->funcs, parser->allocator));
     self->intermediate_counter = 0;
     self->string_counter = 0;
     self->extern_func_counter = 0;
     self->export_func_counter = 0;
+    self->func_counter = 0;
     self->reg_counter = 0;
     self->param_counter = 0;
-    self->func_counter = 0;
     self->label_counter = 0;
     self->parser = parser;
     return 0;
@@ -186,7 +189,7 @@ static CHECK_RESULT int ssa_try_add_extern_func(Ssa *self, FunctionSignature *fu
     
     *result_index = self->extern_func_counter;
     ++self->extern_func_counter;
-    amal_log_debug("ef%u = \"%.*s\"", *result_index, name.size, name.data);
+    amal_log_debug("extern_func%u = %.*s", *result_index, name.size, name.data);
     {
         SsaExternFunc extern_func;
         extern_func.func_sig = func_sig;
@@ -209,7 +212,7 @@ static CHECK_RESULT int ssa_try_add_export_func(Ssa *self, FunctionSignature *fu
         return -1;
     }
     
-    amal_log_debug("ef%u = \"%.*s\"", self->export_func_counter, name.size, name.data);
+    amal_log_debug("exported_func%u = %.*s", self->export_func_counter, name.size, name.data);
     ++self->export_func_counter;
     {
         SsaExportFunc export_func;
@@ -274,7 +277,7 @@ static CHECK_RESULT int ssa_ins_binop(Ssa *self, SsaInstruction binop_type, SsaR
     return ssa_add_ins_form2(self, binop_type, lhs, rhs, result);
 }
 
-static CHECK_RESULT int ssa_ins_func_start(Ssa *self, u8 func_flags, SsaFuncIndex *result, usize *func_metadata_index) {
+static CHECK_RESULT int ssa_ins_func_start(Ssa *self, u8 func_flags, FunctionSignature *func_sig, SsaFuncIndex *result, usize *func_metadata_index) {
     const u8 ins_type = SSA_FUNC_START;
     SsaInsFuncStart ins_func_start;
 
@@ -285,13 +288,18 @@ static CHECK_RESULT int ssa_ins_func_start(Ssa *self, u8 func_flags, SsaFuncInde
     }
 
     *result = self->func_counter++;
+    {
+        SsaFunc func;
+        func.func_sig = func_sig;
+        return_if_error(buffer_append(&self->funcs, &func, sizeof(func)));
+    }
     ins_func_start.flags = func_flags;
     /* Dont set number of local registers yet. That will be set by @func_metadata_index later when it's known */
     /*ins_func_start.num_local_vars_regs = ---*/
     return_if_error(buffer_append(&self->instructions, &ins_type, 1));
     return_if_error(buffer_append(&self->instructions, &ins_func_start, sizeof(ins_func_start)));
     *func_metadata_index = self->instructions.size - sizeof(ins_func_start.num_local_vars_regs);
-    amal_log_debug("FUNC_START f%u", *result);
+    amal_log_debug("FUNC_START f%u(%d) %d", *result, buffer_get_size(&func_sig->parameters, FunctionParameter), buffer_get_size(&func_sig->return_types, FunctionReturnType));
     return 0;
 }
 
@@ -308,27 +316,31 @@ static CHECK_RESULT int ssa_ins_push(Ssa *self, SsaRegister reg) {
     return buffer_append(&self->instructions, &reg, sizeof(reg));
 }
 
-static CHECK_RESULT int ssa_ins_call(Ssa *self, FunctionDecl *func_decl, u8 num_args, SsaRegister *result) {
+static CHECK_RESULT int ssa_ins_push_ret(Ssa *self, SsaRegister reg) {
+    const u8 ins_type = SSA_PUSH_RET;
+    amal_log_debug("PUSH RET r%d", reg);
+    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
+    return buffer_append(&self->instructions, &reg, sizeof(reg));
+}
+
+static CHECK_RESULT int ssa_ins_call(Ssa *self, int import_index, FunctionDecl *func_decl, u8 num_args) {
     const u8 ins_type = SSA_CALL;
     SsaInsFuncCall ins_func_call;
-    return_if_error(ssa_get_unique_reg(self, result));
     ins_func_call.num_args = num_args;
-    ins_func_call.result = *result;
     ins_func_call.func_decl = func_decl;
-    amal_log_debug("r%d = CALL %d, %p", *result, num_args, func_decl);
+    ins_func_call.import_index = import_index;
+    amal_log_debug("CALL %d, f(%d,%p)", num_args, import_index, func_decl);
     return_if_error(buffer_append(&self->instructions, &ins_type, 1));
     return buffer_append(&self->instructions, &ins_func_call, sizeof(ins_func_call));
 }
 
-static CHECK_RESULT int ssa_ins_call_extern(Ssa *self, SsaExternFuncIndex extern_func_index, u8 num_args, SsaRegister *result) {
+static CHECK_RESULT int ssa_ins_call_extern(Ssa *self, int import_index, LhsExpr *func_decl_lhs, u8 num_args) {
     const u8 ins_type = SSA_CALL_EXTERN;
     SsaInsFuncCallExtern ins_func_call_extern;
-    return_if_error(ssa_get_unique_reg(self, result));
-    assert(extern_func_index < self->extern_func_counter);
     ins_func_call_extern.num_args = num_args;
-    ins_func_call_extern.result = *result;
-    ins_func_call_extern.extern_func_index = extern_func_index;
-    amal_log_debug("r%d = CALL_EXTERN %d, %d", *result, num_args, extern_func_index);
+    ins_func_call_extern.func_decl_lhs = func_decl_lhs;
+    ins_func_call_extern.import_index = import_index;
+    amal_log_debug("CALL_EXTERN %d, ef(%d,%p)", num_args, import_index, func_decl_lhs);
     return_if_error(buffer_append(&self->instructions, &ins_type, 1));
     return buffer_append(&self->instructions, &ins_func_call_extern, sizeof(ins_func_call_extern));
 }
@@ -608,10 +620,11 @@ static CHECK_RESULT SsaRegister funcdecl_generate_ssa(FunctionDecl *self, SsaCom
     amal_log_debug("SSA funcdecl %p", self);
     /* Anonymous closure doesn't have lhs_expr, and neither can it have any flags (extern, export etc) */
     if(self->lhs_expr) {
+        assert(!LHS_EXPR_IS_EXTERN(self->lhs_expr));
         if(LHS_EXPR_IS_EXPORT(self->lhs_expr))
             func_flags |= FUNC_FLAG_EXPORTED;
     }
-    throw_if_error(ssa_ins_func_start(context->ssa, func_flags, &self->ssa_func_index, &func_metadata_index));
+    throw_if_error(ssa_ins_func_start(context->ssa, func_flags, self->signature, &self->ssa_func_index, &func_metadata_index));
     scope_generate_ssa(&self->body, context);
     throw_if_error(ssa_ins_func_end(context->ssa));
 
@@ -624,28 +637,41 @@ static CHECK_RESULT SsaRegister funccall_generate_ssa(FunctionCall *self, AstRes
     SsaRegister reg;
     FunctionDecl *func_decl;
     LhsExpr *func_lhs_expr;
+    int import_index = context->import_index;
+    context->import_index = 0;
+    throw_if_error(ssa_get_unique_reg(context->ssa, &reg));
+
+    func_decl = resolve_data->type.value.func_sig->func_decl;
+    assert(resolve_data->type.type == RESOLVED_TYPE_FUNC_SIG);
+    func_lhs_expr = NULL;
+    if(self->func.resolved_var.type == NAMED_OBJECT_LHS_EXPR)
+        func_lhs_expr = self->func.resolved_var.value.lhs_expr;
+
+    /* Push return arguments */
+    {
+        /*
+            TODO: When amalgam supports multiple return types in assignment/declaration, update this to take
+            all of them into account. Right now it only uses one return type.
+            It should also take into account the size of the type.
+        */
+        throw_if_error(ssa_ins_push_ret(context->ssa, reg));
+    }
 
+    /* Push parameter arguments */
     {
         Ast **arg = buffer_begin(&self->args);
         Ast **arg_end = buffer_end(&self->args);
         for(; arg != arg_end; ++arg) {
-            SsaRegister arg_reg;
-            arg_reg = ast_generate_ssa(*arg, context);
+            SsaRegister arg_reg = ast_generate_ssa(*arg, context);
             throw_if_error(ssa_ins_push(context->ssa, arg_reg));
         }
     }
 
-    func_decl = resolve_data->type.value.func_sig->func_decl;
-    assert(resolve_data->type.type == RESOLVED_TYPE_FUNC_SIG);
-    func_lhs_expr = NULL;
-    if(self->func.resolved_var.type == NAMED_OBJECT_LHS_EXPR)
-        func_lhs_expr = self->func.resolved_var.value.lhs_expr;
-
     if(func_lhs_expr && LHS_EXPR_IS_EXTERN(func_lhs_expr)) {
-        throw_if_error(ssa_ins_call_extern(context->ssa, func_lhs_expr->extern_index, buffer_get_size(&self->args, Ast*), &reg));
+        throw_if_error(ssa_ins_call_extern(context->ssa, import_index, func_lhs_expr, buffer_get_size(&self->args, Ast*)));
     } else {
         /* rhs wont be null here because only extern variable can't have rhs */
-        throw_if_error(ssa_ins_call(context->ssa, func_decl, buffer_get_size(&self->args, Ast*), &reg));
+        throw_if_error(ssa_ins_call(context->ssa, import_index, func_decl, buffer_get_size(&self->args, Ast*)));
     }
 
     return reg;
@@ -673,7 +699,7 @@ static CHECK_RESULT SsaRegister string_generate_ssa(String *self, SsaCompilerCon
     return reg;
 }
 
-static CHECK_RESULT SsaRegister variable_generate_ssa(Variable *self, SsaCompilerContext *context) {
+SsaRegister variable_generate_ssa(Variable *self, SsaCompilerContext *context) {
     /* TODO: If resolved_var refers to a variable in another file, use a cross file reference that requires no locking (not yet implemented) */
     /* This is not thread-safe:*/
     assert(self->resolved_var.type != NAMED_OBJECT_NONE);
@@ -699,6 +725,16 @@ static SsaInstruction binop_type_to_ssa_type(BinopType binop_type, amal_default_
     return 0;
 }
 
+/* Returns the import statement for lhs of binop dot expression, where lhs is a variable name */
+static Import* binop_lhs_get_import_or_null(Binop *self) {
+    if(self->lhs->type == AST_VARIABLE) {
+        ScopeNamedObject *resolved_var = &self->lhs->value.variable->resolved_var;
+        if(resolved_var->type == NAMED_OBJECT_LHS_EXPR && resolved_var->value.lhs_expr->rhs_expr && resolved_var->value.lhs_expr->rhs_expr->type == AST_IMPORT)
+            return resolved_var->value.lhs_expr->rhs_expr->value.import;
+    }
+    return NULL;
+}
+
 static CHECK_RESULT SsaRegister binop_generate_ssa(Binop *self, SsaCompilerContext *context) {
     SsaRegister reg;
 
@@ -707,8 +743,12 @@ static CHECK_RESULT SsaRegister binop_generate_ssa(Binop *self, SsaCompilerConte
         const std = @import("std.amal");
         std.printf
     */
-    if(self->type == BINOP_DOT && resolved_type_is_func_decl(self->rhs)) {
+    if(self->type == BINOP_DOT && self->rhs->resolve_data.type.type == RESOLVED_TYPE_FUNC_SIG) {
+        Import *lhs_import = binop_lhs_get_import_or_null(self);
+        if(lhs_import)
+            context->import_index = 1 + lhs_import->file_scope->import_index;
         reg = ast_generate_ssa(self->rhs, context);
+        context->import_index = 0;
     } else {
         const SsaRegister lhs_reg = ast_generate_ssa(self->lhs, context);
         const SsaRegister rhs_reg = ast_generate_ssa(self->rhs, context);
@@ -774,9 +814,10 @@ static void while_statement_generate_ssa(WhileStatement *while_stmt, SsaCompiler
     SsaLabelIndex before_condition_label;
     SsaLabelIndex skip_body_label;
     usize jump_after_condition_index;
+    SsaRegister condition_reg;
 
     throw_if_error(ssa_ins_label(context->ssa, &before_condition_label));
-    SsaRegister condition_reg = ast_generate_ssa(while_stmt->condition, context);
+    condition_reg = ast_generate_ssa(while_stmt->condition, context);
     throw_if_error(ssa_ins_jumpzero(context->ssa, condition_reg, 0, &jump_after_condition_index));
     scope_generate_ssa(&while_stmt->body, context);
 
diff --git a/src/std/buffer.c b/src/std/buffer.c
index a482bb9..021fce8 100644
--- a/src/std/buffer.c
+++ b/src/std/buffer.c
@@ -94,6 +94,19 @@ void buffer_clear(Buffer *self) {
     self->size = 0;
 }
 
+int buffer_set_capacity(Buffer *self, usize new_capacity) {
+    if(am_realloc(self->data, new_capacity, (void**)&self->data) != ALLOC_OK)
+        return BUFFER_ALLOC_FAIL;
+    
+    self->capacity = new_capacity;
+    if(self->size < self->capacity)
+        self->size = self->capacity;
+    /* Update list of buffers in the allocator with the new address of the buffer data */
+    if(self->allocator)
+        am_memcpy(self->allocator->mems.data + sizeof(void*) * self->allocator_index, &self->data, sizeof(void*));
+    return BUFFER_OK;
+}
+
 void* buffer_begin(Buffer *self) {
     return self->data;
 }
diff --git a/src/std/buffer_view.c b/src/std/buffer_view.c
index f2d79c0..249928b 100644
--- a/src/std/buffer_view.c
+++ b/src/std/buffer_view.c
@@ -1,7 +1,7 @@
 #include "../../include/std/buffer_view.h"
 #include "../../include/std/mem.h"
 
-BufferView create_buffer_view_null() {
+BufferView create_buffer_view_null(void) {
     BufferView buffer_view;
     buffer_view.data = NULL;
     buffer_view.size = 0;
diff --git a/src/std/hash_map.c b/src/std/hash_map.c
index 98ebf40..234f3e3 100644
--- a/src/std/hash_map.c
+++ b/src/std/hash_map.c
@@ -178,6 +178,7 @@ int hash_map_insert(HashMap *self, BufferView key, void *value) {
 }
 
 bool hash_map_get(HashMap *self, BufferView key, void *value) {
+#if 0
     usize bucket_size;
     usize bucket_index;
     usize hash;
@@ -200,6 +201,37 @@ bool hash_map_get(HashMap *self, BufferView key, void *value) {
     }
 
     return bool_false;
+#endif
+    void *ref;
+    if(!hash_map_get_ref(self, key, &ref))
+        return bool_false;
+    am_memcpy(value, ref, self->value_type_size);
+    return bool_true;
+}
+
+bool hash_map_get_ref(HashMap *self, BufferView key, void **value) {
+    usize bucket_size;
+    usize bucket_index;
+    usize hash;
+    HashMapBucket *bucket;
+    HashMapBucketNode *bucket_node;
+
+    bucket_size = buffer_get_size(&self->buckets, HashMapBucket);
+    hash = self->hash_func((const u8*)key.data, key.size);
+    bucket_index = hash % bucket_size;
+
+    bucket = ((HashMapBucket*)self->buckets.data) + bucket_index;
+    for(bucket_node = bucket->start; bucket_node; bucket_node = bucket_node_get_next(bucket_node)) {
+        BufferView bucket_key;
+        bucket_key = bucket_node_get_key(bucket_node);
+        if(hash == bucket_node_get_hash(bucket_node) && self->compare_func(&key, &bucket_key) == 0) {
+            if(value)
+                *value = bucket_node_get_value(bucket_node);
+            return bool_true;
+        }
+    }
+
+    return bool_false;
 }
 
 bool hash_map_contains(HashMap *self, BufferView key) {
diff --git a/src/std/log.c b/src/std/log.c
index 59e0319..68f1f2e 100644
--- a/src/std/log.c
+++ b/src/std/log.c
@@ -10,14 +10,14 @@ static amal_mutex mutex;
 static bool mutex_initialized = bool_false;
 
 /* Safe to call multiple times */
-static void mutex_init() {
+static void mutex_init(void) {
     if(!mutex_initialized) {
         ignore_result_int(amal_mutex_init(&mutex));
         mutex_initialized = bool_true;
     }
 }
 
-amal_mutex* amal_log_get_mutex() {
+amal_mutex* amal_log_get_mutex(void) {
     mutex_init();
     return &mutex;
 }
diff --git a/src/std/mem.c b/src/std/mem.c
index 95edcb9..8658781 100644
--- a/src/std/mem.c
+++ b/src/std/mem.c
@@ -18,7 +18,6 @@ void am_memset(void *dest, int value, usize size) {
     memset(dest, value, size);
 }
 
-long am_pagesize() {
+long am_pagesize(void) {
     return sysconf(_SC_PAGESIZE);
 }
-
diff --git a/src/std/thread.c b/src/std/thread.c
index 87362d2..9b9b764 100644
--- a/src/std/thread.c
+++ b/src/std/thread.c
@@ -120,11 +120,11 @@ void amal_mutex_deinit(amal_mutex *self) {
     pthread_mutex_destroy(&self->mutex);
 }
 
-static long amal_process_get_id() {
+static long amal_process_get_id(void) {
     return getpid();
 }
 
-static long amal_thread_get_id() {
+static long amal_thread_get_id(void) {
     return syscall(SYS_gettid);
 }
 
@@ -173,11 +173,11 @@ void amal_mutex_tryunlock(amal_mutex *self) {
     ignore_result_int(amal_mutex_unlock(self));
 }
 
-bool amal_thread_is_main() {
+bool amal_thread_is_main(void) {
     /* TODO: This only works for linux, use equivalent functions on other platforms */
     return amal_thread_get_id() == amal_process_get_id();
 }
 
-int amal_get_usable_thread_count() {
+int amal_get_usable_thread_count(void) {
     return get_nprocs();
 }
diff --git a/std/io.amal b/std/io.amal
new file mode 100644
index 0000000..9023280
--- /dev/null
+++ b/std/io.amal
@@ -0,0 +1,5 @@
+extern const print_extern: fn() i32;
+
+pub const print = fn() i32 {
+    return print_extern();
+}
\ No newline at end of file
diff --git a/tests/bytecode.amal b/tests/bytecode.amal
index ef255cd..6941bc8 100644
--- a/tests/bytecode.amal
+++ b/tests/bytecode.amal
@@ -1,8 +1,9 @@
-extern const print_extern: fn;
-extern const print_extern_num: fn(num: i32);
-
-const print = fn {
+/*
+extern const print_extern: fn() i32;
+extern const print_extern_num: fn(num: i32) i32;
 
+const print = fn() i32 {
+    return 0;
 }
 
 const main = fn {
@@ -21,4 +22,10 @@ const print_num = fn(num: i32) i32 {
     print_extern_num(num);
     print_extern_num(8080);
     return num;
-}
\ No newline at end of file
+}
+*/
+
+const io = @import("../std/io.amal");
+const main = fn {
+    io.print();
+}
diff --git a/tests/main.c b/tests/main.c
index b2b53cc..eec3a78 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -19,7 +19,7 @@ static int num_tests_run = 0;
     }\
 }while(0)
 
-static CHECK_RESULT int test_hash_map() {
+static CHECK_RESULT int test_hash_map(void) {
     ArenaAllocator arena_allocator;
     HashMapType(BufferView, int) hash_map;
     int value;
@@ -132,7 +132,7 @@ static CHECK_RESULT int get_thread_count_env_var(int *thread_count) {
     return 0;
 }
 
-static int print_extern() {
+static int print_extern(void) {
     printf("hello from amalgam extern func, print_extern!\n");
     return 0;
 }
@@ -228,7 +228,7 @@ static void test_load_error(const char *filepath, const char *expected_error) {
         free(expected_data.expected_error);
 }
 
-static void run_all_tests() {
+static void run_all_tests(void) {
     test_load("tests/main.amal");
     test_load("tests/utf8bom.amal");
     test_load("tests/bytecode.amal");