Continue work on custom SSA; Fix double declaration in when statements

src/ssa.c

@@ -1,6 +1,7 @@
 typedef struct ssaModule           ssaModule;
 typedef struct ssaValue            ssaValue;
 typedef struct ssaValueArgs        ssaValueArgs;
+typedef struct ssaDefer            ssaDefer;
 typedef struct ssaBlock            ssaBlock;
 typedef struct ssaProc             ssaProc;
 typedef struct ssaEdge             ssaEdge;
@@ -8,6 +9,8 @@ typedef struct ssaRegister         ssaRegister;
 typedef struct ssaTargetList       ssaTargetList;
 typedef enum   ssaBlockKind        ssaBlockKind;
 typedef enum   ssaBranchPrediction ssaBranchPrediction;
+typedef enum   ssaDeferExitKind    ssaDeferExitKind;
+
 
 String ssa_mangle_name(ssaModule *m, String path, Entity *e);
 
@@ -49,6 +52,7 @@ enum ssaBlockKind {
 	// architectures, these could become conditions blocks like amd64 LT or EQ
 	ssaBlock_Entry, // Entry point
 	ssaBlock_Plain,
+	ssaBlock_Defer, // Similar to a plain block but generated by a `defer` statement
 	ssaBlock_If,
 	ssaBlock_Ret,
 	ssaBlock_RetJmp, // Stores return value and jumps to Ret block
@@ -63,6 +67,27 @@ enum ssaBranchPrediction {
 	ssaBranch_Unlikely = -1,
 };
 
+typedef enum ssaDeferKind {
+	ssaDefer_Node,
+	ssaDefer_Instr,
+} ssaDeferKind;
+
+struct ssaDefer {
+	ssaDeferKind     kind;
+	i32              scope_level;
+	ssaBlock *       block;
+	union {
+		AstNode *    stmt;
+		ssaValue *   instr;
+	};
+};
+
+enum ssaDeferExitKind {
+	ssaDeferExit_Default,
+	ssaDeferExit_Return,
+	ssaDeferExit_Branch,
+};
+
 // ssaEdge represents a control flow graph (CFG) edge
 struct ssaEdge {
 	// Succs array: Block To
@@ -79,6 +104,7 @@ struct ssaBlock {
 	ssaBlockKind         kind;
 	ssaProc *            proc; // Containing procedure
 	String               name; // Optional
+	i32                  scope_level;
 
 	// Likely branch direction
 	ssaBranchPrediction likeliness;
@@ -118,6 +144,9 @@ struct ssaProc {
 	i32               block_id;
 	i32               value_id;
 	MapSsaValue       values;   // Key: Entity *
+
+	Array(ssaDefer)   defer_stmts;
+	i32               scope_level;
 };
 
 struct ssaRegister {
@@ -147,6 +176,17 @@ struct ssaModule {
 	ssaValueArray     procs_to_generate;
 };
 
+typedef enum ssaAddrKind {
+	ssaAddr_Default,
+	ssaAddr_Map,
+} ssaAddrKind;
+
+typedef struct ssaAddr {
+	ssaValue *  addr;
+	ssaAddrKind kind;
+} ssaAddr;
+
+
 
 void ssa_push_target_list(ssaProc *p, ssaBlock *break_, ssaBlock *continue_, ssaBlock *fallthrough_) {
 	ssaTargetList *tl = gb_alloc_item(p->allocator, ssaTargetList);
@@ -167,6 +207,7 @@ ssaBlock *ssa_new_block(ssaProc *p, ssaBlockKind kind, char *name) {
 	b->id = p->block_id++;
 	b->kind = kind;
 	b->proc = p;
+	p->scope_level = p->scope_level;
 	if (name != NULL || name[0] != 0) {
 		b->name = make_string_c(name);
 	}
@@ -352,6 +393,17 @@ ssaValue *ssa_const_int(ssaProc *p, Type *t, i64 c) {
 	return NULL;
 }
 
+
+
+
+ssaAddr   ssa_build_addr     (ssaProc *p, AstNode *expr);
+ssaValue *ssa_build_expr     (ssaProc *p, AstNode *expr);
+void      ssa_build_stmt     (ssaProc *p, AstNode *node);
+void      ssa_build_stmt_list(ssaProc *p, AstNodeArray nodes);
+ssaValue *ssa_emit_deep_field_ptr_index(ssaProc *p, ssaValue *e, Selection sel);
+
+
+
 void ssa_reset_value_args(ssaValue *v) {
 	for_array(i, v->args) {
 		v->args.e[i]->uses--;
@@ -365,6 +417,85 @@ void ssa_reset(ssaValue *v, ssaOp op) {
 	ssa_reset_value_args(v);
 }
 
+ssaValue *ssa_get_last_value(ssaBlock *b) {
+	if (b == NULL) {
+		return NULL;
+	}
+	isize len = b->values.count;
+	if (len <= 0) {
+		return 0;
+	}
+	ssaValue *v = b->values.e[len-1];
+	return v;
+}
+
+void ssa_emit_comment(ssaProc *p, String s) {
+	// ssa_new_value0v(p, ssaOp_Comment, NULL, exact_value_string(s));
+}
+
+void ssa_build_defer_stmt(ssaProc *p, ssaDefer d) {
+	// ssaValue *last_instr = ssa_get_last_value(p->curr_block);
+	ssaBlock *b = ssa_new_block(p, ssaBlock_Plain, "defer");
+	ssa_emit_jump(p, b);
+	ssa_start_block(p, b);
+	ssa_emit_comment(p, str_lit("defer"));
+	if (d.kind == ssaDefer_Node) {
+		ssa_build_stmt(p, d.stmt);
+	} else if (d.kind == ssaDefer_Instr) {
+		// NOTE(bill): Need to make a new copy
+		ssaValue *v = cast(ssaValue *)gb_alloc_copy(p->allocator, d.instr, gb_size_of(ssaValue));
+		array_add(&p->curr_block->values, v);
+	}
+}
+
+void ssa_emit_defer_stmts(ssaProc *p, ssaDeferExitKind kind, ssaBlock *b) {
+	isize count = p->defer_stmts.count;
+	for (isize i = count-1; i >= 0; i--) {
+		ssaDefer d = p->defer_stmts.e[i];
+		if (kind == ssaDeferExit_Default) {
+			gb_printf_err("scope_level %d %d\n", p->scope_level, d.scope_level);
+			if (p->scope_level == d.scope_level &&
+			    d.scope_level > 1) {
+				ssa_build_defer_stmt(p, d);
+				array_pop(&p->defer_stmts);
+				continue;
+			} else {
+				break;
+			}
+		} else if (kind == ssaDeferExit_Return) {
+			ssa_build_defer_stmt(p, d);
+		} else if (kind == ssaDeferExit_Branch) {
+			GB_ASSERT(b != NULL);
+			i32 lower_limit = b->scope_level+1;
+			if (lower_limit < d.scope_level) {
+				ssa_build_defer_stmt(p, d);
+			}
+		}
+	}
+}
+
+ssaDefer ssa_add_defer_node(ssaProc *p, i32 scope_level, AstNode *stmt) {
+	ssaDefer d = {ssaDefer_Node};
+	d.scope_level = scope_level;
+	d.block = p->curr_block;
+	d.stmt = stmt;
+	array_add(&p->defer_stmts, d);
+	return d;
+}
+
+void ssa_open_scope(ssaProc *p) {
+	p->scope_level++;
+}
+
+void ssa_close_scope(ssaProc *p, ssaDeferExitKind kind, ssaBlock *b) {
+	ssa_emit_defer_stmts(p, kind, b);
+	GB_ASSERT(p->scope_level > 0);
+	p->scope_level--;
+}
+
+
+
+
 ssaValue *ssa_emit_load(ssaProc *p, ssaValue *v) {
 	GB_ASSERT(is_type_pointer(v->type));
 	return ssa_new_value1(p, ssaOp_Load, type_deref(v->type), v);
@@ -411,15 +542,6 @@ bool ssa_is_blank_ident(AstNode *node) {
 }
 
 
-typedef enum ssaAddrKind {
-	ssaAddr_Default,
-	ssaAddr_Map,
-} ssaAddrKind;
-
-typedef struct ssaAddr {
-	ssaValue *  addr;
-	ssaAddrKind kind;
-} ssaAddr;
 
 ssaAddr ssa_addr(ssaValue *v) {
 	if (v != NULL) {
@@ -456,6 +578,7 @@ ssaProc *ssa_new_proc(ssaModule *m, String name, Entity *entity, DeclInfo *decl_
 	p->decl_info = decl_info;
 
 	array_init(&p->blocks, heap_allocator());
+	array_init(&p->defer_stmts, heap_allocator());
 	map_ssa_value_init(&p->values, heap_allocator());
 
 	return p;
@@ -472,10 +595,8 @@ ssaAddr ssa_add_local(ssaProc *p, Entity *e, AstNode *expr) {
 	map_ssa_value_set(&p->values,         hash_pointer(e), local);
 	map_ssa_value_set(&p->module->values, hash_pointer(e), local);
 	local->comment_string = e->token.string;
-
-	ssaValue *addr = ssa_new_value1(p, ssaOp_Addr, local->type, local);
-	ssa_new_value1(p, ssaOp_Zero, t, addr);
-	return ssa_addr(addr);
+	ssa_new_value1(p, ssaOp_Zero, t, local);
+	return ssa_addr(local);
 }
 ssaAddr ssa_add_local_for_ident(ssaProc *p, AstNode *name) {
 	Entity **found = map_entity_get(&p->module->info->definitions, hash_pointer(name));
@@ -498,9 +619,7 @@ ssaAddr ssa_add_local_generated(ssaProc *p, Type *t) {
 	return ssa_add_local(p, e, NULL);
 }
 
-void ssa_emit_comment(ssaProc *p, String s) {
-	// ssa_new_value0v(p, ssaOp_Comment, NULL, exact_value_string(s));
-}
+
 
 #define SSA_MAX_STRUCT_FIELD_COUNT 4
 
@@ -549,12 +668,6 @@ bool can_ssa_type(Type *t) {
 	return true;
 }
 
-ssaAddr   ssa_build_addr     (ssaProc *p, AstNode *expr);
-ssaValue *ssa_build_expr     (ssaProc *p, AstNode *expr);
-void      ssa_build_stmt     (ssaProc *p, AstNode *node);
-void      ssa_build_stmt_list(ssaProc *p, AstNodeArray nodes);
-ssaValue *ssa_emit_deep_field_ptr_index(ssaProc *p, ssaValue *e, Selection sel);
-
 void ssa_addr_store(ssaProc *p, ssaAddr addr, ssaValue *value) {
 	if (addr.addr == NULL) {
 		return;
@@ -706,10 +819,6 @@ ssaValue *ssa_emit_ptr_index(ssaProc *p, ssaValue *s, i64 index) {
 		GB_ASSERT(t->Record.field_count > 0);
 		GB_ASSERT(gb_is_between(index, 0, t->Record.field_count-1));
 		result_type = make_type_pointer(a, t->Record.fields[index]->type);
-		i64 offset = t->Record.offsets[index];
-		ssaValue *ptr = ssa_emit_conv(p, s, t_u8_ptr);
-		ptr = ssa_new_value2(p, ssaOp_PtrOffset, ptr->type, ptr, ssa_const_int(p, t_int, offset));
-		return ssa_emit_conv(p, ptr, result_type);
 	} else if (is_type_tuple(t)) {
 		GB_ASSERT(t->Tuple.variable_count > 0);
 		GB_ASSERT(gb_is_between(index, 0, t->Tuple.variable_count-1));
@@ -772,13 +881,7 @@ ssaValue *ssa_emit_value_index(ssaProc *p, ssaValue *s, i64 index) {
 		type_set_offsets(a, t);
 		GB_ASSERT(t->Record.field_count > 0);
 		GB_ASSERT(gb_is_between(index, 0, t->Record.field_count-1));
-		Type *ptr_type = make_type_pointer(a, t->Record.fields[index]->type);
-		i64 offset = t->Record.offsets[index];
-		ssaValue *ptr = ssa_address_from_load_or_generate_local(p, s);
-		ptr = ssa_emit_conv(p, s, t_u8_ptr);
-		ptr = ssa_new_value2(p, ssaOp_PtrOffset, ptr->type, ptr, ssa_const_int(p, t_int, offset));
-		ptr = ssa_emit_conv(p, ptr, ptr_type);
-		return ssa_emit_load(p, ptr);
+		result_type = t->Record.fields[index]->type;
 	} else if (is_type_tuple(t)) {
 		GB_ASSERT(t->Tuple.variable_count > 0);
 		GB_ASSERT(gb_is_between(index, 0, t->Tuple.variable_count-1));
@@ -1007,9 +1110,88 @@ ssaAddr ssa_build_addr(ssaProc *p, AstNode *expr) {
 			return ssa_addr(a);
 		}
 	case_end;
+
+
+	case_ast_node(ce, CastExpr, expr);
+		switch (ce->token.kind) {
+		case Token_cast: {
+			ssa_emit_comment(p, str_lit("Cast - cast"));
+			// NOTE(bill): Needed for dereference of pointer conversion
+			Type *type = type_of_expr(p->module->info, expr);
+			ssaAddr addr = ssa_add_local_generated(p, type);
+			ssa_addr_store(p, addr, ssa_emit_conv(p, ssa_build_expr(p, ce->expr), type));
+			return addr;
+		}
+		#if 0
+		case Token_transmute: {
+			ssa_emit_comment(p, str_lit("Cast - transmute"));
+			// NOTE(bill): Needed for dereference of pointer conversion
+			Type *type = type_of_expr(p->module->info, expr);
+			ssaValue *v = ssa_add_local_generated(p, type);
+			ssa_emit_store(p, v, ssa_emit_transmute(p, ssa_build_expr(p, ce->expr), type));
+			return ssa_addr(v);
+		}
+		case Token_union_cast: {
+			ssa_emit_comment(p, str_lit("Cast - union_cast"));
+			// NOTE(bill): Needed for dereference of pointer conversion
+			Type *type = type_of_expr(p->module->info, expr);
+			ssaValue *v = ssa_add_local_generated(p, type);
+			ssa_emit_store(p, v, ssa_emit_union_cast(p, ssa_build_expr(p, ce->expr), type, ast_node_token(expr).pos));
+			return ssa_addr(v);
+		}
+		#endif
+		default:
+			GB_PANIC("Unknown cast expression");
+		}
+	case_end;
+
+	case_ast_node(ue, UnaryExpr, expr);
+		switch (ue->op.kind) {
+		case Token_Pointer: {
+			return ssa_build_addr(p, ue->expr);
+		}
+		default:
+			GB_PANIC("Invalid unary expression for ssa_build_addr");
+		}
+	case_end;
+
+	case_ast_node(be, BinaryExpr, expr);
+		GB_PANIC("Invalid binary expression for ssa_build_addr: %.*s\n", LIT(be->op.string));
+	case_end;
+
+	case_ast_node(ie, IndexExpr, expr);
+		GB_PANIC("TODO(bill): ssa_build_addr IndexExpr");
+	case_end;
+
+	case_ast_node(se, SliceExpr, expr);
+		GB_PANIC("TODO(bill): ssa_build_addr SliceExpr");
+	case_end;
+
+	case_ast_node(de, DerefExpr, expr);
+		ssaValue *addr = ssa_build_expr(p, de->expr);
+		return ssa_addr(addr);
+	case_end;
+
+	case_ast_node(ce, CallExpr, expr);
+		ssaValue *e = ssa_build_expr(p, expr);
+		ssaValue *v = ssa_address_from_load_or_generate_local(p, e);
+		return ssa_addr(v);
+	case_end;
+
+	case_ast_node(cl, CompoundLit, expr);
+		GB_PANIC("TODO(bill): ssa_build_addr CompoundLit");
+	case_end;
+
 	}
 
-	GB_PANIC("Cannot get entity's address");
+	TokenPos token_pos = ast_node_token(expr).pos;
+	GB_PANIC("Unexpected address expression\n"
+	         "\tAstNode: %.*s @ "
+	         "%.*s(%td:%td)\n",
+	         LIT(ast_node_strings[expr->kind]),
+	         LIT(token_pos.file), token_pos.line, token_pos.column);
+
+
 	return ssa_addr(NULL);
 }
 
@@ -1234,6 +1416,7 @@ ssaOp ssa_determine_op(TokenKind op, Type *t) {
 	return ssaOp_Invalid;
 }
 
+
 ssaValue *ssa_emit_comp(ssaProc *p, TokenKind op, ssaValue *x, ssaValue *y) {
 	GB_ASSERT(x != NULL && y != NULL);
 	Type *a = core_type(x->type);
@@ -1278,6 +1461,130 @@ ssaValue *ssa_emit_comp(ssaProc *p, TokenKind op, ssaValue *x, ssaValue *y) {
 
 
 
+ssaValue *ssa_emit_unary_arith(ssaProc *p, TokenKind op, ssaValue *x, Type *type) {
+	if (is_type_vector(x->type)) {
+		ssa_emit_comment(p, str_lit("vector.arith.begin"));
+		// IMPORTANT TODO(bill): This is very wasteful with regards to stack memory
+		Type *tl = base_type(x->type);
+		ssaValue *val = ssa_address_from_load_or_generate_local(p, x);
+		GB_ASSERT(is_type_vector(type));
+		Type *elem_type = base_type(type)->Vector.elem;
+
+		ssaAddr res = ssa_add_local_generated(p, type);
+		for (i64 i = 0; i < tl->Vector.count; i++) {
+			ssaValue *index = ssa_const_int(p, t_int, i);
+			ssaValue *e = ssa_emit_load(p, ssa_emit_array_index(p, val, index));
+			ssaValue *z = ssa_emit_unary_arith(p, op, e, elem_type);
+			ssa_emit_store(p, ssa_emit_array_index(p, res.addr, index), z);
+		}
+		ssa_emit_comment(p, str_lit("vector.arith.end"));
+		return ssa_addr_load(p, res);
+
+	}
+
+
+	switch (op) {
+	case Token_Pointer: {
+		GB_PANIC("Token_Pointer should be handled elsewhere");
+	} break;
+
+	case Token_Add:
+		return x;
+
+	case Token_Not: // Boolean not
+		return ssa_new_value1(p, ssaOp_NotB, type, x);
+	case Token_Xor: { // Bitwise not
+		isize bits = 8*type_size_of(p->allocator, x->type);
+		switch (bits) {
+		case  8: return ssa_new_value1(p, ssaOp_Not8,  type, x);
+		case 16: return ssa_new_value1(p, ssaOp_Not16, type, x);
+		case 32: return ssa_new_value1(p, ssaOp_Not32, type, x);
+		case 64: return ssa_new_value1(p, ssaOp_Not64, type, x);
+		}
+		GB_PANIC("unknown integer size");
+	} break;
+
+	case Token_Sub: { // 0-x
+		isize bits = 8*type_size_of(p->allocator, x->type);
+		if (is_type_integer(x->type)) {
+			switch (bits) {
+			case  8: return ssa_new_value1(p, ssaOp_Neg8,  type, x);
+			case 16: return ssa_new_value1(p, ssaOp_Neg16, type, x);
+			case 32: return ssa_new_value1(p, ssaOp_Neg32, type, x);
+			case 64: return ssa_new_value1(p, ssaOp_Neg64, type, x);
+			}
+		} else if (is_type_float(x->type)) {
+			switch (bits) {
+			case 32: return ssa_new_value1(p, ssaOp_Neg32F, type, x);
+			case 64: return ssa_new_value1(p, ssaOp_Neg64F, type, x);
+			}
+		}
+		GB_PANIC("unknown type for -x");
+	} break;
+	}
+	return NULL;
+}
+ssaValue *ssa_emit_arith(ssaProc *p, TokenKind op, ssaValue *x, ssaValue *y, Type *type) {
+	if (is_type_vector(x->type)) {
+		GB_PANIC("TODO(bill): ssa_emit_arith vector");
+	} else if (is_type_complex(x->type)) {
+		GB_PANIC("TODO(bill): ssa_emit_arith complex");
+	} else if (is_type_quaternion(x->type)) {
+		GB_PANIC("TODO(bill): ssa_emit_arith quaternion");
+	}
+
+	if (op == Token_Add) {
+		if (is_type_pointer(x->type)) {
+			GB_PANIC("TODO(bill): Ptr arith");
+			ssaValue *ptr = ssa_emit_conv(p, x, type);
+			ssaValue *offset = y;
+			// return ssa_emit_ptr_offset(p, ptr, offset);
+		} else if (is_type_pointer(y->type)) {
+			GB_PANIC("TODO(bill): Ptr arith");
+
+			ssaValue *ptr = ssa_emit_conv(p, y, type);
+			ssaValue *offset = x;
+			// return ssa_emit_ptr_offset(p, ptr, offset);
+		}
+	} else if (op == Token_Sub) {
+		if (is_type_pointer(x->type) && is_type_integer(y->type)) {
+			GB_PANIC("TODO(bill): Ptr arith");
+			// ptr - int
+			ssaValue *ptr = ssa_emit_conv(p, x, type);
+			ssaValue *offset = y;
+			// return ssa_emit_ptr_offset(p, ptr, offset);
+		} else if (is_type_pointer(x->type) && is_type_pointer(y->type)) {
+			GB_ASSERT(is_type_integer(type));
+			Type *ptr_type = base_type(x->type);
+			GB_ASSERT(!is_type_rawptr(ptr_type));
+			ssaValue *elem_size = ssa_const_int(p, t_int, type_size_of(p->allocator, ptr_type->Pointer.elem));
+			ssaValue *a = ssa_emit_conv(p, x, type);
+			ssaValue *b = ssa_emit_conv(p, y, type);
+			ssaValue *diff = ssa_emit_arith(p, op, a, b, type);
+			return ssa_emit_arith(p, Token_Quo, diff, elem_size, type);
+		}
+	}
+
+	switch (op) {
+	case Token_Add:
+	case Token_Sub:
+	case Token_Mul:
+	case Token_Quo:
+	case Token_Mod:
+	case Token_And:
+	case Token_Or:
+	case Token_Xor:
+	case Token_AndNot:
+		GB_ASSERT(x != NULL && y != NULL);
+		return ssa_new_value2(p, ssa_determine_op(op, x->type), type, x, y);
+	}
+
+	return NULL;
+}
+
+
+
+
 ssaValue *ssa_build_cond(ssaProc *p, AstNode *cond, ssaBlock *yes, ssaBlock *no) {
 	switch (cond->kind) {
 	case_ast_node(pe, ParenExpr, cond);
@@ -1439,47 +1746,12 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) {
 	case_end;
 
 	case_ast_node(ue, UnaryExpr, expr);
-		switch (ue->op.kind) {
-		case Token_Pointer: {
+		if (ue->op.kind == Token_Pointer) {
 			return ssa_build_addr(p, ue->expr).addr;
-		} break;
-
-		case Token_Add:
-			return ssa_build_expr(p, ue->expr);
-
-		case Token_Not: // Boolean not
-			return ssa_new_value1(p, ssaOp_NotB, tv->type, ssa_build_expr(p, ue->expr));
-		case Token_Xor: { // Bitwise not
-			ssaValue *x = ssa_build_expr(p, ue->expr);
-			isize bits = 8*type_size_of(p->allocator, x->type);
-			switch (bits) {
-			case  8: return ssa_new_value1(p, ssaOp_Not8,  tv->type, x);
-			case 16: return ssa_new_value1(p, ssaOp_Not16, tv->type, x);
-			case 32: return ssa_new_value1(p, ssaOp_Not32, tv->type, x);
-			case 64: return ssa_new_value1(p, ssaOp_Not64, tv->type, x);
-			}
-			GB_PANIC("unknown integer size");
-		} break;
-
-		case Token_Sub: { // 0-x
-			ssaValue *x = ssa_build_expr(p, ue->expr);
-			isize bits = 8*type_size_of(p->allocator, x->type);
-			if (is_type_integer(x->type)) {
-				switch (bits) {
-				case  8: return ssa_new_value1(p, ssaOp_Neg8,  tv->type, x);
-				case 16: return ssa_new_value1(p, ssaOp_Neg16, tv->type, x);
-				case 32: return ssa_new_value1(p, ssaOp_Neg32, tv->type, x);
-				case 64: return ssa_new_value1(p, ssaOp_Neg64, tv->type, x);
-				}
-			} else if (is_type_float(x->type)) {
-				switch (bits) {
-				case 32: return ssa_new_value1(p, ssaOp_Neg32F, tv->type, x);
-				case 64: return ssa_new_value1(p, ssaOp_Neg64F, tv->type, x);
-				}
-			}
-			GB_PANIC("unknown type for -x");
-		} break;
 		}
+		ssaValue *x = ssa_build_expr(p, ue->expr);
+		return ssa_emit_unary_arith(p, ue->op.kind, x, tv->type);
+
 	case_end;
 
 	case_ast_node(be, BinaryExpr, expr);
@@ -1497,8 +1769,7 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) {
 		case Token_AndNot: {
 			ssaValue *x = ssa_build_expr(p, be->left);
 			ssaValue *y = ssa_build_expr(p, be->right);
-			GB_ASSERT(x != NULL && y != NULL);
-			return ssa_new_value2(p, ssa_determine_op(be->op.kind, x->type), tv->type, x, y);
+			return ssa_emit_arith(p, be->op.kind, x, y, type);
 		}
 
 		case Token_Shl:
@@ -1527,8 +1798,126 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) {
 			break;
 		}
 	case_end;
+
+	case_ast_node(de, DerefExpr, expr);
+		return ssa_addr_load(p, ssa_build_addr(p, expr));
+	case_end;
+
+	case_ast_node(se, SelectorExpr, expr);
+		return ssa_addr_load(p, ssa_build_addr(p, expr));
+	case_end;
+
+	case_ast_node(te, TernaryExpr, expr);
+		ssa_emit_comment(p, str_lit("TernaryExpr"));
+
+		ssaValue *yes = NULL;
+		ssaValue *no = NULL;
+
+		GB_ASSERT(te->y != NULL);
+		ssaBlock *then  = ssa_new_block(p, ssaBlock_Plain, "if.then");
+		ssaBlock *done  = ssa_new_block(p, ssaBlock_Plain, "if.done"); // NOTE(bill): Append later
+		ssaBlock *else_ = ssa_new_block(p, ssaBlock_Plain, "if.else");
+
+		ssaBlock *v = NULL;
+
+		ssa_build_cond(p, te->cond, then, else_);
+		ssa_start_block(p, then);
+
+		// ssa_open_scope(p);
+		yes = ssa_build_expr(p, te->x);
+		// ssa_close_scope(p, ssaDeferExit_Default, NULL);
+
+		ssa_emit_jump(p, done);
+		ssa_start_block(p, else_);
+
+		// ssa_open_scope(p);
+		no = ssa_build_expr(p, te->y);
+		// ssa_close_scope(p, ssaDeferExit_Default, NULL);
+
+		ssa_emit_jump(p, done);
+		ssa_start_block(p, done);
+
+		return ssa_new_value2(p, ssaOp_Phi, tv->type, yes, no);
+	case_end;
+
+
+	case_ast_node(ce, CastExpr, expr);
+		Type *type = tv->type;
+		ssaValue *e = ssa_build_expr(p, ce->expr);
+		switch (ce->token.kind) {
+		case Token_cast:
+			ssa_emit_comment(p, str_lit("cast - cast"));
+			return ssa_emit_conv(p, e, type);
+
+		// case Token_transmute:
+			// ssa_emit_comment(p, str_lit("cast - transmute"));
+			// return ssa_emit_transmute(p, e, type);
+
+	#if 0
+		case Token_down_cast:
+			ssa_emit_comment(p, str_lit("cast - down_cast"));
+			return ssa_emit_down_cast(p, e, type);
+	#endif
+
+		// case Token_union_cast:
+			// ssa_emit_comment(p, str_lit("cast - union_cast"));
+			// return ssa_emit_union_cast(p, e, type, ast_node_token(expr).pos);
+
+		default:
+			GB_PANIC("Unhandled cast expression %.*s", LIT(token_strings[ce->token.kind]));
+		}
+	case_end;
+
+	case_ast_node(pl, ProcLit, expr);
+		GB_PANIC("TODO(bill): ssa_build_expr ProcLit");
+	#if 0
+		// NOTE(bill): Generate a new name
+		// parent$count
+		isize name_len = proc->name.len + 1 + 8 + 1;
+		u8 *name_text = gb_alloc_array(proc->module->allocator, u8, name_len);
+		name_len = gb_snprintf(cast(char *)name_text, name_len, "%.*s$%d", LIT(proc->name), cast(i32)proc->children.count);
+		String name = make_string(name_text, name_len-1);
+
+		Type *type = type_of_expr(proc->module->info, expr);
+		irValue *value = ir_value_procedure(proc->module->allocator,
+		                                    proc->module, NULL, type, pl->type, pl->body, name);
+
+		value->Proc.tags = pl->tags;
+		value->Proc.parent = proc;
+
+		array_add(&proc->children, &value->Proc);
+		array_add(&proc->module->procs_to_generate, value);
+
+		return value;
+	#endif
+	case_end;
+
+	case_ast_node(cl, CompoundLit, expr);
+		return ssa_addr_load(p, ssa_build_addr(p, expr));
+	case_end;
+
+
+	case_ast_node(ce, CallExpr, expr);
+		if (map_tav_get(&p->module->info->types, hash_pointer(ce->proc))->mode == Addressing_Type) {
+			GB_ASSERT(ce->args.count == 1);
+			ssaValue *x = ssa_build_expr(p, ce->args.e[0]);
+			return ssa_emit_conv(p, x, tv->type);
+		}
+
+		AstNode *p = unparen_expr(ce->proc);
+		GB_PANIC("TODO(bill): ssa_build_expr CallExpr");
+	case_end;
+
+	case_ast_node(se, SliceExpr, expr);
+		return ssa_addr_load(p, ssa_build_addr(p, expr));
+	case_end;
+
+	case_ast_node(ie, IndexExpr, expr);
+		return ssa_addr_load(p, ssa_build_addr(p, expr));
+	case_end;
 	}
 
+	GB_PANIC("Unexpected expression: %.*s", LIT(ast_node_strings[expr->kind]));
 
 	return NULL;
 }
@@ -1566,21 +1955,43 @@ void ssa_build_when_stmt(ssaProc *p, AstNodeWhenStmt *ws) {
 }
 
 void ssa_build_assign_op(ssaProc *p, ssaAddr lhs, ssaValue *value, TokenKind op) {
-	// ssaValue *old_value = ssa_addr_load(p, lhs);
-	// Type *type = old_value->type;
+	ssaValue *old_value = ssa_addr_load(p, lhs);
+	Type *type = old_value->type;
 
-	// ssaValue *change = value;
-	// if (is_type_pointer(type) && is_type_integer(value->type)) {
-	// 	change = ssa_emit_conv(p, value, default_type(value->type));
-	// } else {
-	// 	change = ssa_emit_conv(p, value, type);
-	// }
-	// ssaValue *new_value = ssa_emit_arith(p, op, old_value, change, type);
-	// ssa_addr_store(p, lhs, new_value);
+	ssaValue *change = value;
+	if (is_type_pointer(type) && is_type_integer(value->type)) {
+		change = ssa_emit_conv(p, value, default_type(value->type));
+	} else {
+		change = ssa_emit_conv(p, value, type);
+	}
+	ssaValue *new_value = ssa_emit_arith(p, op, old_value, change, type);
+	ssa_addr_store(p, lhs, new_value);
 }
 
-
+void ssa_build_stmt_internal(ssaProc *p, AstNode *node);
 void ssa_build_stmt(ssaProc *p, AstNode *node) {
+	u32 prev_stmt_state_flags = p->module->stmt_state_flags;
+
+	if (node->stmt_state_flags != 0) {
+		u32 in = node->stmt_state_flags;
+		u32 out = p->module->stmt_state_flags;
+
+		if (in & StmtStateFlag_bounds_check) {
+			out |= StmtStateFlag_bounds_check;
+			out &= ~StmtStateFlag_no_bounds_check;
+		} else if (in & StmtStateFlag_no_bounds_check) {
+			out |= StmtStateFlag_no_bounds_check;
+			out &= ~StmtStateFlag_bounds_check;
+		}
+
+		p->module->stmt_state_flags = out;
+	}
+
+	ssa_build_stmt_internal(p, node);
+
+	p->module->stmt_state_flags = prev_stmt_state_flags;
+}
+void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
 	if (p->curr_block == NULL) {
 		ssaBlock *dead_block = ssa_new_block(p, ssaBlock_Plain, "");
 		ssa_start_block(p, dead_block);
@@ -1591,7 +2002,9 @@ void ssa_build_stmt(ssaProc *p, AstNode *node) {
 	case_end;
 
 	case_ast_node(bs, BlockStmt, node);
+		ssa_open_scope(p);
 		ssa_build_stmt_list(p, bs->stmts);
+		ssa_close_scope(p, ssaDeferExit_Default, NULL);
 	case_end;
 
 	case_ast_node(us, UsingStmt, node);
@@ -1649,11 +2062,11 @@ void ssa_build_stmt(ssaProc *p, AstNode *node) {
 					if (init == NULL) { // TODO(bill): remove this
 						continue;
 					}
-					Type *t = type_deref(init->type);
-					if (init->op == ssaOp_Addr && t->kind == Type_Tuple) {
+					Type *t = base_type(init->type);
+					if (t->kind == Type_Tuple) {
 						for (isize i = 0; i < t->Tuple.variable_count; i++) {
-							Entity *e = t->Tuple.variables[i];
-							ssaValue *v = ssa_emit_ptr_index(p, init, i);
+							// Entity *e = t->Tuple.variables[i];
+							ssaValue *v = ssa_emit_value_index(p, init, i);
 							array_add(&inits, v);
 						}
 					} else {
@@ -1667,6 +2080,8 @@ void ssa_build_stmt(ssaProc *p, AstNode *node) {
 			}
 
 			gb_temp_arena_memory_end(tmp);
+		} else {
+			GB_PANIC("TODO(bill): ssa_build_stmt Type/Proc Entities");
 		}
 	case_end;
 
@@ -1714,12 +2129,12 @@ void ssa_build_stmt(ssaProc *p, AstNode *node) {
 
 				for_array(i, as->rhs) {
 					ssaValue *init = ssa_build_expr(p, as->rhs.e[i]);
-					Type *t = type_deref(init->type);
+					Type *t = base_type(init->type);
 					// TODO(bill): refactor for code reuse as this is repeated a bit
-					if (init->op == ssaOp_Addr && t->kind == Type_Tuple) {
+					if (t->kind == Type_Tuple) {
 						for (isize i = 0; i < t->Tuple.variable_count; i++) {
 							Entity *e = t->Tuple.variables[i];
-							ssaValue *v = ssa_emit_ptr_index(p, init, i);
+							ssaValue *v = ssa_emit_value_index(p, init, i);
 							array_add(&inits, v);
 						}
 					} else {
@@ -1734,14 +2149,14 @@ void ssa_build_stmt(ssaProc *p, AstNode *node) {
 		} break;
 
 		default: {
-			GB_PANIC("TODO(bill): assign operations");
+			// GB_PANIC("TODO(bill): assign operations");
 			// NOTE(bill): Only 1 += 1 is allowed, no tuples
 			// +=, -=, etc
-			// i32 op = cast(i32)as->op.kind;
-			// op += Token_Add - Token_AddEq; // Convert += to +
-			// ssaAddr lhs = ssa_build_addr(p, as->lhs.e[0]);
-			// ssaValue *value = ssa_build_expr(p, as->rhs.e[0]);
-			// ssa_build_assign_op(p, lhs, value, cast(TokenKind)op);
+			i32 op = cast(i32)as->op.kind;
+			op += Token_Add - Token_AddEq; // Convert += to +
+			ssaAddr lhs = ssa_build_addr(p, as->lhs.e[0]);
+			ssaValue *value = ssa_build_expr(p, as->rhs.e[0]);
+			ssa_build_assign_op(p, lhs, value, cast(TokenKind)op);
 		} break;
 		}
 
@@ -1754,7 +2169,13 @@ void ssa_build_stmt(ssaProc *p, AstNode *node) {
 	case_end;
 
 	case_ast_node(ds, DeferStmt, node);
-		GB_PANIC("TODO: DeferStmt");
+		// GB_PANIC("TODO: DeferStmt");
+		ssa_emit_comment(p, str_lit("DeferStmt"));
+		i32 scope_level = p->scope_level;
+		if (ds->stmt->kind == AstNode_BlockStmt) {
+			scope_level--;
+		}
+		ssa_add_defer_node(p, scope_level, ds->stmt);
 	case_end;
 
 	case_ast_node(rs, ReturnStmt, node);
@@ -1780,18 +2201,18 @@ void ssa_build_stmt(ssaProc *p, AstNode *node) {
 		ssa_build_cond(p, is->cond, then, else_);
 		ssa_start_block(p, then);
 
-		// ssa_open_scope(p);
+		ssa_open_scope(p);
 		ssa_build_stmt(p, is->body);
-		// ssa_close_scope(p, ssaDeferExit_Default, NULL);
+		ssa_close_scope(p, ssaDeferExit_Default, NULL);
 
 		ssa_emit_jump(p, done);
 
 		if (is->else_stmt != NULL) {
 			ssa_start_block(p, else_);
 
-			// ssa_open_scope(p);
+			ssa_open_scope(p);
 			ssa_build_stmt(p, is->else_stmt);
-			// ssa_close_scope(p, ssaDeferExit_Default, NULL);
+			ssa_close_scope(p, ssaDeferExit_Default, NULL);
 
 			ssa_emit_jump(p, done);
 		}
@@ -1829,9 +2250,9 @@ void ssa_build_stmt(ssaProc *p, AstNode *node) {
 		}
 
 		ssa_push_target_list(p, done, post, NULL);
-		// ssa_open_scope(p);
+		ssa_open_scope(p);
 		ssa_build_stmt(p, fs->body);
-		// ssa_close_scope(p, ssaDeferExit_Default, NULL);
+		ssa_close_scope(p, ssaDeferExit_Default, NULL);
 		ssa_pop_target_list(p);
 
 		ssa_emit_jump(p, post);
@@ -1877,7 +2298,7 @@ void ssa_build_stmt(ssaProc *p, AstNode *node) {
 			break;
 		}
 		if (b != NULL) {
-			// ssa_emit_defer_stmts(p, irDeferExit_Branch, b);
+			ssa_emit_defer_stmts(p, ssaDeferExit_Branch, b);
 		}
 		switch (bs->token.kind) {
 		case Token_break:       ssa_emit_comment(p, str_lit("break"));       break;
@@ -1986,6 +2407,9 @@ void ssa_print_proc(gbFile *f, ssaProc *p) {
 				gb_fprintf(f, " b%d", pred->id);
 			}
 		}
+		if (b->name.len > 0) {
+			gb_fprintf(f, " ; %.*s", LIT(b->name));
+		}
 		gb_fprintf(f, "\n");
 
 		isize n = 0;
@@ -2087,6 +2511,10 @@ void ssa_build_proc(ssaModule *m, ssaProc *p) {
 	ssa_start_block(p, p->entry);
 	ssa_build_stmt(p, pl->body);
 
+	if (p->entity->type->Proc.result_count == 0) {
+		ssa_emit_defer_stmts(p, ssaDeferExit_Return, NULL);
+	}
+
 	p->exit = ssa_new_block(p, ssaBlock_Exit, "exit");
 	ssa_emit_jump(p, p->exit);