File restructure (again)

1 files changed, 0 insertions, 495 deletions

diff --git a/src/ssa/make.cpp b/src/ssa/make.cpp
deleted file mode 100644
index 47ae3a305..000000000
--- a/src/ssa/make.cpp
+++ /dev/null
@@ -1,495 +0,0 @@
-void ssa_module_add_value(ssaModule *m, Entity *e, ssaValue *v);
-ssaValue *ssa_emit_zero_init(ssaProcedure *p, ssaValue *address);
-ssaValue *ssa_emit_comment(ssaProcedure *p, String text);
-ssaValue *ssa_emit_store(ssaProcedure *p, ssaValue *address, ssaValue *value);
-ssaValue *ssa_emit_load(ssaProcedure *p, ssaValue *address);
-
-
-ssaValue *ssa_alloc_value(gbAllocator a, ssaValueKind kind) {
-	ssaValue *v = gb_alloc_item(a, ssaValue);
-	v->kind = kind;
-	return v;
-}
-ssaValue *ssa_alloc_instr(ssaProcedure *proc, ssaInstrKind kind) {
-	ssaValue *v = ssa_alloc_value(proc->module->allocator, ssaValue_Instr);
-	v->Instr.kind = kind;
-	proc->instr_count++;
-	return v;
-}
-ssaDebugInfo *ssa_alloc_debug_info(gbAllocator a, ssaDebugInfoKind kind) {
-	ssaDebugInfo *di = gb_alloc_item(a, ssaDebugInfo);
-	di->kind = kind;
-	return di;
-}
-
-
-
-
-ssaValue *ssa_make_value_type_name(gbAllocator a, String name, Type *type) {
-	ssaValue *v = ssa_alloc_value(a, ssaValue_TypeName);
-	v->TypeName.name = name;
-	v->TypeName.type = type;
-	return v;
-}
-
-ssaValue *ssa_make_value_global(gbAllocator a, Entity *e, ssaValue *value) {
-	ssaValue *v = ssa_alloc_value(a, ssaValue_Global);
-	v->Global.entity = e;
-	v->Global.type = make_type_pointer(a, e->type);
-	v->Global.value = value;
-	array_init(&v->Global.referrers, heap_allocator()); // TODO(bill): Replace heap allocator here
-	return v;
-}
-ssaValue *ssa_make_value_param(gbAllocator a, ssaProcedure *parent, Entity *e) {
-	ssaValue *v = ssa_alloc_value(a, ssaValue_Param);
-	v->Param.parent = parent;
-	v->Param.entity = e;
-	v->Param.type   = e->type;
-	array_init(&v->Param.referrers, heap_allocator()); // TODO(bill): Replace heap allocator here
-	return v;
-}
-ssaValue *ssa_make_value_nil(gbAllocator a, Type *type) {
-	ssaValue *v = ssa_alloc_value(a, ssaValue_Nil);
-	v->Nil.type = type;
-	return v;
-}
-
-
-
-ssaValue *ssa_make_instr_local(ssaProcedure *p, Entity *e, b32 zero_initialized) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_Local);
-	ssaInstr *i = &v->Instr;
-	i->Local.entity = e;
-	i->Local.type = make_type_pointer(p->module->allocator, e->type);
-	i->Local.zero_initialized = zero_initialized;
-	array_init(&i->Local.referrers, heap_allocator()); // TODO(bill): Replace heap allocator here
-	ssa_module_add_value(p->module, e, v);
-	return v;
-}
-
-
-ssaValue *ssa_make_instr_store(ssaProcedure *p, ssaValue *address, ssaValue *value) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_Store);
-	ssaInstr *i = &v->Instr;
-	i->Store.address = address;
-	i->Store.value = value;
-	return v;
-}
-
-ssaValue *ssa_make_instr_zero_init(ssaProcedure *p, ssaValue *address) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_ZeroInit);
-	ssaInstr *i = &v->Instr;
-	i->ZeroInit.address = address;
-	return v;
-}
-
-ssaValue *ssa_make_instr_load(ssaProcedure *p, ssaValue *address) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_Load);
-	ssaInstr *i = &v->Instr;
-	i->Load.address = address;
-	i->Load.type = type_deref(ssa_type(address));
-	return v;
-}
-
-ssaValue *ssa_make_instr_array_element_ptr(ssaProcedure *p, ssaValue *address, ssaValue *elem_index) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_ArrayElementPtr);
-	ssaInstr *i = &v->Instr;
-	Type *t = ssa_type(address);
-	GB_ASSERT(is_type_pointer(t));
-	t = base_type(type_deref(t));
-	GB_ASSERT(is_type_array(t));
-
-	Type *result_type = make_type_pointer(p->module->allocator, t->Array.elem);
-
-	i->ArrayElementPtr.address = address;
-	i->ArrayElementPtr.elem_index = elem_index;
-	i->ArrayElementPtr.result_type = result_type;
-
-	GB_ASSERT_MSG(is_type_pointer(ssa_type(address)),
-	              "%s", type_to_string(ssa_type(address)));
-	return v;
-}
-ssaValue *ssa_make_instr_struct_element_ptr(ssaProcedure *p, ssaValue *address, i32 elem_index, Type *result_type) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_StructElementPtr);
-	ssaInstr *i = &v->Instr;
-	i->StructElementPtr.address     = address;
-	i->StructElementPtr.elem_index  = elem_index;
-	i->StructElementPtr.result_type = result_type;
-
-	GB_ASSERT_MSG(is_type_pointer(ssa_type(address)),
-	              "%s", type_to_string(ssa_type(address)));
-	return v;
-}
-ssaValue *ssa_make_instr_ptr_offset(ssaProcedure *p, ssaValue *address, ssaValue *offset) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_PtrOffset);
-	ssaInstr *i = &v->Instr;
-	i->PtrOffset.address = address;
-	i->PtrOffset.offset  = offset;
-
-	GB_ASSERT_MSG(is_type_pointer(ssa_type(address)),
-	              "%s", type_to_string(ssa_type(address)));
-	GB_ASSERT_MSG(is_type_integer(ssa_type(offset)),
-	              "%s", type_to_string(ssa_type(address)));
-
-	return v;
-}
-
-
-
-ssaValue *ssa_make_instr_array_extract_value(ssaProcedure *p, ssaValue *address, i32 index) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_ArrayExtractValue);
-	ssaInstr *i = &v->Instr;
-	i->ArrayExtractValue.address = address;
-	i->ArrayExtractValue.index = index;
-	Type *t = base_type(ssa_type(address));
-	GB_ASSERT(is_type_array(t));
-	i->ArrayExtractValue.result_type = t->Array.elem;
-	return v;
-}
-
-ssaValue *ssa_make_instr_struct_extract_value(ssaProcedure *p, ssaValue *address, i32 index, Type *result_type) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_StructExtractValue);
-	ssaInstr *i = &v->Instr;
-	i->StructExtractValue.address = address;
-	i->StructExtractValue.index = index;
-	i->StructExtractValue.result_type = result_type;
-	return v;
-}
-
-ssaValue *ssa_make_instr_binary_op(ssaProcedure *p, TokenKind op, ssaValue *left, ssaValue *right, Type *type) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_BinaryOp);
-	ssaInstr *i = &v->Instr;
-	i->BinaryOp.op = op;
-	i->BinaryOp.left = left;
-	i->BinaryOp.right = right;
-	i->BinaryOp.type = type;
-	return v;
-}
-
-ssaValue *ssa_make_instr_jump(ssaProcedure *p, ssaBlock *block) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_Jump);
-	ssaInstr *i = &v->Instr;
-	i->Jump.block = block;
-	return v;
-}
-ssaValue *ssa_make_instr_if(ssaProcedure *p, ssaValue *cond, ssaBlock *true_block, ssaBlock *false_block) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_If);
-	ssaInstr *i = &v->Instr;
-	i->If.cond = cond;
-	i->If.true_block = true_block;
-	i->If.false_block = false_block;
-	return v;
-}
-
-
-ssaValue *ssa_make_instr_phi(ssaProcedure *p, Array<ssaValue *> edges, Type *type) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_Phi);
-	ssaInstr *i = &v->Instr;
-	i->Phi.edges = edges;
-	i->Phi.type = type;
-	return v;
-}
-
-ssaValue *ssa_make_instr_unreachable(ssaProcedure *p) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_Unreachable);
-	return v;
-}
-
-ssaValue *ssa_make_instr_return(ssaProcedure *p, ssaValue *value) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_Return);
-	v->Instr.Return.value = value;
-	return v;
-}
-
-ssaValue *ssa_make_instr_select(ssaProcedure *p, ssaValue *cond, ssaValue *t, ssaValue *f) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_Select);
-	v->Instr.Select.cond = cond;
-	v->Instr.Select.true_value = t;
-	v->Instr.Select.false_value = f;
-	return v;
-}
-
-ssaValue *ssa_make_instr_call(ssaProcedure *p, ssaValue *value, ssaValue **args, isize arg_count, Type *result_type) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_Call);
-	v->Instr.Call.value = value;
-	v->Instr.Call.args = args;
-	v->Instr.Call.arg_count = arg_count;
-	v->Instr.Call.type = result_type;
-	return v;
-}
-
-ssaValue *ssa_make_instr_conv(ssaProcedure *p, ssaConvKind kind, ssaValue *value, Type *from, Type *to) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_Conv);
-	v->Instr.Conv.kind = kind;
-	v->Instr.Conv.value = value;
-	v->Instr.Conv.from = from;
-	v->Instr.Conv.to = to;
-	return v;
-}
-
-ssaValue *ssa_make_instr_extract_element(ssaProcedure *p, ssaValue *vector, ssaValue *index) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_VectorExtractElement);
-	v->Instr.VectorExtractElement.vector = vector;
-	v->Instr.VectorExtractElement.index = index;
-	return v;
-}
-
-ssaValue *ssa_make_instr_insert_element(ssaProcedure *p, ssaValue *vector, ssaValue *elem, ssaValue *index) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_VectorInsertElement);
-	v->Instr.VectorInsertElement.vector = vector;
-	v->Instr.VectorInsertElement.elem   = elem;
-	v->Instr.VectorInsertElement.index  = index;
-	return v;
-}
-
-ssaValue *ssa_make_instr_vector_shuffle(ssaProcedure *p, ssaValue *vector, i32 *indices, isize index_count) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_VectorShuffle);
-	v->Instr.VectorShuffle.vector      = vector;
-	v->Instr.VectorShuffle.indices     = indices;
-	v->Instr.VectorShuffle.index_count = index_count;
-
-	Type *vt = base_type(ssa_type(vector));
-	v->Instr.VectorShuffle.type = make_type_vector(p->module->allocator, vt->Vector.elem, index_count);
-
-	return v;
-}
-
-ssaValue *ssa_make_instr_comment(ssaProcedure *p, String text) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_Comment);
-	v->Instr.Comment.text = text;
-	return v;
-}
-
-ssaValue *ssa_make_instr_bounds_check(ssaProcedure *p, TokenPos pos, ssaValue *index, ssaValue *len) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_BoundsCheck);
-	v->Instr.BoundsCheck.pos   = pos;
-	v->Instr.BoundsCheck.index = index;
-	v->Instr.BoundsCheck.len   = len;
-	return v;
-}
-ssaValue *ssa_make_instr_slice_bounds_check(ssaProcedure *p, TokenPos pos, ssaValue *low, ssaValue *high, ssaValue *max, b32 is_substring) {
-	ssaValue *v = ssa_alloc_instr(p, ssaInstr_SliceBoundsCheck);
-	v->Instr.SliceBoundsCheck.pos  = pos;
-	v->Instr.SliceBoundsCheck.low  = low;
-	v->Instr.SliceBoundsCheck.high = high;
-	v->Instr.SliceBoundsCheck.max  = max;
-	v->Instr.SliceBoundsCheck.is_substring = is_substring;
-	return v;
-}
-
-
-
-ssaValue *ssa_make_value_constant(gbAllocator a, Type *type, ExactValue value) {
-	ssaValue *v = ssa_alloc_value(a, ssaValue_Constant);
-	v->Constant.type  = type;
-	v->Constant.value = value;
-	return v;
-}
-
-
-ssaValue *ssa_make_value_constant_slice(gbAllocator a, Type *type, ssaValue *backing_array, i64 count) {
-	ssaValue *v = ssa_alloc_value(a, ssaValue_ConstantSlice);
-	v->ConstantSlice.type = type;
-	v->ConstantSlice.backing_array = backing_array;
-	v->ConstantSlice.count = count;
-	return v;
-}
-
-ssaValue *ssa_make_const_int(gbAllocator a, i64 i) {
-	return ssa_make_value_constant(a, t_int, make_exact_value_integer(i));
-}
-ssaValue *ssa_make_const_i32(gbAllocator a, i64 i) {
-	return ssa_make_value_constant(a, t_i32, make_exact_value_integer(i));
-}
-ssaValue *ssa_make_const_i64(gbAllocator a, i64 i) {
-	return ssa_make_value_constant(a, t_i64, make_exact_value_integer(i));
-}
-ssaValue *ssa_make_const_bool(gbAllocator a, b32 b) {
-	return ssa_make_value_constant(a, t_bool, make_exact_value_bool(b != 0));
-}
-ssaValue *ssa_make_const_string(gbAllocator a, String s) {
-	return ssa_make_value_constant(a, t_string, make_exact_value_string(s));
-}
-
-ssaValue *ssa_make_value_procedure(gbAllocator a, ssaModule *m, Entity *entity, Type *type, AstNode *type_expr, AstNode *body, String name) {
-	ssaValue *v = ssa_alloc_value(a, ssaValue_Proc);
-	v->Proc.module = m;
-	v->Proc.entity = entity;
-	v->Proc.type   = type;
-	v->Proc.type_expr = type_expr;
-	v->Proc.body   = body;
-	v->Proc.name   = name;
-	array_init(&v->Proc.referrers, heap_allocator(), 0); // TODO(bill): replace heap allocator
-
-	Type *t = base_type(type);
-	GB_ASSERT(is_type_proc(t));
-	array_init(&v->Proc.params, heap_allocator(), t->Proc.param_count);
-
-	return v;
-}
-
-ssaBlock *ssa_add_block(ssaProcedure *proc, AstNode *node, char *label) {
-	Scope *scope = NULL;
-	if (node != NULL) {
-		Scope **found = map_get(&proc->module->info->scopes, hash_pointer(node));
-		if (found) {
-			scope = *found;
-		} else {
-			GB_PANIC("Block scope not found for %.*s", LIT(ast_node_strings[node->kind]));
-		}
-	}
-
-	ssaValue *v = ssa_alloc_value(proc->module->allocator, ssaValue_Block);
-	v->Block.label  = make_string(label);
-	v->Block.node   = node;
-	v->Block.scope  = scope;
-	v->Block.parent = proc;
-
-	array_init(&v->Block.instrs, heap_allocator());
-	array_init(&v->Block.locals, heap_allocator());
-
-	array_init(&v->Block.preds,  heap_allocator());
-	array_init(&v->Block.succs,  heap_allocator());
-
-	ssaBlock *block = &v->Block;
-
-	array_add(&proc->blocks, block);
-	proc->block_count++;
-
-	return block;
-}
-
-
-
-
-
-ssaDefer ssa_add_defer_node(ssaProcedure *proc, isize scope_index, AstNode *stmt) {
-	ssaDefer d = {ssaDefer_Node};
-	d.scope_index = scope_index;
-	d.block = proc->curr_block;
-	d.stmt = stmt;
-	array_add(&proc->defer_stmts, d);
-	return d;
-}
-
-
-ssaDefer ssa_add_defer_instr(ssaProcedure *proc, isize scope_index, ssaValue *instr) {
-	ssaDefer d = {ssaDefer_Instr};
-	d.scope_index = proc->scope_index;
-	d.block = proc->curr_block;
-	d.instr = instr; // NOTE(bill): It will make a copy everytime it is called
-	array_add(&proc->defer_stmts, d);
-	return d;
-}
-
-
-
-ssaValue *ssa_add_module_constant(ssaModule *m, Type *type, ExactValue value) {
-	if (is_type_slice(type)) {
-		ast_node(cl, CompoundLit, value.value_compound);
-		gbAllocator a = m->allocator;
-
-		isize count = cl->elems.count;
-		if (count == 0) {
-			return ssa_make_value_nil(a, type);
-		}
-		Type *elem = base_type(type)->Slice.elem;
-		Type *t = make_type_array(a, elem, count);
-		ssaValue *backing_array = ssa_add_module_constant(m, t, value);
-
-
-		isize max_len = 7+8+1;
-		u8 *str = cast(u8 *)gb_alloc_array(a, u8, max_len);
-		isize len = gb_snprintf(cast(char *)str, max_len, "__csba$%x", m->global_array_index);
-		m->global_array_index++;
-
-		String name = make_string(str, len-1);
-
-		Entity *e = make_entity_constant(a, NULL, make_token_ident(name), t, value);
-		ssaValue *g = ssa_make_value_global(a, e, backing_array);
-		ssa_module_add_value(m, e, g);
-		map_set(&m->members, hash_string(name), g);
-
-		return ssa_make_value_constant_slice(a, type, g, count);
-	}
-
-	return ssa_make_value_constant(m->allocator, type, value);
-}
-
-ssaValue *ssa_add_global_string_array(ssaModule *m, String string) {
-	gbAllocator a = m->allocator;
-
-	isize max_len = 6+8+1;
-	u8 *str = cast(u8 *)gb_alloc_array(a, u8, max_len);
-	isize len = gb_snprintf(cast(char *)str, max_len, "__str$%x", m->global_string_index);
-	m->global_string_index++;
-
-	String name = make_string(str, len-1);
-	Token token = {Token_String};
-	token.string = name;
-	Type *type = make_type_array(a, t_u8, string.len);
-	ExactValue ev = make_exact_value_string(string);
-	Entity *entity = make_entity_constant(a, NULL, token, type, ev);
-	ssaValue *g = ssa_make_value_global(a, entity, ssa_add_module_constant(m, type, ev));
-	g->Global.is_private      = true;
-	// g->Global.is_unnamed_addr = true;
-	// g->Global.is_constant = true;
-
-	ssa_module_add_value(m, entity, g);
-	map_set(&m->members, hash_string(name), g);
-
-	return g;
-}
-
-
-
-
-ssaValue *ssa_add_local(ssaProcedure *proc, Entity *e, b32 zero_initialized = true) {
-	ssaBlock *b = proc->decl_block; // all variables must be in the first block
-	ssaValue *instr = ssa_make_instr_local(proc, e, zero_initialized);
-	instr->Instr.parent = b;
-	array_add(&b->instrs, instr);
-	array_add(&b->locals, instr);
-	proc->local_count++;
-
-	// if (zero_initialized) {
-		ssa_emit_zero_init(proc, instr);
-	// }
-
-	return instr;
-}
-
-ssaValue *ssa_add_local_for_identifier(ssaProcedure *proc, AstNode *name, b32 zero_initialized) {
-	Entity **found = map_get(&proc->module->info->definitions, hash_pointer(name));
-	if (found) {
-		Entity *e = *found;
-		ssa_emit_comment(proc, e->token.string);
-		return ssa_add_local(proc, e, zero_initialized);
-	}
-	return NULL;
-}
-
-ssaValue *ssa_add_local_generated(ssaProcedure *proc, Type *type) {
-	GB_ASSERT(type != NULL);
-
-	Scope *scope = NULL;
-	if (proc->curr_block) {
-		scope = proc->curr_block->scope;
-	}
-	Entity *e = make_entity_variable(proc->module->allocator,
-	                                 scope,
-	                                 empty_token,
-	                                 type);
-	return ssa_add_local(proc, e, true);
-}
-
-ssaValue *ssa_add_param(ssaProcedure *proc, Entity *e) {
-	ssaValue *v = ssa_make_value_param(proc->module->allocator, proc, e);
-#if 1
-	ssaValue *l = ssa_add_local(proc, e);
-	ssa_emit_store(proc, l, v);
-#else
-	ssa_module_add_value(proc->module, e, v);
-#endif
-	return v;
-}