mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-02-18 00:48:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Core library and Better name mangling for files

Browse Source
This commit is contained in:
Ginger Bill
2016-09-19 11:51:21 +01:00
parent 828095afd1
commit bbc9739f5c
11 changed files with 1643 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/codegen/codegen.cpp
View File

@@ -58,7 +58,7 @@ String ssa_mangle_name(ssaGen *s, String path, String name) {
u8 *new_name = gb_alloc_array(a, u8, max_len);
isize new_name_len = gb_snprintf(
cast(char *)new_name, max_len,
"%.*s$%u.%.*s",
"%.*s-%u.%.*s",
base_len, base,
file->id,
LIT(name));
@@ -104,8 +104,7 @@ void ssa_gen_tree(ssaGen *s) {
switch (e->kind) {
case Entity_TypeName:
GB_ASSERT(e->type->kind == Type_Named);
// HACK(bill): Rename type's name for ssa gen
e->type->Named.name = name;
map_set(&m->type_names, hash_pointer(e->type), name);
ssa_gen_global_type_name(m, e, name);
break;

124
src/codegen/print_llvm.cpp
View File

@@ -128,7 +128,8 @@ void ssa_print_encoded_global(ssaFileBuffer *f, String name, b32 global_scope) {
}
void ssa_print_type(ssaFileBuffer *f, BaseTypeSizes s, Type *t) {
void ssa_print_type(ssaFileBuffer *f, ssaModule *m, Type *t) {
BaseTypeSizes s = m->sizes;
i64 word_bits = 8*s.word_size;
GB_ASSERT_NOT_NULL(t);
t = default_type(t);
@@ -155,27 +156,27 @@ void ssa_print_type(ssaFileBuffer *f, BaseTypeSizes s, Type *t) {
case Basic_int: ssa_fprintf(f, "i%lld", word_bits); break;
case Basic_any:
ssa_fprintf(f, "{");
ssa_print_type(f, s, t_type_info_ptr);
ssa_print_type(f, m, t_type_info_ptr);
ssa_fprintf(f, ", ");
ssa_print_type(f, s, t_rawptr);
ssa_print_type(f, m, t_rawptr);
ssa_fprintf(f, "}");
break;
}
break;
case Type_Array:
ssa_fprintf(f, "[%lld x ", t->Array.count);
ssa_print_type(f, s, t->Array.elem);
ssa_print_type(f, m, t->Array.elem);
ssa_fprintf(f, "]");
break;
case Type_Vector: {
// TODO(bill): actually do correctly
ssa_fprintf(f, "<%lld x ", t->Vector.count);
ssa_print_type(f, s, t->Vector.elem);
ssa_print_type(f, m, t->Vector.elem);
ssa_fprintf(f, ">");
} break;
case Type_Slice:
ssa_fprintf(f, "{");
ssa_print_type(f, s, t->Slice.elem);
ssa_print_type(f, m, t->Slice.elem);
ssa_fprintf(f, "*, i%lld, i%lld}", word_bits, word_bits);
break;
case Type_Record: {
@@ -194,7 +195,7 @@ void ssa_print_type(ssaFileBuffer *f, BaseTypeSizes s, Type *t) {
if (!is_type_struct(bft)) {
ft = bft;
}
ssa_print_type(f, s, ft);
ssa_print_type(f, m, ft);
}
ssa_fprintf(f, "}");
if (t->Record.struct_is_packed) {
@@ -209,30 +210,33 @@ void ssa_print_type(ssaFileBuffer *f, BaseTypeSizes s, Type *t) {
ssa_fprintf(f, "[%lld x i8]", type_size_of(s, gb_heap_allocator(), t));
break;
case TypeRecord_Enum:
ssa_print_type(f, s, t->Record.enum_base);
ssa_print_type(f, m, t->Record.enum_base);
break;
}
} break;
case Type_Pointer:
ssa_print_type(f, s, t->Pointer.elem);
ssa_print_type(f, m, t->Pointer.elem);
ssa_fprintf(f, "*");
break;
case Type_Named:
if (is_type_struct(t) || is_type_union(t)) {
ssa_print_encoded_local(f, t->Named.name);
String *name = map_get(&m->type_names, hash_pointer(t));
GB_ASSERT(name != NULL);
ssa_print_encoded_local(f, *name);
// ssa_print_encoded_local(f, t->Named.name);
} else {
ssa_print_type(f, s, get_base_type(t));
ssa_print_type(f, m, get_base_type(t));
}
break;
case Type_Tuple:
if (t->Tuple.variable_count == 1) {
ssa_print_type(f, s, t->Tuple.variables[0]->type);
ssa_print_type(f, m, t->Tuple.variables[0]->type);
} else {
ssa_fprintf(f, "{");
for (isize i = 0; i < t->Tuple.variable_count; i++) {
if (i > 0) ssa_fprintf(f, ", ");
ssa_print_type(f, s, t->Tuple.variables[i]->type);
ssa_print_type(f, m, t->Tuple.variables[i]->type);
}
ssa_fprintf(f, "}");
}
@@ -241,7 +245,7 @@ void ssa_print_type(ssaFileBuffer *f, BaseTypeSizes s, Type *t) {
if (t->Proc.result_count == 0) {
ssa_fprintf(f, "void");
} else {
ssa_print_type(f, s, t->Proc.results);
ssa_print_type(f, m, t->Proc.results);
}
ssa_fprintf(f, " (");
auto *params = &t->Proc.params->Tuple;
@@ -249,7 +253,7 @@ void ssa_print_type(ssaFileBuffer *f, BaseTypeSizes s, Type *t) {
if (i > 0) {
ssa_fprintf(f, ", ");
}
ssa_print_type(f, s, params->variables[i]->type);
ssa_print_type(f, m, params->variables[i]->type);
}
ssa_fprintf(f, ")*");
} break;
@@ -281,9 +285,9 @@ void ssa_print_exact_value(ssaFileBuffer *f, ssaModule *m, ExactValue value, Typ
ssa_fprintf(f, "null");
} else {
ssa_fprintf(f, "inttoptr (");
ssa_print_type(f, m->sizes, t_int);
ssa_print_type(f, m, t_int);
ssa_fprintf(f, " %llu to ", value.value_integer);
ssa_print_type(f, m->sizes, t_rawptr);
ssa_print_type(f, m, t_rawptr);
ssa_fprintf(f, ")");
}
} else {
@@ -307,9 +311,9 @@ void ssa_print_exact_value(ssaFileBuffer *f, ssaModule *m, ExactValue value, Typ
ssa_fprintf(f, "null");
} else {
ssa_fprintf(f, "inttoptr (");
ssa_print_type(f, m->sizes, t_int);
ssa_print_type(f, m, t_int);
ssa_fprintf(f, " %llu to ", cast(u64)cast(uintptr)value.value_pointer);
ssa_print_type(f, m->sizes, t_rawptr);
ssa_print_type(f, m, t_rawptr);
ssa_fprintf(f, ")");
}
break;
@@ -344,15 +348,15 @@ void ssa_print_value(ssaFileBuffer *f, ssaModule *m, ssaValue *value, Type *type
}
if (type_hint != NULL && is_type_string(type_hint)) {
ssa_fprintf(f, "{i8* getelementptr inbounds (");
ssa_print_type(f, m->sizes, value->Global.entity->type);
ssa_print_type(f, m, value->Global.entity->type);
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, value->Global.entity->type);
ssa_print_type(f, m, value->Global.entity->type);
ssa_fprintf(f, "* ");
ssa_print_encoded_global(f, value->Global.entity->token.string, in_global_scope);
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, t_int);
ssa_print_type(f, m, t_int);
ssa_fprintf(f, " 0, i32 0), ");
ssa_print_type(f, m->sizes, t_int);
ssa_print_type(f, m, t_int);
ssa_fprintf(f, " %lld}", 0);
} else {
ssa_print_encoded_global(f, value->Global.entity->token.string, in_global_scope);
@@ -390,13 +394,13 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
case ssaInstr_Local: {
Type *type = instr->Local.entity->type;
ssa_fprintf(f, "%%%d = alloca ", value->id);
ssa_print_type(f, m->sizes, type);
ssa_print_type(f, m, type);
ssa_fprintf(f, ", align %lld\n", type_align_of(m->sizes, m->allocator, type));
// if (instr->Local.zero_initialized) {
// ssa_fprintf(f, "\tstore ");
// ssa_print_type(f, m->sizes, type);
// ssa_print_type(f, m, type);
// ssa_fprintf(f, " zeroinitializer, ");
// ssa_print_type(f, m->sizes, type);
// ssa_print_type(f, m, type);
// ssa_fprintf(f, "* %%%d\n", value->id);
// }
} break;
@@ -404,9 +408,9 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
case ssaInstr_ZeroInit: {
Type *type = type_deref(ssa_type(instr->ZeroInit.address));
ssa_fprintf(f, "\tstore ");
ssa_print_type(f, m->sizes, type);
ssa_print_type(f, m, type);
ssa_fprintf(f, " zeroinitializer, ");
ssa_print_type(f, m->sizes, type);
ssa_print_type(f, m, type);
ssa_fprintf(f, "* %%%d\n", instr->ZeroInit.address->id);
} break;
@@ -416,11 +420,11 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
if ((type->flags & TypeFlag_volatile) != 0) {
ssa_fprintf(f, "volatile ");
}
ssa_print_type(f, m->sizes, type);
ssa_print_type(f, m, type);
ssa_fprintf(f, " ");
ssa_print_value(f, m, instr->Store.value, type);
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, type);
ssa_print_type(f, m, type);
ssa_fprintf(f, "* ");
ssa_print_value(f, m, instr->Store.address, type);
ssa_fprintf(f, "\n");
@@ -432,9 +436,9 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
if ((type->flags & TypeFlag_volatile) != 0) {
ssa_fprintf(f, "volatile ");
}
ssa_print_type(f, m->sizes, type);
ssa_print_type(f, m, type);
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, type);
ssa_print_type(f, m, type);
ssa_fprintf(f, "* ");
ssa_print_value(f, m, instr->Load.address, type);
ssa_fprintf(f, ", align %lld\n", type_align_of(m->sizes, m->allocator, type));
@@ -447,16 +451,16 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
ssa_fprintf(f, "inbounds ");
}
ssa_print_type(f, m->sizes, type_deref(et));
ssa_print_type(f, m, type_deref(et));
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, et);
ssa_print_type(f, m, et);
ssa_fprintf(f, " ");
ssa_print_value(f, m, instr->GetElementPtr.address, et);
for (isize i = 0; i < instr->GetElementPtr.index_count; i++) {
ssaValue *index = instr->GetElementPtr.indices[i];
Type *t = ssa_type(index);
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, t);
ssa_print_type(f, m, t);
ssa_fprintf(f, " ");
ssa_print_value(f, m, index, t);
}
@@ -467,7 +471,7 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
Type *et = instr->ExtractValue.elem_type;
ssa_fprintf(f, "%%%d = extractvalue ", value->id);
ssa_print_type(f, m->sizes, et);
ssa_print_type(f, m, et);
ssa_fprintf(f, " ");
ssa_print_value(f, m, instr->ExtractValue.address, et);
ssa_fprintf(f, ", %d\n", instr->ExtractValue.index);
@@ -480,7 +484,7 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
case ssaInstr_Br: {;
ssa_fprintf(f, "br ");
if (instr->Br.cond != NULL) {
ssa_print_type(f, m->sizes, t_bool);
ssa_print_type(f, m, t_bool);
ssa_fprintf(f, " ");
ssa_print_value(f, m, instr->Br.cond, t_bool);
ssa_fprintf(f, ", ", instr->Br.cond->id);
@@ -501,7 +505,7 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
ssa_fprintf(f, "void");
} else {
Type *t = ssa_type(ret->value);
ssa_print_type(f, m->sizes, t);
ssa_print_type(f, m, t);
ssa_fprintf(f, " ");
ssa_print_value(f, m, ret->value, t);
}
@@ -513,11 +517,11 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
case ssaInstr_Conv: {
auto *c = &instr->Conv;
ssa_fprintf(f, "%%%d = %.*s ", value->id, LIT(ssa_conv_strings[c->kind]));
ssa_print_type(f, m->sizes, c->from);
ssa_print_type(f, m, c->from);
ssa_fprintf(f, " ");
ssa_print_value(f, m, c->value, c->from);
ssa_fprintf(f, " to ");
ssa_print_type(f, m->sizes, c->to);
ssa_print_type(f, m, c->to);
ssa_fprintf(f, "\n");
} break;
@@ -539,7 +543,7 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
if (gb_is_between(bo->op.kind, Token__ComparisonBegin+1, Token__ComparisonEnd-1)) {
if (is_type_string(elem_type)) {
ssa_fprintf(f, "call ");
ssa_print_type(f, m->sizes, t_bool);
ssa_print_type(f, m, t_bool);
char *runtime_proc = "";
switch (bo->op.kind) {
case Token_CmpEq: runtime_proc = "__string_eq"; break;
@@ -553,11 +557,11 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
ssa_fprintf(f, " ");
ssa_print_encoded_global(f, make_string(runtime_proc), false);
ssa_fprintf(f, "(");
ssa_print_type(f, m->sizes, type);
ssa_print_type(f, m, type);
ssa_fprintf(f, " ");
ssa_print_value(f, m, bo->left, type);
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, type);
ssa_print_type(f, m, type);
ssa_fprintf(f, " ");
ssa_print_value(f, m, bo->right, type);
ssa_fprintf(f, ")\n");
@@ -624,7 +628,7 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
}
ssa_fprintf(f, " ");
ssa_print_type(f, m->sizes, type);
ssa_print_type(f, m, type);
ssa_fprintf(f, " ");
ssa_print_value(f, m, bo->left, type);
ssa_fprintf(f, ", ");
@@ -641,7 +645,7 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
}
ssa_fprintf(f, "call ");
if (result_type) {
ssa_print_type(f, m->sizes, result_type);
ssa_print_type(f, m, result_type);
} else {
ssa_fprintf(f, "void");
}
@@ -661,7 +665,7 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
if (i > 0) {
ssa_fprintf(f, ", ");
}
ssa_print_type(f, m->sizes, t);
ssa_print_type(f, m, t);
ssa_fprintf(f, " ");
ssaValue *arg = call->args[i];
ssa_print_value(f, m, arg, t);
@@ -675,11 +679,11 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
ssa_fprintf(f, "%%%d = select i1 ", value->id);
ssa_print_value(f, m, instr->Select.cond, t_bool);
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, ssa_type(instr->Select.true_value));
ssa_print_type(f, m, ssa_type(instr->Select.true_value));
ssa_fprintf(f, " ");
ssa_print_value(f, m, instr->Select.true_value, ssa_type(instr->Select.true_value));
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, ssa_type(instr->Select.false_value));
ssa_print_type(f, m, ssa_type(instr->Select.false_value));
ssa_fprintf(f, " ");
ssa_print_value(f, m, instr->Select.false_value, ssa_type(instr->Select.false_value));
ssa_fprintf(f, "\n");
@@ -689,12 +693,12 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
Type *vt = ssa_type(instr->ExtractElement.vector);
ssa_fprintf(f, "%%%d = extractelement ", value->id);
ssa_print_type(f, m->sizes, vt);
ssa_print_type(f, m, vt);
ssa_fprintf(f, " ");
ssa_print_value(f, m, instr->ExtractElement.vector, vt);
ssa_fprintf(f, ", ");
Type *it = ssa_type(instr->ExtractElement.index);
ssa_print_type(f, m->sizes, it);
ssa_print_type(f, m, it);
ssa_fprintf(f, " ");
ssa_print_value(f, m, instr->ExtractElement.index, it);
ssa_fprintf(f, "\n");
@@ -705,17 +709,17 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
Type *vt = ssa_type(ie->vector);
ssa_fprintf(f, "%%%d = insertelement ", value->id);
ssa_print_type(f, m->sizes, vt);
ssa_print_type(f, m, vt);
ssa_fprintf(f, " ");
ssa_print_value(f, m, ie->vector, vt);
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, ssa_type(ie->elem));
ssa_print_type(f, m, ssa_type(ie->elem));
ssa_fprintf(f, " ");
ssa_print_value(f, m, ie->elem, ssa_type(ie->elem));
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, ssa_type(ie->index));
ssa_print_type(f, m, ssa_type(ie->index));
ssa_fprintf(f, " ");
ssa_print_value(f, m, ie->index, ssa_type(ie->index));
@@ -727,12 +731,12 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
Type *vt = ssa_type(sv->vector);
ssa_fprintf(f, "%%%d = shufflevector ", value->id);
ssa_print_type(f, m->sizes, vt);
ssa_print_type(f, m, vt);
ssa_fprintf(f, " ");
ssa_print_value(f, m, sv->vector, vt);
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, vt);
ssa_print_type(f, m, vt);
ssa_fprintf(f, " ");
ssa_print_value(f, m, sv->vector, vt);
ssa_fprintf(f, ", ");
@@ -780,7 +784,7 @@ void ssa_print_proc(ssaFileBuffer *f, ssaModule *m, ssaProcedure *proc) {
if (proc_type->result_count == 0) {
ssa_fprintf(f, "void");
} else {
ssa_print_type(f, m->sizes, proc_type->results);
ssa_print_type(f, m, proc_type->results);
}
ssa_fprintf(f, " ");
@@ -798,7 +802,7 @@ void ssa_print_proc(ssaFileBuffer *f, ssaModule *m, ssaProcedure *proc) {
if (i > 0) {
ssa_fprintf(f, ", ");
}
ssa_print_type(f, m->sizes, e->type);
ssa_print_type(f, m, e->type);
if (proc->body != NULL) {
ssa_fprintf(f, " %%%.*s", LIT(e->token.string));
}
@@ -860,7 +864,7 @@ void ssa_print_type_name(ssaFileBuffer *f, ssaModule *m, ssaValue *v) {
}
ssa_print_encoded_local(f, v->TypeName.name);
ssa_fprintf(f, " = type ");
ssa_print_type(f, m->sizes, get_base_type(v->TypeName.type));
ssa_print_type(f, m, get_base_type(v->TypeName.type));
ssa_fprintf(f, "\n");
}
@@ -871,7 +875,7 @@ void ssa_print_llvm_ir(ssaFileBuffer *f, ssaModule *m) {
ssa_print_encoded_local(f, make_string("..string"));
ssa_fprintf(f, " = type {i8*, ");
ssa_print_type(f, m->sizes, t_int);
ssa_print_type(f, m, t_int);
ssa_fprintf(f, "} ; Basic_string\n");
ssa_print_encoded_local(f, make_string("..rawptr"));
@@ -936,7 +940,7 @@ void ssa_print_llvm_ir(ssaFileBuffer *f, ssaModule *m) {
}
ssa_print_type(f, m->sizes, g->entity->type);
ssa_print_type(f, m, g->entity->type);
ssa_fprintf(f, " ");
if (g->value != NULL) {
ssa_print_value(f, m, g->value, g->entity->type);

81
src/codegen/ssa.cpp
View File

@@ -57,6 +57,7 @@ struct ssaModule {
Map<ssaValue *> values; // Key: Entity *
Map<ssaValue *> members; // Key: String
Map<String> type_names; // Key: Type *
Map<ssaDebugInfo *> debug_info; // Key: Unique pointer
i32 global_string_index;
};
@@ -330,7 +331,6 @@ struct ssaAddr {
ssaValue *addr;
AstNode *expr; // NOTE(bill): Just for testing - probably remove later
// HACK(bill): Fix how lvalues for vectors work
b32 is_vector;
ssaValue *index;
};
@@ -371,6 +371,7 @@ void ssa_init_module(ssaModule *m, Checker *c) {
map_init(&m->values, gb_heap_allocator());
map_init(&m->members, gb_heap_allocator());
map_init(&m->debug_info, gb_heap_allocator());
map_init(&m->type_names, gb_heap_allocator());
// Default states
m->stmt_state_flags = 0;
@@ -439,6 +440,7 @@ void ssa_init_module(ssaModule *m, Checker *c) {
void ssa_destroy_module(ssaModule *m) {
map_destroy(&m->values);
map_destroy(&m->members);
map_destroy(&m->type_names);
map_destroy(&m->debug_info);
gb_arena_free(&m->arena);
}
@@ -962,7 +964,7 @@ void ssa_emit_jump(ssaProcedure *proc, ssaBlock *block);
void ssa_build_defer_stmt(ssaProcedure *proc, ssaDefer d) {
ssaBlock *b = ssa__make_block(proc, NULL, make_string("defer"));
// HACK(bill): The prev block may defer injection before it's terminator
// NOTE(bill): The prev block may defer injection before it's terminator
ssaInstr *last_instr = ssa_get_last_instr(proc->curr_block);
if (last_instr == NULL || !ssa_is_instr_terminating(last_instr)) {
ssa_emit_jump(proc, b);
@@ -1031,17 +1033,14 @@ void ssa_emit_no_op(ssaProcedure *proc) {
ssaValue *ssa_lvalue_store(ssaProcedure *proc, ssaAddr lval, ssaValue *value) {
if (lval.addr != NULL) {
if (lval.is_vector) {
// HACK(bill): Fix how lvalues for vectors work
ssaValue *v = ssa_emit_load(proc, lval.addr);
Type *elem_type = get_base_type(ssa_type(v))->Vector.elem;
ssaValue *elem = ssa_emit_conv(proc, value, elem_type);
ssaValue *out = ssa_emit(proc, ssa_make_instr_insert_element(proc, v, elem, lval.index));
return ssa_emit_store(proc, lval.addr, out);
} else {
// gb_printf_err("%s <- %s\n", type_to_string(ssa_addr_type(lval)), type_to_string(ssa_type(value)));
// gb_printf_err("%.*s - %s\n", LIT(ast_node_strings[lval.expr->kind]), expr_to_string(lval.expr));
value = ssa_emit_conv(proc, value, ssa_addr_type(lval));
return ssa_emit_store(proc, lval.addr, value);
ssaValue *v = ssa_emit_conv(proc, value, ssa_addr_type(lval));
return ssa_emit_store(proc, lval.addr, v);
}
}
return NULL;
@@ -1049,11 +1048,10 @@ ssaValue *ssa_lvalue_store(ssaProcedure *proc, ssaAddr lval, ssaValue *value) {
ssaValue *ssa_lvalue_load(ssaProcedure *proc, ssaAddr lval) {
if (lval.addr != NULL) {
if (lval.is_vector) {
// HACK(bill): Fix how lvalues for vectors work
ssaValue *v = ssa_emit_load(proc, lval.addr);
return ssa_emit(proc, ssa_make_instr_extract_element(proc, v, lval.index));
}
// HACK(bill): Imported procedures don't require a load
// NOTE(bill): Imported procedures don't require a load as they are pointers
Type *t = get_base_type(ssa_type(lval.addr));
if (t->kind == Type_Proc) {
return lval.addr;
@@ -2239,8 +2237,8 @@ ssaValue *ssa_build_single_expr(ssaProcedure *proc, AstNode *expr, TypeAndValue
err_len += 20;
err_len += gb_string_length(expr);
err_len += 2;
// HACK(bill): memory leaks
u8 *err_str = gb_alloc_array(gb_heap_allocator(), u8, err_len);
u8 *err_str = gb_alloc_array(proc->module->allocator, u8, err_len);
err_len = gb_snprintf(cast(char *)err_str, err_len,
"%.*s(%td:%td) Runtime assertion: %s\n",
LIT(pos.file), pos.line, pos.column, expr);
@@ -2718,7 +2716,6 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) {
switch (be->op.kind) {
case Token_as: {
ssa_emit_comment(proc, make_string("Cast - as"));
// HACK(bill): Do have to make new variable to do this?
// NOTE(bill): Needed for dereference of pointer conversion
Type *type = type_of_expr(proc->module->info, expr);
ssaValue *v = ssa_add_local_generated(proc, type);
@@ -2727,7 +2724,6 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) {
}
case Token_transmute: {
ssa_emit_comment(proc, make_string("Cast - transmute"));
// HACK(bill): Do have to make new variable to do this?
// NOTE(bill): Needed for dereference of pointer conversion
Type *type = type_of_expr(proc->module->info, expr);
ssaValue *v = ssa_add_local_generated(proc, type);
@@ -2747,7 +2743,6 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) {
switch (t->kind) {
case Type_Vector: {
// HACK(bill): Fix how lvalues for vectors work
ssaValue *vector = ssa_build_addr(proc, ie->expr).addr;
ssaValue *index = ssa_emit_conv(proc, ssa_build_expr(proc, ie->index), t_int);
ssaValue *len = ssa_make_const_int(a, t->Vector.count);
@@ -2961,6 +2956,27 @@ void ssa_build_cond(ssaProcedure *proc, AstNode *cond, ssaBlock *true_block, ssa
ssa_emit_if(proc, expr, true_block, false_block);
}
void ssa_gen_global_type_name(ssaModule *m, Entity *e, String name);
void ssa_mangle_sub_type_name(ssaModule *m, Entity *field, String parent) {
if (field->kind != Entity_TypeName) {
return;
}
auto *tn = &field->type->Named;
String cn = field->token.string;
isize len = parent.len + 1 + cn.len;
String child = {NULL, len};
child.text = gb_alloc_array(m->allocator, u8, len);
isize i = 0;
gb_memcopy(child.text+i, parent.text, parent.len);
i += parent.len;
child.text[i++] = '.';
gb_memcopy(child.text+i, cn.text, cn.len);
map_set(&m->type_names, hash_pointer(field->type), child);
ssa_gen_global_type_name(m, field, child);
}
void ssa_gen_global_type_name(ssaModule *m, Entity *e, String name) {
ssaValue *t = ssa_make_value_type_name(m->allocator, name, e->type);
@@ -2971,22 +2987,7 @@ void ssa_gen_global_type_name(ssaModule *m, Entity *e, String name) {
if (bt->kind == Type_Record) {
auto *s = &bt->Record;
for (isize j = 0; j < s->other_field_count; j++) {
Entity *field = s->other_fields[j];
if (field->kind == Entity_TypeName) {
// HACK(bill): Override name of type so printer prints it correctly
auto *tn = &field->type->Named;
String cn = field->token.string;
isize len = name.len + 1 + cn.len;
String child = {NULL, len};
child.text = gb_alloc_array(m->allocator, u8, len);
isize i = 0;
gb_memcopy(child.text+i, name.text, name.len);
i += name.len;
child.text[i++] = '.';
gb_memcopy(child.text+i, cn.text, cn.len);
tn->name = child;
ssa_gen_global_type_name(m, field, tn->name);
}
ssa_mangle_sub_type_name(m, s->other_fields[j], name);
}
}
@@ -2994,22 +2995,7 @@ void ssa_gen_global_type_name(ssaModule *m, Entity *e, String name) {
auto *s = &bt->Record;
// NOTE(bill): Zeroth entry is null (for `match type` stmts)
for (isize j = 1; j < s->field_count; j++) {
Entity *field = s->fields[j];
if (field->kind == Entity_TypeName) {
// HACK(bill): Override name of type so printer prints it correctly
auto *tn = &field->type->Named;
String cn = field->token.string;
isize len = name.len + 1 + cn.len;
String child = {NULL, len};
child.text = gb_alloc_array(m->allocator, u8, len);
isize i = 0;
gb_memcopy(child.text+i, name.text, name.len);
i += name.len;
child.text[i++] = '.';
gb_memcopy(child.text+i, cn.text, cn.len);
tn->name = child;
ssa_gen_global_type_name(m, field, tn->name);
}
ssa_mangle_sub_type_name(m, s->fields[j], name);
}
}
}
@@ -3199,8 +3185,7 @@ void ssa_build_stmt(ssaProcedure *proc, AstNode *node) {
Entity *e = *found;
ssaValue *value = ssa_make_value_type_name(proc->module->allocator,
name, e->type);
// HACK(bill): Override name of type so printer prints it correctly
e->type->Named.name = name;
map_set(&proc->module->type_names, hash_pointer(e->type), name);
ssa_gen_global_type_name(proc->module, e, name);
case_end;

2
src/parser.cpp
View File

@@ -2752,7 +2752,6 @@ String get_fullpath_relative(gbAllocator a, String base_dir, String path) {
gb_memcopy(str, base_dir.text, base_dir.len);
gb_memcopy(str+base_dir.len, path.text, path.len);
str[str_len] = '\0';
// HACK(bill): memory leak
char *path_str = gb_path_get_full_name(a, cast(char *)str);
return make_string(path_str);
}
@@ -2779,7 +2778,6 @@ String get_fullpath_core(gbAllocator a, String path) {
gb_memcopy(str+buf_len, core, core_len);
gb_memcopy(str+buf_len+core_len, path.text, path.len);
str[str_len] = '\0';
// HACK(bill): memory leak
char *path_str = gb_path_get_full_name(a, cast(char *)str);
return make_string(path_str);}