From: Brendan Hansen Date: Sat, 15 Aug 2020 15:19:04 +0000 (-0500) Subject: code cleanup; can 'use' bare structures X-Git-Url: https://git.brendanfh.com/?a=commitdiff_plain;h=1217310d963a2f99520982be0aa0d6349618a68a;p=onyx.git code cleanup; can 'use' bare structures --- diff --git a/core/alloc.onyx b/core/alloc.onyx index 81a96dd2..e70f900d 100644 --- a/core/alloc.onyx +++ b/core/alloc.onyx @@ -22,15 +22,15 @@ Allocator :: struct { func: alloc_proc; } -alloc :: proc (use a: ^Allocator, size: u32) -> rawptr { +alloc :: proc (use a: Allocator, size: u32) -> rawptr { return func(data, AllocAction.Alloc, size, 16, null); } -resize :: proc (use a: ^Allocator, ptr: rawptr, size: u32) -> rawptr { +resize :: proc (use a: Allocator, ptr: rawptr, size: u32) -> rawptr { return func(data, AllocAction.Resize, size, 16, ptr); } -free :: proc (use a: ^Allocator, ptr: rawptr) { +free :: proc (use a: Allocator, ptr: rawptr) { func(data, AllocAction.Free, 0, 0, ptr); } @@ -159,9 +159,9 @@ heap_alloc_proc :: proc (data: rawptr, aa: AllocAction, size: u32, align: u32, o return null; } -malloc :: proc (size: u32) -> rawptr do return alloc(^heap_allocator, size); -mfree :: proc (ptr: rawptr) do free(^heap_allocator, ptr); -mresize :: proc (ptr: rawptr, size: u32) -> rawptr do return resize(^heap_allocator, ptr, size); +malloc :: proc (size: u32) -> rawptr do return alloc(heap_allocator, size); +mfree :: proc (ptr: rawptr) do free(heap_allocator, ptr); +mresize :: proc (ptr: rawptr, size: u32) -> rawptr do return resize(heap_allocator, ptr, size); @@ -206,10 +206,10 @@ scratch_alloc_init :: proc (a: ^Allocator, ss: ^ScratchState) { } -#private return_scratch_size :: 256 -#private return_scratch_buff : [return_scratch_size] u8 +#private return_scratch_size :: 256 +#private return_scratch_buff : [return_scratch_size] u8 +#private return_scratch_state : ScratchState; -return_scratch_state : ScratchState; return_scratch_alloc : Allocator; memory_init :: proc { diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h index 7fb649f6..c9b0e146 100644 --- a/include/onyxastnodes.h +++ b/include/onyxastnodes.h @@ -353,7 +353,7 @@ struct AstTypeAlias { AstType_base; AstType* to; }; // Top level nodes struct AstBinding { AstTyped_base; AstNode* node; }; -struct AstMemRes { AstTyped_base; u64 addr; AstTyped *initial_value; }; // HACK: This has to be the same size or bigger as AstDereference +struct AstMemRes { AstTyped_base; u64 addr; AstTyped *initial_value; }; struct AstInclude { AstNode_base; OnyxToken *name; }; struct AstUsePackage { AstNode_base; diff --git a/onyx b/onyx index 9e1bc71e..77ebf6e3 100755 Binary files a/onyx and b/onyx differ diff --git a/progs/stack_based.onyx b/progs/stack_based.onyx index dadd2ade..b9d80080 100644 --- a/progs/stack_based.onyx +++ b/progs/stack_based.onyx @@ -142,29 +142,27 @@ start :: proc #export { stupid_idea(1234)() |> print(); - { - varr : [5] Vec3; - varr[2].x = 4; - varr[2].y = 5; - varr[2].z = 6; - mag_squared(varr[2]) |> print(); - - v1 : Vec3; - v1.x = 1; - v1.y = 2; - v1.z = 4; - - v2 := v1; - - v3 : Vec3 = *vadd(v1, v2); - print(v3.x); - print(v3.y); - print(v3.z); - } + varr : [5] Vec3; + varr[2].x = 4; + varr[2].y = 5; + varr[2].z = 6; + mag_squared(varr[2]) |> print(); + + v1 : Vec3; + v1.x = 1; + v1.y = 2; + v1.z = 4; + + v2 := v1; + + v3 := *vadd(v1, v2); + print(v3.x); + print(v3.y); + print(v3.z); } vadd :: proc (v1: Vec3, v2: Vec3) -> ^Vec3 { - out := cast(^Vec3) alloc(^return_scratch_alloc, sizeof Vec3); + out := cast(^Vec3) alloc(return_scratch_alloc, sizeof Vec3); out.x = v1.x + v2.x; out.y = v1.y + v2.y; out.z = v1.z + v2.z; diff --git a/src/onyxchecker.c b/src/onyxchecker.c index c0b50b8d..68f21b10 100644 --- a/src/onyxchecker.c +++ b/src/onyxchecker.c @@ -1048,7 +1048,6 @@ CHECK(memres, AstMemRes* memres) { } Type* memres_type = memres->type; - if (!type_is_compound(memres_type)) memres_type = memres_type->Pointer.elem; if (!types_are_compatible(memres_type, memres->initial_value->type)) { onyx_message_add(Msg_Type_Binop_Mismatch, diff --git a/src/onyxsymres.c b/src/onyxsymres.c index 83cc6091..34573b4c 100644 --- a/src/onyxsymres.c +++ b/src/onyxsymres.c @@ -338,12 +338,13 @@ static void symres_function(AstFunction* func) { symbol_introduce(semstate.curr_scope, param->token, (AstNode *) param); if (param->flags & Ast_Flag_Param_Use) { - if (param->type->kind != Type_Kind_Pointer || param->type->Pointer.elem->kind != Type_Kind_Struct) { - onyx_message_add(Msg_Type_Literal, - param->token->pos, - "can only 'use' pointers to structures."); - } else { - AstStructType* st = (AstStructType *) ((AstPointerType *) param->type_node)->elem; + if (type_is_struct(param->type)) { + AstStructType* st; + if (param->type->kind == Type_Kind_Struct) { + st = (AstStructType *) param->type_node; + } else { + st = (AstStructType *) ((AstPointerType *) param->type_node)->elem; + } bh_arr_each(AstStructMember *, mem, st->members) { AstFieldAccess* fa = onyx_ast_node_new(semstate.node_allocator, sizeof(AstFieldAccess), Ast_Kind_Field_Access); @@ -358,6 +359,11 @@ static void symres_function(AstFunction* func) { (AstNode *) fa); token_toggle_end((*mem)->token); } + + } else { + onyx_message_add(Msg_Type_Literal, + param->token->pos, + "can only 'use' structures or pointers to structures."); } } } @@ -478,26 +484,6 @@ static void symres_memres(AstMemRes** memres) { } else { if ((*memres)->type_node == NULL) return; } - - (*memres)->type = type_build_from_ast(semstate.allocator, (*memres)->type_node); - - if (!type_is_compound((*memres)->type)) { - Type* ptr_type = type_make_pointer(semstate.allocator, (*memres)->type); - (*memres)->type = ptr_type; - - AstMemRes* new_memres = onyx_ast_node_new(semstate.node_allocator, sizeof(AstMemRes), Ast_Kind_Memres); - memcpy(new_memres, (*memres), sizeof(AstMemRes)); - - // BIG HACK: converting the (*memres) node to a dereference node to not break - // already resolved symbols - ((AstDereference *) (*memres))->kind = Ast_Kind_Dereference; - ((AstDereference *) (*memres))->type_node = (*memres)->type_node; - ((AstDereference *) (*memres))->type = (*memres)->type->Pointer.elem; - ((AstDereference *) (*memres))->expr = (AstTyped *) new_memres; - - // BUT retain the 'old' memres in the entity list - *memres = new_memres; - } } void onyx_resolve_symbols() { diff --git a/src/onyxwasm.c b/src/onyxwasm.c index debefaae..822480c5 100644 --- a/src/onyxwasm.c +++ b/src/onyxwasm.c @@ -343,31 +343,32 @@ static u64 local_lookup_idx(LocalAllocator* la, u64 value) { #define WIL(instr, data) bh_arr_push(code, ((WasmInstruction){ instr, { .l = data } })) #define COMPILE_FUNC(kind, ...) static void compile_ ## kind (OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, __VA_ARGS__) -COMPILE_FUNC(function_body, AstFunction* fd); -COMPILE_FUNC(block, AstBlock* block, b32 generate_block_headers); -COMPILE_FUNC(statement, AstNode* stmt); -COMPILE_FUNC(assignment, AstBinaryOp* assign); -COMPILE_FUNC(store_instruction, Type* type, u32 offset); -COMPILE_FUNC(load_instruction, Type* type, u32 offset); -COMPILE_FUNC(if, AstIf* if_node); -COMPILE_FUNC(while, AstWhile* while_node); -COMPILE_FUNC(for, AstFor* for_node); -COMPILE_FUNC(defer, AstDefer* defer); -COMPILE_FUNC(deferred_stmts, AstNode* node); -COMPILE_FUNC(binop, AstBinaryOp* binop); -COMPILE_FUNC(unaryop, AstUnaryOp* unop); -COMPILE_FUNC(call, AstCall* call); -COMPILE_FUNC(intrinsic_call, AstIntrinsicCall* call); -COMPILE_FUNC(array_access_location, AstArrayAccess* aa, u64* offset_return); -COMPILE_FUNC(field_access_location, AstFieldAccess* field, u64* offset_return); -COMPILE_FUNC(local_location, AstLocal* local, u64* offset_return); -COMPILE_FUNC(struct_load, Type* type, u64 offset); -COMPILE_FUNC(struct_store, AstTyped* lval); -COMPILE_FUNC(expression, AstTyped* expr); -COMPILE_FUNC(cast, AstUnaryOp* cast); -COMPILE_FUNC(return, AstReturn* ret); -COMPILE_FUNC(stack_enter, u64 stacksize); -COMPILE_FUNC(stack_leave, u32 unused); +COMPILE_FUNC(function_body, AstFunction* fd); +COMPILE_FUNC(block, AstBlock* block, b32 generate_block_headers); +COMPILE_FUNC(statement, AstNode* stmt); +COMPILE_FUNC(assignment, AstBinaryOp* assign); +COMPILE_FUNC(store_instruction, Type* type, u32 offset); +COMPILE_FUNC(load_instruction, Type* type, u32 offset); +COMPILE_FUNC(if, AstIf* if_node); +COMPILE_FUNC(while, AstWhile* while_node); +COMPILE_FUNC(for, AstFor* for_node); +COMPILE_FUNC(defer, AstDefer* defer); +COMPILE_FUNC(deferred_stmts, AstNode* node); +COMPILE_FUNC(binop, AstBinaryOp* binop); +COMPILE_FUNC(unaryop, AstUnaryOp* unop); +COMPILE_FUNC(call, AstCall* call); +COMPILE_FUNC(intrinsic_call, AstIntrinsicCall* call); +COMPILE_FUNC(array_access_location, AstArrayAccess* aa, u64* offset_return); +COMPILE_FUNC(field_access_location, AstFieldAccess* field, u64* offset_return); +COMPILE_FUNC(local_location, AstLocal* local, u64* offset_return); +COMPILE_FUNC(memory_reservation_location, AstMemRes* memres); +COMPILE_FUNC(struct_load, Type* type, u64 offset); +COMPILE_FUNC(struct_store, AstTyped* lval); +COMPILE_FUNC(expression, AstTyped* expr); +COMPILE_FUNC(cast, AstUnaryOp* cast); +COMPILE_FUNC(return, AstReturn* ret); +COMPILE_FUNC(stack_enter, u64 stacksize); +COMPILE_FUNC(stack_leave, u32 unused); COMPILE_FUNC(function_body, AstFunction* fd) { if (fd->body == NULL) return; @@ -1002,6 +1003,9 @@ COMPILE_FUNC(array_access_location, AstArrayAccess* aa, u64* offset_return) { } else if (aa->addr->kind == Ast_Kind_Local && aa->addr->type->kind == Type_Kind_Array) { compile_local_location(mod, &code, (AstLocal *) aa->addr, &offset); + } else if (aa->addr->kind == Ast_Kind_Memres + && aa->addr->type->kind != Type_Kind_Array) { + compile_memory_reservation_location(mod, &code, (AstMemRes *) aa->addr); } else { compile_expression(mod, &code, aa->addr); } @@ -1033,6 +1037,9 @@ COMPILE_FUNC(field_access_location, AstFieldAccess* field, u64* offset_return) { u64 o2 = 0; compile_local_location(mod, &code, (AstLocal *) source_expr, &o2); offset += o2; + } else if (source_expr->kind == Ast_Kind_Memres + && source_expr->type->kind != Type_Kind_Pointer) { + compile_memory_reservation_location(mod, &code, (AstMemRes *) source_expr); } else { compile_expression(mod, &code, source_expr); } @@ -1042,6 +1049,14 @@ COMPILE_FUNC(field_access_location, AstFieldAccess* field, u64* offset_return) { *pcode = code; } +COMPILE_FUNC(memory_reservation_location, AstMemRes* memres) { + bh_arr(WasmInstruction) code = *pcode; + + WID(WI_I32_CONST, memres->addr); + + *pcode = code; +} + COMPILE_FUNC(local_location, AstLocal* local, u64* offset_return) { bh_arr(WasmInstruction) code = *pcode; @@ -1328,6 +1343,7 @@ COMPILE_FUNC(expression, AstTyped* expr) { case Ast_Kind_Memres: { AstMemRes* memres = (AstMemRes *) expr; WID(WI_I32_CONST, memres->addr); + compile_load_instruction(mod, &code, memres->type, 0); break; } @@ -1658,16 +1674,17 @@ static void compile_function(OnyxWasmModule* mod, AstFunction* fd) { mod->local_alloc = &wasm_func.locals; mod->local_alloc->param_count = localidx; - mod->stack_base_idx = local_raw_allocate(mod->local_alloc, WASM_TYPE_INT32); - mod->has_stack_locals = 0; bh_arr_each(AstLocal *, local, fd->locals) mod->has_stack_locals |= !local_is_wasm_local(*local); - if (mod->has_stack_locals) + if (mod->has_stack_locals) { // NOTE: '5' needs to match the number of instructions it takes // to setup a stack frame bh_arr_insert_end(wasm_func.code, 5); + mod->stack_base_idx = local_raw_allocate(mod->local_alloc, WASM_TYPE_INT32); + } + // Generate code compile_function_body(mod, &wasm_func.code, fd); @@ -1833,7 +1850,6 @@ static void compile_raw_data(OnyxWasmModule* mod, ptr data, AstTyped* node) { static void compile_memory_reservation(OnyxWasmModule* mod, AstMemRes* memres) { Type* effective_type = memres->type; - if (!type_is_compound(effective_type)) effective_type = effective_type->Pointer.elem; u64 alignment = type_alignment_of(effective_type); u64 size = type_size_of(effective_type);