typedef struct llirProcedure llirProcedure;
typedef struct llirBlock llirBlock;
typedef struct llirValue llirValue;
typedef struct llirDebugInfo llirDebugInfo;

typedef Array(llirValue *) llirValueArray;

#define MAP_TYPE llirValue *
#define MAP_PROC map_llir_value_
#define MAP_NAME MapSsaValue
#include "map.c"

#define MAP_TYPE llirDebugInfo *
#define MAP_PROC map_llir_debug_info_
#define MAP_NAME MapSsaDebugInfo
#include "map.c"

typedef struct llirModule {
	CheckerInfo * info;
	BuildContext *build_context;
	BaseTypeSizes sizes;
	gbArena       arena;
	gbArena       tmp_arena;
	gbAllocator   allocator;
	gbAllocator   tmp_allocator;
	bool generate_debug_info;

	u32 stmt_state_flags;

	// String source_filename;
	String layout;
	// String triple;

	MapEntity       min_dep_map; // Key: Entity *
	MapSsaValue     values;      // Key: Entity *
	MapSsaValue     members;     // Key: String
	MapString       type_names;  // Key: Type *
	MapSsaDebugInfo debug_info;  // Key: Unique pointer
	i32             global_string_index;
	i32             global_array_index; // For ConstantSlice

	Entity *        entry_point_entity;

	Array(llirProcedure *) procs;             // NOTE(bill): All procedures with bodies
	llirValueArray         procs_to_generate; // NOTE(bill): Procedures to generate
} llirModule;

// NOTE(bill): For more info, see https://en.wikipedia.org/wiki/Dominator_(graph_theory)
typedef struct llirDomNode {
	llirBlock *        idom; // Parent (Immediate Dominator)
	Array(llirBlock *) children;
	i32               pre, post; // Ordering in tree
} llirDomNode;


typedef struct llirBlock {
	i32           index;
	String        label;
	llirProcedure *parent;
	AstNode *     node; // Can be NULL
	Scope *       scope;
	isize         scope_index;
	llirDomNode    dom;
	i32           gaps;

	llirValueArray instrs;
	llirValueArray locals;

	Array(llirBlock *) preds;
	Array(llirBlock *) succs;
} llirBlock;

typedef struct llirTargetList llirTargetList;
struct llirTargetList {
	llirTargetList *prev;
	llirBlock *     break_;
	llirBlock *     continue_;
	llirBlock *     fallthrough_;
};

typedef enum llirDeferExitKind {
	llirDeferExit_Default,
	llirDeferExit_Return,
	llirDeferExit_Branch,
} llirDeferExitKind;
typedef enum llirDeferKind {
	llirDefer_Node,
	llirDefer_Instr,
} llirDeferKind;

typedef struct llirDefer {
	llirDeferKind kind;
	isize        scope_index;
	llirBlock *   block;
	union {
		AstNode *stmt;
		// NOTE(bill): `instr` will be copied every time to create a new one
		llirValue *instr;
	};
} llirDefer;

struct llirProcedure {
	llirProcedure *        parent;
	Array(llirProcedure *) children;

	Entity *              entity;
	llirModule *           module;
	String                name;
	Type *                type;
	AstNode *             type_expr;
	AstNode *             body;
	u64                   tags;

	llirValueArray         params;
	Array(llirDefer)       defer_stmts;
	Array(llirBlock *)     blocks;
	i32                   scope_index;
	llirBlock *            decl_block;
	llirBlock *            entry_block;
	llirBlock *            curr_block;
	llirTargetList *       target_list;
	llirValueArray         referrers;

	i32                   local_count;
	i32                   instr_count;
	i32                   block_count;
};

#define LLIR_STARTUP_RUNTIME_PROC_NAME  "__$startup_runtime"
#define LLIR_TYPE_INFO_DATA_NAME        "__$type_info_data"
#define LLIR_TYPE_INFO_DATA_MEMBER_NAME "__$type_info_data_member"


#define LLIR_INSTR_KINDS \
	LLIR_INSTR_KIND(Comment, struct { String text; }) \
	LLIR_INSTR_KIND(Local,   struct { \
		Entity *      entity; \
		Type *        type; \
		bool          zero_initialized; \
		llirValueArray referrers; \
	}) \
	LLIR_INSTR_KIND(ZeroInit, struct { llirValue *address; }) \
	LLIR_INSTR_KIND(Store,    struct { llirValue *address, *value; }) \
	LLIR_INSTR_KIND(Load,     struct { Type *type; llirValue *address; }) \
	LLIR_INSTR_KIND(PtrOffset, struct { \
		llirValue *address; \
		llirValue *offset; \
	}) \
	LLIR_INSTR_KIND(ArrayElementPtr, struct { \
		llirValue *address; \
		Type *    result_type; \
		llirValue *elem_index; \
	}) \
	LLIR_INSTR_KIND(StructElementPtr, struct {  \
		llirValue *address; \
		Type *    result_type; \
		i32       elem_index; \
	}) \
	LLIR_INSTR_KIND(ArrayExtractValue, struct { \
		llirValue *address; \
		Type *    result_type; \
		i32       index; \
	}) \
	LLIR_INSTR_KIND(StructExtractValue, struct { \
		llirValue *address; \
		Type *    result_type; \
		i32       index; \
	}) \
	LLIR_INSTR_KIND(UnionTagPtr, struct { \
		llirValue *address; \
		Type     *type; /* ^int */  \
	}) \
	LLIR_INSTR_KIND(UnionTagValue, struct { \
		llirValue *address; \
		Type     *type; /* int */ \
	}) \
	LLIR_INSTR_KIND(Conv, struct { \
		llirConvKind kind; \
		llirValue *value; \
		Type *from, *to; \
	}) \
	LLIR_INSTR_KIND(Jump, struct { llirBlock *block; }) \
	LLIR_INSTR_KIND(If, struct { \
		llirValue *cond; \
		llirBlock *true_block; \
		llirBlock *false_block; \
	}) \
	LLIR_INSTR_KIND(Return, struct { llirValue *value; }) \
	LLIR_INSTR_KIND(Select, struct { \
		llirValue *cond; \
		llirValue *true_value; \
		llirValue *false_value; \
	}) \
	LLIR_INSTR_KIND(Phi, struct { llirValueArray edges; Type *type; }) \
	LLIR_INSTR_KIND(Unreachable, i32) \
	LLIR_INSTR_KIND(UnaryOp, struct { \
		Type *    type; \
		TokenKind op; \
		llirValue *expr; \
	}) \
	LLIR_INSTR_KIND(BinaryOp, struct { \
		Type *    type; \
		TokenKind op; \
		llirValue *left, *right; \
	}) \
	LLIR_INSTR_KIND(Call, struct { \
		Type *    type; /* return type */  \
		llirValue *value; \
		llirValue **args; \
		isize      arg_count; \
	}) \
	LLIR_INSTR_KIND(VectorExtractElement, struct { \
		llirValue *vector; \
		llirValue *index; \
	}) \
	LLIR_INSTR_KIND(VectorInsertElement, struct { \
		llirValue *vector; \
		llirValue *elem; \
		llirValue *index; \
	}) \
	LLIR_INSTR_KIND(VectorShuffle, struct { \
		llirValue *vector; \
		i32 *     indices; \
		i32       index_count; \
		Type *    type; \
	}) \
	LLIR_INSTR_KIND(StartupRuntime, i32) \
	LLIR_INSTR_KIND(BoundsCheck, struct { \
		TokenPos  pos; \
		llirValue *index; \
		llirValue *len; \
	}) \
	LLIR_INSTR_KIND(SliceBoundsCheck, struct { \
		TokenPos  pos; \
		llirValue *low; \
		llirValue *high; \
		bool      is_substring; \
	})

#define LLIR_CONV_KINDS \
	LLIR_CONV_KIND(trunc) \
	LLIR_CONV_KIND(zext) \
	LLIR_CONV_KIND(fptrunc) \
	LLIR_CONV_KIND(fpext) \
	LLIR_CONV_KIND(fptoui) \
	LLIR_CONV_KIND(fptosi) \
	LLIR_CONV_KIND(uitofp) \
	LLIR_CONV_KIND(sitofp) \
	LLIR_CONV_KIND(ptrtoint) \
	LLIR_CONV_KIND(inttoptr) \
	LLIR_CONV_KIND(bitcast)

typedef enum llirInstrKind {
	llirInstr_Invalid,
#define LLIR_INSTR_KIND(x, ...) GB_JOIN2(llirInstr_, x),
	LLIR_INSTR_KINDS
#undef LLIR_INSTR_KIND
} llirInstrKind;

String const llir_instr_strings[] = {
	{cast(u8 *)"Invalid", gb_size_of("Invalid")-1},
#define LLIR_INSTR_KIND(x, ...) {cast(u8 *)#x, gb_size_of(#x)-1},
	LLIR_INSTR_KINDS
#undef LLIR_INSTR_KIND
};

typedef enum llirConvKind {
	llirConv_Invalid,
#define LLIR_CONV_KIND(x) GB_JOIN2(llirConv_, x),
	LLIR_CONV_KINDS
#undef LLIR_CONV_KIND
} llirConvKind;

String const llir_conv_strings[] = {
	{cast(u8 *)"Invalid", gb_size_of("Invalid")-1},
#define LLIR_CONV_KIND(x) {cast(u8 *)#x, gb_size_of(#x)-1},
	LLIR_CONV_KINDS
#undef LLIR_CONV_KIND
};

#define LLIR_INSTR_KIND(k, ...) typedef __VA_ARGS__ GB_JOIN2(llirInstr, k);
	LLIR_INSTR_KINDS
#undef LLIR_INSTR_KIND

typedef struct llirInstr llirInstr;
struct llirInstr {
	llirInstrKind kind;

	llirBlock *parent;
	Type *type;

	union {
#define LLIR_INSTR_KIND(k, ...) GB_JOIN2(llirInstr, k) k;
	LLIR_INSTR_KINDS
#undef LLIR_INSTR_KIND
	};
};


typedef enum llirValueKind {
	llirValue_Invalid,

	llirValue_Constant,
	llirValue_ConstantSlice,
	llirValue_Nil,
	llirValue_TypeName,
	llirValue_Global,
	llirValue_Param,

	llirValue_Proc,
	llirValue_Block,
	llirValue_Instr,

	llirValue_Count,
} llirValueKind;

typedef struct llirValueConstant {
	Type *     type;
	ExactValue value;
} llirValueConstant;

typedef struct llirValueConstantSlice {
	Type *    type;
	llirValue *backing_array;
	i64       count;
} llirValueConstantSlice;

typedef struct llirValueNil {
	Type *type;
} llirValueNil;

typedef struct llirValueTypeName {
	Type * type;
	String name;
} llirValueTypeName;

typedef struct llirValueGlobal {
	Entity *      entity;
	Type *        type;
	llirValue *    value;
	llirValueArray referrers;
	bool          is_constant;
	bool          is_private;
	bool          is_thread_local;
	bool          is_unnamed_addr;
} llirValueGlobal;

typedef struct llirValueParam {
	llirProcedure *parent;
	Entity *      entity;
	Type *        type;
	llirValueArray referrers;
} llirValueParam;

typedef struct llirValue {
	llirValueKind kind;
	i32 index;
	union {
		llirValueConstant      Constant;
		llirValueConstantSlice ConstantSlice;
		llirValueNil           Nil;
		llirValueTypeName      TypeName;
		llirValueGlobal        Global;
		llirValueParam         Param;
		llirProcedure          Proc;
		llirBlock              Block;
		llirInstr              Instr;
	};
} llirValue;

gb_global llirValue *v_zero    = NULL;
gb_global llirValue *v_one     = NULL;
gb_global llirValue *v_zero32  = NULL;
gb_global llirValue *v_one32   = NULL;
gb_global llirValue *v_two32   = NULL;
gb_global llirValue *v_false   = NULL;
gb_global llirValue *v_true    = NULL;

typedef enum llirAddrKind {
	llirAddr_Default,
	llirAddr_Vector,
} llirAddrKind;

typedef struct llirAddr {
	llirValue *  addr;
	AstNode *   expr; // NOTE(bill): Just for testing - probably remove later
	llirAddrKind kind;
	union {
		struct { llirValue *index; } Vector;
	};
} llirAddr;

llirAddr llir_make_addr(llirValue *addr, AstNode *expr) {
	llirAddr v = {addr, expr};
	return v;
}
llirAddr llir_make_addr_vector(llirValue *addr, llirValue *index, AstNode *expr) {
	llirAddr v = llir_make_addr(addr, expr);
	v.kind = llirAddr_Vector;
	v.Vector.index = index;
	return v;
}



typedef enum llirDebugEncoding {
	llirDebugBasicEncoding_Invalid       = 0,

	llirDebugBasicEncoding_address       = 1,
	llirDebugBasicEncoding_boolean       = 2,
	llirDebugBasicEncoding_float         = 3,
	llirDebugBasicEncoding_signed        = 4,
	llirDebugBasicEncoding_signed_char   = 5,
	llirDebugBasicEncoding_unsigned      = 6,
	llirDebugBasicEncoding_unsigned_char = 7,

	llirDebugBasicEncoding_member       = 13,
	llirDebugBasicEncoding_pointer_type = 15,
	llirDebugBasicEncoding_typedef      = 22,

	llirDebugBasicEncoding_array_type       = 1,
	llirDebugBasicEncoding_enumeration_type = 4,
	llirDebugBasicEncoding_structure_type   = 19,
	llirDebugBasicEncoding_union_type       = 23,

} llirDebugEncoding;

typedef enum llirDebugInfoKind {
	llirDebugInfo_Invalid,

	llirDebugInfo_CompileUnit,
	llirDebugInfo_File,
	llirDebugInfo_Scope,
	llirDebugInfo_Proc,
	llirDebugInfo_AllProcs,

	llirDebugInfo_BasicType,      // basic types
	llirDebugInfo_ProcType,
	llirDebugInfo_DerivedType,    // pointer, typedef
	llirDebugInfo_CompositeType,  // array, struct, enum, (raw_)union
	llirDebugInfo_Enumerator,     // For llirDebugInfo_CompositeType if enum
	llirDebugInfo_GlobalVariable,
	llirDebugInfo_LocalVariable,


	llirDebugInfo_Count,
} llirDebugInfoKind;

typedef struct llirDebugInfo llirDebugInfo;
struct llirDebugInfo {
	llirDebugInfoKind kind;
	i32 id;

	union {
		struct {
			AstFile *     file;
			String        producer;
			llirDebugInfo *all_procs;
		} CompileUnit;
		struct {
			AstFile *file;
			String   filename;
			String   directory;
		} File;
		struct {
			llirDebugInfo *parent;
			llirDebugInfo *file;
			TokenPos      pos;
			Scope *       scope; // Actual scope
		} Scope;
		struct {
			Entity *      entity;
			String        name;
			llirDebugInfo *file;
			TokenPos      pos;
		} Proc;
		struct {
			Array(llirDebugInfo *) procs;
		} AllProcs;


		struct {
			String           name;
			i32              size;
			i32              align;
			llirDebugEncoding encoding;
		} BasicType;
		struct {
			llirDebugInfo *        return_type;
			Array(llirDebugInfo *) param_types;
		} ProcType;
		struct {
			llirDebugInfo *   base_type;
			llirDebugEncoding encoding;
		} DerivedType;
		struct {
			llirDebugEncoding      encoding;
			String                name;
			String                identifier;
			llirDebugInfo *        file;
			TokenPos              pos;
			i32                   size;
			i32                   align;
			Array(llirDebugInfo *) elements;
		} CompositeType;
		struct {
			String name;
			i64    value;
		} Enumerator;
		struct {
			String        name;
			String        linkage_name;
			llirDebugInfo *scope;
			llirDebugInfo *file;
			TokenPos      pos;
			llirValue     *variable;
			llirDebugInfo *declaration;
		} GlobalVariable;
		struct {
			String        name;
			llirDebugInfo *scope;
			llirDebugInfo *file;
			TokenPos      pos;
			i32           arg; // Non-zero if proc parameter
			llirDebugInfo *type;
		} LocalVariable;
	};
};

typedef struct llirGen {
	llirModule module;
	gbFile    output_file;
	bool       opt_called;
} llirGen;

llirValue *llir_lookup_member(llirModule *m, String name) {
	llirValue **v = map_llir_value_get(&m->members, hash_string(name));
	if (v != NULL) {
		return *v;
	}
	return NULL;
}


Type *llir_type(llirValue *value);
Type *llir_instr_type(llirInstr *instr) {
	switch (instr->kind) {
	case llirInstr_Local:
		return instr->Local.type;
	case llirInstr_Load:
		return instr->Load.type;
	case llirInstr_StructElementPtr:
		return instr->StructElementPtr.result_type;
	case llirInstr_ArrayElementPtr:
		return instr->ArrayElementPtr.result_type;
	case llirInstr_PtrOffset:
		return llir_type(instr->PtrOffset.address);
	case llirInstr_Phi:
		return instr->Phi.type;
	case llirInstr_ArrayExtractValue:
		return instr->ArrayExtractValue.result_type;
	case llirInstr_StructExtractValue:
		return instr->StructExtractValue.result_type;
	case llirInstr_UnionTagPtr:
		return instr->UnionTagPtr.type;
	case llirInstr_UnionTagValue:
		return instr->UnionTagValue.type;
	case llirInstr_UnaryOp:
		return instr->UnaryOp.type;
	case llirInstr_BinaryOp:
		return instr->BinaryOp.type;
	case llirInstr_Conv:
		return instr->Conv.to;
	case llirInstr_Select:
		return llir_type(instr->Select.true_value);
	case llirInstr_Call: {
		Type *pt = base_type(instr->Call.type);
		if (pt != NULL) {
			if (pt->kind == Type_Tuple && pt->Tuple.variable_count == 1) {
				return pt->Tuple.variables[0]->type;
			}
			return pt;
		}
		return NULL;
	} break;
	case llirInstr_VectorExtractElement: {
		Type *vt = llir_type(instr->VectorExtractElement.vector);
		Type *bt = base_vector_type(vt);
		GB_ASSERT(!is_type_vector(bt));
		return bt;
	} break;
	case llirInstr_VectorInsertElement:
		return llir_type(instr->VectorInsertElement.vector);
	case llirInstr_VectorShuffle:
		return instr->VectorShuffle.type;
	}
	return NULL;
}

Type *llir_type(llirValue *value) {
	switch (value->kind) {
	case llirValue_Constant:
		return value->Constant.type;
	case llirValue_ConstantSlice:
		return value->ConstantSlice.type;
	case llirValue_Nil:
		return value->Nil.type;
	case llirValue_TypeName:
		return value->TypeName.type;
	case llirValue_Global:
		return value->Global.type;
	case llirValue_Param:
		return value->Param.type;
	case llirValue_Proc:
		return value->Proc.type;
	case llirValue_Instr:
		return llir_instr_type(&value->Instr);
	}
	return NULL;
}

Type *llir_addr_type(llirAddr lval) {
	if (lval.addr != NULL) {
		Type *t = llir_type(lval.addr);
		GB_ASSERT(is_type_pointer(t));
		return type_deref(t);
	}
	return NULL;
}



bool llir_is_blank_ident(AstNode *node) {
	if (node->kind == AstNode_Ident) {
		ast_node(i, Ident, node);
		return is_blank_ident(i->string);
	}
	return false;
}


llirInstr *llir_get_last_instr(llirBlock *block) {
	if (block != NULL) {
		isize len = block->instrs.count;
		if (len > 0) {
			llirValue *v = block->instrs.e[len-1];
			GB_ASSERT(v->kind == llirValue_Instr);
			return &v->Instr;
		}
	}
	return NULL;

}

bool llir_is_instr_terminating(llirInstr *i) {
	if (i != NULL) {
		switch (i->kind) {
		case llirInstr_Return:
		case llirInstr_Unreachable:
			return true;
		}
	}

	return false;
}


void llir_add_edge(llirBlock *from, llirBlock *to) {
	array_add(&from->succs, to);
	array_add(&to->preds, from);
}

void llir_set_instr_parent(llirValue *instr, llirBlock *parent) {
	if (instr->kind == llirValue_Instr) {
		instr->Instr.parent = parent;
	}
}

llirValueArray *llir_value_referrers(llirValue *v) {
	switch (v->kind) {
	case llirValue_Global:
		return &v->Global.referrers;
	case llirValue_Param:
		return &v->Param.referrers;
	case llirValue_Proc: {
		if (v->Proc.parent != NULL) {
			return &v->Proc.referrers;
		}
		return NULL;
	}
	case llirValue_Instr: {
		llirInstr *i = &v->Instr;
		switch (i->kind) {
		case llirInstr_Local:
			return &i->Local.referrers;
		}
	} break;
	}

	return NULL;
}



////////////////////////////////////////////////////////////////
//
// @Make
//
////////////////////////////////////////////////////////////////

void      llir_module_add_value    (llirModule *m, Entity *e, llirValue *v);
llirValue *llir_emit_zero_init      (llirProcedure *p, llirValue *address);
llirValue *llir_emit_comment        (llirProcedure *p, String text);
llirValue *llir_emit_store          (llirProcedure *p, llirValue *address, llirValue *value);
llirValue *llir_emit_load           (llirProcedure *p, llirValue *address);
void      llir_emit_jump           (llirProcedure *proc, llirBlock *block);
llirValue *llir_emit_conv           (llirProcedure *proc, llirValue *value, Type *t);
llirValue *llir_type_info           (llirProcedure *proc, Type *type);
llirValue *llir_build_expr          (llirProcedure *proc, AstNode *expr);
void      llir_build_stmt          (llirProcedure *proc, AstNode *node);
llirValue *llir_build_cond          (llirProcedure *proc, AstNode *cond, llirBlock *true_block, llirBlock *false_block);
void      llir_build_defer_stmt    (llirProcedure *proc, llirDefer d);
llirAddr   llir_build_addr          (llirProcedure *proc, AstNode *expr);
void      llir_build_proc          (llirValue *value, llirProcedure *parent);
void      llir_gen_global_type_name(llirModule *m, Entity *e, String name);




llirValue *llir_alloc_value(gbAllocator a, llirValueKind kind) {
	llirValue *v = gb_alloc_item(a, llirValue);
	v->kind = kind;
	return v;
}
llirValue *llir_alloc_instr(llirProcedure *proc, llirInstrKind kind) {
	llirValue *v = llir_alloc_value(proc->module->allocator, llirValue_Instr);
	v->Instr.kind = kind;
	proc->instr_count++;
	return v;
}
llirDebugInfo *llir_alloc_debug_info(gbAllocator a, llirDebugInfoKind kind) {
	llirDebugInfo *di = gb_alloc_item(a, llirDebugInfo);
	di->kind = kind;
	return di;
}




llirValue *llir_make_value_type_name(gbAllocator a, String name, Type *type) {
	llirValue *v = llir_alloc_value(a, llirValue_TypeName);
	v->TypeName.name = name;
	v->TypeName.type = type;
	return v;
}

llirValue *llir_make_value_global(gbAllocator a, Entity *e, llirValue *value) {
	llirValue *v = llir_alloc_value(a, llirValue_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;
}
llirValue *llir_make_value_param(gbAllocator a, llirProcedure *parent, Entity *e) {
	llirValue *v = llir_alloc_value(a, llirValue_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;
}
llirValue *llir_make_value_nil(gbAllocator a, Type *type) {
	llirValue *v = llir_alloc_value(a, llirValue_Nil);
	v->Nil.type = type;
	return v;
}



llirValue *llir_make_instr_local(llirProcedure *p, Entity *e, bool zero_initialized) {
	llirValue *v = llir_alloc_instr(p, llirInstr_Local);
	llirInstr *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
	llir_module_add_value(p->module, e, v);
	return v;
}


llirValue *llir_make_instr_store(llirProcedure *p, llirValue *address, llirValue *value) {
	llirValue *v = llir_alloc_instr(p, llirInstr_Store);
	llirInstr *i = &v->Instr;
	i->Store.address = address;
	i->Store.value = value;
	return v;
}

llirValue *llir_make_instr_zero_init(llirProcedure *p, llirValue *address) {
	llirValue *v = llir_alloc_instr(p, llirInstr_ZeroInit);
	llirInstr *i = &v->Instr;
	i->ZeroInit.address = address;
	return v;
}

llirValue *llir_make_instr_load(llirProcedure *p, llirValue *address) {
	llirValue *v = llir_alloc_instr(p, llirInstr_Load);
	llirInstr *i = &v->Instr;
	i->Load.address = address;
	i->Load.type = type_deref(llir_type(address));
	return v;
}

llirValue *llir_make_instr_array_element_ptr(llirProcedure *p, llirValue *address, llirValue *elem_index) {
	llirValue *v = llir_alloc_instr(p, llirInstr_ArrayElementPtr);
	llirInstr *i = &v->Instr;
	Type *t = llir_type(address);
	GB_ASSERT(is_type_pointer(t));
	t = base_type(type_deref(t));
	GB_ASSERT(is_type_array(t) || is_type_vector(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(llir_type(address)),
	              "%s", type_to_string(llir_type(address)));
	return v;
}
llirValue *llir_make_instr_struct_element_ptr(llirProcedure *p, llirValue *address, i32 elem_index, Type *result_type) {
	llirValue *v = llir_alloc_instr(p, llirInstr_StructElementPtr);
	llirInstr *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(llir_type(address)),
	              "%s", type_to_string(llir_type(address)));
	return v;
}
llirValue *llir_make_instr_ptr_offset(llirProcedure *p, llirValue *address, llirValue *offset) {
	llirValue *v = llir_alloc_instr(p, llirInstr_PtrOffset);
	llirInstr *i = &v->Instr;
	i->PtrOffset.address = address;
	i->PtrOffset.offset  = offset;

	GB_ASSERT_MSG(is_type_pointer(llir_type(address)),
	              "%s", type_to_string(llir_type(address)));
	GB_ASSERT_MSG(is_type_integer(llir_type(offset)),
	              "%s", type_to_string(llir_type(address)));

	return v;
}



llirValue *llir_make_instr_array_extract_value(llirProcedure *p, llirValue *address, i32 index) {
	llirValue *v = llir_alloc_instr(p, llirInstr_ArrayExtractValue);
	llirInstr *i = &v->Instr;
	i->ArrayExtractValue.address = address;
	i->ArrayExtractValue.index = index;
	Type *t = base_type(llir_type(address));
	GB_ASSERT(is_type_array(t));
	i->ArrayExtractValue.result_type = t->Array.elem;
	return v;
}

llirValue *llir_make_instr_struct_extract_value(llirProcedure *p, llirValue *address, i32 index, Type *result_type) {
	llirValue *v = llir_alloc_instr(p, llirInstr_StructExtractValue);
	llirInstr *i = &v->Instr;
	i->StructExtractValue.address = address;
	i->StructExtractValue.index = index;
	i->StructExtractValue.result_type = result_type;
	return v;
}

llirValue *llir_make_instr_union_tag_ptr(llirProcedure *p, llirValue *address) {
	llirValue *v = llir_alloc_instr(p, llirInstr_UnionTagPtr);
	llirInstr *i = &v->Instr;
	i->UnionTagPtr.address = address;
	i->UnionTagPtr.type = t_int_ptr;
	return v;
}

llirValue *llir_make_instr_union_tag_value(llirProcedure *p, llirValue *address) {
	llirValue *v = llir_alloc_instr(p, llirInstr_UnionTagValue);
	llirInstr *i = &v->Instr;
	i->UnionTagValue.address = address;
	i->UnionTagValue.type = t_int_ptr;
	return v;
}

llirValue *llir_make_instr_unary_op(llirProcedure *p, TokenKind op, llirValue *expr, Type *type) {
	llirValue *v = llir_alloc_instr(p, llirInstr_UnaryOp);
	llirInstr *i = &v->Instr;
	i->UnaryOp.op = op;
	i->UnaryOp.expr = expr;
	i->UnaryOp.type = type;
	return v;
}


llirValue *llir_make_instr_binary_op(llirProcedure *p, TokenKind op, llirValue *left, llirValue *right, Type *type) {
	llirValue *v = llir_alloc_instr(p, llirInstr_BinaryOp);
	llirInstr *i = &v->Instr;
	i->BinaryOp.op = op;
	i->BinaryOp.left = left;
	i->BinaryOp.right = right;
	i->BinaryOp.type = type;
	return v;
}

llirValue *llir_make_instr_jump(llirProcedure *p, llirBlock *block) {
	llirValue *v = llir_alloc_instr(p, llirInstr_Jump);
	llirInstr *i = &v->Instr;
	i->Jump.block = block;
	return v;
}
llirValue *llir_make_instr_if(llirProcedure *p, llirValue *cond, llirBlock *true_block, llirBlock *false_block) {
	llirValue *v = llir_alloc_instr(p, llirInstr_If);
	llirInstr *i = &v->Instr;
	i->If.cond = cond;
	i->If.true_block = true_block;
	i->If.false_block = false_block;
	return v;
}


llirValue *llir_make_instr_phi(llirProcedure *p, llirValueArray edges, Type *type) {
	llirValue *v = llir_alloc_instr(p, llirInstr_Phi);
	llirInstr *i = &v->Instr;
	i->Phi.edges = edges;
	i->Phi.type = type;
	return v;
}

llirValue *llir_make_instr_unreachable(llirProcedure *p) {
	llirValue *v = llir_alloc_instr(p, llirInstr_Unreachable);
	return v;
}

llirValue *llir_make_instr_return(llirProcedure *p, llirValue *value) {
	llirValue *v = llir_alloc_instr(p, llirInstr_Return);
	v->Instr.Return.value = value;
	return v;
}

llirValue *llir_make_instr_select(llirProcedure *p, llirValue *cond, llirValue *t, llirValue *f) {
	llirValue *v = llir_alloc_instr(p, llirInstr_Select);
	v->Instr.Select.cond = cond;
	v->Instr.Select.true_value = t;
	v->Instr.Select.false_value = f;
	return v;
}

llirValue *llir_make_instr_call(llirProcedure *p, llirValue *value, llirValue **args, isize arg_count, Type *result_type) {
	llirValue *v = llir_alloc_instr(p, llirInstr_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;
}

llirValue *llir_make_instr_conv(llirProcedure *p, llirConvKind kind, llirValue *value, Type *from, Type *to) {
	llirValue *v = llir_alloc_instr(p, llirInstr_Conv);
	v->Instr.Conv.kind = kind;
	v->Instr.Conv.value = value;
	v->Instr.Conv.from = from;
	v->Instr.Conv.to = to;
	return v;
}

llirValue *llir_make_instr_extract_element(llirProcedure *p, llirValue *vector, llirValue *index) {
	llirValue *v = llir_alloc_instr(p, llirInstr_VectorExtractElement);
	v->Instr.VectorExtractElement.vector = vector;
	v->Instr.VectorExtractElement.index = index;
	return v;
}

llirValue *llir_make_instr_insert_element(llirProcedure *p, llirValue *vector, llirValue *elem, llirValue *index) {
	llirValue *v = llir_alloc_instr(p, llirInstr_VectorInsertElement);
	v->Instr.VectorInsertElement.vector = vector;
	v->Instr.VectorInsertElement.elem   = elem;
	v->Instr.VectorInsertElement.index  = index;
	return v;
}

llirValue *llir_make_instr_vector_shuffle(llirProcedure *p, llirValue *vector, i32 *indices, isize index_count) {
	llirValue *v = llir_alloc_instr(p, llirInstr_VectorShuffle);
	v->Instr.VectorShuffle.vector      = vector;
	v->Instr.VectorShuffle.indices     = indices;
	v->Instr.VectorShuffle.index_count = index_count;

	Type *vt = base_type(llir_type(vector));
	v->Instr.VectorShuffle.type = make_type_vector(p->module->allocator, vt->Vector.elem, index_count);

	return v;
}

llirValue *llir_make_instr_comment(llirProcedure *p, String text) {
	llirValue *v = llir_alloc_instr(p, llirInstr_Comment);
	v->Instr.Comment.text = text;
	return v;
}

llirValue *llir_make_instr_bounds_check(llirProcedure *p, TokenPos pos, llirValue *index, llirValue *len) {
	llirValue *v = llir_alloc_instr(p, llirInstr_BoundsCheck);
	v->Instr.BoundsCheck.pos   = pos;
	v->Instr.BoundsCheck.index = index;
	v->Instr.BoundsCheck.len   = len;
	return v;
}
llirValue *llir_make_instr_slice_bounds_check(llirProcedure *p, TokenPos pos, llirValue *low, llirValue *high, bool is_substring) {
	llirValue *v = llir_alloc_instr(p, llirInstr_SliceBoundsCheck);
	v->Instr.SliceBoundsCheck.pos  = pos;
	v->Instr.SliceBoundsCheck.low  = low;
	v->Instr.SliceBoundsCheck.high = high;
	v->Instr.SliceBoundsCheck.is_substring = is_substring;
	return v;
}



llirValue *llir_make_value_constant(gbAllocator a, Type *type, ExactValue value) {
	llirValue *v = llir_alloc_value(a, llirValue_Constant);
	v->Constant.type  = type;
	v->Constant.value = value;
	return v;
}


llirValue *llir_make_value_constant_slice(gbAllocator a, Type *type, llirValue *backing_array, i64 count) {
	llirValue *v = llir_alloc_value(a, llirValue_ConstantSlice);
	v->ConstantSlice.type = type;
	v->ConstantSlice.backing_array = backing_array;
	v->ConstantSlice.count = count;
	return v;
}

llirValue *llir_make_const_int(gbAllocator a, i64 i) {
	return llir_make_value_constant(a, t_int, make_exact_value_integer(i));
}
llirValue *llir_make_const_i32(gbAllocator a, i64 i) {
	return llir_make_value_constant(a, t_i32, make_exact_value_integer(i));
}
llirValue *llir_make_const_i64(gbAllocator a, i64 i) {
	return llir_make_value_constant(a, t_i64, make_exact_value_integer(i));
}
llirValue *llir_make_const_bool(gbAllocator a, bool b) {
	return llir_make_value_constant(a, t_bool, make_exact_value_bool(b != 0));
}
llirValue *llir_make_const_string(gbAllocator a, String s) {
	return llir_make_value_constant(a, t_string, make_exact_value_string(s));
}

llirValue *llir_make_value_procedure(gbAllocator a, llirModule *m, Entity *entity, Type *type, AstNode *type_expr, AstNode *body, String name) {
	llirValue *v = llir_alloc_value(a, llirValue_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()); // TODO(bill): replace heap allocator

	Type *t = base_type(type);
	GB_ASSERT(is_type_proc(t));
	array_init_reserve(&v->Proc.params, heap_allocator(), t->Proc.param_count);

	return v;
}

llirBlock *llir_add_block(llirProcedure *proc, AstNode *node, char *label) {
	Scope *scope = NULL;
	if (node != NULL) {
		Scope **found = map_scope_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]));
		}
	}

	llirValue *v = llir_alloc_value(proc->module->allocator, llirValue_Block);
	v->Block.label  = make_string_c(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());

	llirBlock *block = &v->Block;

	array_add(&proc->blocks, block);
	proc->block_count++;

	return block;
}





llirDefer llir_add_defer_node(llirProcedure *proc, isize scope_index, AstNode *stmt) {
	llirDefer d = {llirDefer_Node};
	d.scope_index = scope_index;
	d.block = proc->curr_block;
	d.stmt = stmt;
	array_add(&proc->defer_stmts, d);
	return d;
}


llirDefer llir_add_defer_instr(llirProcedure *proc, isize scope_index, llirValue *instr) {
	llirDefer d = {llirDefer_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;
}



llirValue *llir_add_module_constant(llirModule *m, Type *type, ExactValue value) {
	gbAllocator a = m->allocator;
	// gbAllocator a = gb_heap_allocator();

	if (is_type_slice(type)) {
		ast_node(cl, CompoundLit, value.value_compound);

		isize count = cl->elems.count;
		if (count == 0) {
			return llir_make_value_nil(a, type);
		}
		Type *elem = base_type(type)->Slice.elem;
		Type *t = make_type_array(a, elem, count);
		llirValue *backing_array = llir_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);
		llirValue *g = llir_make_value_global(a, e, backing_array);
		llir_module_add_value(m, e, g);
		map_llir_value_set(&m->members, hash_string(name), g);

		return llir_make_value_constant_slice(a, type, g, count);
	}

	return llir_make_value_constant(a, type, value);
}

llirValue *llir_add_global_string_array(llirModule *m, String string) {
	// TODO(bill): Should this use the arena allocator or the heap allocator?
	// Strings could be huge!
	gbAllocator a = m->allocator;
	// gbAllocator a = gb_heap_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);
	llirValue *g = llir_make_value_global(a, entity, llir_add_module_constant(m, type, ev));
	g->Global.is_private      = true;
	// g->Global.is_unnamed_addr = true;
	// g->Global.is_constant = true;

	llir_module_add_value(m, entity, g);
	map_llir_value_set(&m->members, hash_string(name), g);

	return g;
}




llirValue *llir_add_local(llirProcedure *proc, Entity *e) {
	llirBlock *b = proc->decl_block; // all variables must be in the first block
	llirValue *instr = llir_make_instr_local(proc, e, true);
	instr->Instr.parent = b;
	array_add(&b->instrs, instr);
	array_add(&b->locals, instr);
	proc->local_count++;

	// if (zero_initialized) {
		llir_emit_zero_init(proc, instr);
	// }

	return instr;
}

llirValue *llir_add_local_for_identifier(llirProcedure *proc, AstNode *name, bool zero_initialized) {
	Entity **found = map_entity_get(&proc->module->info->definitions, hash_pointer(name));
	if (found) {
		Entity *e = *found;
		llir_emit_comment(proc, e->token.string);
		return llir_add_local(proc, e);
	}
	return NULL;
}

llirValue *llir_add_local_generated(llirProcedure *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 llir_add_local(proc, e);
}

llirValue *llir_add_param(llirProcedure *proc, Entity *e) {
	llirValue *v = llir_make_value_param(proc->module->allocator, proc, e);
#if 1
	llirValue *l = llir_add_local(proc, e);
	llir_emit_store(proc, l, v);
#else
	llir_module_add_value(proc->module, e, v);
#endif
	return v;
}



////////////////////////////////////////////////////////////////
//
// @Debug
//
////////////////////////////////////////////////////////////////

llirDebugInfo *llir_add_debug_info_file(llirProcedure *proc, AstFile *file) {
	if (!proc->module->generate_debug_info) {
		return NULL;
	}

	GB_ASSERT(file != NULL);
	llirDebugInfo *di = llir_alloc_debug_info(proc->module->allocator, llirDebugInfo_File);
	di->File.file = file;

	String filename = file->tokenizer.fullpath;
	String directory = filename;
	isize slash_index = 0;
	for (isize i = filename.len-1; i >= 0; i--) {
		if (filename.text[i] == '\\' ||
		    filename.text[i] == '/') {
			break;
		}
		slash_index = i;
	}
	directory.len = slash_index-1;
	filename.text = filename.text + slash_index;
	filename.len -= slash_index;


	di->File.filename = filename;
	di->File.directory = directory;

	map_llir_debug_info_set(&proc->module->debug_info, hash_pointer(file), di);
	return di;
}


llirDebugInfo *llir_add_debug_info_proc(llirProcedure *proc, Entity *entity, String name, llirDebugInfo *file) {
	if (!proc->module->generate_debug_info) {
		return NULL;
	}

	GB_ASSERT(entity != NULL);
	llirDebugInfo *di = llir_alloc_debug_info(proc->module->allocator, llirDebugInfo_Proc);
	di->Proc.entity = entity;
	di->Proc.name = name;
	di->Proc.file = file;
	di->Proc.pos = entity->token.pos;

	map_llir_debug_info_set(&proc->module->debug_info, hash_pointer(entity), di);
	return di;
}

////////////////////////////////////////////////////////////////
//
// @Emit
//
////////////////////////////////////////////////////////////////


llirValue *llir_emit(llirProcedure *proc, llirValue *instr) {
	GB_ASSERT(instr->kind == llirValue_Instr);
	llirBlock *b = proc->curr_block;
	instr->Instr.parent = b;
	if (b != NULL) {
		llirInstr *i = llir_get_last_instr(b);
		if (!llir_is_instr_terminating(i)) {
			array_add(&b->instrs, instr);
		}
	}
	return instr;
}
llirValue *llir_emit_store(llirProcedure *p, llirValue *address, llirValue *value) {
	return llir_emit(p, llir_make_instr_store(p, address, value));
}
llirValue *llir_emit_load(llirProcedure *p, llirValue *address) {
	return llir_emit(p, llir_make_instr_load(p, address));
}
llirValue *llir_emit_select(llirProcedure *p, llirValue *cond, llirValue *t, llirValue *f) {
	return llir_emit(p, llir_make_instr_select(p, cond, t, f));
}

llirValue *llir_emit_zero_init(llirProcedure *p, llirValue *address)  {
	return llir_emit(p, llir_make_instr_zero_init(p, address));
}

llirValue *llir_emit_comment(llirProcedure *p, String text) {
	return llir_emit(p, llir_make_instr_comment(p, text));
}


llirValue *llir_emit_call(llirProcedure *p, llirValue *value, llirValue **args, isize arg_count) {
	Type *pt = base_type(llir_type(value));
	GB_ASSERT(pt->kind == Type_Proc);
	Type *results = pt->Proc.results;
	return llir_emit(p, llir_make_instr_call(p, value, args, arg_count, results));
}

llirValue *llir_emit_global_call(llirProcedure *proc, char *name_, llirValue **args, isize arg_count) {
	String name = make_string_c(name_);
	llirValue **found = map_llir_value_get(&proc->module->members, hash_string(name));
	GB_ASSERT_MSG(found != NULL, "%.*s", LIT(name));
	llirValue *gp = *found;
	return llir_emit_call(proc, gp, args, arg_count);
}



void llir_emit_defer_stmts(llirProcedure *proc, llirDeferExitKind kind, llirBlock *block) {
	isize count = proc->defer_stmts.count;
	isize i = count;
	while (i --> 0) {
		llirDefer d = proc->defer_stmts.e[i];
		if (kind == llirDeferExit_Default) {
			if (proc->scope_index == d.scope_index &&
			    d.scope_index > 1) {
				llir_build_defer_stmt(proc, d);
				array_pop(&proc->defer_stmts);
				continue;
			} else {
				break;
			}
		} else if (kind == llirDeferExit_Return) {
			llir_build_defer_stmt(proc, d);
		} else if (kind == llirDeferExit_Branch) {
			GB_ASSERT(block != NULL);
			isize lower_limit = block->scope_index+1;
			if (lower_limit < d.scope_index) {
				llir_build_defer_stmt(proc, d);
			}
		}
	}
}


void llir_open_scope(llirProcedure *proc) {
	proc->scope_index++;
}

void llir_close_scope(llirProcedure *proc, llirDeferExitKind kind, llirBlock *block) {
	llir_emit_defer_stmts(proc, kind, block);
	GB_ASSERT(proc->scope_index > 0);
	proc->scope_index--;
}



void llir_emit_unreachable(llirProcedure *proc) {
	llir_emit(proc, llir_make_instr_unreachable(proc));
}

void llir_emit_return(llirProcedure *proc, llirValue *v) {
	llir_emit_defer_stmts(proc, llirDeferExit_Return, NULL);
	llir_emit(proc, llir_make_instr_return(proc, v));
}

void llir_emit_jump(llirProcedure *proc, llirBlock *target_block) {
	llirBlock *b = proc->curr_block;
	if (b == NULL) {
		return;
	}
	llir_emit(proc, llir_make_instr_jump(proc, target_block));
	llir_add_edge(b, target_block);
	proc->curr_block = NULL;
}

void llir_emit_if(llirProcedure *proc, llirValue *cond, llirBlock *true_block, llirBlock *false_block) {
	llirBlock *b = proc->curr_block;
	if (b == NULL) {
		return;
	}
	llir_emit(proc, llir_make_instr_if(proc, cond, true_block, false_block));
	llir_add_edge(b, true_block);
	llir_add_edge(b, false_block);
	proc->curr_block = NULL;
}

void llir_emit_startup_runtime(llirProcedure *proc) {
	GB_ASSERT(proc->parent == NULL && str_eq(proc->name, str_lit("main")));
	llir_emit(proc, llir_alloc_instr(proc, llirInstr_StartupRuntime));
}




llirValue *llir_addr_store(llirProcedure *proc, llirAddr addr, llirValue *value) {
	if (addr.addr == NULL) {
		return NULL;
	}

	if (addr.kind == llirAddr_Vector) {
		llirValue *v = llir_emit_load(proc, addr.addr);
		Type *elem_type = base_type(llir_type(v))->Vector.elem;
		llirValue *elem = llir_emit_conv(proc, value, elem_type);
		llirValue *out = llir_emit(proc, llir_make_instr_insert_element(proc, v, elem, addr.Vector.index));
		return llir_emit_store(proc, addr.addr, out);
	} else {
		llirValue *v = llir_emit_conv(proc, value, llir_addr_type(addr));
		return llir_emit_store(proc, addr.addr, v);
	}
}
llirValue *llir_addr_load(llirProcedure *proc, llirAddr addr) {
	if (addr.addr == NULL) {
		GB_PANIC("Illegal addr load");
		return NULL;
	}

	if (addr.kind == llirAddr_Vector) {
		llirValue *v = llir_emit_load(proc, addr.addr);
		return llir_emit(proc, llir_make_instr_extract_element(proc, v, addr.Vector.index));
	}
	Type *t = base_type(llir_type(addr.addr));
	if (t->kind == Type_Proc) {
		// NOTE(bill): Imported procedures don't require a load as they are pointers
		return addr.addr;
	}
	return llir_emit_load(proc, addr.addr);
}




llirValue *llir_emit_ptr_offset(llirProcedure *proc, llirValue *ptr, llirValue *offset) {
	offset = llir_emit_conv(proc, offset, t_int);
	return llir_emit(proc, llir_make_instr_ptr_offset(proc, ptr, offset));
}

llirValue *llir_emit_arith(llirProcedure *proc, TokenKind op, llirValue *left, llirValue *right, Type *type) {
	Type *t_left = llir_type(left);
	Type *t_right = llir_type(right);

	if (op == Token_Add) {
		if (is_type_pointer(t_left)) {
			llirValue *ptr = llir_emit_conv(proc, left, type);
			llirValue *offset = right;
			return llir_emit_ptr_offset(proc, ptr, offset);
		} else if (is_type_pointer(llir_type(right))) {
			llirValue *ptr = llir_emit_conv(proc, right, type);
			llirValue *offset = left;
			return llir_emit_ptr_offset(proc, ptr, offset);
		}
	} else if (op == Token_Sub) {
		if (is_type_pointer(t_left) && is_type_integer(t_right)) {
			// ptr - int
			llirValue *ptr = llir_emit_conv(proc, left, type);
			llirValue *offset = right;
			return llir_emit_ptr_offset(proc, ptr, offset);
		} else if (is_type_pointer(t_left) && is_type_pointer(t_right)) {
			GB_ASSERT(is_type_integer(type));
			Type *ptr_type = t_left;
			llirModule *m = proc->module;
			llirValue *x = llir_emit_conv(proc, left, type);
			llirValue *y = llir_emit_conv(proc, right, type);
			llirValue *diff = llir_emit_arith(proc, op, x, y, type);
			llirValue *elem_size = llir_make_const_int(m->allocator, type_size_of(m->sizes, m->allocator, ptr_type));
			return llir_emit_arith(proc, Token_Quo, diff, elem_size, type);
		}
	}


	switch (op) {
	case Token_AndNot: {
		// NOTE(bill): x &~ y == x & (~y) == x & (y ~ -1)
		// NOTE(bill): "not" `x` == `x` "xor" `-1`
		llirValue *neg = llir_add_module_constant(proc->module, type, make_exact_value_integer(-1));
		op = Token_Xor;
		right = llir_emit_arith(proc, op, right, neg, type);
		GB_ASSERT(right->Instr.kind == llirInstr_BinaryOp);
		right->Instr.BinaryOp.type = type;
		op = Token_And;
	} /* fallthrough */
	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_Shl:
	case Token_Shr:
		left  = llir_emit_conv(proc, left, type);
		right = llir_emit_conv(proc, right, type);
		break;
	}

	return llir_emit(proc, llir_make_instr_binary_op(proc, op, left, right, type));
}

llirValue *llir_emit_comp(llirProcedure *proc, TokenKind op_kind, llirValue *left, llirValue *right) {
	Type *a = base_type(llir_type(left));
	Type *b = base_type(llir_type(right));

	GB_ASSERT(gb_is_between(op_kind, Token__ComparisonBegin+1, Token__ComparisonEnd-1));

	if (are_types_identical(a, b)) {
		// NOTE(bill): No need for a conversion
	} else if (left->kind == llirValue_Constant || left->kind == llirValue_Nil) {
		left = llir_emit_conv(proc, left, llir_type(right));
	} else if (right->kind == llirValue_Constant || right->kind == llirValue_Nil) {
		right = llir_emit_conv(proc, right, llir_type(left));
	}

	Type *result = t_bool;
	if (is_type_vector(a)) {
		result = make_type_vector(proc->module->allocator, t_bool, a->Vector.count);
	}
	return llir_emit(proc, llir_make_instr_binary_op(proc, op_kind, left, right, result));
}

llirValue *llir_emit_array_ep(llirProcedure *proc, llirValue *s, llirValue *index) {
	GB_ASSERT(index != NULL);
	Type *st = base_type(type_deref(llir_type(s)));
	GB_ASSERT(is_type_array(st) || is_type_vector(st));

	// NOTE(bill): For some weird legacy reason in LLVM, structure elements must be accessed as an i32
	index = llir_emit_conv(proc, index, t_i32);
	return llir_emit(proc, llir_make_instr_array_element_ptr(proc, s, index));
}

llirValue *llir_emit_array_epi(llirProcedure *proc, llirValue *s, i32 index) {
	return llir_emit_array_ep(proc, s, llir_make_const_i32(proc->module->allocator, index));
}

llirValue *llir_emit_union_tag_ptr(llirProcedure *proc, llirValue *u) {
	Type *t = llir_type(u);
	GB_ASSERT(is_type_pointer(t) &&
	          is_type_union(type_deref(t)));
	GB_ASSERT(are_types_identical(t, llir_type(u)));
	return llir_emit(proc, llir_make_instr_union_tag_ptr(proc, u));
}

llirValue *llir_emit_union_tag_value(llirProcedure *proc, llirValue *u) {
	Type *t = llir_type(u);
	GB_ASSERT(is_type_union(t));
	GB_ASSERT(are_types_identical(t, llir_type(u)));
	return llir_emit(proc, llir_make_instr_union_tag_value(proc, u));
}



llirValue *llir_emit_struct_ep(llirProcedure *proc, llirValue *s, i32 index) {
	gbAllocator a = proc->module->allocator;
	Type *t = base_type(type_deref(llir_type(s)));
	Type *result_type = NULL;
	llirValue *gep = NULL;

	if (is_type_struct(t)) {
		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);
	} 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));
		result_type = make_type_pointer(a, t->Tuple.variables[index]->type);
	} else if (is_type_slice(t)) {
		switch (index) {
		case 0: result_type = make_type_pointer(a, make_type_pointer(a, t->Slice.elem)); break;
		case 1: result_type = make_type_pointer(a, t_int); break;
		case 2: result_type = make_type_pointer(a, t_int); break;
		}
	} else if (is_type_string(t)) {
		switch (index) {
		case 0: result_type = make_type_pointer(a, t_u8_ptr); break;
		case 1: result_type = make_type_pointer(a, t_int);    break;
		}
	} else if (is_type_any(t)) {
		switch (index) {
		case 0: result_type = make_type_pointer(a, t_type_info_ptr); break;
		case 1: result_type = make_type_pointer(a, t_rawptr);        break;
		}
	} else if (is_type_maybe(t)) {
		switch (index) {
		case 0: result_type = make_type_pointer(a, t->Maybe.elem); break;
		case 1: result_type = make_type_pointer(a, t_bool);        break;
		}
	} else {
		GB_PANIC("TODO(bill): struct_gep type: %s, %d", type_to_string(llir_type(s)), index);
	}

	GB_ASSERT(result_type != NULL);

	gep = llir_make_instr_struct_element_ptr(proc, s, index, result_type);
	return llir_emit(proc, gep);
}



llirValue *llir_emit_array_ev(llirProcedure *proc, llirValue *s, i32 index) {
	Type *st = base_type(llir_type(s));
	GB_ASSERT(is_type_array(st));
	return llir_emit(proc, llir_make_instr_array_extract_value(proc, s, index));
}

llirValue *llir_emit_struct_ev(llirProcedure *proc, llirValue *s, i32 index) {
	// NOTE(bill): For some weird legacy reason in LLVM, structure elements must be accessed as an i32

	gbAllocator a = proc->module->allocator;
	Type *t = base_type(llir_type(s));
	Type *result_type = NULL;

	if (is_type_struct(t)) {
		GB_ASSERT(t->Record.field_count > 0);
		GB_ASSERT(gb_is_between(index, 0, t->Record.field_count-1));
		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));
		result_type = t->Tuple.variables[index]->type;
	} else if (is_type_slice(t)) {
		switch (index) {
		case 0: result_type = make_type_pointer(a, t->Slice.elem); break;
		case 1: result_type = t_int; break;
		case 2: result_type = t_int; break;
		}
	} else if (is_type_string(t)) {
		switch (index) {
		case 0: result_type = t_u8_ptr; break;
		case 1: result_type = t_int;    break;
		}
	} else if (is_type_any(t)) {
		switch (index) {
		case 0: result_type = t_type_info_ptr; break;
		case 1: result_type = t_rawptr;        break;
		}
	} else if (is_type_maybe(t)) {
		switch (index) {
		case 0: result_type = t->Maybe.elem; break;
		case 1: result_type = t_bool;        break;
		}
	} else {
		GB_PANIC("TODO(bill): struct_ev type: %s, %d", type_to_string(llir_type(s)), index);
	}

	GB_ASSERT(result_type != NULL);

	return llir_emit(proc, llir_make_instr_struct_extract_value(proc, s, index, result_type));
}


llirValue *llir_emit_deep_field_gep(llirProcedure *proc, Type *type, llirValue *e, Selection sel) {
	GB_ASSERT(sel.index.count > 0);

	for_array(i, sel.index) {
		i32 index = cast(i32)sel.index.e[i];
		if (is_type_pointer(type)) {
			type = type_deref(type);
			e = llir_emit_load(proc, e);
			e = llir_emit_ptr_offset(proc, e, v_zero); // TODO(bill): Do I need these copies?
		}
		type = base_type(type);


		if (is_type_raw_union(type)) {
			type = type->Record.fields[index]->type;
			e = llir_emit_conv(proc, e, make_type_pointer(proc->module->allocator, type));
		} else if (type->kind == Type_Record) {
			type = type->Record.fields[index]->type;
			e = llir_emit_struct_ep(proc, e, index);
		} else if (type->kind == Type_Basic) {
			switch (type->Basic.kind) {
			case Basic_any: {
				if (index == 0) {
					type = t_type_info_ptr;
				} else if (index == 1) {
					type = t_rawptr;
				}
				e = llir_emit_struct_ep(proc, e, index);
			} break;

			case Basic_string:
				e = llir_emit_struct_ep(proc, e, index);
				break;

			default:
				GB_PANIC("un-gep-able type");
				break;
			}
		} else if (type->kind == Type_Slice) {
			e = llir_emit_struct_ep(proc, e, index);
		} else if (type->kind == Type_Vector) {
			e = llir_emit_array_epi(proc, e, index);
		} else if (type->kind == Type_Array) {
			e = llir_emit_array_epi(proc, e, index);
		} else {
			GB_PANIC("un-gep-able type");
		}
	}

	return e;
}


llirValue *llir_emit_deep_field_ev(llirProcedure *proc, Type *type, llirValue *e, Selection sel) {
	GB_ASSERT(sel.index.count > 0);

	for_array(i, sel.index) {
		i32 index = cast(i32)sel.index.e[i];
		if (is_type_pointer(type)) {
			type = type_deref(type);
			e = llir_emit_load(proc, e);
			e = llir_emit_ptr_offset(proc, e, v_zero); // TODO(bill): Do I need these copies?
		}
		type = base_type(type);


		if (is_type_raw_union(type)) {
			GB_PANIC("TODO(bill): IS THIS EVEN CORRECT?");
			type = type->Record.fields[index]->type;
			e = llir_emit_conv(proc, e, type);
		} else {
			e = llir_emit_struct_ev(proc, e, index);
		}
	}

	return e;
}




llirValue *llir_array_elem(llirProcedure *proc, llirValue *array) {
	return llir_emit_array_ep(proc, array, v_zero32);
}
llirValue *llir_array_len(llirProcedure *proc, llirValue *array) {
	Type *t = llir_type(array);
	GB_ASSERT(t->kind == Type_Array);
	return llir_make_const_int(proc->module->allocator, t->Array.count);
}
llirValue *llir_array_cap(llirProcedure *proc, llirValue *array) {
	return llir_array_len(proc, array);
}

llirValue *llir_slice_elem(llirProcedure *proc, llirValue *slice) {
	Type *t = llir_type(slice);
	GB_ASSERT(t->kind == Type_Slice);
	return llir_emit_struct_ev(proc, slice, 0);
}
llirValue *llir_slice_len(llirProcedure *proc, llirValue *slice) {
	Type *t = llir_type(slice);
	GB_ASSERT(t->kind == Type_Slice);
	return llir_emit_struct_ev(proc, slice, 1);
}

llirValue *llir_string_elem(llirProcedure *proc, llirValue *string) {
	Type *t = llir_type(string);
	GB_ASSERT(t->kind == Type_Basic && t->Basic.kind == Basic_string);
	return llir_emit_struct_ev(proc, string, 0);
}
llirValue *llir_string_len(llirProcedure *proc, llirValue *string) {
	Type *t = llir_type(string);
	GB_ASSERT_MSG(t->kind == Type_Basic && t->Basic.kind == Basic_string, "%s", type_to_string(t));
	return llir_emit_struct_ev(proc, string, 1);
}



llirValue *llir_add_local_slice(llirProcedure *proc, Type *slice_type, llirValue *base, llirValue *low, llirValue *high) {
	// TODO(bill): array bounds checking for slice creation
	// TODO(bill): check that low < high <= max
	gbAllocator a = proc->module->allocator;
	Type *bt = base_type(llir_type(base));

	if (low == NULL) {
		low = v_zero;
	}
	if (high == NULL) {
		switch (bt->kind) {
		case Type_Array:   high = llir_array_len(proc, base); break;
		case Type_Slice:   high = llir_slice_len(proc, base); break;
		case Type_Pointer: high = v_one;                     break;
		}
	}

	llirValue *len = llir_emit_arith(proc, Token_Sub, high, low, t_int);

	llirValue *elem = NULL;
	switch (bt->kind) {
	case Type_Array:   elem = llir_array_elem(proc, base); break;
	case Type_Slice:   elem = llir_slice_elem(proc, base); break;
	case Type_Pointer: elem = llir_emit_load(proc, base);  break;
	}

	elem = llir_emit_ptr_offset(proc, elem, low);

	llirValue *slice = llir_add_local_generated(proc, slice_type);

	llirValue *gep = NULL;
	gep = llir_emit_struct_ep(proc, slice, 0);
	llir_emit_store(proc, gep, elem);

	gep = llir_emit_struct_ep(proc, slice, 1);
	llir_emit_store(proc, gep, len);

	return slice;
}

llirValue *llir_emit_string(llirProcedure *proc, llirValue *elem, llirValue *len) {
	llirValue *str = llir_add_local_generated(proc, t_string);
	llirValue *str_elem = llir_emit_struct_ep(proc, str, 0);
	llirValue *str_len = llir_emit_struct_ep(proc, str, 1);
	llir_emit_store(proc, str_elem, elem);
	llir_emit_store(proc, str_len, len);
	return llir_emit_load(proc, str);
}




String lookup_polymorphic_field(CheckerInfo *info, Type *dst, Type *src) {
	Type *prev_src = src;
	// Type *prev_dst = dst;
	src = base_type(type_deref(src));
	// dst = base_type(type_deref(dst));
	bool src_is_ptr = src != prev_src;
	// bool dst_is_ptr = dst != prev_dst;

	GB_ASSERT(is_type_struct(src));
	for (isize i = 0; i < src->Record.field_count; i++) {
		Entity *f = src->Record.fields[i];
		if (f->kind == Entity_Variable && f->flags & EntityFlag_Anonymous) {
			if (are_types_identical(dst, f->type)) {
				return f->token.string;
			}
			if (src_is_ptr && is_type_pointer(dst)) {
				if (are_types_identical(type_deref(dst), f->type)) {
					return f->token.string;
				}
			}
			if (is_type_struct(f->type)) {
				String name = lookup_polymorphic_field(info, dst, f->type);
				if (name.len > 0) {
					return name;
				}
			}
		}
	}
	return str_lit("");
}

llirValue *llir_emit_bitcast(llirProcedure *proc, llirValue *data, Type *type) {
	return llir_emit(proc, llir_make_instr_conv(proc, llirConv_bitcast, data, llir_type(data), type));
}


llirValue *llir_emit_conv(llirProcedure *proc, llirValue *value, Type *t) {
	Type *src_type = llir_type(value);
	if (are_types_identical(t, src_type)) {
		return value;
	}

	Type *src = base_type(base_enum_type(src_type));
	Type *dst = base_type(base_enum_type(t));

	if (value->kind == llirValue_Constant) {
		if (is_type_any(dst)) {
			llirValue *default_value = llir_add_local_generated(proc, default_type(src_type));
			llir_emit_store(proc, default_value, value);
			return llir_emit_conv(proc, llir_emit_load(proc, default_value), t_any);
		} else if (dst->kind == Type_Basic) {
			ExactValue ev = value->Constant.value;
			if (is_type_float(dst)) {
				ev = exact_value_to_float(ev);
			} else if (is_type_string(dst)) {
				// Handled elsewhere
				GB_ASSERT(ev.kind == ExactValue_String);
			} else if (is_type_integer(dst)) {
				ev = exact_value_to_integer(ev);
			} else if (is_type_pointer(dst)) {
				// IMPORTANT NOTE(bill): LLVM doesn't support pointer constants expect `null`
				llirValue *i = llir_add_module_constant(proc->module, t_uint, ev);
				return llir_emit(proc, llir_make_instr_conv(proc, llirConv_inttoptr, i, t_uint, dst));
			}
			return llir_add_module_constant(proc->module, t, ev);
		}
	}

	if (are_types_identical(src, dst)) {
		return value;
	}

	if (is_type_maybe(dst)) {
		llirValue *maybe = llir_add_local_generated(proc, dst);
		llirValue *val = llir_emit_struct_ep(proc, maybe, 0);
		llirValue *set = llir_emit_struct_ep(proc, maybe, 1);
		llir_emit_store(proc, val, value);
		llir_emit_store(proc, set, v_true);
		return llir_emit_load(proc, maybe);
	}

	// integer -> integer
	if (is_type_integer(src) && is_type_integer(dst)) {
		GB_ASSERT(src->kind == Type_Basic &&
		          dst->kind == Type_Basic);
		i64 sz = type_size_of(proc->module->sizes, proc->module->allocator, src);
		i64 dz = type_size_of(proc->module->sizes, proc->module->allocator, dst);
		if (sz == dz) {
			// NOTE(bill): In LLVM, all integers are signed and rely upon 2's compliment
			return value;
		}

		llirConvKind kind = llirConv_trunc;
		if (dz >= sz) {
			kind = llirConv_zext;
		}
		return llir_emit(proc, llir_make_instr_conv(proc, kind, value, src, dst));
	}

	// boolean -> integer
	if (is_type_boolean(src) && is_type_integer(dst)) {
		return llir_emit(proc, llir_make_instr_conv(proc, llirConv_zext, value, src, dst));
	}

	// integer -> boolean
	if (is_type_integer(src) && is_type_boolean(dst)) {
		return llir_emit_comp(proc, Token_NotEq, value, v_zero);
	}


	// float -> float
	if (is_type_float(src) && is_type_float(dst)) {
		i64 sz = type_size_of(proc->module->sizes, proc->module->allocator, src);
		i64 dz = type_size_of(proc->module->sizes, proc->module->allocator, dst);
		llirConvKind kind = llirConv_fptrunc;
		if (dz >= sz) {
			kind = llirConv_fpext;
		}
		return llir_emit(proc, llir_make_instr_conv(proc, kind, value, src, dst));
	}

	// float <-> integer
	if (is_type_float(src) && is_type_integer(dst)) {
		llirConvKind kind = llirConv_fptosi;
		if (is_type_unsigned(dst)) {
			kind = llirConv_fptoui;
		}
		return llir_emit(proc, llir_make_instr_conv(proc, kind, value, src, dst));
	}
	if (is_type_integer(src) && is_type_float(dst)) {
		llirConvKind kind = llirConv_sitofp;
		if (is_type_unsigned(src)) {
			kind = llirConv_uitofp;
		}
		return llir_emit(proc, llir_make_instr_conv(proc, kind, value, src, dst));
	}

	// Pointer <-> int
	if (is_type_pointer(src) && is_type_int_or_uint(dst)) {
		return llir_emit(proc, llir_make_instr_conv(proc, llirConv_ptrtoint, value, src, dst));
	}
	if (is_type_int_or_uint(src) && is_type_pointer(dst)) {
		return llir_emit(proc, llir_make_instr_conv(proc, llirConv_inttoptr, value, src, dst));
	}

	if (is_type_union(dst)) {
		for (isize i = 0; i < dst->Record.field_count; i++) {
			Entity *f = dst->Record.fields[i];
			if (are_types_identical(f->type, src_type)) {
				llir_emit_comment(proc, str_lit("union - child to parent"));
				gbAllocator allocator = proc->module->allocator;
				llirValue *parent = llir_add_local_generated(proc, t);
				llirValue *tag = llir_make_const_int(allocator, i);
				llir_emit_store(proc, llir_emit_union_tag_ptr(proc, parent), tag);

				llirValue *data = llir_emit_conv(proc, parent, t_rawptr);

				Type *tag_type = src_type;
				Type *tag_type_ptr = make_type_pointer(allocator, tag_type);
				llirValue *underlying = llir_emit_bitcast(proc, data, tag_type_ptr);
				llir_emit_store(proc, underlying, value);

				return llir_emit_load(proc, parent);
			}
		}
	}

	// NOTE(bill): This has to be done beofre `Pointer <-> Pointer` as it's
	// subtype polymorphism casting
	{
		Type *sb = base_type(type_deref(src));
		bool src_is_ptr = src != sb;
		if (is_type_struct(sb)) {
			String field_name = lookup_polymorphic_field(proc->module->info, t, src);
			// gb_printf("field_name: %.*s\n", LIT(field_name));
			if (field_name.len > 0) {
				// NOTE(bill): It can be casted
				Selection sel = lookup_field(proc->module->allocator, sb, field_name, false);
				if (sel.entity != NULL) {
					llir_emit_comment(proc, str_lit("cast - polymorphism"));
					if (src_is_ptr) {
						value = llir_emit_load(proc, value);
					}
					return llir_emit_deep_field_ev(proc, sb, value, sel);
				}
			}
		}
	}



	// Pointer <-> Pointer
	if (is_type_pointer(src) && is_type_pointer(dst)) {
		return llir_emit_bitcast(proc, value, dst);
	}



	// proc <-> proc
	if (is_type_proc(src) && is_type_proc(dst)) {
		return llir_emit_bitcast(proc, value, dst);
	}

	// pointer -> proc
	if (is_type_pointer(src) && is_type_proc(dst)) {
		return llir_emit_bitcast(proc, value, dst);
	}
	// proc -> pointer
	if (is_type_proc(src) && is_type_pointer(dst)) {
		return llir_emit_bitcast(proc, value, dst);
	}



	// []byte/[]u8 <-> string
	if (is_type_u8_slice(src) && is_type_string(dst)) {
		llirValue *elem = llir_slice_elem(proc, value);
		llirValue *len  = llir_slice_len(proc, value);
		return llir_emit_string(proc, elem, len);
	}
	if (is_type_string(src) && is_type_u8_slice(dst)) {
		llirValue *elem = llir_string_elem(proc, value);
		llirValue *elem_ptr = llir_add_local_generated(proc, llir_type(elem));
		llir_emit_store(proc, elem_ptr, elem);

		llirValue *len  = llir_string_len(proc, value);
		llirValue *slice = llir_add_local_slice(proc, dst, elem_ptr, v_zero, len);
		return llir_emit_load(proc, slice);
	}

	if (is_type_vector(dst)) {
		Type *dst_elem = dst->Vector.elem;
		value = llir_emit_conv(proc, value, dst_elem);
		llirValue *v = llir_add_local_generated(proc, t);
		v = llir_emit_load(proc, v);
		v = llir_emit(proc, llir_make_instr_insert_element(proc, v, value, v_zero32));
		// NOTE(bill): Broadcast lowest value to all values
		isize index_count = dst->Vector.count;
		i32 *indices = gb_alloc_array(proc->module->allocator, i32, index_count);
		for (isize i = 0; i < index_count; i++) {
			indices[i] = 0;
		}

		v = llir_emit(proc, llir_make_instr_vector_shuffle(proc, v, indices, index_count));
		return v;
	}

	if (is_type_any(dst)) {
		llirValue *result = llir_add_local_generated(proc, t_any);

		if (is_type_untyped_nil(src)) {
			return llir_emit_load(proc, result);
		}

		llirValue *data = NULL;
		if (value->kind == llirValue_Instr &&
		    value->Instr.kind == llirInstr_Load) {
			// NOTE(bill): Addrellirble value
			data = value->Instr.Load.address;
		} else {
			// NOTE(bill): Non-addrellirble value
			data = llir_add_local_generated(proc, src_type);
			llir_emit_store(proc, data, value);
		}
		GB_ASSERT(is_type_pointer(llir_type(data)));
		GB_ASSERT(is_type_typed(src_type));
		data = llir_emit_conv(proc, data, t_rawptr);


		llirValue *ti = llir_type_info(proc, src_type);

		llirValue *gep0 = llir_emit_struct_ep(proc, result, 0);
		llirValue *gep1 = llir_emit_struct_ep(proc, result, 1);
		llir_emit_store(proc, gep0, ti);
		llir_emit_store(proc, gep1, data);

		return llir_emit_load(proc, result);
	}

	if (is_type_untyped_nil(src) && type_has_nil(dst)) {
		return llir_make_value_nil(proc->module->allocator, t);
	}


	gb_printf_err("llir_emit_conv: src -> dst\n");
	gb_printf_err("Not Identical %s != %s\n", type_to_string(src_type), type_to_string(t));
	gb_printf_err("Not Identical %s != %s\n", type_to_string(src), type_to_string(dst));


	GB_PANIC("Invalid type conversion: `%s` to `%s`", type_to_string(src_type), type_to_string(t));

	return NULL;
}

bool llir_is_type_aggregate(Type *t) {
	t = base_type(t);
	switch (t->kind) {
	case Type_Basic:
		switch (t->Basic.kind) {
		case Basic_string:
		case Basic_any:
			return true;
		}
		break;

	case Type_Pointer:
	case Type_Vector:
		return false;

	case Type_Array:
	case Type_Slice:
	case Type_Maybe:
	case Type_Record:
	case Type_Tuple:
		return true;

	case Type_Named:
		return llir_is_type_aggregate(t->Named.base);
	}

	return false;
}

llirValue *llir_emit_transmute(llirProcedure *proc, llirValue *value, Type *t) {
	Type *src_type = llir_type(value);
	if (are_types_identical(t, src_type)) {
		return value;
	}

	Type *src = base_type(src_type);
	Type *dst = base_type(t);
	if (are_types_identical(t, src_type)) {
		return value;
	}

	llirModule *m = proc->module;

	i64 sz = type_size_of(m->sizes, m->allocator, src);
	i64 dz = type_size_of(m->sizes, m->allocator, dst);

	GB_ASSERT_MSG(sz == dz, "Invalid transmute conversion: `%s` to `%s`", type_to_string(src_type), type_to_string(t));

	if (llir_is_type_aggregate(src) || llir_is_type_aggregate(dst)) {
		llirValue *s = llir_add_local_generated(proc, src);
		llir_emit_store(proc, s, value);

		llirValue *d = llir_emit_bitcast(proc, s, make_type_pointer(m->allocator, dst));
		return llir_emit_load(proc, d);
	}

	// TODO(bill): Actually figure out what the conversion needs to be correctly 'cause LLVM

	return llir_emit_bitcast(proc, value, dst);
}

llirValue *llir_emit_down_cast(llirProcedure *proc, llirValue *value, Type *t) {
	GB_ASSERT(is_type_pointer(llir_type(value)));
	gbAllocator allocator = proc->module->allocator;

	String field_name = check_down_cast_name(t, type_deref(llir_type(value)));
	GB_ASSERT(field_name.len > 0);
	Selection sel = lookup_field(proc->module->allocator, t, field_name, false);
	llirValue *bytes = llir_emit_conv(proc, value, t_u8_ptr);

	i64 offset_ = type_offset_of_from_selection(proc->module->sizes, allocator, type_deref(t), sel);
	llirValue *offset = llir_make_const_int(allocator, -offset_);
	llirValue *head = llir_emit_ptr_offset(proc, bytes, offset);
	return llir_emit_conv(proc, head, t);
}

llirValue *llir_emit_union_cast(llirProcedure *proc, llirValue *value, Type *tuple) {
	GB_ASSERT(tuple->kind == Type_Tuple);
	gbAllocator a = proc->module->allocator;

	Type *src_type = llir_type(value);
	bool is_ptr = is_type_pointer(src_type);

	llirValue *v = llir_add_local_generated(proc, tuple);

	if (is_ptr) {
		Type *src = base_type(type_deref(src_type));
		Type *src_ptr = src_type;
		GB_ASSERT(is_type_union(src));
		Type *dst_ptr = tuple->Tuple.variables[0]->type;
		Type *dst = type_deref(dst_ptr);

		llirValue *tag = llir_emit_load(proc, llir_emit_union_tag_ptr(proc, value));
		llirValue *dst_tag = NULL;
		for (isize i = 1; i < src->Record.field_count; i++) {
			Entity *f = src->Record.fields[i];
			if (are_types_identical(f->type, dst)) {
				dst_tag = llir_make_const_int(a, i);
				break;
			}
		}
		GB_ASSERT(dst_tag != NULL);

		llirBlock *ok_block = llir_add_block(proc, NULL, "union_cast.ok");
		llirBlock *end_block = llir_add_block(proc, NULL, "union_cast.end");
		llirValue *cond = llir_emit_comp(proc, Token_CmpEq, tag, dst_tag);
		llir_emit_if(proc, cond, ok_block, end_block);
		proc->curr_block = ok_block;

		llirValue *gep0 = llir_emit_struct_ep(proc, v, 0);
		llirValue *gep1 = llir_emit_struct_ep(proc, v, 1);

		llirValue *data = llir_emit_conv(proc, value, dst_ptr);
		llir_emit_store(proc, gep0, data);
		llir_emit_store(proc, gep1, v_true);

		llir_emit_jump(proc, end_block);
		proc->curr_block = end_block;

	} else {
		Type *src = base_type(src_type);
		GB_ASSERT(is_type_union(src));
		Type *dst = tuple->Tuple.variables[0]->type;
		Type *dst_ptr = make_type_pointer(a, dst);

		llirValue *tag = llir_emit_union_tag_value(proc, value);
		llirValue *dst_tag = NULL;
		for (isize i = 1; i < src->Record.field_count; i++) {
			Entity *f = src->Record.fields[i];
			if (are_types_identical(f->type, dst)) {
				dst_tag = llir_make_const_int(a, i);
				break;
			}
		}
		GB_ASSERT(dst_tag != NULL);

		// HACK(bill): This is probably not very efficient
		llirValue *union_copy = llir_add_local_generated(proc, src_type);
		llir_emit_store(proc, union_copy, value);

		llirBlock *ok_block = llir_add_block(proc, NULL, "union_cast.ok");
		llirBlock *end_block = llir_add_block(proc, NULL, "union_cast.end");
		llirValue *cond = llir_emit_comp(proc, Token_CmpEq, tag, dst_tag);
		llir_emit_if(proc, cond, ok_block, end_block);
		proc->curr_block = ok_block;

		llirValue *gep0 = llir_emit_struct_ep(proc, v, 0);
		llirValue *gep1 = llir_emit_struct_ep(proc, v, 1);

		llirValue *data = llir_emit_load(proc, llir_emit_conv(proc, union_copy, dst_ptr));
		llir_emit_store(proc, gep0, data);
		llir_emit_store(proc, gep1, v_true);

		llir_emit_jump(proc, end_block);
		proc->curr_block = end_block;

	}
	return llir_emit_load(proc, v);
}


isize llir_type_info_index(CheckerInfo *info, Type *type) {
	type = default_type(type);

	isize entry_index = -1;
	HashKey key = hash_pointer(type);
	isize *found_entry_index = map_isize_get(&info->type_info_map, key);
	if (found_entry_index) {
		entry_index = *found_entry_index;
	}
	if (entry_index < 0) {
		// NOTE(bill): Do manual search
		// TODO(bill): This is O(n) and can be very slow
		for_array(i, info->type_info_map.entries){
			MapIsizeEntry *e = &info->type_info_map.entries.e[i];
			Type *prev_type = cast(Type *)e->key.ptr;
			if (are_types_identical(prev_type, type)) {
				entry_index = e->value;
				// NOTE(bill): Add it to the search map
				map_isize_set(&info->type_info_map, key, entry_index);
				break;
			}
		}
	}

	if (entry_index < 0) {
		compiler_error("Type_Info for `%s` could not be found", type_to_string(type));
	}
	return entry_index;
}

llirValue *llir_type_info(llirProcedure *proc, Type *type) {
	llirValue **found = map_llir_value_get(&proc->module->members, hash_string(str_lit(LLIR_TYPE_INFO_DATA_NAME)));
	GB_ASSERT(found != NULL);
	llirValue *type_info_data = *found;
	CheckerInfo *info = proc->module->info;

	type = default_type(type);

	i32 entry_index = llir_type_info_index(info, type);

	// gb_printf_err("%d %s\n", entry_index, type_to_string(type));

	return llir_emit_array_ep(proc, type_info_data, llir_make_const_i32(proc->module->allocator, entry_index));
}



llirValue *llir_emit_logical_binary_expr(llirProcedure *proc, AstNode *expr) {
	ast_node(be, BinaryExpr, expr);
#if 0
	llirBlock *true_   = llir_add_block(proc, NULL, "logical.cmp.true");
	llirBlock *false_  = llir_add_block(proc, NULL, "logical.cmp.false");
	llirBlock *done  = llir_add_block(proc, NULL, "logical.cmp.done");

	llirValue *result = llir_add_local_generated(proc, t_bool);
	llir_build_cond(proc, expr, true_, false_);

	proc->curr_block = true_;
	llir_emit_store(proc, result, v_true);
	llir_emit_jump(proc, done);

	proc->curr_block = false_;
	llir_emit_store(proc, result, v_false);
	llir_emit_jump(proc, done);

	proc->curr_block = done;

	return llir_emit_load(proc, result);
#else
	llirBlock *rhs = llir_add_block(proc, NULL, "logical.cmp.rhs");
	llirBlock *done = llir_add_block(proc, NULL, "logical.cmp.done");

	Type *type = type_of_expr(proc->module->info, expr);
	type = default_type(type);

	llirValue *short_circuit = NULL;
	if (be->op.kind == Token_CmpAnd) {
		llir_build_cond(proc, be->left, rhs, done);
		short_circuit = v_false;
	} else if (be->op.kind == Token_CmpOr) {
		llir_build_cond(proc, be->left, done, rhs);
		short_circuit = v_true;
	}

	if (rhs->preds.count == 0) {
		proc->curr_block = done;
		return short_circuit;
	}

	if (done->preds.count == 0) {
		proc->curr_block = rhs;
		return llir_build_expr(proc, be->right);
	}

	llirValueArray edges = {0};
	array_init_reserve(&edges, proc->module->allocator, done->preds.count+1);
	for_array(i, done->preds) {
		array_add(&edges, short_circuit);
	}

	proc->curr_block = rhs;
	array_add(&edges, llir_build_expr(proc, be->right));
	llir_emit_jump(proc, done);
	proc->curr_block = done;

	return llir_emit(proc, llir_make_instr_phi(proc, edges, type));
#endif
}


void llir_emit_bounds_check(llirProcedure *proc, Token token, llirValue *index, llirValue *len) {
	if ((proc->module->stmt_state_flags & StmtStateFlag_no_bounds_check) != 0) {
		return;
	}

	index = llir_emit_conv(proc, index, t_int);
	len = llir_emit_conv(proc, len, t_int);

	llir_emit(proc, llir_make_instr_bounds_check(proc, token.pos, index, len));

	// gbAllocator a = proc->module->allocator;
	// llirValue **args = gb_alloc_array(a, llirValue *, 5);
	// args[0] = llir_emit_global_string(proc, token.pos.file);
	// args[1] = llir_make_const_int(a, token.pos.line);
	// args[2] = llir_make_const_int(a, token.pos.column);
	// args[3] = llir_emit_conv(proc, index, t_int);
	// args[4] = llir_emit_conv(proc, len, t_int);

	// llir_emit_global_call(proc, "__bounds_check_error", args, 5);
}

void llir_emit_slice_bounds_check(llirProcedure *proc, Token token, llirValue *low, llirValue *high, bool is_substring) {
	if ((proc->module->stmt_state_flags & StmtStateFlag_no_bounds_check) != 0) {
		return;
	}

	low  = llir_emit_conv(proc, low,  t_int);
	high = llir_emit_conv(proc, high, t_int);

	llir_emit(proc, llir_make_instr_slice_bounds_check(proc, token.pos, low, high, is_substring));
}


////////////////////////////////////////////////////////////////
//
// @Build
//
////////////////////////////////////////////////////////////////


void llir_push_target_list(llirProcedure *proc, llirBlock *break_, llirBlock *continue_, llirBlock *fallthrough_) {
	llirTargetList *tl = gb_alloc_item(proc->module->allocator, llirTargetList);
	tl->prev          = proc->target_list;
	tl->break_        = break_;
	tl->continue_     = continue_;
	tl->fallthrough_  = fallthrough_;
	proc->target_list = tl;
}

void llir_pop_target_list(llirProcedure *proc) {
	proc->target_list = proc->target_list->prev;
}


void llir_mangle_sub_type_name(llirModule *m, Entity *field, String parent) {
	if (field->kind != Entity_TypeName) {
		return;
	}
	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_memmove(child.text+i, parent.text, parent.len);
	i += parent.len;
	child.text[i++] = '.';
	gb_memmove(child.text+i, cn.text, cn.len);

	map_string_set(&m->type_names, hash_pointer(field->type), child);
	llir_gen_global_type_name(m, field, child);
}

void llir_gen_global_type_name(llirModule *m, Entity *e, String name) {
	llirValue *t = llir_make_value_type_name(m->allocator, name, e->type);
	llir_module_add_value(m, e, t);
	map_llir_value_set(&m->members, hash_string(name), t);

	if (is_type_union(e->type)) {
		Type *bt = base_type(e->type);
		TypeRecord *s = &bt->Record;
		// NOTE(bill): Zeroth entry is null (for `match type` stmts)
		for (isize j = 1; j < s->field_count; j++) {
			llir_mangle_sub_type_name(m, s->fields[j], name);
		}
	}
}




void llir_build_defer_stmt(llirProcedure *proc, llirDefer d) {
	llirBlock *b = llir_add_block(proc, NULL, "defer");
	// NOTE(bill): The prev block may defer injection before it's terminator
	llirInstr *last_instr = llir_get_last_instr(proc->curr_block);
	if (last_instr == NULL || !llir_is_instr_terminating(last_instr)) {
		llir_emit_jump(proc, b);
	}
	proc->curr_block = b;
	llir_emit_comment(proc, str_lit("defer"));
	if (d.kind == llirDefer_Node) {
		llir_build_stmt(proc, d.stmt);
	} else if (d.kind == llirDefer_Instr) {
		// NOTE(bill): Need to make a new copy
		llirValue *instr = cast(llirValue *)gb_alloc_copy(proc->module->allocator, d.instr, gb_size_of(llirValue));
		llir_emit(proc, instr);
	}
}



llirValue *llir_find_global_variable(llirProcedure *proc, String name) {
	llirValue **value = map_llir_value_get(&proc->module->members, hash_string(name));
	GB_ASSERT_MSG(value != NULL, "Unable to find global variable `%.*s`", LIT(name));
	return *value;
}

llirValue *llir_find_implicit_value_backing(llirProcedure *proc, ImplicitValueId id) {
	Entity *e = proc->module->info->implicit_values[id];
	GB_ASSERT(e->kind == Entity_ImplicitValue);
	Entity *backing = e->ImplicitValue.backing;
	llirValue **value = map_llir_value_get(&proc->module->values, hash_pointer(backing));
	GB_ASSERT_MSG(value != NULL, "Unable to find implicit value backing `%.*s`", LIT(backing->token.string));
	return *value;
}

void llir_build_stmt_list(llirProcedure *proc, AstNodeArray stmts);

llirValue *llir_build_single_expr(llirProcedure *proc, AstNode *expr, TypeAndValue *tv) {
	expr = unparen_expr(expr);
	switch (expr->kind) {
	case_ast_node(bl, BasicLit, expr);
		GB_PANIC("Non-constant basic literal");
	case_end;

	case_ast_node(i, Ident, expr);
		Entity *e = *map_entity_get(&proc->module->info->uses, hash_pointer(expr));
		if (e->kind == Entity_Builtin) {
			Token token = ast_node_token(expr);
			GB_PANIC("TODO(bill): llir_build_single_expr Entity_Builtin `%.*s`\n"
			         "\t at %.*s(%td:%td)", LIT(builtin_procs[e->Builtin.id].name),
			         LIT(token.pos.file), token.pos.line, token.pos.column);
			return NULL;
		} else if (e->kind == Entity_Nil) {
			return llir_make_value_nil(proc->module->allocator, tv->type);
		} else if (e->kind == Entity_ImplicitValue) {
			return llir_emit_load(proc, llir_find_implicit_value_backing(proc, e->ImplicitValue.id));
		}

		llirValue **found = map_llir_value_get(&proc->module->values, hash_pointer(e));
		if (found) {
			llirValue *v = *found;
			if (v->kind == llirValue_Proc) {
				return v;
			}
			// if (e->kind == Entity_Variable && e->Variable.param) {
				// return v;
			// }
			return llir_emit_load(proc, v);
		} else if (e != NULL && e->kind == Entity_Variable) {
			return llir_addr_load(proc, llir_build_addr(proc, expr));
		}
		GB_PANIC("NULL value for expression from identifier: %.*s", LIT(i->string));
		return NULL;
	case_end;

	case_ast_node(re, RunExpr, expr);
		// TODO(bill): Run Expression
		return llir_build_single_expr(proc, re->expr, tv);
	case_end;

	case_ast_node(de, DerefExpr, expr);
		return llir_addr_load(proc, llir_build_addr(proc, expr));
	case_end;

	case_ast_node(se, SelectorExpr, expr);
		TypeAndValue *tav = map_tav_get(&proc->module->info->types, hash_pointer(expr));
		GB_ASSERT(tav != NULL);
		return llir_addr_load(proc, llir_build_addr(proc, expr));
	case_end;

	case_ast_node(be, BlockExpr, expr);
		llir_emit_comment(proc, str_lit("BlockExpr"));
		llir_open_scope(proc);

		AstNodeArray stmts = be->stmts;
		stmts.count--;
		llir_build_stmt_list(proc, stmts);

		AstNode *give_stmt = be->stmts.e[be->stmts.count-1];
		GB_ASSERT(give_stmt->kind == AstNode_ExprStmt);
		AstNode *give_expr = give_stmt->ExprStmt.expr;
		GB_ASSERT(give_expr->kind == AstNode_GiveExpr);
		llirValue *value = llir_build_expr(proc, give_expr);

		llir_close_scope(proc, llirDeferExit_Default, NULL);

		return value;
	case_end;

	case_ast_node(ie, IfExpr, expr);
		llir_emit_comment(proc, str_lit("IfExpr"));
		if (ie->init != NULL) {
			llirBlock *init = llir_add_block(proc, expr, "if.init");
			llir_emit_jump(proc, init);
			proc->curr_block = init;
			llir_build_stmt(proc, ie->init);
		}

		llirValueArray edges = {0};
		array_init_reserve(&edges, proc->module->allocator, 2);

		GB_ASSERT(ie->else_expr != NULL);
		llirBlock *then  = llir_add_block(proc, expr, "if.then");
		llirBlock *done  = llir_add_block(proc, expr, "if.done"); // NOTE(bill): Append later
		llirBlock *else_ = llir_add_block(proc, ie->else_expr, "if.else");

		llirValue *cond = llir_build_cond(proc, ie->cond, then, else_);
		proc->curr_block = then;

		llir_open_scope(proc);
		array_add(&edges, llir_build_expr(proc, ie->body));
		llir_close_scope(proc, llirDeferExit_Default, NULL);

		llir_emit_jump(proc, done);
		proc->curr_block = else_;

		llir_open_scope(proc);
		array_add(&edges, llir_build_expr(proc, ie->else_expr));
		llir_close_scope(proc, llirDeferExit_Default, NULL);

		llir_emit_jump(proc, done);
		proc->curr_block = done;

		Type *type = type_of_expr(proc->module->info, expr);

		return llir_emit(proc, llir_make_instr_phi(proc, edges, type));
	case_end;

	case_ast_node(ge, GiveExpr, expr);
		llir_emit_comment(proc, str_lit("GiveExpr"));

		llirValue *v = NULL;
		Type *give_type = type_of_expr(proc->module->info, expr);
		GB_ASSERT(give_type != NULL);
		if (give_type->kind != Type_Tuple) {
			v = llir_emit_conv(proc, llir_build_expr(proc, ge->results.e[0]), give_type);
		} else {
			TypeTuple *tuple = &give_type->Tuple;
			gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena);

			llirValueArray results;
			array_init_reserve(&results, proc->module->tmp_allocator, tuple->variable_count);

			for_array(res_index, ge->results) {
				llirValue *res = llir_build_expr(proc, ge->results.e[res_index]);
				Type *t = llir_type(res);
				if (t->kind == Type_Tuple) {
					for (isize i = 0; i < t->Tuple.variable_count; i++) {
						Entity *e = t->Tuple.variables[i];
						llirValue *v = llir_emit_struct_ev(proc, res, i);
						array_add(&results, v);
					}
				} else {
					array_add(&results, res);
				}
			}

			v = llir_add_local_generated(proc, give_type);
			for_array(i, results) {
				Entity *e = tuple->variables[i];
				llirValue *res = llir_emit_conv(proc, results.e[i], e->type);
				llirValue *field = llir_emit_struct_ep(proc, v, i);
				llir_emit_store(proc, field, res);
			}
			v = llir_emit_load(proc, v);

			gb_temp_arena_memory_end(tmp);
		}

		return v;
	case_end;

	case_ast_node(ue, UnaryExpr, expr);
		switch (ue->op.kind) {
		case Token_Pointer:
			return llir_emit_ptr_offset(proc, llir_build_addr(proc, ue->expr).addr, v_zero); // Make a copy of the pointer

		case Token_Maybe:
			return llir_emit_conv(proc, llir_build_expr(proc, ue->expr), type_of_expr(proc->module->info, expr));

		case Token_Add:
			return llir_build_expr(proc, ue->expr);

		case Token_Not: // Boolean not
		case Token_Xor: // Bitwise not
		case Token_Sub: // Bitwise not
			return llir_emit(proc, llir_make_instr_unary_op(proc, ue->op.kind, llir_build_expr(proc, ue->expr), tv->type));
		}
	case_end;

	case_ast_node(be, BinaryExpr, expr);
		llirValue *left = llir_build_expr(proc, be->left);
		Type *type = default_type(tv->type);

		switch (be->op.kind) {
		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:
		case Token_Shl:
		case Token_Shr: {
			llirValue *right = llir_build_expr(proc, be->right);
			return llir_emit_arith(proc, be->op.kind, left, right, type);
		}


		case Token_CmpEq:
		case Token_NotEq:
		case Token_Lt:
		case Token_LtEq:
		case Token_Gt:
		case Token_GtEq: {
			llirValue *right = llir_build_expr(proc, be->right);
			llirValue *cmp = llir_emit_comp(proc, be->op.kind, left, right);
			return llir_emit_conv(proc, cmp, type);
		} break;

		case Token_CmpAnd:
		case Token_CmpOr:
			return llir_emit_logical_binary_expr(proc, expr);

		case Token_as:
			llir_emit_comment(proc, str_lit("cast - as"));
			return llir_emit_conv(proc, left, type);

		case Token_transmute:
			llir_emit_comment(proc, str_lit("cast - transmute"));
			return llir_emit_transmute(proc, left, type);

		case Token_down_cast:
			llir_emit_comment(proc, str_lit("cast - down_cast"));
			return llir_emit_down_cast(proc, left, type);

		case Token_union_cast:
			llir_emit_comment(proc, str_lit("cast - union_cast"));
			return llir_emit_union_cast(proc, left, type);

		default:
			GB_PANIC("Invalid binary expression");
			break;
		}
	case_end;

	case_ast_node(pl, ProcLit, expr);
		// 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);
		llirValue *value = llir_make_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;
	case_end;


	case_ast_node(cl, CompoundLit, expr);
		return llir_emit_load(proc, llir_build_addr(proc, expr).addr);
	case_end;


	case_ast_node(ce, CallExpr, expr);
		AstNode *p = unparen_expr(ce->proc);
		if (p->kind == AstNode_Ident) {
			Entity **found = map_entity_get(&proc->module->info->uses, hash_pointer(p));
			if (found && (*found)->kind == Entity_Builtin) {
				Entity *e = *found;
				switch (e->Builtin.id) {
				case BuiltinProc_type_info: {
					Type *t = default_type(type_of_expr(proc->module->info, ce->args.e[0]));
					return llir_type_info(proc, t);
				} break;
				case BuiltinProc_type_info_of_val: {
					Type *t = default_type(type_of_expr(proc->module->info, ce->args.e[0]));
					return llir_type_info(proc, t);
				} break;

				case BuiltinProc_new: {
					llir_emit_comment(proc, str_lit("new"));
					// new :: proc(Type) -> ^Type
					gbAllocator allocator = proc->module->allocator;

					Type *type = type_of_expr(proc->module->info, ce->args.e[0]);
					Type *ptr_type = make_type_pointer(allocator, type);

					i64 s = type_size_of(proc->module->sizes, allocator, type);
					i64 a = type_align_of(proc->module->sizes, allocator, type);

					llirValue **args = gb_alloc_array(allocator, llirValue *, 2);
					args[0] = llir_make_const_int(allocator, s);
					args[1] = llir_make_const_int(allocator, a);
					llirValue *call = llir_emit_global_call(proc, "alloc_align", args, 2);
					llirValue *v = llir_emit_conv(proc, call, ptr_type);
					return v;
				} break;

				case BuiltinProc_new_slice: {
					llir_emit_comment(proc, str_lit("new_slice"));
					// new_slice :: proc(Type, len: int[, cap: int]) -> ^Type
					gbAllocator allocator = proc->module->allocator;

					Type *type = type_of_expr(proc->module->info, ce->args.e[0]);
					Type *ptr_type = make_type_pointer(allocator, type);
					Type *slice_type = make_type_slice(allocator, type);

					i64 s = type_size_of(proc->module->sizes, allocator, type);
					i64 a = type_align_of(proc->module->sizes, allocator, type);

					llirValue *elem_size  = llir_make_const_int(allocator, s);
					llirValue *elem_align = llir_make_const_int(allocator, a);

					llirValue *count = llir_emit_conv(proc, llir_build_expr(proc, ce->args.e[1]), t_int);

					llir_emit_slice_bounds_check(proc, ast_node_token(ce->args.e[1]), v_zero, count, false);

					llirValue *slice_size = llir_emit_arith(proc, Token_Mul, elem_size, count, t_int);

					llirValue **args = gb_alloc_array(allocator, llirValue *, 2);
					args[0] = slice_size;
					args[1] = elem_align;
					llirValue *call = llir_emit_global_call(proc, "alloc_align", args, 2);

					llirValue *ptr = llir_emit_conv(proc, call, ptr_type);
					llirValue *slice = llir_add_local_generated(proc, slice_type);

					llirValue *gep0 = llir_emit_struct_ep(proc, slice, 0);
					llirValue *gep1 = llir_emit_struct_ep(proc, slice, 1);
					llir_emit_store(proc, gep0, ptr);
					llir_emit_store(proc, gep1, count);
					return llir_emit_load(proc, slice);
				} break;

				case BuiltinProc_assert: {
					llir_emit_comment(proc, str_lit("assert"));
					llirValue *cond = llir_build_expr(proc, ce->args.e[0]);
					GB_ASSERT(is_type_boolean(llir_type(cond)));

					cond = llir_emit_comp(proc, Token_CmpEq, cond, v_false);
					llirBlock *err  = llir_add_block(proc, NULL, "builtin.assert.err");
					llirBlock *done = llir_add_block(proc, NULL, "builtin.assert.done");

					llir_emit_if(proc, cond, err, done);
					proc->curr_block = err;

					// TODO(bill): Cleanup allocations here
					Token token = ast_node_token(ce->args.e[0]);
					TokenPos pos = token.pos;
					gbString expr = expr_to_string(ce->args.e[0]);
					isize expr_len = gb_string_length(expr);
					String expr_str = {0};
					expr_str.text = cast(u8 *)gb_alloc_copy_align(proc->module->allocator, expr, expr_len, 1);
					expr_str.len = expr_len;
					gb_string_free(expr);


					llirValue **args = gb_alloc_array(proc->module->allocator, llirValue *, 4);
					args[0] = llir_make_const_string(proc->module->allocator, pos.file);
					args[1] = llir_make_const_int(proc->module->allocator, pos.line);
					args[2] = llir_make_const_int(proc->module->allocator, pos.column);
					args[3] = llir_make_const_string(proc->module->allocator, expr_str);
					llir_emit_global_call(proc, "__assert", args, 4);

					llir_emit_jump(proc, done);
					proc->curr_block = done;

					return NULL;
				} break;

				case BuiltinProc_panic: {
					llir_emit_comment(proc, str_lit("panic"));
					llirValue *msg = llir_build_expr(proc, ce->args.e[0]);
					GB_ASSERT(is_type_string(llir_type(msg)));

					Token token = ast_node_token(ce->args.e[0]);
					TokenPos pos = token.pos;

					llirValue **args = gb_alloc_array(proc->module->allocator, llirValue *, 4);
					args[0] = llir_make_const_string(proc->module->allocator, pos.file);
					args[1] = llir_make_const_int(proc->module->allocator, pos.line);
					args[2] = llir_make_const_int(proc->module->allocator, pos.column);
					args[3] = msg;
					llir_emit_global_call(proc, "__assert", args, 4);

					return NULL;
				} break;


				case BuiltinProc_copy: {
					llir_emit_comment(proc, str_lit("copy"));
					// copy :: proc(dst, src: []Type) -> int
					AstNode *dst_node = ce->args.e[0];
					AstNode *src_node = ce->args.e[1];
					llirValue *dst_slice = llir_build_expr(proc, dst_node);
					llirValue *src_slice = llir_build_expr(proc, src_node);
					Type *slice_type = base_type(llir_type(dst_slice));
					GB_ASSERT(slice_type->kind == Type_Slice);
					Type *elem_type = slice_type->Slice.elem;
					i64 size_of_elem = type_size_of(proc->module->sizes, proc->module->allocator, elem_type);

					llirValue *dst = llir_emit_conv(proc, llir_slice_elem(proc, dst_slice), t_rawptr);
					llirValue *src = llir_emit_conv(proc, llir_slice_elem(proc, src_slice), t_rawptr);

					llirValue *len_dst = llir_slice_len(proc, dst_slice);
					llirValue *len_src = llir_slice_len(proc, src_slice);

					llirValue *cond = llir_emit_comp(proc, Token_Lt, len_dst, len_src);
					llirValue *len = llir_emit_select(proc, cond, len_dst, len_src);

					llirValue *elem_size = llir_make_const_int(proc->module->allocator, size_of_elem);
					llirValue *byte_count = llir_emit_arith(proc, Token_Mul, len, elem_size, t_int);

					llirValue **args = gb_alloc_array(proc->module->allocator, llirValue *, 3);
					args[0] = dst;
					args[1] = src;
					args[2] = byte_count;

					llir_emit_global_call(proc, "__mem_copy", args, 3);

					return len;
				} break;
				#if 0
				case BuiltinProc_append: {
					llir_emit_comment(proc, str_lit("append"));
					// append :: proc(s: ^[]Type, item: Type) -> bool
					AstNode *sptr_node = ce->args.e[0];
					AstNode *item_node = ce->args.e[1];
					llirValue *slice_ptr = llir_build_expr(proc, sptr_node);
					llirValue *slice = llir_emit_load(proc, slice_ptr);

					llirValue *elem = llir_slice_elem(proc, slice);
					llirValue *len  = llir_slice_len(proc,  slice);
					llirValue *cap  = llir_slice_cap(proc,  slice);

					Type *elem_type = type_deref(llir_type(elem));

					llirValue *item_value = llir_build_expr(proc, item_node);
					item_value = llir_emit_conv(proc, item_value, elem_type);

					llirValue *item = llir_add_local_generated(proc, elem_type);
					llir_emit_store(proc, item, item_value);


					// NOTE(bill): Check if can append is possible
					llirValue *cond = llir_emit_comp(proc, Token_Lt, len, cap);
					llirBlock *able = llir_add_block(proc, NULL, "builtin.append.able");
					llirBlock *done = llir_add_block(proc, NULL, "builtin.append.done");

					llir_emit_if(proc, cond, able, done);
					proc->curr_block = able;

					// Add new slice item
					i64 item_size = type_size_of(proc->module->sizes, proc->module->allocator, elem_type);
					llirValue *byte_count = llir_make_const_int(proc->module->allocator, item_size);

					llirValue *offset = llir_emit_ptr_offset(proc, elem, len);
					offset = llir_emit_conv(proc, offset, t_rawptr);

					item = llir_emit_ptr_offset(proc, item, v_zero);
					item = llir_emit_conv(proc, item, t_rawptr);

					llirValue **args = gb_alloc_array(proc->module->allocator, llirValue *, 3);
					args[0] = offset;
					args[1] = item;
					args[2] = byte_count;

					llir_emit_global_call(proc, "__mem_copy", args, 3);

					// Increment slice length
					llirValue *new_len = llir_emit_arith(proc, Token_Add, len, v_one, t_int);
					llirValue *gep = llir_emit_struct_ep(proc, slice_ptr, 1);
					llir_emit_store(proc, gep, new_len);

					llir_emit_jump(proc, done);
					proc->curr_block = done;

					return llir_emit_conv(proc, cond, t_bool);
				} break;
				#endif

				case BuiltinProc_swizzle: {
					llir_emit_comment(proc, str_lit("swizzle"));
					llirValue *vector = llir_build_expr(proc, ce->args.e[0]);
					isize index_count = ce->args.count-1;
					if (index_count == 0) {
						return vector;
					}

					i32 *indices = gb_alloc_array(proc->module->allocator, i32, index_count);
					isize index = 0;
					for_array(i, ce->args) {
						if (i == 0) continue;
						TypeAndValue *tv = type_and_value_of_expression(proc->module->info, ce->args.e[i]);
						GB_ASSERT(is_type_integer(tv->type));
						GB_ASSERT(tv->value.kind == ExactValue_Integer);
						indices[index++] = cast(i32)tv->value.value_integer;
					}

					return llir_emit(proc, llir_make_instr_vector_shuffle(proc, vector, indices, index_count));

				} break;

				case BuiltinProc_slice_ptr: {
					llir_emit_comment(proc, str_lit("slice_ptr"));
					llirValue *ptr = llir_build_expr(proc, ce->args.e[0]);
					llirValue *count = llir_build_expr(proc, ce->args.e[1]);
					count = llir_emit_conv(proc, count, t_int);

					Type *slice_type = make_type_slice(proc->module->allocator, type_deref(llir_type(ptr)));
					llirValue *slice = llir_add_local_generated(proc, slice_type);
					llir_emit_store(proc, llir_emit_struct_ep(proc, slice, 0), ptr);
					llir_emit_store(proc, llir_emit_struct_ep(proc, slice, 1), count);
					return llir_emit_load(proc, slice);
				} break;

				case BuiltinProc_min: {
					llir_emit_comment(proc, str_lit("min"));
					Type *t = type_of_expr(proc->module->info, expr);
					llirValue *x = llir_emit_conv(proc, llir_build_expr(proc, ce->args.e[0]), t);
					llirValue *y = llir_emit_conv(proc, llir_build_expr(proc, ce->args.e[1]), t);
					llirValue *cond = llir_emit_comp(proc, Token_Lt, x, y);
					return llir_emit_select(proc, cond, x, y);
				} break;

				case BuiltinProc_max: {
					llir_emit_comment(proc, str_lit("max"));
					Type *t = type_of_expr(proc->module->info, expr);
					llirValue *x = llir_emit_conv(proc, llir_build_expr(proc, ce->args.e[0]), t);
					llirValue *y = llir_emit_conv(proc, llir_build_expr(proc, ce->args.e[1]), t);
					llirValue *cond = llir_emit_comp(proc, Token_Gt, x, y);
					return llir_emit_select(proc, cond, x, y);
				} break;

				case BuiltinProc_abs: {
					llir_emit_comment(proc, str_lit("abs"));
					gbAllocator a = proc->module->allocator;

					llirValue *x = llir_build_expr(proc, ce->args.e[0]);
					Type *original_type = llir_type(x);
					Type *t = original_type;
					i64 sz = type_size_of(proc->module->sizes, a, t);
					GB_ASSERT(is_type_integer(t) || is_type_float(t));
					if (is_type_float(t)) {
						if (sz == 4) {
							t = t_i32;
						} else if (sz == 8) {
							t = t_i64;
						} else {
							GB_PANIC("unknown float type for `abs`");
						}

						x = llir_emit_bitcast(proc, x, t);
					}

					/*
						NOTE(bill): See Hacker's Delight, section 2-4.
						m := x >> (int_size-1)
						b := x ^ m
						return b - m
					*/

					llirValue *m = llir_emit_arith(proc, Token_Shr,
					                             x,
					                             llir_make_value_constant(a, t, make_exact_value_integer(sz-1)),
					                             t);
					llirValue *b = llir_emit_arith(proc, Token_Xor, x, m, t);
					llirValue *v = llir_emit_arith(proc, Token_Sub, b, m, t);

					if (is_type_float(t)) {
						v = llir_emit_bitcast(proc, v, original_type);
					}
					return v;
				} break;

				case BuiltinProc_clamp: {
					llir_emit_comment(proc, str_lit("clamp"));
					Type *t = type_of_expr(proc->module->info, expr);
					llirValue *x   = llir_emit_conv(proc, llir_build_expr(proc, ce->args.e[0]), t);
					llirValue *min = llir_emit_conv(proc, llir_build_expr(proc, ce->args.e[1]), t);
					llirValue *max = llir_emit_conv(proc, llir_build_expr(proc, ce->args.e[2]), t);
					llirValue *cond;
					cond = llir_emit_comp(proc, Token_Gt, min, x);
					x    = llir_emit_select(proc, cond,   min, x);
					cond = llir_emit_comp(proc, Token_Lt, max, x);
					x    = llir_emit_select(proc, cond,   max, x);
					return x;
				} break;
				}
			}
		}

		// NOTE(bill): Regular call
		llirValue *value = llir_build_expr(proc, ce->proc);
		GB_ASSERT(value != NULL);
		Type *proc_type_ = base_type(llir_type(value));
		GB_ASSERT(proc_type_->kind == Type_Proc);
		TypeProc *type = &proc_type_->Proc;

		isize arg_index = 0;

		isize arg_count = 0;
		for_array(i, ce->args) {
			AstNode *a = ce->args.e[i];
			Type *at = base_type(type_of_expr(proc->module->info, a));
			if (at->kind == Type_Tuple) {
				arg_count += at->Tuple.variable_count;
			} else {
				arg_count++;
			}
		}
		llirValue **args = gb_alloc_array(proc->module->allocator, llirValue *, arg_count);
		bool variadic = proc_type_->Proc.variadic;
		bool vari_expand = ce->ellipsis.pos.line != 0;

		for_array(i, ce->args) {
			llirValue *a = llir_build_expr(proc, ce->args.e[i]);
			Type *at = llir_type(a);
			if (at->kind == Type_Tuple) {
				for (isize i = 0; i < at->Tuple.variable_count; i++) {
					Entity *e = at->Tuple.variables[i];
					llirValue *v = llir_emit_struct_ev(proc, a, i);
					args[arg_index++] = v;
				}
			} else {
				args[arg_index++] = a;
			}
		}

		TypeTuple *pt = &type->params->Tuple;

		if (variadic) {
			isize i = 0;
			for (; i < type->param_count-1; i++) {
				args[i] = llir_emit_conv(proc, args[i], pt->variables[i]->type);
			}
			if (!vari_expand) {
				Type *variadic_type = pt->variables[i]->type;
				GB_ASSERT(is_type_slice(variadic_type));
				variadic_type = base_type(variadic_type)->Slice.elem;
				for (; i < arg_count; i++) {
					args[i] = llir_emit_conv(proc, args[i], variadic_type);
				}
			}
		} else {
			for (isize i = 0; i < arg_count; i++) {
				args[i] = llir_emit_conv(proc, args[i], pt->variables[i]->type);
			}
		}

		if (variadic && !vari_expand) {
			llir_emit_comment(proc, str_lit("variadic call argument generation"));
			gbAllocator allocator = proc->module->allocator;
			Type *slice_type = pt->variables[type->param_count-1]->type;
			Type *elem_type  = base_type(slice_type)->Slice.elem;
			llirValue *slice = llir_add_local_generated(proc, slice_type);
			isize slice_len = arg_count+1 - type->param_count;

			if (slice_len > 0) {
				llirValue *base_array = llir_add_local_generated(proc, make_type_array(allocator, elem_type, slice_len));

				for (isize i = type->param_count-1, j = 0; i < arg_count; i++, j++) {
					llirValue *addr = llir_emit_array_epi(proc, base_array, j);
					llir_emit_store(proc, addr, args[i]);
				}

				llirValue *base_elem  = llir_emit_array_epi(proc, base_array, 0);
				llirValue *slice_elem = llir_emit_struct_ep(proc, slice,      0);
				llir_emit_store(proc, slice_elem, base_elem);
				llirValue *len = llir_make_const_int(allocator, slice_len);
				llir_emit_store(proc, llir_emit_struct_ep(proc, slice, 1), len);
				llir_emit_store(proc, llir_emit_struct_ep(proc, slice, 2), len);
			}

			arg_count = type->param_count;
			args[arg_count-1] = llir_emit_load(proc, slice);
		}

		return llir_emit_call(proc, value, args, arg_count);
	case_end;

	case_ast_node(de, DemaybeExpr, expr);
		return llir_emit_load(proc, llir_build_addr(proc, expr).addr);
	case_end;

	case_ast_node(se, SliceExpr, expr);
		return llir_emit_load(proc, llir_build_addr(proc, expr).addr);
	case_end;

	case_ast_node(ie, IndexExpr, expr);
		return llir_emit_load(proc, llir_build_addr(proc, expr).addr);
	case_end;
	}

	GB_PANIC("Unexpected expression: %.*s", LIT(ast_node_strings[expr->kind]));
	return NULL;
}


llirValue *llir_build_expr(llirProcedure *proc, AstNode *expr) {
	expr = unparen_expr(expr);

	TypeAndValue *tv = map_tav_get(&proc->module->info->types, hash_pointer(expr));
	GB_ASSERT_NOT_NULL(tv);

	if (tv->value.kind != ExactValue_Invalid) {
		return llir_add_module_constant(proc->module, tv->type, tv->value);
	}

	llirValue *value = NULL;
	if (tv->mode == Addressing_Variable) {
		value = llir_addr_load(proc, llir_build_addr(proc, expr));
	} else {
		value = llir_build_single_expr(proc, expr, tv);
	}

	return value;
}

llirValue *llir_add_using_variable(llirProcedure *proc, Entity *e) {
	GB_ASSERT(e->kind == Entity_Variable && e->flags & EntityFlag_Anonymous);
	String name = e->token.string;
	Entity *parent = e->using_parent;
	Selection sel = lookup_field(proc->module->allocator, parent->type, name, false);
	GB_ASSERT(sel.entity != NULL);
	llirValue **pv = map_llir_value_get(&proc->module->values, hash_pointer(parent));
	llirValue *v = NULL;
	if (pv != NULL) {
		v = *pv;
	} else {
		v = llir_build_addr(proc, e->using_expr).addr;
	}
	GB_ASSERT(v != NULL);
	llirValue *var = llir_emit_deep_field_gep(proc, parent->type, v, sel);
	map_llir_value_set(&proc->module->values, hash_pointer(e), var);
	return var;
}

bool llir_is_elem_const(llirModule *m, AstNode *elem, Type *elem_type) {
	if (base_type(elem_type) == t_any) {
		return false;
	}
	if (elem->kind == AstNode_FieldValue) {
		elem = elem->FieldValue.value;
	}
	TypeAndValue *tav = type_and_value_of_expression(m->info, elem);
	GB_ASSERT(tav != NULL);
	return tav->value.kind != ExactValue_Invalid;
}

llirAddr llir_build_addr_from_entity(llirProcedure *proc, Entity *e, AstNode *expr) {
	GB_ASSERT(e != NULL);
	GB_ASSERT(e->kind != Entity_Constant);

	llirValue *v = NULL;
	llirValue **found = map_llir_value_get(&proc->module->values, hash_pointer(e));
	if (found) {
		v = *found;
	} else if (e->kind == Entity_Variable && e->flags & EntityFlag_Anonymous) {
		v = llir_add_using_variable(proc, e);
	} else if (e->kind == Entity_ImplicitValue) {
		// TODO(bill): Should a copy be made?
		v = llir_find_implicit_value_backing(proc, e->ImplicitValue.id);
	}

	if (v == NULL) {
		GB_PANIC("Unknown value: %.*s, entity: %p %.*s\n", LIT(e->token.string), e, LIT(entity_strings[e->kind]));
	}

	return llir_make_addr(v, expr);
}

llirAddr llir_build_addr(llirProcedure *proc, AstNode *expr) {
	switch (expr->kind) {
	case_ast_node(i, Ident, expr);
		if (llir_is_blank_ident(expr)) {
			llirAddr val = {0};
			return val;
		}

		Entity *e = entity_of_ident(proc->module->info, expr);
		return llir_build_addr_from_entity(proc, e, expr);
	case_end;

	case_ast_node(pe, ParenExpr, expr);
		return llir_build_addr(proc, unparen_expr(expr));
	case_end;

	case_ast_node(se, SelectorExpr, expr);
		llir_emit_comment(proc, str_lit("SelectorExpr"));
		AstNode *sel = unparen_expr(se->selector);
		GB_ASSERT(sel->kind == AstNode_Ident);
		String selector = sel->Ident.string;
		Type *type = base_type(type_of_expr(proc->module->info, se->expr));

		if (type == t_invalid) {
			// NOTE(bill): Imports
			Entity *imp = entity_of_ident(proc->module->info, se->expr);
			if (imp != NULL) {
				GB_ASSERT(imp->kind == Entity_ImportName);
			}
			return llir_build_addr(proc, unparen_expr(se->selector));
		} else {
			Selection sel = lookup_field(proc->module->allocator, type, selector, false);
			GB_ASSERT(sel.entity != NULL);

			llirValue *a = llir_build_addr(proc, se->expr).addr;
			a = llir_emit_deep_field_gep(proc, type, a, sel);
			return llir_make_addr(a, expr);
		}
	case_end;

	case_ast_node(ue, UnaryExpr, expr);
		switch (ue->op.kind) {
		case Token_Pointer: {
			return llir_build_addr(proc, ue->expr);
		}
		default:
			GB_PANIC("Invalid unary expression for llir_build_addr");
		}
	case_end;

	case_ast_node(be, BinaryExpr, expr);
		switch (be->op.kind) {
		case Token_as: {
			llir_emit_comment(proc, str_lit("Cast - as"));
			// NOTE(bill): Needed for dereference of pointer conversion
			Type *type = type_of_expr(proc->module->info, expr);
			llirValue *v = llir_add_local_generated(proc, type);
			llir_emit_store(proc, v, llir_emit_conv(proc, llir_build_expr(proc, be->left), type));
			return llir_make_addr(v, expr);
		}
		case Token_transmute: {
			llir_emit_comment(proc, str_lit("Cast - transmute"));
			// NOTE(bill): Needed for dereference of pointer conversion
			Type *type = type_of_expr(proc->module->info, expr);
			llirValue *v = llir_add_local_generated(proc, type);
			llir_emit_store(proc, v, llir_emit_transmute(proc, llir_build_expr(proc, be->left), type));
			return llir_make_addr(v, expr);
		}
		default:
			GB_PANIC("Invalid binary expression for llir_build_addr: %.*s\n", LIT(be->op.string));
			break;
		}
	case_end;

	case_ast_node(ie, IndexExpr, expr);
		llir_emit_comment(proc, str_lit("IndexExpr"));
		Type *t = base_type(type_of_expr(proc->module->info, ie->expr));
		gbAllocator a = proc->module->allocator;


		bool deref = is_type_pointer(t);
		t = type_deref(t);

		llirValue *using_addr = NULL;
		if (!is_type_indexable(t)) {
			// Using index expression
			Entity *using_field = find_using_index_expr(t);
			if (using_field != NULL) {
				Selection sel = lookup_field(a, t, using_field->token.string, false);
				llirValue *e = llir_build_addr(proc, ie->expr).addr;
				using_addr = llir_emit_deep_field_gep(proc, t, e, sel);

				t = using_field->type;
			}
		}


		switch (t->kind) {
		case Type_Vector: {
			llirValue *vector = NULL;
			if (using_addr != NULL) {
				vector = using_addr;
			} else {
				vector = llir_build_addr(proc, ie->expr).addr;
				if (deref) {
					vector = llir_emit_load(proc, vector);
				}
			}
			llirValue *index = llir_emit_conv(proc, llir_build_expr(proc, ie->index), t_int);
			llirValue *len = llir_make_const_int(a, t->Vector.count);
			llir_emit_bounds_check(proc, ast_node_token(ie->index), index, len);
			return llir_make_addr_vector(vector, index, expr);
		} break;

		case Type_Array: {
			llirValue *array = NULL;
			if (using_addr != NULL) {
				array = using_addr;
			} else {
				array = llir_build_addr(proc, ie->expr).addr;
				if (deref) {
					array = llir_emit_load(proc, array);
				}
			}
			llirValue *index = llir_emit_conv(proc, llir_build_expr(proc, ie->index), t_int);
			llirValue *elem = llir_emit_array_ep(proc, array, index);
			llirValue *len = llir_make_const_int(a, t->Vector.count);
			llir_emit_bounds_check(proc, ast_node_token(ie->index), index, len);
			return llir_make_addr(elem, expr);
		} break;

		case Type_Slice: {
			llirValue *slice = NULL;
			if (using_addr != NULL) {
				slice = llir_emit_load(proc, using_addr);
			} else {
				slice = llir_build_expr(proc, ie->expr);
				if (deref) {
					slice = llir_emit_load(proc, slice);
				}
			}
			llirValue *elem = llir_slice_elem(proc, slice);
			llirValue *len = llir_slice_len(proc, slice);
			llirValue *index = llir_emit_conv(proc, llir_build_expr(proc, ie->index), t_int);
			llir_emit_bounds_check(proc, ast_node_token(ie->index), index, len);
			llirValue *v = llir_emit_ptr_offset(proc, elem, index);
			return llir_make_addr(v, expr);

		} break;

		case Type_Basic: { // Basic_string
			TypeAndValue *tv = map_tav_get(&proc->module->info->types, hash_pointer(ie->expr));
			llirValue *str;
			llirValue *elem;
			llirValue *len;
			llirValue *index;

			if (using_addr != NULL) {
				str = llir_emit_load(proc, using_addr);
			} else {
				str = llir_build_expr(proc, ie->expr);
				if (deref) {
					str = llir_emit_load(proc, str);
				}
			}
			elem = llir_string_elem(proc, str);
			len = llir_string_len(proc, str);

			index = llir_emit_conv(proc, llir_build_expr(proc, ie->index), t_int);
			llir_emit_bounds_check(proc, ast_node_token(ie->index), index, len);

			return llir_make_addr(llir_emit_ptr_offset(proc, elem, index), expr);
		} break;
		}
	case_end;

	case_ast_node(se, SliceExpr, expr);
		llir_emit_comment(proc, str_lit("SliceExpr"));
		gbAllocator a = proc->module->allocator;
		llirValue *low  = v_zero;
		llirValue *high = NULL;

		if (se->low  != NULL)    low  = llir_build_expr(proc, se->low);
		if (se->high != NULL)    high = llir_build_expr(proc, se->high);
		llirValue *addr = llir_build_addr(proc, se->expr).addr;
		llirValue *base = llir_emit_load(proc, addr);
		Type *type = base_type(llir_type(base));

		if (is_type_pointer(type)) {
			type = type_deref(type);
			addr = base;
			base = llir_emit_load(proc, base);
		}

		// TODO(bill): Cleanup like mad!

		switch (type->kind) {
		case Type_Slice: {
			Type *slice_type = type;

			if (high == NULL) high = llir_slice_len(proc, base);

			llir_emit_slice_bounds_check(proc, se->open, low, high, false);

			llirValue *elem  = llir_emit_ptr_offset(proc, llir_slice_elem(proc, base), low);
			llirValue *len   = llir_emit_arith(proc, Token_Sub, high, low, t_int);
			llirValue *slice = llir_add_local_generated(proc, slice_type);

			llirValue *gep0 = llir_emit_struct_ep(proc, slice, 0);
			llirValue *gep1 = llir_emit_struct_ep(proc, slice, 1);
			llir_emit_store(proc, gep0, elem);
			llir_emit_store(proc, gep1, len);

			return llir_make_addr(slice, expr);
		}

		case Type_Array: {
			Type *slice_type = make_type_slice(a, type->Array.elem);

			if (high == NULL) high = llir_array_len(proc, base);

			llir_emit_slice_bounds_check(proc, se->open, low, high, false);

			llirValue *elem = llir_emit_ptr_offset(proc, llir_array_elem(proc, addr), low);
			llirValue *len  = llir_emit_arith(proc, Token_Sub, high, low, t_int);
			llirValue *slice = llir_add_local_generated(proc, slice_type);

			llirValue *gep0 = llir_emit_struct_ep(proc, slice, 0);
			llirValue *gep1 = llir_emit_struct_ep(proc, slice, 1);
			llir_emit_store(proc, gep0, elem);
			llir_emit_store(proc, gep1, len);

			return llir_make_addr(slice, expr);
		}

		case Type_Basic: {
			GB_ASSERT(type == t_string);
			if (high == NULL) {
				high = llir_string_len(proc, base);
			}

			llir_emit_slice_bounds_check(proc, se->open, low, high, true);

			llirValue *elem, *len;
			len = llir_emit_arith(proc, Token_Sub, high, low, t_int);

			elem = llir_string_elem(proc, base);
			elem = llir_emit_ptr_offset(proc, elem, low);

			llirValue *str = llir_add_local_generated(proc, t_string);
			llirValue *gep0 = llir_emit_struct_ep(proc, str, 0);
			llirValue *gep1 = llir_emit_struct_ep(proc, str, 1);
			llir_emit_store(proc, gep0, elem);
			llir_emit_store(proc, gep1, len);

			return llir_make_addr(str, expr);
		} break;
		}

		GB_PANIC("Unknown slicable type");
	case_end;

	case_ast_node(de, DerefExpr, expr);
		// TODO(bill): Is a ptr copy needed?
		llirValue *addr = llir_build_expr(proc, de->expr);
		addr = llir_emit_ptr_offset(proc, addr, v_zero);
		return llir_make_addr(addr, expr);
	case_end;

	case_ast_node(de, DemaybeExpr, expr);
		llir_emit_comment(proc, str_lit("DemaybeExpr"));
		llirValue *maybe = llir_build_expr(proc, de->expr);
		Type *t = default_type(type_of_expr(proc->module->info, expr));
		GB_ASSERT(is_type_tuple(t));

		llirValue *result = llir_add_local_generated(proc, t);
		llir_emit_store(proc, result, maybe);

		return llir_make_addr(result, expr);
	case_end;

	case_ast_node(ce, CallExpr, expr);
		llirValue *e = llir_build_expr(proc, expr);
		llirValue *v = llir_add_local_generated(proc, llir_type(e));
		llir_emit_store(proc, v, e);
		return llir_make_addr(v, expr);
	case_end;


	case_ast_node(cl, CompoundLit, expr);
		llir_emit_comment(proc, str_lit("CompoundLit"));
		Type *type = type_of_expr(proc->module->info, expr);
		Type *bt = base_type(type);
		llirValue *v = llir_add_local_generated(proc, type);

		Type *et = NULL;
		switch (bt->kind) {
		case Type_Vector: et = bt->Vector.elem; break;
		case Type_Array:  et = bt->Array.elem;  break;
		case Type_Slice:  et = bt->Slice.elem;  break;
		}

		switch (bt->kind) {
		default: GB_PANIC("Unknown CompoundLit type: %s", type_to_string(type)); break;

		case Type_Vector: {
			llirValue *result = llir_add_module_constant(proc->module, type, make_exact_value_compound(expr));
			for_array(index, cl->elems) {
				AstNode *elem = cl->elems.e[index];
				if (llir_is_elem_const(proc->module, elem, et)) {
					continue;
				}
				llirValue *field_elem = llir_build_expr(proc, elem);
				Type *t = llir_type(field_elem);
				GB_ASSERT(t->kind != Type_Tuple);
				llirValue *ev = llir_emit_conv(proc, field_elem, et);
				llirValue *i = llir_make_const_int(proc->module->allocator, index);
				result = llir_emit(proc, llir_make_instr_insert_element(proc, result, ev, i));
			}

			if (cl->elems.count == 1 && bt->Vector.count > 1) {
				isize index_count = bt->Vector.count;
				i32 *indices = gb_alloc_array(proc->module->allocator, i32, index_count);
				for (isize i = 0; i < index_count; i++) {
					indices[i] = 0;
				}
				llirValue *sv = llir_emit(proc, llir_make_instr_vector_shuffle(proc, result, indices, index_count));
				llir_emit_store(proc, v, sv);
				return llir_make_addr(v, expr);
			}
			llir_emit_store(proc, v, result);
		} break;

		case Type_Record: {
			GB_ASSERT(is_type_struct(bt));
			TypeRecord *st = &bt->Record;
			if (cl->elems.count > 0) {
				llir_emit_store(proc, v, llir_add_module_constant(proc->module, type, make_exact_value_compound(expr)));
				for_array(field_index, cl->elems) {
					AstNode *elem = cl->elems.e[field_index];

					llirValue *field_expr = NULL;
					Entity *field = NULL;
					isize index = field_index;

					if (elem->kind == AstNode_FieldValue) {
						ast_node(fv, FieldValue, elem);
						Selection sel = lookup_field(proc->module->allocator, bt, fv->field->Ident.string, false);
						index = sel.index.e[0];
						elem = fv->value;
					} else {
						TypeAndValue *tav = type_and_value_of_expression(proc->module->info, elem);
						Selection sel = lookup_field(proc->module->allocator, bt, st->fields_in_src_order[field_index]->token.string, false);
						index = sel.index.e[0];
					}

					field = st->fields[index];
					if (llir_is_elem_const(proc->module, elem, field->type)) {
						continue;
					}

					field_expr = llir_build_expr(proc, elem);

					GB_ASSERT(llir_type(field_expr)->kind != Type_Tuple);

					Type *ft = field->type;
					llirValue *fv = llir_emit_conv(proc, field_expr, ft);
					llirValue *gep = llir_emit_struct_ep(proc, v, index);
					llir_emit_store(proc, gep, fv);
				}
			}
		} break;
		case Type_Array: {
			if (cl->elems.count > 0) {
				llir_emit_store(proc, v, llir_add_module_constant(proc->module, type, make_exact_value_compound(expr)));
				for_array(i, cl->elems) {
					AstNode *elem = cl->elems.e[i];
					if (llir_is_elem_const(proc->module, elem, et)) {
						continue;
					}
					llirValue *field_expr = llir_build_expr(proc, elem);
					Type *t = llir_type(field_expr);
					GB_ASSERT(t->kind != Type_Tuple);
					llirValue *ev = llir_emit_conv(proc, field_expr, et);
					llirValue *gep = llir_emit_array_epi(proc, v, i);
					llir_emit_store(proc, gep, ev);
				}
			}
		} break;
		case Type_Slice: {
			if (cl->elems.count > 0) {
				Type *elem_type = bt->Slice.elem;
				Type *elem_ptr_type = make_type_pointer(proc->module->allocator, elem_type);
				Type *elem_ptr_ptr_type = make_type_pointer(proc->module->allocator, elem_ptr_type);
				llirValue *slice = llir_add_module_constant(proc->module, type, make_exact_value_compound(expr));
				GB_ASSERT(slice->kind == llirValue_ConstantSlice);

				llirValue *data = llir_emit_array_ep(proc, slice->ConstantSlice.backing_array, v_zero32);

				for_array(i, cl->elems) {
					AstNode *elem = cl->elems.e[i];
					if (llir_is_elem_const(proc->module, elem, et)) {
						continue;
					}

					llirValue *field_expr = llir_build_expr(proc, elem);
					Type *t = llir_type(field_expr);
					GB_ASSERT(t->kind != Type_Tuple);
					llirValue *ev = llir_emit_conv(proc, field_expr, elem_type);
					llirValue *offset = llir_emit_ptr_offset(proc, data, llir_make_const_int(proc->module->allocator, i));
					llir_emit_store(proc, offset, ev);
				}

				llirValue *gep0 = llir_emit_struct_ep(proc, v, 0);
				llirValue *gep1 = llir_emit_struct_ep(proc, v, 1);
				llirValue *gep2 = llir_emit_struct_ep(proc, v, 1);

				llir_emit_store(proc, gep0, data);
				llir_emit_store(proc, gep1, llir_make_const_int(proc->module->allocator, slice->ConstantSlice.count));
				llir_emit_store(proc, gep2, llir_make_const_int(proc->module->allocator, slice->ConstantSlice.count));
			}
		} break;
		}

		return llir_make_addr(v, expr);
	case_end;


	}

	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 llir_make_addr(NULL, NULL);
}

void llir_build_assign_op(llirProcedure *proc, llirAddr lhs, llirValue *value, TokenKind op) {
	llirValue *old_value = llir_addr_load(proc, lhs);
	Type *type = llir_type(old_value);

	llirValue *change = value;
	if (is_type_pointer(type) && is_type_integer(llir_type(value))) {
		change = llir_emit_conv(proc, value, default_type(llir_type(value)));
	} else {
		change = llir_emit_conv(proc, value, type);
	}
	llirValue *new_value = llir_emit_arith(proc, op, old_value, change, type);
	llir_addr_store(proc, lhs, new_value);
}

llirValue *llir_build_cond(llirProcedure *proc, AstNode *cond, llirBlock *true_block, llirBlock *false_block) {
	switch (cond->kind) {
	case_ast_node(pe, ParenExpr, cond);
		return llir_build_cond(proc, pe->expr, true_block, false_block);
	case_end;

	case_ast_node(ue, UnaryExpr, cond);
		if (ue->op.kind == Token_Not) {
			return llir_build_cond(proc, ue->expr, false_block, true_block);
		}
	case_end;

	case_ast_node(be, BinaryExpr, cond);
		if (be->op.kind == Token_CmpAnd) {
			llirBlock *block = llir_add_block(proc, NULL, "cmp.and");
			llir_build_cond(proc, be->left, block, false_block);
			proc->curr_block = block;
			return llir_build_cond(proc, be->right, true_block, false_block);
		} else if (be->op.kind == Token_CmpOr) {
			llirBlock *block = llir_add_block(proc, NULL, "cmp.or");
			llir_build_cond(proc, be->left, true_block, block);
			proc->curr_block = block;
			return llir_build_cond(proc, be->right, true_block, false_block);
		}
	case_end;
	}

	llirValue *v = llir_build_expr(proc, cond);
	v = llir_emit_conv(proc, v, t_bool);
	llir_emit_if(proc, v, true_block, false_block);
	return v;
}




void llir_build_stmt_list(llirProcedure *proc, AstNodeArray stmts) {
	for_array(i, stmts) {
		llir_build_stmt(proc, stmts.e[i]);
	}
}

void llir_build_stmt_internal(llirProcedure *proc, AstNode *node);
void llir_build_stmt(llirProcedure *proc, AstNode *node) {
	u32 prev_stmt_state_flags = proc->module->stmt_state_flags;

	if (node->stmt_state_flags != 0) {
		u32 in = node->stmt_state_flags;
		u32 out = proc->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;
		}

		proc->module->stmt_state_flags = out;
	}

	llir_build_stmt_internal(proc, node);

	proc->module->stmt_state_flags = prev_stmt_state_flags;
}

void llir_build_when_stmt(llirProcedure *proc, AstNodeWhenStmt *ws) {
	llirValue *cond = llir_build_expr(proc, ws->cond);
	GB_ASSERT(cond->kind == llirValue_Constant &&
	          is_type_boolean(llir_type(cond)));

	GB_ASSERT(cond->Constant.value.kind == ExactValue_Bool);
	if (cond->Constant.value.value_bool) {
		llir_build_stmt_list(proc, ws->body->BlockStmt.stmts);
	} else if (ws->else_stmt) {
		switch (ws->else_stmt->kind) {
		case AstNode_BlockStmt:
			llir_build_stmt_list(proc, ws->else_stmt->BlockStmt.stmts);
			break;
		case AstNode_WhenStmt:
			llir_build_when_stmt(proc, &ws->else_stmt->WhenStmt);
			break;
		default:
			GB_PANIC("Invalid `else` statement in `when` statement");
			break;
		}
	}
}

void llir_emit_increment(llirProcedure *proc, llirValue *addr) {
	GB_ASSERT(is_type_pointer(llir_type(addr)));
	Type *type = type_deref(llir_type(addr));
	llir_emit_store(proc, addr, llir_emit_arith(proc, Token_Add, llir_emit_load(proc, addr), v_one, type));

}

void llir_build_range_indexed(llirProcedure *proc, llirValue *expr, Type *val_type,
                             llirValue **val_, llirValue **idx_, llirBlock **loop_, llirBlock **done_) {
	llirValue *count = NULL;
	Type *expr_type = base_type(llir_type(expr));
	switch (expr_type->kind) {
	case Type_Array:
		count = llir_make_const_int(proc->module->allocator, expr_type->Array.count);
		break;
	case Type_Slice:
		count = llir_slice_len(proc, expr);
		break;
	default:
		GB_PANIC("Cannot do range_indexed of %s", type_to_string(expr_type));
		break;
	}

	llirValue *val = NULL;
	llirValue *idx = NULL;
	llirBlock *loop = NULL;
	llirBlock *done = NULL;
	llirBlock *body = NULL;

	llirValue *index = llir_add_local_generated(proc, t_int);
	llir_emit_store(proc, index, llir_make_const_int(proc->module->allocator, -1));

	loop = llir_add_block(proc, NULL, "for.index.loop");
	llir_emit_jump(proc, loop);
	proc->curr_block = loop;

	llirValue *incr = llir_emit_arith(proc, Token_Add, llir_emit_load(proc, index), v_one, t_int);
	llir_emit_store(proc, index, incr);

	body = llir_add_block(proc, NULL, "for.index.body");
	done = llir_add_block(proc, NULL, "for.index.done");
	llirValue *cond = llir_emit_comp(proc, Token_Lt, incr, count);
	llir_emit_if(proc, cond, body, done);
	proc->curr_block = body;

	idx = llir_emit_load(proc, index);
	if (val_type != NULL) {
		switch (expr_type->kind) {
		case Type_Array: {
			val = llir_emit_load(proc, llir_emit_array_ep(proc, expr, idx));
		} break;
		case Type_Slice: {
			llirValue *elem = llir_slice_elem(proc, expr);
			val = llir_emit_load(proc, llir_emit_ptr_offset(proc, elem, idx));
		} break;
		default:
			GB_PANIC("Cannot do range_indexed of %s", type_to_string(expr_type));
			break;
		}
	}

	if (val_)  *val_  = val;
	if (idx_)  *idx_  = idx;
	if (loop_) *loop_ = loop;
	if (done_) *done_ = done;
}


void llir_build_range_string(llirProcedure *proc, llirValue *expr, Type *val_type,
                            llirValue **val_, llirValue **idx_, llirBlock **loop_, llirBlock **done_) {
	llirValue *count = v_zero;
	Type *expr_type = base_type(llir_type(expr));
	switch (expr_type->kind) {
	case Type_Basic:
		count = llir_string_len(proc, expr);
		break;
	default:
		GB_PANIC("Cannot do range_string of %s", type_to_string(expr_type));
		break;
	}

	llirValue *val = NULL;
	llirValue *idx = NULL;
	llirBlock *loop = NULL;
	llirBlock *done = NULL;
	llirBlock *body = NULL;

	llirValue *index = llir_add_local_generated(proc, t_int);
	llir_emit_store(proc, index, v_zero);

	llirValue *offset_ = llir_add_local_generated(proc, t_int);
	llir_emit_store(proc, index, v_zero);

	loop = llir_add_block(proc, NULL, "for.string.loop");
	llir_emit_jump(proc, loop);
	proc->curr_block = loop;



	body = llir_add_block(proc, NULL, "for.string.body");
	done = llir_add_block(proc, NULL, "for.string.done");

	llirValue *offset = llir_emit_load(proc, offset_);

	llirValue *cond = llir_emit_comp(proc, Token_Lt, offset, count);
	llir_emit_if(proc, cond, body, done);
	proc->curr_block = body;


	llirValue *str_elem = llir_emit_ptr_offset(proc, llir_string_elem(proc, expr), offset);
	llirValue *str_len  = llir_emit_arith(proc, Token_Sub, count, offset, t_int);
	llirValue **args    = gb_alloc_array(proc->module->allocator, llirValue *, 1);
	args[0] = llir_emit_string(proc, str_elem, str_len);
	llirValue *rune_and_len = llir_emit_global_call(proc, "__string_decode_rune", args, 1);
	llirValue *len  = llir_emit_struct_ev(proc, rune_and_len, 1);
	llir_emit_store(proc, offset_, llir_emit_arith(proc, Token_Add, offset, len, t_int));


	idx = llir_emit_load(proc, index);
	if (val_type != NULL) {
		val = llir_emit_struct_ev(proc, rune_and_len, 0);
	}
	llir_emit_increment(proc, index);

	if (val_)  *val_  = val;
	if (idx_)  *idx_  = idx;
	if (loop_) *loop_ = loop;
	if (done_) *done_ = done;
}

void llir_build_range_interval(llirProcedure *proc, AstNodeIntervalExpr *node, Type *val_type,
                              llirValue **val_, llirValue **idx_, llirBlock **loop_, llirBlock **done_) {
	// TODO(bill): How should the behaviour work for lower and upper bounds checking for iteration?
	// If `lower` is changed, should `val` do so or is that not typical behaviour?

	llirValue *lower = llir_build_expr(proc, node->left);
	llirValue *upper = NULL;

	llirValue *val = NULL;
	llirValue *idx = NULL;
	llirBlock *loop = NULL;
	llirBlock *done = NULL;
	llirBlock *body = NULL;

	if (val_type == NULL) {
		val_type = llir_type(lower);
	}
	llirValue *value = llir_add_local_generated(proc, val_type);
	llir_emit_store(proc, value, lower);

	llirValue *index = llir_add_local_generated(proc, t_int);
	llir_emit_store(proc, index, llir_make_const_int(proc->module->allocator, 0));

	loop = llir_add_block(proc, NULL, "for.interval.loop");
	llir_emit_jump(proc, loop);
	proc->curr_block = loop;

	body = llir_add_block(proc, NULL, "for.interval.body");
	done = llir_add_block(proc, NULL, "for.interval.done");

	upper = llir_build_expr(proc, node->right);

	llirValue *cond = llir_emit_comp(proc, Token_Lt, llir_emit_load(proc, value), upper);
	llir_emit_if(proc, cond, body, done);
	proc->curr_block = body;

	if (value != NULL) {
		val = llir_emit_load(proc, value);
	}
	idx = llir_emit_load(proc, index);

	llir_emit_increment(proc, value);
	llir_emit_increment(proc, index);

	if (val_)  *val_  = val;
	if (idx_)  *idx_  = idx;
	if (loop_) *loop_ = loop;
	if (done_) *done_ = done;
}


void llir_build_stmt_internal(llirProcedure *proc, AstNode *node) {
	switch (node->kind) {
	case_ast_node(bs, EmptyStmt, node);
	case_end;

	case_ast_node(us, UsingStmt, node);
		AstNode *decl = unparen_expr(us->node);
		if (decl->kind == AstNode_GenericDecl) {
			llir_build_stmt(proc, decl);
		}
	case_end;

	case_ast_node(ws, WhenStmt, node);
		llir_build_when_stmt(proc, ws);
	case_end;

	case_ast_node(vd, ValueDecl, node);
		if (vd->is_var) {
			llirModule *m = proc->module;
			gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena);

			if (vd->values.count == 0) { // declared and zero-initialized
				for_array(i, vd->names) {
					AstNode *name = vd->names.e[i];
					if (!llir_is_blank_ident(name)) {
						llir_add_local_for_identifier(proc, name, true);
					}
				}
			} else { // Tuple(s)
				Array(llirAddr) lvals;
				llirValueArray  inits;
				array_init_reserve(&lvals, m->tmp_allocator, vd->names.count);
				array_init_reserve(&inits, m->tmp_allocator, vd->names.count);

				for_array(i, vd->names) {
					AstNode *name = vd->names.e[i];
					llirAddr lval = llir_make_addr(NULL, NULL);
					if (!llir_is_blank_ident(name)) {
						llir_add_local_for_identifier(proc, name, false);
						lval = llir_build_addr(proc, name);
					}

					array_add(&lvals, lval);
				}

				for_array(i, vd->values) {
					llirValue *init = llir_build_expr(proc, vd->values.e[i]);
					Type *t = llir_type(init);
					if (t->kind == Type_Tuple) {
						for (isize i = 0; i < t->Tuple.variable_count; i++) {
							Entity *e = t->Tuple.variables[i];
							llirValue *v = llir_emit_struct_ev(proc, init, i);
							array_add(&inits, v);
						}
					} else {
						array_add(&inits, init);
					}
				}


				for_array(i, inits) {
					if (lvals.e[i].addr == NULL) {
						continue;
					}
					llirValue *v = llir_emit_conv(proc, inits.e[i], llir_addr_type(lvals.e[i]));
					llir_addr_store(proc, lvals.e[i], v);
				}
			}

			gb_temp_arena_memory_end(tmp);
		} else {
			for_array(i, vd->names) {
				AstNode *ident = vd->names.e[i];
				GB_ASSERT(ident->kind == AstNode_Ident);
				Entity *e = entity_of_ident(proc->module->info, ident);
				GB_ASSERT(e != NULL);
				switch (e->kind) {
				case Entity_TypeName: {
					// NOTE(bill): Generate a new name
					// parent_proc.name-guid
					String ts_name = e->token.string;
					isize name_len = proc->name.len + 1 + ts_name.len + 1 + 10 + 1;
					u8 *name_text = gb_alloc_array(proc->module->allocator, u8, name_len);
					i32 guid = cast(i32)proc->module->members.entries.count;
					name_len = gb_snprintf(cast(char *)name_text, name_len, "%.*s.%.*s-%d", LIT(proc->name), LIT(ts_name), guid);
					String name = make_string(name_text, name_len-1);

					llirValue *value = llir_make_value_type_name(proc->module->allocator,
					                                           name, e->type);
					map_string_set(&proc->module->type_names, hash_pointer(e->type), name);
					llir_gen_global_type_name(proc->module, e, name);
				} break;
				case Entity_Procedure: {
					DeclInfo **decl_info = map_decl_info_get(&proc->module->info->entities, hash_pointer(e));
					GB_ASSERT(decl_info != NULL);
					DeclInfo *dl = *decl_info;
					ast_node(pd, ProcLit, dl->proc_decl);
					if (pd->body != NULL) {
						CheckerInfo *info = proc->module->info;

						if (map_entity_get(&proc->module->min_dep_map, hash_pointer(e)) == NULL) {
							// NOTE(bill): Nothing depends upon it so doesn't need to be built
							break;
						}

						// NOTE(bill): Generate a new name
						// parent.name-guid
						String original_name = e->token.string;
						String pd_name = original_name;
						if (pd->link_name.len > 0) {
							pd_name = pd->link_name;
						}

						isize name_len = proc->name.len + 1 + pd_name.len + 1 + 10 + 1;
						u8 *name_text = gb_alloc_array(proc->module->allocator, u8, name_len);
						i32 guid = cast(i32)proc->children.count;
						name_len = gb_snprintf(cast(char *)name_text, name_len, "%.*s.%.*s-%d", LIT(proc->name), LIT(pd_name), guid);
						String name = make_string(name_text, name_len-1);


						llirValue *value = llir_make_value_procedure(proc->module->allocator,
						                                           proc->module, e, e->type, pd->type, pd->body, name);

						value->Proc.tags = pd->tags;
						value->Proc.parent = proc;

						llir_module_add_value(proc->module, e, value);
						array_add(&proc->children, &value->Proc);
						array_add(&proc->module->procs_to_generate, value);
					} else {
						CheckerInfo *info = proc->module->info;

						// FFI - Foreign function interace
						String original_name = e->token.string;
						String name = original_name;
						if (pd->foreign_name.len > 0) {
							name = pd->foreign_name;
						}

						llirValue *value = llir_make_value_procedure(proc->module->allocator,
						                                           proc->module, e, e->type, pd->type, pd->body, name);

						value->Proc.tags = pd->tags;

						llir_module_add_value(proc->module, e, value);
						llir_build_proc(value, proc);

						if (value->Proc.tags & ProcTag_foreign) {
							HashKey key = hash_string(name);
							llirValue **prev_value = map_llir_value_get(&proc->module->members, key);
							if (prev_value == NULL) {
								// NOTE(bill): Don't do mutliple declarations in the IR
								map_llir_value_set(&proc->module->members, key, value);
							}
						} else {
							array_add(&proc->children, &value->Proc);
						}
					}
				} break;
				}
			}
		}
	case_end;

	case_ast_node(as, AssignStmt, node);
		llir_emit_comment(proc, str_lit("AssignStmt"));

		llirModule *m = proc->module;
		gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena);

		switch (as->op.kind) {
		case Token_Eq: {
			Array(llirAddr) lvals;
			array_init(&lvals, m->tmp_allocator);

			for_array(i, as->lhs) {
				AstNode *lhs = as->lhs.e[i];
				llirAddr lval = {0};
				if (!llir_is_blank_ident(lhs)) {
					lval = llir_build_addr(proc, lhs);
				}
				array_add(&lvals, lval);
			}

			if (as->lhs.count == as->rhs.count) {
				if (as->lhs.count == 1) {
					AstNode *rhs = as->rhs.e[0];
					llirValue *init = llir_build_expr(proc, rhs);
					llir_addr_store(proc, lvals.e[0], init);
				} else {
					llirValueArray inits;
					array_init_reserve(&inits, m->tmp_allocator, lvals.count);

					for_array(i, as->rhs) {
						llirValue *init = llir_build_expr(proc, as->rhs.e[i]);
						array_add(&inits, init);
					}

					for_array(i, inits) {
						llir_addr_store(proc, lvals.e[i], inits.e[i]);
					}
				}
			} else {
				llirValueArray inits;
				array_init_reserve(&inits, m->tmp_allocator, lvals.count);

				for_array(i, as->rhs) {
					llirValue *init = llir_build_expr(proc, as->rhs.e[i]);
					Type *t = llir_type(init);
					// TODO(bill): refactor for code reuse as this is repeated a bit
					if (t->kind == Type_Tuple) {
						for (isize i = 0; i < t->Tuple.variable_count; i++) {
							Entity *e = t->Tuple.variables[i];
							llirValue *v = llir_emit_struct_ev(proc, init, i);
							array_add(&inits, v);
						}
					} else {
						array_add(&inits, init);
					}
				}

				for_array(i, inits) {
					llir_addr_store(proc, lvals.e[i], inits.e[i]);
				}
			}

		} break;

		default: {
			// NOTE(bill): Only 1 += 1 is allowed, no tuples
			// +=, -=, etc
			i32 op = cast(i32)as->op.kind;
			op += Token_Add - Token_AddEq; // Convert += to +
			llirAddr lhs = llir_build_addr(proc, as->lhs.e[0]);
			llirValue *value = llir_build_expr(proc, as->rhs.e[0]);
			llir_build_assign_op(proc, lhs, value, cast(TokenKind)op);
		} break;
		}

		gb_temp_arena_memory_end(tmp);
	case_end;

	case_ast_node(es, ExprStmt, node);
		// NOTE(bill): No need to use return value
		llir_build_expr(proc, es->expr);
	case_end;

	case_ast_node(bs, BlockStmt, node);
		llir_open_scope(proc);
		llir_build_stmt_list(proc, bs->stmts);
		llir_close_scope(proc, llirDeferExit_Default, NULL);
	case_end;

	case_ast_node(ds, DeferStmt, node);
		llir_emit_comment(proc, str_lit("DeferStmt"));
		isize scope_index = proc->scope_index;
		if (ds->stmt->kind == AstNode_BlockStmt) {
			scope_index--;
		}
		llir_add_defer_node(proc, scope_index, ds->stmt);
	case_end;

	case_ast_node(rs, ReturnStmt, node);
		llir_emit_comment(proc, str_lit("ReturnStmt"));
		llirValue *v = NULL;
		TypeTuple *return_type_tuple  = &proc->type->Proc.results->Tuple;
		isize return_count = proc->type->Proc.result_count;
		if (return_count == 0) {
			// No return values
		} else if (return_count == 1) {
			Entity *e = return_type_tuple->variables[0];
			v = llir_emit_conv(proc, llir_build_expr(proc, rs->results.e[0]), e->type);
		} else {
			gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena);

			llirValueArray results;
			array_init_reserve(&results, proc->module->tmp_allocator, return_count);

			for_array(res_index, rs->results) {
				llirValue *res = llir_build_expr(proc, rs->results.e[res_index]);
				Type *t = llir_type(res);
				if (t->kind == Type_Tuple) {
					for (isize i = 0; i < t->Tuple.variable_count; i++) {
						Entity *e = t->Tuple.variables[i];
						llirValue *v = llir_emit_struct_ev(proc, res, i);
						array_add(&results, v);
					}
				} else {
					array_add(&results, res);
				}
			}

			Type *ret_type = proc->type->Proc.results;
			v = llir_add_local_generated(proc, ret_type);
			for_array(i, results) {
				Entity *e = return_type_tuple->variables[i];
				llirValue *res = llir_emit_conv(proc, results.e[i], e->type);
				llirValue *field = llir_emit_struct_ep(proc, v, i);
				llir_emit_store(proc, field, res);
			}

			v = llir_emit_load(proc, v);

			gb_temp_arena_memory_end(tmp);
		}
		llir_emit_return(proc, v);

	case_end;

	case_ast_node(is, IfStmt, node);
		llir_emit_comment(proc, str_lit("IfStmt"));
		if (is->init != NULL) {
			llirBlock *init = llir_add_block(proc, node, "if.init");
			llir_emit_jump(proc, init);
			proc->curr_block = init;
			llir_build_stmt(proc, is->init);
		}
		llirBlock *then = llir_add_block(proc, node, "if.then");
		llirBlock *done = llir_add_block(proc, node, "if.done"); // NOTE(bill): Append later
		llirBlock *else_ = done;
		if (is->else_stmt != NULL) {
			else_ = llir_add_block(proc, is->else_stmt, "if.else");
		}

		llir_build_cond(proc, is->cond, then, else_);
		proc->curr_block = then;

		llir_open_scope(proc);
		llir_build_stmt(proc, is->body);
		llir_close_scope(proc, llirDeferExit_Default, NULL);

		llir_emit_jump(proc, done);

		if (is->else_stmt != NULL) {
			proc->curr_block = else_;

			llir_open_scope(proc);
			llir_build_stmt(proc, is->else_stmt);
			llir_close_scope(proc, llirDeferExit_Default, NULL);

			llir_emit_jump(proc, done);
		}
		proc->curr_block = done;
	case_end;

	case_ast_node(ws, WhileStmt, node);
		llir_emit_comment(proc, str_lit("WhileStmt"));
		if (ws->init != NULL) {
			llirBlock *init = llir_add_block(proc, node, "while.init");
			llir_emit_jump(proc, init);
			proc->curr_block = init;
			llir_build_stmt(proc, ws->init);
		}
		llirBlock *body = llir_add_block(proc, node, "while.body");
		llirBlock *done = llir_add_block(proc, node, "while.done"); // NOTE(bill): Append later

		llirBlock *loop = body;

		if (ws->cond != NULL) {
			loop = llir_add_block(proc, node, "while.loop");
		}
		llir_emit_jump(proc, loop);
		proc->curr_block = loop;
		if (loop != body) {
			llir_build_cond(proc, ws->cond, body, done);
			proc->curr_block = body;
		}

		llir_push_target_list(proc, done, loop, NULL);

		llir_open_scope(proc);
		llir_build_stmt(proc, ws->body);
		llir_close_scope(proc, llirDeferExit_Default, NULL);

		llir_pop_target_list(proc);
		llir_emit_jump(proc, loop);

		proc->curr_block = done;
	case_end;


	case_ast_node(rs, ForStmt, node);
		llir_emit_comment(proc, str_lit("ForStmt"));

		Type *val_type = NULL;
		Type *idx_type = NULL;
		if (rs->value != NULL && !llir_is_blank_ident(rs->value)) {
			val_type = type_of_expr(proc->module->info, rs->value);
		}
		if (rs->index != NULL && !llir_is_blank_ident(rs->index)) {
			idx_type = type_of_expr(proc->module->info, rs->index);
		}

		if (val_type != NULL) {
			llir_add_local_for_identifier(proc, rs->value, true);
		}
		if (idx_type != NULL) {
			llir_add_local_for_identifier(proc, rs->index, true);
		}

		llirValue *val = NULL;
		llirValue *index = NULL;
		llirBlock *loop = NULL;
		llirBlock *done = NULL;

		if (rs->expr->kind == AstNode_IntervalExpr) {
			llir_build_range_interval(proc, &rs->expr->IntervalExpr, val_type, &val, &index, &loop, &done);
		} else {
			Type *expr_type = type_of_expr(proc->module->info, rs->expr);
			Type *et = base_type(type_deref(expr_type));
			bool deref = is_type_pointer(expr_type);
			switch (et->kind) {
			case Type_Array: {
				llirValue *array = llir_build_addr(proc, rs->expr).addr;
				if (deref) {
					array = llir_emit_load(proc, array);
				}
				llir_build_range_indexed(proc, array, val_type, &val, &index, &loop, &done);
			} break;
			case Type_Slice: {
				llirValue *slice = llir_build_expr(proc, rs->expr);
				if (deref) {
					slice = llir_emit_load(proc, slice);
				}
				llir_build_range_indexed(proc, slice, val_type, &val, &index, &loop, &done);
			} break;
			case Type_Basic: {
				llirValue *string = llir_build_expr(proc, rs->expr);
				if (deref) {
					string = llir_emit_load(proc, string);
				}
				if (is_type_untyped(expr_type)) {
					llirValue *s = llir_add_local_generated(proc, t_string);
					llir_emit_store(proc, s, string);
					string = llir_emit_load(proc, s);
				}
				llir_build_range_string(proc, string, val_type, &val, &index, &loop, &done);
			} break;
			default:
				GB_PANIC("Cannot range over %s", type_to_string(expr_type));
				break;
			}
		}

		llirAddr val_addr = {0};
		llirAddr idx_addr = {0};
		if (val_type != NULL) {
			val_addr = llir_build_addr(proc, rs->value);
		}
		if (idx_type != NULL) {
			idx_addr = llir_build_addr(proc, rs->index);
		}
		if (val_type != NULL) {
			llir_addr_store(proc, val_addr, val);
		}
		if (idx_type != NULL) {
			llir_addr_store(proc, idx_addr, index);
		}

		llir_push_target_list(proc, done, loop, NULL);

		llir_open_scope(proc);
		llir_build_stmt(proc, rs->body);
		llir_close_scope(proc, llirDeferExit_Default, NULL);

		llir_pop_target_list(proc);
		llir_emit_jump(proc, loop);
		proc->curr_block = done;
	case_end;

	case_ast_node(ms, MatchStmt, node);
		llir_emit_comment(proc, str_lit("MatchStmt"));
		if (ms->init != NULL) {
			llir_build_stmt(proc, ms->init);
		}
		llirValue *tag = v_true;
		if (ms->tag != NULL) {
			tag = llir_build_expr(proc, ms->tag);
		}
		llirBlock *done = llir_add_block(proc, node, "match.done"); // NOTE(bill): Append later

		ast_node(body, BlockStmt, ms->body);

		AstNodeArray default_stmts = {0};
		llirBlock *default_fall = NULL;
		llirBlock *default_block = NULL;

		llirBlock *fall = NULL;
		bool append_fall = false;

		isize case_count = body->stmts.count;
		for_array(i, body->stmts) {
			AstNode *clause = body->stmts.e[i];
			llirBlock *body = fall;

			ast_node(cc, CaseClause, clause);

			if (body == NULL) {
				if (cc->list.count == 0) {
					body = llir_add_block(proc, clause, "match.dflt.body");
				} else {
					body = llir_add_block(proc, clause, "match.case.body");
				}
			}
			if (append_fall && body == fall) {
				append_fall = false;
			}

			fall = done;
			if (i+1 < case_count) {
				append_fall = true;
				fall = llir_add_block(proc, clause, "match.fall.body");
			}

			if (cc->list.count == 0) {
				// default case
				default_stmts = cc->stmts;
				default_fall  = fall;
				default_block = body;
				continue;
			}

			llirBlock *next_cond = NULL;
			for_array(j, cc->list) {
				AstNode *expr = cc->list.e[j];
				next_cond = llir_add_block(proc, clause, "match.case.next");

				llirValue *cond = llir_emit_comp(proc, Token_CmpEq, tag, llir_build_expr(proc, expr));
				llir_emit_if(proc, cond, body, next_cond);
				proc->curr_block = next_cond;
			}
			proc->curr_block = body;

			llir_push_target_list(proc, done, NULL, fall);
			llir_open_scope(proc);
			llir_build_stmt_list(proc, cc->stmts);
			llir_close_scope(proc, llirDeferExit_Default, body);
			llir_pop_target_list(proc);

			llir_emit_jump(proc, done);
			proc->curr_block = next_cond;
		}

		if (default_block != NULL) {
			llir_emit_jump(proc, default_block);
			proc->curr_block = default_block;

			llir_push_target_list(proc, done, NULL, default_fall);
			llir_open_scope(proc);
			llir_build_stmt_list(proc, default_stmts);
			llir_close_scope(proc, llirDeferExit_Default, default_block);
			llir_pop_target_list(proc);
		}

		llir_emit_jump(proc, done);
		proc->curr_block = done;
	case_end;


	case_ast_node(ms, TypeMatchStmt, node);
		llir_emit_comment(proc, str_lit("TypeMatchStmt"));
		gbAllocator allocator = proc->module->allocator;

		llirValue *parent = llir_build_expr(proc, ms->tag);
		bool is_union_ptr = false;
		bool is_any = false;
		GB_ASSERT(check_valid_type_match_type(llir_type(parent), &is_union_ptr, &is_any));

		llirValue *tag_index = NULL;
		llirValue *union_data = NULL;
		if (is_union_ptr) {
			llir_emit_comment(proc, str_lit("get union's tag"));
			tag_index = llir_emit_load(proc, llir_emit_union_tag_ptr(proc, parent));
			union_data = llir_emit_conv(proc, parent, t_rawptr);
		}

		llirBlock *start_block = llir_add_block(proc, node, "type-match.case.first");
		llir_emit_jump(proc, start_block);
		proc->curr_block = start_block;

		llirBlock *done = llir_add_block(proc, node, "type-match.done"); // NOTE(bill): Append later

		ast_node(body, BlockStmt, ms->body);

		String tag_var_name = ms->var->Ident.string;

		AstNodeArray default_stmts = {0};
		llirBlock *default_block = NULL;


		isize case_count = body->stmts.count;
		for_array(i, body->stmts) {
			AstNode *clause = body->stmts.e[i];
			ast_node(cc, CaseClause, clause);

			if (cc->list.count == 0) {
				// default case
				default_stmts = cc->stmts;
				default_block = llir_add_block(proc, clause, "type-match.dflt.body");
				continue;
			}


			llirBlock *body = llir_add_block(proc, clause, "type-match.case.body");

			Scope *scope = *map_scope_get(&proc->module->info->scopes, hash_pointer(clause));
			Entity *tag_var_entity = current_scope_lookup_entity(scope, tag_var_name);
			GB_ASSERT_MSG(tag_var_entity != NULL, "%.*s", LIT(tag_var_name));

			llirBlock *next_cond = NULL;
			llirValue *cond = NULL;

			if (is_union_ptr) {
				Type *bt = type_deref(tag_var_entity->type);
				llirValue *index = NULL;
				Type *ut = base_type(type_deref(llir_type(parent)));
				GB_ASSERT(ut->Record.kind == TypeRecord_Union);
				for (isize field_index = 1; field_index < ut->Record.field_count; field_index++) {
					Entity *f = ut->Record.fields[field_index];
					if (are_types_identical(f->type, bt)) {
						index = llir_make_const_int(allocator, field_index);
						break;
					}
				}
				GB_ASSERT(index != NULL);

				llirValue *tag_var = llir_add_local(proc, tag_var_entity);
				llirValue *data_ptr = llir_emit_conv(proc, union_data, tag_var_entity->type);
				llir_emit_store(proc, tag_var, data_ptr);

				cond = llir_emit_comp(proc, Token_CmpEq, tag_index, index);
			} else if (is_any) {
				Type *type = tag_var_entity->type;
				llirValue *any_data = llir_emit_struct_ev(proc, parent, 1);
				llirValue *data = llir_emit_conv(proc, any_data, make_type_pointer(proc->module->allocator, type));
				llir_module_add_value(proc->module, tag_var_entity, data);

				llirValue *any_ti  = llir_emit_struct_ev(proc, parent, 0);
				llirValue *case_ti = llir_type_info(proc, type);
				cond = llir_emit_comp(proc, Token_CmpEq, any_ti, case_ti);
			} else {
				GB_PANIC("Invalid type for type match statement");
			}

			next_cond = llir_add_block(proc, clause, "type-match.case.next");
			llir_emit_if(proc, cond, body, next_cond);
			proc->curr_block = next_cond;

			proc->curr_block = body;

			llir_push_target_list(proc, done, NULL, NULL);
			llir_open_scope(proc);
			llir_build_stmt_list(proc, cc->stmts);
			llir_close_scope(proc, llirDeferExit_Default, body);
			llir_pop_target_list(proc);

			llir_emit_jump(proc, done);
			proc->curr_block = next_cond;
		}

		if (default_block != NULL) {
			llir_emit_jump(proc, default_block);
			proc->curr_block = default_block;

			llir_push_target_list(proc, done, NULL, NULL);
			llir_open_scope(proc);
			llir_build_stmt_list(proc, default_stmts);
			llir_close_scope(proc, llirDeferExit_Default, default_block);
			llir_pop_target_list(proc);
		}

		llir_emit_jump(proc, done);
		proc->curr_block = done;
	case_end;

	case_ast_node(bs, BranchStmt, node);
		llirBlock *block = NULL;
		switch (bs->token.kind) {
		case Token_break:
			for (llirTargetList *t = proc->target_list; t != NULL && block == NULL; t = t->prev) {
				block = t->break_;
			}
			break;
		case Token_continue:
			for (llirTargetList *t = proc->target_list; t != NULL && block == NULL; t = t->prev) {
				block = t->continue_;
			}
			break;
		case Token_fallthrough:
			for (llirTargetList *t = proc->target_list; t != NULL && block == NULL; t = t->prev) {
				block = t->fallthrough_;
			}
			break;
		}
		if (block != NULL) {
			llir_emit_defer_stmts(proc, llirDeferExit_Branch, block);
		}
		switch (bs->token.kind) {
		case Token_break:       llir_emit_comment(proc, str_lit("break"));       break;
		case Token_continue:    llir_emit_comment(proc, str_lit("continue"));    break;
		case Token_fallthrough: llir_emit_comment(proc, str_lit("fallthrough")); break;
		}
		llir_emit_jump(proc, block);
		llir_emit_unreachable(proc);
	case_end;



	case_ast_node(pa, PushAllocator, node);
		llir_emit_comment(proc, str_lit("PushAllocator"));
		llir_open_scope(proc);

		llirValue *context_ptr = llir_find_implicit_value_backing(proc, ImplicitValue_context);
		llirValue *prev_context = llir_add_local_generated(proc, t_context);
		llir_emit_store(proc, prev_context, llir_emit_load(proc, context_ptr));

		llir_add_defer_instr(proc, proc->scope_index, llir_make_instr_store(proc, context_ptr, llir_emit_load(proc, prev_context)));

		llirValue *gep = llir_emit_struct_ep(proc, context_ptr, 1);
		llir_emit_store(proc, gep, llir_build_expr(proc, pa->expr));

		llir_build_stmt(proc, pa->body);

		llir_close_scope(proc, llirDeferExit_Default, NULL);
	case_end;


	case_ast_node(pa, PushContext, node);
		llir_emit_comment(proc, str_lit("PushContext"));
		llir_open_scope(proc);

		llirValue *context_ptr = llir_find_implicit_value_backing(proc, ImplicitValue_context);
		llirValue *prev_context = llir_add_local_generated(proc, t_context);
		llir_emit_store(proc, prev_context, llir_emit_load(proc, context_ptr));

		llir_add_defer_instr(proc, proc->scope_index, llir_make_instr_store(proc, context_ptr, llir_emit_load(proc, prev_context)));

		llir_emit_store(proc, context_ptr, llir_build_expr(proc, pa->expr));

		llir_build_stmt(proc, pa->body);

		llir_close_scope(proc, llirDeferExit_Default, NULL);
	case_end;


	}
}







////////////////////////////////////////////////////////////////
//
// @Procedure
//
////////////////////////////////////////////////////////////////

void llir_number_proc_registers(llirProcedure *proc) {
	i32 reg_index = 0;
	for_array(i, proc->blocks) {
		llirBlock *b = proc->blocks.e[i];
		b->index = i;
		for_array(j, b->instrs) {
			llirValue *value = b->instrs.e[j];
			GB_ASSERT(value->kind == llirValue_Instr);
			llirInstr *instr = &value->Instr;
			if (llir_instr_type(instr) == NULL) { // NOTE(bill): Ignore non-returning instructions
				continue;
			}
			value->index = reg_index;
			reg_index++;
		}
	}
}

void llir_begin_procedure_body(llirProcedure *proc) {
	array_add(&proc->module->procs, proc);

	array_init(&proc->blocks,      heap_allocator());
	array_init(&proc->defer_stmts, heap_allocator());
	array_init(&proc->children,    heap_allocator());

	proc->decl_block  = llir_add_block(proc, proc->type_expr, "decls");
	proc->entry_block = llir_add_block(proc, proc->type_expr, "entry");
	proc->curr_block  = proc->entry_block;

	if (proc->type->Proc.params != NULL) {
		TypeTuple *params = &proc->type->Proc.params->Tuple;
		for (isize i = 0; i < params->variable_count; i++) {
			Entity *e = params->variables[i];
			if (!str_eq(e->token.string, str_lit("")) &&
			    !str_eq(e->token.string, str_lit("_"))) {
				llirValue *param = llir_add_param(proc, e);
				array_add(&proc->params, param);
			}
		}
	}
}


void llir_end_procedure_body(llirProcedure *proc) {
	if (proc->type->Proc.result_count == 0) {
		llir_emit_return(proc, NULL);
	}

	if (proc->curr_block->instrs.count == 0) {
		llir_emit_unreachable(proc);
	}

	proc->curr_block = proc->decl_block;
	llir_emit_jump(proc, proc->entry_block);

	llir_number_proc_registers(proc);
}


void llir_insert_code_before_proc(llirProcedure* proc, llirProcedure *parent) {
	if (parent == NULL) {
		if (str_eq(proc->name, str_lit("main"))) {
			llir_emit_startup_runtime(proc);
		}
	}
}

void llir_build_proc(llirValue *value, llirProcedure *parent) {
	llirProcedure *proc = &value->Proc;

	proc->parent = parent;

	if (proc->entity != NULL) {
		llirModule *m = proc->module;
		CheckerInfo *info = m->info;
		Entity *e = proc->entity;
		String filename = e->token.pos.file;
		AstFile **found = map_ast_file_get(&info->files, hash_string(filename));
		GB_ASSERT(found != NULL);
		AstFile *f = *found;
		llirDebugInfo *di_file = NULL;

		llirDebugInfo **di_file_found = map_llir_debug_info_get(&m->debug_info, hash_pointer(f));
		if (di_file_found) {
			di_file = *di_file_found;
			GB_ASSERT(di_file->kind == llirDebugInfo_File);
		} else {
			di_file = llir_add_debug_info_file(proc, f);
		}

		llir_add_debug_info_proc(proc, e, proc->name, di_file);
	}

	if (proc->body != NULL) {
		u32 prev_stmt_state_flags = proc->module->stmt_state_flags;

		if (proc->tags != 0) {
			u32 in = proc->tags;
			u32 out = proc->module->stmt_state_flags;
			if (in & ProcTag_bounds_check) {
				out |= StmtStateFlag_bounds_check;
				out &= ~StmtStateFlag_no_bounds_check;
			} else if (in & ProcTag_no_bounds_check) {
				out |= StmtStateFlag_no_bounds_check;
				out &= ~StmtStateFlag_bounds_check;
			}
			proc->module->stmt_state_flags = out;
		}


		llir_begin_procedure_body(proc);
		llir_insert_code_before_proc(proc, parent);
		llir_build_stmt(proc, proc->body);
		llir_end_procedure_body(proc);

		proc->module->stmt_state_flags = prev_stmt_state_flags;
	}
}







////////////////////////////////////////////////////////////////
//
// @Module
//
////////////////////////////////////////////////////////////////



void llir_module_add_value(llirModule *m, Entity *e, llirValue *v) {
	map_llir_value_set(&m->values, hash_pointer(e), v);
}

void llir_init_module(llirModule *m, Checker *c, BuildContext *build_context) {
	// TODO(bill): Determine a decent size for the arena
	isize token_count = c->parser->total_token_count;
	isize arena_size = 4 * token_count * gb_size_of(llirValue);
	gb_arena_init_from_allocator(&m->arena, heap_allocator(), arena_size);
	gb_arena_init_from_allocator(&m->tmp_arena, heap_allocator(), arena_size);
	m->allocator     = gb_arena_allocator(&m->arena);
	m->tmp_allocator = gb_arena_allocator(&m->tmp_arena);
	m->info = &c->info;
	m->sizes = c->sizes;
	m->build_context = build_context;

	map_llir_value_init(&m->values,  heap_allocator());
	map_llir_value_init(&m->members, heap_allocator());
	map_llir_debug_info_init(&m->debug_info, heap_allocator());
	map_string_init(&m->type_names, heap_allocator());
	array_init(&m->procs,    heap_allocator());
	array_init(&m->procs_to_generate, heap_allocator());

	// Default states
	m->stmt_state_flags = 0;
	m->stmt_state_flags |= StmtStateFlag_bounds_check;

	{
		// Add type info data
		{
			String name = str_lit(LLIR_TYPE_INFO_DATA_NAME);
			isize count = c->info.type_info_map.entries.count;
			Entity *e = make_entity_variable(m->allocator, NULL, make_token_ident(name), make_type_array(m->allocator, t_type_info, count));
			llirValue *g = llir_make_value_global(m->allocator, e, NULL);
			g->Global.is_private  = true;
			llir_module_add_value(m, e, g);
			map_llir_value_set(&m->members, hash_string(name), g);
		}

		// Type info member buffer
		{
			// NOTE(bill): Removes need for heap allocation by making it global memory
			isize count = 0;

			for_array(entry_index, m->info->type_info_map.entries) {
				MapIsizeEntry *entry = &m->info->type_info_map.entries.e[entry_index];
				Type *t = cast(Type *)cast(uintptr)entry->key.key;

				switch (t->kind) {
				case Type_Record:
					switch (t->Record.kind) {
					case TypeRecord_Struct:
					case TypeRecord_RawUnion:
						count += t->Record.field_count;
					}
					break;
				case Type_Tuple:
					count += t->Tuple.variable_count;
					break;
				}
			}

			String name = str_lit(LLIR_TYPE_INFO_DATA_MEMBER_NAME);
			Entity *e = make_entity_variable(m->allocator, NULL, make_token_ident(name),
			                                 make_type_array(m->allocator, t_type_info_member, count));
			llirValue *g = llir_make_value_global(m->allocator, e, NULL);
			llir_module_add_value(m, e, g);
			map_llir_value_set(&m->members, hash_string(name), g);
		}
	}

	{
		llirDebugInfo *di = llir_alloc_debug_info(m->allocator, llirDebugInfo_CompileUnit);
		di->CompileUnit.file = m->info->files.entries.e[0].value; // Zeroth is the init file
		di->CompileUnit.producer = str_lit("odin");

		map_llir_debug_info_set(&m->debug_info, hash_pointer(m), di);
	}
}

void llir_destroy_module(llirModule *m) {
	map_llir_value_destroy(&m->values);
	map_llir_value_destroy(&m->members);
	map_string_destroy(&m->type_names);
	map_llir_debug_info_destroy(&m->debug_info);
	array_free(&m->procs_to_generate);
	gb_arena_free(&m->arena);
}



////////////////////////////////////////////////////////////////
//
// @Code Generation
//
////////////////////////////////////////////////////////////////


bool llir_gen_init(llirGen *s, Checker *c, BuildContext *build_context) {
	if (global_error_collector.count != 0) {
		return false;
	}

	isize tc = c->parser->total_token_count;
	if (tc < 2) {
		return false;
	}

	llir_init_module(&s->module, c, build_context);
	s->module.generate_debug_info = false;

	// TODO(bill): generate appropriate output name
	int pos = cast(int)string_extension_position(c->parser->init_fullpath);
	gbFileError err = gb_file_create(&s->output_file, gb_bprintf("%.*s.ll", pos, c->parser->init_fullpath.text));
	if (err != gbFileError_None) {
		return false;
	}

	return true;
}

void llir_gen_destroy(llirGen *s) {
	llir_destroy_module(&s->module);
	gb_file_close(&s->output_file);
}

String llir_mangle_name(llirGen *s, String path, String name) {
	// NOTE(bill): prefix names not in the init scope
	// TODO(bill): make robust and not just rely on the file's name

	llirModule *m = &s->module;
	CheckerInfo *info = m->info;
	gbAllocator a = m->allocator;
	AstFile *file = *map_ast_file_get(&info->files, hash_string(path));

	char *str = gb_alloc_array(a, char, path.len+1);
	gb_memmove(str, path.text, path.len);
	str[path.len] = 0;
	for (isize i = 0; i < path.len; i++) {
		if (str[i] == '\\') {
			str[i] = '/';
		}
	}

	char const *base = gb_path_base_name(str);
	char const *ext = gb_path_extension(base);
	isize base_len = ext-1-base;

	isize max_len = base_len + 1 + 10 + 1 + name.len;
	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",
		cast(int)base_len, base,
		file->id,
		LIT(name));

	return make_string(new_name, new_name_len-1);
}

llirValue *llir_get_type_info_ptr(llirProcedure *proc, llirValue *type_info_data, Type *type) {
	i32 index = cast(i32)llir_type_info_index(proc->module->info, type);
	// gb_printf_err("%d %s\n", index, type_to_string(type));
	llirValue *ptr = llir_emit_array_epi(proc, type_info_data, index);
	return llir_emit_bitcast(proc, ptr, t_type_info_ptr);
}

llirValue *llir_type_info_member_offset(llirProcedure *proc, llirValue *data, isize count, i32 *index) {
	llirValue *offset = llir_emit_array_epi(proc, data, *index);
	*index += count;
	return offset;
}

void llir_gen_tree(llirGen *s) {
	llirModule *m = &s->module;
	CheckerInfo *info = m->info;
	gbAllocator a = m->allocator;

	if (v_zero == NULL) {
		v_zero   = llir_make_const_int (m->allocator, 0);
		v_one    = llir_make_const_int (m->allocator, 1);
		v_zero32 = llir_make_const_i32 (m->allocator, 0);
		v_one32  = llir_make_const_i32 (m->allocator, 1);
		v_two32  = llir_make_const_i32 (m->allocator, 2);
		v_false  = llir_make_const_bool(m->allocator, false);
		v_true   = llir_make_const_bool(m->allocator, true);
	}

	isize global_variable_max_count = 0;
	Entity *entry_point = NULL;
	bool has_dll_main = false;
	bool has_win_main = false;

	for_array(i, info->entities.entries) {
		MapDeclInfoEntry *entry = &info->entities.entries.e[i];
		Entity *e = cast(Entity *)cast(uintptr)entry->key.key;
		String name = e->token.string;
		if (e->kind == Entity_Variable) {
			global_variable_max_count++;
		} else if (e->kind == Entity_Procedure && !e->scope->is_global) {
			if (e->scope->is_init && str_eq(name, str_lit("main"))) {
				entry_point = e;
			}
			if ((e->Procedure.tags & ProcTag_export) != 0 ||
			    (e->Procedure.link_name.len > 0) ||
			    (e->scope->is_file && e->Procedure.link_name.len > 0)) {
				if (!has_dll_main && str_eq(name, str_lit("DllMain"))) {
					has_dll_main = true;
				} else if (!has_win_main && str_eq(name, str_lit("WinMain"))) {
					has_win_main = true;
				}
			}
		}
	}

	typedef struct llirGlobalVariable {
		llirValue *var, *init;
		DeclInfo *decl;
	} llirGlobalVariable;
	Array(llirGlobalVariable) global_variables;
	array_init_reserve(&global_variables, m->tmp_allocator, global_variable_max_count);

	m->entry_point_entity = entry_point;
	m->min_dep_map = generate_minimum_dependency_map(info, entry_point);

	for_array(i, info->entities.entries) {
		MapDeclInfoEntry *entry = &info->entities.entries.e[i];
		Entity *e = cast(Entity *)entry->key.ptr;
		String name = e->token.string;
		DeclInfo *decl = entry->value;
		Scope *scope = e->scope;

		if (!scope->is_file) {
			continue;
		}

		if (map_entity_get(&m->min_dep_map, hash_pointer(e)) == NULL) {
			// NOTE(bill): Nothing depends upon it so doesn't need to be built
			continue;
		}

		if (!scope->is_global) {
			if (e->kind == Entity_Procedure && (e->Procedure.tags & ProcTag_export) != 0) {
			} else if (e->kind == Entity_Procedure && e->Procedure.link_name.len > 0) {
			} else if (scope->is_init && e->kind == Entity_Procedure && str_eq(name, str_lit("main"))) {
			} else {
				name = llir_mangle_name(s, e->token.pos.file, name);
			}
		}


		switch (e->kind) {
		case Entity_TypeName:
			GB_ASSERT(e->type->kind == Type_Named);
			map_string_set(&m->type_names, hash_pointer(e->type), name);
			llir_gen_global_type_name(m, e, name);
			break;

		case Entity_Variable: {
			llirValue *g = llir_make_value_global(a, e, NULL);
			if (decl->var_decl_tags & VarDeclTag_thread_local) {
				g->Global.is_thread_local = true;
			}
			llirGlobalVariable var = {0};
			var.var = g;
			var.decl = decl;

			if (decl->init_expr != NULL) {
				TypeAndValue *tav = map_tav_get(&info->types, hash_pointer(decl->init_expr));
				if (tav != NULL) {
					if (tav->value.kind != ExactValue_Invalid) {
						ExactValue v = tav->value;
						// if (v.kind != ExactValue_String) {
							g->Global.value = llir_add_module_constant(m, tav->type, v);
						// }
					}
				}
			}

			if (g->Global.value == NULL) {
				array_add(&global_variables, var);
			}

			llir_module_add_value(m, e, g);
			map_llir_value_set(&m->members, hash_string(name), g);
		} break;

		case Entity_Procedure: {
			ast_node(pd, ProcLit, decl->proc_decl);
			String original_name = name;
			AstNode *body = pd->body;
			if (e->Procedure.is_foreign) {
				name = e->token.string; // NOTE(bill): Don't use the mangled name
			}
			if (pd->foreign_name.len > 0) {
				name = pd->foreign_name;
			} else if (pd->link_name.len > 0) {
				name = pd->link_name;
			}

			llirValue *p = llir_make_value_procedure(a, m, e, e->type, decl->type_expr, body, name);
			p->Proc.tags = pd->tags;

			llir_module_add_value(m, e, p);
			HashKey hash_name = hash_string(name);
			if (map_llir_value_get(&m->members, hash_name) == NULL) {
				map_llir_value_set(&m->members, hash_name, p);
			}
		} break;
		}
	}

	for_array(i, m->members.entries) {
		MapSsaValueEntry *entry = &m->members.entries.e[i];
		llirValue *v = entry->value;
		if (v->kind == llirValue_Proc) {
			llir_build_proc(v, NULL);
		}
	}

	llirDebugInfo *compile_unit = m->debug_info.entries.e[0].value;
	GB_ASSERT(compile_unit->kind == llirDebugInfo_CompileUnit);
	llirDebugInfo *all_procs = llir_alloc_debug_info(m->allocator, llirDebugInfo_AllProcs);

	isize all_proc_max_count = 0;
	for_array(i, m->debug_info.entries) {
		MapSsaDebugInfoEntry *entry = &m->debug_info.entries.e[i];
		llirDebugInfo *di = entry->value;
		di->id = i;
		if (di->kind == llirDebugInfo_Proc) {
			all_proc_max_count++;
		}
	}

	array_init_reserve(&all_procs->AllProcs.procs, m->allocator, all_proc_max_count);
	map_llir_debug_info_set(&m->debug_info, hash_pointer(all_procs), all_procs); // NOTE(bill): This doesn't need to be mapped
	compile_unit->CompileUnit.all_procs = all_procs;


	for_array(i, m->debug_info.entries) {
		MapSsaDebugInfoEntry *entry = &m->debug_info.entries.e[i];
		llirDebugInfo *di = entry->value;
		di->id = i;
		if (di->kind == llirDebugInfo_Proc) {
			array_add(&all_procs->AllProcs.procs, di);
		}
	}

#if defined(GB_SYSTEM_WINDOWS)
	if (m->build_context->is_dll && !has_dll_main) {
		// DllMain :: proc(inst: rawptr, reason: u32, reserved: rawptr) -> i32
		String name = str_lit("DllMain");
		Type *proc_params = make_type_tuple(a);
		Type *proc_results = make_type_tuple(a);

		Scope *proc_scope = gb_alloc_item(a, Scope);

		proc_params->Tuple.variables = gb_alloc_array(a, Entity *, 3);
		proc_params->Tuple.variable_count = 3;

		proc_results->Tuple.variables = gb_alloc_array(a, Entity *, 1);
		proc_results->Tuple.variable_count = 1;

		proc_params->Tuple.variables[0] = make_entity_param(a, proc_scope, blank_token, t_rawptr, false);
		proc_params->Tuple.variables[1] = make_entity_param(a, proc_scope, make_token_ident(str_lit("reason")), t_i32, false);
		proc_params->Tuple.variables[2] = make_entity_param(a, proc_scope, blank_token, t_rawptr, false);

		proc_results->Tuple.variables[0] = make_entity_param(a, proc_scope, empty_token, t_i32, false);


		Type *proc_type = make_type_proc(a, proc_scope,
		                                 proc_params, 3,
		                                 proc_results, 1, false, ProcCC_Std);

		AstNode *body = gb_alloc_item(a, AstNode);
		Entity *e = make_entity_procedure(a, NULL, make_token_ident(name), proc_type, 0);
		llirValue *p = llir_make_value_procedure(a, m, e, proc_type, NULL, body, name);

		map_llir_value_set(&m->values, hash_pointer(e), p);
		map_llir_value_set(&m->members, hash_string(name), p);

		llirProcedure *proc = &p->Proc;
		proc->tags = ProcTag_no_inline; // TODO(bill): is no_inline a good idea?
		e->Procedure.link_name = name;

		llir_begin_procedure_body(proc);

		// NOTE(bill): https://msdn.microsoft.com/en-us/library/windows/desktop/ms682583(v=vs.85).aspx
		// DLL_PROCESS_ATTACH == 1

		llirAddr reason_addr = llir_build_addr_from_entity(proc, proc_params->Tuple.variables[1], NULL);
		llirValue *cond = llir_emit_comp(proc, Token_CmpEq, llir_addr_load(proc, reason_addr), v_one32);
		llirBlock *then = llir_add_block(proc, NULL, "if.then");
		llirBlock *done = llir_add_block(proc, NULL, "if.done"); // NOTE(bill): Append later
		llir_emit_if(proc, cond, then, done);
		proc->curr_block = then;
		llir_emit_global_call(proc, "main", NULL, 0);
		llir_emit_jump(proc, done);
		proc->curr_block = done;

		llir_emit_return(proc, v_one32);


		llir_end_procedure_body(proc);
	}
#endif
#if defined(GB_SYSTEM_WINDOWS)
	if (!m->build_context->is_dll && !has_win_main) {
		// WinMain :: proc(inst, prev: rawptr, cmd_line: ^byte, cmd_show: i32) -> i32
		String name = str_lit("WinMain");
		Type *proc_params = make_type_tuple(a);
		Type *proc_results = make_type_tuple(a);

		Scope *proc_scope = gb_alloc_item(a, Scope);

		proc_params->Tuple.variables = gb_alloc_array(a, Entity *, 4);
		proc_params->Tuple.variable_count = 4;

		proc_results->Tuple.variables = gb_alloc_array(a, Entity *, 1);
		proc_results->Tuple.variable_count = 1;

		proc_params->Tuple.variables[0] = make_entity_param(a, proc_scope, blank_token, t_rawptr, false);
		proc_params->Tuple.variables[1] = make_entity_param(a, proc_scope, blank_token, t_rawptr, false);
		proc_params->Tuple.variables[2] = make_entity_param(a, proc_scope, blank_token, t_u8_ptr, false);
		proc_params->Tuple.variables[3] = make_entity_param(a, proc_scope, blank_token, t_i32,    false);

		proc_results->Tuple.variables[0] = make_entity_param(a, proc_scope, empty_token, t_i32, false);


		Type *proc_type = make_type_proc(a, proc_scope,
		                                 proc_params, 4,
		                                 proc_results, 1, false, ProcCC_Std);

		AstNode *body = gb_alloc_item(a, AstNode);
		Entity *e = make_entity_procedure(a, NULL, make_token_ident(name), proc_type, 0);
		llirValue *p = llir_make_value_procedure(a, m, e, proc_type, NULL, body, name);

		m->entry_point_entity = e;

		map_llir_value_set(&m->values, hash_pointer(e), p);
		map_llir_value_set(&m->members, hash_string(name), p);

		llirProcedure *proc = &p->Proc;
		proc->tags = ProcTag_no_inline; // TODO(bill): is no_inline a good idea?
		e->Procedure.link_name = name;

		llir_begin_procedure_body(proc);
		llir_emit_global_call(proc, "main", NULL, 0);
		llir_emit_return(proc, v_one32);
		llir_end_procedure_body(proc);
	}
#endif
	{ // Startup Runtime
		// Cleanup(bill): probably better way of doing code insertion
		String name = str_lit(LLIR_STARTUP_RUNTIME_PROC_NAME);
		Type *proc_type = make_type_proc(a, gb_alloc_item(a, Scope),
		                                 NULL, 0,
		                                 NULL, 0, false, ProcCC_Odin);
		AstNode *body = gb_alloc_item(a, AstNode);
		Entity *e = make_entity_procedure(a, NULL, make_token_ident(name), proc_type, 0);
		llirValue *p = llir_make_value_procedure(a, m, e, proc_type, NULL, body, name);

		map_llir_value_set(&m->values, hash_pointer(e), p);
		map_llir_value_set(&m->members, hash_string(name), p);

		llirProcedure *proc = &p->Proc;
		proc->tags = ProcTag_no_inline; // TODO(bill): is no_inline a good idea?

		llir_begin_procedure_body(proc);

		// TODO(bill): Should do a dependency graph do check which order to initialize them in?
		for_array(i, global_variables) {
			llirGlobalVariable *var = &global_variables.e[i];
			if (var->decl->init_expr != NULL) {
				var->init = llir_build_expr(proc, var->decl->init_expr);
			}
		}

		// NOTE(bill): Initialize constants first
		for_array(i, global_variables) {
			llirGlobalVariable *var = &global_variables.e[i];
			if (var->init != NULL) {
				if (var->init->kind == llirValue_Constant) {
					llir_emit_store(proc, var->var, var->init);
				}
			}
		}

		for_array(i, global_variables) {
			llirGlobalVariable *var = &global_variables.e[i];
			if (var->init != NULL) {
				if (var->init->kind != llirValue_Constant) {
					llir_emit_store(proc, var->var, var->init);
				}
			}
		}

		{ // NOTE(bill): Setup type_info data
			// TODO(bill): Try and make a lot of this constant aggregate literals in LLVM IR
			llirValue *type_info_data = NULL;
			llirValue *type_info_member_data = NULL;

			llirValue **found = NULL;
			found = map_llir_value_get(&proc->module->members, hash_string(str_lit(LLIR_TYPE_INFO_DATA_NAME)));
			GB_ASSERT(found != NULL);
			type_info_data = *found;

			found = map_llir_value_get(&proc->module->members, hash_string(str_lit(LLIR_TYPE_INFO_DATA_MEMBER_NAME)));
			GB_ASSERT(found != NULL);
			type_info_member_data = *found;

			CheckerInfo *info = proc->module->info;

			// Useful types
			Type *t_i64_slice_ptr    = make_type_pointer(a, make_type_slice(a, t_i64));
			Type *t_string_slice_ptr = make_type_pointer(a, make_type_slice(a, t_string));

			i32 type_info_member_index = 0;

			for_array(type_info_map_index, info->type_info_map.entries) {
				MapIsizeEntry *entry = &info->type_info_map.entries.e[type_info_map_index];
				Type *t = cast(Type *)cast(uintptr)entry->key.key;
				t = default_type(t);
				isize entry_index = entry->value;

				llirValue *tag = NULL;

				switch (t->kind) {
				case Type_Named: {
					tag = llir_add_local_generated(proc, t_type_info_named);

					// TODO(bill): Which is better? The mangled name or actual name?
					llirValue *name = llir_make_const_string(a, t->Named.type_name->token.string);
					llirValue *gtip = llir_get_type_info_ptr(proc, type_info_data, t->Named.base);

					llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 0), name);
					llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 1), gtip);
				} break;

				case Type_Basic:
					switch (t->Basic.kind) {
					case Basic_bool:
						tag = llir_add_local_generated(proc, t_type_info_boolean);
						break;
					case Basic_i8:
					case Basic_u8:
					case Basic_i16:
					case Basic_u16:
					case Basic_i32:
					case Basic_u32:
					case Basic_i64:
					case Basic_u64:
					// case Basic_i128:
					// case Basic_u128:
					case Basic_int:
					case Basic_uint: {
						tag = llir_add_local_generated(proc, t_type_info_integer);
						bool is_unsigned = (t->Basic.flags & BasicFlag_Unsigned) != 0;
						llirValue *bits = llir_make_const_int(a, type_size_of(m->sizes, a, t));
						llirValue *is_signed = llir_make_const_bool(a, !is_unsigned);
						llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 0), bits);
						llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 1), is_signed);
					} break;

					// case Basic_f16:
					case Basic_f32:
					case Basic_f64:
					// case Basic_f128:
					{
						tag = llir_add_local_generated(proc, t_type_info_float);
						llirValue *bits = llir_make_const_int(a, type_size_of(m->sizes, a, t));
						llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 0), bits);
					} break;

					case Basic_rawptr:
						tag = llir_add_local_generated(proc, t_type_info_pointer);
						break;

					case Basic_string:
						tag = llir_add_local_generated(proc, t_type_info_string);
						break;

					case Basic_any:
						tag = llir_add_local_generated(proc, t_type_info_any);
						break;
					}
					break;

				case Type_Pointer: {
					tag = llir_add_local_generated(proc, t_type_info_pointer);
					llirValue *gep = llir_get_type_info_ptr(proc, type_info_data, t->Pointer.elem);
					llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 0), gep);
				} break;
				case Type_Maybe: {
					tag = llir_add_local_generated(proc, t_type_info_maybe);
					llirValue *gep = llir_get_type_info_ptr(proc, type_info_data, t->Maybe.elem);
					llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 0), gep);
				} break;
				case Type_Array: {
					tag = llir_add_local_generated(proc, t_type_info_array);
					llirValue *gep = llir_get_type_info_ptr(proc, type_info_data, t->Array.elem);
					llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 0), gep);

					isize ez = type_size_of(m->sizes, a, t->Array.elem);
					llirValue *elem_size = llir_emit_struct_ep(proc, tag, 1);
					llir_emit_store(proc, elem_size, llir_make_const_int(a, ez));

					llirValue *count = llir_emit_struct_ep(proc, tag, 2);
					llir_emit_store(proc, count, llir_make_const_int(a, t->Array.count));

				} break;
				case Type_Slice: {
					tag = llir_add_local_generated(proc, t_type_info_slice);
					llirValue *gep = llir_get_type_info_ptr(proc, type_info_data, t->Slice.elem);
					llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 0), gep);

					isize ez = type_size_of(m->sizes, a, t->Slice.elem);
					llirValue *elem_size = llir_emit_struct_ep(proc, tag, 1);
					llir_emit_store(proc, elem_size, llir_make_const_int(a, ez));

				} break;
				case Type_Vector: {
					tag = llir_add_local_generated(proc, t_type_info_vector);
					llirValue *gep = llir_get_type_info_ptr(proc, type_info_data, t->Vector.elem);
					llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 0), gep);

					isize ez = type_size_of(m->sizes, a, t->Vector.elem);
					llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 1), llir_make_const_int(a, ez));
					llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 2), llir_make_const_int(a, t->Vector.count));
					llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 3), llir_make_const_int(a, type_align_of(m->sizes, a, t)));

				} break;
				case Type_Record: {
					switch (t->Record.kind) {
					case TypeRecord_Struct: {
						tag = llir_add_local_generated(proc, t_type_info_struct);

						{
							llirValue *packed  = llir_make_const_bool(a, t->Record.struct_is_packed);
							llirValue *ordered = llir_make_const_bool(a, t->Record.struct_is_ordered);
							llirValue *size    = llir_make_const_int(a, type_size_of(m->sizes, a, t));
							llirValue *align   = llir_make_const_int(a, type_align_of(m->sizes, a, t));
							llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 1), size);
							llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 2), align);
							llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 3), packed);
							llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 4), ordered);
						}

						llirValue *memory = llir_type_info_member_offset(proc, type_info_member_data, t->Record.field_count, &type_info_member_index);

						type_set_offsets(m->sizes, a, t); // NOTE(bill): Just incase the offsets have not been set yet
						for (isize source_index = 0; source_index < t->Record.field_count; source_index++) {
							// TODO(bill): Order fields in source order not layout order
							Entity *f = t->Record.fields_in_src_order[source_index];
							llirValue *tip = llir_get_type_info_ptr(proc, type_info_data, f->type);
							i64 foffset = t->Record.struct_offsets[f->Variable.field_index];
							GB_ASSERT(f->kind == Entity_Variable && f->flags & EntityFlag_Field);

							llirValue *field     = llir_emit_ptr_offset(proc, memory, llir_make_const_int(a, source_index));
							llirValue *name      = llir_emit_struct_ep(proc, field, 0);
							llirValue *type_info = llir_emit_struct_ep(proc, field, 1);
							llirValue *offset    = llir_emit_struct_ep(proc, field, 2);

							if (f->token.string.len > 0) {
								llir_emit_store(proc, name, llir_make_const_string(a, f->token.string));
							}
							llir_emit_store(proc, type_info, tip);
							llir_emit_store(proc, offset, llir_make_const_int(a, foffset));
						}

						Type *slice_type = make_type_slice(a, t_type_info_member);
						Type *slice_type_ptr = make_type_pointer(a, slice_type);
						llirValue *slice = llir_emit_struct_ep(proc, tag, 0);
						llirValue *field_count = llir_make_const_int(a, t->Record.field_count);

						llirValue *elem = llir_emit_struct_ep(proc, slice, 0);
						llirValue *len  = llir_emit_struct_ep(proc, slice, 1);
						llirValue *cap  = llir_emit_struct_ep(proc, slice, 2);

						llir_emit_store(proc, elem, memory);
						llir_emit_store(proc, len, field_count);
						llir_emit_store(proc, cap, field_count);
					} break;
					case TypeRecord_Union:
						tag = llir_add_local_generated(proc, t_type_info_union);
						{
							llirValue *size    = llir_make_const_int(a, type_size_of(m->sizes, a, t));
							llirValue *align   = llir_make_const_int(a, type_align_of(m->sizes, a, t));
							llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 1),  size);
							llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 2),  align);
						}
						break;
					case TypeRecord_RawUnion: {
						tag = llir_add_local_generated(proc, t_type_info_raw_union);
						{
							llirValue *size    = llir_make_const_int(a, type_size_of(m->sizes, a, t));
							llirValue *align   = llir_make_const_int(a, type_align_of(m->sizes, a, t));
							llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 1),  size);
							llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 2),  align);
						}

						llirValue *memory = llir_type_info_member_offset(proc, type_info_member_data, t->Record.field_count, &type_info_member_index);

						for (isize i = 0; i < t->Record.field_count; i++) {
							llirValue *field     = llir_emit_ptr_offset(proc, memory, llir_make_const_int(a, i));
							llirValue *name      = llir_emit_struct_ep(proc, field, 0);
							llirValue *type_info = llir_emit_struct_ep(proc, field, 1);
							llirValue *offset    = llir_emit_struct_ep(proc, field, 2);

							Entity *f = t->Record.fields[i];
							llirValue *tip = llir_get_type_info_ptr(proc, type_info_data, f->type);

							if (f->token.string.len > 0) {
								llir_emit_store(proc, name, llir_make_const_string(a, f->token.string));
							}
							llir_emit_store(proc, type_info, tip);
							llir_emit_store(proc, offset, llir_make_const_int(a, 0));
						}

						Type *slice_type = make_type_slice(a, t_type_info_member);
						Type *slice_type_ptr = make_type_pointer(a, slice_type);
						llirValue *slice = llir_emit_struct_ep(proc, tag, 0);
						llirValue *field_count = llir_make_const_int(a, t->Record.field_count);

						llirValue *elem = llir_emit_struct_ep(proc, slice, 0);
						llirValue *len  = llir_emit_struct_ep(proc, slice, 1);
						llirValue *cap  = llir_emit_struct_ep(proc, slice, 2);

						llir_emit_store(proc, elem, memory);
						llir_emit_store(proc, len, field_count);
						llir_emit_store(proc, cap, field_count);
					} break;
					case TypeRecord_Enum:
						tag = llir_add_local_generated(proc, t_type_info_enum);
						{
							GB_ASSERT(t->Record.enum_base_type != NULL);
							llirValue *base = llir_type_info(proc, t->Record.enum_base_type);
							llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 0), base);

							if (t->Record.field_count > 0) {
								Entity **fields = t->Record.fields;
								isize count = t->Record.field_count;
								llirValue *name_array = NULL;

								{
									Token token = {Token_Ident};
									i32 id = cast(i32)entry_index;
									char name_base[] = "__$enum_names";
									isize name_len = gb_size_of(name_base) + 10;
									token.string.text = gb_alloc_array(a, u8, name_len);
									token.string.len = gb_snprintf(cast(char *)token.string.text, name_len,
									                               "%s-%d", name_base, id)-1;
									Entity *e = make_entity_variable(a, NULL, token, make_type_array(a, t_string, count));
									name_array = llir_make_value_global(a, e, NULL);
									name_array->Global.is_private = true;
									llir_module_add_value(m, e, name_array);
									map_llir_value_set(&m->members, hash_string(token.string), name_array);
								}

								for (isize i = 0; i < count; i++) {
									llirValue *name_ep = llir_emit_array_epi(proc, name_array, i);
									llir_emit_store(proc, name_ep, llir_make_const_string(a, fields[i]->token.string));
								}

								llirValue *v_count = llir_make_const_int(a, count);

								llirValue *names = llir_emit_struct_ep(proc, tag, 1);
								llirValue *name_array_elem = llir_array_elem(proc, name_array);

								llir_emit_store(proc, llir_emit_struct_ep(proc, names, 0), name_array_elem);
								llir_emit_store(proc, llir_emit_struct_ep(proc, names, 1), v_count);
								llir_emit_store(proc, llir_emit_struct_ep(proc, names, 2), v_count);
							}
						}
						break;
					}
				} break;

				case Type_Tuple: {
					tag = llir_add_local_generated(proc, t_type_info_tuple);

					{
						llirValue *align = llir_make_const_int(a, type_align_of(m->sizes, a, t));
						llir_emit_store(proc, llir_emit_struct_ep(proc, tag, 2), align);
					}

					llirValue *memory = llir_type_info_member_offset(proc, type_info_member_data, t->Tuple.variable_count, &type_info_member_index);

					for (isize i = 0; i < t->Tuple.variable_count; i++) {
						llirValue *field     = llir_emit_ptr_offset(proc, memory, llir_make_const_int(a, i));
						llirValue *name      = llir_emit_struct_ep(proc, field, 0);
						llirValue *type_info = llir_emit_struct_ep(proc, field, 1);
						// NOTE(bill): offset is not used for tuples

						Entity *f = t->Tuple.variables[i];
						llirValue *tip = llir_get_type_info_ptr(proc, type_info_data, f->type);

						if (f->token.string.len > 0) {
							llir_emit_store(proc, name, llir_make_const_string(a, f->token.string));
						}
						llir_emit_store(proc, type_info, tip);
					}

					Type *slice_type = make_type_slice(a, t_type_info_member);
					Type *slice_type_ptr = make_type_pointer(a, slice_type);
					llirValue *slice = llir_emit_struct_ep(proc, tag, 0);
					llirValue *variable_count = llir_make_const_int(a, t->Tuple.variable_count);

					llirValue *elem = llir_emit_struct_ep(proc, slice, 0);
					llirValue *len  = llir_emit_struct_ep(proc, slice, 1);
					llirValue *cap  = llir_emit_struct_ep(proc, slice, 2);

					llir_emit_store(proc, elem, memory);
					llir_emit_store(proc, len, variable_count);
					llir_emit_store(proc, cap, variable_count);
				} break;

				case Type_Proc: {
					tag = llir_add_local_generated(proc, t_type_info_procedure);

					llirValue *params   = llir_emit_struct_ep(proc, tag, 0);
					llirValue *results  = llir_emit_struct_ep(proc, tag, 1);
					llirValue *variadic = llir_emit_struct_ep(proc, tag, 2);

					if (t->Proc.params) {
						llir_emit_store(proc, params, llir_get_type_info_ptr(proc, type_info_data, t->Proc.params));
					}
					if (t->Proc.results) {
						llir_emit_store(proc, results, llir_get_type_info_ptr(proc, type_info_data, t->Proc.results));
					}
					llir_emit_store(proc, variadic, llir_make_const_bool(a, t->Proc.variadic));

					// TODO(bill): Type_Info for procedures
				} break;
				}

				if (tag != NULL) {
					llirValue *gep = llir_emit_array_epi(proc, type_info_data, entry_index);
					llirValue *val = llir_emit_conv(proc, llir_emit_load(proc, tag), t_type_info);
					llir_emit_store(proc, gep, val);
				}
			}
		}

		llir_end_procedure_body(proc);
	}

	for_array(i, m->procs_to_generate) {
		llir_build_proc(m->procs_to_generate.e[i], m->procs_to_generate.e[i]->Proc.parent);
	}


	// m->layout = str_lit("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64");
}