diff --git a/src/tilde/tb.h b/src/tilde/tb.h index 0f0aaf4c6..8b698ff30 100644 --- a/src/tilde/tb.h +++ b/src/tilde/tb.h @@ -439,7 +439,7 @@ struct TB_Node { typedef struct { // TB_BRANCH // avoid empty structs with flexible members int64_t _; - int64_t keys[/* input_count - 1 */]; + int64_t keys[]; } TB_NodeBranch; typedef struct { // TB_PROJ @@ -538,19 +538,6 @@ typedef struct { TB_Node* value; } TB_SwitchEntry; -typedef struct TB_Loop { - // refers to another entry in TB_LoopInfo... unless it's -1 - ptrdiff_t parent_loop; - - TB_Node* header; - TB_Node* backedge; -} TB_Loop; - -typedef struct TB_LoopInfo { - size_t count; - TB_Loop* loops; -} TB_LoopInfo; - typedef enum { TB_EXECUTABLE_UNKNOWN, TB_EXECUTABLE_PE, @@ -648,7 +635,7 @@ TB_API void tb_module_destroy(TB_Module* m); // When targetting windows & thread local storage, you'll need to bind a tls index // which is usually just a global that the runtime support has initialized, if you // dont and the tls_index is used, it'll crash -TB_API void tb_module_set_tls_index(TB_Module* m, const char* name); +TB_API void tb_module_set_tls_index(TB_Module* m, ptrdiff_t len, const char* name); // You don't need to manually call this unless you want to resolve locations before // exporting. @@ -756,7 +743,7 @@ TB_API TB_External* tb_next_external(TB_External* e); TB_API TB_ExternalType tb_extern_get_type(TB_External* e); TB_Global* tb_extern_transmute(TB_External* e, TB_DebugType* dbg_type, TB_Linkage linkage); -TB_API TB_External* tb_extern_create(TB_Module* m, const char* name, TB_ExternalType type); +TB_API TB_External* tb_extern_create(TB_Module* m, ptrdiff_t len, const char* name, TB_ExternalType type); TB_API TB_FileID tb_file_create(TB_Module* m, const char* path); // Called once you're done with TB operations on a thread (or i guess when it's @@ -798,7 +785,7 @@ TB_API TB_FunctionPrototype* tb_prototype_create(TB_Module* m, TB_CallingConv cc //////////////////////////////// // Globals //////////////////////////////// -TB_API TB_Global* tb_global_create(TB_Module* m, const char* name, TB_DebugType* dbg_type, TB_Linkage linkage); +TB_API TB_Global* tb_global_create(TB_Module* m, ptrdiff_t len, const char* name, TB_DebugType* dbg_type, TB_Linkage linkage); // allocate space for the global TB_API void tb_global_set_storage(TB_Module* m, TB_ModuleSection* section, TB_Global* global, size_t size, size_t align, size_t max_objects); @@ -818,8 +805,11 @@ TB_API TB_ModuleSection* tb_module_get_tls(TB_Module* m); //////////////////////////////// // Function Attributes //////////////////////////////// +TB_API void tb_node_append_attrib(TB_Node* n, TB_Attrib* a); + // These are parts of a function that describe metadata for instructions -TB_API void tb_function_attrib_variable(TB_Function* f, TB_Node* n, const char* name, TB_DebugType* type); +TB_API TB_Attrib* tb_function_attrib_variable(TB_Function* f, ptrdiff_t len, const char* name, TB_DebugType* type); +TB_API TB_Attrib* tb_function_attrib_scope(TB_Function* f, TB_Attrib* parent_scope); //////////////////////////////// // Debug info Generation @@ -830,9 +820,9 @@ TB_API TB_DebugType* tb_debug_get_integer(TB_Module* m, bool is_signed, int bits TB_API TB_DebugType* tb_debug_get_float(TB_Module* m, TB_FloatFormat fmt); TB_API TB_DebugType* tb_debug_create_ptr(TB_Module* m, TB_DebugType* base); TB_API TB_DebugType* tb_debug_create_array(TB_Module* m, TB_DebugType* base, size_t count); -TB_API TB_DebugType* tb_debug_create_struct(TB_Module* m, const char* tag); -TB_API TB_DebugType* tb_debug_create_union(TB_Module* m, const char* tag); -TB_API TB_DebugType* tb_debug_create_field(TB_Module* m, TB_DebugType* type, const char* name, TB_CharUnits offset); +TB_API TB_DebugType* tb_debug_create_struct(TB_Module* m, ptrdiff_t len, const char* tag); +TB_API TB_DebugType* tb_debug_create_union(TB_Module* m, ptrdiff_t len, const char* tag); +TB_API TB_DebugType* tb_debug_create_field(TB_Module* m, TB_DebugType* type, ptrdiff_t len, const char* name, TB_CharUnits offset); TB_API void tb_debug_complete_record(TB_DebugType* type, TB_DebugType** members, size_t count, TB_CharUnits size, TB_CharUnits align); //////////////////////////////// @@ -869,12 +859,14 @@ TB_API void tb_inst_set_location(TB_Function* f, TB_FileID file, int line); TB_API TB_DataType tb_vector_type(TB_DataTypeEnum type, int width); // if section is NULL, default to .text -TB_API TB_Function* tb_function_create(TB_Module* m, const char* name, TB_Linkage linkage, TB_ComdatType comdat); +TB_API TB_Function* tb_function_create(TB_Module* m, ptrdiff_t len, const char* name, TB_Linkage linkage, TB_ComdatType comdat); TB_API void* tb_function_get_jit_pos(TB_Function* f); +// if len is -1, it's null terminated +TB_API void tb_symbol_set_name(TB_Symbol* s, ptrdiff_t len, const char* name); + TB_API void tb_symbol_bind_ptr(TB_Symbol* s, void* ptr); -TB_API void tb_symbol_set_name(TB_Symbol* s, const char* name); TB_API const char* tb_symbol_get_name(TB_Symbol* s); // if arena is NULL, defaults to module arena which is freed on tb_free_thread_resources @@ -915,7 +907,6 @@ TB_API TB_Node* tb_inst_load(TB_Function* f, TB_DataType dt, TB_Node* addr, TB_C TB_API void tb_inst_store(TB_Function* f, TB_DataType dt, TB_Node* addr, TB_Node* val, TB_CharUnits align, bool is_volatile); TB_API TB_Node* tb_inst_bool(TB_Function* f, bool imm); -TB_API TB_Node* tb_inst_ptr(TB_Function* f, uint64_t imm); TB_API TB_Node* tb_inst_sint(TB_Function* f, TB_DataType dt, int64_t imm); TB_API TB_Node* tb_inst_uint(TB_Function* f, TB_DataType dt, uint64_t imm); TB_API TB_Node* tb_inst_float32(TB_Function* f, float imm); @@ -923,9 +914,12 @@ TB_API TB_Node* tb_inst_float64(TB_Function* f, double imm); TB_API TB_Node* tb_inst_cstring(TB_Function* f, const char* str); TB_API TB_Node* tb_inst_string(TB_Function* f, size_t len, const char* str); -// Broadcasts 'val' across 'count' elements starting 'dst' +// write 'val' over 'count' bytes on 'dst' TB_API void tb_inst_memset(TB_Function* f, TB_Node* dst, TB_Node* val, TB_Node* count, TB_CharUnits align, bool is_volatile); +// zero 'count' bytes on 'dst' +TB_API void tb_inst_memzero(TB_Function* f, TB_Node* dst, TB_Node* val, TB_Node* count, TB_CharUnits align, bool is_volatile); + // performs a copy of 'count' elements from one memory location to another // both locations cannot overlap. TB_API void tb_inst_memcpy(TB_Function* f, TB_Node* dst, TB_Node* src, TB_Node* count, TB_CharUnits align, bool is_volatile); @@ -1052,13 +1046,15 @@ TB_API TB_FuncOpt* tb_funcopt_enter(TB_Function* f, TB_Arena* arena); TB_API void tb_funcopt_exit(TB_FuncOpt* opt); TB_API bool tb_funcopt_peephole(TB_FuncOpt* opt); -TB_API bool tb_funcopt_mem2reg(TB_FuncOpt* f); -TB_API bool tb_funcopt_loop(TB_FuncOpt* f); +TB_API bool tb_funcopt_mem2reg(TB_FuncOpt* opt); +TB_API bool tb_funcopt_loop(TB_FuncOpt* opt); -TB_API void tb_funcopt_kill(TB_FuncOpt* restrict queue, TB_Node* n); +// isn't an optimization, just does the name flat form of IR printing +TB_API bool tb_funcopt_print(TB_FuncOpt* opt); -TB_API bool tb_funcopt_mark(TB_FuncOpt* restrict queue, TB_Node* n); -TB_API void tb_funcopt_mark_users(TB_FuncOpt* restrict queue, TB_Node* n); +TB_API void tb_funcopt_kill(TB_FuncOpt* opt, TB_Node* n); +TB_API bool tb_funcopt_mark(TB_FuncOpt* opt, TB_Node* n); +TB_API void tb_funcopt_mark_users(TB_FuncOpt* opt, TB_Node* n); //////////////////////////////// // IR access diff --git a/src/tilde/tb.lib b/src/tilde/tb.lib index a1f893968..a6ac5cbff 100644 Binary files a/src/tilde/tb.lib and b/src/tilde/tb.lib differ diff --git a/src/tilde_backend.cpp b/src/tilde_backend.cpp index d695c846c..0572e2fd0 100644 --- a/src/tilde_backend.cpp +++ b/src/tilde_backend.cpp @@ -184,7 +184,7 @@ gb_internal void cg_create_global_variables(cgModule *m) { // gb_printf_err("max_type_info_count: %td\n", max_type_info_count); Type *t = alloc_type_array(t_type_info, max_type_info_count); - TB_Global *g = tb_global_create(m->mod, CG_TYPE_INFO_DATA_NAME, nullptr, TB_LINKAGE_PRIVATE); + TB_Global *g = tb_global_create(m->mod, -1, CG_TYPE_INFO_DATA_NAME, nullptr, TB_LINKAGE_PRIVATE); tb_global_set_storage(m->mod, tb_module_get_rdata(m->mod), g, type_size_of(t), 16, max_type_info_count); cgValue value = cg_value(g, alloc_type_pointer(t)); @@ -219,7 +219,7 @@ gb_internal void cg_create_global_variables(cgModule *m) { { char const *name = CG_TYPE_INFO_TYPES_NAME; Type *t = alloc_type_array(t_type_info_ptr, count); - TB_Global *g = tb_global_create(m->mod, name, nullptr, TB_LINKAGE_PRIVATE); + TB_Global *g = tb_global_create(m->mod, -1, name, nullptr, TB_LINKAGE_PRIVATE); tb_global_set_storage(m->mod, tb_module_get_rdata(m->mod), g, type_size_of(t), 16, count); cg_global_type_info_member_types = cg_addr(cg_value(g, alloc_type_pointer(t))); @@ -227,14 +227,14 @@ gb_internal void cg_create_global_variables(cgModule *m) { { char const *name = CG_TYPE_INFO_NAMES_NAME; Type *t = alloc_type_array(t_string, count); - TB_Global *g = tb_global_create(m->mod, name, nullptr, TB_LINKAGE_PRIVATE); + TB_Global *g = tb_global_create(m->mod, -1, name, nullptr, TB_LINKAGE_PRIVATE); tb_global_set_storage(m->mod, tb_module_get_rdata(m->mod), g, type_size_of(t), 16, count); cg_global_type_info_member_names = cg_addr(cg_value(g, alloc_type_pointer(t))); } { char const *name = CG_TYPE_INFO_OFFSETS_NAME; Type *t = alloc_type_array(t_uintptr, count); - TB_Global *g = tb_global_create(m->mod, name, nullptr, TB_LINKAGE_PRIVATE); + TB_Global *g = tb_global_create(m->mod, -1, name, nullptr, TB_LINKAGE_PRIVATE); tb_global_set_storage(m->mod, tb_module_get_rdata(m->mod), g, type_size_of(t), 16, count); cg_global_type_info_member_offsets = cg_addr(cg_value(g, alloc_type_pointer(t))); } @@ -242,7 +242,7 @@ gb_internal void cg_create_global_variables(cgModule *m) { { char const *name = CG_TYPE_INFO_USINGS_NAME; Type *t = alloc_type_array(t_bool, count); - TB_Global *g = tb_global_create(m->mod, name, nullptr, TB_LINKAGE_PRIVATE); + TB_Global *g = tb_global_create(m->mod, -1, name, nullptr, TB_LINKAGE_PRIVATE); tb_global_set_storage(m->mod, tb_module_get_rdata(m->mod), g, type_size_of(t), 16, count); cg_global_type_info_member_usings = cg_addr(cg_value(g, alloc_type_pointer(t))); } @@ -250,7 +250,7 @@ gb_internal void cg_create_global_variables(cgModule *m) { { char const *name = CG_TYPE_INFO_TAGS_NAME; Type *t = alloc_type_array(t_string, count); - TB_Global *g = tb_global_create(m->mod, name, nullptr, TB_LINKAGE_PRIVATE); + TB_Global *g = tb_global_create(m->mod, -1, name, nullptr, TB_LINKAGE_PRIVATE); tb_global_set_storage(m->mod, tb_module_get_rdata(m->mod), g, type_size_of(t), 16, count); cg_global_type_info_member_tags = cg_addr(cg_value(g, alloc_type_pointer(t))); } @@ -268,7 +268,7 @@ cgModule *cg_module_create(Checker *c) { TB_FeatureSet feature_set = {}; bool is_jit = false; m->mod = tb_module_create(TB_ARCH_X86_64, TB_SYSTEM_WINDOWS, &feature_set, is_jit); - tb_module_set_tls_index(m->mod, "_tls_index"); + tb_module_set_tls_index(m->mod, 10, "_tls_index"); map_init(&m->values); array_init(&m->procedures_to_generate, heap_allocator()); @@ -634,8 +634,6 @@ gb_internal cgProcedure *cg_procedure_create(cgModule *m, Entity *entity, bool i // p->scope_stack.allocator = a; // map_init(&p->tuple_fix_map, 0); - char const *link_name_c = alloc_cstring(temporary_allocator(), link_name); - TB_Linkage linkage = TB_LINKAGE_PRIVATE; if (p->is_export) { linkage = TB_LINKAGE_PUBLIC; @@ -643,11 +641,11 @@ gb_internal cgProcedure *cg_procedure_create(cgModule *m, Entity *entity, bool i if (ignore_body) { linkage = TB_LINKAGE_PUBLIC; } - p->symbol = cast(TB_Symbol *)tb_extern_create(m->mod, link_name_c, TB_EXTERNAL_SO_LOCAL); + p->symbol = cast(TB_Symbol *)tb_extern_create(m->mod, link_name.len, cast(char const *)link_name.text, TB_EXTERNAL_SO_LOCAL); } if (p->symbol == nullptr) { - p->func = tb_function_create(m->mod, link_name_c, linkage, TB_COMDAT_NONE); + p->func = tb_function_create(m->mod, link_name.len, cast(char const *)link_name.text, linkage, TB_COMDAT_NONE); tb_function_set_prototype(p->func, cg_procedure_type_as_prototype(m, p->type), tb_default_arena()); p->symbol = cast(TB_Symbol *)p->func; } @@ -688,12 +686,9 @@ gb_internal cgProcedure *cg_procedure_create_dummy(cgModule *m, String const &li // map_init(&p->tuple_fix_map, 0); - - char const *link_name_c = alloc_cstring(temporary_allocator(), link_name); - TB_Linkage linkage = TB_LINKAGE_PRIVATE; - p->func = tb_function_create(m->mod, link_name_c, linkage, TB_COMDAT_NONE); + p->func = tb_function_create(m->mod, link_name.len, cast(char const *)link_name.text, linkage, TB_COMDAT_NONE); tb_function_set_prototype(p->func, cg_procedure_type_as_prototype(m, p->type), tb_default_arena()); p->symbol = cast(TB_Symbol *)p->func; @@ -715,6 +710,13 @@ gb_internal void cg_procedure_end(cgProcedure *p) { return; } tb_inst_ret(p->func, 0, nullptr); + if (p->name == "main") { + TB_Arena *arena = tb_default_arena(); + defer (arena->free(arena)); + TB_FuncOpt *opt = tb_funcopt_enter(p->func, arena); + defer (tb_funcopt_exit(opt)); + tb_funcopt_print(opt); + } tb_module_compile_function(p->module->mod, p->func, TB_ISEL_FAST); } diff --git a/src/tilde_backend.hpp b/src/tilde_backend.hpp index 44591190a..6c17f8ba3 100644 --- a/src/tilde_backend.hpp +++ b/src/tilde_backend.hpp @@ -212,4 +212,6 @@ gb_internal void cg_emit_store(cgProcedure *p, cgValue dst, cgValue const &src, gb_internal cgAddr cg_add_local(cgProcedure *p, Type *type, Entity *e, bool zero_init); -gb_internal cgValue cg_build_call_expr(cgProcedure *p, Ast *expr); \ No newline at end of file +gb_internal cgValue cg_build_call_expr(cgProcedure *p, Ast *expr); + +gb_internal cgValue cg_find_procedure_value_from_entity(cgModule *m, Entity *e); \ No newline at end of file diff --git a/src/tilde_const.cpp b/src/tilde_const.cpp index 7a8be70c7..97fee838e 100644 --- a/src/tilde_const.cpp +++ b/src/tilde_const.cpp @@ -8,7 +8,7 @@ gb_internal cgValue cg_const_nil(cgProcedure *p, Type *type) { TB_Module *m = p->module->mod; char name[32] = {}; gb_snprintf(name, 31, "cnil$%u", 1+p->module->const_nil_guid.fetch_add(1)); - TB_Global *global = tb_global_create(m, name, nullptr, TB_LINKAGE_PRIVATE); + TB_Global *global = tb_global_create(m, -1, name, nullptr, TB_LINKAGE_PRIVATE); tb_global_set_storage(m, tb_module_get_rdata(m), global, size, align, 0); TB_Symbol *symbol = cast(TB_Symbol *)global; @@ -41,6 +41,18 @@ gb_internal cgValue cg_const_value(cgModule *m, cgProcedure *p, Type *type, Exac return cg_const_nil(p, type); } + if (value.kind == ExactValue_Procedure) { + Ast *expr = unparen_expr(value.value_procedure); + Entity *e = entity_of_node(expr); + if (e != nullptr) { + cgValue found = cg_find_procedure_value_from_entity(m, e); + GB_ASSERT(are_types_identical(type, found.type)); + return found; + } + + } + + GB_ASSERT(node != nullptr); return cg_value(node, type); } diff --git a/src/tilde_expr.cpp b/src/tilde_expr.cpp index ccd126747..702cb42ad 100644 --- a/src/tilde_expr.cpp +++ b/src/tilde_expr.cpp @@ -101,7 +101,7 @@ gb_internal cgValue cg_build_expr(cgProcedure *p, Ast *expr) { cgValue res = cg_build_expr_internal(p, expr); if (res.kind == cgValue_Symbol) { - GB_ASSERT(is_type_pointer(res.type)); + GB_ASSERT(is_type_internally_pointer_like(res.type)); res = cg_value(tb_inst_get_symbol_address(p->func, res.symbol), res.type); } @@ -161,6 +161,7 @@ gb_internal cgValue cg_build_expr_internal(cgProcedure *p, Ast *expr) { token_pos_to_string(token.pos)); return {}; } else if (e->kind == Entity_Nil) { + GB_PANIC("TODO: cg_find_ident nil"); // TODO(bill): is this correct? return cg_value(cast(TB_Node *)nullptr, e->type); } diff --git a/src/tilde_proc.cpp b/src/tilde_proc.cpp index 306852db3..dbebae853 100644 --- a/src/tilde_proc.cpp +++ b/src/tilde_proc.cpp @@ -1,5 +1,127 @@ -gb_internal cgValue cg_build_call_expr(cgProcedure *p, Ast *expr) { - ast_node(ce, CallExpr, expr); - // TODO(bill): cg_build_call_expr +gb_internal cgValue cg_find_procedure_value_from_entity(cgModule *m, Entity *e) { + GB_ASSERT(is_type_proc(e->type)); + e = strip_entity_wrapping(e); + GB_ASSERT(e != nullptr); + GB_ASSERT(e->kind == Entity_Procedure); + + cgValue *found = nullptr; + rw_mutex_shared_lock(&m->values_mutex); + found = map_get(&m->values, e); + rw_mutex_shared_unlock(&m->values_mutex); + if (found) { + return *found; + } + + GB_PANIC("Error in: %s, missing procedure %.*s\n", token_pos_to_string(e->token.pos), LIT(e->token.string)); return {}; -} \ No newline at end of file +} + + + +gb_internal cgValue cg_build_call_expr_internal(cgProcedure *p, Ast *expr); +gb_internal cgValue cg_build_call_expr(cgProcedure *p, Ast *expr) { + expr = unparen_expr(expr); + ast_node(ce, CallExpr, expr); + + cgValue res = cg_build_call_expr_internal(p, expr); + + if (ce->optional_ok_one) { // TODO(bill): Minor hack for #optional_ok procedures + GB_PANIC("Handle optional_ok_one"); + // GB_ASSERT(is_type_tuple(res.type)); + // GB_ASSERT(res.type->Tuple.variables.count == 2); + // return cg_emit_struct_ev(p, res, 0); + } + return res; +} + +gb_internal cgValue cg_emit_call(cgProcedure * p, cgValue value, Slice args) { + if (value.kind == cgValue_Symbol) { + value = cg_value(tb_inst_get_symbol_address(p->func, value.symbol), value.type); + } + GB_ASSERT(value.kind == cgValue_Value); + + TB_FunctionPrototype *proto = cg_procedure_type_as_prototype(p->module, value.type); + TB_Node *target = value.node; + auto params = slice_make(temporary_allocator(), 0); + + GB_ASSERT(target != nullptr); + TB_MultiOutput multi_output = tb_inst_call(p->func, proto, target, 0, nullptr); + gb_unused(multi_output); + return {}; +} + +gb_internal cgValue cg_build_call_expr_internal(cgProcedure *p, Ast *expr) { + ast_node(ce, CallExpr, expr); + + TypeAndValue tv = type_and_value_of_expr(expr); + + TypeAndValue proc_tv = type_and_value_of_expr(ce->proc); + AddressingMode proc_mode = proc_tv.mode; + if (proc_mode == Addressing_Type) { + GB_ASSERT(ce->args.count == 1); + cgValue x = cg_build_expr(p, ce->args[0]); + return cg_emit_conv(p, x, tv.type); + } + + Ast *proc_expr = unparen_expr(ce->proc); + if (proc_mode == Addressing_Builtin) { + Entity *e = entity_of_node(proc_expr); + BuiltinProcId id = BuiltinProc_Invalid; + if (e != nullptr) { + id = cast(BuiltinProcId)e->Builtin.id; + } else { + id = BuiltinProc_DIRECTIVE; + } + if (id == BuiltinProc___entry_point) { + if (p->module->info->entry_point) { + cgValue entry_point = cg_find_procedure_value_from_entity(p->module, p->module->info->entry_point); + GB_ASSERT(entry_point.node != nullptr); + cg_emit_call(p, entry_point, {}); + } + return {}; + } + GB_PANIC("TODO(bill): builtin procs %d %.*s", id, LIT(builtin_procs[id].name)); + } + + // NOTE(bill): Regular call + cgValue value = {}; + + Entity *proc_entity = entity_of_node(proc_expr); + if (proc_entity != nullptr) { + if (proc_entity->flags & EntityFlag_Disabled) { + GB_ASSERT(tv.type == nullptr); + return {}; + } + } + + if (proc_expr->tav.mode == Addressing_Constant) { + ExactValue v = proc_expr->tav.value; + switch (v.kind) { + case ExactValue_Integer: + { + u64 u = big_int_to_u64(&v.value_integer); + cgValue x = cg_value(tb_inst_uint(p->func, TB_TYPE_PTR, u), t_rawptr); + value = cg_emit_conv(p, x, proc_expr->tav.type); + break; + } + case ExactValue_Pointer: + { + u64 u = cast(u64)v.value_pointer; + cgValue x = cg_value(tb_inst_uint(p->func, TB_TYPE_PTR, u), t_rawptr); + value = cg_emit_conv(p, x, proc_expr->tav.type); + break; + } + } + } + + if (value.node == nullptr) { + value = cg_build_expr(p, proc_expr); + } + if (value.kind == cgValue_Addr) { + value = cg_emit_load(p, value); + } + GB_ASSERT(value.kind == cgValue_Value); + GB_ASSERT(is_type_proc(value.type)); + + return cg_emit_call(p, value, {}); +} diff --git a/src/tilde_stmt.cpp b/src/tilde_stmt.cpp index f7e68d483..07bfc0555 100644 --- a/src/tilde_stmt.cpp +++ b/src/tilde_stmt.cpp @@ -8,14 +8,16 @@ gb_internal cgValue cg_emit_load(cgProcedure *p, cgValue const &ptr, bool is_vol case cgValue_Value: return cg_lvalue_addr(ptr.node, type); case cgValue_Addr: - GB_PANIC("NOT POSSIBLE"); + GB_PANIC("NOT POSSIBLE - Cannot load an lvalue to begin with"); break; case cgValue_Symbol: return cg_lvalue_addr(tb_inst_get_symbol_address(p->func, ptr.symbol), type); } } - TB_CharUnits alignment = 1; // for the time being + // use the natural alignment + // if people need a special alignment, they can use `intrinsics.unaligned_load` + TB_CharUnits alignment = cast(TB_CharUnits)type_align_of(type); TB_Node *the_ptr = nullptr; switch (ptr.kind) { @@ -48,7 +50,9 @@ gb_internal void cg_emit_store(cgProcedure *p, cgValue dst, cgValue const &src, TB_DataType st = cg_data_type(src.type); GB_ASSERT(dt.raw == st.raw); - TB_CharUnits alignment = 1; // for the time being + // use the natural alignment + // if people need a special alignment, they can use `intrinsics.unaligned_store` + TB_CharUnits alignment = cast(TB_CharUnits)type_align_of(dst_type); if (TB_IS_VOID_TYPE(dt)) { TB_Node *dst_ptr = nullptr; @@ -281,10 +285,9 @@ gb_internal cgAddr cg_add_local(cgProcedure *p, Type *type, Entity *e, bool zero if (e != nullptr && e->token.string.len > 0 && e->token.string != "_") { // NOTE(bill): for debugging purposes only - char const *name = alloc_cstring(permanent_allocator(), e->token.string); - - TB_DebugType *debug_type = cg_debug_type(p->module, type); - tb_function_attrib_variable(p->func, local, name, debug_type); + // String name = e->token.string; + // TB_DebugType *debug_type = cg_debug_type(p->module, type); + // tb_function_attrib_variable(p->func, name.len, cast(char const *)name.text, debug_type); } if (zero_init) { @@ -546,7 +549,7 @@ gb_internal void cg_build_stmt(cgProcedure *p, Ast *node) { case_end; case_ast_node(as, AssignStmt, node); - cg_build_assign_stmt(p, as); + // cg_build_assign_stmt(p, as); case_end; case_ast_node(rs, ReturnStmt, node);