mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-08-26 06:51:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update Tilde

Browse Source
This commit is contained in:
gingerBill
2024-04-30 09:59:35 +01:00
parent e32ffdace8
commit d04039ba43
6 changed files with 75 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/tilde.cpp
View File

@@ -1,16 +1,42 @@
#include "tilde.hpp"
gb_global Slice<TB_Arena *> global_tb_arenas;
struct CGArenaPair {
TB_Arena *arenas[2];
};
gb_internal TB_Arena *cg_arena(void) {
return global_tb_arenas[current_thread_index()];
gb_global Slice<CGArenaPair> global_tb_arenas;
gb_internal TB_Arena *cg_arena(int index) {
return global_tb_arenas[current_thread_index()].arenas[index];
}
gb_internal void cg_global_arena_init(void) {
global_tb_arenas = slice_make<TB_Arena *>(permanent_allocator(), global_thread_pool.threads.count);
for_array(i, global_tb_arenas) {
global_tb_arenas[i] = tb_arena_create(2ull<<20);
global_tb_arenas = slice_make<CGArenaPair>(permanent_allocator(), global_thread_pool.threads.count);
for (CGArenaPair &pair : global_tb_arenas) {
for (TB_Arena *&arena : pair.arenas) {
arena = tb_arena_create(1ull<<20);
}
}
}
gb_global Slice<TB_Worklist *> global_tb_worklists;
gb_internal TB_Worklist *cg_worklist(void) {
return global_tb_worklists[current_thread_index()];
}
gb_internal void cg_global_worklist_init(void) {
global_tb_worklists = slice_make<TB_Worklist *>(permanent_allocator(), global_thread_pool.threads.count);
for (TB_Worklist *&worklist : global_tb_worklists) {
worklist = tb_worklist_alloc();
}
}
gb_internal void cg_global_worklist_destroy(void) {
for (TB_Worklist *worklist : global_tb_worklists) {
tb_worklist_free(worklist);
}
}
@@ -248,7 +274,9 @@ gb_internal void cg_add_member(cgModule *m, String const &name, cgValue const &v
gb_internal void cg_add_procedure_value(cgModule *m, cgProcedure *p) {
rw_mutex_lock(&m->values_mutex);
if (p->entity != nullptr) {
map_set(&m->procedure_values, p->func, p->entity);
if (p->func != nullptr) {
map_set(&m->procedure_values, p->func, p->entity);
}
if (p->symbol != nullptr) {
map_set(&m->symbols, p->entity, p->symbol);
}
@@ -729,6 +757,7 @@ gb_internal bool cg_generate_code(Checker *c, LinkerData *linker_data) {
#endif
cg_global_arena_init();
cg_global_worklist_init();
cgModule *m = cg_module_create(c);
defer (cg_module_destroy(m));
@@ -828,8 +857,11 @@ gb_internal bool cg_generate_code(Checker *c, LinkerData *linker_data) {
break;
}
}
TB_ExportBuffer export_buffer = tb_module_object_export(m->mod, cg_arena(), debug_format);
// defer (tb_export_buffer_free(export_buffer)); // THIS IS MISSING
TB_Arena *export_arena = tb_arena_create(0);
defer (tb_arena_destroy(export_arena));
TB_ExportBuffer export_buffer = tb_module_object_export(m->mod, export_arena, debug_format);
String filepath_obj = cg_filepath_obj_for_module(m, false);
array_add(&linker_data->output_object_paths, filepath_obj);

4
src/tilde.hpp
View File

@@ -167,6 +167,8 @@ struct cgProcedure {
TB_FunctionPrototype *proto;
TB_Symbol *symbol;
TB_Arena *arenas[2];
Entity * entity;
cgModule *module;
String name;
@@ -272,7 +274,7 @@ gb_global cgProcedure *cg_cleanup_runtime_proc = nullptr;
gb_internal TB_Arena *cg_arena(void);
gb_internal TB_Arena *cg_arena(int index=0);
gb_internal cgProcedure *cg_procedure_create(cgModule *m, Entity *entity, bool ignore_body=false);
gb_internal void cg_add_procedure_to_queue(cgProcedure *p);

BIN
src/tilde/tb.lib
View File

Binary file not shown.

15
src/tilde_builtin.cpp
View File

@@ -581,6 +581,21 @@ gb_internal cgValue cg_build_builtin(cgProcedure *p, BuiltinProcId id, Ast *expr
return cg_emit_arith(p, Token_Sub, size, cg_value(ones, n.type), n.type);
}
case BuiltinProc_volatile_load:
{
cgValue ptr = cg_build_expr(p, ce->args[0]);
ptr = cg_flatten_value(p, ptr);
GB_ASSERT(ptr.kind == cgValue_Value);
return cg_emit_load(p, ptr, true);
}
case BuiltinProc_volatile_store:
{
cgValue ptr = cg_build_expr(p, ce->args[0]);
cgValue val = cg_build_expr(p, ce->args[1]);
cg_emit_store(p, ptr, val, true);
return {};
}
}

56
src/tilde_proc.cpp
View File

@@ -96,6 +96,10 @@ gb_internal cgProcedure *cg_procedure_create(cgModule *m, Entity *entity, bool i
if (p->symbol == nullptr) {
p->func = tb_function_create(m->mod, link_name.len, cast(char const *)link_name.text, linkage);
p->arenas[0] = tb_arena_create(0);
p->arenas[1] = tb_arena_create(0);
tb_function_set_arenas(p->func, p->arenas[0], p->arenas[1]);
p->debug_type = cg_debug_type_for_proc(m, p->type);
p->proto = tb_prototype_from_dbg(m->mod, p->debug_type);
@@ -105,6 +109,8 @@ gb_internal cgProcedure *cg_procedure_create(cgModule *m, Entity *entity, bool i
p->value = cg_value(p->symbol, p->type);
GB_ASSERT(p->symbol != nullptr || p->func != nullptr);
cg_add_symbol(m, entity, p->symbol);
cg_add_entity(m, entity, p->value);
cg_add_member(m, p->name, p->value);
@@ -225,6 +231,11 @@ gb_internal void cg_procedure_begin(cgProcedure *p) {
}
TB_ModuleSectionHandle section = tb_module_get_text(p->module->mod);
if (p->arenas[0] == nullptr) {
p->arenas[0] = tb_arena_create(0);
p->arenas[1] = tb_arena_create(0);
}
tb_function_set_arenas(p->func, p->arenas[0], p->arenas[1]);
tb_function_set_prototype(p->func, section, p->proto);
if (p->body == nullptr) {
@@ -370,48 +381,11 @@ gb_internal WORKER_TASK_PROC(cg_procedure_compile_worker_proc) {
cgProcedure *p = cast(cgProcedure *)data;
gb_unused(p);
// TB_Passes *opt = tb_pass_enter(p->func, cg_arena());
// defer (tb_pass_exit(opt));
tb_print(p->func, cg_arena());
fprintf(stdout, "\n");
// // optimization passes
// if (false) {
// tb_pass_peephole(opt, TB_PEEPHOLE_ALL);
// tb_pass_mem2reg(opt);
// tb_pass_peephole(opt, TB_PEEPHOLE_ALL);
// }
// bool emit_asm = false;
// if (
// // string_starts_with(p->name, str_lit("runtime@_windows_default_alloc_or_resize")) ||
// false
// ) {
// emit_asm = true;
// }
// // emit ir
// if (
// // string_starts_with(p->name, str_lit("main@")) ||
// false
// ) { // IR Printing
// TB_Arena *arena = cg_arena();
// TB_Passes *passes = tb_pass_enter(p->func, arena);
// defer (tb_pass_exit(passes));
// tb_pass_print(passes);
// fprintf(stdout, "\n");
// fflush(stdout);
// }
// if (false) { // GraphViz printing
// tb_pass_print_dot(opt, tb_default_print_callback, stdout);
// }
// // compile
// TB_FunctionOutput *output = tb_pass_codegen(opt, emit_asm);
// if (emit_asm) {
// tb_output_print_asm(output, stdout);
// fprintf(stdout, "\n");
// fflush(stdout);
// }
// bool preserve_types = true;
// tb_opt(p->func, cg_worklist(), preserve_types);
return 0;
}

3
src/tilde_stmt.cpp
View File

@@ -1257,8 +1257,7 @@ gb_internal void cg_build_return_stmt(cgProcedure *p, Slice<Ast *> const &return
cg_append_tuple_values(p, &results, res);
}
} else {
for_array(i, tuple->variables) {
Entity *e = tuple->variables[i];
for (Entity *e : tuple->variables) {
cgAddr addr = map_must_get(&p->variable_map, e);
cgValue res = cg_addr_load(p, addr);
array_add(&results, res);