diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/asm/x86_64.c | 383 | ||||
| -rw-r--r-- | src/ast.c | 129 | ||||
| -rw-r--r-- | src/bytecode/bytecode.c | 43 | ||||
| -rw-r--r-- | src/compiler.c | 90 | ||||
| -rw-r--r-- | src/parser.c | 66 | ||||
| -rw-r--r-- | src/program.c | 368 | ||||
| -rw-r--r-- | src/ssa/ssa.c | 56 | ||||
| -rw-r--r-- | src/std/arena_allocator.c (renamed from src/std/scoped_allocator.c) | 36 | ||||
| -rw-r--r-- | src/std/buffer.c | 6 | ||||
| -rw-r--r-- | src/std/hash_map.c | 6 | ||||
| -rw-r--r-- | src/std/mem.c | 6 | ||||
| -rw-r--r-- | src/tokenizer.c | 7 |
12 files changed, 1015 insertions, 181 deletions
diff --git a/src/asm/x86_64.c b/src/asm/x86_64.c new file mode 100644 index 0000000..2cbeead --- /dev/null +++ b/src/asm/x86_64.c @@ -0,0 +1,383 @@ +#include "../../include/asm/x86_64.h" + +#include "../../include/std/mem.h" +#include "../../include/std/log.h" +#include <errno.h> +#include <assert.h> +#include <stdio.h> + +#include <sys/mman.h> + +#define REX_W 0x48 + +void asm_ptr_init(AsmPtr *self, Reg64 base) { + self->base = base; + self->index = -1; + self->disp = 0; + self->scale = 0; +} + +void asm_ptr_init_index(AsmPtr *self, Reg64 base, Reg64 index) { + self->base = base; + self->index = index; + self->disp = 0; + self->scale = 0; +} + +void asm_ptr_init_disp(AsmPtr *self, Reg64 base, i32 disp) { + self->base = base; + self->index = -1; + self->disp = disp; + self->scale = 0; +} + +void asm_ptr_init_index_disp(AsmPtr *self, Reg64 base, Reg64 index, i32 disp) { + self->base = base; + self->index = index; + self->disp = disp; + self->scale = 0; +} + +int asm_init(Asm *self) { + self->size = am_pagesize(); + amal_log_debug("asm: page size: %u", self->size); + self->code = mmap(NULL, self->size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + if(self->code == MAP_FAILED) + return -errno; + self->code_it = self->code; + return 0; +} + +void asm_deinit(Asm *self) { + if(self->code) + munmap(self->code, self->size); + self->code = NULL; + self->code_it = NULL; + self->size = 0; +} + +static void asm_print_code_hex(Asm *self) { + u8 *ptr; + int off; + ptr = self->code; + off = 0; + while(ptr != self->code_it) { + printf("%02x", *ptr); + ++ptr; + ++off; + if(off == 8) { + putc('\n', stdout); + off = 0; + } else { + putc(' ', stdout); + } + } + if(off != 0) + putc('\n', stdout); +} + +int asm_execute(Asm *self) { + void (*func)(); + if(mprotect(self->code, self->size, PROT_READ | PROT_EXEC) != 0) + return -errno; + + 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; + func(); + return 0; +} + +/* TODO: See how this can be optimized */ +static CHECK_RESULT int asm_ensure_capacity(Asm *self, usize size) { + usize current_offset; + current_offset = (u8*)self->code_it - (u8*)self->code; + if(current_offset + size > self->size) { + void *new_mem; + usize new_size; + new_size = self->size + am_pagesize(); + new_mem = mmap(NULL, new_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + if(self->code == MAP_FAILED) + return -errno; + + am_memcpy(new_mem, self->code, self->size); + self->code = new_mem; + self->size = new_size; + self->code_it = (u8*)self->code + current_offset; + } + return 0; +} + +static isize asm_get_capacity_left(Asm *self) { + return (isize)self->size - (isize)((u8*)self->code_it - (u8*)self->code); +} + +int asm_nop(Asm *self) { + return_if_error(asm_ensure_capacity(self, 1)); + *self->code_it++ = 0x90; + return 0; +} + +static i32 abs_i32(i32 value) { + return value >= 0 ? value : -value; +} + +/* +TODO: Implement 1 and 2 byte displacement? +There has to be at least 6 bytes left in the asm buffer before calling this function. +*/ +static void asm_rm(Asm *self, AsmPtr *mem, Reg64 reg) { + u8 rm_byte; + u8 disp_bytes; + assert(asm_get_capacity_left(self) >= 6); + if((int)mem->index != -1) { + u8 sib_offset; + if(mem->disp == 0) { + rm_byte = 0x04; + disp_bytes = 0; + } else if(abs_i32(mem->disp) <= INT8_MAX) { + rm_byte = 0x44; + disp_bytes = 1; + } else { + rm_byte = 0x84; + disp_bytes = 4; + } + + #ifdef DEBUG + if(mem->scale != 0 && mem->scale != 2 && mem->scale != 4 && mem->scale != 8) { + amal_log_error("Invalid scale %d, expected 0, 2, 4, or 8", mem->scale); + assert(bool_false); + } + #endif + assert(mem->base != RBP && "TODO: Implement RBP base for sib byte. RBP is special and requires different logic"); + sib_offset = (mem->scale << 5) + 8*mem->index + mem->base; + + *self->code_it++ = rm_byte; + *self->code_it++ = sib_offset; + } else { + if(mem->disp == 0) { + if(mem->base == RBP) { + rm_byte = 0x45; + disp_bytes = 1; + } else { + rm_byte = mem->base; + disp_bytes = 0; + } + } else if(abs_i32(mem->disp) <= INT8_MAX) { + rm_byte = 0x40 + mem->base; + disp_bytes = 1; + } else { + rm_byte = 0x80 + mem->base; + disp_bytes = 4; + } + *self->code_it++ = (reg << 3) | rm_byte; + } + + am_memcpy(self->code_it, &mem->disp, disp_bytes); + self->code_it += disp_bytes; +} + +/* There has to be at least 1 byte left in the asm buffer before calling this function. */ +static void asm_rr(Asm *self, Reg64 dst, Reg64 src) { + assert(asm_get_capacity_left(self) >= 1); + *self->code_it++ = 0xC0 + dst + 8*src; +} + +/* TODO: Implement 1 and 2 byte immediate? */ +int asm_mov_mi(Asm *self, AsmPtr *dst, i32 immediate) { + /* 12 bytes is the maximum size of the instruction. We don't how how large it will be so we prepare for the largest size */ + return_if_error(asm_ensure_capacity(self, 12)); + *self->code_it++ = REX_W; + *self->code_it++ = 0xC7; + asm_rm(self, dst, 0); + am_memcpy(self->code_it, &immediate, sizeof(immediate)); + self->code_it += sizeof(immediate); + return 0; +} + +int asm_mov_mr(Asm *self, AsmPtr *dst, Reg64 src) { + /* 8 bytes is the maximum size of the instruction. We don't how how large it will be so we prepare for the largest size */ + return_if_error(asm_ensure_capacity(self, 8)); + *self->code_it++ = REX_W; + *self->code_it++ = 0x89; + asm_rm(self, dst, src); + return 0; +} + +int asm_mov_rm(Asm *self, Reg64 dst, AsmPtr *src) { + /* 8 bytes is the maximum size of the instruction. We don't how how large it will be so we prepare for the largest size */ + return_if_error(asm_ensure_capacity(self, 8)); + *self->code_it++ = REX_W; + *self->code_it++ = 0x8B; + asm_rm(self, src, dst); + return 0; +} + +int asm_mov_ri(Asm *self, Reg64 dst, i64 immediate) { + /* 10 bytes is the maximum size of the instruction. We don't how how large it will be so we prepare for the largest size */ + return_if_error(asm_ensure_capacity(self, 10)); + *self->code_it++ = REX_W; + *self->code_it++ = 0xB8 + dst; + am_memcpy(self->code_it, &immediate, sizeof(immediate)); + self->code_it += sizeof(immediate); + return 0; +} + +int asm_mov_rr(Asm *self, Reg64 dst, Reg64 src) { + /* 3 bytes is the maximum size of the instruction. We don't how how large it will be so we prepare for the largest size */ + return_if_error(asm_ensure_capacity(self, 3)); + *self->code_it++ = REX_W; + *self->code_it++ = 0x89; + asm_rr(self, dst, src); + return 0; +} + +int asm_add_rr(Asm *self, Reg64 dst, Reg64 src) { + /* 3 bytes is the maximum size of the instruction. We don't how how large it will be so we prepare for the largest size */ + return_if_error(asm_ensure_capacity(self, 3)); + *self->code_it++ = REX_W; + *self->code_it++ = 0x01; + asm_rr(self, dst, src); + return 0; +} + +int asm_sub_rr(Asm *self, Reg64 dst, Reg64 src) { + /* 3 bytes is the maximum size of the instruction. We don't how how large it will be so we prepare for the largest size */ + return_if_error(asm_ensure_capacity(self, 3)); + *self->code_it++ = REX_W; + *self->code_it++ = 0x29; + asm_rr(self, dst, src); + return 0; +} + +int asm_imul_rr(Asm *self, Reg64 dst, Reg64 src) { + /* 3 bytes is the maximum size of the instruction. We don't how how large it will be so we prepare for the largest size */ + return_if_error(asm_ensure_capacity(self, 4)); + *self->code_it++ = REX_W; + *self->code_it++ = 0x0F; + *self->code_it++ = 0xAF; + asm_rr(self, dst, src); + return 0; +} + +int asm_pushr(Asm *self, Reg64 reg) { + return_if_error(asm_ensure_capacity(self, 1)); + *self->code_it++ = 0x50 + reg; + return 0; +} + +int asm_popr(Asm *self, Reg64 reg) { + return_if_error(asm_ensure_capacity(self, 1)); + *self->code_it++ = 0x58 + reg; + return 0; +} + +/* /r */ +#define DEFINE_INS_RM(mnemonic, opcode) \ +int asm_##mnemonic##_rm32(Asm *self, Reg32 dst, Reg32 src) { \ + return_if_error(asm_ensure_capacity(self, 2)); \ + *self->code_it++ = opcode; \ + *self->code_it++ = 0xC0 + 8*dst + src; \ + return 0; \ +} \ + \ +int asm_##mnemonic##_rm64(Asm *self, Reg64 dst, Reg64 src) { \ + return_if_error(asm_ensure_capacity(self, 1)); \ + *self->code_it++ = REX_W; \ + return asm_##mnemonic##_rm32(self, (Reg32)dst, (Reg32)src); \ +} + +DEFINE_INS_RM(mov, 0x8B) +DEFINE_INS_RM(add, 0x03) +DEFINE_INS_RM(sub, 0x2B) +DEFINE_INS_RM(and, 0x23) +DEFINE_INS_RM(or, 0x0B) +DEFINE_INS_RM(xor, 0x33) +DEFINE_INS_RM(cmp, 0x3B) + +/* + /number + The number is called the extension, a number from 0 to 7; + It's a number used to extend the opcode type, since the instruction only uses + one register the other register can be encoded for that. +*/ +#define DEFINE_INS_EXT_IMM(mnemonic, extension) \ +int asm_##mnemonic##_rm32_imm(Asm *self, Reg32 reg, i32 immediate) { \ + if(abs_i32(immediate) <= INT8_MAX) { \ + return_if_error(asm_ensure_capacity(self, 3)); \ + *self->code_it++ = 0x83; \ + *self->code_it++ = 0xC0 + 8*extension + reg; \ + *self->code_it++ = (u8)immediate; \ + } else { \ + return_if_error(asm_ensure_capacity(self, 6)); \ + *self->code_it++ = 0x81; \ + *self->code_it++ = 0xC0 + 8*extension + reg; \ + am_memcpy(self->code_it, &immediate, sizeof(immediate)); \ + self->code_it += sizeof(immediate); \ + } \ + return 0; \ +} \ + \ +int asm_##mnemonic##_rm64_imm(Asm *self, Reg64 reg, i32 immediate) { \ + return_if_error(asm_ensure_capacity(self, 1)); \ + *self->code_it++ = REX_W; \ + return asm_##mnemonic##_rm32_imm(self, (Reg32)reg, immediate); \ +} + +DEFINE_INS_EXT_IMM(add, 0) +DEFINE_INS_EXT_IMM(or, 1) +DEFINE_INS_EXT_IMM(adc, 2) +DEFINE_INS_EXT_IMM(sbb, 3) +DEFINE_INS_EXT_IMM(and, 4) +DEFINE_INS_EXT_IMM(sub, 5) +DEFINE_INS_EXT_IMM(xor, 6) +DEFINE_INS_EXT_IMM(cmp, 7) + +/* + /number + The number is called the extension, a number from 0 to 7; + It's a number used to extend the opcode type, since the instruction only uses + one register the other register can be encoded for that. +*/ +#define DEFINE_INS_SHIFT_IMM8(mnemonic, extension) \ +int asm_##mnemonic##_rm32_imm(Asm *self, Reg32 reg, i8 immediate) { \ + if(immediate == 1) { \ + return_if_error(asm_ensure_capacity(self, 2)); \ + *self->code_it++ = 0xC1; \ + *self->code_it++ = 0xC0 + 8*reg + extension; \ + } else { \ + return_if_error(asm_ensure_capacity(self, 3)); \ + *self->code_it++ = 0xD1; \ + *self->code_it++ = 0xC0 + 8*reg + extension; \ + *self->code_it++ = immediate; \ + } \ + return 0; \ +} \ + \ +int asm_##mnemonic##_rm64_imm(Asm *self, Reg64 reg, i8 immediate) { \ + return_if_error(asm_ensure_capacity(self, 1)); \ + *self->code_it++ = REX_W; \ + return asm_##mnemonic##_rm32_imm(self, (Reg32)reg, immediate); \ +} + +DEFINE_INS_SHIFT_IMM8(rol, 0) +DEFINE_INS_SHIFT_IMM8(ror, 1) +DEFINE_INS_SHIFT_IMM8(rcl, 2) +DEFINE_INS_SHIFT_IMM8(rcr, 3) +DEFINE_INS_SHIFT_IMM8(shl, 4) +DEFINE_INS_SHIFT_IMM8(shr, 5) +/*DEFINE_INS_SHIFT_IMM8(shl, 6)*/ +DEFINE_INS_SHIFT_IMM8(sar, 7) + +int asm_ret(Asm *self, u16 bytes) { + if(bytes == 0) { + return_if_error(asm_ensure_capacity(self, 1)); + *self->code_it++ = 0xC3; + } else { + return_if_error(asm_ensure_capacity(self, 3)); + *self->code_it++ = 0xC2; + am_memcpy(self->code_it, &bytes, sizeof(bytes)); + } + return 0; +}
\ No newline at end of file @@ -23,8 +23,8 @@ static void resolve_data_init(AstResolveData *self) { self->type = NULL; } -int ast_create(ScopedAllocator *allocator, void *value, AstType type, Ast **result) { - return_if_error(scoped_allocator_alloc(allocator, sizeof(Ast), (void**)result)); +int ast_create(ArenaAllocator *allocator, void *value, AstType type, Ast **result) { + return_if_error(arena_allocator_alloc(allocator, sizeof(Ast), (void**)result)); (*result)->value.data = value; (*result)->type = type; resolve_data_init(&(*result)->resolve_data); @@ -75,18 +75,23 @@ static BufferView ast_get_code_reference(Ast *self) { return ast_get_name(self); } -int funcdecl_init(FunctionDecl *self, FunctionSignature *signature, Scope *parent, ScopedAllocator *allocator) { +void function_signature_init(FunctionSignature *self) { + self->params = 0; + self->resolved = bool_false; +} + +int funcdecl_init(FunctionDecl *self, FunctionSignature *signature, Scope *parent, ArenaAllocator *allocator) { self->signature = signature; self->ssa_func_index = 0; return scope_init(&self->body, parent, allocator); } -int funccall_init(FunctionCall *self, BufferView name, ScopedAllocator *allocator) { +int funccall_init(FunctionCall *self, BufferView name, ArenaAllocator *allocator) { variable_init(&self->func, name); return buffer_init(&self->args, allocator); } -int structdecl_init(StructDecl *self, Scope *parent, ScopedAllocator *allocator) { +int structdecl_init(StructDecl *self, Scope *parent, ArenaAllocator *allocator) { return scope_init(&self->body, parent, allocator); } @@ -139,24 +144,24 @@ void binop_init(Binop *self) { self->grouped = bool_false; } -int if_statement_init(IfStatement *self, Scope *parent, ScopedAllocator *allocator) { +int if_statement_init(IfStatement *self, Scope *parent, ArenaAllocator *allocator) { self->condition = NULL; self->else_if_stmt = NULL; return scope_init(&self->body, parent, allocator); } -int else_if_statement_init(ElseIfStatement *self, Scope *parent, ScopedAllocator *allocator) { +int else_if_statement_init(ElseIfStatement *self, Scope *parent, ArenaAllocator *allocator) { self->condition = NULL; self->next_else_if_stmt = NULL; return scope_init(&self->body, parent, allocator); } -int while_statement_init(WhileStatement *self, Scope *parent, ScopedAllocator *allocator) { +int while_statement_init(WhileStatement *self, Scope *parent, ArenaAllocator *allocator) { self->condition = NULL; return scope_init(&self->body, parent, allocator); } -int scope_init(Scope *self, Scope *parent, ScopedAllocator *allocator) { +int scope_init(Scope *self, Scope *parent, ArenaAllocator *allocator) { return_if_error(buffer_init(&self->ast_objects, allocator)); return_if_error(hash_map_init(&self->named_objects, allocator, sizeof(Ast*), hash_map_compare_string, amal_hash_string)); self->parent = parent; @@ -164,7 +169,7 @@ int scope_init(Scope *self, Scope *parent, ScopedAllocator *allocator) { return 0; } -int file_scope_reference_init(FileScopeReference *self, BufferView canonical_path, ScopedAllocator *allocator) { +int file_scope_reference_init(FileScopeReference *self, BufferView canonical_path, ArenaAllocator *allocator) { char null_terminator; null_terminator = '\0'; self->parser = NULL; @@ -273,15 +278,17 @@ static Ast* scope_get_resolved_variable(Scope *self, AstCompilerContext *context static void function_signature_resolve(FunctionSignature *self, AstCompilerContext *context) { /* TODO: Implement */ + if(self->resolved) + return; + self->resolved = bool_true; (void)self; (void)context; } static void variable_resolve(Variable *self, AstCompilerContext *context, AstResolveData *resolve_data) { - if(!self->resolved_var) { + if(!self->resolved_var) self->resolved_var = scope_get_resolved_variable(context->scope, context, self->name); - resolve_data->type = self->resolved_var->resolve_data.type; - } + resolve_data->type = self->resolved_var->resolve_data.type; } static LhsExpr* variable_get_resolved_type(Variable *self) { @@ -289,15 +296,18 @@ static LhsExpr* variable_get_resolved_type(Variable *self) { return self->resolved_var->value.lhs_expr; } -static void variable_type_resolve(VariableType *self, AstCompilerContext *context, AstResolveData *resolve_data) { - switch(self->type) { +static void variable_type_resolve(LhsExpr *self, AstCompilerContext *context, AstResolveData *resolve_data) { + VariableType *lhs_expr_type; + lhs_expr_type = &self->type; + switch(lhs_expr_type->type) { case VARIABLE_TYPE_NONE: return; case VARIABLE_TYPE_VARIABLE: - variable_resolve(self->value.variable, context, resolve_data); + variable_resolve(lhs_expr_type->value.variable, context, resolve_data); break; case VARIABLE_TYPE_SIGNATURE: - function_signature_resolve(self->value.signature, context); + function_signature_resolve(lhs_expr_type->value.signature, context); + resolve_data->type = self; break; } } @@ -333,13 +343,11 @@ static LhsExpr* lhsexpr_resolve_rhs(LhsExpr *self, AstCompilerContext *context) static void lhsexpr_resolve(Ast *ast, AstCompilerContext *context) { LhsExpr *self; - LhsExpr *rhs_resolve_type; assert(ast->type == AST_LHS); self = ast->value.lhs_expr; - rhs_resolve_type = NULL; - variable_type_resolve(&self->type, context, &ast->resolve_data); + variable_type_resolve(self, context, &ast->resolve_data); /* TODO: When parameters and return types are implemented, AST_RESOLVE_END should be set after @@ -347,8 +355,22 @@ static void lhsexpr_resolve(Ast *ast, AstCompilerContext *context) { be allowed but recursive function calls still require parameters and return types to be known. */ if(self->rhs_expr) { - if(self->rhs_expr->type == AST_FUNCTION_DECL) + LhsExpr *rhs_resolve_type; + if(self->rhs_expr->type == AST_FUNCTION_DECL) { + /* + The function declaration itself always resolves the signature, but we also do it here because we + want to have the signature solved before setting the lhs expr as solved. Also function signatures can exist + without lhs expr (anonymous function). + */ + function_signature_resolve(self->rhs_expr->value.func_decl->signature, context); ast->resolve_data.status = AST_RESOLVED; + /* + If rhs is a function declaration then there is no need to wait until it has been resolved before setting the type as the type + is @self (the lhs). We still need to continue after this, so rhs can be resolved. + */ + if(!ast->resolve_data.type) + ast->resolve_data.type = self; + } rhs_resolve_type = lhsexpr_resolve_rhs(self, context); @@ -365,10 +387,8 @@ static void lhsexpr_resolve(Ast *ast, AstCompilerContext *context) { "Variable type and variable assignment type (right-hand side) do not match"); throw(AST_ERR); } - } - - if(rhs_resolve_type) ast->resolve_data.type = rhs_resolve_type; + } } static LhsExpr* binop_get_lhs_expr(Binop *self) { @@ -443,18 +463,20 @@ static void import_resolve(Ast *ast, AstCompilerContext *context) { static Scope* lhsexpr_get_scope(LhsExpr *self) { AstValue value; - 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; - default: - break; + if(self->rhs_expr) { + 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; + default: + break; + } } - assert(bool_false && "Expected lhsexpr_get_scope to only be called for function decl, struct decl and import"); + assert(bool_false && "Expected lhsexpr_get_scope to only be called for non-extern function declaration, struct declaration and import"); return NULL; } @@ -466,9 +488,20 @@ static Parser* get_resolved_type_parser(Ast *self) { static void funcdecl_resolve(FunctionDecl *self, AstCompilerContext *context) { /* TODO: Implement parameters and return types */ + function_signature_resolve(self->signature, context); scope_resolve(&self->body, context); } +/* + 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. +*/ +static bool is_func_decl(Ast *self) { + const LhsExpr *resolved_type = self->resolve_data.type; + 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; @@ -477,7 +510,7 @@ static void funccall_resolve(Ast *self, AstCompilerContext *context) { func_call = self->value.func_call; variable_resolve(&func_call->func, context, &self->resolve_data); /* Attemping to use call syntax (variable_name ( ) ) with a variable that is not a function */ - if(self->resolve_data.type->rhs_expr->type != AST_FUNCTION_DECL) { + if(!is_func_decl(self)) { Parser *caller_parser; Parser *callee_parser; BufferView callee_code_ref; @@ -514,6 +547,12 @@ static void structfield_resolve(Ast *self, AstCompilerContext *context) { variable_resolve(&struct_field->type, context, &self->resolve_data); } +static bool is_struct_decl(Ast *self) { + const LhsExpr *resolved_type = self->resolve_data.type; + assert(self->resolve_data.status == AST_RESOLVED); + return resolved_type->rhs_expr && resolved_type->rhs_expr->type == AST_STRUCT_DECL; +} + static void binop_resolve_dot_access(Ast *ast, AstCompilerContext *context) { Binop *self; Scope *lhs_scope; @@ -541,7 +580,7 @@ static void binop_resolve_dot_access(Ast *ast, AstCompilerContext *context) { caller_code_ref = ast_get_code_reference(self->rhs); callee_code_ref = self->rhs->resolve_data.type->var_name; - if(self->lhs->resolve_data.type->rhs_expr->type != AST_STRUCT_DECL) { + if(!is_struct_decl(self->lhs)) { parser_print_error(caller_parser, caller_code_ref.data, "Can only access field of structs"); /* TODO: use tokenizer_print_note, once it has been added */ /* TODO: Print type */ @@ -583,6 +622,8 @@ static void binop_resolve(Ast *ast, AstCompilerContext *context) { /* TODO: For this first error, only print the line without a reference to code. This requires change in tokenizer_print_error to be able to take a line as reference. + + TODO: Use note for the additional information instead of error. */ Parser *parser; parser = scope_get_parser(context->scope); @@ -597,6 +638,14 @@ static void binop_resolve(Ast *ast, AstCompilerContext *context) { "Right-hand side is of type %.*s", self->rhs->resolve_data.type->var_name.size, self->rhs->resolve_data.type->var_name.data); throw(AST_ERR); + } else if(!is_arithmetic_type(self->lhs->resolve_data.type, context->compiler)) { /* TODO: Optimize this? store arithmetic type in the LhsExpr itself? */ + /* TODO: Point the error at the binop instead of LHS */ + Parser *parser; + parser = scope_get_parser(context->scope); + parser_print_error(parser, ast_get_code_reference(self->lhs).data, + "Arithmetic operation can only be performed with the types i8, u8, i16, u16, i32, u32, i64, u64, isize and usize", + self->lhs->resolve_data.type->var_name.size, self->lhs->resolve_data.type->var_name.data); + throw(AST_ERR); } ast->resolve_data.type = self->lhs->resolve_data.type; } @@ -655,9 +704,9 @@ void ast_resolve(Ast *self, AstCompilerContext *context) { number = self->value.number; /* TODO: Support other number types */ if(number->is_integer) - self->resolve_data.type = context->compiler->default_types.i64; + self->resolve_data.type = (LhsExpr*)context->compiler->default_types.i64; else - self->resolve_data.type = context->compiler->default_types.f64; + self->resolve_data.type = (LhsExpr*)context->compiler->default_types.f64; break; } case AST_FUNCTION_DECL: @@ -684,7 +733,7 @@ void ast_resolve(Ast *self, AstCompilerContext *context) { break; case AST_STRING: /* TODO: Convert special combinations. For example \n to newline */ - self->resolve_data.type = context->compiler->default_types.str; + self->resolve_data.type = (LhsExpr*)context->compiler->default_types.str; break; case AST_VARIABLE: variable_resolve(self->value.variable, context, &self->resolve_data); diff --git a/src/bytecode/bytecode.c b/src/bytecode/bytecode.c index 9bf5f24..ffcd2e0 100644 --- a/src/bytecode/bytecode.c +++ b/src/bytecode/bytecode.c @@ -18,7 +18,7 @@ throw(return_if_result); \ } while(0) -int bytecode_init(Bytecode *self, ScopedAllocator *allocator) { +int bytecode_init(Bytecode *self, ArenaAllocator *allocator) { return buffer_init(&self->data, allocator); } @@ -37,8 +37,8 @@ static CHECK_RESULT usize ssa_extract_form2(u8 *instruction_data, SsaInsForm2 *r static CHECK_RESULT usize ssa_extract_func_start(u8 *instruction_data, SsaInsFuncStart *result) { am_memcpy(&result->func_index, instruction_data, sizeof(result->func_index)); - am_memcpy(&result->num_args, instruction_data + sizeof(result->func_index), sizeof(result->num_args)); - return sizeof(result->func_index) + sizeof(result->num_args); + am_memcpy(&result->num_registers, instruction_data + sizeof(result->func_index), sizeof(result->num_registers)); + return sizeof(result->func_index) + sizeof(result->num_registers); } static CHECK_RESULT usize ssa_extract_func_call(u8 *instruction_data, SsaInsFuncCall *result) { @@ -109,7 +109,7 @@ void add_strings(BytecodeCompilerContext *self) { throw_if_error(buffer_append(instructions, &strings_size, sizeof(u32))); for(; string != strings_end; ++string) { throw_if_error(buffer_append(instructions, &string->size, sizeof(u16))); - throw_if_error(buffer_append(instructions, &string->data, string->size)); + throw_if_error(buffer_append(instructions, string->data, string->size)); } } @@ -189,6 +189,20 @@ static void add_ins6(BytecodeCompilerContext *self, AmalOpcode opcode, u8 dst_re fputc('\n', stderr); } +static void add_ins7(BytecodeCompilerContext *self, AmalOpcode opcode, u16 idx, u8 arg, const char *fmt) { + Buffer *instructions; + size_t index; + instructions = &self->bytecode.data; + index = instructions->size; + + throw_if_error(buffer_append_empty(instructions, sizeof(AmalOpcodeType) + sizeof(idx) + sizeof(arg))); + instructions->data[index] = opcode; + memcpy(instructions->data + index + sizeof(AmalOpcodeType), &idx, sizeof(idx)); + instructions->data[index + sizeof(AmalOpcodeType) + sizeof(idx)] = arg; + fprintf(stderr, fmt, idx, arg); + fputc('\n', stderr); +} + #if 0 #define NUM_MAX_REGS 256 #define NUM_MAX_FUNC_ARGS 32 @@ -397,11 +411,21 @@ static void add_instructions(BytecodeCompilerContext *self) { add_ins5(self, AMAL_OP_SUB, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "sub r%d, r%d, r%d"); break; } + case SSA_IMUL: { + instruction += ssa_extract_form2(instruction, &ssa_ins_form2); + add_ins5(self, AMAL_OP_IMUL, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "imul r%d, r%d, r%d"); + break; + } case SSA_MUL: { instruction += ssa_extract_form2(instruction, &ssa_ins_form2); add_ins5(self, AMAL_OP_MUL, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "mul r%d, r%d, r%d"); break; } + case SSA_IDIV: { + instruction += ssa_extract_form2(instruction, &ssa_ins_form2); + add_ins5(self, AMAL_OP_IDIV, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "idiv r%d, r%d, r%d"); + break; + } case SSA_DIV: { instruction += ssa_extract_form2(instruction, &ssa_ins_form2); add_ins5(self, AMAL_OP_DIV, ssa_ins_form2.result, ssa_ins_form2.lhs, ssa_ins_form2.rhs, "div r%d, r%d, r%d"); @@ -414,11 +438,11 @@ static void add_instructions(BytecodeCompilerContext *self) { } case SSA_FUNC_START: { instruction += ssa_extract_func_start(instruction, &ssa_ins_func_start); - add_ins1(self, AMAL_OP_FUNC_START, "func_start"); + add_ins4(self, AMAL_OP_FUNC_START, ssa_ins_func_start.num_registers, "func_start %u"); break; } case SSA_FUNC_END: { - add_ins1(self, AMAL_OP_FUNC_START, "func_end"); + add_ins1(self, AMAL_OP_FUNC_END, "func_end"); break; } case SSA_PUSH: { @@ -429,7 +453,6 @@ static void add_instructions(BytecodeCompilerContext *self) { break; } case SSA_CALL: { - /* TODO: Add args, using number of bytes to pop after function call. */ /* TODO: Pass return register to function. The register should be a pointer that has the size of the function return values so the return values can fit in it. @@ -443,7 +466,8 @@ static void add_instructions(BytecodeCompilerContext *self) { is defined as the size of all previous files' number of functions. */ instruction += ssa_extract_func_call(instruction, &ssa_ins_func_call); - add_ins4(self, AMAL_OP_CALL, ssa_ins_func_call.func_decl->ssa_func_index, "call %d"); + /* TODO: Replace 0 with the number of arguments */ + add_ins7(self, AMAL_OP_CALL, ssa_ins_func_call.func_decl->ssa_func_index, 0, "call %d, %d"); break; } case SSA_JUMP_ZERO: { @@ -456,9 +480,6 @@ static void add_instructions(BytecodeCompilerContext *self) { add_ins4(self, AMAL_OP_JMP, ssa_ins_jump.jump_offset, "jmp %d"); break; } - default: - amal_log_error("Instruction not yet implemented: %d", ins); - assert(bool_false && "Instruction not yet implemented"); } } diff --git a/src/compiler.c b/src/compiler.c index 05fae78..8c3266c 100644 --- a/src/compiler.c +++ b/src/compiler.c @@ -29,10 +29,10 @@ static CHECK_RESULT int create_default_type(amal_compiler *compiler, const char StructDecl *struct_decl; Ast *expr; - return_if_error(scoped_allocator_alloc(&compiler->allocator, sizeof(StructDecl), (void**)&struct_decl)); + 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)); - return_if_error(scoped_allocator_alloc(&compiler->allocator, sizeof(LhsExpr), (void**)lhs_expr)); + return_if_error(arena_allocator_alloc(&compiler->allocator, sizeof(LhsExpr), (void**)lhs_expr)); lhsexpr_init(*lhs_expr, bool_true, bool_true, bool_true, create_buffer_view(name, strnlen(name, PATH_MAX))); return_if_error(ast_create(&compiler->allocator, struct_decl, AST_STRUCT_DECL, &(*lhs_expr)->rhs_expr)); return_if_error(ast_create(&compiler->allocator, *lhs_expr, AST_LHS, &expr)); @@ -42,22 +42,59 @@ static CHECK_RESULT int create_default_type(amal_compiler *compiler, const char } 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(compiler, "i8", (LhsExpr**)&compiler->default_types.i8)); + return_if_error(create_default_type(compiler, "i16", (LhsExpr**)&compiler->default_types.i16)); + return_if_error(create_default_type(compiler, "i32", (LhsExpr**)&compiler->default_types.i32)); + return_if_error(create_default_type(compiler, "i64", (LhsExpr**)&compiler->default_types.i64)); + return_if_error(create_default_type(compiler, "u8", (LhsExpr**)&compiler->default_types.u8)); + return_if_error(create_default_type(compiler, "u16", (LhsExpr**)&compiler->default_types.u16)); + return_if_error(create_default_type(compiler, "u32", (LhsExpr**)&compiler->default_types.u32)); + return_if_error(create_default_type(compiler, "u64", (LhsExpr**)&compiler->default_types.u64)); + return_if_error(create_default_type(compiler, "isize", (LhsExpr**)&compiler->default_types.isize)); + return_if_error(create_default_type(compiler, "usize", (LhsExpr**)&compiler->default_types.usize)); + return_if_error(create_default_type(compiler, "f32", (LhsExpr**)&compiler->default_types.f32)); + return_if_error(create_default_type(compiler, "f64", (LhsExpr**)&compiler->default_types.f64)); + return_if_error(create_default_type(compiler, "str", (LhsExpr**)&compiler->default_types.str)); + + compiler->default_types.arithmetic_types[0] = compiler->default_types.i8; + compiler->default_types.arithmetic_types[1] = compiler->default_types.u8; + compiler->default_types.arithmetic_types[2] = compiler->default_types.i16; + compiler->default_types.arithmetic_types[3] = compiler->default_types.u16; + compiler->default_types.arithmetic_types[4] = compiler->default_types.i32; + compiler->default_types.arithmetic_types[5] = compiler->default_types.u32; + compiler->default_types.arithmetic_types[6] = compiler->default_types.i64; + compiler->default_types.arithmetic_types[7] = compiler->default_types.u64; + compiler->default_types.arithmetic_types[8] = compiler->default_types.isize; + compiler->default_types.arithmetic_types[9] = compiler->default_types.usize; + + compiler->default_types.i8->is_signed = bool_true; + compiler->default_types.u8->is_signed = bool_false; + compiler->default_types.i16->is_signed = bool_true; + compiler->default_types.u16->is_signed = bool_false; + compiler->default_types.i32->is_signed = bool_true; + compiler->default_types.u32->is_signed = bool_false; + compiler->default_types.i64->is_signed = bool_true; + compiler->default_types.u64->is_signed = bool_false; + compiler->default_types.isize->is_signed = bool_true; + compiler->default_types.usize->is_signed = bool_false; + compiler->default_types.f32->is_signed = bool_true; + compiler->default_types.f64->is_signed = bool_true; + compiler->default_types.str->is_signed = bool_false; return 0; } +bool is_arithmetic_type(LhsExpr *expr, amal_compiler *compiler) { + usize i; + const amal_default_types *default_types; + default_types = &compiler->default_types; + + for(i = 0; i < NUM_ARITHMETIC_TYPES; ++i) { + if(expr == (LhsExpr*)default_types->arithmetic_types[i]) + return bool_true; + } + return bool_false; +} + void amal_compiler_options_init(amal_compiler_options *self) { self->error_callback = NULL; self->error_callback_userdata = NULL; @@ -89,12 +126,12 @@ static CHECK_RESULT int amal_compiler_init(amal_compiler *self, const amal_compi self->generic_work_object_index = 0; amal_mutex_init(&self->mutex); - return_if_error(scoped_allocator_init(&self->allocator)); + return_if_error(arena_allocator_init(&self->allocator)); cleanup_if_error(scope_init(&self->root_scope, NULL, &self->allocator)); cleanup_if_error(buffer_init(&self->parsers, &self->allocator)); cleanup_if_error(buffer_init(&self->queued_files, &self->allocator)); cleanup_if_error(hash_map_init(&self->file_scopes, &self->allocator, sizeof(FileScopeReference*), hash_map_compare_string, amal_hash_string)); - cleanup_if_error(scoped_allocator_alloc(&self->allocator, + cleanup_if_error(arena_allocator_alloc(&self->allocator, self->usable_thread_count * sizeof(ParserThreadData), (void**)&self->threads)); for(i = 0; i < self->usable_thread_count; ++i) @@ -114,7 +151,7 @@ void amal_compiler_deinit(amal_compiler *self) { } amal_mutex_deinit(&self->mutex); - scoped_allocator_deinit(&self->allocator); + arena_allocator_deinit(&self->allocator); } typedef enum { @@ -145,7 +182,7 @@ typedef struct { ThreadWorkType type; } ThreadWorkData; -static CHECK_RESULT int amal_compiler_load_in_this_thread(amal_compiler *compiler, FileScopeReference *file_scope, ScopedAllocator *allocator) { +static CHECK_RESULT int amal_compiler_load_in_this_thread(amal_compiler *compiler, FileScopeReference *file_scope, ArenaAllocator *allocator) { Parser *parser; int result; BufferView filepath; @@ -153,7 +190,7 @@ static CHECK_RESULT int amal_compiler_load_in_this_thread(amal_compiler *compile filepath = create_buffer_view(file_scope->canonical_path.data, file_scope->canonical_path.size); amal_log_info("Started parsing %.*s", filepath.size, filepath.data); - return_if_error(scoped_allocator_alloc(allocator, sizeof(Parser), (void**)&parser)); + return_if_error(arena_allocator_alloc(allocator, sizeof(Parser), (void**)&parser)); return_if_error(parser_init(parser, compiler, allocator)); file_scope->parser = parser; return_if_error(parser_parse_file(parser, filepath)); @@ -229,7 +266,7 @@ static CHECK_RESULT int thread_generate_ssa(Parser *parser) { SsaCompilerContext compiler_context; int result; - return_if_error(scoped_allocator_alloc(parser->allocator, sizeof(Ssa), (void**)&compiler_context.ssa)); + return_if_error(arena_allocator_alloc(parser->allocator, sizeof(Ssa), (void**)&compiler_context.ssa)); return_if_error(ssa_init(compiler_context.ssa, parser->allocator)); compiler_context.compiler = parser->compiler; parser->ssa = compiler_context.ssa; @@ -446,7 +483,10 @@ 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 */ + /* + TODO: Copying the bytecode to the program can be done using multiple threads. + Use self->threads for that. + */ Parser **parser; Parser **parser_end; parser = buffer_begin(&self->parsers); @@ -472,7 +512,7 @@ static CHECK_RESULT int try_create_file_scope(amal_compiler *compiler, const cha path_view = create_buffer_view(result_path, result_path_size); cleanup_if_error(amal_mutex_lock(&compiler->mutex, "try_create_file_scope")); if(!hash_map_get(&compiler->file_scopes, path_view, file_scope)) { - cleanup_if_error(scoped_allocator_alloc(&compiler->allocator, sizeof(FileScopeReference), (void**)file_scope)); + cleanup_if_error(arena_allocator_alloc(&compiler->allocator, sizeof(FileScopeReference), (void**)file_scope)); /* @(*file_scope)->canonical_path won't change after this, so it's fine if allocator belongs to non-thread safe compiler instance */ cleanup_if_error(file_scope_reference_init(*file_scope, path_view, &compiler->allocator)); cleanup_if_error(hash_map_insert(&compiler->file_scopes, path_view, file_scope)); @@ -487,11 +527,11 @@ static CHECK_RESULT int try_create_file_scope(amal_compiler *compiler, const cha } int amal_compiler_load_file(amal_compiler_options *options, amal_program *program, const char *filepath) { - assert(program); - assert(filepath); amal_compiler compiler; FileScopeReference *file_scope; int result; + assert(program); + assert(filepath); return_if_error(amal_compiler_init(&compiler, options, program)); result = amal_compiler_internal_load_file(&compiler, filepath, &file_scope); amal_compiler_deinit(&compiler); diff --git a/src/parser.c b/src/parser.c index b61a968..fdf34ce 100644 --- a/src/parser.c +++ b/src/parser.c @@ -30,12 +30,12 @@ int parser_thread_data_init(ParserThreadData *self) { am_memset(&self->allocator, 0, sizeof(self->allocator)); am_memset(&self->thread, 0, sizeof(self->thread)); self->status = PARSER_THREAD_STATUS_NEW; - return scoped_allocator_init(&self->allocator); + return arena_allocator_init(&self->allocator); } void parser_thread_data_deinit(ParserThreadData *self) { ignore_result_int(amal_thread_deinit(&self->thread)); - scoped_allocator_deinit(&self->allocator); + arena_allocator_deinit(&self->allocator); } int parser_thread_data_start(ParserThreadData *self, AmalThreadCallbackFunc callback_func, void *userdata) { @@ -51,7 +51,7 @@ int parser_thread_data_join(ParserThreadData *self, void **result) { return amal_thread_join(&self->thread, result); } -int parser_init(Parser *self, amal_compiler *compiler, ScopedAllocator *allocator) { +int parser_init(Parser *self, amal_compiler *compiler, ArenaAllocator *allocator) { self->allocator = allocator; self->compiler = compiler; self->ssa = NULL; @@ -151,15 +151,15 @@ static CHECK_RESULT FunctionSignature* parser_parse_function_signature(Parser *s /* TODO: Parse return types */ } - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(FunctionSignature), (void**)&signature)); - signature->params = 0; + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(FunctionSignature), (void**)&signature)); + function_signature_init(signature); return signature; } /* VAR_TYPE_DEF = ':' TOK_IDENTIFIER|FUNC_SIGNATURE */ -static CHECK_RESULT int parser_parse_var_type_def(Parser *self, VariableType *result) { +static void parser_parse_var_type_def(Parser *self, VariableType *result) { bool match; result->type = VARIABLE_TYPE_NONE; @@ -167,14 +167,14 @@ static CHECK_RESULT int parser_parse_var_type_def(Parser *self, VariableType *re throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_COLON, &match)); if(!match) - return -1; + return; throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_IDENTIFIER, &match)); if(match) { result->type = VARIABLE_TYPE_VARIABLE; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(Variable), (void**)&result->value.variable)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(Variable), (void**)&result->value.variable)); variable_init(result->value.variable, self->tokenizer.value.identifier); - return 0; + return; } result->type = VARIABLE_TYPE_SIGNATURE; @@ -185,7 +185,6 @@ static CHECK_RESULT int parser_parse_var_type_def(Parser *self, VariableType *re "Expected type or closure signature"); throw(PARSER_UNEXPECTED_TOKEN); } - return 0; } /* @@ -232,10 +231,10 @@ static CHECK_RESULT LhsExpr* parser_parse_declaration_lhs(Parser *self) { throw_if_error(tokenizer_accept(&self->tokenizer, TOK_IDENTIFIER)); var_name = self->tokenizer.value.identifier; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(LhsExpr), (void**)&result)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(LhsExpr), (void**)&result)); lhsexpr_init(result, is_extern, is_pub, is_const, var_name); - ignore_result_int(parser_parse_var_type_def(self, &result->type)); + parser_parse_var_type_def(self, &result->type); return result; } @@ -252,7 +251,7 @@ static CHECK_RESULT FunctionDecl* parser_parse_closure(Parser *self) { if(!signature) return NULL; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(FunctionDecl), (void**)&result)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(FunctionDecl), (void**)&result)); throw_if_error(funcdecl_init(result, signature, self->current_scope, self->allocator)); self->current_scope = &result->body; @@ -277,7 +276,7 @@ static CHECK_RESULT StructDecl* parser_parse_struct_decl(Parser *self) { if(!match) return result; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(StructDecl), (void**)&result)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(StructDecl), (void**)&result)); throw_if_error(structdecl_init(result, self->current_scope, self->allocator)); self->current_scope = &result->body; @@ -329,13 +328,13 @@ static CHECK_RESULT Ast* parser_parse_function_call_or_variable(Parser *self) { throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_OPEN_PAREN, &match)); if(!match) { Variable *variable; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(Variable), (void**)&variable)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(Variable), (void**)&variable)); variable_init(variable, identifier); throw_if_error(ast_create(self->allocator, variable, AST_VARIABLE, &result)); return result; } - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(FunctionCall), (void**)&func_call)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(FunctionCall), (void**)&func_call)); throw_if_error(funccall_init(func_call, self->tokenizer.value.identifier, self->allocator)); throw_if_error(ast_create(self->allocator, func_call, AST_FUNCTION_CALL, &result)); /* Ends after TOK_CLOSING_PAREN */ @@ -355,7 +354,7 @@ static CHECK_RESULT Import* parser_parse_import(Parser *self) { if(!match) return result; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(Import), (void**)&result)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(Import), (void**)&result)); import_init(result, self->tokenizer.value.string); return result; } @@ -371,7 +370,7 @@ static CHECK_RESULT ElseIfStatement* parser_parse_else_if_statement(Parser *self if(!match) return NULL; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(ElseIfStatement), (void**)&result)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(ElseIfStatement), (void**)&result)); throw_if_error(else_if_statement_init(result, self->current_scope, self->allocator)); throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_IF, &match)); @@ -417,7 +416,7 @@ static CHECK_RESULT IfStatement* parser_parse_if_statement(Parser *self) { if(!match) return NULL; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(IfStatement), (void**)&result)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(IfStatement), (void**)&result)); throw_if_error(if_statement_init(result, self->current_scope, self->allocator)); result->condition = parser_parse_rhs_binop(self); @@ -446,7 +445,7 @@ static CHECK_RESULT WhileStatement* parser_parse_while_statement(Parser *self) { if(!match) return NULL; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(WhileStatement), (void**)&result)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(WhileStatement), (void**)&result)); throw_if_error(while_statement_init(result, self->current_scope, self->allocator)); result->condition = parser_parse_rhs_binop(self); @@ -473,7 +472,7 @@ static CHECK_RESULT Ast* parser_parse_number(Parser *self) { if(!match) return result; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(Number), (void**)&number)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(Number), (void**)&number)); number_init(number, self->tokenizer.value.integer, self->tokenizer.number_is_integer, create_buffer_view(self->tokenizer.code.data + self->tokenizer.prev_index, self->tokenizer.index - self->tokenizer.prev_index)); throw_if_error(ast_create(self->allocator, number, AST_NUMBER, &result)); @@ -491,7 +490,7 @@ static Ast* parser_parse_rhs_single_expr(Parser *self) { throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_STRING, &match)); if(match) { String *string; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(String), (void**)&string)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(String), (void**)&string)); throw_if_error(string_init(string, self->tokenizer.value.string)); throw_if_error(ast_create(self->allocator, string, AST_STRING, &result)); return result; @@ -549,7 +548,7 @@ Ast* parser_parse_rhs_binop(Parser *self) { binop_type = self->tokenizer.value.binop_type; rhs = parser_parse_rhs_binop(self); - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(Binop), (void**)&binop)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(Binop), (void**)&binop)); binop_init(binop); binop->type = binop_type; binop->lhs = lhs; @@ -645,11 +644,23 @@ Ast* parser_parse_body(Parser *self) { throw_if_error(ast_create(self->allocator, lhs_expr, AST_LHS, &result)); if(lhs_expr->is_extern) { throw_if_error(tokenizer_accept(&self->tokenizer, TOK_SEMICOLON)); + if (lhs_expr->type.type == VARIABLE_TYPE_NONE) { + self->error = tokenizer_create_error(&self->tokenizer, self->tokenizer.prev_index, "A variable can't be declared without a type or assignment"); + throw(PARSER_UNEXPECTED_TOKEN); + } return result; } else { throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_SEMICOLON, &match)); - if(match) + if(match) { + if(lhs_expr->type.type == VARIABLE_TYPE_SIGNATURE) { + self->error = tokenizer_create_error(&self->tokenizer, self->tokenizer.prev_index, "Expected function declaration. Only extern functions can have empty declarations."); + throw(PARSER_UNEXPECTED_TOKEN); + } else if (lhs_expr->type.type == VARIABLE_TYPE_NONE) { + self->error = tokenizer_create_error(&self->tokenizer, self->tokenizer.prev_index, "A variable can't be declared without a type or assignment"); + throw(PARSER_UNEXPECTED_TOKEN); + } return result; + } } throw_if_error(tokenizer_accept(&self->tokenizer, TOK_EQUALS)); @@ -683,14 +694,16 @@ Ast* parser_parse_body(Parser *self) { self->error_context = ERROR_CONTEXT_RHS_STANDALONE; rhs_expr = parser_parse_rhs(self); self->error_context = ERROR_CONTEXT_NONE; + /* Variable declaration with lhs and rhs */ if(lhs_expr) { lhs_expr->rhs_expr = rhs_expr; } else { bool match; throw_if_error(tokenizer_consume_if(&self->tokenizer, TOK_EQUALS, &match)); + /* Variable assignment */ if(match) { AssignmentExpr *assign_expr; - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(AssignmentExpr), (void**)&assign_expr)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(AssignmentExpr), (void**)&assign_expr)); throw_if_error(ast_create(self->allocator, assign_expr, AST_ASSIGN, &result)); assign_expr->lhs_expr = rhs_expr; @@ -698,6 +711,7 @@ Ast* parser_parse_body(Parser *self) { assign_expr->rhs_expr = parser_parse_rhs(self); self->error_context = ERROR_CONTEXT_NONE; } else { + /* Only rhs (for example function call, binop etc...) */ result = rhs_expr; } } @@ -721,7 +735,7 @@ Ast* parser_parse_struct_body(Parser *self) { throw_if_error(tokenizer_accept(&self->tokenizer, TOK_IDENTIFIER)); type_name = self->tokenizer.value.identifier; throw_if_error(tokenizer_accept(&self->tokenizer, TOK_SEMICOLON)); - throw_if_error(scoped_allocator_alloc(self->allocator, sizeof(LhsExpr), (void**)&struct_field)); + throw_if_error(arena_allocator_alloc(self->allocator, sizeof(LhsExpr), (void**)&struct_field)); structfield_init(struct_field, var_name, type_name); throw_if_error(ast_create(self->allocator, struct_field, AST_STRUCT_FIELD, &result)); return result; diff --git a/src/program.c b/src/program.c index 167f4c4..5e63c04 100644 --- a/src/program.c +++ b/src/program.c @@ -2,6 +2,7 @@ #include "../include/std/mem.h" #include "../include/std/alloc.h" #include "../include/std/log.h" +#include "../include/std/buffer_view.h" #include <stdio.h> #include <errno.h> #include <assert.h> @@ -19,13 +20,12 @@ typedef union { f64 floating; } NumberUnion; -int amal_program_init(amal_program *self) { - ignore_result_int(buffer_init(&self->data, NULL)); - ignore_result_int(buffer_init(&self->string_indices, NULL)); - self->intermediates_start = NULL; - self->strings_start = NULL; - self->read_index = 0; +typedef struct { + NumberType type; + NumberUnion value; +} Number; +static CHECK_RESULT int amal_program_append_header(amal_program *self) { /*doc(Bytecode header) # Header layout |Size|Name |Description | @@ -50,9 +50,37 @@ int amal_program_init(amal_program *self) { return 0; } +int amal_program_init(amal_program *self) { + ignore_result_int(buffer_init(&self->data, NULL)); + self->string_indices = NULL; + self->intermediates_start = NULL; + self->strings_start = NULL; + self->read_index = 0; + self->num_strings = 0; + self->num_intermediates = 0; + am_memset(self->reg, 0, sizeof(self->reg)); + self->stack = NULL; + self->stack_size = 4096; + am_memset(&self->asm, 0, sizeof(self->asm)); + cleanup_if_error(am_malloc(self->stack_size, (void**)&self->stack)); + cleanup_if_error(asm_init(&self->asm)); + self->stack_index = 0; + + cleanup_if_error(amal_program_append_header(self)); + return 0; + + cleanup: + amal_program_deinit(self); + return -1; +} + void amal_program_deinit(amal_program *self) { buffer_deinit(&self->data); - buffer_deinit(&self->string_indices); + am_free(self->string_indices); + self->string_indices = NULL; + am_free(self->stack); + self->stack = NULL; + asm_deinit(&self->asm); } int amal_program_append_bytecode(amal_program *self, Bytecode *bytecode) { @@ -113,6 +141,8 @@ static CHECK_RESULT int amal_program_read_intermediates(amal_program *self) { } self->intermediates_start = &self->data.data[self->read_index]; + if(intermediates_size > 0) + self->num_intermediates = intermediates_size / (sizeof(u8) + sizeof(u64)); /* read_end = self->read_index + intermediates_size; while(self->read_index < read_end) { @@ -140,10 +170,11 @@ static CHECK_RESULT int amal_program_read_strings(amal_program *self) { am_memcpy(&num_strings, &self->data.data[self->read_index], sizeof(num_strings)); self->read_index += sizeof(num_strings); + self->num_strings = num_strings; - if(buffer_append_empty(&self->string_indices, num_strings) != 0) + if(am_malloc(sizeof(u32) * num_strings, (void**)&self->string_indices) != 0) return AMAL_PROGRAM_STRING_ALLOC_FAILURE; - string_index_ptr = (u32*)self->string_indices.data; + string_index_ptr = self->string_indices; if(bytes_left_to_read(self) < sizeof(strings_size)) return AMAL_PROGRAM_INVALID_STRINGS; @@ -178,9 +209,58 @@ static CHECK_RESULT int amal_program_read_strings(amal_program *self) { 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; + + am_memcpy(&result->type, &self->intermediates_start[(sizeof(u8) + sizeof(u64)) * (usize)index], sizeof(u8)); + am_memcpy(&result->value, &self->intermediates_start[(sizeof(u8) + sizeof(u64)) * (usize)index + sizeof(u8)], sizeof(u64)); + return 0; +} + +static CHECK_RESULT int amal_program_get_data_by_index(amal_program *self, u16 index, char **result) { + char *str_ptr; + + if(index >= self->num_strings) { + amal_log_error("Data index %ld is out of range (%ld)", index, self->num_strings); + return AMAL_PROGRAM_INSTRUCTION_INVALID_DATA_INDEX; + } + + str_ptr = self->strings_start + self->string_indices[index]; + am_memcpy(result, &str_ptr, sizeof(char**)); + return 0; +} + +static CHECK_RESULT int ensure_stack_capacity_for_push(amal_program *self) { + if(self->stack_index >= self->stack_size) { + self->stack_size *= 2; + /* 4MB */ + if(self->stack_size >= (1<<22)) + return AMAL_PROGRAM_INSTRUCTION_STACK_OVERFLOW; + if(am_realloc(self->stack, self->stack_size, (void**)&self->stack) != 0) + return AMAL_PROGRAM_INSTRUCTION_STACK_OOM; + } + return 0; +} + +static i64 abs_i64(i64 value) { + return value >= 0 ? value : -value; +} + +static int assert_reg_outside_stack() { + assert(bool_false && "Register outside stack!"); + return 0; +} + static CHECK_RESULT int amal_program_read_instructions(amal_program *self) { u32 instructions_size; + u32 read_start; u32 read_end; + bool inside_func; + u16 func_num_registers; + + func_num_registers = 0; + inside_func = bool_false; if(bytes_left_to_read(self) < sizeof(instructions_size)) return AMAL_PROGRAM_INVALID_INSTRUCTIONS_SIZE; @@ -191,68 +271,296 @@ static CHECK_RESULT int amal_program_read_instructions(amal_program *self) { if(bytes_left_to_read(self) < instructions_size) return AMAL_PROGRAM_INVALID_INSTRUCTIONS_SIZE; - read_end = self->read_index + instructions_size; + /* + TODO: self->reg should be of type Number and each arithmetic operation should operate + on the type of the register. + + TODO: Currently almost all operations are performed on memory. This should be optimized + to take advantage of registers. + + TODO: Operations with memory registers could access outside the stack. Should this be checked? + */ + + #ifdef DEBUG + #define get_register_at_offset(offset) \ + (self->data.data[self->read_index + (offset)] < func_num_registers ? self->data.data[self->read_index + (offset)] * (int)sizeof(usize) + (int)sizeof(usize) : assert_reg_outside_stack()) + #else + #define get_register_at_offset(offset) (self->data.data[self->read_index + (offset)] * (int)sizeof(usize) + (int)sizeof(usize)) + #endif + + read_start = self->read_index; + read_end = read_start + instructions_size; while(self->read_index < read_end) { AmalOpcode opcode; opcode = self->data.data[self->read_index]; self->read_index += sizeof(AmalOpcodeType); switch(opcode) { - case AMAL_OP_NOP: + case AMAL_OP_NOP: { + return_if_error(asm_nop(&self->asm)); break; - case AMAL_OP_SETZ: + } + case AMAL_OP_SETZ: { + AsmPtr dst; + asm_ptr_init_disp(&dst, RBP, -(i32)get_register_at_offset(0)); + return_if_error(asm_mov_mi(&self->asm, &dst, 0)); + self->reg[(u8)self->data.data[self->read_index]] = 0; self->read_index += 1; break; - case AMAL_OP_MOV: + } + case AMAL_OP_MOV: { + AsmPtr ptr; + asm_ptr_init_disp(&ptr, RBP, -(i32)get_register_at_offset(1)); + return_if_error(asm_mov_rm(&self->asm, RAX, &ptr)); + + asm_ptr_init_disp(&ptr, RBP, -(i32)get_register_at_offset(0)); + return_if_error(asm_mov_mr(&self->asm, &ptr, RAX)); + + self->reg[(u8)self->data.data[self->read_index]] = self->reg[(u8)self->data.data[self->read_index + 1]]; self->read_index += 2; break; - case AMAL_OP_MOVI: + } + case AMAL_OP_MOVI: { + u8 dst_reg; + u16 intermediate_index; + Number number; + + dst_reg = self->reg[(u8)self->data.data[self->read_index]]; + am_memcpy(&intermediate_index, &self->data.data[self->read_index + sizeof(u8)], sizeof(intermediate_index)); + + return_if_error(amal_program_get_intermediate_by_index(self, intermediate_index, &number)); + self->reg[dst_reg] = number.value.integer; + + /* TODO: if @number is a float then use float instructions */ + if(abs_i64(number.value.integer) <= INT32_MAX) { + AsmPtr dst; + asm_ptr_init_disp(&dst, RBP, -(i32)get_register_at_offset(0)); + return_if_error(asm_mov_mi(&self->asm, &dst, number.value.integer)); + } else { + AsmPtr dst; + asm_ptr_init_disp(&dst, RBP, -(i32)get_register_at_offset(0)); + return_if_error(asm_mov_ri(&self->asm, RAX, number.value.integer)); + return_if_error(asm_mov_mr(&self->asm, &dst, RAX)); + } + + self->read_index += 3; + break; + } + case AMAL_OP_MOVD: { + u8 dst_reg; + u16 data_index; + char *data_ptr; + AsmPtr dst; + + dst_reg = self->reg[(u8)self->data.data[self->read_index]]; + am_memcpy(&data_index, &self->data.data[self->read_index + sizeof(u8)], sizeof(data_index)); + + return_if_error(amal_program_get_data_by_index(self, data_index, &data_ptr)); + self->reg[dst_reg] = (uintptr_t)data_ptr; + + asm_ptr_init_disp(&dst, RBP, -(i32)get_register_at_offset(0)); + return_if_error(asm_mov_ri(&self->asm, RAX, (uintptr_t)data_ptr)); + return_if_error(asm_mov_mr(&self->asm, &dst, RAX)); + + self->read_index += 3; + break; + } + case AMAL_OP_ADD: { + AsmPtr dst; + AsmPtr reg1; + AsmPtr reg2; + + asm_ptr_init_disp(&dst, RBP, -(i32)get_register_at_offset(0)); + asm_ptr_init_disp(®1, RBP, -(i32)get_register_at_offset(1)); + asm_ptr_init_disp(®2, RBP, -(i32)get_register_at_offset(2)); + + return_if_error(asm_mov_rm(&self->asm, RAX, ®1)); + return_if_error(asm_mov_rm(&self->asm, RCX, ®2)); + return_if_error(asm_add_rr(&self->asm, RAX, RCX)); + return_if_error(asm_mov_mr(&self->asm, &dst, RAX)); + self->read_index += 3; break; - case AMAL_OP_MOVD: + } + case AMAL_OP_SUB: { + AsmPtr dst; + AsmPtr reg1; + AsmPtr reg2; + + asm_ptr_init_disp(&dst, RBP, -(i32)get_register_at_offset(0)); + asm_ptr_init_disp(®1, RBP, -(i32)get_register_at_offset(1)); + asm_ptr_init_disp(®2, RBP, -(i32)get_register_at_offset(2)); + + return_if_error(asm_mov_rm(&self->asm, RAX, ®1)); + return_if_error(asm_mov_rm(&self->asm, RCX, ®2)); + return_if_error(asm_sub_rr(&self->asm, RAX, RCX)); + return_if_error(asm_mov_mr(&self->asm, &dst, RAX)); + self->read_index += 3; break; - case AMAL_OP_ADD: + } + case AMAL_OP_IMUL: { + AsmPtr dst; + AsmPtr reg1; + AsmPtr reg2; + + asm_ptr_init_disp(&dst, RBP, -(i32)get_register_at_offset(0)); + asm_ptr_init_disp(®1, RBP, -(i32)get_register_at_offset(1)); + asm_ptr_init_disp(®2, RBP, -(i32)get_register_at_offset(2)); + + return_if_error(asm_mov_rm(&self->asm, RAX, ®1)); + return_if_error(asm_mov_rm(&self->asm, RCX, ®2)); + return_if_error(asm_imul_rr(&self->asm, RAX, RCX)); + return_if_error(asm_mov_mr(&self->asm, &dst, RAX)); + self->read_index += 3; break; - case AMAL_OP_SUB: + } + case AMAL_OP_MUL: { + #if 0 + AsmPtr dst; + AsmPtr reg1; + AsmPtr reg2; + + asm_ptr_init_disp(&dst, RBP, -(i32)get_register_at_offset(0)); + asm_ptr_init_disp(®1, RBP, -(i32)get_register_at_offset(1)); + asm_ptr_init_disp(®2, RBP, -(i32)get_register_at_offset(2)); + + return_if_error(asm_mov_rm(&self->asm, RAX, ®1)); + return_if_error(asm_mov_rm(&self->asm, RCX, ®2)); + return_if_error(asm_mul_rr(&self->asm, RAX, RCX)); + return_if_error(asm_mov_mr(&self->asm, &dst, RAX)); + #endif + self->read_index += 3; break; - case AMAL_OP_MUL: + } + case AMAL_OP_IDIV: { self->read_index += 3; break; - case AMAL_OP_DIV: + } + case AMAL_OP_DIV: { self->read_index += 3; break; - case AMAL_OP_PUSH: + } + case AMAL_OP_PUSH: { + #if 0 + AsmPtr reg; + asm_ptr_init_disp(®, RBP, -(i32)get_register_at_offset(0)); + + return_if_error(ensure_stack_capacity_for_push(self)); + self->stack[self->stack_index] = self->reg[(u8)self->data.data[self->read_index]]; + ++self->stack_index; + return_if_error(asm_pushm(&self->asm, ®)); + #endif self->read_index += 1; break; - case AMAL_OP_PUSHI: + } + case AMAL_OP_PUSHI: { + u16 intermediate_index; + Number number; + + am_memcpy(&intermediate_index, &self->data.data[self->read_index], sizeof(intermediate_index)); + return_if_error(amal_program_get_intermediate_by_index(self, intermediate_index, &number)); + return_if_error(ensure_stack_capacity_for_push(self)); + + self->stack[self->stack_index] = number.value.integer; + ++self->stack_index; self->read_index += 2; break; - case AMAL_OP_PUSHD: + } + case AMAL_OP_PUSHD: { + u16 data_index; + char *data_ptr; + + am_memcpy(&data_index, &self->data.data[self->read_index], sizeof(data_index)); + return_if_error(amal_program_get_data_by_index(self, data_index, &data_ptr)); + return_if_error(ensure_stack_capacity_for_push(self)); + + self->stack[self->stack_index] = (uintptr_t)data_ptr; + ++self->stack_index; self->read_index += 2; break; + } case AMAL_OP_CALL: - self->read_index += 2; + /*assert(bool_false && "TODO: Implement CALL");*/ + self->read_index += 3; break; case AMAL_OP_CALLR: - self->read_index += 1; + /*assert(bool_false && "TODO: Implement CALLR");*/ + self->read_index += 2; break; - case AMAL_OP_CMP: + case AMAL_OP_CMP: { + self->reg[(u8)self->data.data[self->read_index]] = + self->reg[(u8)self->data.data[self->read_index + 1]] == self->reg[(u8)self->data.data[self->read_index + 2]]; self->read_index += 3; break; - case AMAL_OP_JZ: + } + case AMAL_OP_JZ: { + #if 0 + u8 reg; + i16 jump_offset; + u32 jump_target; + + reg = (u8)self->data.data[self->read_index]; + am_memcpy(&jump_offset, &self->data.data[self->read_index + 1], sizeof(jump_offset)); + jump_target = (isize)self->read_index + jump_offset; + if(jump_target < read_start || jump_target >= read_end) + return AMAL_PROGRAM_INSTRUCTION_ILLEGAL_JUMP_TARGET; + #endif self->read_index += 3; break; - case AMAL_OP_JMP: + } + case AMAL_OP_JMP: { + #if 0 + i16 jump_offset; + u32 jump_target; + + am_memcpy(&jump_offset, &self->data.data[self->read_index], sizeof(jump_offset)); + jump_target = (isize)self->read_index + jump_offset; + if(jump_target < read_start || jump_target >= read_end) + return AMAL_PROGRAM_INSTRUCTION_ILLEGAL_JUMP_TARGET; + #endif self->read_index += 2; break; + } case AMAL_OP_RET: + /* return_if_error(asm_ret(&self->asm, 0)); */ + assert(bool_false && "TODO: Implement RET. RET needs to restore the stack before returning"); break; - case AMAL_OP_FUNC_START: + case AMAL_OP_FUNC_START: { + assert(!inside_func); + inside_func = bool_true; + am_memcpy(&func_num_registers, &self->data.data[self->read_index], sizeof(func_num_registers)); + /* + TODO: Validate stack size, or maybe remove all validation? do we really need validation? + If we need security, we could fork the process instead. + */ + + /* + Some registers need to be preserved before entering a function scope and these registers are different on different platforms. + 32-bit: EBX, ESI, EDI, EBP + 64-bit Windows: RBX, RSI, RDI, RBP, R12-R15, XMM6-XMM15 + 64-bit Linux,BSD,Mac: RBX, RBP, R12-R15 + */ + return_if_error(asm_pushr(&self->asm, RBX)); + return_if_error(asm_pushr(&self->asm, RBP)); + return_if_error(asm_mov_rr(&self->asm, RBP, RSP)); + return_if_error(asm_sub_rm64_imm(&self->asm, RSP, func_num_registers * sizeof(usize))); + self->read_index += 2; break; - case AMAL_OP_FUNC_END: + } + case AMAL_OP_FUNC_END: { + assert(inside_func); + inside_func = bool_false; + /*assert(bool_false && "TODO: Implement FUNC_END");*/ + /* TODO: Validate FUNC_END is called for every FUNC_START, otherwise stack will be corrupted */ + /* TODO: Use mov_rr(RSP, RBP) instead? why doesn't gcc do this? */ + return_if_error(asm_mov_rr(&self->asm, RSP, RBP)); + return_if_error(asm_popr(&self->asm, RBP)); + return_if_error(asm_popr(&self->asm, RBX)); + return_if_error(asm_ret(&self->asm, 0)); break; + } } } @@ -266,7 +574,7 @@ int amal_program_run(amal_program *self) { return_if_error(amal_program_read_strings(self)); return_if_error(amal_program_read_instructions(self)); } - return AMAL_PROGRAM_OK; + return asm_execute(&self->asm); } int amal_program_save(amal_program *self, const char *filepath) { diff --git a/src/ssa/ssa.c b/src/ssa/ssa.c index 6e61bf1..b95cd10 100644 --- a/src/ssa/ssa.c +++ b/src/ssa/ssa.c @@ -50,7 +50,7 @@ SsaNumber create_ssa_float(f64 value) { return result; } -int ssa_init(Ssa *self, ScopedAllocator *allocator) { +int ssa_init(Ssa *self, ArenaAllocator *allocator) { return_if_error(buffer_init(&self->instructions, allocator)); return_if_error(hash_map_init(&self->intermediates_map, allocator, sizeof(SsaIntermediateIndex), compare_number, hash_number)); return_if_error(buffer_init(&self->intermediates, allocator)); @@ -207,7 +207,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 num_args, SsaFuncIndex *result) { +static CHECK_RESULT int ssa_ins_func_start(Ssa *self, SsaFuncIndex *result, usize *func_metadata_index) { usize index; index = self->instructions.size; @@ -215,12 +215,13 @@ static CHECK_RESULT int ssa_ins_func_start(Ssa *self, u8 num_args, SsaFuncIndex if(self->func_counter + 1 < self->func_counter) return -1; - return_if_error(buffer_append_empty(&self->instructions, sizeof(u8) + sizeof(SsaFuncIndex) + sizeof(u8))); + return_if_error(buffer_append_empty(&self->instructions, sizeof(u8) + sizeof(SsaFuncIndex) + sizeof(u16))); *result = self->func_counter++; self->instructions.data[index + 0] = SSA_FUNC_START; am_memcpy(self->instructions.data + index + 1, result, sizeof(SsaFuncIndex)); - self->instructions.data[index + 1 + sizeof(SsaFuncIndex)] = num_args; - amal_log_debug("FUNC_START f%u(%u)", *result, num_args); + *func_metadata_index = index + 1 + sizeof(SsaFuncIndex); + /* No need to add data to instructions.data here, it can contain undefined data until we set it (@ the caller) */ + amal_log_debug("FUNC_START f%u", *result); return 0; } @@ -363,9 +364,9 @@ static CHECK_RESULT SsaRegister lhsexpr_generate_ssa(Ast *self, SsaCompilerConte } else { /* TODO: Do not assign if we dont want default value */ SsaNumber number; - if(self->resolve_data.type == context->compiler->default_types.i64) + if(self->resolve_data.type == (LhsExpr*)context->compiler->default_types.i64) number = create_ssa_integer(0); - else if(self->resolve_data.type == context->compiler->default_types.f64) + else if(self->resolve_data.type == (LhsExpr*)context->compiler->default_types.f64) number = create_ssa_float(0.0); else assert(bool_false && "TODO: assign default value to reg depending on LhsExpr type"); @@ -399,23 +400,24 @@ static CHECK_RESULT SsaRegister funcdecl_generate_ssa(FunctionDecl *self, SsaCom that is reset after function end */ SsaRegister prev_reg_counter; + usize func_metadata_index; prev_reg_counter = context->ssa->reg_counter; context->ssa->reg_counter = 0; amal_log_debug("SSA funcdecl %p", self); - throw_if_error(ssa_ins_func_start(context->ssa, 0, &self->ssa_func_index)); + throw_if_error(ssa_ins_func_start(context->ssa, &self->ssa_func_index, &func_metadata_index)); scope_generate_ssa(&self->body, context); throw_if_error(ssa_ins_func_end(context->ssa)); + /* Add the number of registers used to the function metadata (FUNC_START) */ + am_memcpy(&context->ssa->instructions.data[func_metadata_index], &context->ssa->reg_counter, sizeof(u16)); context->ssa->reg_counter = prev_reg_counter; - /*assert(bool_false);*/ return 0; } static CHECK_RESULT SsaRegister funccall_generate_ssa(Ast *self, SsaCompilerContext *context) { /* TODO: Implement */ FunctionCall *func_call; - FunctionDecl *func_to_call; Ast **ast; Ast **ast_end; SsaRegister reg; @@ -430,14 +432,19 @@ static CHECK_RESULT SsaRegister funccall_generate_ssa(Ast *self, SsaCompilerCont throw_if_error(ssa_ins_push(context->ssa, arg_reg)); } - assert(self->resolve_data.type->rhs_expr->type == AST_FUNCTION_DECL); - func_to_call = self->resolve_data.type->rhs_expr->value.func_decl; - /* - TODO: Implement func reference instead of using 0. Perhaps the best way is to use function declaration pointer value? - then there is no need for mutex locks. - */ - amal_log_debug("SSA funccall %.*s, func index ptr: %p", func_call->func.name.size, func_call->func.name.data, func_to_call); - throw_if_error(ssa_ins_call(context->ssa, func_to_call, ®)); + assert((self->resolve_data.type->rhs_expr && self->resolve_data.type->rhs_expr->type == AST_FUNCTION_DECL) || + self->resolve_data.type->type.type == VARIABLE_TYPE_SIGNATURE); + if(self->resolve_data.type->is_extern) { + amal_log_error("TODO: Implement extern function call (extern function %.*s was called)", func_call->func.name.size, func_call->func.name.data); + reg = 0; + assert(bool_false && "TODO: Implement extern function call!"); + } else { + FunctionDecl *func_to_call; + func_to_call = self->resolve_data.type->rhs_expr->value.func_decl; + amal_log_debug("SSA funccall %.*s, func index ptr: %p", func_call->func.name.size, func_call->func.name.data, func_to_call); + throw_if_error(ssa_ins_call(context->ssa, func_to_call, ®)); + } + return reg; } @@ -470,16 +477,16 @@ static CHECK_RESULT SsaRegister variable_generate_ssa(Variable *self, SsaCompile return ast_generate_ssa(self->resolved_var, context); } -static SsaInstruction binop_type_to_ssa_type(BinopType binop_type) { +static SsaInstruction binop_type_to_ssa_type(BinopType binop_type, amal_default_type *type) { switch(binop_type) { case BINOP_ADD: return SSA_ADD; case BINOP_SUB: return SSA_SUB; case BINOP_MUL: - return SSA_MUL; + return type->is_signed ? SSA_IMUL : SSA_MUL; case BINOP_DIV: - return SSA_DIV; + return type->is_signed ? SSA_IDIV : SSA_DIV; case BINOP_DOT: assert(bool_false && "Binop dot not valid for arithmetic operation and requires special functionality"); return 0; @@ -494,18 +501,23 @@ static CHECK_RESULT SsaRegister binop_generate_ssa(Binop *self, SsaCompilerConte SsaRegister rhs_reg; SsaRegister reg; + /* + const std = @import("std.amal"); + std.printf + */ if(self->type == BINOP_DOT && self->rhs->resolve_data.type->rhs_expr->type == AST_FUNCTION_DECL) { reg = ast_generate_ssa(self->rhs, context); } else { lhs_reg = ast_generate_ssa(self->lhs, context); rhs_reg = ast_generate_ssa(self->rhs, context); - throw_if_error(ssa_ins_binop(context->ssa, binop_type_to_ssa_type(self->type), lhs_reg, rhs_reg, ®)); + throw_if_error(ssa_ins_binop(context->ssa, binop_type_to_ssa_type(self->type, (amal_default_type*)self->lhs->resolve_data.type), lhs_reg, rhs_reg, ®)); } return reg; } static void else_if_statement_generate_ssa(ElseIfStatement *else_if_stmt, SsaCompilerContext *context) { usize jump_ins_index; + jump_ins_index = 0; if(else_if_stmt->condition) { SsaRegister condition_reg; condition_reg = ast_generate_ssa(else_if_stmt->condition, context); diff --git a/src/std/scoped_allocator.c b/src/std/arena_allocator.c index d8acbf6..20f0394 100644 --- a/src/std/scoped_allocator.c +++ b/src/std/arena_allocator.c @@ -1,4 +1,4 @@ -#include "../../include/std/scoped_allocator.h" +#include "../../include/std/arena_allocator.h" #include "../../include/std/alloc.h" #include "../../include/std/thread.h" #include "../../include/std/log.h" @@ -6,31 +6,31 @@ #define ALLOC_NODE_SIZE 4096 -int scoped_allocator_node_init(ScopedAllocatorNode *self) { +int arena_allocator_node_init(ArenaAllocatorNode *self) { self->data = NULL; self->size = 0; self->next = NULL; return am_malloc(ALLOC_NODE_SIZE, (void**)&self->data); } -void scoped_allocator_node_deinit(ScopedAllocatorNode *self) { +void arena_allocator_node_deinit(ArenaAllocatorNode *self) { am_free(self->data); self->data = NULL; self->size = 0; if(self->next) { - scoped_allocator_node_deinit(self->next); + arena_allocator_node_deinit(self->next); am_free(self->next); self->next = NULL; } } -int scoped_allocator_init(ScopedAllocator *self) { - return_if_error(scoped_allocator_node_init(&self->head)); +int arena_allocator_init(ArenaAllocator *self) { + return_if_error(arena_allocator_node_init(&self->head)); self->current = &self->head; return buffer_init(&self->mems, NULL); } -static void scoped_allocator_deinit_buffers(ScopedAllocator *self) { +static void arena_allocator_deinit_buffers(ArenaAllocator *self) { void **mem; void **mems_end; mem = buffer_begin(&self->mems); @@ -42,19 +42,19 @@ static void scoped_allocator_deinit_buffers(ScopedAllocator *self) { buffer_deinit(&self->mems); } -void scoped_allocator_deinit(ScopedAllocator *self) { +void arena_allocator_deinit(ArenaAllocator *self) { self->current = NULL; - scoped_allocator_deinit_buffers(self); - scoped_allocator_node_deinit(&self->head); + arena_allocator_deinit_buffers(self); + arena_allocator_node_deinit(&self->head); } -static CHECK_RESULT int scoped_allocator_ensure_capacity_for(ScopedAllocator *self, usize size) { +static CHECK_RESULT int arena_allocator_ensure_capacity_for(ArenaAllocator *self, usize size) { void *new_node; new_node = NULL; if(self->current->size + size > ALLOC_NODE_SIZE) { - return_if_error(am_malloc(sizeof(ScopedAllocatorNode), &new_node)); - cleanup_if_error(scoped_allocator_node_init(new_node)); + return_if_error(am_malloc(sizeof(ArenaAllocatorNode), &new_node)); + cleanup_if_error(arena_allocator_node_init(new_node)); self->current->next = new_node; self->current = new_node; } @@ -78,19 +78,19 @@ static usize align_ptr_ceil_offset(void *ptr, uintptr_t alignment) { #define SCOPED_ALLOC_ALIGNMENT 8 -int scoped_allocator_alloc(ScopedAllocator *self, usize size, void **mem) { - ScopedAllocatorNode *current; +int arena_allocator_alloc(ArenaAllocator *self, usize size, void **mem) { + ArenaAllocatorNode *current; usize alloc_size; assert(self->current); current = self->current; if(size >= ALLOC_NODE_SIZE) { - amal_log_error("scoped_allocator_alloc: tried to alloc memory of size %lu. Max allowed alloc size is %lu", size, ALLOC_NODE_SIZE); + amal_log_error("arena_allocator_alloc: tried to alloc memory of size %lu. Max allowed alloc size is %lu", size, ALLOC_NODE_SIZE); return -1; } alloc_size = size + align_ptr_ceil_offset(self->current->data + self->current->size, SCOPED_ALLOC_ALIGNMENT); - return_if_error(scoped_allocator_ensure_capacity_for(self, alloc_size)); + return_if_error(arena_allocator_ensure_capacity_for(self, alloc_size)); /* Reallocated (new node created) */ if(self->current != current) { *mem = self->current->data; @@ -102,7 +102,7 @@ int scoped_allocator_alloc(ScopedAllocator *self, usize size, void **mem) { return 0; } -int scoped_allocator_add_mem(ScopedAllocator *self, usize *result_index) { +int arena_allocator_add_mem(ArenaAllocator *self, usize *result_index) { void *null_data; null_data = NULL; *result_index = buffer_get_size(&self->mems, sizeof(void*)); diff --git a/src/std/buffer.c b/src/std/buffer.c index f4e93e5..0e4ca89 100644 --- a/src/std/buffer.c +++ b/src/std/buffer.c @@ -1,16 +1,16 @@ #include "../../include/std/buffer.h" #include "../../include/std/alloc.h" #include "../../include/std/mem.h" -#include "../../include/std/scoped_allocator.h" +#include "../../include/std/arena_allocator.h" #include <assert.h> -int buffer_init(Buffer *self, struct ScopedAllocator *allocator) { +int buffer_init(Buffer *self, struct ArenaAllocator *allocator) { self->data = NULL; self->size = 0; self->capacity = 0; self->allocator = allocator; if(allocator) { - return scoped_allocator_add_mem(allocator, &self->allocator_index); + return arena_allocator_add_mem(allocator, &self->allocator_index); } else { self->allocator_index = ~(usize)0; return 0; diff --git a/src/std/hash_map.c b/src/std/hash_map.c index 1ad0dea..bcb43eb 100644 --- a/src/std/hash_map.c +++ b/src/std/hash_map.c @@ -1,5 +1,5 @@ #include "../../include/std/hash_map.h" -#include "../../include/std/scoped_allocator.h" +#include "../../include/std/arena_allocator.h" #include "../../include/std/mem.h" #include <assert.h> @@ -73,7 +73,7 @@ static void* bucket_node_get_value(HashMapBucketNode *self) { return value; } -int hash_map_init(HashMap *self, ScopedAllocator *allocator, usize value_type_size, +int hash_map_init(HashMap *self, ArenaAllocator *allocator, usize value_type_size, HashMapCompare compare_func, HashMapHash hash_func) { assert(compare_func); assert(hash_func); @@ -91,7 +91,7 @@ int hash_map_init(HashMap *self, ScopedAllocator *allocator, usize value_type_si static CHECK_RESULT int hash_map_bucket_add(HashMap *self, HashMapBucket *bucket, BufferView key, void *value, usize hash) { HashMapBucketNode *new_bucket_node; - return_if_error(scoped_allocator_alloc(self->allocator, + return_if_error(arena_allocator_alloc(self->allocator, sizeof(HashMapBucketNode*) + sizeof(hash) + sizeof(u32) + key.size + self->value_type_size, (void**)&new_bucket_node)); bucket_node_set_next(new_bucket_node, bucket->start); diff --git a/src/std/mem.c b/src/std/mem.c index f406176..95edcb9 100644 --- a/src/std/mem.c +++ b/src/std/mem.c @@ -1,5 +1,6 @@ #include "../../include/std/mem.h" #include <string.h> +#include <unistd.h> void am_memcpy(void *dest, const void *src, usize size) { memcpy(dest, src, size); @@ -16,3 +17,8 @@ bool am_memeql(const void *lhs, const void *rhs, usize size) { void am_memset(void *dest, int value, usize size) { memset(dest, value, size); } + +long am_pagesize() { + return sysconf(_SC_PAGESIZE); +} + diff --git a/src/tokenizer.c b/src/tokenizer.c index bce386d..7620fc0 100644 --- a/src/tokenizer.c +++ b/src/tokenizer.c @@ -2,7 +2,7 @@ #include "../include/std/mem.h" #include "../include/std/log.h" #include "../include/std/thread.h" -#include "../include/std/scoped_allocator.h" +#include "../include/std/arena_allocator.h" #include <assert.h> #include <limits.h> #include <stdio.h> @@ -25,7 +25,7 @@ static int tokenizer_get_end_of_line_from_index(Tokenizer *self, int index); /* Returns -1 if end of multiline comment was not found */ static int tokenizer_get_end_of_multiline_comment(Tokenizer *self, int index); -int tokenizer_init(Tokenizer *self, ScopedAllocator *allocator, BufferView code, BufferView code_name, const amal_compiler_options *compiler_options) { +int tokenizer_init(Tokenizer *self, ArenaAllocator *allocator, BufferView code, BufferView code_name, const amal_compiler_options *compiler_options) { assert(code.size <= INT_MAX); assert(compiler_options); /* Skip UTF-8 BOM */ @@ -415,6 +415,7 @@ static const char* binop_to_string(BinopType binop_type) { static BufferView tokenizer_expected_token_as_string(Token token) { const char *str; + str = ""; switch(token) { case TOK_NONE: str = "none"; @@ -737,7 +738,7 @@ TokenizerError tokenizer_create_error(Tokenizer *self, int index, const char *fm result.index = index; result.str = NULL; - ignore_result_int(scoped_allocator_alloc(self->allocator, bytes_copied + 1, (void**)&result.str)); + ignore_result_int(arena_allocator_alloc(self->allocator, bytes_copied + 1, (void**)&result.str)); if(result.str && bytes_copied > 0) am_memcpy(result.str, buffer, bytes_copied + 1); return result; |