Delete ir.cpp and related files

1 files changed, 0 insertions, 13167 deletions

diff --git a/src/ir.cpp b/src/ir.cpp
deleted file mode 100644
index bd3c0409c..000000000
--- a/src/ir.cpp
+++ /dev/null
@@ -1,13167 +0,0 @@
-struct irProcedure;
-struct irBlock;
-struct irValue;
-struct irDebugInfo;
-
-
-
-struct irModule {
-	CheckerInfo * info;
-	gbArena       tmp_arena;
-	// gbAllocator   allocator;
-	gbAllocator   tmp_allocator;
-	bool generate_debug_info;
-
-	u64 state_flags;
-
-	// String source_filename;
-	// String layout;
-	// String triple;
-
-	PtrSet<Entity *>      min_dep_set;
-	Map<irValue *>        values;              // Key: Entity *
-	StringMap<irValue *>  members;
-	Map<String>           entity_names;        // Key: Entity * of the typename
-	Map<irDebugInfo *>    debug_info;          // Key: Unique pointer
-	Map<irValue *>        anonymous_proc_lits; // Key: Ast *
-
-	Map<irValue *>        equal_procs;  // Key: Type *
-	Map<irValue *>        hasher_procs; // Key: Type *
-
-	irDebugInfo *         debug_compile_unit;
-	Array<irDebugInfo *>  debug_location_stack;
-
-
-	i32                   global_string_index;
-	i32                   global_array_index; // For ConstantSlice
-	i32                   global_generated_index;
-
-	// NOTE(bill): To prevent strings from being copied a lot
-	// Mainly used for file names
-	StringMap<irValue *>  const_strings;
-	StringMap<irValue *>  const_string_byte_slices;
-	Map<irValue *>        constant_value_to_global; // Key: irValue *
-
-
-	Entity *              entry_point_entity;
-
-	Array<irProcedure *>  procs;             // NOTE(bill): All procedures with bodies
-	Array<irValue *>      procs_to_generate; // NOTE(bill): Procedures to generate
-
-	Array<String>         foreign_library_paths; // Only the ones that were used
-};
-
-// NOTE(bill): For more info, see https://en.wikipedia.org/wiki/Dominator_(graph_theory)
-struct irDomNode {
-	irBlock *        idom; // Parent (Immediate Dominator)
-	Array<irBlock *> children;
-	i32              pre, post; // Ordering in tree
-};
-
-
-struct irBlock {
-	i32          index;
-	String       label;
-	irProcedure *proc;
-	Ast *    node; // Can be nullptr
-	Scope *      scope;
-	isize        scope_index;
-	irDomNode    dom;
-	i32          gaps;
-
-	Array<irValue *> instrs;
-	Array<irValue *> locals;
-
-	Array<irBlock *> preds;
-	Array<irBlock *> succs;
-};
-
-struct irTargetList {
-	irTargetList *prev;
-	bool          is_block;
-	irBlock *     break_;
-	irBlock *     continue_;
-	irBlock *     fallthrough_;
-};
-
-enum irDeferExitKind {
-	irDeferExit_Default,
-	irDeferExit_Return,
-	irDeferExit_Branch,
-};
-enum irDeferKind {
-	irDefer_Node,
-	irDefer_Instr,
-	irDefer_Proc,
-};
-
-struct irDefer {
-	irDeferKind kind;
-	isize       scope_index;
-	isize       context_stack_count;
-	irBlock *   block;
-	union {
-		Ast *stmt;
-		// NOTE(bill): 'instr' will be copied every time to create a new one
-		irValue *instr;
-		struct {
-			irValue *deferred;
-			Array<irValue *> result_as_args;
-		} proc;
-	};
-};
-
-
-struct irBranchBlocks {
-	Ast *label;
-	irBlock *break_;
-	irBlock *continue_;
-};
-
-
-struct irContextData {
-	irValue *value;
-	isize scope_index;
-};
-
-struct irProcedure {
-	irProcedure *         parent;
-	Array<irProcedure *>  children;
-
-	Entity *              entity;
-	irModule *            module;
-	String                name;
-	Type *                type;
-	Ast *                 proc_lit; // only for actual anonymous procedure literals
-	Ast *                 type_expr;
-	Ast *                 body;
-	u64                   tags;
-	ProcInlining          inlining;
-	bool                  is_foreign;
-	bool                  is_export;
-	bool                  is_entry_point;
-	bool                  is_startup;
-
-	irDebugInfo *         debug_scope;
-
-	irValue *             return_ptr;
-	Array<irValue *>      params;
-	Array<irDefer>        defer_stmts;
-	Array<irBlock *>      blocks;
-	i32                   scope_index;
-	irBlock *             decl_block;
-	irBlock *             entry_block;
-	irBlock *             curr_block;
-	irTargetList *        target_list;
-	Array<irValue *>      referrers;
-
-	Ast *curr_stmt;
-
-	Array<irContextData>  context_stack;
-
-	i32      parameter_count;
-
-	irValue *return_ptr_hint_value;
-	Ast *    return_ptr_hint_ast;
-	bool     return_ptr_hint_used;
-
-	bool ignore_dead_instr;
-
-	Array<irBranchBlocks> branch_blocks;
-
-	i32                   local_count;
-	i32                   instr_count;
-	i32                   block_count;
-};
-
-
-gb_global Arena global_ir_arena = {};
-gbAllocator ir_allocator(void) {
-	Arena *arena = &global_ir_arena;
-	return arena_allocator(arena);
-}
-
-
-#define IR_STARTUP_TYPE_INFO_PROC_NAME "__$startup_type_info"
-#define IR_STARTUP_RUNTIME_PROC_NAME "__$startup_runtime"
-#define IR_TYPE_INFO_DATA_NAME       "__$type_info_data"
-#define IR_TYPE_INFO_TYPES_NAME      "__$type_info_types_data"
-#define IR_TYPE_INFO_NAMES_NAME      "__$type_info_names_data"
-#define IR_TYPE_INFO_OFFSETS_NAME    "__$type_info_offsets_data"
-#define IR_TYPE_INFO_USINGS_NAME     "__$type_info_usings_data"
-#define IR_TYPE_INFO_TAGS_NAME       "__$type_info_tags_data"
-
-
-#define IR_INSTR_KINDS \
-	IR_INSTR_KIND(Comment, struct { String text; })                   \
-	IR_INSTR_KIND(Local,   struct {                                   \
-		Entity *     entity;                                          \
-		Type *       type;                                            \
-		bool         zero_initialized;                                \
-		Array<irValue *> referrers;                                   \
-		i64          alignment;                                       \
-	})                                                                \
-	IR_INSTR_KIND(ZeroInit, struct { irValue *address; })             \
-	IR_INSTR_KIND(Store,    struct { irValue *address, *value; bool is_volatile; }) \
-	IR_INSTR_KIND(Load,     struct { Type *type; irValue *address; i64 custom_align; bool is_volatile; }) \
-	IR_INSTR_KIND(InlineCode, struct { BuiltinProcId id; Array<irValue *> operands; Type *type; }) \
-	IR_INSTR_KIND(AtomicFence, struct { BuiltinProcId id; })          \
-	IR_INSTR_KIND(AtomicStore, struct {                               \
-		irValue *address, *value;                                     \
-		BuiltinProcId id;                                             \
-	})                                                                \
-	IR_INSTR_KIND(AtomicLoad, struct {                                \
-		Type *type; irValue *address;                                 \
-		BuiltinProcId id;                                             \
-	})                                                                \
-	IR_INSTR_KIND(AtomicRmw, struct {                                 \
-		Type *type; irValue *address;                                 \
-		irValue *value;                                               \
-		BuiltinProcId id;                                             \
-	})                                                                \
-	IR_INSTR_KIND(AtomicCxchg, struct {                               \
-		Type *type; irValue *address;                                 \
-		irValue *old_value; irValue *new_value;                       \
-		BuiltinProcId id;                                             \
-	})                                                                \
-	IR_INSTR_KIND(PtrOffset, struct {                                 \
-		irValue *address;                                             \
-		irValue *offset;                                              \
-	})                                                                \
-	IR_INSTR_KIND(ArrayElementPtr, struct {                           \
-		irValue *address;                                             \
-		Type *   result_type;                                         \
-		irValue *elem_index;                                          \
-	})                                                                \
-	IR_INSTR_KIND(StructElementPtr, struct {                          \
-		irValue *address;                                             \
-		Type *    result_type;                                        \
-		i32       elem_index;                                         \
-	})                                                                \
-	IR_INSTR_KIND(StructExtractValue, struct {                        \
-		irValue *address;                                             \
-		Type *    result_type;                                        \
-		i32       index;                                              \
-	})                                                                \
-	IR_INSTR_KIND(UnionTagPtr, struct {                               \
-		irValue *address;                                             \
-		Type     *type; /* ^int */                                    \
-	})                                                                \
-	IR_INSTR_KIND(UnionTagValue, struct {                             \
-		irValue *address;                                             \
-		Type     *type; /* int */                                     \
-	})                                                                \
-	IR_INSTR_KIND(Conv, struct {                                      \
-		irConvKind kind;                                              \
-		irValue *value;                                               \
-		Type *from, *to;                                              \
-	})                                                                \
-	IR_INSTR_KIND(Jump, struct { irBlock *block; })                   \
-	IR_INSTR_KIND(If, struct {                                        \
-		irValue *cond;                                                \
-		irBlock *true_block;                                          \
-		irBlock *false_block;                                         \
-	})                                                                \
-	IR_INSTR_KIND(Return, struct { irValue *value; })                 \
-	IR_INSTR_KIND(Select, struct {                                    \
-		irValue *cond;                                                \
-		irValue *true_value;                                          \
-		irValue *false_value;                                         \
-	})                                                                \
-	IR_INSTR_KIND(Phi, struct { Array<irValue *> edges; Type *type; })\
-	IR_INSTR_KIND(Unreachable, i32)                                   \
-	IR_INSTR_KIND(UnaryOp, struct {                                   \
-		Type *    type;                                               \
-		TokenKind op;                                                 \
-		irValue * expr;                                               \
-	})                                                                \
-	IR_INSTR_KIND(BinaryOp, struct {                                  \
-		Type *    type;                                               \
-		TokenKind op;                                                 \
-		irValue * left, *right;                                       \
-	})                                                                \
-	IR_INSTR_KIND(Call, struct {                                      \
-		Type *    type; /* return type */                             \
-		irValue * value;                                              \
-		irValue * return_ptr;                                         \
-		Array<irValue *> args;                                        \
-		irValue * context_ptr;                                        \
-		ProcInlining inlining;                                        \
-	})                                                                \
-	IR_INSTR_KIND(StartupRuntime, i32)                                \
-	IR_INSTR_KIND(DebugDeclare, struct {                              \
-		Ast *        expr;                                            \
-		Entity *     entity;                                          \
-		bool         is_addr;                                         \
-		irValue *    value;                                           \
-	})                                                                \
-
-// 	IR_INSTR_KIND(BoundsCheck, struct {                               \
-// 		TokenPos pos;                                                 \
-// 		irValue *index;                                               \
-// 		irValue *len;                                                 \
-// 	})                                                                \
-// 	IR_INSTR_KIND(SliceBoundsCheck, struct {                          \
-// 		TokenPos pos;                                                 \
-// 		irValue *low;                                                 \
-// 		irValue *high;                                                \
-// 		irValue *max;                                                 \
-// 		bool     is_substring;                                        \
-// 	})                                                                \
-
-
-#define IR_CONV_KINDS \
-	IR_CONV_KIND(trunc) \
-	IR_CONV_KIND(zext) \
-	IR_CONV_KIND(sext) \
-	IR_CONV_KIND(fptrunc) \
-	IR_CONV_KIND(fpext) \
-	IR_CONV_KIND(fptoui) \
-	IR_CONV_KIND(fptosi) \
-	IR_CONV_KIND(uitofp) \
-	IR_CONV_KIND(sitofp) \
-	IR_CONV_KIND(ptrtoint) \
-	IR_CONV_KIND(inttoptr) \
-	IR_CONV_KIND(bitcast) \
-	IR_CONV_KIND(byteswap)
-/*
-	Odin specifc conversion
-	byteswap - swap bytes for endian change
-*/
-
-
-enum irInstrKind {
-	irInstr_Invalid,
-#define IR_INSTR_KIND(x, ...) GB_JOIN2(irInstr_, x),
-	IR_INSTR_KINDS
-#undef IR_INSTR_KIND
-};
-
-String const ir_instr_strings[] = {
-	{cast(u8 *)"Invalid", gb_size_of("Invalid")-1},
-#define IR_INSTR_KIND(x, ...) {cast(u8 *)#x, gb_size_of(#x)-1},
-	IR_INSTR_KINDS
-#undef IR_INSTR_KIND
-};
-
-enum irConvKind {
-	irConv_Invalid,
-#define IR_CONV_KIND(x) GB_JOIN2(irConv_, x),
-	IR_CONV_KINDS
-#undef IR_CONV_KIND
-};
-
-String const ir_conv_strings[] = {
-	{cast(u8 *)"Invalid", gb_size_of("Invalid")-1},
-#define IR_CONV_KIND(x) {cast(u8 *)#x, gb_size_of(#x)-1},
-	IR_CONV_KINDS
-#undef IR_CONV_KIND
-};
-
-#define IR_INSTR_KIND(k, ...) typedef __VA_ARGS__ GB_JOIN2(irInstr, k);
-	IR_INSTR_KINDS
-#undef IR_INSTR_KIND
-
-struct irInstr {
-	irInstrKind kind;
-
-	irBlock *block;
-	Type *type;
-
-	union {
-#define IR_INSTR_KIND(k, ...) GB_JOIN2(irInstr, k) k;
-	IR_INSTR_KINDS
-#undef IR_INSTR_KIND
-	};
-};
-
-
-enum irValueKind {
-	irValue_Invalid,
-
-	irValue_Constant,
-	irValue_ConstantSlice,
-	irValue_Nil,
-	irValue_Undef,
-	irValue_TypeName,
-	irValue_Global,
-	irValue_Param,
-	irValue_SourceCodeLocation,
-
-	irValue_Proc,
-	irValue_Block,
-	irValue_Instr,
-
-	irValue_Count,
-};
-
-struct irValueConstant {
-	Type *     type;
-	ExactValue value;
-};
-
-struct irValueConstantSlice {
-	Type *    type;
-	irValue *backing_array;
-	i64       count;
-};
-
-struct irValueNil {
-	Type *type;
-};
-
-struct irValueUndef {
-	Type *type;
-};
-
-struct irValueTypeName {
-	Type * type;
-	String name;
-};
-
-struct irValueGlobal {
-	String        name;
-	Entity *      entity;
-	Type *        type;
-	irValue *     value;
-	Array<irValue *>  referrers;
-	bool          is_constant;
-	bool          is_export;
-	bool          is_private;
-	bool          is_internal;
-	String        thread_local_model;
-	bool          is_foreign;
-	bool          is_unnamed_addr;
-};
-
-
-enum irParamPasskind {
-	irParamPass_Value,    // Pass by value
-	irParamPass_Pointer,  // Pass as a pointer rather than by value
-	irParamPass_Integer,  // Pass as an integer of the same size
-	irParamPass_ConstRef, // Pass as a pointer but the value is immutable
-	irParamPass_BitCast,  // Pass by value and bit cast to the correct type
-	irParamPass_Tuple,    // Pass across multiple parameters (System V AMD64, up to 2)
-};
-
-struct irValueParam {
-	irParamPasskind  kind;
-	irProcedure *    parent;
-	Entity *         entity;
-	Type *           type;
-	Type *           original_type;
-	i32              index;
-	Array<irValue *> referrers;
-};
-
-struct irValueSourceCodeLocation {
-	irValue *file;
-	irValue *line;
-	irValue *column;
-	irValue *procedure;
-};
-
-
-struct irValue {
-	irValueKind     kind;
-	i32             index;
-	bool            index_set;
-	irDebugInfo *   loc;
-	isize           uses;
-	union {
-		irValueConstant      Constant;
-		irValueConstantSlice ConstantSlice;
-		irValueNil           Nil;
-		irValueUndef         Undef;
-		irValueTypeName      TypeName;
-		irValueGlobal        Global;
-		irValueParam         Param;
-		irProcedure          Proc;
-		irBlock              Block;
-		irInstr              Instr;
-		irValueSourceCodeLocation SourceCodeLocation;
-	};
-};
-
-gb_global irValue *v_zero    = nullptr;
-gb_global irValue *v_one     = nullptr;
-gb_global irValue *v_zero32  = nullptr;
-gb_global irValue *v_one32   = nullptr;
-gb_global irValue *v_two32   = nullptr;
-gb_global irValue *v_false   = nullptr;
-gb_global irValue *v_true    = nullptr;
-gb_global irValue *v_raw_nil = nullptr;
-
-enum irAddrKind {
-	irAddr_Default,
-	irAddr_Map,
-	irAddr_Context,
-	irAddr_SoaVariable,
-	irAddr_RelativePointer,
-	irAddr_RelativeSlice,
-};
-
-struct irAddr {
-	irAddrKind kind;
-	irValue *  addr;
-	union {
-		struct {
-			irValue *map_key;
-			Type *   map_type;
-			Type *   map_result;
-		};
-		struct {
-			i32      bit_field_value_index;
-		};
-		struct {
-			Selection sel;
-		} ctx;
-		struct {
-			irValue *index;
-			Ast *index_expr;
-		} soa;
-		struct {
-			bool deref;
-		} relative;
-	};
-};
-
-Type *ir_type(irValue *value);
-irValue *ir_gen_anonymous_proc_lit(irModule *m, String prefix_name, Ast *expr, irProcedure *proc = nullptr);
-void ir_begin_procedure_body(irProcedure *proc);
-void ir_end_procedure_body(irProcedure *proc);
-irValue *ir_get_equal_proc_for_type(irModule *m, Type *type);
-irValue *ir_get_hasher_proc_for_type(irModule *m, Type *type);
-
-
-irAddr ir_addr(irValue *addr) {
-	irAddr v = {irAddr_Default, addr};
-	if (addr != nullptr && is_type_relative_pointer(type_deref(ir_type(addr)))) {
-		GB_ASSERT(is_type_pointer(ir_type(addr)));
-		v.kind = irAddr_RelativePointer;
-	} else if (addr != nullptr && is_type_relative_slice(type_deref(ir_type(addr)))) {
-		GB_ASSERT(is_type_pointer(ir_type(addr)));
-		v.kind = irAddr_RelativeSlice;
-	}
-	return v;
-}
-
-irAddr ir_addr_map(irValue *addr, irValue *map_key, Type *map_type, Type *map_result) {
-	irAddr v = {irAddr_Map, addr};
-	v.map_key    = map_key;
-	v.map_type   = map_type;
-	v.map_result = map_result;
-	return v;
-}
-
-
-irAddr ir_addr_context(irValue *addr, Selection sel = empty_selection) {
-	irAddr v = {irAddr_Context, addr};
-	v.ctx.sel = sel;
-	return v;
-}
-
-
-irAddr ir_addr_soa_variable(irValue *addr, irValue *index, Ast *index_expr) {
-	irAddr v = {irAddr_SoaVariable, addr};
-	v.soa.index = index;
-	v.soa.index_expr = index_expr;
-	return v;
-}
-
-
-enum irDebugEncoding {
-	irDebugBasicEncoding_Invalid       = 0,
-
-	irDebugBasicEncoding_address       = 1,
-	irDebugBasicEncoding_boolean       = 2,
-	irDebugBasicEncoding_float         = 3,
-	irDebugBasicEncoding_signed        = 4,
-	irDebugBasicEncoding_signed_char   = 5,
-	irDebugBasicEncoding_unsigned      = 6,
-	irDebugBasicEncoding_unsigned_char = 7,
-
-	// TODO(lachsinc): Should the following be renamed from basic -> tag to mirror their DW_TAG_*
-	// counterparts? Perhaps separate out if they truly have different meaning.
-
-	irDebugBasicEncoding_member       = 13,
-	irDebugBasicEncoding_pointer_type = 15,
-	irDebugBasicEncoding_typedef      = 22,
-
-	irDebugBasicEncoding_array_type       = 1,
-	irDebugBasicEncoding_enumeration_type = 4,
-	irDebugBasicEncoding_structure_type   = 19,
-	irDebugBasicEncoding_union_type       = 23,
-};
-
-enum irDebugInfoFlags {
-	irDebugInfoFlag_Bitfield = (1 << 19),
-};
-
-enum irDebugInfoKind {
-	irDebugInfo_Invalid,
-
-	irDebugInfo_CompileUnit,
-	irDebugInfo_File,
-	irDebugInfo_Proc,
-	irDebugInfo_ProcType,
-	irDebugInfo_Location,
-	irDebugInfo_LexicalBlock,
-	irDebugInfo_AllProcs,
-
-	irDebugInfo_BasicType,      // primitive types
-	irDebugInfo_DerivedType,    // pointer, distinct etc.
-	irDebugInfo_CompositeType,  // array, struct, enum, union etc.
-	irDebugInfo_Enumerator,     // For irDebugInfo_CompositeType if enum
-	irDebugInfo_GlobalVariableExpression, // used to describe if global is const or not
-	irDebugInfo_GlobalVariable,
-	irDebugInfo_LocalVariable,
-
-	irDebugInfo_DebugInfoArray, // array of irDebugInfo *'s
-
-	irDebugInfo_Count,
-};
-
-struct irDebugInfo {
-	irDebugInfoKind kind;
-	i32 id;
-
-	union {
-		struct {
-			AstFile *    file;
-			String       producer;
-			irDebugInfo *enums;   // DebugInfoArray
-			irDebugInfo *globals; // DebugInfoArray
-		} CompileUnit;
-		struct {
-			AstFile *file;
-			String   filename;
-			String   directory;
-		} File;
-		struct {
-			Entity *      entity;
-			String        name;
-			irDebugInfo * file;
-			TokenPos      pos;
-			irDebugInfo * type;
-			// TODO(lachsinc): variables / retainedNodes ?
-		} Proc;
-		struct {
-			irDebugInfo * types; // !{return, return, param, param, param.. etc.}
-		} ProcType;
-		struct {
-			TokenPos     pos;
-			irDebugInfo *scope;
-		} Location;
-		struct {
-			TokenPos     pos;
-			irDebugInfo *file;
-			irDebugInfo *scope;
-		} LexicalBlock;
-
-		struct {
-			Type *          type;
-			String          name;
-			i32             size;
-			i32             align;
-			irDebugEncoding encoding;
-		} BasicType;
-		struct {
-			Type *           type;
-			irDebugEncoding  tag;
-			irDebugInfo *    base_type;
-			String           name;
-			irDebugInfo *    scope;
-			irDebugInfo *    file;
-			TokenPos         pos;
-			i32              size;
-			i32              align;
-			i32              offset;
-			irDebugInfoFlags flags; // Used only for DIFlagBitField.
-		} DerivedType;
-		struct {
-			irDebugEncoding tag;
-			String          name;
-			irDebugInfo *   scope;
-			irDebugInfo *   file;
-			TokenPos        pos;
-			irDebugInfo *   base_type; // optional, used for enumeration_type.
-			i32             size;
-			i32             align;
-			irDebugInfo *   elements;
-			i32             array_count; // for DISubrange
-		} CompositeType;
-		struct {
-			String name;
-			i64    value;
-		} Enumerator;
-		struct {
-			irDebugInfo *var;
-		} GlobalVariableExpression;
-		struct {
-			String       name;
-			String       linkage_name;
-			irDebugInfo *scope;
-			irDebugInfo *file;
-			TokenPos     pos;
-			irDebugInfo *type;
-			irValue     *variable;
-		} GlobalVariable;
-		struct {
-			String       name;
-			irDebugInfo *scope;
-			irDebugInfo *file;
-			TokenPos     pos;
-			i32          arg; // Non-zero if proc parameter
-			irDebugInfo *type;
-		} LocalVariable;
-		struct {
-			Array<irDebugInfo *> elements; // TODO(lachsinc): Leak?
-		} DebugInfoArray;
-	};
-};
-
-static irDebugInfo IR_DEBUG_INFO_EMPTY = {};
-
-
-struct irGen {
-	irModule module;
-	gbFile   output_file;
-	bool     opt_called;
-	String   output_base;
-	String   output_name;
-	bool     print_chkstk;
-};
-
-
-
-
-gb_inline bool ir_min_dep_entity(irModule *m, Entity *e) {
-	return ptr_set_exists(&m->min_dep_set, e);
-}
-
-Type *ir_instr_type(irInstr *instr) {
-	switch (instr->kind) {
-	case irInstr_InlineCode:
-		return instr->InlineCode.type;
-	case irInstr_Local:
-		return instr->Local.type;
-	case irInstr_Load:
-		return instr->Load.type;
-	case irInstr_AtomicLoad:
-		return instr->AtomicLoad.type;
-	case irInstr_AtomicRmw:
-		return instr->AtomicRmw.type;
-	case irInstr_AtomicCxchg:
-		return instr->AtomicCxchg.type;
-	case irInstr_StructElementPtr:
-		return instr->StructElementPtr.result_type;
-	case irInstr_ArrayElementPtr:
-		return instr->ArrayElementPtr.result_type;
-	case irInstr_PtrOffset:
-		return ir_type(instr->PtrOffset.address);
-	case irInstr_Phi:
-		return instr->Phi.type;
-	case irInstr_StructExtractValue:
-		return instr->StructExtractValue.result_type;
-	case irInstr_UnionTagPtr:
-		return instr->UnionTagPtr.type;
-	case irInstr_UnionTagValue:
-		return instr->UnionTagValue.type;
-	case irInstr_UnaryOp:
-		return instr->UnaryOp.type;
-	case irInstr_BinaryOp:
-		return instr->BinaryOp.type;
-	case irInstr_Conv:
-		return instr->Conv.to;
-	case irInstr_Select:
-		return ir_type(instr->Select.true_value);
-	case irInstr_Call: {
-		Type *pt = base_type(instr->Call.type);
-		if (pt != nullptr) {
-			if (pt->kind == Type_Tuple && pt->Tuple.variables.count == 1) {
-				return pt->Tuple.variables[0]->type;
-			}
-			return pt;
-		}
-		return nullptr;
-	}
-	}
-	return nullptr;
-}
-
-Type *ir_type(irValue *value) {
-	if (value == nullptr) {
-		return nullptr;
-	}
-	switch (value->kind) {
-	case irValue_Constant:
-		return value->Constant.type;
-	case irValue_ConstantSlice:
-		return value->ConstantSlice.type;
-	case irValue_Nil:
-		return value->Nil.type;
-	case irValue_Undef:
-		return value->Undef.type;
-	case irValue_TypeName:
-		return value->TypeName.type;
-	case irValue_Global:
-		return value->Global.type;
-	case irValue_Param:
-		return value->Param.type;
-	case irValue_SourceCodeLocation:
-		return t_source_code_location;
-	case irValue_Proc:
-		return value->Proc.type;
-	case irValue_Instr:
-		return ir_instr_type(&value->Instr);
-	}
-	return nullptr;
-}
-
-
-
-irInstr *ir_get_last_instr(irBlock *block) {
-	if (block != nullptr) {
-		isize len = block->instrs.count;
-		if (len > 0) {
-			irValue *v = block->instrs[len-1];
-			GB_ASSERT(v->kind == irValue_Instr);
-			return &v->Instr;
-		}
-	}
-	return nullptr;
-
-}
-
-bool ir_is_instr_terminating(irInstr *i) {
-	if (i != nullptr) {
-		switch (i->kind) {
-		case irInstr_Return:
-		case irInstr_Unreachable:
-			return true;
-		}
-	}
-
-	return false;
-}
-
-
-void ir_add_edge(irBlock *from, irBlock *to) {
-	GB_ASSERT(from->instrs.count > 0);
-	if (!ir_is_instr_terminating(ir_get_last_instr(from))) {
-		array_add(&from->succs, to);
-		array_add(&to->preds, from);
-	}
-}
-
-void ir_set_instr_block(irValue *instr, irBlock *block) {
-	if (instr->kind == irValue_Instr) {
-		instr->Instr.block = block;
-	}
-}
-
-Array<irValue *> *ir_value_referrers(irValue *v) {
-	switch (v->kind) {
-	case irValue_Global:
-		return &v->Global.referrers;
-	case irValue_Param:
-		return &v->Param.referrers;
-	case irValue_Proc: {
-		if (v->Proc.parent != nullptr) {
-			return &v->Proc.referrers;
-		}
-		return nullptr;
-	}
-	case irValue_Instr: {
-		irInstr *i = &v->Instr;
-		switch (i->kind) {
-		case irInstr_Local:
-			return &i->Local.referrers;
-		}
-		break;
-	}
-	}
-
-	return nullptr;
-}
-
-
-
-////////////////////////////////////////////////////////////////
-//
-// @Make
-//
-////////////////////////////////////////////////////////////////
-
-void     ir_module_add_value    (irModule *m, Entity *e, irValue *v);
-irValue *ir_emit_zero_init      (irProcedure *p, irValue *address, Ast *expr);
-irValue *ir_emit_comment        (irProcedure *p, String text);
-irValue *ir_emit_store          (irProcedure *p, irValue *address, irValue *value, bool is_volatile=false);
-irValue *ir_emit_load           (irProcedure *p, irValue *address, i64 custom_align=0);
-void     ir_emit_jump           (irProcedure *proc, irBlock *block);
-irValue *ir_emit_conv           (irProcedure *proc, irValue *value, Type *t);
-irValue *ir_type_info           (irProcedure *proc, Type *type);
-irValue *ir_typeid              (irModule *m, Type *type);
-irValue *ir_build_expr          (irProcedure *proc, Ast *expr);
-void     ir_build_stmt          (irProcedure *proc, Ast *node);
-irValue *ir_build_cond          (irProcedure *proc, Ast *cond, irBlock *true_block, irBlock *false_block);
-void     ir_build_defer_stmt    (irProcedure *proc, irDefer d);
-irAddr   ir_build_addr          (irProcedure *proc, Ast *expr);
-void     ir_build_proc          (irValue *value, irProcedure *parent);
-void     ir_gen_global_type_name(irModule *m, Entity *e, String name);
-irValue *ir_get_type_info_ptr   (irProcedure *proc, Type *type);
-void     ir_value_set_debug_location(irProcedure *proc, irValue *v);
-void     ir_push_debug_location (irModule *m, Ast *node, irDebugInfo *scope, Entity *e=nullptr);
-void     ir_pop_debug_location  (irModule *m);
-irDebugInfo *ir_add_debug_info_local(irProcedure *proc, Entity *e, i32 arg_id);
-irDebugInfo *ir_add_debug_info_file(irModule *module, AstFile *file);
-irDebugInfo *ir_add_debug_info_proc(irProcedure *proc);
-void ir_emit_increment(irProcedure *proc, irValue *addr);
-irValue *ir_emit_array_ep(irProcedure *proc, irValue *s, irValue *index);
-irValue *ir_emit_array_epi(irProcedure *proc, irValue *s, i32 index);
-irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index);
-irValue *ir_emit_bitcast(irProcedure *proc, irValue *data, Type *type);
-irValue *ir_emit_byte_swap(irProcedure *proc, irValue *value, Type *t);
-irValue *ir_find_or_add_entity_string(irModule *m, String str);
-irValue *ir_find_or_add_entity_string_byte_slice(irModule *m, String str);
-irValue *ir_slice_elem(irProcedure *proc, irValue *slice);
-irValue *ir_slice_len(irProcedure *proc, irValue *slice);
-void ir_fill_slice(irProcedure *proc, irValue *slice_ptr, irValue *data, irValue *len);
-
-
-irValue *ir_alloc_value(irValueKind kind) {
-	irValue *v = gb_alloc_item(ir_allocator(), irValue);
-	v->kind = kind;
-	return v;
-}
-irValue *ir_alloc_instr(irProcedure *proc, irInstrKind kind) {
-	irValue *v = ir_alloc_value(irValue_Instr);
-	v->Instr.kind = kind;
-	proc->instr_count++;
-	return v;
-}
-irDebugInfo *ir_alloc_debug_info(irDebugInfoKind kind) {
-	irDebugInfo *di = gb_alloc_item(ir_allocator(), irDebugInfo);
-	di->kind = kind;
-	return di;
-}
-
-
-
-
-irValue *ir_value_type_name(String name, Type *type) {
-	irValue *v = ir_alloc_value(irValue_TypeName);
-	v->TypeName.name = name;
-	v->TypeName.type = type;
-	return v;
-}
-
-irValue *ir_value_global(Entity *e, irValue *value) {
-	irValue *v = ir_alloc_value(irValue_Global);
-	v->Global.entity = e;
-	v->Global.type = alloc_type_pointer(e->type);
-	v->Global.value = value;
-	array_init(&v->Global.referrers, ir_allocator()); // TODO(bill): Replace heap allocator here
-
-	if (value) value->uses += 1;
-	return v;
-}
-irValue *ir_value_param(irProcedure *parent, Entity *e, Type *abi_type, i32 index) {
-	irValue *v = ir_alloc_value(irValue_Param);
-	v->Param.kind          = irParamPass_Value;
-	v->Param.parent        = parent;
-	if (e != nullptr) {
-		v->Param.entity        = e;
-		v->Param.original_type = e->type;
-	}
-	v->Param.type          = abi_type;
-	v->Param.index         = index;
-
-	if (e != nullptr && abi_type != e->type) {
-		if (is_type_pointer(abi_type)) {
-			GB_ASSERT(e->kind == Entity_Variable);
-			Type *av = core_type(type_deref(abi_type));
-			if (are_types_identical(av, core_type(e->type))) {
-				v->Param.kind = irParamPass_Pointer;
-				if (e->flags&EntityFlag_Value) {
-					v->Param.kind = irParamPass_ConstRef;
-				}
-			} else {
-				v->Param.kind = irParamPass_BitCast;
-			}
-		} else if (is_type_integer(abi_type)) {
-			v->Param.kind = irParamPass_Integer;
-		} else if (abi_type == t_llvm_bool) {
-			v->Param.kind = irParamPass_Value;
-		} else if (is_type_boolean(abi_type)) {
-			v->Param.kind = irParamPass_Integer;
-		} else if (is_type_simd_vector(abi_type)) {
-			v->Param.kind = irParamPass_BitCast;
-		} else if (is_type_float(abi_type)) {
-			v->Param.kind = irParamPass_BitCast;
-		} else if (is_type_tuple(abi_type)) {
-			v->Param.kind = irParamPass_Tuple;
-		} else {
-			GB_PANIC("Invalid abi type pass kind: %s", type_to_string(abi_type));
-		}
-	}
-	array_init(&v->Param.referrers, heap_allocator()); // TODO(bill): Replace heap allocator here
-	return v;
-}
-irValue *ir_value_nil(Type *type) {
-	irValue *v = ir_alloc_value(irValue_Nil);
-	v->Nil.type = type;
-	return v;
-}
-
-irValue *ir_value_undef(Type *type) {
-	irValue *v = ir_alloc_value(irValue_Undef);
-	v->Undef.type = type;
-	return v;
-}
-
-
-String ir_get_global_name(irModule *m, irValue *v) {
-	if (v->kind != irValue_Global) {
-		return str_lit("");
-	}
-	irValueGlobal *g = &v->Global;
-	Entity *e = g->entity;
-	String name = e->token.string;
-	String *found = map_get(&m->entity_names, hash_entity(e));
-	if (found != nullptr) {
-		name = *found;
-	} else {
-		GB_ASSERT(name.len > 0);
-	}
-	return name;
-}
-
-void ir_add_entity_name(irModule *m, Entity *e, String name) {
-	GB_ASSERT(name.len > 0);
-	if (e != nullptr && e->kind == Entity_TypeName) {
-		e->TypeName.ir_mangled_name = name;
-	}
-	map_set(&m->entity_names, hash_entity(e), name);
-}
-
-
-
-
-
-irValue *ir_instr_local(irProcedure *p, Entity *e, bool zero_initialized) {
-	irValue *v = ir_alloc_instr(p, irInstr_Local);
-	irInstr *i = &v->Instr;
-	i->Local.entity = e;
-	i->Local.type = alloc_type_pointer(e->type);
-	i->Local.zero_initialized = zero_initialized;
-	// i->Local.alignment = type_align_of(p->module->allocator, e->type);
-	// TODO(bill): determine the correct alignment
-	i->Local.alignment = gb_max(16, type_align_of(e->type));
-	array_init(&i->Local.referrers, heap_allocator()); // TODO(bill): Replace heap allocator here
-	ir_module_add_value(p->module, e, v);
-	return v;
-}
-
-irValue *ir_instr_zero_init(irProcedure *p, irValue *address) {
-	irValue *v = ir_alloc_instr(p, irInstr_ZeroInit);
-	irInstr *i = &v->Instr;
-	i->ZeroInit.address = address;
-
-	if (address) address->uses += 1;
-	return v;
-}
-
-irValue *ir_instr_store(irProcedure *p, irValue *address, irValue *value, bool is_volatile) {
-	irValue *v = ir_alloc_instr(p, irInstr_Store);
-	irInstr *i = &v->Instr;
-	i->Store.address = address;
-	i->Store.value = value;
-	i->Store.is_volatile = is_volatile;
-
-	if (address) address->uses += 1;
-	if (value) value->uses += 1;
-	return v;
-}
-
-irValue *ir_instr_load(irProcedure *p, irValue *address, bool is_volatile) {
-	irValue *v = ir_alloc_instr(p, irInstr_Load);
-	irInstr *i = &v->Instr;
-	i->Load.address = address;
-	i->Load.type = type_deref(ir_type(address));
-	i->Load.is_volatile = is_volatile;
-
-	if (address) address->uses += 1;
-
-	return v;
-}
-
-irValue *ir_instr_inline_code(irProcedure *p, BuiltinProcId id, Array<irValue *> const &operands, Type *type) {
-	irValue *v = ir_alloc_instr(p, irInstr_InlineCode);
-	irInstr *i = &v->Instr;
-	i->InlineCode.id = id;
-	i->InlineCode.operands = operands;
-	i->InlineCode.type = type;
-	return v;
-}
-
-irValue *ir_instr_atomic_fence(irProcedure *p, BuiltinProcId id) {
-	irValue *v = ir_alloc_instr(p, irInstr_AtomicFence);
-	irInstr *i = &v->Instr;
-	i->AtomicFence.id = id;
-	return v;
-}
-
-irValue *ir_instr_atomic_store(irProcedure *p, irValue *address, irValue *value, BuiltinProcId id) {
-	irValue *v = ir_alloc_instr(p, irInstr_AtomicStore);
-	irInstr *i = &v->Instr;
-	i->AtomicStore.address = address;
-	i->AtomicStore.value = value;
-	i->AtomicStore.id = id;
-
-	if (address) address->uses += 1;
-	if (value) value->uses += 1;
-
-	return v;
-}
-
-irValue *ir_instr_atomic_load(irProcedure *p, irValue *address, BuiltinProcId id) {
-	irValue *v = ir_alloc_instr(p, irInstr_AtomicLoad);
-	irInstr *i = &v->Instr;
-	i->AtomicLoad.address = address;
-	i->AtomicLoad.type = type_deref(ir_type(address));
-	i->AtomicLoad.id = id;
-
-	if (address) address->uses += 1;
-
-	return v;
-}
-
-irValue *ir_instr_atomic_rmw(irProcedure *p, irValue *address, irValue *value, BuiltinProcId id) {
-	irValue *v = ir_alloc_instr(p, irInstr_AtomicRmw);
-	irInstr *i = &v->Instr;
-	i->AtomicRmw.type = type_deref(ir_type(address));
-	i->AtomicRmw.address = address;
-	i->AtomicRmw.value = value;
-	i->AtomicRmw.id = id;
-
-	if (address) address->uses += 1;
-	if (value) value->uses += 1;
-
-	return v;
-}
-
-
-irValue *ir_instr_atomic_cxchg(irProcedure *p, Type *type, irValue *address, irValue *old_value, irValue *new_value, BuiltinProcId id) {
-	irValue *v = ir_alloc_instr(p, irInstr_AtomicCxchg);
-	irInstr *i = &v->Instr;
-
-
-	if (type->kind == Type_Tuple) {
-		GB_ASSERT(type->Tuple.variables.count == 2);
-		Type *elem = type->Tuple.variables[0]->type;
-		// LEAK TODO(bill): LLVM returns {T, i1} whilst Odin does {T, bool}, fix this mapping hack
-		gbAllocator a = permanent_allocator();
-		Type *llvm_type = alloc_type_tuple();
-		array_init(&llvm_type->Tuple.variables, a, 0, 2);
-		array_add (&llvm_type->Tuple.variables, alloc_entity_field(nullptr, blank_token, elem, false, 0));
-		array_add (&llvm_type->Tuple.variables, alloc_entity_field(nullptr, blank_token, t_llvm_bool, false, 1));
-
-		type = llvm_type;
-	}
-	i->AtomicCxchg.type = type;
-
-	i->AtomicCxchg.address = address;
-	i->AtomicCxchg.old_value = old_value;
-	i->AtomicCxchg.new_value = new_value;
-	i->AtomicCxchg.id = id;
-
-
-	if (address) address->uses += 1;
-	if (old_value) old_value->uses += 1;
-	if (new_value) new_value->uses += 1;
-
-	return v;
-}
-
-irValue *ir_instr_array_element_ptr(irProcedure *p, irValue *address, irValue *elem_index) {
-	irValue *v = ir_alloc_instr(p, irInstr_ArrayElementPtr);
-	irInstr *i = &v->Instr;
-	Type *t = ir_type(address);
-	GB_ASSERT_MSG(is_type_pointer(t), "%s", type_to_string(t));
-	t = base_type(type_deref(t));
-	GB_ASSERT(is_type_array(t) || is_type_enumerated_array(t));
-
-	Type *result_type = nullptr;
-	if (t->kind == Type_Array) {
-		result_type = alloc_type_pointer(t->Array.elem);
-	} else if (t->kind == Type_EnumeratedArray) {
-		result_type = alloc_type_pointer(t->EnumeratedArray.elem);
-	}
-
-	i->ArrayElementPtr.address = address;
-	i->ArrayElementPtr.elem_index = elem_index;
-	i->ArrayElementPtr.result_type = result_type;
-
-	if (address) address->uses += 1;
-	if (elem_index) elem_index->uses += 1;
-
-	GB_ASSERT_MSG(is_type_pointer(ir_type(address)),
-	              "%s", type_to_string(ir_type(address)));
-	return v;
-}
-irValue *ir_instr_struct_element_ptr(irProcedure *p, irValue *address, i32 elem_index, Type *result_type) {
-	irValue *v = ir_alloc_instr(p, irInstr_StructElementPtr);
-	irInstr *i = &v->Instr;
-	i->StructElementPtr.address     = address;
-	i->StructElementPtr.elem_index  = elem_index;
-	i->StructElementPtr.result_type = result_type;
-
-	if (address) address->uses += 1;
-
-	GB_ASSERT_MSG(is_type_pointer(ir_type(address)),
-	              "%s", type_to_string(ir_type(address)));
-	return v;
-}
-irValue *ir_instr_ptr_offset(irProcedure *p, irValue *address, irValue *offset) {
-	irValue *v = ir_alloc_instr(p, irInstr_PtrOffset);
-	irInstr *i = &v->Instr;
-	i->PtrOffset.address = address;
-	i->PtrOffset.offset  = offset;
-
-	if (address) address->uses += 1;
-	if (offset) offset->uses += 1;
-
-
-	GB_ASSERT_MSG(is_type_pointer(ir_type(address)),
-	              "%s", type_to_string(ir_type(address)));
-	GB_ASSERT_MSG(is_type_integer(ir_type(offset)),
-	              "%s", type_to_string(ir_type(address)));
-
-	return v;
-}
-
-
-
-irValue *ir_instr_struct_extract_value(irProcedure *p, irValue *address, i32 index, Type *result_type) {
-	irValue *v = ir_alloc_instr(p, irInstr_StructExtractValue);
-	irInstr *i = &v->Instr;
-	i->StructExtractValue.address = address;
-	i->StructExtractValue.index = index;
-	i->StructExtractValue.result_type = result_type;
-
-	if (address) address->uses += 1;
-
-	return v;
-}
-
-irValue *ir_instr_union_tag_ptr(irProcedure *p, irValue *address) {
-	irValue *v = ir_alloc_instr(p, irInstr_UnionTagPtr);
-	irInstr *i = &v->Instr;
-	i->UnionTagPtr.address = address;
-
-	if (address) address->uses += 1;
-
-	// i->UnionTagPtr.type = alloc_type_pointer(t_type_info_ptr);
-	Type *u = type_deref(ir_type(address));
-	if (is_type_union_maybe_pointer(u)) {
-		GB_PANIC("union #maybe UnionTagPtr");
-	}
-	i->UnionTagPtr.type = alloc_type_pointer(union_tag_type(u));
-
-	return v;
-}
-
-irValue *ir_instr_union_tag_value(irProcedure *p, irValue *address) {
-	irValue *v = ir_alloc_instr(p, irInstr_UnionTagValue);
-	irInstr *i = &v->Instr;
-	i->UnionTagValue.address = address;
-
-	if (address) address->uses += 1;
-
-	Type *u = type_deref(ir_type(address));
-	if (is_type_union_maybe_pointer(u)) {
-		GB_PANIC("union #maybe UnionTagValue");
-	}
-	i->UnionTagPtr.type = union_tag_type(u);
-	return v;
-}
-
-irValue *ir_instr_unary_op(irProcedure *p, TokenKind op, irValue *expr, Type *type) {
-	irValue *v = ir_alloc_instr(p, irInstr_UnaryOp);
-	irInstr *i = &v->Instr;
-	i->UnaryOp.op = op;
-	i->UnaryOp.expr = expr;
-	i->UnaryOp.type = type;
-
-	if (expr) expr->uses += 1;
-	return v;
-}
-
-
-irValue *ir_instr_binary_op(irProcedure *p, TokenKind op, irValue *left, irValue *right, Type *type) {
-	irValue *v = ir_alloc_instr(p, irInstr_BinaryOp);
-	irInstr *i = &v->Instr;
-	i->BinaryOp.op = op;
-	i->BinaryOp.left = left;
-	i->BinaryOp.right = right;
-	i->BinaryOp.type = type;
-
-	if (left) left->uses += 1;
-	if (right) right->uses += 1;
-
-	return v;
-}
-
-irValue *ir_instr_jump(irProcedure *p, irBlock *block) {
-	irValue *v = ir_alloc_instr(p, irInstr_Jump);
-	irInstr *i = &v->Instr;
-	i->Jump.block = block;
-	return v;
-}
-irValue *ir_instr_if(irProcedure *p, irValue *cond, irBlock *true_block, irBlock *false_block) {
-	irValue *v = ir_alloc_instr(p, irInstr_If);
-	irInstr *i = &v->Instr;
-	i->If.cond = ir_emit_conv(p, cond, t_llvm_bool);
-	i->If.true_block = true_block;
-	i->If.false_block = false_block;
-	return v;
-}
-
-
-irValue *ir_instr_phi(irProcedure *p, Array<irValue *> edges, Type *type) {
-	GB_ASSERT(is_type_typed(type));
-
-	irValue *v = ir_alloc_instr(p, irInstr_Phi);
-	irInstr *i = &v->Instr;
-	i->Phi.edges = edges;
-	i->Phi.type = type;
-
-	for_array(j, edges) {
-		if (edges[j]) edges[j]->uses += 1;
-	}
-	return v;
-}
-
-irValue *ir_instr_unreachable(irProcedure *p) {
-	irValue *v = ir_alloc_instr(p, irInstr_Unreachable);
-	return v;
-}
-
-irValue *ir_instr_return(irProcedure *p, irValue *value) {
-	irValue *v = ir_alloc_instr(p, irInstr_Return);
-	v->Instr.Return.value = value;
-
-	if (value) value->uses += 1;
-
-	return v;
-}
-
-irValue *ir_instr_select(irProcedure *p, irValue *cond, irValue *t, irValue *f) {
-	irValue *v = ir_alloc_instr(p, irInstr_Select);
-	v->Instr.Select.cond = cond;
-	v->Instr.Select.true_value = t;
-	v->Instr.Select.false_value = f;
-
-	if (cond) cond->uses += 1;
-	if (t) t->uses += 1;
-	if (f) f->uses += 1;
-
-	return v;
-}
-
-irValue *ir_instr_call(irProcedure *p, irValue *value, irValue *return_ptr, Array<irValue *> args, Type *result_type, irValue *context_ptr, ProcInlining inlining) {
-	irValue *v = ir_alloc_instr(p, irInstr_Call);
-	v->Instr.Call.value       = value;
-	v->Instr.Call.return_ptr  = return_ptr;
-	v->Instr.Call.args        = args;
-	v->Instr.Call.type        = result_type;
-	v->Instr.Call.context_ptr = context_ptr;
-	v->Instr.Call.inlining    = inlining;
-
-	if (value) value->uses += 1;
-	if (return_ptr) return_ptr->uses += 1;
-	for_array(i, args) {
-		if (args[i]) args[i]->uses += 1;
-	}
-	if (context_ptr) context_ptr->uses += 1;
-
-	return v;
-}
-
-irValue *ir_instr_conv(irProcedure *p, irConvKind kind, irValue *value, Type *from, Type *to) {
-	irValue *v = ir_alloc_instr(p, irInstr_Conv);
-	v->Instr.Conv.kind  = kind;
-	v->Instr.Conv.value = value;
-	v->Instr.Conv.from  = from;
-	v->Instr.Conv.to    = to;
-
-	if (value) value->uses += 1;
-
-	return v;
-}
-
-irValue *ir_instr_comment(irProcedure *p, String text) {
-	irValue *v = ir_alloc_instr(p, irInstr_Comment);
-	v->Instr.Comment.text = text;
-	return v;
-}
-
-irValue *ir_instr_debug_declare(irProcedure *p, Ast *expr, Entity *entity, bool is_addr, irValue *value) {
-	irValue *v = ir_alloc_instr(p, irInstr_DebugDeclare);
-	v->Instr.DebugDeclare.expr       = expr;
-	v->Instr.DebugDeclare.entity     = entity;
-	v->Instr.DebugDeclare.is_addr    = is_addr;
-	v->Instr.DebugDeclare.value      = value;
-
-	if (value) value->uses += 1;
-
-	return v;
-}
-
-
-
-irValue *ir_value_constant(Type *type, ExactValue value) {
-	irValue *v = ir_alloc_value(irValue_Constant);
-	v->Constant.type  = type;
-	v->Constant.value = value;
-	return v;
-}
-
-
-irValue *ir_value_constant_slice(Type *type, irValue *backing_array, i64 count) {
-	irValue *v = ir_alloc_value(irValue_ConstantSlice);
-	v->ConstantSlice.type = type;
-	v->ConstantSlice.backing_array = backing_array;
-	v->ConstantSlice.count = count;
-
-	if (backing_array) backing_array->uses += 1;
-
-	return v;
-}
-
-
-irValue *ir_emit(irProcedure *proc, irValue *instr) {
-	GB_ASSERT(instr->kind == irValue_Instr);
-	irModule *m = proc->module;
-	irBlock *b = proc->curr_block;
-	instr->Instr.block = b;
-	if (b != nullptr) {
-		irInstr *i = ir_get_last_instr(b);
-		if (!ir_is_instr_terminating(i)) {
-			array_add(&b->instrs, instr);
-		}
-	} else if (instr->Instr.kind != irInstr_Unreachable) {
-		GB_PANIC("ir_emit: Instruction missing parent block");
-	}
-	if (m->generate_debug_info) {
-		ir_value_set_debug_location(proc, instr);
-	}
-	return instr;
-}
-
-irValue *ir_de_emit(irProcedure *proc, irValue *instr) {
-	GB_ASSERT(instr->kind == irValue_Instr);
-	irModule *m = proc->module;
-	irBlock *b = proc->curr_block;
-	GB_ASSERT(b != nullptr);
-	irInstr *i = ir_get_last_instr(b);
-	GB_ASSERT(i == &instr->Instr);
-	array_pop(&b->instrs);
-	return instr;
-}
-
-irValue *ir_const_int(i64 i) {
-	return ir_value_constant(t_int, exact_value_i64(i));
-}
-irValue *ir_const_uintptr(u64 i) {
-	return ir_value_constant(t_uintptr, exact_value_i64(i));
-}
-irValue *ir_const_u8(u32 i) {
-	return ir_value_constant(t_u8, exact_value_i64(i));
-}
-irValue *ir_const_i32(i32 i) {
-	return ir_value_constant(t_i32, exact_value_i64(i));
-}
-irValue *ir_const_u32(u32 i) {
-	return ir_value_constant(t_u32, exact_value_i64(i));
-}
-irValue *ir_const_i64(i64 i) {
-	return ir_value_constant(t_i64, exact_value_i64(i));
-}
-irValue *ir_const_u64(u64 i) {
-	return ir_value_constant(t_u64, exact_value_i64(i));
-}
-irValue *ir_const_f32(f32 f) {
-	return ir_value_constant(t_f32, exact_value_float(f));
-}
-irValue *ir_const_f64(f64 f) {
-	return ir_value_constant(t_f64, exact_value_float(f));
-}
-irValue *ir_const_bool(bool b) {
-	return ir_value_constant(t_bool, exact_value_bool(b != 0));
-}
-irValue *ir_const_string(irModule *m, String s) {
-	return ir_find_or_add_entity_string(m, s);
-	// return ir_value_constant(t_string, exact_value_string(s));
-}
-
-irValue *ir_value_procedure(irModule *m, Entity *entity, Type *type, Ast *type_expr, Ast *body, String name) {
-	irValue *v = ir_alloc_value(irValue_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());
-
-	Type *t = base_type(type);
-	GB_ASSERT(is_type_proc(t));
-	array_init(&v->Proc.params, heap_allocator(), 0, t->Proc.param_count);
-
-	return v;
-}
-
-
-irValue *ir_generate_array(irModule *m, Type *elem_type, i64 count, String prefix, i64 id) {
-	gbAllocator a = ir_allocator();
-	Token token = {Token_Ident};
-	isize name_len = prefix.len + 1 + 20;
-
-	auto suffix_id = cast(unsigned long long)id;
-	char *text = gb_alloc_array(a, char, name_len+1);
-	gb_snprintf(text, name_len,
-	            "%.*s-%llu", LIT(prefix), suffix_id);
-	text[name_len] = 0;
-
-	String s = make_string_c(text);
-
-	Entity *e = alloc_entity_variable(nullptr, make_token_ident(s), alloc_type_array(elem_type, count));
-	irValue *value = ir_value_global(e, nullptr);
-	value->Global.is_private = true;
-	ir_module_add_value(m, e, value);
-	string_map_set(&m->members, s, value);
-	return value;
-}
-
-irBlock *ir_new_block(irProcedure *proc, Ast *node, char const *label) {
-	Scope *scope = nullptr;
-	if (node != nullptr) {
-		scope = scope_of_node(node);
-		GB_ASSERT_MSG(scope != nullptr, "Block scope not found for %.*s", LIT(ast_strings[node->kind]));
-	}
-
-	irValue *v = ir_alloc_value(irValue_Block);
-	v->Block.label  = make_string_c(label);
-	v->Block.node   = node;
-	v->Block.scope  = scope;
-	v->Block.proc   = proc;
-	// TODO(bill): Is this correct or even needed?
-	v->Block.scope_index = proc->scope_index;
-
-	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());
-
-	irBlock *block = &v->Block;
-	return block;
-}
-
-void ir_add_block_to_proc(irProcedure *proc, irBlock *b) {
-	for_array(i, proc->blocks) {
-		if (proc->blocks[i] == b) {
-			return;
-		}
-	}
-	array_add(&proc->blocks, b);
-	b->index = proc->block_count++;
-}
-
-void ir_start_block(irProcedure *proc, irBlock *block) {
-	proc->curr_block = block;
-	if (block != nullptr) {
-		ir_add_block_to_proc(proc, block);
-	}
-}
-
-
-irValue *ir_emit_transmute(irProcedure *proc, irValue *value, Type *t);
-irValue *ir_address_from_load_or_generate_local(irProcedure *proc, irValue *val);
-irValue *ir_emit_struct_ep(irProcedure *proc, irValue *s, i32 index);
-
-
-
-
-void ir_add_defer_node(irProcedure *proc, isize scope_index, Ast *stmt) {
-	irDefer d = {irDefer_Node};
-	d.scope_index = scope_index;
-	d.context_stack_count = proc->context_stack.count;
-	d.block = proc->curr_block;
-	d.stmt = stmt;
-	array_add(&proc->defer_stmts, d);
-}
-
-
-void ir_add_defer_instr(irProcedure *proc, isize scope_index, irValue *instr) {
-	irDefer d = {irDefer_Instr};
-	d.scope_index = proc->scope_index;
-	d.context_stack_count = proc->context_stack.count;
-	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);
-}
-
-void ir_add_defer_proc(irProcedure *proc, isize scope_index, irValue *deferred, Array<irValue *> const &result_as_args) {
-	irDefer d = {irDefer_Proc};
-	d.scope_index = proc->scope_index;
-	d.context_stack_count = proc->context_stack.count;
-	d.block = proc->curr_block;
-	d.proc.deferred = deferred;
-	d.proc.result_as_args = result_as_args;
-	array_add(&proc->defer_stmts, d);
-}
-
-irValue *ir_add_module_constant(irModule *m, Type *type, ExactValue value);
-
-irValue *ir_check_compound_lit_constant(irModule *m, Ast *expr) {
-	expr = unparen_expr(expr);
-	if (expr == nullptr) {
-		return nullptr;
-	}
-
-	if (expr->kind == Ast_CompoundLit) {
-		ast_node(cl, CompoundLit, expr);
-		for_array(i, cl->elems) {
-			Ast *elem = cl->elems[i];
-			if (elem->kind == Ast_FieldValue) {
-				ast_node(fv, FieldValue, elem);
-				ir_check_compound_lit_constant(m, fv->value);
-			} else {
-				ir_check_compound_lit_constant(m, elem);
-			}
-		}
-	}
-	if (expr->kind == Ast_ProcLit) {
-		return ir_gen_anonymous_proc_lit(m, str_lit("_proclit"), expr);
-	}
-
-	if (expr->kind == Ast_Ident || expr->kind == Ast_SelectorExpr) {
-		TypeAndValue tav = type_and_value_of_expr(expr);
-		if (tav.mode == Addressing_Constant) {
-			return ir_add_module_constant(m, tav.type, tav.value);
-		}
-	}
-
-
-	return 	nullptr;
-}
-
-irValue *ir_add_module_constant(irModule *m, Type *type, ExactValue value) {
-	gbAllocator a = ir_allocator();
-
-	if (is_type_slice(type)) {
-		if (value.kind == ExactValue_String) {
-			GB_ASSERT(is_type_u8_slice(type));
-			return ir_find_or_add_entity_string_byte_slice(m, value.value_string);
-		} else {
-			ast_node(cl, CompoundLit, value.value_compound);
-
-			isize count = cl->elems.count;
-			if (count == 0) {
-				return ir_value_nil(type);
-			}
-			count = gb_max(cl->max_count, count);
-			Type *elem = base_type(type)->Slice.elem;
-			Type *t = alloc_type_array(elem, count);
-			irValue *backing_array = ir_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 = alloc_entity_constant(nullptr, make_token_ident(name), t, value);
-			irValue *g = ir_value_global(e, backing_array);
-			ir_module_add_value(m, e, g);
-			string_map_set(&m->members, name, g);
-
-			return ir_value_constant_slice(type, g, count);
-		}
-	}
-
-	if (value.kind == ExactValue_Compound) {
-		// NOTE(bill): Removed for numerous reasons
-		irValue *lit = ir_check_compound_lit_constant(m, value.value_compound);
-		if (lit != nullptr) {
-			return lit;
-		}
-	}
-
-	return ir_value_constant(type, value);
-}
-
-irValue *ir_add_global_string_array(irModule *m, String string) {
-
-	irValue *global_constant_value = nullptr;
-	{
-		irValue **found = string_map_get(&m->const_string_byte_slices, string);
-		if (found != nullptr) {
-			global_constant_value = *found;
-
-			irValue **global_found = map_get(&m->constant_value_to_global, hash_pointer(global_constant_value));
-			if (global_found != nullptr) {
-				return *global_found;
-			}
-		}
-	}
-
-	if (global_constant_value == nullptr) {
-		global_constant_value = ir_find_or_add_entity_string_byte_slice(m, string);
-	}
-	Type *type = alloc_type_array(t_u8, string.len+1);
-
-
-	isize max_len = 6+8+1;
-	u8 *str = cast(u8 *)gb_alloc_array(ir_allocator(), 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;
-
-	Entity *entity = alloc_entity_constant(nullptr, token, type, exact_value_string(string));
-
-	irValue *g = ir_value_global(entity, global_constant_value);
-	g->Global.is_private      = true;
-	g->Global.is_unnamed_addr = true;
-	g->Global.is_constant = true;
-
-	map_set(&m->constant_value_to_global, hash_pointer(global_constant_value), g);
-
-
-	ir_module_add_value(m, entity, g);
-	string_map_set(&m->members, name, g);
-
-	return g;
-}
-
-void ir_add_foreign_library_path(irModule *m, Entity *e) {
-	if (e == nullptr) {
-		return;
-	}
-	GB_ASSERT(e->kind == Entity_LibraryName);
-	GB_ASSERT(e->flags & EntityFlag_Used);
-
-	for_array(i, e->LibraryName.paths) {
-		String library_path = e->LibraryName.paths[i];
-		if (library_path.len == 0) {
-			continue;
-		}
-
-		bool ok = true;
-		for_array(path_index, m->foreign_library_paths) {
-			String path = m->foreign_library_paths[path_index];
-	#if defined(GB_SYSTEM_WINDOWS)
-			if (str_eq_ignore_case(path, library_path)) {
-	#else
-			if (str_eq(path, library_path)) {
-	#endif
-				ok = false;
-				break;
-			}
-		}
-
-		if (ok) {
-			array_add(&m->foreign_library_paths, library_path);
-		}
-	}
-}
-
-
-
-void ir_push_context_onto_stack(irProcedure *proc, irValue *ctx) {
-	irContextData cd = {ctx, proc->scope_index};
-	array_add(&proc->context_stack, cd);
-}
-
-irValue *ir_add_local(irProcedure *proc, Entity *e, Ast *expr, bool zero_initialized, i32 param_index = 0) {
-	irBlock *b = proc->decl_block; // all variables must be in the first block
-	irValue *instr = ir_instr_local(proc, e, true);
-	instr->Instr.block = b;
-	array_add(&b->instrs, instr);
-	array_add(&b->locals, instr);
-	proc->local_count++;
-
-	if (zero_initialized) {
-		ir_emit_zero_init(proc, instr, expr);
-	}
-	set_procedure_abi_types(e->type);
-
-	// if (proc->module->generate_debug_info && expr != nullptr && proc->entity != nullptr) {
-	// if (proc->module->generate_debug_info && proc->entity != nullptr) {
-	if (proc->module->generate_debug_info) {
-		// GB_ASSERT_NOT_NULL(proc->debug_scope);
-		if (expr != nullptr) {
-			ir_emit(proc, ir_instr_debug_declare(proc, expr, e, true, instr));
-		}
-		if (e->scope != nullptr && proc->debug_scope != nullptr) {
-			irDebugInfo *di_local = ir_add_debug_info_local(proc, e, param_index);
-		}
-	}
-
-	return instr;
-}
-
-irValue *ir_add_local_for_identifier(irProcedure *proc, Ast *ident, bool zero_initialized) {
-	Entity *e = entity_of_node(ident);
-	if (e != nullptr) {
-		String name = e->token.string;
-		ir_emit_comment(proc, name);
-		if (e->kind == Entity_Variable &&
-		    e->Variable.is_foreign) {
-			if (e->Variable.link_name.len != 0) {
-				name = e->Variable.link_name;
-			}
-
-			StringHashKey key = string_hash_string(name);
-			irValue **prev_value = string_map_get(&proc->module->members, key);
-			if (prev_value == nullptr) {
-				ir_add_foreign_library_path(proc->module, e->Variable.foreign_library);
-				// NOTE(bill): Don't do mutliple declarations in the IR
-				irValue *g = ir_value_global(e, nullptr);
-				g->Global.name = name;
-				g->Global.is_foreign = true;
-				ir_module_add_value(proc->module, e, g);
-				string_map_set(&proc->module->members, key, g);
-				return g;
-			} else {
-				return *prev_value;
-			}
-		}
-		return ir_add_local(proc, e, ident, zero_initialized);
-	}
-	return nullptr;
-}
-
-irValue *ir_add_local_generated(irProcedure *proc, Type *type, bool zero_initialized) {
-	GB_ASSERT(type != nullptr);
-	type = default_type(type);
-
-	Scope *scope = nullptr;
-	if (proc->curr_block) {
-		scope = proc->curr_block->scope;
-	}
-	Entity *e = alloc_entity_variable(scope, empty_token, type);
-	return ir_add_local(proc, e, nullptr, zero_initialized);
-}
-
-
-irValue *ir_add_global_generated(irModule *m, Type *type, irValue *value) {
-	GB_ASSERT(type != nullptr);
-	type = default_type(type);
-
-	isize max_len = 7+8+1;
-	u8 *str = cast(u8 *)gb_alloc_array(ir_allocator(), u8, max_len);
-	isize len = gb_snprintf(cast(char *)str, max_len, "ggv$%x", m->global_generated_index);
-	m->global_generated_index++;
-	String name = make_string(str, len-1);
-
-	Scope *scope = nullptr;
-	Entity *e = alloc_entity_variable(scope, make_token_ident(name), type);
-	irValue *g = ir_value_global(e, value);
-	ir_module_add_value(m, e, g);
-	string_map_set(&m->members, name, g);
-	return g;
-}
-
-
-irValue *ir_add_param(irProcedure *proc, Entity *e, Ast *expr, Type *abi_type, i32 index) {
-	irValue *v = ir_value_param(proc, e, abi_type, index);
-	array_add(&proc->params, v);
-	irValueParam *p = &v->Param;
-
-	irValue *res = nullptr;
-
-	ir_push_debug_location(proc->module, e ? e->identifier : nullptr, proc->debug_scope, e);
-	defer (ir_pop_debug_location(proc->module));
-
-	switch (p->kind) {
-	case irParamPass_Value: {
-		irValue *l = ir_add_local(proc, e, expr, false, index);
-		irValue *x = v;
-		if (abi_type == t_llvm_bool) {
-			x = ir_emit_conv(proc, x, t_bool);
-		}
-		ir_emit_store(proc, l, x);
-		return x;
-	}
-	case irParamPass_Pointer:
-		ir_module_add_value(proc->module, e, v);
-		return ir_emit_load(proc, v);
-
-	case irParamPass_Integer: {
-		irValue *l = ir_add_local(proc, e, expr, false, index);
-		irValue *iptr = ir_emit_conv(proc, l, alloc_type_pointer(p->type));
-		ir_emit_store(proc, iptr, v);
-		return ir_emit_load(proc, l);
-	}
-
-	case irParamPass_ConstRef:
-		ir_module_add_value(proc->module, e, v);
-		return ir_emit_load(proc, v);
-
-	case irParamPass_BitCast: {
-		irValue *l = ir_add_local(proc, e, expr, false, index);
-		irValue *x = ir_emit_transmute(proc, v, e->type);
-		ir_emit_store(proc, l, x);
-		return x;
-	}
-	case irParamPass_Tuple: {
-		irValue *l = ir_add_local(proc, e, expr, true, index);
-		Type *st = struct_type_from_systemv_distribute_struct_fields(abi_type);
-		irValue *ptr = ir_emit_transmute(proc, l, alloc_type_pointer(st));
-		if (abi_type->Tuple.variables.count > 0) {
-			array_pop(&proc->params);
-		}
-		for_array(i, abi_type->Tuple.variables) {
-			Type *t = abi_type->Tuple.variables[i]->type;
-
-			irValue *elem = ir_value_param(proc, nullptr, t, index+cast(i32)i);
-			array_add(&proc->params, elem);
-
-			irValue *dst = ir_emit_struct_ep(proc, ptr, cast(i32)i);
-			ir_emit_store(proc, dst, elem);
-		}
-		return ir_emit_load(proc, l);
-	}
-
-	}
-
-	GB_PANIC("Unreachable");
-	return nullptr;
-}
-
-
-
-////////////////////////////////////////////////////////////////
-//
-// @Debug
-//
-////////////////////////////////////////////////////////////////
-
-irDebugInfo *ir_add_debug_info_type(irModule *module, Type *type, Entity *e, irDebugInfo *scope, irDebugInfo *file);
-
-irDebugInfo *ir_add_debug_info_array(irModule *module, isize count, isize capacity) {
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DebugInfoArray);
-	array_init(&di->DebugInfoArray.elements, ir_allocator(), count, capacity);
-	map_set(&module->debug_info, hash_pointer(di), di);
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_file(irModule *module, AstFile *file) {
-	// if (!proc->module->generate_debug_info) {
-	// 	return nullptr;
-	// }
-
-	irDebugInfo **existing = map_get(&module->debug_info, hash_ast_file(file));
-	if (existing != nullptr) {
-		GB_ASSERT((*existing)->kind == irDebugInfo_File);
-		return *existing;
-	}
-
-	GB_ASSERT(file != nullptr);
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_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[i] == '\\' ||
-		    filename[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_set(&module->debug_info, hash_ast_file(file), di);
-	return di;
-}
-
-irDebugEncoding ir_debug_encoding_for_basic(BasicKind kind) {
-	switch (kind) {
-	case Basic_llvm_bool:
-	case Basic_bool:
-	case Basic_b8:
-	case Basic_b16:
-	case Basic_b32:
-	case Basic_b64:
-		return irDebugBasicEncoding_boolean;
-
-	case Basic_i8:
-		return irDebugBasicEncoding_signed_char;
-
-	case Basic_u8:
-		return irDebugBasicEncoding_unsigned_char;
-
-
-	case Basic_i16:
-	case Basic_i32:
-	case Basic_i64:
-	case Basic_i128:
-	case Basic_i16le:
-	case Basic_i32le:
-	case Basic_i64le:
-	case Basic_i128le:
-	case Basic_i16be:
-	case Basic_i32be:
-	case Basic_i64be:
-	case Basic_i128be:
-	case Basic_int:
-	case Basic_rune:
-	case Basic_typeid:
-		return irDebugBasicEncoding_signed;
-
-	case Basic_u16:
-	case Basic_u32:
-	case Basic_u64:
-	case Basic_u128:
-	case Basic_u16le:
-	case Basic_u32le:
-	case Basic_u64le:
-	case Basic_u128le:
-	case Basic_u16be:
-	case Basic_u32be:
-	case Basic_u64be:
-	case Basic_u128be:
-	case Basic_uint:
-	case Basic_uintptr:
-		return irDebugBasicEncoding_unsigned;
-
-	case Basic_f16:
-	case Basic_f32:
-	case Basic_f64:
-	case Basic_f16le:
-	case Basic_f32le:
-	case Basic_f64le:
-	case Basic_f16be:
-	case Basic_f32be:
-	case Basic_f64be:
-			return irDebugBasicEncoding_float;
-
-	case Basic_complex32:
-	case Basic_complex64:
-	case Basic_complex128:
-	case Basic_quaternion64:
-	case Basic_quaternion128:
-	case Basic_quaternion256:
-	case Basic_cstring:
-	case Basic_string:
-	case Basic_any:
-	case Basic_rawptr:
-		break; // not a "DIBasicType"
-	}
-
-	GB_PANIC("Unreachable %d", kind);
-	return irDebugBasicEncoding_Invalid;
-}
-
-i32 ir_debug_info_bits(i64 size) {
-	return 8*cast(i32)size;
-}
-
-i32 ir_debug_size_bits(Type *type) {
-	return ir_debug_info_bits(type_size_of(type));
-}
-
-i32 ir_debug_align_bits(Type *type) {
-	return ir_debug_info_bits(type_align_of(type));
-}
-
-irDebugInfo *ir_add_debug_info_field_internal(irModule *module, String name, Type *type, i32 offset_bits, Entity *e, irDebugInfo *scope) {
-	// NOTE(lachsinc): Caller is expected to insert the returned value into map themselves.
-	// "scope", if set, should be inserted into map prior to calling to ensure no cyclical dependency issues.
-
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DerivedType);
-	// GB_ASSERT_MSG(name.len > 0, "%s", type_to_string(type));
-	di->DerivedType.name = name;
-	di->DerivedType.tag = irDebugBasicEncoding_member;
-	di->DerivedType.size = ir_debug_size_bits(type);
-	di->DerivedType.offset = offset_bits;
-	di->DerivedType.scope = scope;
-
-	// NOTE(lachsinc): It is "safe" to overwrite this base_type after a call to this function,
-	// if you need to set a specific type for this field.
-	di->DerivedType.base_type = ir_add_debug_info_type(module, type, e, scope, nullptr);
-	GB_ASSERT_NOT_NULL(di->DerivedType.base_type);
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_field(irModule *module, irDebugInfo *scope, Entity *e, Type *scope_type, i32 index, Type *type, irDebugInfo *file) {
-	// NOTE(lachsinc): This lookup will only work for struct fields!!
-	if (e) {
-		irDebugInfo **existing = map_get(&module->debug_info, hash_entity(e));
-		if (existing != nullptr) {
-			return *existing;
-		}
-	}
-
-	irDebugInfo *di = ir_add_debug_info_field_internal(module, make_string(nullptr, 0), type, 0, e, scope);
-	void *ptr_to_hash = nullptr;
-	if (scope_type) {
-		Type *scope_base = base_type(scope_type);
-		if (is_type_struct(scope_type) || is_type_tuple(scope_type)) {
-			if (is_type_struct(scope_type) && scope_base->Struct.are_offsets_set) {
-				di->DerivedType.offset = ir_debug_info_bits(scope_base->Struct.offsets[index]);
-			} else if (is_type_tuple(scope_type) && scope_base->Tuple.are_offsets_set) {
-				di->DerivedType.offset = ir_debug_info_bits(scope_base->Tuple.offsets[index]);
-			} else {
-				di->DerivedType.offset = ir_debug_info_bits(type_offset_of(scope_base, index));
-			}
-			if (e) {
-				ptr_to_hash = e;
-				di->DerivedType.name = e->token.string;
-				if (e->token.string.len == 0) {
-					// If no name available for field, use its field index as its name.
-					isize max_len = 8;
-					u8 *str = cast(u8 *)gb_alloc_array(permanent_allocator(), u8, max_len);
-					isize len = gb_snprintf(cast(char *)str, 8, "%d", index);
-					di->DerivedType.name = make_string(str, len-1);
-				}
-				di->DerivedType.pos = e->token.pos;
-			} else {
-				GB_PANIC("Unreachable"); // struct field Entity's should be provided.
-			}
-		} else if (is_type_union(scope_base)) {
-			// TODO(lachsinc): Handle this in a more generic manner/pass in??...
-			// Token token = base_type(scope_base)->Union.node->UnionType.token;
-			// di->DerivedType.name = token.string;
-			// di->DerivedType.pos = token.pos;
-			if (is_type_named(type)) {
-				di->DerivedType.name = type->kind == Type_Named ? type->Named.name : type->Basic.name;
-			}
-			ptr_to_hash = di;
-		}
-	}
-
-	di->DerivedType.file = file;
-
-	GB_ASSERT_NOT_NULL(ptr_to_hash);
-	map_set(&module->debug_info, hash_pointer(ptr_to_hash), di);
-
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_enumerator(irModule *module, Entity *e) {
-	irDebugInfo **existing = map_get(&module->debug_info, hash_entity(e));
-	if (existing != nullptr) {
-		return *existing;
-	}
-
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_Enumerator);
-	di->Enumerator.name = e->token.string;
-	GB_ASSERT(e->kind == Entity_Constant);
-	GB_ASSERT(e->Constant.value.kind == ExactValue_Integer);
-	di->Enumerator.value = big_int_to_i64(&e->Constant.value.value_integer);
-
-	map_set(&module->debug_info, hash_entity(e), di);
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_type_dynamic_array(irModule *module, Type *type, Entity *e, irDebugInfo *scope, irDebugInfo *file) {
-	GB_ASSERT(type->kind == Type_DynamicArray);
-
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-	di->CompositeType.name = str_lit("dynamic_array"); // TODO(lachsinc): [dynamic] .. type->DynamicArray.elem name
-	di->CompositeType.tag = irDebugBasicEncoding_structure_type;
-	di->CompositeType.size = ir_debug_size_bits(t_rawptr) +
-	                         ir_debug_size_bits(t_int) +
-	                         ir_debug_size_bits(t_int) +
-	                         ir_debug_size_bits(t_allocator);
-	di->CompositeType.align = ir_debug_align_bits(t_rawptr);
-	map_set(&module->debug_info, hash_type(type), di);
-
-	// Data pointer type
-	// TODO(lachsinc): Perhaps lookup/alloc-a-fake Type_Pointer type and go via ir_add_debug_info_type() with it.
-	irDebugInfo *data_ptr_di = ir_alloc_debug_info(irDebugInfo_DerivedType);
-	data_ptr_di->DerivedType.tag = irDebugBasicEncoding_pointer_type;
-	data_ptr_di->DerivedType.size = ir_debug_size_bits(t_rawptr);
-	map_set(&module->debug_info, hash_pointer(data_ptr_di), data_ptr_di);
-	data_ptr_di->DerivedType.base_type = ir_add_debug_info_type(module, type->DynamicArray.elem, e, scope, file);
-
-	irDebugInfo *data_di = ir_add_debug_info_field_internal(module, str_lit("data"), t_rawptr,
-	                                                        0,
-	                                                        nullptr,
-	                                                        di);
-	data_di->DerivedType.base_type = data_ptr_di;
-	map_set(&module->debug_info, hash_pointer(data_di), data_di);
-
-	irDebugInfo *len_di = ir_add_debug_info_field_internal(module, str_lit("len"), t_int,
-	                                                       data_di->DerivedType.size,
-	                                                       nullptr,
-	                                                       di);
-	map_set(&module->debug_info, hash_pointer(len_di), len_di);
-
-	irDebugInfo *cap_di = ir_add_debug_info_field_internal(module, str_lit("cap"), t_int,
-	                                                       data_di->DerivedType.size +
-	                                                       len_di->DerivedType.size,
-	                                                       nullptr,
-	                                                       di);
-	map_set(&module->debug_info, hash_pointer(cap_di), cap_di);
-
-	irDebugInfo *alloc_di = ir_add_debug_info_field_internal(module, str_lit("allocator"), t_allocator,
-	                                                         data_di->DerivedType.size +
-	                                                         len_di->DerivedType.size +
-	                                                         cap_di->DerivedType.size,
-	                                                         nullptr,
-	                                                         di);
-	map_set(&module->debug_info, hash_pointer(alloc_di), alloc_di);
-
-	irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 4);
-	array_add(&elements_di->DebugInfoArray.elements, data_di);
-	array_add(&elements_di->DebugInfoArray.elements, len_di);
-	array_add(&elements_di->DebugInfoArray.elements, cap_di);
-	array_add(&elements_di->DebugInfoArray.elements, alloc_di);
-	di->CompositeType.elements = elements_di;
-	map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
-
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_type_bit_set(irModule *module, Type *type, Entity *e, irDebugInfo *scope) {
-	GB_ASSERT(type->kind == Type_BitSet || type->kind == Type_Named);
-
-	Type *base = base_type(type);
-
-	Type *named = nullptr;
-	if (type->kind == Type_Named) {
-		named = type;
-	}
-
-	Type *elem_type = nullptr;
-	if (base->BitSet.elem != nullptr) {
-		// TODO(lachsinc): Do bitsets have integration with non-primitive types other than enums?
-		elem_type = base->BitSet.elem;
-		if (elem_type->kind == Type_Enum) {
-			GB_ASSERT(elem_type->Enum.fields.count == base->BitSet.upper + 1);
-		}
-	}
-
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-	di->CompositeType.name = named != nullptr ? named->Named.name : str_lit("bit_set");
-	di->CompositeType.tag = irDebugBasicEncoding_structure_type;
-	di->CompositeType.size = ir_debug_size_bits(base);
-	map_set(&module->debug_info, hash_type(type), di);
-
-	irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, base->BitSet.upper + 1);
-	di->CompositeType.elements = elements_di;
-	map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
-
-	for (i64 i = 0; i <= base->BitSet.upper; ++i) {
-		u32 offset = cast(u32)i;
-		// TODO(lachsinc): Maybe name these fields numbered ascending?
-		String name = str_lit("field_todo");
-		if (elem_type != nullptr && is_type_enum(elem_type)) {
-			// name = base_type(elem_type)->Enum.fields[i]->token.string;
-		}
-		irDebugInfo *field_di = ir_add_debug_info_field_internal(module, name, t_u32, // TODO(lachsinc): u32 fine??
-		                                                         0,
-		                                                         nullptr,
-		                                                         di);
-		field_di->DerivedType.size   = 1;
-		field_di->DerivedType.offset = offset; // Offset stored in bits already, no need to convert
-		field_di->DerivedType.flags  = irDebugInfoFlag_Bitfield;
-		map_set(&module->debug_info, hash_pointer(field_di), field_di);
-		array_add(&elements_di->DebugInfoArray.elements, field_di);
-	}
-
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_type_string(irModule *module, irDebugInfo *scope, Entity *e, Type *type) {
-	// TODO(lachsinc): Does this only occur once ??
-	irDebugInfo **existing = map_get(&module->debug_info, hash_type(t_string));
-	if (existing != nullptr) {
-		GB_ASSERT((*existing)->kind == irDebugInfo_CompositeType);
-		return *existing;
-	} else {
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-		di->CompositeType.name = type->Basic.name;
-		di->CompositeType.tag = irDebugBasicEncoding_structure_type;
-		di->CompositeType.size = ir_debug_size_bits(t_string);
-		di->CompositeType.align = ir_debug_align_bits(t_string);
-
-		map_set(&module->debug_info, hash_type(type), di);
-
-		// Field "data"
-		irDebugInfo *data_di = ir_add_debug_info_field_internal(module, str_lit("data"), t_cstring,
-		                                                        0,
-		                                                        nullptr,
-		                                                        di);
-		map_set(&module->debug_info, hash_pointer(data_di), data_di);
-
-		// Field "len"
-		irDebugInfo *len_di = ir_add_debug_info_field_internal(module, str_lit("len"), t_i64,
-		                                                       data_di->DerivedType.size,
-		                                                       nullptr,
-		                                                       di);
-		map_set(&module->debug_info, hash_pointer(len_di), len_di);
-
-		irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 2);
-		array_add(&elements_di->DebugInfoArray.elements, data_di);
-		array_add(&elements_di->DebugInfoArray.elements, len_di);
-		di->CompositeType.elements = elements_di;
-		map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
-
-		return di;
-	}
-}
-
-irDebugInfo *ir_add_debug_info_type_any(irModule *module) {
-	irDebugInfo **existing = map_get(&module->debug_info, hash_type(t_any));
-	if (existing != nullptr) {
-		GB_ASSERT((*existing)->kind == irDebugInfo_CompositeType);
-		return *existing;
-	} else {
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-		di->CompositeType.name = t_any->Basic.name;
-		di->CompositeType.tag = irDebugBasicEncoding_structure_type;
-		di->CompositeType.size = ir_debug_size_bits(t_any);
-		di->CompositeType.align = ir_debug_align_bits(t_any);
-
-		map_set(&module->debug_info, hash_type(t_any), di);
-
-		// Field "data"
-		irDebugInfo *data_di = ir_add_debug_info_field_internal(module, str_lit("data"), t_rawptr,
-		                                                        0,
-		                                                        nullptr,
-		                                                        di);
-		map_set(&module->debug_info, hash_pointer(data_di), data_di);
-
-		// Field "id"
-		irDebugInfo *id_di = ir_add_debug_info_field_internal(module, str_lit("id"), t_typeid,
-		                                                      data_di->DerivedType.size,
-		                                                      nullptr,
-		                                                      di);
-		map_set(&module->debug_info, hash_pointer(id_di), id_di);
-
-		irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 2);
-		array_add(&elements_di->DebugInfoArray.elements, data_di);
-		array_add(&elements_di->DebugInfoArray.elements, id_di);
-		di->CompositeType.elements = elements_di;
-		map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
-
-		return di;
-	}
-}
-
-irDebugInfo *ir_add_debug_info_type_complex(irModule *module, Type *type) {
-	GB_ASSERT(type->kind == Type_Basic && is_type_complex(type));
-
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-	map_set(&module->debug_info, hash_type(type), di);
-
-	di->CompositeType.name = type->Basic.name;
-	di->CompositeType.tag = irDebugBasicEncoding_structure_type;
-	di->CompositeType.size = ir_debug_size_bits(type);
-
-	Type *field_type = base_complex_elem_type(type);
-
-	irDebugInfo *real_di = ir_add_debug_info_field_internal(module, str_lit("real"), field_type, 0*cast(i32)type_size_of(field_type), nullptr, di);
-	irDebugInfo *imag_di = ir_add_debug_info_field_internal(module, str_lit("imag"), field_type, 1*cast(i32)type_size_of(field_type), nullptr, di);
-	map_set(&module->debug_info, hash_pointer(real_di), real_di);
-	map_set(&module->debug_info, hash_pointer(imag_di), imag_di);
-
-	irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 2);
-	array_add(&elements_di->DebugInfoArray.elements, real_di);
-	array_add(&elements_di->DebugInfoArray.elements, imag_di);
-	di->CompositeType.elements = elements_di;
-	map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
-
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_type_quaternion(irModule *module, Type *type) {
-	GB_ASSERT(type->kind == Type_Basic && is_type_quaternion(type));
-
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-	map_set(&module->debug_info, hash_type(type), di);
-
-	di->CompositeType.name = type->Basic.name;
-	di->CompositeType.tag = irDebugBasicEncoding_structure_type;
-	di->CompositeType.size = ir_debug_size_bits(type);
-
-	Type *field_type = base_complex_elem_type(type);
-
-	// @QuaternionLayout
-	irDebugInfo *imag_di = ir_add_debug_info_field_internal(module, str_lit("imag"), field_type, 0*cast(i32)type_size_of(field_type), nullptr, di);
-	irDebugInfo *jmag_di = ir_add_debug_info_field_internal(module, str_lit("jmag"), field_type, 1*cast(i32)type_size_of(field_type), nullptr, di);
-	irDebugInfo *kmag_di = ir_add_debug_info_field_internal(module, str_lit("kmag"), field_type, 2*cast(i32)type_size_of(field_type), nullptr, di);
-	irDebugInfo *real_di = ir_add_debug_info_field_internal(module, str_lit("real"), field_type, 3*cast(i32)type_size_of(field_type), nullptr, di);
-
-	map_set(&module->debug_info, hash_pointer(imag_di), imag_di);
-	map_set(&module->debug_info, hash_pointer(jmag_di), jmag_di);
-	map_set(&module->debug_info, hash_pointer(kmag_di), kmag_di);
-	map_set(&module->debug_info, hash_pointer(real_di), real_di);
-
-	irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 4);
-	array_add(&elements_di->DebugInfoArray.elements, imag_di);
-	array_add(&elements_di->DebugInfoArray.elements, jmag_di);
-	array_add(&elements_di->DebugInfoArray.elements, kmag_di);
-	array_add(&elements_di->DebugInfoArray.elements, real_di);
-	di->CompositeType.elements = elements_di;
-	map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
-
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_proc_type(irModule *module, Type *type) {
-	GB_ASSERT(type->kind == Type_Proc);
-
-	irDebugInfo **existing = map_get(&module->debug_info, hash_type(type));
-	if (existing != nullptr) {
-		GB_ASSERT((*existing)->kind == irDebugInfo_ProcType);
-		return *existing;
-	}
-
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_ProcType);
-	map_set(&module->debug_info, hash_type(type), di);
-
-	isize result_count = type->Proc.result_count;
-	isize param_count = type->Proc.param_count;
-	// gb_max(result_count, 1) because llvm expects explicit "null" return type
-	di->ProcType.types = ir_add_debug_info_array(module, 0, gb_max(result_count, 1) + param_count);
-
-	// TODO(bill): Is this even correct?!
-	irDebugInfo *scope = di;
-
-	// Result/return types
-	if (result_count >= 1) {
-		TypeTuple *results_tuple = &type->Proc.results->Tuple;
-		for_array(i, results_tuple->variables) {
-			Entity *e = results_tuple->variables[i];
-			if (e->kind != Entity_Variable) {
-				continue;
-			}
-
-			irDebugInfo *type_di = ir_add_debug_info_type(module, e->type, e, scope, nullptr);
-			GB_ASSERT_NOT_NULL(type_di);
-			array_add(&di->ProcType.types->DebugInfoArray.elements, type_di);
-		}
-	} else {
-		// llvm expects "!{null}" for a function without return type, use nullptr to represent it.
-		array_add(&di->ProcType.types->DebugInfoArray.elements, (irDebugInfo*)nullptr);
-	}
-
-	// Param types
-	if (param_count >= 1) {
-		TypeTuple *params_tuple = &type->Proc.params->Tuple;
-		for_array(i, params_tuple->variables) {
-			Entity *e = params_tuple->variables[i];
-			if (e->kind != Entity_Variable) {
-				continue;
-			}
-
-			irDebugInfo *type_di = ir_add_debug_info_type(module, e->type, e, scope, nullptr);
-			GB_ASSERT_NOT_NULL(type_di);
-			array_add(&di->ProcType.types->DebugInfoArray.elements, type_di);
-		}
-	}
-
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_type(irModule *module, Type *type, Entity *e, irDebugInfo *scope, irDebugInfo *file) {
-	// NOTE(lachsinc): Special handling for procedure pointers - we hash their types directly into DISubroutineType's
-	// but we need them interpreted as pointers when we use them as variables.
-	if (type->kind == Type_Proc) {
-		if (e->kind == Entity_Variable || e->kind == Entity_TypeName) {
-			// TODO(lachsinc): Wasteful (maybe?). Create a derived type for _every_ different proc ptr type
-			irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DerivedType);
-			map_set(&module->debug_info, hash_pointer(di), di);
-			di->DerivedType.tag = irDebugBasicEncoding_pointer_type;
-			di->DerivedType.size = ir_debug_size_bits(t_rawptr);
-			di->DerivedType.base_type = ir_add_debug_info_proc_type(module, type);
-			return di;
-		} else {
-			GB_PANIC("Proc definitions should have their type created manually (not through this function)");
-		}
-	}
-
-	irDebugInfo **existing = map_get(&module->debug_info, hash_type(type));
-	if (existing != nullptr) {
-		return *existing;
-	}
-
-	// Reset entity/location info, if applicable, for every type we try add.
-	// TODO(lachsinc): Confirm this doesn't mess up field's scopes etc.
-	if (type->kind == Type_Named) {
-		e = type->Named.type_name;
-		if (e) {
-			CheckerInfo *info = module->info;
-			file = ir_add_debug_info_file(module, ast_file_of_filename(info, get_file_path_string(e->token.pos.file_id)));
-			// TODO(lachsinc): Determine proper scope for type declaration location stuff.
-			scope = file;
-		}
-	}
-
-	// TODO(lachsinc): Reorder if tests, "unique" types, like basic etc. should go last, they are most likely to hit the existing hashed type
-	// and no point checking them for the rest of the types. Or just use a massive switch...
-
-	// NOTE(lachsinc): Types should be inserted into debug_info map as their named, not base_type()'d counterparts.
-	Type *base = base_type(type);
-
-	if (type->kind == Type_Named) {
-		Type *named_base = type->Named.base;
-		// TODO(lachsinc): Better way to determine distinct etc. or just handle structs, enums before we reach here.
-		// ir_is_type_aggregate() except with no call to base_type().
-		if (named_base->kind != Type_Struct &&
-			named_base->kind != Type_Union &&
-			named_base->kind != Type_Enum &&
-			named_base->kind != Type_Tuple) {
-			// distinct / typedef etc.
-			irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DerivedType);
-			if (type->kind == Type_Named) {
-				di->DerivedType.name = type->Named.name;
-			} else if (named_base->kind == Type_Basic) {
-				di->DerivedType.name = named_base->Basic.name;
-			}
-			di->DerivedType.tag = irDebugBasicEncoding_typedef;
-			map_set(&module->debug_info, hash_type(type), di);
-			// TODO(lachsinc): Do we need to try and resolve a new entity/scope for the base type?
-			// Maybe we also want to pull out type->Named.type_name ?? in the case it is a Named
-			di->DerivedType.base_type = ir_add_debug_info_type(module, named_base, e, scope, file);
-			return di;
-		}
-	}
-
-	if (type->kind == Type_Basic) {
-		switch (type->Basic.kind) {
-		// Composite basic types
-		case Basic_complex32: case Basic_complex64: case Basic_complex128:
-			return ir_add_debug_info_type_complex(module, type);
-		case Basic_quaternion64: case Basic_quaternion128: case Basic_quaternion256:
-			return ir_add_debug_info_type_quaternion(module, type);
-		case Basic_string:
-			return ir_add_debug_info_type_string(module, scope, e, type);
-		case Basic_any:
-			return ir_add_debug_info_type_any(module);
-
-		// Derived basic types
-		case Basic_cstring:
-		case Basic_rawptr: {
-			irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DerivedType);
-			di->DerivedType.name = type->Basic.name;
-			di->DerivedType.tag = irDebugBasicEncoding_pointer_type;
-			di->DerivedType.size = ir_debug_size_bits(t_rawptr);
-			di->DerivedType.align = ir_debug_align_bits(t_rawptr); // TODO(lachsinc): Not sure if align is required.
-			map_set(&module->debug_info, hash_type(type), di);
-			if (type->Basic.kind == Basic_cstring) {
-				di->DerivedType.base_type = ir_add_debug_info_type(module, t_i8, e, scope, file);
-			} else {
-				// NOTE(lachsinc): llvm expects "null" for rawptr/voidptr
-			}
-			return di;
-		}
-
-		// Basic basic types
-		default: {
-			irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_BasicType);
-			di->BasicType.encoding = ir_debug_encoding_for_basic(type->Basic.kind);
-			di->BasicType.name = type->Basic.name;
-			di->BasicType.size = ir_debug_size_bits(type);
-			di->BasicType.align = ir_debug_align_bits(type);
-			map_set(&module->debug_info, hash_type(type), di);
-			return di;
-		}
-		}
-	}
-
-	if (is_type_pointer(type)) {
-		// TODO(lachsinc): Ensure this handles pointer-to-pointer of same type etc. correctly.
-		Type *deref = type_deref(base);
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DerivedType);
-		di->DerivedType.tag = irDebugBasicEncoding_pointer_type;
-		di->DerivedType.size = ir_debug_size_bits(type);
-		// NOTE(lachsinc): Map set before creating base_type to avoid circular dependency issues.
-		map_set(&module->debug_info, hash_type(type), di);
-		if (is_type_struct(deref)) {
-			int i = 123;
-		}
-		di->DerivedType.base_type = ir_add_debug_info_type(module, deref, e, scope, file);
-		return di;
-	}
-
-	if (is_type_struct(type) ||
-	    is_type_union(type) || is_type_enum(type) || is_type_tuple(type)) {
-		if (type->kind == Type_Named) {
-			// NOTE(lachsinc): Named named's should always be handled prior as typedefs.
-			GB_ASSERT(type->Named.base->kind != Type_Named);
-		}
-
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-		// NOTE(lachsinc): Set map value before resolving field types to avoid circular dependencies.
-		map_set(&module->debug_info, hash_type(type), di);
-		if (is_type_named(type)) {
-			di->CompositeType.name = type->kind == Type_Named ? type->Named.name : type->Basic.name;
-		}
-		if (e) {
-			di->CompositeType.file = file;
-			di->CompositeType.scope = scope;
-			di->CompositeType.pos = e->token.pos;
-		}
-		di->CompositeType.size = ir_debug_size_bits(type);
-		// di->CompositeType.align = ir_debug_align_bits(type); // TODO(lachsinc): Necessary?
-
-		if (is_type_struct(type)) {
-			GB_ASSERT(base->kind == Type_Struct);
-			if (!is_type_named(type)) {
-				di->CompositeType.name = str_lit("struct");
-				GB_ASSERT_NOT_NULL(scope);
-				di->CompositeType.scope = scope;
-			}
-			di->CompositeType.tag = irDebugBasicEncoding_structure_type;
-			di->CompositeType.elements = ir_add_debug_info_array(module, 0, base->Struct.fields.count);
-			for_array(field_index, base->Struct.fields) {
-				array_add(&di->CompositeType.elements->DebugInfoArray.elements,
-				          ir_add_debug_info_field(module, di, base->Struct.fields[field_index], type,
-				                                  cast(i32)field_index, base->Struct.fields[field_index]->type, file));
-			}
-		} else if (is_type_union(type)) {
-			GB_ASSERT(base->kind == Type_Union);
-			if (!is_type_named(type)) {
-				di->CompositeType.name = str_lit("union");
-				GB_ASSERT_NOT_NULL(scope);
-				di->CompositeType.scope = scope;
-			}
-			di->CompositeType.tag = irDebugBasicEncoding_union_type;
-			di->CompositeType.elements = ir_add_debug_info_array(module, 0, base->Union.variants.count);
-			// TODO(lachsinc): Cleanup; this should be handled in a more generic manner for all types.
-			file = ir_add_debug_info_file(module, base->Union.node->file);
-			GB_ASSERT_NOT_NULL(file); // Union debug info requires file info
-			di->CompositeType.file = file;
-			di->CompositeType.pos = base->Union.node->UnionType.token.pos;
-			for_array(field_index, base->Union.variants) {
-				// TODO(bill): Union pseudo-"fields"
-				// irDebugInfo *di = ir_add_debug_info_field(module, di, nullptr, type, cast(i32)field_index, base->Union.variants[field_index], file);
-				// array_add(&di->CompositeType.elements->DebugInfoArray.elements, di);
-			}
-		} else if (is_type_enum(type)) {
-			GB_ASSERT(base->kind == Type_Enum);
-			if (!is_type_named(type)) {
-				di->CompositeType.name = str_lit("enum");
-				GB_ASSERT_NOT_NULL(scope);
-				di->CompositeType.scope = scope;
-			}
-			di->CompositeType.tag = irDebugBasicEncoding_enumeration_type;
-			di->CompositeType.base_type = ir_add_debug_info_type(module, base->Enum.base_type, e, scope, file);
-			di->CompositeType.elements = ir_add_debug_info_array(module, 0, base->Enum.fields.count);
-			for_array(field_index, base->Enum.fields) {
-				array_add(&di->CompositeType.elements->DebugInfoArray.elements,
-				          ir_add_debug_info_enumerator(module, base->Enum.fields[field_index]));
-			}
-
-			// TODO(lachsinc): Do we want to ensure this is an enum in the global scope before
-			// adding it into the modules enum array ??
-			array_add(&module->debug_compile_unit->CompileUnit.enums->DebugInfoArray.elements, di);
-		} else if (is_type_tuple(type)) {
-			GB_ASSERT(base->kind == Type_Tuple);
-			if (!is_type_named(type)) {
-				di->CompositeType.name = str_lit("tuple");
-				GB_ASSERT_NOT_NULL(scope);
-				di->CompositeType.scope = scope;
-			}
-			di->CompositeType.tag = irDebugBasicEncoding_structure_type;
-			di->CompositeType.elements = ir_add_debug_info_array(module, 0, base->Tuple.variables.count);
-			// TODO(lachsinc): Ensure offsets are set properly?
-			for_array(var_index, base->Tuple.variables) {
-				array_add(&di->CompositeType.elements->DebugInfoArray.elements,
-				          ir_add_debug_info_field(module, di, base->Tuple.variables[var_index], type,
-				                                  cast(i32)var_index, base->Tuple.variables[var_index]->type, file));
-			}
-		}
-
-		return di;
-	}
-
-	if (is_type_dynamic_array(type)) {
-		return ir_add_debug_info_type_dynamic_array(module, type, e, scope, file);
-	}
-
-	if (is_type_array(type)) {
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-		di->CompositeType.size = ir_debug_size_bits(type);
-		di->CompositeType.align = ir_debug_align_bits(type);
-		di->CompositeType.tag = irDebugBasicEncoding_array_type;
-		di->CompositeType.array_count = (i32)type->Array.count;
-
-		map_set(&module->debug_info, hash_type(type), di);
-		di->CompositeType.base_type = ir_add_debug_info_type(module, type->Array.elem, e, scope, file);
-		GB_ASSERT(base->kind != Type_Named);
-
-		return di;
-	}
-
-	if (is_type_enumerated_array(type)) {
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-		di->CompositeType.size = ir_debug_size_bits(type);
-		di->CompositeType.align = ir_debug_align_bits(type);
-		di->CompositeType.tag = irDebugBasicEncoding_array_type;
-		di->CompositeType.array_count = (i32)type->EnumeratedArray.count;
-
-		map_set(&module->debug_info, hash_type(type), di);
-		di->CompositeType.base_type = ir_add_debug_info_type(module, type->EnumeratedArray.elem, e, scope, file);
-		GB_ASSERT(base->kind != Type_Named);
-
-		return di;
-	}
-
-	if (is_type_slice(type)) {
-		// NOTE(lachsinc): Every slice type has its own composite type / field debug infos created. This is sorta wasteful.
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-		di->CompositeType.name = str_lit("slice");
-		di->CompositeType.tag = irDebugBasicEncoding_structure_type;
-		di->CompositeType.size = ir_debug_size_bits(type); // TODO(lachsinc): Correct ??
-		di->CompositeType.align = ir_debug_align_bits(type);
-		map_set(&module->debug_info, hash_type(type), di);
-
-		// Data pointer type
-		irDebugInfo *data_ptr_di = ir_alloc_debug_info(irDebugInfo_DerivedType);
-		Type *elem_type = type->Slice.elem;
-		if (is_type_named(elem_type)) {
-			data_ptr_di->DerivedType.name = elem_type->kind == Type_Named ? elem_type->Named.name : elem_type->Basic.name;
-		}
-		data_ptr_di->DerivedType.tag = irDebugBasicEncoding_pointer_type;
-		data_ptr_di->DerivedType.size = ir_debug_size_bits(t_rawptr);
-		map_set(&module->debug_info, hash_pointer(data_ptr_di), data_ptr_di);
-		data_ptr_di->DerivedType.base_type = ir_add_debug_info_type(module, elem_type, e, scope, file);
-
-		irDebugInfo *data_di = ir_add_debug_info_field_internal(module, str_lit("data"), t_rawptr,
-		                                                        0,
-		                                                        nullptr,
-		                                                        di);
-		data_di->DerivedType.base_type = data_ptr_di;
-		map_set(&module->debug_info, hash_pointer(data_di), data_di);
-
-		irDebugInfo *len_di = ir_add_debug_info_field_internal(module, str_lit("len"), t_int,
-		                                                       data_di->DerivedType.size,
-		                                                       nullptr,
-		                                                       di);
-		map_set(&module->debug_info, hash_pointer(len_di), len_di);
-
-		irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 2);
-		array_add(&elements_di->DebugInfoArray.elements, data_di);
-		array_add(&elements_di->DebugInfoArray.elements, len_di);
-		di->CompositeType.elements = elements_di;
-		map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
-
-		return di;
-	}
-
-	if (is_type_map(type)) {
-		// TODO(lachsinc): Looks like "generated_struct_type" map.entries.data is just a u8*, we could
-		// always look at the map header and create the debug info manually (if we
-		// want struct members to be interpreted as the correct type).
-		// Also; are hashes meant to be interpreted as bool*'s ?? or is that simply slot occupied data?
-		return ir_add_debug_info_type(module, type->Map.generated_struct_type, e, scope, file);
-	}
-
-	// NOTE(lachsinc): For now we just interpret all BitFieldValues as i64 inside ir_add_debug_info_type_bit_field().
-	/*
-	if (is_type_bit_field_value(type)) {
-		// NOTE(Lachsinc): Suboptimal; creates a new type for each unique bit field value type
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_BasicType);
-		di->BasicType.encoding = irDebugBasicEncoding_unsigned;
-		// di->BasicType.name = str_lit("todo");
-		di->BasicType.size = base->BitFieldValue.bits;
-		map_set(&module->debug_info, hash_type(type), di);
-		return di;
-	}
-	*/
-
-	if (is_type_bit_set(type)) {
-		return ir_add_debug_info_type_bit_set(module, type, e, scope);
-	}
-
-	if (is_type_simd_vector(type)) {
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-		di->CompositeType.size = ir_debug_size_bits(type);
-		di->CompositeType.align = ir_debug_align_bits(type);
-		di->CompositeType.tag = irDebugBasicEncoding_array_type;
-		di->CompositeType.array_count = (i32)type->SimdVector.count;
-
-		map_set(&module->debug_info, hash_type(type), di);
-		di->CompositeType.base_type = ir_add_debug_info_type(module, type->SimdVector.elem, e, scope, file);
-		GB_ASSERT(base->kind != Type_Named);
-		return di;
-	}
-
-	if (is_type_relative_pointer(type)) {
-		Type *base_integer = base_type(type)->RelativePointer.base_integer;
-		base_integer = core_type(base_integer);
-		GB_ASSERT(base_integer->kind == Type_Basic);
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_BasicType);
-		di->BasicType.encoding = ir_debug_encoding_for_basic(base_integer->Basic.kind);
-		di->BasicType.name = base_integer->Basic.name;
-		di->BasicType.size = ir_debug_size_bits(type);
-		di->BasicType.align = ir_debug_align_bits(type);
-		map_set(&module->debug_info, hash_type(type), di);
-		return di;
-	}
-
-	if (is_type_relative_slice(type)) {
-		Type *base_integer = base_type(type)->RelativeSlice.base_integer;
-		base_integer = core_type(base_integer);
-
-		// NOTE(lachsinc): Every slice type has its own composite type / field debug infos created. This is sorta wasteful.
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
-		di->CompositeType.name = str_lit("relative slice");
-		di->CompositeType.tag = irDebugBasicEncoding_structure_type;
-		di->CompositeType.size = ir_debug_size_bits(type); // TODO(lachsinc): Correct ??
-		di->CompositeType.align = ir_debug_align_bits(type);
-		map_set(&module->debug_info, hash_type(type), di);
-
-		irDebugInfo *data_di = ir_add_debug_info_field_internal(module, str_lit("data"), base_integer,
-		                                                        0,
-		                                                        nullptr,
-		                                                        di);
-		map_set(&module->debug_info, hash_pointer(data_di), data_di);
-
-		irDebugInfo *len_di = ir_add_debug_info_field_internal(module, str_lit("len"), base_integer,
-		                                                       data_di->DerivedType.size,
-		                                                       nullptr,
-		                                                       di);
-		map_set(&module->debug_info, hash_pointer(len_di), len_di);
-
-		irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 2);
-		array_add(&elements_di->DebugInfoArray.elements, data_di);
-		array_add(&elements_di->DebugInfoArray.elements, len_di);
-		di->CompositeType.elements = elements_di;
-		map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
-
-		return di;
-	}
-
-	GB_PANIC("Unreachable %s", type_to_string(type));
-	return nullptr;
-}
-
-irDebugInfo *ir_add_debug_info_global(irModule *module, irValue *v) {
-	if (!module->generate_debug_info) {
-		return nullptr;
-	}
-
-	Entity *e = v->Global.entity;
-
-	// NOTE(lachsinc): Just to be safe/robust; globals are likely added once only?
-	irDebugInfo **existing = map_get(&module->debug_info, hash_entity(e));
-	if (existing != nullptr) {
-		return *existing;
-	}
-
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_GlobalVariableExpression);
-	map_set(&module->debug_info, hash_entity(e), di);
-
-	// Create or fetch file debug info.
-	CheckerInfo *info = module->info;
-	String filename = get_file_path_string(e->token.pos.file_id);
-	AstFile *f = ast_file_of_filename(info, filename);
-	GB_ASSERT_NOT_NULL(f);
-	irDebugInfo *scope = ir_add_debug_info_file(module, f);
-
-	irDebugInfo *var_di = ir_alloc_debug_info(irDebugInfo_GlobalVariable);
-	var_di->GlobalVariable.name = e->token.string;
-	var_di->GlobalVariable.scope = scope;
-	var_di->GlobalVariable.file = scope;
-	var_di->GlobalVariable.pos = e->token.pos;
-	var_di->GlobalVariable.variable = v;
-
-	// NOTE(lachsinc): The "DIGlobalVariableExpression" owns us, and is what we refer to from other
-	// locations in the ir source, so we will reserve the "e" hash for it, and use something else
-	// unique for the DIGlobalVariable's hash.
-	map_set(&module->debug_info, hash_pointer(var_di), var_di);
-
-	var_di->GlobalVariable.type = ir_add_debug_info_type(module, e->type, nullptr, scope, nullptr);
-	GB_ASSERT_NOT_NULL(var_di->GlobalVariable.type);
-
-	di->GlobalVariableExpression.var = var_di;
-
-	array_add(&module->debug_compile_unit->CompileUnit.globals->DebugInfoArray.elements, di);
-
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_block(irProcedure *proc, Scope *scope) {
-	irModule *module = proc->module;
-
-	irDebugInfo **existing = map_get(&module->debug_info, hash_pointer(scope));
-	if (existing != nullptr) {
-		GB_ASSERT((*existing)->kind == irDebugInfo_LexicalBlock);
-		return *existing;
-	}
-
-	Ast *block = scope->node;
-
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_LexicalBlock);
-	di->LexicalBlock.file = proc->debug_scope->Proc.file;
-	di->LexicalBlock.scope = proc->debug_scope;
-	di->LexicalBlock.pos = ast_token(block).pos;
-	map_set(&module->debug_info, hash_pointer(scope), di);
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_local(irProcedure *proc, Entity *e, i32 arg_id) {
-	// TODO(lachsinc): Not sure if this handles generated locals properly as they may not have
-	// enough information contained inside "e".
-
-	irModule *module = proc->module;
-	if (!module->generate_debug_info) {
-		return nullptr;
-	}
-
-	irDebugInfo *scope = nullptr;
-	irDebugInfo *file = nullptr;
-	if (e->scope && e->scope->node->kind == Ast_ProcType) {
-		scope = proc->debug_scope;
-		file = proc->debug_scope->Proc.file;
-	} else {
-		scope = ir_add_debug_info_block(proc, e->scope);
-		file = scope->LexicalBlock.file;
-	}
-	GB_ASSERT_NOT_NULL(scope);
-	GB_ASSERT_NOT_NULL(file);
-
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_LocalVariable);
-	di->LocalVariable.name = e->token.string;
-	di->LocalVariable.scope = scope;
-	di->LocalVariable.file = file;
-	di->LocalVariable.pos = e->token.pos;
-	di->LocalVariable.arg = arg_id;
-	di->LocalVariable.type = ir_add_debug_info_type(module, e->type, e, scope, file); // TODO(lachsinc): Is this the correct entity to pass? Or do we want a TypeName ??
-
-	map_set(&module->debug_info, hash_entity(e), di);
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_proc(irProcedure *proc) {
-	irModule *module = proc->module;
-	if (!module->generate_debug_info) {
-		return nullptr;
-	}
-
-	Entity *entity = proc->entity;
-
-	// Add / retrieve debug info for file.
-	CheckerInfo *info = proc->module->info;
-	String filename = get_file_path_string(proc->entity->token.pos.file_id);
-	AstFile *f = ast_file_of_filename(info, filename);
-	irDebugInfo *file = nullptr;
-	if (f) {
-		file = ir_add_debug_info_file(proc->module, f);
-	}
-	// TODO(lachsinc): Should scope be made separate to file?
-	irDebugInfo *scope = file;
-
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_Proc);
-	map_set(&proc->module->debug_info, hash_entity(entity), di);
-	di->Proc.entity = entity;
-	di->Proc.name = proc->name;
-	di->Proc.file = file;
-	di->Proc.pos = entity->token.pos;
-	di->Proc.type = ir_add_debug_info_proc_type(proc->module, proc->type);
-
-	proc->debug_scope = di;
-	return di;
-}
-
-irDebugInfo *ir_add_debug_info_location(irModule *m, Ast *node, irDebugInfo *scope, Entity *e) {
-	if (node == nullptr || scope == nullptr) {
-		if (e != nullptr && scope != nullptr) {
-			// irDebugInfo **existing = map_get(&m->debug_info, hash_entity(e));
-			// if (existing != nullptr) {
-			// 	return *existing;
-			// }
-
-			// // TODO HACK(bill): This is a little dirty but it is should do for the weird edge cases
-			// irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_Location);
-			// di->Location.pos = e->token.pos;
-			// di->Location.scope = scope;
-			// map_set(&m->debug_info, hash_entity(e), di);
-			// return di;
-		}
-		return nullptr;
-	}
-	// TODO(lachsinc): Should we traverse the node/children until we find one with
-	// valid token/pos and use that instead??
-	irDebugInfo **existing = map_get(&m->debug_info, hash_node(node));
-	if (existing != nullptr) {
-		return *existing;
-	}
-	irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_Location);
-	di->Location.pos = ast_token(node).pos;
-	di->Location.scope = scope;
-	map_set(&m->debug_info, hash_node(node), di);
-	return di;
-}
-
-void ir_push_debug_location(irModule *m, Ast *node, irDebugInfo *scope, Entity *e) {
-	irDebugInfo *debug_location = ir_add_debug_info_location(m, node, scope, e);
-	array_add(&m->debug_location_stack, debug_location);
-}
-
-void ir_pop_debug_location(irModule *m) {
-	GB_ASSERT_MSG(m->debug_location_stack.count > 0, "Attempt to pop debug location stack too many times");
-	array_pop(&m->debug_location_stack);
-}
-
-////////////////////////////////////////////////////////////////
-//
-// @Emit
-//
-////////////////////////////////////////////////////////////////
-
-irValue *ir_emit_runtime_call(irProcedure *proc,                            char const *name_, Array<irValue *> args, Ast *expr = nullptr, ProcInlining inlining = ProcInlining_none);
-irValue *ir_emit_package_call(irProcedure *proc, char const *package_name_, char const *name_, Array<irValue *> args, Ast *expr = nullptr, ProcInlining inlining = ProcInlining_none);
-
-bool ir_type_requires_mem_zero(Type *t) {
-	t = core_type(t);
-	isize sz = type_size_of(t);
-	if (t->kind == Type_SimdVector) {
-		return false;
-	}
-
-	if (!(gb_is_power_of_two(sz) && sz <= build_context.max_align)) {
-		return true;
-	}
-
-	enum : i64 {LARGE_SIZE = 64};
-	if (sz > LARGE_SIZE) {
-		return true;
-	}
-
-	switch (t->kind) {
-	case Type_Union:
-		return true;
-	case Type_Struct:
-		if (t->Struct.is_raw_union) {
-			return true;
-		}
-		if (t->Struct.is_packed) {
-			return false;
-		} else {
-			i64 packed_sized = 0;
-			for_array(i, t->Struct.fields) {
-				Entity *f = t->Struct.fields[i];
-				if (f->kind == Entity_Variable) {
-					packed_sized += type_size_of(f->type);
-				}
-			}
-			return sz != packed_sized;
-		}
-		break;
-	case Type_Tuple:
-		if (t->Tuple.is_packed) {
-			return false;
-		} else {
-			i64 packed_sized = 0;
-			for_array(i, t->Tuple.variables) {
-				Entity *f = t->Tuple.variables[i];
-				if (f->kind == Entity_Variable) {
-					packed_sized += type_size_of(f->type);
-				}
-			}
-			return sz != packed_sized;
-		}
-		break;
-
-	case Type_DynamicArray:
-	case Type_Map:
-		return true;
-	case Type_Array:
-		return ir_type_requires_mem_zero(t->Array.elem);
-	case Type_EnumeratedArray:
-		return ir_type_requires_mem_zero(t->EnumeratedArray.elem);
-	}
-	return false;
-}
-
-irValue *ir_call_mem_zero(irProcedure *p, irValue *address, Ast *expr = nullptr) {
-	Type *t = type_deref(ir_type(address));
-	// TODO(bill): Is this a good idea?
-	auto args = array_make<irValue *>(ir_allocator(), 2);
-	args[0] = ir_emit_conv(p, address, t_rawptr);
-	args[1] = ir_const_int(type_size_of(t));
-	AstPackage *pkg_runtime = get_core_package(p->module->info, str_lit("runtime"));
-	if (p->entity != nullptr) {
-		String name = p->entity->token.string;
-		if (p->entity->pkg != pkg_runtime && !(name == "mem_zero" || name == "memset")) {
-			ir_emit_comment(p, str_lit("ZeroInit"));
-			return ir_emit_package_call(p, "runtime", "mem_zero", args, expr);
-		}
-	}
-	return nullptr;
-}
-
-irValue *ir_emit_store(irProcedure *p, irValue *address, irValue *value, bool is_volatile) {
-	Type *a = type_deref(ir_type(address));
-
-	if (is_type_boolean(a)) {
-		// NOTE(bill): There are multiple sized booleans, thus force a conversion (if necessarily)
-		value = ir_emit_conv(p, value, a);
-	}
-
-	if (address) address->uses += 1;
-	if (value) value->uses += 1;
-
-
-	Type *b = ir_type(value);
-	if (!is_type_untyped(b)) {
-		GB_ASSERT_MSG(are_types_identical(core_type(a), core_type(b)), "%s %s", type_to_string(a), type_to_string(b));
-	}
-
-
-	if (value->kind == irValue_Constant) {
-		ExactValue const &v = value->Constant.value;
-		irValue *res = nullptr;
-		switch (v.kind) {
-		case ExactValue_Invalid:
-			res = ir_call_mem_zero(p, address);
-			if (res) {
-				return res;
-			}
-			goto end;
-
-		case ExactValue_Compound:
-			// NOTE(bill): This is to enforce the zeroing of the padding
-			if (ir_type_requires_mem_zero(a)) {
-				res = ir_call_mem_zero(p, address);
-				if (res == nullptr || v.value_compound == nullptr) {
-					goto end;
-				}
-				if (is_exact_value_zero(v)) {
-					return res;
-				}
-			}
-			goto end;
-		}
-	}
-
-end:;
-	return ir_emit(p, ir_instr_store(p, address, value, is_volatile));
-}
-irValue *ir_emit_load(irProcedure *p, irValue *address, i64 custom_align) {
-	GB_ASSERT(address != nullptr);
-	Type *t = type_deref(ir_type(address));
-	// if (is_type_boolean(t)) {
-		// return ir_emit(p, ir_instr_load_bool(p, address));
-	// }
-	if (address) address->uses += 1;
-	auto instr = ir_instr_load(p, address, false);
-	instr->Instr.Load.custom_align = custom_align;
-	return ir_emit(p, instr);
-}
-irValue *ir_emit_select(irProcedure *p, irValue *cond, irValue *t, irValue *f) {
-	if (cond) cond->uses += 1;
-	if (t) t->uses += 1;
-	if (f) f->uses += 1;
-
-	return ir_emit(p, ir_instr_select(p, cond, t, f));
-}
-
-void ir_value_set_debug_location(irProcedure *proc, irValue *v) {
-	GB_ASSERT_NOT_NULL(proc);
-	GB_ASSERT_NOT_NULL(v);
-
-	if (v->loc != nullptr) {
-		return; // Already set
-	}
-
-	if (proc->is_startup) {
-		// ignore startup procedures
-		return;
-	}
-
-	irModule *m = proc->module;
-	GB_ASSERT(m->debug_location_stack.count > 0);
-	v->loc = *array_end_ptr(&m->debug_location_stack);
-
-	if (v->loc == nullptr && proc->entity != nullptr) {
-		if (proc->is_entry_point || (string_compare(proc->name, str_lit(IR_STARTUP_RUNTIME_PROC_NAME)) == 0)) {
-			// NOTE(lachsinc): Entry point (main()) and runtime_startup are the only ones where null location is considered valid.
-		} else {
-			if (v->kind == irValue_Instr) {
-				auto *instr = &v->Instr;
-				gb_printf_err("Instruction kind: %.*s\n", LIT(ir_instr_strings[instr->kind]));
-				if (instr->kind == irInstr_DebugDeclare) {
-					gb_printf_err("\t%.*s\n", LIT(instr->DebugDeclare.entity->token.string));
-				}
-			}
-			GB_PANIC("Value without debug location: %.*s %p; %p :: %s", LIT(proc->name), proc->entity, v, type_to_string(proc->type));
-		}
-	}
-}
-
-irValue *ir_emit_zero_init(irProcedure *p, irValue *address, Ast *expr) {
-	gbAllocator a = ir_allocator();
-	Type *t = type_deref(ir_type(address));
-
-	if (address) address->uses += 1;
-
-	if (ir_type_requires_mem_zero(t)) {
-		irValue *res = ir_call_mem_zero(p, address, expr);
-		if (res) {
-			return res;
-		}
-	}
-	return ir_emit(p, ir_instr_zero_init(p, address));
-}
-
-irValue *ir_emit_comment(irProcedure *p, String text) {
-	return ir_emit(p, ir_instr_comment(p, text));
-}
-
-void ir_emit_init_context(irProcedure *proc, irValue *c) {
-	GB_ASSERT(c != nullptr);
-	irModule *m = proc->module;
-	gbAllocator a = ir_allocator();
-	auto args = array_make<irValue *>(a, 1);
-	args[0] = c;
-	ir_emit_runtime_call(proc, "__init_context", args);
-}
-
-
-
-
-
-
-irValue *ir_copy_value_to_ptr(irProcedure *proc, irValue *val, Type *new_type, i64 alignment) {
-	i64 type_alignment = type_align_of(new_type);
-	if (alignment < type_alignment) {
-		alignment = type_alignment;
-	}
-	GB_ASSERT_MSG(are_types_identical(new_type, ir_type(val)), "%s %s", type_to_string(new_type), type_to_string(ir_type(val)));
-
-	irValue *ptr = ir_add_local_generated(proc, new_type, false);
-	ptr->Instr.Local.alignment = alignment;
-	ir_emit_store(proc, ptr, val);
-
-	return ptr;
-}
-
-irValue *ir_emit_bitcast(irProcedure *proc, irValue *data, Type *type) {
-	return ir_emit(proc, ir_instr_conv(proc, irConv_bitcast, data, ir_type(data), type));
-}
-
-void ir_emit_unreachable(irProcedure *proc) {
-	ir_emit(proc, ir_instr_unreachable(proc));
-}
-
-
-irValue *ir_get_package_value(irModule *m, String package_name, String entity_name) {
-	AstPackage *rt_pkg = get_core_package(m->info, package_name);
-	Entity *e = scope_lookup_current(rt_pkg->scope, entity_name);
-	irValue **found = map_get(&m->values, hash_entity(e));
-	GB_ASSERT_MSG(found != nullptr, "%.*s", LIT(e->token.string));
-	return *found;
-}
-
-irValue *ir_find_or_generate_context_ptr(irProcedure *proc) {
-	if (proc->context_stack.count > 0) {
-		return proc->context_stack[proc->context_stack.count-1].value;
-	}
-
-	irValue *c = ir_add_local_generated(proc, t_context, true);
-	ir_push_context_onto_stack(proc, c);
-	ir_emit_init_context(proc, c);
-	return c;
-}
-
-Array<irValue *> ir_value_to_array(irProcedure *p, irValue *value) {
-	Array<irValue *> array = {};
-	Type *t = base_type(ir_type(value));
-	if (t == nullptr) {
-		// Do nothing
-	} else if (is_type_tuple(t)) {
-		GB_ASSERT(t->kind == Type_Tuple);
-		auto *rt = &t->Tuple;
-		if (rt->variables.count > 0) {
-			array = array_make<irValue *>(ir_allocator(), rt->variables.count);
-			for_array(i, rt->variables) {
-				irValue *elem = ir_emit_struct_ev(p, value, cast(i32)i);
-				array[i] = elem;
-			}
-		}
-	} else {
-		array = array_make<irValue *>(ir_allocator(), 1);
-		array[0] = value;
-	}
-	return array;
-}
-
-
-irValue *ir_emit_call(irProcedure *p, irValue *value, Array<irValue *> const &args, ProcInlining inlining = ProcInlining_none, bool use_return_ptr_hint = false) {
-	Type *pt = base_type(ir_type(value));
-	GB_ASSERT(pt->kind == Type_Proc);
-	Type *results = pt->Proc.results;
-
-	if (p->entity != nullptr) {
-		if (p->entity->flags & EntityFlag_Disabled) {
-			return nullptr;
-		}
-	}
-
-	defer (if (pt->Proc.diverging) {
-		ir_emit_unreachable(p);
-	});
-
-	irValue *context_ptr = nullptr;
-	if (pt->Proc.calling_convention == ProcCC_Odin) {
-		context_ptr = ir_find_or_generate_context_ptr(p);
-	}
-
-	set_procedure_abi_types(pt);
-
-	bool is_c_vararg = pt->Proc.c_vararg;
-	isize param_count = pt->Proc.param_count;
-	if (is_c_vararg) {
-		GB_ASSERT(param_count-1 <= args.count);
-		param_count -= 1;
-	} else {
-		GB_ASSERT_MSG(param_count == args.count, "%.*s %td == %td", LIT(p->entity->token.string), param_count, args.count);
-	}
-
-	auto processed_args = array_make<irValue *>(permanent_allocator(), 0, args.count);
-
-	for (isize i = 0; i < param_count; i++) {
-		Entity *e = pt->Proc.params->Tuple.variables[i];
-		if (e->kind != Entity_Variable) {
-			array_add(&processed_args, args[i]);
-			continue;
-		}
-		GB_ASSERT(e->flags & EntityFlag_Param);
-
-		Type *original_type = e->type;
-		Type *new_type = pt->Proc.abi_compat_params[i];
-		Type *arg_type = ir_type(args[i]);
-		if (are_types_identical(arg_type, new_type)) {
-			// NOTE(bill): Done
-			array_add(&processed_args, args[i]);
-		} else if (!are_types_identical(original_type, new_type)) {
-			if (is_type_pointer(new_type) && !is_type_pointer(original_type)) {
-				Type *av = core_type(type_deref(new_type));
-				if (are_types_identical(av, core_type(original_type))) {
-					if (e->flags&EntityFlag_ImplicitReference) {
-						array_add(&processed_args, ir_address_from_load_or_generate_local(p, args[i]));
-					} else if (!is_type_pointer(arg_type)) {
-						array_add(&processed_args, ir_copy_value_to_ptr(p, args[i], original_type, 16));
-					}
-				} else {
-					array_add(&processed_args, ir_emit_transmute(p, args[i], new_type));
-				}
-			} else if (is_type_integer(new_type) || is_type_float(new_type)) {
-				array_add(&processed_args, ir_emit_transmute(p, args[i], new_type));
-			} else if (new_type == t_llvm_bool) {
-				array_add(&processed_args, ir_emit_conv(p, args[i], new_type));
-			} else if (is_type_simd_vector(new_type)) {
-				array_add(&processed_args, ir_emit_transmute(p, args[i], new_type));
-			} else if (is_type_tuple(new_type)) {
-				Type *abi_type = pt->Proc.abi_compat_params[i];
-				Type *st = struct_type_from_systemv_distribute_struct_fields(abi_type);
-				irValue *x = nullptr;
-				i64 st_sz = type_size_of(st);
-				i64 arg_sz = type_size_of(ir_type(args[i]));
-				if (st_sz == arg_sz) {
-					x = ir_emit_transmute(p, args[i], st);
-				} else {
-					// NOTE(bill): struct{f32, f32, f32} != struct{#simd[2]f32, f32}
-					GB_ASSERT(st_sz > arg_sz);
-					irValue *xx = ir_add_local_generated(p, st, false);
-					irValue *pp = ir_emit_conv(p, xx, alloc_type_pointer(ir_type(args[i])));
-					ir_emit_store(p, pp, args[i]);
-					x = ir_emit_load(p, xx);
-				}
-				for (isize j = 0; j < new_type->Tuple.variables.count; j++) {
-					irValue *xx = ir_emit_struct_ev(p, x, cast(i32)j);
-					array_add(&processed_args, xx);
-				}
-			} else {
-				if (type_size_of(new_type) == type_size_of(original_type)) {
-					irValue *x = ir_emit_transmute(p, args[i], new_type);
-					array_add(&processed_args, x);
-				} else {
-					GB_PANIC("ABI ERROR: %s %s %s\n", type_to_string(original_type), type_to_string(new_type), type_to_string(arg_type));
-				}
-			}
-		} else {
-			irValue *x = ir_emit_conv(p, args[i], new_type);
-			array_add(&processed_args, x);
-		}
-	}
-
-	if (is_c_vararg) {
-			for (isize i = param_count; i < args.count; i++) {
-				array_add(&processed_args, args[i]);
-			}
-	}
-
-	if (inlining == ProcInlining_none) {
-		inlining = p->inlining;
-	}
-
-	irValue *result = nullptr;
-
-	Type *abi_rt = pt->Proc.abi_compat_result_type;
-	Type *rt = reduce_tuple_to_single_type(results);
-	if (pt->Proc.return_by_pointer) {
-		irValue *return_ptr = nullptr;
-		if (use_return_ptr_hint && p->return_ptr_hint_value != nullptr) {
-			if (are_types_identical(type_deref(ir_type(p->return_ptr_hint_value)), rt)) {
-				return_ptr = p->return_ptr_hint_value;
-				p->return_ptr_hint_used = true;
-				return_ptr->uses += 1;
-			}
-		}
-		if (return_ptr == nullptr) {
-			return_ptr = ir_add_local_generated(p, rt, true);
-		}
-		GB_ASSERT(is_type_pointer(ir_type(return_ptr)));
-		ir_emit(p, ir_instr_call(p, value, return_ptr, processed_args, nullptr, context_ptr, inlining));
-		result = ir_emit_load(p, return_ptr);
-	} else {
-		result = ir_emit(p, ir_instr_call(p, value, nullptr, processed_args, abi_rt, context_ptr, inlining));
-		if (abi_rt != results) {
-			result = ir_emit_transmute(p, result, rt);
-		}
-	}
-
-	if (value->kind == irValue_Proc) {
-		irProcedure *the_proc = &value->Proc;
-		Entity *e = the_proc->entity;
-		if (e != nullptr && entity_has_deferred_procedure(e)) {
-			DeferredProcedureKind kind = e->Procedure.deferred_procedure.kind;
-			Entity *deferred_entity = e->Procedure.deferred_procedure.entity;
-			irValue **deferred_found = map_get(&p->module->values, hash_entity(deferred_entity));
-			GB_ASSERT(deferred_found != nullptr);
-			irValue *deferred = *deferred_found;
-
-
-			auto in_args = args;
-			Array<irValue *> result_as_args = {};
-			switch (kind) {
-			case DeferredProcedure_none:
-				break;
-			case DeferredProcedure_in:
-				result_as_args = in_args;
-				break;
-			case DeferredProcedure_out:
-				result_as_args = ir_value_to_array(p, result);
-				break;
-			case DeferredProcedure_in_out:
-				{
-					auto out_args = ir_value_to_array(p, result);
-					array_init(&result_as_args, permanent_allocator(), in_args.count + out_args.count);
-					array_copy(&result_as_args, in_args, 0);
-					array_copy(&result_as_args, out_args, in_args.count);
-				}
-				break;
-			}
-
-			ir_add_defer_proc(p, p->scope_index, deferred, result_as_args);
-		}
-	}
-
-	return result;
-}
-
-irValue *ir_emit_runtime_call(irProcedure *proc, char const *name_, Array<irValue *> args, Ast *expr, ProcInlining inlining) {
-	String name = make_string_c(cast(char *)name_);
-
-	AstPackage *p = proc->module->info->runtime_package;
-	Entity *e = scope_lookup_current(p->scope, name);
-	irValue **found = map_get(&proc->module->values, hash_entity(e));
-	GB_ASSERT_MSG(found != nullptr, "%.*s", LIT(name));
-	irValue *gp = *found;
-	irValue *call = ir_emit_call(proc, gp, args, inlining);
-	return call;
-}
-irValue *ir_emit_package_call(irProcedure *proc, char const *package_name_, char const *name_, Array<irValue *> args, Ast *expr, ProcInlining inlining) {
-	String name = make_string_c(cast(char *)name_);
-	String package_name = make_string_c(cast(char *)package_name_);
-
-	AstPackage *p = get_core_package(proc->module->info, package_name);
-	Entity *e = scope_lookup_current(p->scope, name);
-	irValue **found = map_get(&proc->module->values, hash_entity(e));
-	GB_ASSERT_MSG(found != nullptr, "%s.%.*s", package_name_, LIT(name));
-	irValue *gp = *found;
-	irValue *call = ir_emit_call(proc, gp, args, inlining);
-	return call;
-}
-
-
-void ir_emit_defer_stmts(irProcedure *proc, irDeferExitKind kind, irBlock *block) {
-	isize count = proc->defer_stmts.count;
-	isize i = count;
-	while (i --> 0) {
-		irDefer d = proc->defer_stmts[i];
-
-		isize prev_context_stack_count = proc->context_stack.count;
-		defer (proc->context_stack.count = prev_context_stack_count);
-		proc->context_stack.count = d.context_stack_count;
-
-		if (kind == irDeferExit_Default) {
-			if (proc->scope_index == d.scope_index &&
-			    d.scope_index > 0) { // TODO(bill): Which is correct: > 0 or > 1?
-				ir_build_defer_stmt(proc, d);
-				array_pop(&proc->defer_stmts);
-				continue;
-			} else {
-				break;
-			}
-		} else if (kind == irDeferExit_Return) {
-			ir_build_defer_stmt(proc, d);
-		} else if (kind == irDeferExit_Branch) {
-			GB_ASSERT(block != nullptr);
-			isize lower_limit = block->scope_index;
-			if (lower_limit < d.scope_index) {
-				ir_build_defer_stmt(proc, d);
-			}
-		}
-	}
-}
-
-
-void ir_open_scope(irProcedure *proc) {
-	proc->scope_index++;
-}
-
-void ir_close_scope(irProcedure *proc, irDeferExitKind kind, irBlock *block, bool pop_stack=true) {
-	ir_emit_defer_stmts(proc, kind, block);
-	GB_ASSERT(proc->scope_index > 0);
-
-
-	// NOTE(bill): Remove `context`s made in that scope
-
-	isize end_idx = proc->context_stack.count-1;
-	isize pop_count = 0;
-
-	for (;;) {
-		if (end_idx < 0) {
-			break;
-		}
-		irContextData *end = &proc->context_stack[end_idx];
-		if (end == nullptr) {
-			break;
-		}
-		if (end->scope_index != proc->scope_index) {
-			break;
-		}
-		end_idx -= 1;
-		pop_count += 1;
-	}
-	if (pop_stack) {
-		for (isize i = 0; i < pop_count; i++) {
-			array_pop(&proc->context_stack);
-		}
-	}
-
-
-	proc->scope_index--;
-}
-
-
-
-void ir_emit_return(irProcedure *proc, irValue *v) {
-	ir_emit_defer_stmts(proc, irDeferExit_Return, nullptr);
-
-	if (proc->type->Proc.return_by_pointer) {
-		ir_emit_store(proc, proc->return_ptr, v);
-		ir_emit(proc, ir_instr_return(proc, nullptr));
-	} else {
-		Type *abi_rt = proc->type->Proc.abi_compat_result_type;
-		if (abi_rt != proc->type->Proc.results) {
-			v = ir_emit_transmute(proc, v, abi_rt);
-		}
-
-		ir_emit(proc, ir_instr_return(proc, v));
-	}
-
-	if (v) v->uses += 1;
-}
-
-void ir_emit_jump(irProcedure *proc, irBlock *target_block) {
-	irBlock *b = proc->curr_block;
-	if (b == nullptr) {
-		return;
-	}
-	ir_emit(proc, ir_instr_jump(proc, target_block));
-	ir_add_edge(b, target_block);
-	ir_start_block(proc, nullptr);
-}
-
-void ir_emit_if(irProcedure *proc, irValue *cond, irBlock *true_block, irBlock *false_block) {
-	irBlock *b = proc->curr_block;
-	if (b == nullptr) {
-		return;
-	}
-	ir_emit(proc, ir_instr_if(proc, cond, true_block, false_block));
-	ir_add_edge(b, true_block);
-	ir_add_edge(b, false_block);
-	ir_start_block(proc, nullptr);
-
-	if (cond) cond->uses += 1;
-}
-
-
-
-
-irValue *ir_emit_comp(irProcedure *proc, TokenKind op_kind, irValue *left, irValue *right);
-
-irValue *ir_gen_map_header(irProcedure *proc, irValue *map_val_ptr, Type *map_type) {
-	GB_ASSERT_MSG(is_type_pointer(ir_type(map_val_ptr)), "%s", type_to_string(ir_type(map_val_ptr)));
-	gbAllocator a = ir_allocator();
-	irValue *h = ir_add_local_generated(proc, t_map_header, false); // all the values will be initialzed later
-	map_type = base_type(map_type);
-
-	Type *key_type = map_type->Map.key;
-	Type *val_type = map_type->Map.value;
-
-	// NOTE(bill): Removes unnecessary allocation if split gep
-	irValue *gep0 = ir_emit_struct_ep(proc, h, 0);
-	irValue *m = ir_emit_conv(proc, map_val_ptr, type_deref(ir_type(gep0)));
-	ir_emit_store(proc, gep0, m);
-
-
-	i64 entry_size   = type_size_of  (map_type->Map.entry_type);
-	i64 entry_align  = type_align_of (map_type->Map.entry_type);
-	i64 key_offset   = type_offset_of(map_type->Map.entry_type, 2);
-	i64 key_size     = type_size_of  (map_type->Map.key);
-	i64 value_offset = type_offset_of(map_type->Map.entry_type, 3);
-	i64 value_size   = type_size_of  (map_type->Map.value);
-
-	ir_emit_store(proc, ir_emit_struct_ep(proc, h, 1), ir_get_equal_proc_for_type(proc->module, key_type));
-	ir_emit_store(proc, ir_emit_struct_ep(proc, h, 2), ir_const_int(entry_size));
-	ir_emit_store(proc, ir_emit_struct_ep(proc, h, 3), ir_const_int(entry_align));
-	ir_emit_store(proc, ir_emit_struct_ep(proc, h, 4), ir_const_uintptr(key_offset));
-	ir_emit_store(proc, ir_emit_struct_ep(proc, h, 5), ir_const_int(key_size));
-	ir_emit_store(proc, ir_emit_struct_ep(proc, h, 6), ir_const_uintptr(value_offset));
-	ir_emit_store(proc, ir_emit_struct_ep(proc, h, 7), ir_const_int(value_size));
-
-	return ir_emit_load(proc, h);
-}
-
-irValue *ir_const_hash(irModule *m, irValue *key, Type *key_type) {
-	irValue *hashed_key = nullptr;
-
-	if (key->kind == irValue_Constant) {
-		u64 hash = 0xcbf29ce484222325;
-		if (is_type_string(key_type)) {
-			GB_ASSERT(key->Constant.value.kind == ExactValue_String);
-			String s = key->Constant.value.value_string;
-			hash = fnv64a(s.text, s.len);
-		} else {
-			return nullptr;
-		}
-		// TODO(bill): other const hash types
-
-		if (build_context.word_size == 4) {
-			hash &= 0xffffffffull;
-		}
-		hashed_key = ir_const_uintptr(hash);
-	}
-
-	return hashed_key;
-}
-
-irValue *ir_gen_map_hash(irProcedure *proc, irValue *key, Type *key_type) {
-	Type *hash_type = t_u64;
-	irValue *v = ir_add_local_generated(proc, t_map_hash, true);
-	Type *t = base_type(ir_type(key));
-	key = ir_emit_conv(proc, key, key_type);
-
-	irValue *key_ptr = ir_address_from_load_or_generate_local(proc, key);
-	key_ptr = ir_emit_conv(proc, key_ptr, t_rawptr);
-
-	irValue *hashed_key = ir_const_hash(proc->module, key, key_type);
-	if (hashed_key == nullptr) {
-		irValue *hasher = ir_get_hasher_proc_for_type(proc->module, key_type);
-		auto args = array_make<irValue *>(permanent_allocator(), 2);
-		args[0] = key_ptr;
-		args[1] = ir_value_constant(t_uintptr, exact_value_i64(0));
-		hashed_key = ir_emit_call(proc, hasher, args);
-	}
-
-	ir_emit_store(proc, ir_emit_struct_ep(proc, v, 0), hashed_key);
-	ir_emit_store(proc, ir_emit_struct_ep(proc, v, 1), key_ptr);
-
-	return ir_emit_load(proc, v);
-}
-
-// NOTE(bill): Returns nullptr if not possible
-irValue *ir_address_from_load_or_generate_local(irProcedure *proc, irValue *val) {
-	if (val->kind == irValue_Instr) {
-		if (val->Instr.kind == irInstr_Load) {
-			return val->Instr.Load.address;
-		}
-	}
-	Type *type = ir_type(val);
-	irValue *local = ir_add_local_generated(proc, type, false);
-	ir_emit_store(proc, local, val);
-	return local;
-}
-irValue *ir_address_from_load(irProcedure *proc, irValue *val) {
-	if (val->kind == irValue_Instr) {
-		if (val->Instr.kind == irInstr_Load) {
-			return val->Instr.Load.address;
-		}
-	}
-	GB_PANIC("ir_address_from_load");
-	return nullptr;
-}
-
-
-Type *ir_addr_type(irAddr const &addr) {
-	if (addr.addr == nullptr) {
-		return nullptr;
-	}
-
-	if (addr.kind == irAddr_Map) {
-		Type *t = base_type(addr.map_type);
-		GB_ASSERT(is_type_map(t));
-		return t->Map.value;
-	}
-
-	Type *t = ir_type(addr.addr);
-	GB_ASSERT(is_type_pointer(t));
-	return type_deref(t);
-}
-
-irValue *ir_emit_source_code_location(irProcedure *proc, String procedure, TokenPos pos);
-irValue *ir_emit_source_code_location(irProcedure *proc, Ast *node);
-irValue *ir_emit_ptr_offset(irProcedure *proc, irValue *ptr, irValue *offset);
-irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue *right, Type *type);
-irValue *ir_emit_deep_field_gep(irProcedure *proc, irValue *e, Selection sel);
-void ir_emit_bounds_check(irProcedure *proc, Token token, irValue *index, irValue *len);
-
-
-irValue *ir_insert_dynamic_map_key_and_value(irProcedure *proc, irValue *addr, Type *map_type,
-                                             irValue *map_key, irValue *map_value, Ast *node) {
-	map_type = base_type(map_type);
-
-	irValue *h = ir_gen_map_header(proc, addr, map_type);
-	irValue *key = ir_gen_map_hash(proc, map_key, map_type->Map.key);
-	irValue *v = ir_emit_conv(proc, map_value, map_type->Map.value);
-
-	irValue *ptr = ir_add_local_generated(proc, ir_type(v), false);
-	ir_emit_store(proc, ptr, v);
-
-	auto args = array_make<irValue *>(ir_allocator(), 4);
-	args[0] = h;
-	args[1] = key;
-	args[2] = ir_emit_conv(proc, ptr, t_rawptr);
-	args[3] = ir_emit_source_code_location(proc, node);
-	return ir_emit_runtime_call(proc, "__dynamic_map_set", args);
-}
-
-
-
-irValue *ir_soa_struct_len(irProcedure *proc, irValue *value) {
-	Type *t = base_type(ir_type(value));
-	bool is_ptr = false;
-	if (is_type_pointer(t)) {
-		is_ptr = true;
-		t = base_type(type_deref(t));
-	}
-
-
-	if (t->Struct.soa_kind == StructSoa_Fixed) {
-		return ir_const_int(t->Struct.soa_count);
-	}
-
-	GB_ASSERT(t->Struct.soa_kind == StructSoa_Slice ||
-	          t->Struct.soa_kind == StructSoa_Dynamic);
-
-	isize n = 0;
-	Type *elem = base_type(t->Struct.soa_elem);
-	if (elem->kind == Type_Struct) {
-		n = elem->Struct.fields.count;
-	} else if (elem->kind == Type_Array) {
-		n = elem->Array.count;
-	} else {
-		GB_PANIC("Unreachable");
-	}
-
-	if (is_ptr) {
-		irValue *v = ir_emit_struct_ep(proc, value, cast(i32)n);
-		return ir_emit_load(proc, v);
-	}
-	return ir_emit_struct_ev(proc, value, cast(i32)n);
-}
-
-irValue *ir_soa_struct_cap(irProcedure *proc, irValue *value) {
-	Type *t = base_type(ir_type(value));
-
-	bool is_ptr = false;
-	if (is_type_pointer(t)) {
-		is_ptr = true;
-		t = base_type(type_deref(t));
-	}
-
-	if (t->Struct.soa_kind == StructSoa_Fixed) {
-		return ir_const_int(t->Struct.soa_count);
-	}
-
-	GB_ASSERT(t->Struct.soa_kind == StructSoa_Dynamic);
-
-	isize n = 0;
-	Type *elem = base_type(t->Struct.soa_elem);
-	if (elem->kind == Type_Struct) {
-		n = elem->Struct.fields.count+1;
-	} else if (elem->kind == Type_Array) {
-		n = elem->Array.count+1;
-	} else {
-		GB_PANIC("Unreachable");
-	}
-
-	if (is_ptr) {
-		irValue *v = ir_emit_struct_ep(proc, value, cast(i32)n);
-		return ir_emit_load(proc, v);
-	}
-	return ir_emit_struct_ev(proc, value, cast(i32)n);
-}
-
-
-irValue *ir_addr_load(irProcedure *proc, irAddr const &addr);
-
-void ir_addr_store(irProcedure *proc, irAddr addr, irValue *value) {
-	if (addr.addr == nullptr) {
-		return;
-	}
-	if (addr.kind == irAddr_RelativePointer && addr.relative.deref) {
-		addr = ir_addr(ir_address_from_load(proc, ir_addr_load(proc, addr)));
-	}
-
-	if (addr.kind == irAddr_RelativePointer) {
-		Type *rel_ptr = base_type(ir_addr_type(addr));
-		GB_ASSERT(rel_ptr->kind == Type_RelativePointer);
-
-		value = ir_emit_conv(proc, value, rel_ptr->RelativePointer.pointer_type);
-
-		GB_ASSERT(is_type_pointer(ir_type(addr.addr)));
-		irValue *ptr = ir_emit_conv(proc, addr.addr, t_uintptr);
-		irValue *val_ptr = ir_emit_conv(proc, value, t_uintptr);
-		irValue *offset = offset = ir_emit_arith(proc, Token_Sub, val_ptr, ptr, t_uintptr);
-
-		if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) {
-			offset = ir_emit_conv(proc, offset, t_i64);
-		}
-		offset = ir_emit_conv(proc, offset, rel_ptr->RelativePointer.base_integer);
-
-		irValue *offset_ptr = ir_emit_conv(proc, addr.addr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer));
-		offset = ir_emit_select(proc,
-			ir_emit_comp(proc, Token_CmpEq, val_ptr, ir_value_nil(t_uintptr)),
-			ir_value_nil(rel_ptr->RelativePointer.base_integer),
-			offset
-		);
-		ir_emit_store(proc, offset_ptr, offset);
-		return;
-
-	} else if (addr.kind == irAddr_RelativeSlice) {
-		Type *rel_ptr = base_type(ir_addr_type(addr));
-		GB_ASSERT(rel_ptr->kind == Type_RelativeSlice);
-
-		value = ir_emit_conv(proc, value, rel_ptr->RelativeSlice.slice_type);
-
-		GB_ASSERT(is_type_pointer(ir_type(addr.addr)));
-		irValue *ptr = ir_emit_conv(proc, ir_emit_struct_ep(proc, addr.addr, 0), t_uintptr);
-		irValue *val_ptr = ir_emit_conv(proc, ir_slice_elem(proc, value), t_uintptr);
-		irValue *offset = ir_emit_arith(proc, Token_Sub, val_ptr, ptr, t_uintptr);
-
-		if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) {
-			offset = ir_emit_conv(proc, offset, t_i64);
-		}
-		offset = ir_emit_conv(proc, offset, rel_ptr->RelativePointer.base_integer);
-
-		irValue *offset_ptr = ir_emit_conv(proc, addr.addr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer));
-		offset = ir_emit_select(proc,
-			ir_emit_comp(proc, Token_CmpEq, val_ptr, ir_value_nil(t_uintptr)),
-			ir_value_nil(rel_ptr->RelativePointer.base_integer),
-			offset
-		);
-		ir_emit_store(proc, offset_ptr, offset);
-
-		irValue *len = ir_slice_len(proc, value);
-		len = ir_emit_conv(proc, len, rel_ptr->RelativePointer.base_integer);
-
-		irValue *len_ptr = ir_emit_struct_ep(proc, addr.addr, 1);
-		ir_emit_store(proc, len_ptr, len);
-
-		return;
-
-	} else if (addr.kind == irAddr_Map) {
-		ir_insert_dynamic_map_key_and_value(proc, addr.addr, addr.map_type, addr.map_key, value, proc->curr_stmt);
-		return;
-	} else if (addr.kind == irAddr_Context) {
-		irValue *old = ir_emit_load(proc, ir_find_or_generate_context_ptr(proc));
-		irValue *next = ir_add_local_generated(proc, t_context, true);
-		ir_emit_store(proc, next, old);
-		ir_push_context_onto_stack(proc, next);
-
-		if (addr.ctx.sel.index.count > 0) {
-			irValue *lhs = ir_emit_deep_field_gep(proc, next, addr.ctx.sel);
-			irValue *rhs = ir_emit_conv(proc, value, type_deref(ir_type(lhs)));
-			ir_emit_store(proc, lhs, rhs);
-		} else {
-			irValue *lhs = next;
-			irValue *rhs = ir_emit_conv(proc, value, ir_addr_type(addr));
-			ir_emit_store(proc, lhs, rhs);
-		}
-
-		return;
-	} else if (addr.kind == irAddr_SoaVariable) {
-		Type *t = type_deref(ir_type(addr.addr));
-		t = base_type(t);
-		GB_ASSERT(t->kind == Type_Struct && t->Struct.soa_kind != StructSoa_None);
-		Type *elem_type = t->Struct.soa_elem;
-		value = ir_emit_conv(proc, value, elem_type);
-		elem_type = base_type(elem_type);
-
-		irValue *index = addr.soa.index;
-		if (index->kind != irValue_Constant || t->Struct.soa_kind != StructSoa_Fixed) {
-			Type *t = base_type(type_deref(ir_type(addr.addr)));
-			GB_ASSERT(t->kind == Type_Struct && t->Struct.soa_kind != StructSoa_None);
-			irValue *len = ir_soa_struct_len(proc, addr.addr);
-			ir_emit_bounds_check(proc, ast_token(addr.soa.index_expr), index, len);
-		}
-
-		isize field_count = 0;
-
-		switch (elem_type->kind) {
-		case Type_Struct:
-			field_count = elem_type->Struct.fields.count;
-			break;
-		case Type_Array:
-			field_count = elem_type->Array.count;
-			break;
-		}
-		for (isize i = 0; i < field_count; i++) {
-			irValue *dst = ir_emit_struct_ep(proc, addr.addr, cast(i32)i);
-			irValue *src = ir_emit_struct_ev(proc, value, cast(i32)i);
-			if (t->Struct.soa_kind == StructSoa_Fixed) {
-				dst = ir_emit_array_ep(proc, dst, index);
-				ir_emit_store(proc, dst, src);
-			} else {
-				irValue *field = ir_emit_load(proc, dst);
-				dst = ir_emit_ptr_offset(proc, field, index);
-				ir_emit_store(proc, dst, src);
-			}
-		}
-		return;
-	}
-
-	irValue *v = ir_emit_conv(proc, value, ir_addr_type(addr));
-	ir_emit_store(proc, addr.addr, v);
-}
-
-irValue *ir_addr_load(irProcedure *proc, irAddr const &addr) {
-	if (addr.addr == nullptr) {
-		GB_PANIC("Illegal addr load");
-		return nullptr;
-	}
-
-	if (addr.kind == irAddr_RelativePointer) {
-		Type *rel_ptr = base_type(ir_addr_type(addr));
-		GB_ASSERT(rel_ptr->kind == Type_RelativePointer);
-
-		irValue *ptr = ir_emit_conv(proc, addr.addr, t_uintptr);
-		irValue *offset = ir_emit_conv(proc, ptr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer));
-		offset = ir_emit_load(proc, offset);
-
-
-		if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) {
-			offset = ir_emit_conv(proc, offset, t_i64);
-		}
-		offset = ir_emit_conv(proc, offset, t_uintptr);
-		irValue *absolute_ptr = ir_emit_arith(proc, Token_Add, ptr, offset, t_uintptr);
-		absolute_ptr = ir_emit_conv(proc, absolute_ptr, rel_ptr->RelativePointer.pointer_type);
-
-		irValue *cond = ir_emit_comp(proc, Token_CmpEq, offset, ir_value_nil(rel_ptr->RelativePointer.base_integer));
-
-		// NOTE(bill): nil check
-		irValue *nil_ptr = ir_value_nil(rel_ptr->RelativePointer.pointer_type);
-		irValue *final_ptr = ir_emit_select(proc, cond, nil_ptr, absolute_ptr);
-
-		return ir_emit_load(proc, final_ptr);
-
-	} else if (addr.kind == irAddr_RelativeSlice) {
-		Type *rel_ptr = base_type(ir_addr_type(addr));
-		GB_ASSERT(rel_ptr->kind == Type_RelativeSlice);
-
-		irValue *offset_ptr = ir_emit_struct_ep(proc, addr.addr, 0);
-		irValue *ptr = ir_emit_conv(proc, offset_ptr, t_uintptr);
-		irValue *offset = ir_emit_load(proc, offset_ptr);
-
-
-		if (!is_type_unsigned(rel_ptr->RelativeSlice.base_integer)) {
-			offset = ir_emit_conv(proc, offset, t_i64);
-		}
-		offset = ir_emit_conv(proc, offset, t_uintptr);
-		irValue *absolute_ptr = ir_emit_arith(proc, Token_Add, ptr, offset, t_uintptr);
-
-		Type *slice_type = base_type(rel_ptr->RelativeSlice.slice_type);
-		GB_ASSERT(rel_ptr->RelativeSlice.slice_type->kind == Type_Slice);
-		Type *slice_elem = slice_type->Slice.elem;
-		Type *slice_elem_ptr = alloc_type_pointer(slice_elem);
-
-		absolute_ptr = ir_emit_conv(proc, absolute_ptr, slice_elem_ptr);
-
-		irValue *cond = ir_emit_comp(proc, Token_CmpEq, offset, ir_value_nil(rel_ptr->RelativeSlice.base_integer));
-
-		// NOTE(bill): nil check
-		irValue *nil_ptr = ir_value_nil(slice_elem_ptr);
-		irValue *data = ir_emit_select(proc, cond, nil_ptr, absolute_ptr);
-
-		irValue *len = ir_emit_load(proc, ir_emit_struct_ep(proc, addr.addr, 1));
-		len = ir_emit_conv(proc, len, t_int);
-
-		irValue *slice = ir_add_local_generated(proc, slice_type, false);
-		ir_fill_slice(proc, slice, data, len);
-		return ir_emit_load(proc, slice);
-
-
-	} else if (addr.kind == irAddr_Map) {
-		Type *map_type = base_type(addr.map_type);
-		irValue *v = ir_add_local_generated(proc, map_type->Map.lookup_result_type, true);
-		irValue *h = ir_gen_map_header(proc, addr.addr, map_type);
-		irValue *key = ir_gen_map_hash(proc, addr.map_key, map_type->Map.key);
-
-		auto args = array_make<irValue *>(ir_allocator(), 2);
-		args[0] = h;
-		args[1] = key;
-
-		irValue *ptr = ir_emit_runtime_call(proc, "__dynamic_map_get", args);
-		irValue *ok = ir_emit_conv(proc, ir_emit_comp(proc, Token_NotEq, ptr, v_raw_nil), t_bool);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, v, 1), ok);
-
-		irBlock *then = ir_new_block(proc, nullptr, "map.get.then");
-		irBlock *done = ir_new_block(proc, nullptr, "map.get.done");
-		ir_emit_if(proc, ok, then, done);
-		ir_start_block(proc, then);
-		{
-			// TODO(bill): mem copy it instead?
-			irValue *gep0 = ir_emit_struct_ep(proc, v, 0);
-			irValue *value = ir_emit_conv(proc, ptr, ir_type(gep0));
-			ir_emit_store(proc, gep0, ir_emit_load(proc, value));
-		}
-		ir_emit_jump(proc, done);
-		ir_start_block(proc, done);
-
-
-		if (is_type_tuple(addr.map_result)) {
-			return ir_emit_load(proc, v);
-		} else {
-			irValue *single = ir_emit_struct_ep(proc, v, 0);
-			return ir_emit_load(proc, single);
-		}
-	} else if (addr.kind == irAddr_Context) {
-		if (addr.ctx.sel.index.count > 0) {
-			irValue *a = addr.addr;
-			irValue *b = ir_emit_deep_field_gep(proc, a, addr.ctx.sel);
-			return ir_emit_load(proc, b);
-		}
-	} else if (addr.kind == irAddr_SoaVariable) {
-		Type *t = type_deref(ir_type(addr.addr));
-		t = base_type(t);
-		GB_ASSERT(t->kind == Type_Struct && t->Struct.soa_kind != StructSoa_None);
-		Type *elem = t->Struct.soa_elem;
-
-		irValue *len = nullptr;
-		if (t->Struct.soa_kind == StructSoa_Fixed) {
-			len = ir_const_int(t->Struct.soa_count);
-		} else {
-			irValue *v = ir_emit_load(proc, addr.addr);
-			len = ir_soa_struct_len(proc, v);
-		}
-
-		irValue *res = ir_add_local_generated(proc, elem, true);
-
-		if (addr.soa.index->kind != irValue_Constant || t->Struct.soa_kind != StructSoa_Fixed) {
-			ir_emit_bounds_check(proc, ast_token(addr.soa.index_expr), addr.soa.index, len);
-		}
-
-		if (t->Struct.soa_kind == StructSoa_Fixed) {
-			for_array(i, t->Struct.fields) {
-				Entity *field = t->Struct.fields[i];
-				Type *base_type = field->type;
-				GB_ASSERT(base_type->kind == Type_Array);
-
-				irValue *dst = ir_emit_struct_ep(proc, res, cast(i32)i);
-				irValue *src_ptr = ir_emit_struct_ep(proc, addr.addr, cast(i32)i);
-				src_ptr = ir_emit_array_ep(proc, src_ptr, addr.soa.index);
-				irValue *src = ir_emit_load(proc, src_ptr);
-				ir_emit_store(proc, dst, src);
-			}
-		} else {
-			isize field_count = t->Struct.fields.count;
-			if (t->Struct.soa_kind == StructSoa_Slice) {
-				field_count -= 1;
-			} else if (t->Struct.soa_kind == StructSoa_Dynamic) {
-				field_count -= 3;
-			}
-			for (isize i = 0; i < field_count; i++) {
-				Entity *field = t->Struct.fields[i];
-				Type *base_type = field->type;
-				GB_ASSERT(base_type->kind == Type_Pointer);
-				Type *elem = base_type->Pointer.elem;
-
-				irValue *dst = ir_emit_struct_ep(proc, res, cast(i32)i);
-				irValue *src_ptr = ir_emit_struct_ep(proc, addr.addr, cast(i32)i);
-				src_ptr = ir_emit_ptr_offset(proc, src_ptr, addr.soa.index);
-				irValue *src = ir_emit_load(proc, src_ptr);
-				src = ir_emit_load(proc, src);
-				ir_emit_store(proc, dst, src);
-			}
-		}
-
-		return ir_emit_load(proc, res);
-	}
-
-	Type *t = base_type(ir_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 ir_emit_load(proc, addr.addr);
-}
-
-irValue *ir_addr_get_ptr(irProcedure *proc, irAddr const &addr, bool allow_reference=false) {
-	if (addr.addr == nullptr) {
-		GB_PANIC("Illegal addr -> nullptr");
-		return nullptr;
-	}
-
-	switch (addr.kind) {
-	case irAddr_Map: {
-		if (allow_reference) {
-			Type *map_type = base_type(addr.map_type);
-			irValue *h = ir_gen_map_header(proc, addr.addr, map_type);
-			irValue *key = ir_gen_map_hash(proc, addr.map_key, map_type->Map.key);
-
-			auto args = array_make<irValue *>(ir_allocator(), 2);
-			args[0] = h;
-			args[1] = key;
-
-			irValue *ptr = ir_emit_runtime_call(proc, "__dynamic_map_get", args);
-			return ir_emit_conv(proc, ptr, alloc_type_pointer(map_type->Map.value));
-		} else {
-			irValue *v = ir_addr_load(proc, addr);
-			return ir_address_from_load_or_generate_local(proc, v);
-		}
-	}
-
-	case irAddr_RelativePointer: {
-		Type *rel_ptr = base_type(ir_addr_type(addr));
-		GB_ASSERT(rel_ptr->kind == Type_RelativePointer);
-
-		irValue *ptr = ir_emit_conv(proc, addr.addr, t_uintptr);
-		irValue *offset = ir_emit_conv(proc, ptr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer));
-		offset = ir_emit_load(proc, offset);
-
-		if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) {
-			offset = ir_emit_conv(proc, offset, t_i64);
-		}
-		offset = ir_emit_conv(proc, offset, t_uintptr);
-		irValue *absolute_ptr = ir_emit_arith(proc, Token_Add, ptr, offset, t_uintptr);
-		absolute_ptr = ir_emit_conv(proc, absolute_ptr, rel_ptr->RelativePointer.pointer_type);
-
-		irValue *cond = ir_emit_comp(proc, Token_CmpEq, offset, ir_value_nil(rel_ptr->RelativePointer.base_integer));
-
-		// NOTE(bill): nil check
-		irValue *nil_ptr = ir_value_nil(rel_ptr->RelativePointer.pointer_type);
-		irValue *final_ptr = ir_emit_select(proc, cond, nil_ptr, absolute_ptr);
-		return final_ptr;
-	}
-
-	case irAddr_Context:
-		GB_PANIC("irAddr_Context should be handled elsewhere");
-	}
-
-	return addr.addr;
-}
-
-irValue *ir_build_addr_ptr(irProcedure *proc, Ast *expr) {
-	irAddr addr = ir_build_addr(proc, expr);
-	return ir_addr_get_ptr(proc, addr);
-}
-
-
-irValue *ir_dynamic_array_len(irProcedure *proc, irValue *da);
-irValue *ir_dynamic_array_cap(irProcedure *proc, irValue *da);
-
-
-irValue *ir_map_entries(irProcedure *proc, irValue *value) {
-	gbAllocator a = ir_allocator();
-	Type *t = base_type(ir_type(value));
-	GB_ASSERT_MSG(t->kind == Type_Map, "%s", type_to_string(t));
-	init_map_internal_types(t);
-	Type *gst = t->Map.generated_struct_type;
-	i32 index = 1;
-	irValue *entries = ir_emit(proc, ir_instr_struct_extract_value(proc, value, index, gst->Struct.fields[index]->type));
-	return entries;
-}
-
-irValue *ir_map_entries_ptr(irProcedure *proc, irValue *value) {
-	gbAllocator a = ir_allocator();
-	Type *t = base_type(type_deref(ir_type(value)));
-	if (is_type_pointer(t)) {
-		value = ir_emit_load(proc, value);
-		t = base_type(type_deref(t));
-	}
-	GB_ASSERT_MSG(t->kind == Type_Map, "%s", type_to_string(t));
-	init_map_internal_types(t);
-	Type *gst = t->Map.generated_struct_type;
-	i32 index = 1;
-	Type *ptr_t = alloc_type_pointer(gst->Struct.fields[index]->type);
-	irValue *entries = ir_emit(proc, ir_instr_struct_element_ptr(proc, value, index, ptr_t));
-	return entries;
-}
-
-irValue *ir_map_len(irProcedure *proc, irValue *value) {
-	irValue *entries = ir_map_entries(proc, value);
-	return ir_dynamic_array_len(proc, entries);
-}
-
-irValue *ir_map_cap(irProcedure *proc, irValue *value) {
-	irValue *entries = ir_map_entries(proc, value);
-	return ir_dynamic_array_cap(proc, entries);
-}
-
-
-
-
-struct irLoopData {
-	irValue *idx_addr;
-	irValue *idx;
-	irBlock *body;
-	irBlock *done;
-	irBlock *loop;
-};
-
-irLoopData ir_loop_start(irProcedure *proc, isize count, Type *index_type=t_int) {
-	irLoopData data = {};
-
-	irValue *max = ir_const_int(count);
-
-	data.idx_addr = ir_add_local_generated(proc, index_type, true);
-
-	data.body = ir_new_block(proc, nullptr, "loop.body");
-	data.done = ir_new_block(proc, nullptr, "loop.done");
-	data.loop = ir_new_block(proc, nullptr, "loop.loop");
-
-	ir_emit_jump(proc, data.loop);
-	ir_start_block(proc, data.loop);
-
-	data.idx = ir_emit_load(proc, data.idx_addr);
-
-	irValue *cond = ir_emit_comp(proc, Token_Lt, data.idx, max);
-	ir_emit_if(proc, cond, data.body, data.done);
-	ir_start_block(proc, data.body);
-
-	return data;
-}
-
-void ir_loop_end(irProcedure *proc, irLoopData const &data) {
-	if (data.idx_addr != nullptr) {
-		ir_emit_increment(proc, data.idx_addr);
-		ir_emit_jump(proc, data.loop);
-		ir_start_block(proc, data.done);
-	}
-}
-
-
-
-
-irValue *ir_emit_ptr_offset(irProcedure *proc, irValue *ptr, irValue *offset) {
-	offset = ir_emit_conv(proc, offset, t_int);
-	return ir_emit(proc, ir_instr_ptr_offset(proc, ptr, offset));
-}
-
-irValue *ir_emit_unary_arith(irProcedure *proc, TokenKind op, irValue *x, Type *type) {
-	switch (op) {
-	case Token_Add:
-		return x;
-	case Token_Not: // Boolean not
-	case Token_Xor: // Bitwise not
-	case Token_Sub: // Bitwise Not
-		break;
-	case Token_Pointer:
-		GB_PANIC("This should be handled elsewhere");
-		break;
-	}
-
-	if (is_type_array(ir_type(x))) {
-		ir_emit_comment(proc, str_lit("array.arith.begin"));
-		// IMPORTANT TODO(bill): This is very wasteful with regards to stack memory
-		Type *tl = base_type(ir_type(x));
-		irValue *val = ir_address_from_load_or_generate_local(proc, x);
-		GB_ASSERT(is_type_array(type));
-		Type *elem_type = base_array_type(type);
-
-		// NOTE(bill): Doesn't need to be zero because it will be initialized in the loops
-		irValue *res = ir_add_local_generated(proc, type, false);
-
-		bool inline_array_arith = type_size_of(type) <= build_context.max_align;
-
-		i32 count = cast(i32)tl->Array.count;
-
-		if (inline_array_arith) {
-			// inline
-			for (i32 i = 0; i < count; i++) {
-				irValue *e = ir_emit_load(proc, ir_emit_array_epi(proc, val, i));
-				irValue *z = ir_emit_unary_arith(proc, op, e, elem_type);
-				ir_emit_store(proc, ir_emit_array_epi(proc, res, i), z);
-			}
-		} else {
-			auto loop_data = ir_loop_start(proc, count, t_i32);
-
-			irValue *e = ir_emit_load(proc, ir_emit_array_ep(proc, val, loop_data.idx));
-			irValue *z = ir_emit_unary_arith(proc, op, e, elem_type);
-			ir_emit_store(proc, ir_emit_array_ep(proc, res, loop_data.idx), z);
-
-			ir_loop_end(proc, loop_data);
-		}
-		ir_emit_comment(proc, str_lit("array.arith.end"));
-		return ir_emit_load(proc, res);
-
-	}
-
-	if (op == Token_Not) {
-		irValue *cmp = ir_emit_comp(proc, Token_CmpEq, x, v_false);
-		return ir_emit_conv(proc, cmp, type);
-	}
-
-	if (op == Token_Sub && is_type_integer(type) && is_type_different_to_arch_endianness(type)) {
-		Type *platform_type = integer_endian_type_to_platform_type(type);
-		irValue *v = ir_emit_byte_swap(proc, x, platform_type);
-		irValue *res = ir_emit(proc, ir_instr_unary_op(proc, op, v, platform_type));
-		return ir_emit_byte_swap(proc, res, type);
-	}
-
-	if (op == Token_Sub && is_type_float(type) && is_type_different_to_arch_endianness(type)) {
-		Type *platform_type = integer_endian_type_to_platform_type(type);
-		irValue *v = ir_emit_byte_swap(proc, x, platform_type);
-		irValue *res = ir_emit(proc, ir_instr_unary_op(proc, op, v, platform_type));
-		return ir_emit_byte_swap(proc, res, type);
-	}
-
-	if (op == Token_Sub) {
-		if (is_type_integer(ir_type(x))) {
-			return ir_emit(proc, ir_instr_unary_op(proc, op, x, type));
-		} else if (is_type_float(ir_type(x))) {
-			return ir_emit(proc, ir_instr_unary_op(proc, op, x, type));
-		} else if (is_type_complex(ir_type(x))) {
-			irValue *addr = ir_add_local_generated(proc, ir_type(x), false);
-
-			irValue *v0 = ir_emit_struct_ev(proc, x, 0);
-			irValue *v1 = ir_emit_struct_ev(proc, x, 1);
-			v0 = ir_emit(proc, ir_instr_unary_op(proc, op, v0, ir_type(v0)));
-			v1 = ir_emit(proc, ir_instr_unary_op(proc, op, v1, ir_type(v1)));
-			ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 0), v0);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 1), v1);
-
-			return ir_emit_load(proc, addr);
-		} else if (is_type_quaternion(ir_type(x))) {
-			irValue *addr = ir_add_local_generated(proc, ir_type(x), false);
-
-			irValue *v0 = ir_emit_struct_ev(proc, x, 0);
-			irValue *v1 = ir_emit_struct_ev(proc, x, 1);
-			irValue *v2 = ir_emit_struct_ev(proc, x, 2);
-			irValue *v3 = ir_emit_struct_ev(proc, x, 3);
-			v0 = ir_emit(proc, ir_instr_unary_op(proc, op, v0, ir_type(v0)));
-			v1 = ir_emit(proc, ir_instr_unary_op(proc, op, v1, ir_type(v1)));
-			v2 = ir_emit(proc, ir_instr_unary_op(proc, op, v2, ir_type(v2)));
-			v3 = ir_emit(proc, ir_instr_unary_op(proc, op, v3, ir_type(v3)));
-			ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 0), v0);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 1), v1);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 2), v2);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 3), v3);
-
-			return ir_emit_load(proc, addr);
-		}
-	}
-
-	return ir_emit(proc, ir_instr_unary_op(proc, op, x, type));
-}
-
-
-
-irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue *right, Type *type) {
-	Type *t_left = ir_type(left);
-	Type *t_right = ir_type(right);
-
-	if (is_type_array(t_left) || is_type_array(t_right)) {
-		ir_emit_comment(proc, str_lit("array.arith.begin"));
-		// IMPORTANT TODO(bill): This is very wasteful with regards to stack memory
-		left  = ir_emit_conv(proc, left, type);
-		right = ir_emit_conv(proc, right, type);
-		irValue *lhs = ir_address_from_load_or_generate_local(proc, left);
-		irValue *rhs = ir_address_from_load_or_generate_local(proc, right);
-		GB_ASSERT(is_type_array(type));
-		Type *elem_type = base_array_type(type);
-
-		// NOTE(bill): Doesn't need to be zero because it will be initialized in the loops
-		irValue *res = ir_add_local_generated(proc, type, false);
-		i64 count = base_type(type)->Array.count;
-
-		bool inline_array_arith = type_size_of(type) <= build_context.max_align;
-
-		if (inline_array_arith) {
-			// inline
-			for (i32 i = 0; i < count; i++) {
-				irValue *x_ptr = ir_emit_array_epi(proc, lhs, i);
-				irValue *y_ptr = ir_emit_array_epi(proc, rhs, i);
-				irValue *dst_ptr = ir_emit_array_epi(proc, res, i);
-				irValue *x = ir_emit_load(proc, x_ptr);
-				irValue *y = ir_emit_load(proc, y_ptr);
-				irValue *z = ir_emit_arith(proc, op, x, y, elem_type);
-				ir_emit_store(proc, dst_ptr, z);
-			}
-		} else {
-			auto loop_data = ir_loop_start(proc, count, t_i32);
-
-			irValue *x_ptr = ir_emit_array_ep(proc, lhs, loop_data.idx);
-			irValue *y_ptr = ir_emit_array_ep(proc, rhs, loop_data.idx);
-			irValue *dst_ptr = ir_emit_array_ep(proc, res, loop_data.idx);
-
-			irValue *x = ir_emit_load(proc, x_ptr);
-			irValue *y = ir_emit_load(proc, y_ptr);
-			irValue *z = ir_emit_arith(proc, op, x, y, elem_type);
-			ir_emit_store(proc, dst_ptr, z);
-
-			ir_loop_end(proc, loop_data);
-		}
-		ir_emit_comment(proc, str_lit("array.arith.end"));
-		return ir_emit_load(proc, res);
-	}
-
-	if (is_type_complex(t_left)) {
-		ir_emit_comment(proc, str_lit("complex.arith.begin"));
-		defer (ir_emit_comment(proc, str_lit("complex.arith.end")));
-
-		Type *ft = base_complex_elem_type(t_left);
-
-		if (op == Token_Quo) {
-			auto args = array_make<irValue *>(permanent_allocator(), 2);
-			args[0] = left;
-			args[1] = right;
-
-			switch (type_size_of(ft)) {
-			case 4: return ir_emit_runtime_call(proc, "quo_complex64", args);
-			case 8: return ir_emit_runtime_call(proc, "quo_complex128", args);
-			default: GB_PANIC("Unknown float type"); break;
-			}
-		}
-
-		irValue *res = ir_add_local_generated(proc, type, false); // NOTE: initialized in full later
-		irValue *a = ir_emit_struct_ev(proc, left,  0);
-		irValue *b = ir_emit_struct_ev(proc, left,  1);
-		irValue *c = ir_emit_struct_ev(proc, right, 0);
-		irValue *d = ir_emit_struct_ev(proc, right, 1);
-
-		irValue *real = nullptr;
-		irValue *imag = nullptr;
-
-		switch (op) {
-		case Token_Add:
-			real = ir_emit_arith(proc, Token_Add, a, c, ft);
-			imag = ir_emit_arith(proc, Token_Add, b, d, ft);
-			break;
-		case Token_Sub:
-			real = ir_emit_arith(proc, Token_Sub, a, c, ft);
-			imag = ir_emit_arith(proc, Token_Sub, b, d, ft);
-			break;
-		case Token_Mul: {
-			irValue *x = ir_emit_arith(proc, Token_Mul, a, c, ft);
-			irValue *y = ir_emit_arith(proc, Token_Mul, b, d, ft);
-			real = ir_emit_arith(proc, Token_Sub, x, y, ft);
-			irValue *z = ir_emit_arith(proc, Token_Mul, b, c, ft);
-			irValue *w = ir_emit_arith(proc, Token_Mul, a, d, ft);
-			imag = ir_emit_arith(proc, Token_Add, z, w, ft);
-			break;
-		}
-		}
-
-		ir_emit_store(proc, ir_emit_struct_ep(proc, res, 0), real);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, res, 1), imag);
-
-		return ir_emit_load(proc, res);
-	}
-
-	if (is_type_quaternion(t_left)) {
-		ir_emit_comment(proc, str_lit("complex.arith.begin"));
-		defer (ir_emit_comment(proc, str_lit("complex.arith.end")));
-
-		right = ir_emit_conv(proc, right, t_left);
-
-		Type *ft = base_complex_elem_type(t_left);
-
-		if (op == Token_Add || op == Token_Sub) {
-			irValue *res = ir_add_local_generated(proc, type, false); // NOTE: initialized in full later
-			irValue *x0 = ir_emit_struct_ev(proc, left,  0);
-			irValue *x1 = ir_emit_struct_ev(proc, left,  1);
-			irValue *x2 = ir_emit_struct_ev(proc, left,  2);
-			irValue *x3 = ir_emit_struct_ev(proc, left,  3);
-
-			irValue *y0 = ir_emit_struct_ev(proc, right, 0);
-			irValue *y1 = ir_emit_struct_ev(proc, right, 1);
-			irValue *y2 = ir_emit_struct_ev(proc, right, 2);
-			irValue *y3 = ir_emit_struct_ev(proc, right, 3);
-
-			irValue *z0 = ir_emit_arith(proc, op, x0, y0, ft);
-			irValue *z1 = ir_emit_arith(proc, op, x1, y1, ft);
-			irValue *z2 = ir_emit_arith(proc, op, x2, y2, ft);
-			irValue *z3 = ir_emit_arith(proc, op, x3, y3, ft);
-
-			ir_emit_store(proc, ir_emit_struct_ep(proc, res, 0), z0);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, res, 1), z1);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, res, 2), z2);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, res, 3), z3);
-
-			return ir_emit_load(proc, res);
-		} else if (op == Token_Mul) {
-			auto args = array_make<irValue *>(permanent_allocator(), 2);
-			args[0] = left;
-			args[1] = right;
-
-			switch (8*type_size_of(ft)) {
-			case 32: return ir_emit_runtime_call(proc, "mul_quaternion128", args);
-			case 64: return ir_emit_runtime_call(proc, "mul_quaternion256", args);
-			default: GB_PANIC("Unknown float type"); break;
-			}
-		} else if (op == Token_Quo) {
-			auto args = array_make<irValue *>(permanent_allocator(), 2);
-			args[0] = left;
-			args[1] = right;
-
-			switch (8*type_size_of(ft)) {
-			case 32: return ir_emit_runtime_call(proc, "quo_quaternion128", args);
-			case 64: return ir_emit_runtime_call(proc, "quo_quaternion256", args);
-			default: GB_PANIC("Unknown float type"); break;
-			}
-		}
-	}
-
-
-#if 0
-	if (op == Token_Add) {
-		if (is_type_pointer(t_left)) {
-			irValue *ptr = ir_emit_conv(proc, left, type);
-			irValue *offset = right;
-			return ir_emit_ptr_offset(proc, ptr, offset);
-		} else if (is_type_pointer(ir_type(right))) {
-			irValue *ptr = ir_emit_conv(proc, right, type);
-			irValue *offset = left;
-			return ir_emit_ptr_offset(proc, ptr, offset);
-		}
-	} else if (op == Token_Sub) {
-		if (is_type_pointer(t_left) && is_type_integer(t_right)) {
-			// ptr - int
-			irValue *ptr = ir_emit_conv(proc, left, type);
-			irValue *offset = ir_emit_unary_arith(proc, Token_Sub, right, t_int);
-			return ir_emit_ptr_offset(proc, ptr, offset);
-		} else if (is_type_pointer(t_left) && is_type_pointer(t_right)) {
-			GB_ASSERT(is_type_integer(type));
-			irModule *m = proc->module;
-			Type *ptr_type = base_type(t_left);
-			GB_ASSERT(!is_type_rawptr(ptr_type));
-			irValue *elem_size = ir_const_int(type_size_of(ptr_type->Pointer.elem));
-			irValue *x = ir_emit_conv(proc, ir_emit_conv(proc, left, t_uintptr), type);
-			irValue *y = ir_emit_conv(proc, ir_emit_conv(proc, right, t_uintptr), type);
-			irValue *diff = ir_emit_arith(proc, op, x, y, type);
-			return ir_emit_arith(proc, Token_Quo, diff, elem_size, type);
-		}
-	}
-#endif
-
-	if (is_type_integer(type) && is_type_different_to_arch_endianness(type)) {
-		switch (op) {
-		case Token_AndNot:
-		case Token_And:
-		case Token_Or:
-		case Token_Xor:
-			goto handle_op;
-		}
-		Type *platform_type = integer_endian_type_to_platform_type(type);
-		irValue *x = ir_emit_conv(proc, left, integer_endian_type_to_platform_type(t_left));
-		irValue *y = ir_emit_conv(proc, right, integer_endian_type_to_platform_type(t_right));
-
-		irValue *res = ir_emit_arith(proc, op, x, y, platform_type);
-
-		return ir_emit_byte_swap(proc, res, type);
-	}
-
-	if (is_type_float(type) && is_type_different_to_arch_endianness(type)) {
-		Type *platform_type = integer_endian_type_to_platform_type(type);
-		irValue *x = ir_emit_conv(proc, left, integer_endian_type_to_platform_type(t_left));
-		irValue *y = ir_emit_conv(proc, right, integer_endian_type_to_platform_type(t_right));
-
-		irValue *res = ir_emit_arith(proc, op, x, y, platform_type);
-
-		return ir_emit_byte_swap(proc, res, type);
-	}
-
-handle_op:
-
-	// NOTE(bill): Bit Set Aliases for + and -
-	if (is_type_bit_set(type)) {
-		switch (op) {
-		case Token_Add: op = Token_Or;     break;
-		case Token_Sub: op = Token_AndNot; break;
-		}
-	}
-
-	switch (op) {
-	case Token_Shl:
-		{
-			left = ir_emit_conv(proc, left, type);
-			right = ir_emit_conv(proc, right, type);
-			ir_emit(proc, ir_instr_binary_op(proc, op, left, right, type));
-
-			irValue *bits = right;
-
-			irValue *bit_size = ir_value_constant(type, exact_value_i64(8*type_size_of(type)));
-			irValue *width_test = ir_emit(proc, ir_instr_binary_op(proc, Token_Lt, bits, bit_size, t_llvm_bool));
-
-			irValue *zero = ir_value_constant(type, exact_value_i64(0));
-			irValue *res = ir_emit(proc, ir_instr_binary_op(proc, op, left, bits, type));
-			return ir_emit_select(proc, width_test, res, zero);
-		}
-	case Token_Shr:
-		{
-			left = ir_emit_conv(proc, left, type);
-			right = ir_emit_conv(proc, right, type);
-			bool is_unsigned = is_type_unsigned(ir_type(left));
-
-			irValue *bits = right;
-
-			irValue *bit_size = ir_value_constant(type, exact_value_i64(8*type_size_of(type)));
-			irValue *width_test = ir_emit(proc, ir_instr_binary_op(proc, Token_Lt, bits, bit_size, t_llvm_bool));
-
-			irValue *zero = ir_value_constant(type, exact_value_i64(0));
-			irValue *res = ir_emit(proc, ir_instr_binary_op(proc, op, left, bits, type));
-			return ir_emit_select(proc, width_test, res, zero);
-		}
-
-	case Token_AndNot: {
-		// NOTE(bill): x &~ y == x & (~y) == x & (y ~ -1)
-		// NOTE(bill): "not" 'x' == 'x' "xor" '-1'
-		irValue *neg = ir_add_module_constant(proc->module, type, exact_value_i64(-1));
-		op = Token_Xor;
-		right = ir_emit_arith(proc, op, right, neg, type);
-		GB_ASSERT(right->Instr.kind == irInstr_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_ModMod:
-	case Token_And:
-	case Token_Or:
-	case Token_Xor:
-		left  = ir_emit_conv(proc, left, type);
-		right = ir_emit_conv(proc, right, type);
-		break;
-	}
-
-	if (op == Token_ModMod) {
-		if (is_type_unsigned(type)) {
-			op = Token_Mod;
-		} else {
-			irValue *a = ir_emit_arith(proc, Token_Mod, left, right, type);
-			irValue *b = ir_emit_arith(proc, Token_Add, a,    right, type);
-			return ir_emit_arith(proc, Token_Mod, b, right, type);
-		}
-	}
-
-	return ir_emit(proc, ir_instr_binary_op(proc, op, left, right, type));
-}
-
-irValue *ir_emit_union_tag_ptr(irProcedure *proc, irValue *u) {
-	Type *t = ir_type(u);
-	GB_ASSERT_MSG(is_type_pointer(t) &&
-	              is_type_union(type_deref(t)), "%s", type_to_string(t));
-	irValue *tag_ptr = ir_emit(proc, ir_instr_union_tag_ptr(proc, u));
-	return tag_ptr;
-}
-
-irValue *ir_emit_union_tag_value(irProcedure *proc, irValue *u) {
-	Type *t = ir_type(u);
-	GB_ASSERT(is_type_union(t));
-	GB_ASSERT(are_types_identical(t, ir_type(u)));
-	return ir_emit(proc, ir_instr_union_tag_value(proc, u));
-}
-
-
-irValue *ir_emit_comp_against_nil(irProcedure *proc, TokenKind op_kind, irValue *x) {
-	Type *t = ir_type(x);
-	if (is_type_pointer(t)) {
-		return ir_emit_comp(proc, op_kind, x, v_raw_nil);
-	} else if (is_type_cstring(t)) {
-		irValue *ptr = ir_emit_conv(proc, x, t_u8_ptr);
-		return ir_emit_comp(proc, op_kind, ptr, v_raw_nil);
-	} else if (is_type_any(t)) {
-		// TODO(bill): is this correct behaviour for nil comparison for any?
-		irValue *data = ir_emit_struct_ev(proc, x, 0);
-		irValue *ti   = ir_emit_struct_ev(proc, x, 1);
-		if (op_kind == Token_CmpEq) {
-			irValue *a = ir_emit_comp(proc, Token_CmpEq, data, v_raw_nil);
-			irValue *b = ir_emit_comp(proc, Token_CmpEq, ti, v_raw_nil);
-			return ir_emit_arith(proc, Token_Or, a, b, t_bool);
-		} else if (op_kind == Token_NotEq) {
-			irValue *a = ir_emit_comp(proc, Token_NotEq, data, v_raw_nil);
-			irValue *b = ir_emit_comp(proc, Token_NotEq, ti, v_raw_nil);
-			return ir_emit_arith(proc, Token_And, a, b, t_bool);
-		}
-	} else if (is_type_slice(t)) {
-		irValue *len  = ir_emit_struct_ev(proc, x, 1);
-		return ir_emit_comp(proc, op_kind, len, v_zero);
-	} else if (is_type_dynamic_array(t)) {
-		irValue *cap  = ir_emit_struct_ev(proc, x, 2);
-		return ir_emit_comp(proc, op_kind, cap, v_zero);
-	} else if (is_type_map(t)) {
-		irValue *cap = ir_map_cap(proc, x);
-		return ir_emit_comp(proc, op_kind, cap, v_zero);
-	} else if (is_type_union(t)) {
-		if (type_size_of(t) == 0) {
-			return ir_emit_comp(proc, op_kind, v_zero, v_zero);
-		} else if (is_type_union_maybe_pointer(t)) {
-			Type *bt = base_type(t);
-			irValue *ptr = ir_address_from_load_or_generate_local(proc, x);
-			ptr = ir_emit_bitcast(proc, ptr, alloc_type_pointer(bt->Union.variants[0]));
-			irValue *data = ir_emit_load(proc, ptr);
-			return ir_emit_comp_against_nil(proc, op_kind, data);
-		} else {
-			irValue *tag = ir_emit_union_tag_value(proc, x);
-			return ir_emit_comp(proc, op_kind, tag, v_zero);
-		}
-	} else if (is_type_typeid(t)) {
-		irValue *invalid_typeid = ir_value_constant(t_typeid, exact_value_i64(0));
-		return ir_emit_comp(proc, op_kind, x, invalid_typeid);
-	} else if (is_type_soa_struct(t)) {
-		Type *bt = base_type(t);
-		if (bt->Struct.soa_kind == StructSoa_Slice) {
-			ir_emit_comment(proc, str_lit("soa-slice-nil-comp"));
-			irValue *len  = ir_soa_struct_len(proc, x);
-			return ir_emit_comp(proc, op_kind, len, v_zero);
-		} else if (bt->Struct.soa_kind == StructSoa_Dynamic) {
-			ir_emit_comment(proc, str_lit("soa-dynamic-array-nil-comp"));
-
-			irValue *cap  = ir_soa_struct_cap(proc, x);
-			return ir_emit_comp(proc, op_kind, cap, v_zero);
-		}
-	} else if (is_type_struct(t) && type_has_nil(t)) {
-		auto args = array_make<irValue *>(permanent_allocator(), 2);
-		irValue *lhs = ir_address_from_load_or_generate_local(proc, x);
-		args[0] = ir_emit_conv(proc, lhs, t_rawptr);
-		args[1] = ir_const_int(type_size_of(t));
-		irValue *val = ir_emit_runtime_call(proc, "memory_compare_zero", args);
-		irValue *res = ir_emit_comp(proc, op_kind, val, v_zero);
-		return ir_emit_conv(proc, res, t_bool);
-	}
-	return nullptr;
-}
-
-irValue *ir_get_equal_proc_for_type(irModule *m, Type *type) {
-	Type *original_type = type;
-	type = base_type(type);
-	Type *pt = alloc_type_pointer(type);
-
-	auto key = hash_type(type);
-	irValue **found = map_get(&m->equal_procs, key);
-	if (found) {
-		return *found;
-	}
-
-	static u32 proc_index = 0;
-
-	char buf[16] = {};
-	isize n = gb_snprintf(buf, 16, "__$equal%u", ++proc_index);
-	char *str = gb_alloc_str_len(permanent_allocator(), buf, n-1);
-	String proc_name = make_string_c(str);
-
-
-	Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
-	Entity *e = alloc_entity_procedure(nullptr, make_token_ident(proc_name), t_equal_proc, 0);
-	e->Procedure.link_name = proc_name;
-	irValue *p = ir_value_procedure(m, e, t_equal_proc, nullptr, body, proc_name);
-	map_set(&m->values, hash_entity(e), p);
-	string_map_set(&m->members, proc_name, p);
-	map_set(&m->equal_procs, key, p);
-
-	irProcedure *proc = &p->Proc;
-	proc->is_startup = true;
-	proc->ignore_dead_instr = true;
-	ir_begin_procedure_body(proc);
-	// ir_start_block(proc, proc->decl_block);
-	GB_ASSERT(proc->curr_block != nullptr);
-
-	irValue *x = proc->params[0];
-	irValue *y = proc->params[1];
-	irValue *lhs = ir_emit_conv(proc, x, pt);
-	irValue *rhs = ir_emit_conv(proc, y, pt);
-
-	irBlock *block_same_ptr = ir_new_block(proc, nullptr, "same_ptr");
-	irBlock *block_diff_ptr = ir_new_block(proc, nullptr, "diff_ptr");
-
-	irValue *same_ptr = ir_emit_comp(proc, Token_CmpEq, lhs, rhs);
-	ir_emit_if(proc, same_ptr, block_same_ptr, block_diff_ptr);
-	ir_start_block(proc, block_same_ptr);
-	ir_emit(proc, ir_instr_return(proc, ir_const_bool(true)));
-
-	ir_start_block(proc, block_diff_ptr);
-
-	if (type->kind == Type_Struct) {
-		type_set_offsets(type);
-
-		irBlock *done = ir_new_block(proc, nullptr, "done"); // NOTE(bill): Append later
-
-		irBlock *block_false = ir_new_block(proc, nullptr, "bfalse");
-
-		for_array(i, type->Struct.fields) {
-			irBlock *next_block = ir_new_block(proc, nullptr, "btrue");
-
-			irValue *pleft  = ir_emit_struct_ep(proc, lhs, cast(i32)i);
-			irValue *pright = ir_emit_struct_ep(proc, rhs, cast(i32)i);
-			irValue *left = ir_emit_load(proc, pleft);
-			irValue *right = ir_emit_load(proc, pright);
-			irValue *ok = ir_emit_comp(proc, Token_CmpEq, left, right);
-
-			ir_emit_if(proc, ok, next_block, block_false);
-
-			ir_emit_jump(proc, next_block);
-			ir_start_block(proc, next_block);
-		}
-
-		ir_emit_jump(proc, done);
-		ir_start_block(proc, block_false);
-
-		ir_emit(proc, ir_instr_return(proc, ir_const_bool(false)));
-
-		ir_emit_jump(proc, done);
-		ir_start_block(proc, done);
-		ir_emit(proc, ir_instr_return(proc, ir_const_bool(true)));
-	} else {
-		irValue *left = ir_emit_load(proc, lhs);
-		irValue *right = ir_emit_load(proc, rhs);
-		irValue *ok = ir_emit_comp(proc, Token_CmpEq, left, right);
-		ok = ir_emit_conv(proc, ok, t_bool);
-		ir_emit(proc, ir_instr_return(proc, ok));
-	}
-
-	ir_end_procedure_body(proc);
-
-	return p;
-}
-
-
-irValue *ir_simple_compare_hash(irProcedure *p, Type *type, irValue *data, irValue *seed) {
-	GB_ASSERT_MSG(is_type_simple_compare(type), "%s", type_to_string(type));
-
-	i64 sz = type_size_of(type);
-	if (1 <= sz && sz <= 16) {
-		char name[20] = {};
-		gb_snprintf(name, 20, "default_hasher%d", cast(i32)sz);
-
-		auto args = array_make<irValue *>(permanent_allocator(), 2);
-		args[0] = data;
-		args[1] = seed;
-		return ir_emit_runtime_call(p, name, args);
-	}
-
-	auto args = array_make<irValue *>(permanent_allocator(), 3);
-	args[0] = data;
-	args[1] = seed;
-	args[2] = ir_const_int(type_size_of(type));
-	return ir_emit_runtime_call(p, "default_hasher_n", args);
-}
-
-irValue *ir_get_hasher_proc_for_type(irModule *m, Type *type) {
-	Type *original_type = type;
-	type = core_type(type);
-	Type *pt = alloc_type_pointer(type);
-
-	GB_ASSERT(is_type_valid_for_keys(type));
-
-	auto key = hash_type(type);
-	irValue **found = map_get(&m->hasher_procs, key);
-	if (found) {
-		return *found;
-	}
-
-	static u32 proc_index = 0;
-
-	char buf[16] = {};
-	isize n = gb_snprintf(buf, 16, "__$hasher%u", ++proc_index);
-	char *str = gb_alloc_str_len(permanent_allocator(), buf, n-1);
-	String proc_name = make_string_c(str);
-
-
-	Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
-	Entity *e = alloc_entity_procedure(nullptr, make_token_ident(proc_name), t_hasher_proc, 0);
-	e->Procedure.link_name = proc_name;
-	irValue *p = ir_value_procedure(m, e, t_hasher_proc, nullptr, body, proc_name);
-	map_set(&m->values, hash_entity(e), p);
-	string_map_set(&m->members, proc_name, p);
-	map_set(&m->hasher_procs, key, p);
-
-	irProcedure *proc = &p->Proc;
-	proc->is_startup = true;
-	proc->ignore_dead_instr = true;
-	ir_begin_procedure_body(proc);
-	defer (ir_end_procedure_body(proc));
-
-	// ir_start_block(proc, proc->decl_block);
-	GB_ASSERT(proc->curr_block != nullptr);
-
-	irValue *data = proc->params[0];
-	irValue *seed = proc->params[1];
-
-	if (is_type_simple_compare(type)) {
-		irValue *res = ir_simple_compare_hash(proc, type, data, seed);
-		ir_emit(proc, ir_instr_return(proc, res));
-		return p;
-	}
-
-	if (is_type_cstring(type)) {
-		auto args = array_make<irValue *>(permanent_allocator(), 2);
-		args[0] = data;
-		args[1] = seed;
-		irValue *res = ir_emit_runtime_call(proc, "default_hasher_cstring", args);
-		ir_emit(proc, ir_instr_return(proc, res));
-	} else if (is_type_string(type)) {
-		auto args = array_make<irValue *>(permanent_allocator(), 2);
-		args[0] = data;
-		args[1] = seed;
-		irValue *res = ir_emit_runtime_call(proc, "default_hasher_string", args);
-		ir_emit(proc, ir_instr_return(proc, res));
-	} else if (type->kind == Type_Struct) {
-		type_set_offsets(type);
-		data = ir_emit_conv(proc, data, t_u8_ptr);
-
-		auto args = array_make<irValue *>(permanent_allocator(), 2);
-		for_array(i, type->Struct.fields) {
-			i64 offset = type->Struct.offsets[i];
-			Entity *field = type->Struct.fields[i];
-			irValue *field_hasher = ir_get_hasher_proc_for_type(m, field->type);
-			irValue *ptr = ir_emit_ptr_offset(proc, data, ir_const_uintptr(offset));
-
-			args[0] = ptr;
-			args[1] = seed;
-			seed = ir_emit_call(proc, field_hasher, args);
-		}
-		ir_emit(proc, ir_instr_return(proc, seed));
-	} else if (type->kind == Type_Array) {
-		irValue *pres = ir_add_local_generated(proc, t_uintptr, false);
-		ir_emit_store(proc, pres, seed);
-
-		auto args = array_make<irValue *>(permanent_allocator(), 2);
-		irValue *elem_hasher = ir_get_hasher_proc_for_type(m, type->Array.elem);
-
-		auto loop_data = ir_loop_start(proc, type->Array.count, t_i32);
-
-		data = ir_emit_conv(proc, data, pt);
-
-		irValue *ptr = ir_emit_array_ep(proc, data, loop_data.idx);
-		args[0] = ptr;
-		args[1] = ir_emit_load(proc, pres);
-		irValue *new_seed = ir_emit_call(proc, elem_hasher, args);
-		ir_emit_store(proc, pres, new_seed);
-
-		ir_loop_end(proc, loop_data);
-
-		irValue *res = ir_emit_load(proc, pres);
-		ir_emit(proc, ir_instr_return(proc, res));
-	} else if (type->kind == Type_EnumeratedArray) {
-		irValue *pres = ir_add_local_generated(proc, t_uintptr, false);
-		ir_emit_store(proc, pres, seed);
-
-		auto args = array_make<irValue *>(permanent_allocator(), 2);
-		irValue *elem_hasher = ir_get_hasher_proc_for_type(m, type->Array.elem);
-
-		auto loop_data = ir_loop_start(proc, type->Array.count, t_i32);
-
-		data = ir_emit_conv(proc, data, pt);
-
-		irValue *ptr = ir_emit_array_ep(proc, data, loop_data.idx);
-		args[0] = ptr;
-		args[1] = ir_emit_load(proc, pres);
-		irValue *new_seed = ir_emit_call(proc, elem_hasher, args);
-		ir_emit_store(proc, pres, new_seed);
-
-		ir_loop_end(proc, loop_data);
-
-		irValue *res = ir_emit_load(proc, pres);
-		ir_emit(proc, ir_instr_return(proc, res));
-	} else {
-		GB_PANIC("Unhandled type for hasher: %s", type_to_string(type));
-	}
-
-	return p;
-}
-
-irValue *ir_emit_comp(irProcedure *proc, TokenKind op_kind, irValue *left, irValue *right) {
-	Type *a = base_type(ir_type(left));
-	Type *b = base_type(ir_type(right));
-
-	GB_ASSERT(gb_is_between(op_kind, Token__ComparisonBegin+1, Token__ComparisonEnd-1));
-
-	irValue *nil_check = nullptr;
-	if (left->kind == irValue_Nil) {
-		nil_check = ir_emit_comp_against_nil(proc, op_kind, right);
-	} else if (right->kind == irValue_Nil) {
-		nil_check = ir_emit_comp_against_nil(proc, op_kind, left);
-	}
-	if (nil_check != nullptr) {
-		return nil_check;
-	}
-
-	if (are_types_identical(a, b)) {
-		// NOTE(bill): No need for a conversion
-	} else if (left->kind == irValue_Constant || left->kind == irValue_Nil) {
-		left = ir_emit_conv(proc, left, ir_type(right));
-	} else if (right->kind == irValue_Constant || right->kind == irValue_Nil) {
-		right = ir_emit_conv(proc, right, ir_type(left));
-	} else {
-		gbAllocator a = ir_allocator();
-
-		Type *lt = ir_type(left);
-		Type *rt = ir_type(right);
-
-		// if (is_type_bit_set(lt) && is_type_bit_set(rt)) {
-		// 	Type *blt = base_type(lt);
-		// 	Type *brt = base_type(rt);
-		// 	i64 bits = gb_max(blt->BitFieldValue.bits, brt->BitFieldValue.bits);
-		// 	i64 bytes = bits / 8;
-		// 	switch (bytes) {
-		// 	case 1:
-		// 		left = ir_emit_conv(proc, left, t_u8);
-		// 		right = ir_emit_conv(proc, right, t_u8);
-		// 		break;
-		// 	case 2:
-		// 		left = ir_emit_conv(proc, left, t_u16);
-		// 		right = ir_emit_conv(proc, right, t_u16);
-		// 		break;
-		// 	case 4:
-		// 		left = ir_emit_conv(proc, left, t_u32);
-		// 		right = ir_emit_conv(proc, right, t_u32);
-		// 		break;
-		// 	case 8:
-		// 		left = ir_emit_conv(proc, left, t_u64);
-		// 		right = ir_emit_conv(proc, right, t_u64);
-		// 		break;
-		// 	default: GB_PANIC("Unknown integer size"); break;
-		// 	}
-		// }
-
-		lt = ir_type(left);
-		rt = ir_type(right);
-		i64 ls = type_size_of(lt);
-		i64 rs = type_size_of(rt);
-		if (ls < rs) {
-			left = ir_emit_conv(proc, left, rt);
-		} else if (ls > rs) {
-			right = ir_emit_conv(proc, right, lt);
-		} else {
-			right = ir_emit_conv(proc, right, lt);
-		}
-	}
-
-	if (is_type_array(a)) {
-		ir_emit_comment(proc, str_lit("array.comp.begin"));
-		defer (ir_emit_comment(proc, str_lit("array.comp.end")));
-
-		Type *tl = base_type(a);
-		irValue *lhs = ir_address_from_load_or_generate_local(proc, left);
-		irValue *rhs = ir_address_from_load_or_generate_local(proc, right);
-
-
-		TokenKind cmp_op = Token_And;
-		irValue *res = v_true;
-		if (op_kind == Token_NotEq) {
-			res = v_false;
-			cmp_op = Token_Or;
-		} else if (op_kind == Token_CmpEq) {
-			res = v_true;
-			cmp_op = Token_And;
-		}
-
-		bool inline_array_arith = type_size_of(tl) <= build_context.max_align;
-		i32 count = cast(i32)tl->Array.count;
-
-		if (inline_array_arith) {
-			// inline
-			irValue *val = ir_add_local_generated(proc, t_bool, false);
-			ir_emit_store(proc, val, res);
-			for (i32 i = 0; i < count; i++) {
-				irValue *x = ir_emit_load(proc, ir_emit_array_epi(proc, lhs, i));
-				irValue *y = ir_emit_load(proc, ir_emit_array_epi(proc, rhs, i));
-				irValue *cmp = ir_emit_comp(proc, op_kind, x, y);
-				irValue *new_res = ir_emit_arith(proc, cmp_op, ir_emit_load(proc, val), cmp, t_bool);
-				ir_emit_store(proc, val, ir_emit_conv(proc, new_res, t_bool));
-			}
-
-			return ir_emit_load(proc, val);
-		} else {
-			if (is_type_simple_compare(tl) && (op_kind == Token_CmpEq || op_kind == Token_NotEq)) {
-				// TODO(bill): Test to see if this is actually faster!!!!
-				auto args = array_make<irValue *>(permanent_allocator(), 3);
-				args[0] = ir_emit_conv(proc, lhs, t_rawptr);
-				args[1] = ir_emit_conv(proc, rhs, t_rawptr);
-				args[2] = ir_const_int(type_size_of(tl));
-				irValue *val = ir_emit_runtime_call(proc, "memory_compare", args);
-				irValue *res = ir_emit_comp(proc, op_kind, val, v_zero);
-				return ir_emit_conv(proc, res, t_bool);
-			} else {
-				irValue *val = ir_add_local_generated(proc, t_bool, false);
-				ir_emit_store(proc, val, res);
-				auto loop_data = ir_loop_start(proc, count, t_i32);
-				{
-					irValue *i = loop_data.idx;
-					irValue *x = ir_emit_load(proc, ir_emit_array_ep(proc, lhs, i));
-					irValue *y = ir_emit_load(proc, ir_emit_array_ep(proc, rhs, i));
-					irValue *cmp = ir_emit_comp(proc, op_kind, x, y);
-					irValue *new_res = ir_emit_arith(proc, cmp_op, ir_emit_load(proc, val), cmp, t_bool);
-					ir_emit_store(proc, val, ir_emit_conv(proc, new_res, t_bool));
-				}
-				ir_loop_end(proc, loop_data);
-
-				return ir_emit_load(proc, val);
-			}
-		}
-	}
-
-	if (is_type_struct(a) && is_type_comparable(a)) {
-		irValue *left_ptr  = ir_address_from_load_or_generate_local(proc, left);
-		irValue *right_ptr = ir_address_from_load_or_generate_local(proc, right);
-		irValue *res = {};
-		if (is_type_simple_compare(a)) {
-			// TODO(bill): Test to see if this is actually faster!!!!
-			auto args = array_make<irValue *>(permanent_allocator(), 3);
-			args[0] = ir_emit_conv(proc, left_ptr, t_rawptr);
-			args[1] = ir_emit_conv(proc, right_ptr, t_rawptr);
-			args[2] = ir_const_int(type_size_of(a));
-			res = ir_emit_runtime_call(proc, "memory_equal", args);
-		} else {
-			irValue *value = ir_get_equal_proc_for_type(proc->module, a);
-			auto args = array_make<irValue *>(permanent_allocator(), 2);
-			args[0] = ir_emit_conv(proc, left_ptr, t_rawptr);
-			args[1] = ir_emit_conv(proc, right_ptr, t_rawptr);
-			res = ir_emit_call(proc, value, args);
-		}
-		if (op_kind == Token_NotEq) {
-			res = ir_emit_unary_arith(proc, Token_Not, res, ir_type(res));
-		}
-		return res;
-	}
-
-	if (is_type_string(a)) {
-		if (is_type_cstring(a)) {
-			left  = ir_emit_conv(proc, left, t_string);
-			right = ir_emit_conv(proc, right, t_string);
-		}
-
-		char const *runtime_proc = nullptr;
-		switch (op_kind) {
-		case Token_CmpEq: runtime_proc = "string_eq"; break;
-		case Token_NotEq: runtime_proc = "string_ne"; break;
-		case Token_Lt:    runtime_proc = "string_lt"; break;
-		case Token_Gt:    runtime_proc = "string_gt"; break;
-		case Token_LtEq:  runtime_proc = "string_le"; break;
-		case Token_GtEq:  runtime_proc = "string_gt"; break;
-		}
-		GB_ASSERT(runtime_proc != nullptr);
-
-		auto args = array_make<irValue *>(ir_allocator(), 2);
-		args[0] = left;
-		args[1] = right;
-		return ir_emit_runtime_call(proc, runtime_proc, args);
-	}
-
-	if (is_type_complex(a)) {
-		char const *runtime_proc = "";
-		i64 sz = 8*type_size_of(a);
-		switch (sz) {
-		case 64:
-			switch (op_kind) {
-			case Token_CmpEq: runtime_proc = "complex64_eq"; break;
-			case Token_NotEq: runtime_proc = "complex64_ne"; break;
-			}
-			break;
-		case 128:
-			switch (op_kind) {
-			case Token_CmpEq: runtime_proc = "complex128_eq"; break;
-			case Token_NotEq: runtime_proc = "complex128_ne"; break;
-			}
-			break;
-		}
-		GB_ASSERT(runtime_proc != nullptr);
-
-		auto args = array_make<irValue *>(ir_allocator(), 2);
-		args[0] = left;
-		args[1] = right;
-		return ir_emit_runtime_call(proc, runtime_proc, args);
-	}
-
-	if (is_type_quaternion(a)) {
-		char const *runtime_proc = "";
-		i64 sz = 8*type_size_of(a);
-		switch (sz) {
-		case 128:
-			switch (op_kind) {
-			case Token_CmpEq: runtime_proc = "quaternion128_eq"; break;
-			case Token_NotEq: runtime_proc = "quaternion128_ne"; break;
-			}
-			break;
-		case 256:
-			switch (op_kind) {
-			case Token_CmpEq: runtime_proc = "quaternion256_eq"; break;
-			case Token_NotEq: runtime_proc = "quaternion256_ne"; break;
-			}
-			break;
-		}
-		GB_ASSERT(runtime_proc != nullptr);
-
-		auto args = array_make<irValue *>(ir_allocator(), 2);
-		args[0] = left;
-		args[1] = right;
-		return ir_emit_runtime_call(proc, runtime_proc, args);
-	}
-
-	if (is_type_bit_set(a)) {
-		switch (op_kind) {
-		case Token_Lt:
-		case Token_LtEq:
-		case Token_Gt:
-		case Token_GtEq:
-			{
-				Type *it = bit_set_to_int(a);
-				irValue *lhs = ir_emit_bitcast(proc, left, it);
-				irValue *rhs = ir_emit_bitcast(proc, right, it);
-				irValue *res = ir_emit_arith(proc, Token_And, lhs, rhs, it);
-
-				if (op_kind == Token_Lt || op_kind == Token_LtEq) {
-					// (lhs & rhs) == lhs
-					res = ir_emit(proc, ir_instr_binary_op(proc, Token_CmpEq, res, lhs, t_llvm_bool));
-				} else if (op_kind == Token_Gt || op_kind == Token_GtEq) {
-					// (lhs & rhs) == rhs
-					res = ir_emit(proc, ir_instr_binary_op(proc, Token_CmpEq, res, rhs, t_llvm_bool));
-				}
-
-				// NOTE(bill): Strict subsets
-				if (op_kind == Token_Lt || op_kind == Token_Gt) {
-					// res &~ (lhs == rhs)
-					irValue *eq = ir_emit(proc, ir_instr_binary_op(proc, Token_CmpEq, lhs, rhs, t_llvm_bool));
-					res = ir_emit_arith(proc, Token_AndNot, res, eq, t_llvm_bool);
-				}
-
-				return res;
-			}
-		}
-	}
-
-	if (op_kind != Token_CmpEq && op_kind != Token_NotEq) {
-		Type *t = ir_type(left);
-		if (is_type_integer(t) && is_type_different_to_arch_endianness(t)) {
-			Type *platform_type = integer_endian_type_to_platform_type(t);
-			irValue *x = ir_emit_byte_swap(proc, left, platform_type);
-			irValue *y = ir_emit_byte_swap(proc, right, platform_type);
-			return ir_emit(proc, ir_instr_binary_op(proc, op_kind, x, y, t_llvm_bool));
-		} else if (is_type_float(t) && is_type_different_to_arch_endianness(t)) {
-			Type *platform_type = integer_endian_type_to_platform_type(t);
-			irValue *x = ir_emit_conv(proc, left, platform_type);
-			irValue *y = ir_emit_conv(proc, right, platform_type);
-			return ir_emit(proc, ir_instr_binary_op(proc, op_kind, x, y, t_llvm_bool));
-		}
-	}
-
-	return ir_emit(proc, ir_instr_binary_op(proc, op_kind, left, right, t_llvm_bool));
-}
-
-irValue *ir_emit_array_ep(irProcedure *proc, irValue *s, irValue *index) {
-	GB_ASSERT(index != nullptr);
-	Type *t = ir_type(s);
-	GB_ASSERT(is_type_pointer(t));
-	Type *st = base_type(type_deref(t));
-	GB_ASSERT_MSG(is_type_array(st) || is_type_enumerated_array(st), "%s", type_to_string(st));
-
-	// NOTE(bill): For some weird legacy reason in LLVM, structure elements must be accessed as an i32
-	index = ir_emit_conv(proc, index, t_i32);
-	return ir_emit(proc, ir_instr_array_element_ptr(proc, s, index));
-}
-
-irValue *ir_emit_array_epi(irProcedure *proc, irValue *s, i32 index) {
-	return ir_emit_array_ep(proc, s, ir_const_i32(index));
-}
-
-
-
-irValue *ir_emit_struct_ep(irProcedure *proc, irValue *s, i32 index) {
-	gbAllocator a = ir_allocator();
-	GB_ASSERT(is_type_pointer(ir_type(s)));
-	Type *t = base_type(type_deref(ir_type(s)));
-	Type *result_type = nullptr;
-
-	if (is_type_relative_pointer(t)) {
-		s = ir_addr_get_ptr(proc, ir_addr(s));
-	}
-
-	if (is_type_struct(t)) {
-		result_type = alloc_type_pointer(t->Struct.fields[index]->type);
-	} else if (is_type_union(t)) {
-		GB_ASSERT(index == -1);
-		return ir_emit_union_tag_ptr(proc, s);
-	} else if (is_type_tuple(t)) {
-		GB_ASSERT(t->Tuple.variables.count > 0);
-		result_type = alloc_type_pointer(t->Tuple.variables[index]->type);
-	} else if (is_type_complex(t)) {
-		Type *ft = base_complex_elem_type(t);
-		switch (index) {
-		case 0: result_type = alloc_type_pointer(ft); break;
-		case 1: result_type = alloc_type_pointer(ft); break;
-		}
-	} else if (is_type_quaternion(t)) {
-		Type *ft = base_complex_elem_type(t);
-		switch (index) {
-		case 0: result_type = alloc_type_pointer(ft); break;
-		case 1: result_type = alloc_type_pointer(ft); break;
-		case 2: result_type = alloc_type_pointer(ft); break;
-		case 3: result_type = alloc_type_pointer(ft); break;
-		}
-	} else if (is_type_slice(t)) {
-		switch (index) {
-		case 0: result_type = alloc_type_pointer(alloc_type_pointer(t->Slice.elem)); break;
-		case 1: result_type = alloc_type_pointer(t_int); break;
-		}
-	} else if (is_type_string(t)) {
-		switch (index) {
-		case 0: result_type = alloc_type_pointer(t_u8_ptr); break;
-		case 1: result_type = alloc_type_pointer(t_int);    break;
-		}
-	} else if (is_type_any(t)) {
-		switch (index) {
-		case 0: result_type = alloc_type_pointer(t_rawptr); break;
-		case 1: result_type = alloc_type_pointer(t_typeid); break;
-		}
-	} else if (is_type_dynamic_array(t)) {
-		switch (index) {
-		case 0: result_type = alloc_type_pointer(alloc_type_pointer(t->DynamicArray.elem)); break;
-		case 1: result_type = t_int_ptr;       break;
-		case 2: result_type = t_int_ptr;       break;
-		case 3: result_type = t_allocator_ptr; break;
-		}
-	} else if (is_type_map(t)) {
-		init_map_internal_types(t);
-		Type *itp = alloc_type_pointer(t->Map.internal_type);
-		s = ir_emit_transmute(proc, s, itp);
-
-		Type *gst = t->Map.internal_type;
-		GB_ASSERT(gst->kind == Type_Struct);
-		switch (index) {
-		case 0: result_type = alloc_type_pointer(gst->Struct.fields[0]->type); break;
-		case 1: result_type = alloc_type_pointer(gst->Struct.fields[1]->type); break;
-		}
-	} else if (is_type_array(t)) {
-		return ir_emit_array_epi(proc, s, index);
-	} else if (is_type_relative_slice(t)) {
-		switch (index) {
-		case 0: result_type = alloc_type_pointer(t->RelativeSlice.base_integer); break;
-		case 1: result_type = alloc_type_pointer(t->RelativeSlice.base_integer); break;
-		}
-	} else {
-		GB_PANIC("TODO(bill): struct_gep type: %s, %d", type_to_string(ir_type(s)), index);
-	}
-
-	GB_ASSERT_MSG(result_type != nullptr, "%s %d", type_to_string(t), index);
-
-	return ir_emit(proc, ir_instr_struct_element_ptr(proc, s, index, result_type));
-}
-
-
-irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index) {
-	// NOTE(bill): For some weird legacy reason in LLVM, structure elements must be accessed as an i32
-
-	if (s->kind == irValue_Instr) {
-		if (s->Instr.kind == irInstr_Load) {
-			irValue *addr = s->Instr.Load.address;
-			irValue *ptr = ir_emit_struct_ep(proc, addr, index);
-			return ir_emit_load(proc, ptr);
-		}
-	}
-
-	gbAllocator a = ir_allocator();
-	Type *t = base_type(ir_type(s));
-	Type *result_type = nullptr;
-
-	switch (t->kind) {
-	case Type_Basic:
-		switch (t->Basic.kind) {
-		case Basic_string:
-			switch (index) {
-			case 0: result_type = t_u8_ptr; break;
-			case 1: result_type = t_int;    break;
-			}
-			break;
-		case Basic_any:
-			switch (index) {
-			case 0: result_type = t_rawptr; break;
-			case 1: result_type = t_typeid; break;
-			}
-			break;
-		case Basic_complex32:
-		case Basic_complex64:
-		case Basic_complex128:
-		{
-			Type *ft = base_complex_elem_type(t);
-			switch (index) {
-			case 0: result_type = ft; break;
-			case 1: result_type = ft; break;
-			}
-			break;
-		}
-		case Basic_quaternion64:
-		case Basic_quaternion128:
-		case Basic_quaternion256:
-		{
-			Type *ft = base_complex_elem_type(t);
-			switch (index) {
-			case 0: result_type = ft; break;
-			case 1: result_type = ft; break;
-			case 2: result_type = ft; break;
-			case 3: result_type = ft; break;
-			}
-			break;
-		}
-		}
-		break;
-	case Type_Struct:
-		result_type = t->Struct.fields[index]->type;
-		break;
-	case Type_Union:
-		GB_ASSERT(index == -1);
-		return ir_emit_union_tag_value(proc, s);
-	case Type_Tuple:
-		GB_ASSERT(t->Tuple.variables.count > 0);
-		result_type = t->Tuple.variables[index]->type;
-		break;
-	case Type_Slice:
-		switch (index) {
-		case 0: result_type = alloc_type_pointer(t->Slice.elem); break;
-		case 1: result_type = t_int; break;
-		}
-		break;
-	case Type_DynamicArray:
-		switch (index) {
-		case 0: result_type = alloc_type_pointer(t->DynamicArray.elem); break;
-		case 1: result_type = t_int;                                    break;
-		case 2: result_type = t_int;                                    break;
-		case 3: result_type = t_allocator;                              break;
-		}
-		break;
-
-	case Type_Map:
-		{
-			init_map_internal_types(t);
-			Type *gst = t->Map.generated_struct_type;
-			switch (index) {
-			case 0: result_type = gst->Struct.fields[0]->type; break;
-			case 1: result_type = gst->Struct.fields[1]->type; break;
-			}
-		}
-		break;
-
-	case Type_Array:
-		result_type = t->Array.elem;
-		break;
-
-	default:
-		GB_PANIC("TODO(bill): struct_ev type: %s, %d", type_to_string(ir_type(s)), index);
-		break;
-	}
-
-	GB_ASSERT_MSG(result_type != nullptr, "%s, %d", type_to_string(ir_type(s)), index);
-
-	return ir_emit(proc, ir_instr_struct_extract_value(proc, s, index, result_type));
-}
-
-
-irValue *ir_emit_deep_field_gep(irProcedure *proc, irValue *e, Selection sel) {
-	GB_ASSERT(sel.index.count > 0);
-	Type *type = type_deref(ir_type(e));
-	gbAllocator a = ir_allocator();
-
-	for_array(i, sel.index) {
-		i32 index = cast(i32)sel.index[i];
-		if (is_type_pointer(type)) {
-			type = type_deref(type);
-			e = ir_emit_load(proc, e);
-			// e = ir_emit_ptr_offset(proc, e, v_zero); // TODO(bill): Do I need these copies?
-		}
-		type = core_type(type);
-
-		if (is_type_quaternion(type)) {
-			e = ir_emit_struct_ep(proc, e, index);
-		} else if (is_type_raw_union(type)) {
-			type = type->Struct.fields[index]->type;
-			GB_ASSERT(is_type_pointer(ir_type(e)));
-			e = ir_emit_bitcast(proc, e, alloc_type_pointer(type));
-		} else if (is_type_struct(type)) {
-			type = type->Struct.fields[index]->type;
-			e = ir_emit_struct_ep(proc, e, index);
-		} else if (type->kind == Type_Union) {
-			GB_ASSERT(index == -1);
-			type = t_type_info_ptr;
-			e = ir_emit_struct_ep(proc, e, index);
-		} else if (type->kind == Type_Tuple) {
-			type = type->Tuple.variables[index]->type;
-			e = ir_emit_struct_ep(proc, e, index);
-		} else if (type->kind == Type_Basic) {
-			switch (type->Basic.kind) {
-			case Basic_any: {
-				if (index == 0) {
-					type = t_rawptr;
-				} else if (index == 1) {
-					type = t_type_info_ptr;
-				}
-				e = ir_emit_struct_ep(proc, e, index);
-				break;
-			}
-
-			case Basic_string:
-				e = ir_emit_struct_ep(proc, e, index);
-				break;
-
-			default:
-				GB_PANIC("un-gep-able type");
-				break;
-			}
-		} else if (type->kind == Type_Slice) {
-			e = ir_emit_struct_ep(proc, e, index);
-		} else if (type->kind == Type_DynamicArray) {
-			e = ir_emit_struct_ep(proc, e, index);
-		} else if (type->kind == Type_Array) {
-			e = ir_emit_array_epi(proc, e, index);
-		} else if (type->kind == Type_Map) {
-			e = ir_emit_struct_ep(proc, e, index);
-		} else if (type->kind == Type_RelativePointer) {
-			e = ir_emit_struct_ep(proc, e, index);
-		} else {
-			GB_PANIC("un-gep-able type %s", type_to_string(type));
-		}
-	}
-
-	return e;
-}
-
-
-irValue *ir_emit_deep_field_ev(irProcedure *proc, irValue *e, Selection sel) {
-	GB_ASSERT(sel.index.count > 0);
-
-	if (e->kind == irValue_Instr) {
-		if (e->Instr.kind == irInstr_Load) {
-			irValue *addr = e->Instr.Load.address;
-			irValue *ptr = ir_emit_deep_field_gep(proc, addr, sel);
-			return ir_emit_load(proc, ptr);
-		}
-	}
-
-	Type *type = ir_type(e);
-
-	for_array(i, sel.index) {
-		i32 index = cast(i32)sel.index[i];
-		if (is_type_pointer(type)) {
-			type = type_deref(type);
-			e = ir_emit_load(proc, e);
-			e = ir_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->Struct.fields[index]->type;
-			e = ir_emit_conv(proc, e, type);
-		} else if (type->kind == Type_Map) {
-			e = ir_emit_struct_ev(proc, e, 1);
-			switch (index) {
-			case 0: e = ir_emit_struct_ev(proc, e, 1); break; // count
-			case 1: e = ir_emit_struct_ev(proc, e, 2); break; // capacity
-			case 2: e = ir_emit_struct_ev(proc, e, 3); break; // allocator
-			}
-		} else {
-			e = ir_emit_struct_ev(proc, e, index);
-		}
-	}
-
-	return e;
-}
-
-
-
-
-
-irValue *ir_array_elem(irProcedure *proc, irValue *array) {
-	return ir_emit_array_ep(proc, array, v_zero32);
-}
-irValue *ir_array_len(irProcedure *proc, irValue *array) {
-	Type *t = base_type(ir_type(array));
-	GB_ASSERT(t->kind == Type_Array);
-	return ir_const_int(t->Array.count);
-}
-
-
-irValue *ir_slice_elem(irProcedure *proc, irValue *slice) {
-	GB_ASSERT(is_type_slice(ir_type(slice)));
-	return ir_emit_struct_ev(proc, slice, 0);
-}
-irValue *ir_slice_len(irProcedure *proc, irValue *slice) {
-	GB_ASSERT(is_type_slice(ir_type(slice)));
-	return ir_emit_struct_ev(proc, slice, 1);
-}
-irValue *ir_dynamic_array_elem(irProcedure *proc, irValue *da) {
-	GB_ASSERT(is_type_dynamic_array(ir_type(da)));
-	return ir_emit_struct_ev(proc, da, 0);
-}
-irValue *ir_dynamic_array_len(irProcedure *proc, irValue *da) {
-	GB_ASSERT(is_type_dynamic_array(ir_type(da)));
-	return ir_emit_struct_ev(proc, da, 1);
-}
-irValue *ir_dynamic_array_cap(irProcedure *proc, irValue *da) {
-	GB_ASSERT(is_type_dynamic_array(ir_type(da)));
-	return ir_emit_struct_ev(proc, da, 2);
-}
-irValue *ir_dynamic_array_allocator(irProcedure *proc, irValue *da) {
-	GB_ASSERT(is_type_dynamic_array(ir_type(da)));
-	return ir_emit_struct_ev(proc, da, 3);
-}
-
-
-
-irValue *ir_string_elem(irProcedure *proc, irValue *string) {
-	Type *t = base_type(ir_type(string));
-	GB_ASSERT(t->kind == Type_Basic && t->Basic.kind == Basic_string);
-	return ir_emit_struct_ev(proc, string, 0);
-}
-irValue *ir_string_len(irProcedure *proc, irValue *string) {
-	Type *t = base_type(ir_type(string));
-	GB_ASSERT_MSG(t->kind == Type_Basic && t->Basic.kind == Basic_string, "%s", type_to_string(t));
-	return ir_emit_struct_ev(proc, string, 1);
-}
-
-irValue *ir_cstring_len(irProcedure *proc, irValue *value) {
-	GB_ASSERT(is_type_cstring(ir_type(value)));
-	auto args = array_make<irValue *>(ir_allocator(), 1);
-	args[0] = ir_emit_conv(proc, value, t_cstring);
-	return ir_emit_runtime_call(proc, "cstring_len", args);
-}
-
-
-
-void ir_fill_slice(irProcedure *proc, irValue *slice_ptr, irValue *data, irValue *len) {
-	Type *t = ir_type(slice_ptr);
-	GB_ASSERT(is_type_pointer(t));
-	t = type_deref(t);
-	GB_ASSERT(is_type_slice(t));
-	ir_emit_store(proc, ir_emit_struct_ep(proc, slice_ptr, 0), data);
-	ir_emit_store(proc, ir_emit_struct_ep(proc, slice_ptr, 1), len);
-}
-void ir_fill_string(irProcedure *proc, irValue *string_ptr, irValue *data, irValue *len) {
-	Type *t = ir_type(string_ptr);
-	GB_ASSERT(is_type_pointer(t));
-	t = type_deref(t);
-	GB_ASSERT(is_type_string(t));
-	ir_emit_store(proc, ir_emit_struct_ep(proc, string_ptr, 0), data);
-	ir_emit_store(proc, ir_emit_struct_ep(proc, string_ptr, 1), len);
-}
-
-irValue *ir_emit_string(irProcedure *proc, irValue *elem, irValue *len) {
-	irValue *str = ir_add_local_generated(proc, t_string, false);
-	ir_fill_string(proc, str, elem, len);
-	return ir_emit_load(proc, str);
-}
-
-
-irValue *ir_add_local_slice(irProcedure *proc, Type *slice_type, irValue *base, irValue *low, irValue *high) {
-	// TODO(bill): array bounds checking for slice creation
-	// TODO(bill): check that low < high <= max
-	gbAllocator a = ir_allocator();
-	Type *bt = base_type(ir_type(base));
-
-	if (low == nullptr) {
-		low = v_zero;
-	}
-	if (high == nullptr) {
-		switch (bt->kind) {
-		case Type_Array:   high = ir_array_len(proc, base); break;
-		case Type_Slice:   high = ir_slice_len(proc, base); break;
-		case Type_Pointer: high = v_one;                     break;
-		}
-	}
-
-	irValue *len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
-
-	irValue *elem = nullptr;
-	switch (bt->kind) {
-	case Type_Array:   elem = ir_array_elem(proc, base); break;
-	case Type_Slice:   elem = ir_slice_elem(proc, base); break;
-	case Type_Pointer: elem = ir_emit_load(proc, base);  break;
-	}
-
-	elem = ir_emit_ptr_offset(proc, elem, low);
-
-	irValue *slice = ir_add_local_generated(proc, slice_type, false);
-	ir_fill_slice(proc, slice, elem, len);
-	return slice;
-}
-
-
-
-irValue *ir_find_or_add_entity_string(irModule *m, String str) {
-	StringHashKey key = string_hash_string(str);
-	irValue **found = string_map_get(&m->const_strings, key);
-	if (found != nullptr) {
-		return *found;
-	}
-	irValue *v = ir_value_constant(t_string, exact_value_string(str));
-	string_map_set(&m->const_strings, key, v);
-	return v;
-
-}
-
-irValue *ir_find_or_add_entity_string_byte_slice(irModule *m, String str) {
-	StringHashKey key = string_hash_string(str);
-	irValue **found = string_map_get(&m->const_string_byte_slices, key);
-	if (found != nullptr) {
-		return *found;
-	}
-	Type *t = t_u8_slice;
-	irValue *v = ir_value_constant(t, exact_value_string(str));
-	string_map_set(&m->const_string_byte_slices, key, v);
-	return v;
-
-}
-
-
-irValue *ir_const_union_tag(Type *u, Type *v) {
-	return ir_value_constant(union_tag_type(u), exact_value_i64(union_variant_index(u, v)));
-}
-
-
-String ir_lookup_subtype_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) || is_type_union(src));
-	for_array(i, src->Struct.fields) {
-		Entity *f = src->Struct.fields[i];
-		if (f->kind == Entity_Variable && f->flags & EntityFlag_Using) {
-			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 = ir_lookup_subtype_polymorphic_field(info, dst, f->type);
-				if (name.len > 0) {
-					return name;
-				}
-			}
-		}
-	}
-	return str_lit("");
-}
-
-
-irValue *ir_emit_ptr_to_uintptr(irProcedure *proc, irValue *value, Type *t, bool allow_type_type = false) {
-	Type *vt = core_type(ir_type(value));
-	GB_ASSERT(is_type_pointer(vt));
-	if (allow_type_type) {
-		GB_ASSERT(is_type_uintptr(core_type(t)));
-	} else {
-		GB_ASSERT(is_type_uintptr(core_type(t)));
-	}
-	return ir_emit(proc, ir_instr_conv(proc, irConv_ptrtoint, value, vt, t));
-}
-irValue *ir_emit_uintptr_to_ptr(irProcedure *proc, irValue *value, Type *t) {
-	Type *vt = core_type(ir_type(value));
-	GB_ASSERT(is_type_uintptr(vt));
-	GB_ASSERT(is_type_pointer(core_type(t)));
-	return ir_emit(proc, ir_instr_conv(proc, irConv_inttoptr, value, vt, t));
-}
-
-irValue *ir_emit_byte_swap(irProcedure *proc, irValue *value, Type *t) {
-	Type *vt = core_type(ir_type(value));
-	if (is_type_untyped(vt)) {
-		return value;
-	}
-	GB_ASSERT(type_size_of(vt) == type_size_of(t));
-	if (is_type_float(t)) {
-		i64 sz = type_size_of(t);
-
-		auto args = array_make<irValue *>(ir_allocator(), 1);
-		args[0] = value;
-
-		char const *proc_name = nullptr;
-		switch (sz*8) {
-		case 16: proc_name  = "bswap_f16"; break;
-		case 32: proc_name  = "bswap_f32"; break;
-		case 64: proc_name  = "bswap_f64"; break;
-		}
-		GB_ASSERT(proc_name != nullptr);
-
-		String name = make_string_c(proc_name);
-
-		AstPackage *p = proc->module->info->runtime_package;
-		Entity *e = scope_lookup_current(p->scope, name);
-		irValue **found = map_get(&proc->module->values, hash_entity(e));
-		GB_ASSERT_MSG(found != nullptr, "%.*s", LIT(name));
-		irValue *gp = *found;
-
-		return ir_emit(proc, ir_instr_call(proc, gp, nullptr, args, t, nullptr, ProcInlining_none));
-	}
-	return ir_emit(proc, ir_instr_conv(proc, irConv_byteswap, value, vt, t));
-}
-
-
-void ir_emit_store_union_variant(irProcedure *proc, irValue *parent, irValue *variant, Type *variant_type) {
-	gbAllocator a = ir_allocator();
-	irValue *underlying = ir_emit_conv(proc, parent, alloc_type_pointer(variant_type));
-
-	ir_emit_store(proc, underlying, variant);
-
-	Type *t = type_deref(ir_type(parent));
-
-	if (is_type_union_maybe_pointer(t)) {
-		// No tag needed!
-	} else {
-		irValue *tag_ptr = ir_emit_union_tag_ptr(proc, parent);
-		ir_emit_store(proc, tag_ptr, ir_const_union_tag(t, variant_type));
-	}
-}
-
-irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) {
-	Type *src_type = ir_type(value);
-	if (are_types_identical(t, src_type)) {
-		return value;
-	}
-
-	Type *src = core_type(src_type);
-	Type *dst = core_type(t);
-
-
-	// if (is_type_untyped_nil(src) && type_has_nil(dst)) {
-	if (is_type_untyped_nil(src)) {
-		return ir_value_nil(t);
-	}
-	if (is_type_untyped_undef(src)) {
-		return ir_value_undef(t);
-	}
-
-	if (value->kind == irValue_Constant) {
-		if (is_type_any(dst)) {
-			irValue *default_value = ir_add_local_generated(proc, default_type(src_type), false);
-			ir_emit_store(proc, default_value, value);
-			return ir_emit_conv(proc, ir_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_complex(dst)) {
-				ev = exact_value_to_complex(ev);
-			} else if (is_type_quaternion(dst)) {
-				ev = exact_value_to_quaternion(ev);
-			} else if (is_type_string(dst)) {
-				// Handled elsewhere
-				GB_ASSERT_MSG(ev.kind == ExactValue_String, "%d", ev.kind);
-			} 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'
-				irValue *i = ir_add_module_constant(proc->module, t_uintptr, ev);
-				return ir_emit(proc, ir_instr_conv(proc, irConv_inttoptr, i, t_uintptr, dst));
-			}
-			return ir_add_module_constant(proc->module, t, ev);
-		}
-	}
-
-	if (are_types_identical(src, dst)) {
-		if (!are_types_identical(src_type, t)) {
-			return ir_emit_transmute(proc, value, t);
-		}
-		return value;
-	}
-
-
-
-	// bool <-> llvm bool
-	if (is_type_boolean(src) && dst == t_llvm_bool) {
-		return ir_emit(proc, ir_instr_conv(proc, irConv_trunc, value, src_type, t));
-	}
-	if (src == t_llvm_bool && is_type_boolean(dst)) {
-		return ir_emit(proc, ir_instr_conv(proc, irConv_zext, value, src_type, t));
-	}
-
-
-	// 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(default_type(src));
-		i64 dz = type_size_of(default_type(dst));
-
-		if (sz > 1 && is_type_different_to_arch_endianness(src)) {
-			Type *platform_src_type = integer_endian_type_to_platform_type(src);
-			value = ir_emit_byte_swap(proc, value, platform_src_type);
-		}
-		irConvKind kind = irConv_trunc;
-
-		if (dz < sz) {
-			kind = irConv_trunc;
-		} else if (dz == sz) {
-			// NOTE(bill): In LLVM, all integers are signed and rely upon 2's compliment
-			// NOTE(bill): Copy the value just for type correctness
-			kind = irConv_bitcast;
-		} else if (dz > sz) {
-			if (is_type_unsigned(src)) {
-				kind = irConv_zext; // zero extent
-			} else {
-				kind = irConv_sext; // sign extent
-			}
-		}
-
-		if (dz > 1 && is_type_different_to_arch_endianness(dst)) {
-			Type *platform_dst_type = integer_endian_type_to_platform_type(dst);
-			irValue *res = ir_emit(proc, ir_instr_conv(proc, kind, value, src_type, platform_dst_type));
-			return ir_emit_byte_swap(proc, res, t);
-		} else {
-			return ir_emit(proc, ir_instr_conv(proc, kind, value, src_type, t));
-		}
-	}
-
-	// boolean -> boolean/integer
-	if (is_type_boolean(src) && (is_type_boolean(dst) || is_type_integer(dst))) {
-		irValue *b = ir_emit(proc, ir_instr_binary_op(proc, Token_NotEq, value, v_zero, t_llvm_bool));
-		return ir_emit(proc, ir_instr_conv(proc, irConv_zext, b, t_llvm_bool, t));
-	}
-
-	if (is_type_cstring(src) && is_type_u8_ptr(dst)) {
-		return ir_emit_bitcast(proc, value, dst);
-	}
-	if (is_type_u8_ptr(src) && is_type_cstring(dst)) {
-		return ir_emit_bitcast(proc, value, dst);
-	}
-	if (is_type_cstring(src) && is_type_rawptr(dst)) {
-		return ir_emit_bitcast(proc, value, dst);
-	}
-	if (is_type_rawptr(src) && is_type_cstring(dst)) {
-		return ir_emit_bitcast(proc, value, dst);
-	}
-
-	if (are_types_identical(src, t_cstring) && are_types_identical(dst, t_string)) {
-		irValue *c = ir_emit_conv(proc, value, t_cstring);
-		auto args = array_make<irValue *>(ir_allocator(), 1);
-		args[0] = c;
-		irValue *s = ir_emit_runtime_call(proc, "cstring_to_string", args);
-		return ir_emit_conv(proc, s, dst);
-	}
-
-
-	// integer -> boolean
-	if (is_type_integer(src) && is_type_boolean(dst)) {
-		return ir_emit_comp(proc, Token_NotEq, value, v_zero);
-	}
-
-	// float -> float
-	if (is_type_float(src) && is_type_float(dst)) {
-		GB_ASSERT(!are_types_identical(src, dst));
-		gbAllocator a = ir_allocator();
-		i64 sz = type_size_of(src);
-		i64 dz = type_size_of(dst);
-		irConvKind kind = irConv_fptrunc;
-		if (dz == sz) {
-			if (types_have_same_internal_endian(src, dst)) {
-				return ir_emit_transmute(proc, value, t);
-			} else {
-				return ir_emit_byte_swap(proc, value, t);
-			}
-		}
-		if (dz >= sz) {
-			kind = irConv_fpext;
-		}
-		if (is_type_different_to_arch_endianness(src) || is_type_different_to_arch_endianness(dst)) {
-			Type *platform_src_type = integer_endian_type_to_platform_type(src);
-			Type *platform_dst_type = integer_endian_type_to_platform_type(dst);
-			irValue *res = nullptr;
-			res = ir_emit_conv(proc, value, platform_src_type);
-			res = ir_emit_conv(proc, res, platform_dst_type);
-			if (is_type_different_to_arch_endianness(dst)) {
-				res = ir_emit_byte_swap(proc, res, t);
-			}
-			return ir_emit_conv(proc, res, t);
-		}
-
-
-		return ir_emit(proc, ir_instr_conv(proc, kind, value, src_type, t));
-	}
-
-	if (is_type_complex(src) && is_type_complex(dst)) {
-		Type *ft = base_complex_elem_type(dst);
-		irValue *gen = ir_add_local_generated(proc, dst, false);
-		irValue *real = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 0), ft);
-		irValue *imag = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 1), ft);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 0), real);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 1), imag);
-		return ir_emit_load(proc, gen);
-	}
-
-	if (is_type_quaternion(src) && is_type_quaternion(dst)) {
-		// @QuaternionLayout
-		Type *ft = base_complex_elem_type(dst);
-		irValue *gen = ir_add_local_generated(proc, dst, false);
-		irValue *q0 = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 0), ft);
-		irValue *q1 = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 1), ft);
-		irValue *q2 = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 2), ft);
-		irValue *q3 = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 3), ft);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 0), q0);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 1), q1);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 2), q2);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 3), q3);
-		return ir_emit_load(proc, gen);
-	}
-
-	if (is_type_float(src) && is_type_complex(dst)) {
-		Type *ft = base_complex_elem_type(dst);
-		irValue *gen = ir_add_local_generated(proc, dst, true);
-		irValue *real = ir_emit_conv(proc, value, ft);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 0), real);
-		return ir_emit_load(proc, gen);
-	}
-	if (is_type_float(src) && is_type_quaternion(dst)) {
-		Type *ft = base_complex_elem_type(dst);
-		irValue *gen = ir_add_local_generated(proc, dst, true);
-		irValue *real = ir_emit_conv(proc, value, ft);
-		// @QuaternionLayout
-		ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 3), real);
-		return ir_emit_load(proc, gen);
-	}
-	if (is_type_complex(src) && is_type_quaternion(dst)) {
-		Type *ft = base_complex_elem_type(dst);
-		irValue *gen = ir_add_local_generated(proc, dst, true);
-		irValue *real = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 0), ft);
-		irValue *imag = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 1), ft);
-		// @QuaternionLayout
-		ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 3), real);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 0), imag);
-		return ir_emit_load(proc, gen);
-	}
-
-
-
-	// float <-> integer
-	if (is_type_float(src) && is_type_integer(dst)) {
-		irConvKind kind = irConv_fptosi;
-		if (is_type_unsigned(dst)) {
-			kind = irConv_fptoui;
-		}
-		return ir_emit(proc, ir_instr_conv(proc, kind, value, src_type, t));
-	}
-	if (is_type_integer(src) && is_type_float(dst)) {
-		irConvKind kind = irConv_sitofp;
-		if (is_type_unsigned(src)) {
-			kind = irConv_uitofp;
-		}
-		return ir_emit(proc, ir_instr_conv(proc, kind, value, src_type, t));
-	}
-
-	// Pointer <-> uintptr
-	if (is_type_pointer(src) && is_type_uintptr(dst)) {
-		return ir_emit_ptr_to_uintptr(proc, value, t);
-	}
-	if (is_type_uintptr(src) && is_type_pointer(dst)) {
-		return ir_emit_uintptr_to_ptr(proc, value, t);
-	}
-
-	if (is_type_union(dst)) {
-		for_array(i, dst->Union.variants) {
-			Type *vt = dst->Union.variants[i];
-			if (are_types_identical(vt, src_type)) {
-				ir_emit_comment(proc, str_lit("union - child to parent"));
-				gbAllocator a = ir_allocator();
-				irValue *parent = ir_add_local_generated(proc, t, true);
-				ir_emit_store_union_variant(proc, parent, value, vt);
-				return ir_emit_load(proc, parent);
-			}
-		}
-	}
-
-	// NOTE(bill): This has to be done before 'Pointer <-> Pointer' as it's
-	// subtype polymorphism casting
-	if (check_is_assignable_to_using_subtype(src_type, t)) {
-		Type *st = type_deref(src_type);
-		Type *pst = st;
-		st = type_deref(st);
-
-		bool st_is_ptr = is_type_pointer(src_type);
-		st = base_type(st);
-
-		Type *dt = t;
-		bool dt_is_ptr = type_deref(dt) != dt;
-
-		GB_ASSERT(is_type_struct(st) || is_type_raw_union(st));
-		String field_name = ir_lookup_subtype_polymorphic_field(proc->module->info, t, src_type);
-		if (field_name.len > 0) {
-			// NOTE(bill): It can be casted
-			Selection sel = lookup_field(st, field_name, false, true);
-			if (sel.entity != nullptr) {
-				ir_emit_comment(proc, str_lit("cast - polymorphism"));
-				if (st_is_ptr) {
-					irValue *res = ir_emit_deep_field_gep(proc, value, sel);
-					Type *rt = ir_type(res);
-					if (!are_types_identical(rt, dt) && are_types_identical(type_deref(rt), dt)) {
-						res = ir_emit_load(proc, res);
-					}
-					return res;
-				} else {
-					if (is_type_pointer(ir_type(value))) {
-						Type *rt = ir_type(value);
-						if (!are_types_identical(rt, dt) && are_types_identical(type_deref(rt), dt)) {
-							value = ir_emit_load(proc, value);
-						} else {
-							value = ir_emit_deep_field_gep(proc, value, sel);
-							return ir_emit_load(proc, value);
-						}
-					}
-
-					return ir_emit_deep_field_ev(proc, value, sel);
-
-				}
-			} else {
-				GB_PANIC("invalid subtype cast  %s.%.*s", type_to_string(src_type), LIT(field_name));
-			}
-		}
-	}
-
-
-
-	// Pointer <-> Pointer
-	if (is_type_pointer(src) && is_type_pointer(dst)) {
-		return ir_emit_bitcast(proc, value, t);
-	}
-
-
-
-	// proc <-> proc
-	if (is_type_proc(src) && is_type_proc(dst)) {
-		return ir_emit_bitcast(proc, value, t);
-	}
-
-	// pointer -> proc
-	if (is_type_pointer(src) && is_type_proc(dst)) {
-		return ir_emit_bitcast(proc, value, t);
-	}
-	// proc -> pointer
-	if (is_type_proc(src) && is_type_pointer(dst)) {
-		return ir_emit_bitcast(proc, value, t);
-	}
-
-
-
-	// []byte/[]u8 <-> string
-	if (is_type_u8_slice(src) && is_type_string(dst)) {
-		irValue *elem = ir_slice_elem(proc, value);
-		irValue *len  = ir_slice_len(proc, value);
-		return ir_emit_string(proc, elem, len);
-	}
-	if (is_type_string(src) && is_type_u8_slice(dst)) {
-		irValue *elem = ir_string_elem(proc, value);
-		irValue *elem_ptr = ir_add_local_generated(proc, ir_type(elem), false);
-		ir_emit_store(proc, elem_ptr, elem);
-
-		irValue *len  = ir_string_len(proc, value);
-		irValue *slice = ir_add_local_slice(proc, t, elem_ptr, v_zero, len);
-		return ir_emit_load(proc, slice);
-	}
-
-	if (is_type_array(dst)) {
-		Type *elem = dst->Array.elem;
-		irValue *e = ir_emit_conv(proc, value, elem);
-		// NOTE(bill): Doesn't need to be zero because it will be initialized in the loops
-		irValue *v = ir_add_local_generated(proc, t, false);
-		isize index_count = cast(isize)dst->Array.count;
-
-		for (i32 i = 0; i < index_count; i++) {
-			irValue *elem = ir_emit_array_epi(proc, v, i);
-			ir_emit_store(proc, elem, e);
-		}
-		return ir_emit_load(proc, v);
-	}
-
-	if (is_type_any(dst)) {
-		irValue *result = ir_add_local_generated(proc, t_any, true);
-
-		if (is_type_untyped_nil(src)) {
-			return ir_emit_load(proc, result);
-		}
-
-		Type *st = default_type(src_type);
-
-		irValue *data = ir_address_from_load_or_generate_local(proc, value);
-		GB_ASSERT_MSG(is_type_pointer(ir_type(data)), type_to_string(ir_type(data)));
-		GB_ASSERT_MSG(is_type_typed(st), "%s", type_to_string(st));
-		data = ir_emit_conv(proc, data, t_rawptr);
-
-
-		irValue *id = ir_typeid(proc->module, st);
-
-		ir_emit_store(proc, ir_emit_struct_ep(proc, result, 0), data);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, result, 1), id);
-
-		return ir_emit_load(proc, result);
-	}
-
-	if (is_type_untyped(src)) {
-		if (is_type_string(src) && is_type_string(dst)) {
-			irValue *result = ir_add_local_generated(proc, t, false);
-			ir_emit_store(proc, result, value);
-			return ir_emit_load(proc, result);
-		}
-	}
-
-	gb_printf_err("ir_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' for procedure '%.*s'",
-	         type_to_string(src_type), type_to_string(t),
-	         LIT(proc->name));
-
-	return nullptr;
-}
-
-bool ir_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;
-
-		case Basic_complex32:
-		case Basic_complex64:
-		case Basic_complex128:
-		case Basic_quaternion64:
-		case Basic_quaternion128:
-		case Basic_quaternion256:
-			return true;
-		}
-		break;
-
-	case Type_Pointer:
-		return false;
-
-	case Type_Array:
-	case Type_Slice:
-	case Type_Struct:
-	case Type_Union:
-	case Type_Tuple:
-	case Type_DynamicArray:
-	case Type_Map:
-	case Type_SimdVector:
-		return true;
-
-	case Type_Named:
-		return ir_is_type_aggregate(t->Named.base);
-	}
-
-	return false;
-}
-
-irValue *ir_emit_transmute(irProcedure *proc, irValue *value, Type *t) {
-	Type *src_type = ir_type(value);
-	if (are_types_identical(t, src_type)) {
-		return value;
-	}
-
-	Type *src = base_type(src_type);
-	Type *dst = base_type(t);
-
-	irModule *m = proc->module;
-
-	i64 sz = type_size_of(src);
-	i64 dz = type_size_of(dst);
-
-	GB_ASSERT_MSG(sz == dz, "Invalid transmute conversion: '%s' to '%s'", type_to_string(src_type), type_to_string(t));
-
-	// NOTE(bill): Casting between an integer and a pointer cannot be done through a bitcast
-	if (is_type_uintptr(src) && is_type_pointer(dst)) {
-		return ir_emit_uintptr_to_ptr(proc, value, t);
-	}
-	if (is_type_pointer(src) && is_type_uintptr(dst)) {
-		return ir_emit_ptr_to_uintptr(proc, value, t);
-	}
-	if (is_type_uintptr(src) && is_type_proc(dst)) {
-		irValue *ptr = ir_emit_uintptr_to_ptr(proc, value, t_rawptr);
-		return ir_emit_bitcast(proc, ptr, dst);
-	}
-	if (is_type_proc(src) && is_type_uintptr(dst)) {
-		irValue *ptr = ir_emit_uintptr_to_ptr(proc, value, t_rawptr);
-		return ir_emit_bitcast(proc, ptr, dst);
-	}
-	if (is_type_float(src) && is_type_float(dst)) {
-		return ir_emit_bitcast(proc, value, t);
-	}
-
-	if (is_type_integer(src) && (is_type_pointer(dst) || is_type_cstring(dst))) {
-		Type *vt = core_type(ir_type(value));
-		return ir_emit(proc, ir_instr_conv(proc, irConv_inttoptr, value, vt, t));
-	} else if ((is_type_pointer(src) || is_type_cstring(src)) && is_type_integer(dst)) {
-		Type *vt = core_type(ir_type(value));
-		return ir_emit(proc, ir_instr_conv(proc, irConv_ptrtoint, value, vt, t));
-	}
-
-	if (ir_is_type_aggregate(src) || ir_is_type_aggregate(dst)) {
-		irValue *s = ir_address_from_load_or_generate_local(proc, value);
-		irValue *d = ir_emit_bitcast(proc, s, alloc_type_pointer(t));
-		return ir_emit_load(proc, d);
-	}
-
-	// TODO(bill): Actually figure out what the conversion needs to be correctly 'cause LLVM
-	return ir_emit_bitcast(proc, value, t);
-}
-
-
-
-irValue *ir_emit_union_cast(irProcedure *proc, irValue *value, Type *type, TokenPos pos, bool do_conversion_check=true) {
-	gbAllocator a = ir_allocator();
-
-	Type *src_type = ir_type(value);
-	bool is_ptr = is_type_pointer(src_type);
-
-	bool is_tuple = true;
-	Type *tuple = type;
-	if (type->kind != Type_Tuple) {
-		is_tuple = false;
-		tuple = make_optional_ok_type(type);
-	}
-
-	irValue *v = ir_add_local_generated(proc, tuple, true);
-
-	if (is_ptr) {
-		value = ir_emit_load(proc, value);
-	}
-	Type *src = base_type(type_deref(src_type));
-	GB_ASSERT_MSG(is_type_union(src), "%s", type_to_string(src_type));
-	Type *dst = tuple->Tuple.variables[0]->type;
-
-	irValue *value_  = ir_address_from_load_or_generate_local(proc, value);
-
-	irValue *tag = nullptr;
-	irValue *dst_tag = nullptr;
-	irValue *cond = nullptr;
-	irValue *data = nullptr;
-
-	irValue *gep0 = ir_emit_struct_ep(proc, v, 0);
-	irValue *gep1 = ir_emit_struct_ep(proc, v, 1);
-
-	if (is_type_union_maybe_pointer(src)) {
-		data = ir_emit_load(proc, ir_emit_conv(proc, value_, ir_type(gep0)));
-	} else {
-		tag     = ir_emit_load(proc, ir_emit_union_tag_ptr(proc, value_));
-		dst_tag = ir_const_union_tag(src, dst);
-	}
-
-	irBlock *ok_block = ir_new_block(proc, nullptr, "union_cast.ok");
-	irBlock *end_block = ir_new_block(proc, nullptr, "union_cast.end");
-
-	if (data != nullptr) {
-		GB_ASSERT(is_type_union_maybe_pointer(src));
-		cond = ir_emit_comp_against_nil(proc, Token_NotEq, data);
-	} else {
-		cond = ir_emit_comp(proc, Token_CmpEq, tag, dst_tag);
-	}
-
-	ir_emit_if(proc, cond, ok_block, end_block);
-	ir_start_block(proc, ok_block);
-
-
-
-	if (data == nullptr) {
-		data = ir_emit_load(proc, ir_emit_conv(proc, value_, ir_type(gep0)));
-	}
-	ir_emit_store(proc, gep0, data);
-	ir_emit_store(proc, gep1, v_true);
-
-	ir_emit_jump(proc, end_block);
-	ir_start_block(proc, end_block);
-
-	if (!is_tuple) {
-		if (do_conversion_check) {
-			// NOTE(bill): Panic on invalid conversion
-			Type *dst_type = tuple->Tuple.variables[0]->type;
-
-			irValue *ok = ir_emit_load(proc, ir_emit_struct_ep(proc, v, 1));
-			auto args = array_make<irValue *>(ir_allocator(), 6);
-			args[0] = ok;
-
-			args[1] = ir_find_or_add_entity_string(proc->module, get_file_path_string(pos.file_id));
-			args[2] = ir_const_i32(pos.line);
-			args[3] = ir_const_i32(pos.column);
-
-			args[4] = ir_typeid(proc->module, src_type);
-			args[5] = ir_typeid(proc->module, dst_type);
-			ir_emit_runtime_call(proc, "type_assertion_check", args);
-		}
-
-		return ir_emit_load(proc, ir_emit_struct_ep(proc, v, 0));
-	}
-	return ir_emit_load(proc, v);
-}
-
-irAddr ir_emit_any_cast_addr(irProcedure *proc, irValue *value, Type *type, TokenPos pos) {
-	gbAllocator a = ir_allocator();
-	Type *src_type = ir_type(value);
-
-	if (is_type_pointer(src_type)) {
-		value = ir_emit_load(proc, value);
-	}
-
-	bool is_tuple = true;
-	Type *tuple = type;
-	if (type->kind != Type_Tuple) {
-		is_tuple = false;
-		tuple = make_optional_ok_type(type);
-	}
-	Type *dst_type = tuple->Tuple.variables[0]->type;
-
-	irValue *v = ir_add_local_generated(proc, tuple, true);
-
-	irValue *dst_typeid = ir_typeid(proc->module, dst_type);
-	irValue *any_typeid = ir_emit_struct_ev(proc, value, 1);
-
-
-	irBlock *ok_block = ir_new_block(proc, nullptr, "any_cast.ok");
-	irBlock *end_block = ir_new_block(proc, nullptr, "any_cast.end");
-	irValue *cond = ir_emit_comp(proc, Token_CmpEq, any_typeid, dst_typeid);
-	ir_emit_if(proc, cond, ok_block, end_block);
-	ir_start_block(proc, ok_block);
-
-	irValue *gep0 = ir_emit_struct_ep(proc, v, 0);
-	irValue *gep1 = ir_emit_struct_ep(proc, v, 1);
-
-	irValue *any_data = ir_emit_struct_ev(proc, value, 0);
-	irValue *ptr = ir_emit_conv(proc, any_data, alloc_type_pointer(dst_type));
-	ir_emit_store(proc, gep0, ir_emit_load(proc, ptr));
-	ir_emit_store(proc, gep1, v_true);
-
-	ir_emit_jump(proc, end_block);
-	ir_start_block(proc, end_block);
-
-	if (!is_tuple) {
-		// NOTE(bill): Panic on invalid conversion
-
-		irValue *ok = ir_emit_load(proc, ir_emit_struct_ep(proc, v, 1));
-		auto args = array_make<irValue *>(ir_allocator(), 6);
-		args[0] = ok;
-
-		args[1] = ir_find_or_add_entity_string(proc->module, get_file_path_string(pos.file_id));
-		args[2] = ir_const_i32(pos.line);
-		args[3] = ir_const_i32(pos.column);
-
-		args[4] = any_typeid;
-		args[5] = dst_typeid;
-		ir_emit_runtime_call(proc, "type_assertion_check", args);
-
-		return ir_addr(ir_emit_struct_ep(proc, v, 0));
-	}
-	return ir_addr(v);
-}
-irValue *ir_emit_any_cast(irProcedure *proc, irValue *value, Type *type, TokenPos pos) {
-	return ir_addr_load(proc, ir_emit_any_cast_addr(proc, value, type, pos));
-}
-
-// TODO(bill): Try and make a lot of this constant aggregate literals in LLVM IR
-gb_global irValue *ir_global_type_info_data           = nullptr;
-gb_global irValue *ir_global_type_info_member_types   = nullptr;
-gb_global irValue *ir_global_type_info_member_names   = nullptr;
-gb_global irValue *ir_global_type_info_member_offsets = nullptr;
-gb_global irValue *ir_global_type_info_member_usings  = nullptr;
-gb_global irValue *ir_global_type_info_member_tags    = nullptr;
-
-gb_global i32      ir_global_type_info_data_index           = 0;
-gb_global i32      ir_global_type_info_member_types_index   = 0;
-gb_global i32      ir_global_type_info_member_names_index   = 0;
-gb_global i32      ir_global_type_info_member_offsets_index = 0;
-gb_global i32      ir_global_type_info_member_usings_index  = 0;
-gb_global i32      ir_global_type_info_member_tags_index    = 0;
-
-isize ir_type_info_count(CheckerInfo *info) {
-	return info->minimum_dependency_type_info_set.entries.count+1;
-}
-
-isize ir_type_info_index(CheckerInfo *info, Type *type, bool err_on_not_found=true) {
-	isize index = type_info_index(info, type, false);
-	if (index >= 0) {
-		auto *set = &info->minimum_dependency_type_info_set;
-		for_array(i, set->entries) {
-			if (set->entries[i].ptr == index) {
-				return i+1;
-			}
-		}
-	}
-	if (err_on_not_found) {
-		GB_PANIC("NOT FOUND ir_type_info_index %s @ index %td", type_to_string(type), index);
-	}
-	return -1;
-}
-
-irValue *ir_type_info(irProcedure *proc, Type *type) {
-	CheckerInfo *info = proc->module->info;
-	type = default_type(type);
-
-	i32 id = cast(i32)ir_type_info_index(info, type);
-	GB_ASSERT(id >= 0);
-	return ir_emit_array_ep(proc, ir_global_type_info_data, ir_const_i32(id));
-}
-
-u64 ir_typeid_as_integer(irModule *m, Type *type) {
-	if (type == nullptr) {
-		return 0;
-	}
-	type = default_type(type);
-
-	u64 id = cast(u64)ir_type_info_index(m->info, type);
-	GB_ASSERT(id >= 0);
-
-	u64 kind = Typeid_Invalid;
-	u64 named = is_type_named(type) && type->kind != Type_Basic;
-	u64 special = 0;
-	u64 reserved = 0;
-
-	Type *bt = base_type(type);
-	TypeKind tk = bt->kind;
-	switch (tk) {
-	case Type_Basic: {
-		u32 flags = bt->Basic.flags;
-		if (flags & BasicFlag_Boolean)  kind = Typeid_Boolean;
-		if (flags & BasicFlag_Integer)  kind = Typeid_Integer;
-		if (flags & BasicFlag_Unsigned) kind = Typeid_Integer;
-		if (flags & BasicFlag_Float)    kind = Typeid_Float;
-		if (flags & BasicFlag_Complex)  kind = Typeid_Complex;
-		if (flags & BasicFlag_Pointer)  kind = Typeid_Pointer;
-		if (flags & BasicFlag_String)   kind = Typeid_String;
-		if (flags & BasicFlag_Rune)     kind = Typeid_Rune;
-	} break;
-	case Type_Pointer:         kind = Typeid_Pointer;         break;
-	case Type_Array:           kind = Typeid_Array;           break;
-	case Type_EnumeratedArray: kind = Typeid_Enumerated_Array; break;
-	case Type_Slice:           kind = Typeid_Slice;            break;
-	case Type_DynamicArray:    kind = Typeid_Dynamic_Array;    break;
-	case Type_Map:             kind = Typeid_Map;              break;
-	case Type_Struct:          kind = Typeid_Struct;           break;
-	case Type_Enum:            kind = Typeid_Enum;             break;
-	case Type_Union:           kind = Typeid_Union;            break;
-	case Type_Tuple:           kind = Typeid_Tuple;            break;
-	case Type_Proc:            kind = Typeid_Procedure;        break;
-	case Type_BitSet:          kind = Typeid_Bit_Set;          break;
-	case Type_SimdVector:      kind = Typeid_Simd_Vector;      break;
-	case Type_RelativePointer: kind = Typeid_Relative_Pointer; break;
-	case Type_RelativeSlice:   kind = Typeid_Relative_Slice;   break;
-	}
-
-	if (is_type_cstring(type)) {
-		special = 1;
-	} else if (is_type_integer(type) && !is_type_unsigned(type)) {
-		special = 1;
-	}
-
-	u64 data = 0;
-	if (build_context.word_size == 4) {
-		data |= (id       &~ (1u<<24)) << 0u;  // index
-		data |= (kind     &~ (1u<<5))  << 24u; // kind
-		data |= (named    &~ (1u<<1))  << 29u; // kind
-		data |= (special  &~ (1u<<1))  << 30u; // kind
-		data |= (reserved &~ (1u<<1))  << 31u; // kind
-	} else {
-		GB_ASSERT(build_context.word_size == 8);
-		data |= (id       &~ (1ull<<56)) << 0ul;  // index
-		data |= (kind     &~ (1ull<<5))  << 56ull; // kind
-		data |= (named    &~ (1ull<<1))  << 61ull; // kind
-		data |= (special  &~ (1ull<<1))  << 62ull; // kind
-		data |= (reserved &~ (1ull<<1))  << 63ull; // kind
-	}
-
-	return id;
-}
-
-irValue *ir_typeid(irModule *m, Type *type) {
-	return ir_value_constant(t_typeid, exact_value_u64(ir_typeid_as_integer(m, type)));
-}
-
-
-irValue *ir_emit_logical_binary_expr(irProcedure *proc, TokenKind op, Ast *left, Ast *right, Type *type) {
-	irBlock *rhs  = ir_new_block(proc, nullptr, "logical.cmp.rhs");
-	irBlock *done = ir_new_block(proc, nullptr, "logical.cmp.done");
-
-	type = default_type(type);
-
-	irValue *short_circuit = nullptr;
-	if (op == Token_CmpAnd) {
-		ir_build_cond(proc, left, rhs, done);
-		short_circuit = v_false;
-	} else if (op == Token_CmpOr) {
-		ir_build_cond(proc, left, done, rhs);
-		short_circuit = v_true;
-	}
-
-	if (rhs->preds.count == 0) {
-		ir_start_block(proc, done);
-		return short_circuit;
-	}
-
-	if (done->preds.count == 0) {
-		ir_start_block(proc, rhs);
-		return ir_build_expr(proc, right);
-	}
-
-	auto edges = array_make<irValue *>(ir_allocator(), 0, done->preds.count+1);
-	for_array(i, done->preds) {
-		irValue *edge = ir_emit_conv(proc, short_circuit, type);
-		array_add(&edges, edge);
-	}
-
-	ir_start_block(proc, rhs);
-	irValue *edge = ir_emit_conv(proc, ir_build_expr(proc, right), type);
-	array_add(&edges, edge);
-	ir_emit_jump(proc, done);
-	ir_start_block(proc, done);
-
-	return ir_emit(proc, ir_instr_phi(proc, edges, type));
-}
-
-irValue *ir_emit_logical_binary_expr(irProcedure *proc, Ast *expr) {
-	ast_node(be, BinaryExpr, expr);
-
-	Type *type = type_of_expr(expr);
-	type = default_type(type);
-
-	return ir_emit_logical_binary_expr(proc, be->op.kind, be->left, be->right, type);
-}
-
-
-void ir_emit_bounds_check(irProcedure *proc, Token token, irValue *index, irValue *len) {
-	if (build_context.no_bounds_check) {
-		return;
-	}
-	if ((proc->module->state_flags & StateFlag_no_bounds_check) != 0) {
-		return;
-	}
-
-	index = ir_emit_conv(proc, index, t_int);
-	len = ir_emit_conv(proc, len, t_int);
-
-	gbAllocator a = ir_allocator();
-	irValue *file = ir_find_or_add_entity_string(proc->module, get_file_path_string(token.pos.file_id));
-	irValue *line = ir_const_i32(token.pos.line);
-	irValue *column = ir_const_i32(token.pos.column);
-
-
-	auto args = array_make<irValue *>(ir_allocator(), 5);
-	args[0] = file;
-	args[1] = line;
-	args[2] = column;
-	args[3] = index;
-	args[4] = len;
-
-	ir_emit_runtime_call(proc, "bounds_check_error", args);
-}
-
-void ir_emit_slice_bounds_check(irProcedure *proc, Token token, irValue *low, irValue *high, irValue *len, bool lower_value_used) {
-	if (build_context.no_bounds_check) {
-		return;
-	}
-	if ((proc->module->state_flags & StateFlag_no_bounds_check) != 0) {
-		return;
-	}
-
-	gbAllocator a = ir_allocator();
-	irValue *file = ir_find_or_add_entity_string(proc->module, get_file_path_string(token.pos.file_id));
-	irValue *line = ir_const_i32(token.pos.line);
-	irValue *column = ir_const_i32(token.pos.column);
-	high = ir_emit_conv(proc, high, t_int);
-
-	if (!lower_value_used) {
-		auto args = array_make<irValue *>(ir_allocator(), 5);
-		args[0] = file;
-		args[1] = line;
-		args[2] = column;
-		args[3] = high;
-		args[4] = len;
-
-		ir_emit_runtime_call(proc, "slice_expr_error_hi", args);
-	} else {
-		// No need to convert unless used
-		low  = ir_emit_conv(proc, low, t_int);
-
-		auto args = array_make<irValue *>(ir_allocator(), 6);
-		args[0] = file;
-		args[1] = line;
-		args[2] = column;
-		args[3] = low;
-		args[4] = high;
-		args[5] = len;
-
-		ir_emit_runtime_call(proc, "slice_expr_error_lo_hi", args);
-	}
-}
-
-void ir_emit_dynamic_array_bounds_check(irProcedure *proc, Token token, irValue *low, irValue *high, irValue *max) {
-	if (build_context.no_bounds_check) {
-		return;
-	}
-	if ((proc->module->state_flags & StateFlag_no_bounds_check) != 0) {
-		return;
-	}
-
-	gbAllocator a = ir_allocator();
-	irValue *file = ir_find_or_add_entity_string(proc->module, get_file_path_string(token.pos.file_id));
-	irValue *line = ir_const_i32(token.pos.line);
-	irValue *column = ir_const_i32(token.pos.column);
-	low  = ir_emit_conv(proc, low,  t_int);
-	high = ir_emit_conv(proc, high, t_int);
-
-	auto args = array_make<irValue *>(ir_allocator(), 6);
-	args[0] = file;
-	args[1] = line;
-	args[2] = column;
-	args[3] = low;
-	args[4] = high;
-	args[5] = max;
-
-	ir_emit_runtime_call(proc, "dynamic_array_expr_error", args);
-}
-
-
-
-////////////////////////////////////////////////////////////////
-//
-// @Build
-//
-////////////////////////////////////////////////////////////////
-
-String ir_mangle_name(irGen *s, Entity *e) {
-	irModule *m = &s->module;
-	CheckerInfo *info = m->info;
-	gbAllocator a = ir_allocator();
-
-	String name = e->token.string;
-
-	AstPackage *pkg = e->pkg;
-	GB_ASSERT_MSG(pkg != nullptr, "Missing package for '%.*s'", LIT(name));
-	String pkgn = pkg->name;
-	GB_ASSERT(!rune_is_digit(pkgn[0]));
-	if (pkgn == "llvm") {
-		pkgn = str_lit("llvm$");
-	}
-
-	isize max_len = pkgn.len + 1 + name.len + 1;
-	bool require_suffix_id = is_type_polymorphic(e->type, true);
-	if (e->flags & EntityFlag_NotExported) {
-		require_suffix_id = true;
-	}
-	if (require_suffix_id) {
-		max_len += 21;
-	}
-
-	u8 *new_name = gb_alloc_array(a, u8, max_len);
-	isize new_name_len = gb_snprintf(
-		cast(char *)new_name, max_len,
-		"%.*s.%.*s", LIT(pkgn), LIT(name)
-	);
-	if (require_suffix_id) {
-		char *str = cast(char *)new_name + new_name_len-1;
-		isize len = max_len-new_name_len;
-		isize extra = gb_snprintf(str, len, "-%llu", cast(unsigned long long)e->id);
-		new_name_len += extra-1;
-	}
-
-	return make_string(new_name, new_name_len-1);
-}
-
-
-void ir_mangle_add_sub_type_name(irModule *m, Entity *field, String parent) {
-	if (field->kind != Entity_TypeName) {
-		return;
-	}
-	if (is_type_proc(field->type)) {
-		set_procedure_abi_types(field->type);
-	}
-
-	String cn = field->token.string;
-	isize max_len = parent.len + 1 + 16 + 1 + cn.len;
-	bool require_suffix_id = is_type_polymorphic(field->type, true);
-	if (require_suffix_id) {
-		max_len += 21;
-	}
-
-	u8 *new_name = gb_alloc_array(ir_allocator(), u8, max_len);
-	isize new_name_len = gb_snprintf(cast(char *)new_name, max_len,
-	                                 "%.*s.%.*s", LIT(parent), LIT(cn));
-
-	if (require_suffix_id) {
-		char *str = cast(char *)new_name + new_name_len-1;
-		isize len = max_len-new_name_len;
-		isize extra = gb_snprintf(str, len, "-%llu", cast(unsigned long long)field->id);
-		new_name_len += extra-1;
-	}
-
-	String child = {new_name, new_name_len-1};
-	GB_ASSERT(child.len > 0);
-	ir_add_entity_name(m, field, child);
-	ir_gen_global_type_name(m, field, child);
-}
-
-
-irBranchBlocks ir_lookup_branch_blocks(irProcedure *proc, Ast *ident) {
-	GB_ASSERT(ident->kind == Ast_Ident);
-	Entity *e = entity_of_node(ident);
-	GB_ASSERT(e->kind == Entity_Label);
-	for_array(i, proc->branch_blocks) {
-		irBranchBlocks *b = &proc->branch_blocks[i];
-		if (b->label == e->Label.node) {
-			return *b;
-		}
-	}
-
-	GB_PANIC("Unreachable");
-	irBranchBlocks empty = {};
-	return empty;
-}
-
-
-irTargetList *ir_push_target_list(irProcedure *proc, Ast *label, irBlock *break_, irBlock *continue_, irBlock *fallthrough_) {
-	irTargetList *tl = gb_alloc_item(ir_allocator(), irTargetList);
-	tl->prev          = proc->target_list;
-	tl->break_        = break_;
-	tl->continue_     = continue_;
-	tl->fallthrough_  = fallthrough_;
-	proc->target_list = tl;
-
-	if (label != nullptr) { // Set label blocks
-		GB_ASSERT(label->kind == Ast_Label);
-
-		for_array(i, proc->branch_blocks) {
-			irBranchBlocks *b = &proc->branch_blocks[i];
-			GB_ASSERT(b->label != nullptr && label != nullptr);
-			GB_ASSERT(b->label->kind == Ast_Label);
-			if (b->label == label) {
-				b->break_    = break_;
-				b->continue_ = continue_;
-				return tl;
-			}
-		}
-
-		GB_PANIC("ir_set_label_blocks: Unreachable; Unable to find label: %s", expr_to_string(label->Label.name));
-	}
-
-	return tl;
-}
-
-void ir_pop_target_list(irProcedure *proc) {
-	proc->target_list = proc->target_list->prev;
-}
-
-
-
-irValue *ir_gen_anonymous_proc_lit(irModule *m, String prefix_name, Ast *expr, irProcedure *proc) {
-	auto *found = map_get(&m->anonymous_proc_lits, hash_pointer(expr));
-	if (found != nullptr) {
-		return *found;
-	}
-
-	ast_node(pl, ProcLit, expr);
-
-	// NOTE(bill): Generate a new name
-	// parent$count
-	isize name_len = prefix_name.len + 1 + 8 + 1;
-	u8 *name_text = gb_alloc_array(ir_allocator(), u8, name_len);
-	i32 name_id = cast(i32)m->anonymous_proc_lits.entries.count;
-
-	name_len = gb_snprintf(cast(char *)name_text, name_len, "%.*s$anon-%d", LIT(prefix_name), name_id);
-	String name = make_string(name_text, name_len-1);
-
-	Type *type = type_of_expr(expr);
-	set_procedure_abi_types(type);
-	irValue *value = ir_value_procedure(m, nullptr, type, pl->type, pl->body, name);
-
-	value->Proc.proc_lit = expr;
-	value->Proc.tags = pl->tags;
-	value->Proc.inlining = pl->inlining;
-	value->Proc.parent = proc;
-
-	array_add(&m->procs_to_generate, value);
-	if (proc != nullptr) {
-		array_add(&proc->children, &value->Proc);
-	} else {
-		string_map_set(&m->members, name, value);
-	}
-
-	map_set(&m->anonymous_proc_lits, hash_pointer(expr), value);
-
-	return value;
-}
-
-void ir_gen_global_type_name(irModule *m, Entity *e, String name) {
-	if (e->type == nullptr) return;
-
-	if (e->kind == Entity_TypeName && e->type->kind == Type_Named) {
-		if (e != e->type->Named.type_name) {
-			// NOTE(bill): Is alias
-			return;
-		}
-	}
-
-	Type *bt = base_type(e->type);
-
-	bool is_poly = is_type_polymorphic(bt);
-	if (!is_poly) {
-		if (bt->kind == Type_Struct &&
-		    bt->Struct.is_polymorphic &&
-		    !bt->Struct.is_poly_specialized) {
-			is_poly = true;
-		}
-	}
-	if (is_poly) {
-		auto found = map_get(&m->info->gen_types, hash_pointer(e->type));
-		if (found != nullptr) {
-			for_array(i, *found) {
-				Entity *sub = (*found)[i];
-				// gb_printf_err("--> %.*s %p\n", LIT(sub->token.string), sub);
-				if (ir_min_dep_entity(m, sub)) {
-					ir_mangle_add_sub_type_name(m, sub, name);
-				}
-			}
-		}
-		return;
-	}
-
-	if (!ir_min_dep_entity(m, e)) {
-		return;
-	}
-	if (is_type_proc(e->type)) {
-		return;
-	}
-	irValue *t = ir_value_type_name(name, e->type);
-	ir_module_add_value(m, e, t);
-	string_map_set(&m->members, name, t);
-
-	// if (bt->kind == Type_Struct) {
-	// 	Scope *s = bt->Struct.scope;
-	// 	if (s != nullptr) {
-	// 		for_array(i, s->elements.entries) {
-	// 			Entity *e = s->elements.entries[i].value;
-	// 			if (e->kind == Entity_TypeName) {
-	// 				ir_mangle_add_sub_type_name(m, e, name);
-	// 			}
-	// 		}
-	// 	}
-	// }
-}
-
-
-
-
-void ir_build_defer_stmt(irProcedure *proc, irDefer d) {
-	irBlock *b = ir_new_block(proc, nullptr, "defer");
-	// NOTE(bill): The prev block may defer injection before it's terminator
-	irInstr *last_instr = ir_get_last_instr(proc->curr_block);
-	if (last_instr == nullptr || !ir_is_instr_terminating(last_instr)) {
-		ir_emit_jump(proc, b);
-	}
-	ir_start_block(proc, b);
-	ir_emit_comment(proc, str_lit("defer"));
-	if (d.kind == irDefer_Node) {
-		ir_build_stmt(proc, d.stmt);
-	} else if (d.kind == irDefer_Instr) {
-		// NOTE(bill): Need to make a new copy
-		irValue *instr = cast(irValue *)gb_alloc_copy(ir_allocator(), d.instr, gb_size_of(irValue));
-		ir_emit(proc, instr);
-	} else if (d.kind == irDefer_Proc) {
-		ir_emit_call(proc, d.proc.deferred, d.proc.result_as_args);
-	}
-}
-
-irValue *ir_emit_min(irProcedure *proc, Type *t, irValue *x, irValue *y) {
-	x = ir_emit_conv(proc, x, t);
-	y = ir_emit_conv(proc, y, t);
-
-	if (is_type_float(t)) {
-		gbAllocator a = ir_allocator();
-		i64 sz = 8*type_size_of(t);
-		auto args = array_make<irValue *>(ir_allocator(), 2);
-		args[0] = x;
-		args[1] = y;
-		switch (sz) {
-		case 16: return ir_emit_runtime_call(proc, "min_f16", args);
-		case 32: return ir_emit_runtime_call(proc, "min_f32", args);
-		case 64: return ir_emit_runtime_call(proc, "min_f64", args);
-		}
-		GB_PANIC("Unknown float type");
-	}
-	return ir_emit_select(proc, ir_emit_comp(proc, Token_Lt, x, y), x, y);
-}
-irValue *ir_emit_max(irProcedure *proc, Type *t, irValue *x, irValue *y) {
-	x = ir_emit_conv(proc, x, t);
-	y = ir_emit_conv(proc, y, t);
-
-	if (is_type_float(t)) {
-		gbAllocator a = ir_allocator();
-		i64 sz = 8*type_size_of(t);
-		auto args = array_make<irValue *>(ir_allocator(), 2);
-		args[0] = x;
-		args[1] = y;
-		switch (sz) {
-		case 16: return ir_emit_runtime_call(proc, "max_f16", args);
-		case 32: return ir_emit_runtime_call(proc, "max_f32", args);
-		case 64: return ir_emit_runtime_call(proc, "max_f64", args);
-		}
-		GB_PANIC("Unknown float type");
-	}
-	return ir_emit_select(proc, ir_emit_comp(proc, Token_Gt, x, y), x, y);
-}
-
-
-irValue *ir_emit_clamp(irProcedure *proc, Type *t, irValue *x, irValue *min, irValue *max) {
-	ir_emit_comment(proc, str_lit("clamp"));
-	irValue *z = nullptr;
-	z = ir_emit_max(proc, t, x, min);
-	z = ir_emit_min(proc, t, z, max);
-	return z;
-}
-
-
-irValue *ir_find_global_variable(irProcedure *proc, String name) {
-	AstPackage *pkg = proc->module->info->runtime_package;
-	Entity *e = scope_lookup_current(pkg->scope, name);
-	irValue **value = map_get(&proc->module->values, hash_entity(e));
-	GB_ASSERT_MSG(value != nullptr, "Unable to find global variable '%.*s'", LIT(name));
-	return *value;
-}
-
-void ir_build_stmt_list(irProcedure *proc, Slice<Ast *> stmts);
-void ir_build_assign_op(irProcedure *proc, irAddr const &lhs, irValue *value, TokenKind op);
-
-bool is_double_pointer(Type *t) {
-	if (!is_type_pointer(t)) {
-		return false;
-	}
-	Type *td = type_deref(t);
-	if (td == nullptr || td == t) {
-		return false;
-	}
-	return is_type_pointer(td);
-}
-
-irValue *ir_emit_source_code_location(irProcedure *proc, String procedure, TokenPos pos) {
-	gbAllocator a = ir_allocator();
-	irValue *v = ir_alloc_value(irValue_SourceCodeLocation);
-	v->SourceCodeLocation.file      = ir_find_or_add_entity_string(proc->module, get_file_path_string(pos.file_id));
-	v->SourceCodeLocation.line      = ir_const_i32(pos.line);
-	v->SourceCodeLocation.column    = ir_const_i32(pos.column);
-	v->SourceCodeLocation.procedure = ir_find_or_add_entity_string(proc->module, procedure);
-	return v;
-}
-
-
-irValue *ir_emit_source_code_location(irProcedure *proc, Ast *node) {
-	String proc_name = {};
-	if (proc->entity) {
-		proc_name = proc->entity->token.string;
-	}
-	TokenPos pos = {};
-	if (node) {
-		pos = ast_token(node).pos;
-	}
-	return ir_emit_source_code_location(proc, proc_name, pos);
-}
-
-void ir_emit_increment(irProcedure *proc, irValue *addr) {
-	GB_ASSERT(is_type_pointer(ir_type(addr)));
-	Type *type = type_deref(ir_type(addr));
-	ir_emit_store(proc, addr, ir_emit_arith(proc, Token_Add, ir_emit_load(proc, addr), v_one, type));
-
-}
-
-void ir_init_data_with_defaults(irProcedure *proc, irValue *ptr, irValue *count, Ast *expr) {
-	Type *elem_type = type_deref(ir_type(ptr));
-	GB_ASSERT(is_type_struct(elem_type) || is_type_array(elem_type));
-
-	irValue *index = ir_add_local_generated(proc, t_int, false);
-	ir_emit_store(proc, index, ir_const_int(0));
-
-	irBlock *loop = nullptr;
-	irBlock *done = nullptr;
-	irBlock *body = nullptr;
-
-	loop = ir_new_block(proc, nullptr, "make.init.loop");
-	ir_emit_jump(proc, loop);
-	ir_start_block(proc, loop);
-
-	body = ir_new_block(proc, nullptr, "make.init.body");
-	done = ir_new_block(proc, nullptr, "make.init.done");
-
-	irValue *cond = ir_emit_comp(proc, Token_Lt, ir_emit_load(proc, index), count);
-	ir_emit_if(proc, cond, body, done);
-	ir_start_block(proc, body);
-
-	irValue *offset_ptr = ir_emit_ptr_offset(proc, ptr, ir_emit_load(proc, index));
-	ir_emit(proc, ir_instr_zero_init(proc, offset_ptr)); // Use simple zero for this
-	// ir_emit_zero_init(proc, offset_ptr, expr);
-
-	ir_emit_increment(proc, index);
-
-	ir_emit_jump(proc, loop);
-	ir_start_block(proc, done);
-}
-
-
-irValue *ir_build_builtin_proc(irProcedure *proc, Ast *expr, TypeAndValue tv, BuiltinProcId id) {
-	ast_node(ce, CallExpr, expr);
-
-	switch (id) {
-	case BuiltinProc_DIRECTIVE: {
-		ast_node(bd, BasicDirective, ce->proc);
-		String name = bd->name;
-		GB_ASSERT(name == "location");
-		String procedure = proc->entity->token.string;
-		TokenPos pos = ast_token(ce->proc).pos;
-		if (ce->args.count > 0) {
-			Ast *ident = unselector_expr(ce->args[0]);
-			GB_ASSERT(ident->kind == Ast_Ident);
-			Entity *e = entity_of_node(ident);
-			GB_ASSERT(e != nullptr);
-
-			if (e->parent_proc_decl != nullptr && e->parent_proc_decl->entity != nullptr) {
-				procedure = e->parent_proc_decl->entity->token.string;
-			} else {
-				procedure = str_lit("");
-			}
-			pos = e->token.pos;
-
-		}
-		return ir_emit_source_code_location(proc, procedure, pos);
-	}
-
-	case BuiltinProc_type_info_of: {
-		Ast *arg = ce->args[0];
-		TypeAndValue tav = type_and_value_of_expr(arg);
-		if (tav.mode == Addressing_Type) {
-			Type *t = default_type(type_of_expr(arg));
-			return ir_type_info(proc, t);
-		}
-		GB_ASSERT(is_type_typeid(tav.type));
-
-		auto args = array_make<irValue *>(ir_allocator(), 1);
-		args[0] = ir_build_expr(proc, arg);
-		return ir_emit_runtime_call(proc, "__type_info_of", args);
-	}
-
-	case BuiltinProc_typeid_of: {
-		Ast *arg = ce->args[0];
-		TypeAndValue tav = type_and_value_of_expr(arg);
-		if (tav.mode == Addressing_Type) {
-			Type *t = default_type(type_of_expr(arg));
-			return ir_typeid(proc->module, t);
-		}
-		Type *t = base_type(tav.type);
-		GB_ASSERT(are_types_identical(t, t_type_info_ptr));
-
-		auto args = array_make<irValue *>(ir_allocator(), 1);
-		args[0] = ir_emit_conv(proc, ir_build_expr(proc, arg), t_type_info_ptr);
-		return ir_emit_runtime_call(proc, "__typeid_of", args);
-	}
-
-	case BuiltinProc_len: {
-		irValue *v = ir_build_expr(proc, ce->args[0]);
-		Type *t = base_type(ir_type(v));
-		if (is_type_pointer(t)) {
-			// IMPORTANT TODO(bill): Should there be a nil pointer check?
-			v = ir_emit_load(proc, v);
-			t = type_deref(t);
-		}
-		if (is_type_cstring(t)) {
-			return ir_cstring_len(proc, v);
-		} else if (is_type_string(t)) {
-			return ir_string_len(proc, v);
-		} else if (is_type_array(t)) {
-			GB_PANIC("Array lengths are constant");
-		} else if (is_type_slice(t)) {
-			return ir_slice_len(proc, v);
-		} else if (is_type_dynamic_array(t)) {
-			return ir_dynamic_array_len(proc, v);
-		} else if (is_type_map(t)) {
-			return ir_map_len(proc, v);
-		} else if (is_type_soa_struct(t)) {
-			return ir_soa_struct_len(proc, v);
-		}
-
-		GB_PANIC("Unreachable");
-		break;
-	}
-
-	case BuiltinProc_cap: {
-		irValue *v = ir_build_expr(proc, ce->args[0]);
-		Type *t = base_type(ir_type(v));
-		if (is_type_pointer(t)) {
-			// IMPORTANT TODO(bill): Should there be a nil pointer check?
-			v = ir_emit_load(proc, v);
-			t = type_deref(t);
-		}
-		if (is_type_string(t)) {
-			GB_PANIC("Unreachable");
-		} else if (is_type_array(t)) {
-			GB_PANIC("Array lengths are constant");
-		} else if (is_type_slice(t)) {
-			return ir_slice_len(proc, v);
-		} else if (is_type_dynamic_array(t)) {
-			return ir_dynamic_array_cap(proc, v);
-		} else if (is_type_map(t)) {
-			return ir_map_cap(proc, v);
-		} else if (is_type_soa_struct(t)) {
-			return ir_soa_struct_cap(proc, v);
-		}
-
-		GB_PANIC("Unreachable");
-
-		break;
-	}
-
-	case BuiltinProc_swizzle: {
-		ir_emit_comment(proc, str_lit("swizzle.begin"));
-		irAddr addr = ir_build_addr(proc, ce->args[0]);
-		isize index_count = ce->args.count-1;
-		if (index_count == 0) {
-			return ir_addr_load(proc, addr);
-		}
-		irValue *src = ir_addr_get_ptr(proc, addr);
-		// TODO(bill): Should this be zeroed or not?
-		irValue *dst = ir_add_local_generated(proc, tv.type, true);
-
-		for (i32 i = 1; i < ce->args.count; i++) {
-			TypeAndValue tv = type_and_value_of_expr(ce->args[i]);
-			GB_ASSERT(is_type_integer(tv.type));
-			GB_ASSERT(tv.value.kind == ExactValue_Integer);
-
-			i32 src_index = cast(i32)big_int_to_i64(&tv.value.value_integer);
-			i32 dst_index = i-1;
-
-			irValue *src_elem = ir_emit_array_epi(proc, src, src_index);
-			irValue *dst_elem = ir_emit_array_epi(proc, dst, dst_index);
-
-			ir_emit_store(proc, dst_elem, ir_emit_load(proc, src_elem));
-		}
-		ir_emit_comment(proc, str_lit("swizzle.end"));
-		return ir_emit_load(proc, dst);
-	}
-
-	case BuiltinProc_complex: {
-		ir_emit_comment(proc, str_lit("complex"));
-		irValue *real = ir_build_expr(proc, ce->args[0]);
-		irValue *imag = ir_build_expr(proc, ce->args[1]);
-		irValue *dst = ir_add_local_generated(proc, tv.type, false);
-
-		Type *ft = base_complex_elem_type(tv.type);
-		real = ir_emit_conv(proc, real, ft);
-		imag = ir_emit_conv(proc, imag, ft);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 0), real);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 1), imag);
-
-		return ir_emit_load(proc, dst);
-	}
-
-	case BuiltinProc_quaternion: {
-		ir_emit_comment(proc, str_lit("quaternion"));
-		irValue *real = ir_build_expr(proc, ce->args[0]);
-		irValue *imag = ir_build_expr(proc, ce->args[1]);
-		irValue *jmag = ir_build_expr(proc, ce->args[2]);
-		irValue *kmag = ir_build_expr(proc, ce->args[3]);
-
-		// @QuaternionLayout
-		irValue *dst = ir_add_local_generated(proc, tv.type, false);
-		Type *ft = base_complex_elem_type(tv.type);
-		real = ir_emit_conv(proc, real, ft);
-		imag = ir_emit_conv(proc, imag, ft);
-		jmag = ir_emit_conv(proc, jmag, ft);
-		kmag = ir_emit_conv(proc, kmag, ft);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 3), real);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 0), imag);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 1), jmag);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 2), kmag);
-
-		return ir_emit_load(proc, dst);
-	}
-
-	case BuiltinProc_real: {
-		ir_emit_comment(proc, str_lit("real"));
-		irValue *val = ir_build_expr(proc, ce->args[0]);
-		if (is_type_complex(ir_type(val))) {
-			irValue *real = ir_emit_struct_ev(proc, val, 0);
-			return ir_emit_conv(proc, real, tv.type);
-		} else if (is_type_quaternion(ir_type(val))) {
-			// @QuaternionLayout
-			irValue *real = ir_emit_struct_ev(proc, val, 3);
-			return ir_emit_conv(proc, real, tv.type);
-		}
-		GB_PANIC("invalid type for real");
-		return nullptr;
-	}
-	case BuiltinProc_imag: {
-		ir_emit_comment(proc, str_lit("imag"));
-		irValue *val = ir_build_expr(proc, ce->args[0]);
-		if (is_type_complex(ir_type(val))) {
-			irValue *imag = ir_emit_struct_ev(proc, val, 1);
-			return ir_emit_conv(proc, imag, tv.type);
-		} else if (is_type_quaternion(ir_type(val))) {
-			// @QuaternionLayout
-			irValue *imag = ir_emit_struct_ev(proc, val, 0);
-			return ir_emit_conv(proc, imag, tv.type);
-		}
-		GB_PANIC("invalid type for imag");
-		return nullptr;
-	}
-	case BuiltinProc_jmag: {
-		ir_emit_comment(proc, str_lit("jmag"));
-		irValue *val = ir_build_expr(proc, ce->args[0]);
-		if (is_type_quaternion(ir_type(val))) {
-			// @QuaternionLayout
-			irValue *imag = ir_emit_struct_ev(proc, val, 1);
-			return ir_emit_conv(proc, imag, tv.type);
-		}
-		GB_PANIC("invalid type for jmag");
-		return nullptr;
-	}
-	case BuiltinProc_kmag: {
-		ir_emit_comment(proc, str_lit("kmag"));
-		irValue *val = ir_build_expr(proc, ce->args[0]);
-		if (is_type_quaternion(ir_type(val))) {
-			// @QuaternionLayout
-			irValue *imag = ir_emit_struct_ev(proc, val, 2);
-			return ir_emit_conv(proc, imag, tv.type);
-		}
-		GB_PANIC("invalid type for kmag");
-		return nullptr;
-	}
-
-	case BuiltinProc_conj: {
-		ir_emit_comment(proc, str_lit("conj"));
-		irValue *val = ir_build_expr(proc, ce->args[0]);
-		irValue *res = nullptr;
-		Type *t = ir_type(val);
-		if (is_type_complex(t)) {
-			res = ir_add_local_generated(proc, tv.type, false);
-			irValue *real = ir_emit_struct_ev(proc, val, 0);
-			irValue *imag = ir_emit_struct_ev(proc, val, 1);
-			imag = ir_emit_unary_arith(proc, Token_Sub, imag, ir_type(imag));
-			ir_emit_store(proc, ir_emit_struct_ep(proc, res, 0), real);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, res, 1), imag);
-		} else if (is_type_quaternion(t)) {
-			// @QuaternionLayout
-			res = ir_add_local_generated(proc, tv.type, false);
-			irValue *real = ir_emit_struct_ev(proc, val, 3);
-			irValue *imag = ir_emit_struct_ev(proc, val, 0);
-			irValue *jmag = ir_emit_struct_ev(proc, val, 1);
-			irValue *kmag = ir_emit_struct_ev(proc, val, 2);
-			imag = ir_emit_unary_arith(proc, Token_Sub, imag, ir_type(imag));
-			jmag = ir_emit_unary_arith(proc, Token_Sub, jmag, ir_type(jmag));
-			kmag = ir_emit_unary_arith(proc, Token_Sub, kmag, ir_type(kmag));
-			ir_emit_store(proc, ir_emit_struct_ep(proc, res, 3), real);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, res, 0), imag);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, res, 1), jmag);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, res, 2), kmag);
-		}
-		return ir_emit_load(proc, res);
-	}
-
-	case BuiltinProc_expand_to_tuple: {
-		ir_emit_comment(proc, str_lit("expand_to_tuple"));
-		irValue *val = ir_build_expr(proc, ce->args[0]);
-		Type *t = base_type(ir_type(val));
-
-		if (!is_type_tuple(tv.type)) {
-			if (t->kind == Type_Struct) {
-				GB_ASSERT(t->Struct.fields.count == 1);
-				return ir_emit_struct_ev(proc, val, 0);
-			} else if (t->kind == Type_Array) {
-				GB_ASSERT(t->Array.count == 1);
-				return ir_emit_array_epi(proc, val, 0);
-			} else {
-				GB_PANIC("Unknown type of expand_to_tuple");
-			}
-
-		}
-
-		GB_ASSERT(is_type_tuple(tv.type));
-		// NOTE(bill): Doesn't need to be zero because it will be initialized in the loops
-		irValue *tuple = ir_add_local_generated(proc, tv.type, false);
-		if (t->kind == Type_Struct) {
-			for_array(src_index, t->Struct.fields) {
-				Entity *field = t->Struct.fields[src_index];
-				i32 field_index = field->Variable.field_index;
-				irValue *f = ir_emit_struct_ev(proc, val, field_index);
-				irValue *ep = ir_emit_struct_ep(proc, tuple, cast(i32)src_index);
-				ir_emit_store(proc, ep, f);
-			}
-		} else if (t->kind == Type_Array) {
-			// TODO(bill): Clean-up this code
-			irValue *ap = ir_address_from_load_or_generate_local(proc, val);
-			for (i32 i = 0; i < cast(i32)t->Array.count; i++) {
-				irValue *f = ir_emit_load(proc, ir_emit_array_epi(proc, ap, i));
-				irValue *ep = ir_emit_struct_ep(proc, tuple, i);
-				ir_emit_store(proc, ep, f);
-			}
-		} else {
-			GB_PANIC("Unknown type of expand_to_tuple");
-		}
-		return ir_emit_load(proc, tuple);
-	}
-
-	case BuiltinProc_min: {
-		ir_emit_comment(proc, str_lit("min"));
-		Type *t = type_of_expr(expr);
-		if (ce->args.count == 2) {
-			return ir_emit_min(proc, t, ir_build_expr(proc, ce->args[0]), ir_build_expr(proc, ce->args[1]));
-		} else {
-			irValue *x = ir_build_expr(proc, ce->args[0]);
-			for (isize i = 1; i < ce->args.count; i++) {
-				x = ir_emit_min(proc, t, x, ir_build_expr(proc, ce->args[i]));
-			}
-			return x;
-		}
-	}
-
-	case BuiltinProc_max: {
-		ir_emit_comment(proc, str_lit("max"));
-		Type *t = type_of_expr(expr);
-		if (ce->args.count == 2) {
-			return ir_emit_max(proc, t, ir_build_expr(proc, ce->args[0]), ir_build_expr(proc, ce->args[1]));
-		} else {
-			irValue *x = ir_build_expr(proc, ce->args[0]);
-			for (isize i = 1; i < ce->args.count; i++) {
-				x = ir_emit_max(proc, t, x, ir_build_expr(proc, ce->args[i]));
-			}
-			return x;
-		}
-	}
-
-	case BuiltinProc_abs: {
-		gbAllocator a = ir_allocator();
-		irValue *x = ir_build_expr(proc, ce->args[0]);
-		Type *t = ir_type(x);
-		if (is_type_unsigned(t)) {
-			return x;
-		}
-		ir_emit_comment(proc, str_lit("abs"));
-		if (is_type_quaternion(t)) {
-			i64 sz = 8*type_size_of(t);
-			auto args = array_make<irValue *>(ir_allocator(), 1);
-			args[0] = x;
-			switch (sz) {
-			case 64:  return ir_emit_runtime_call(proc, "abs_quaternion64", args);
-			case 128: return ir_emit_runtime_call(proc, "abs_quaternion128", args);
-			case 256: return ir_emit_runtime_call(proc, "abs_quaternion256", args);
-			}
-			GB_PANIC("Unknown complex type");
-		} else if (is_type_complex(t)) {
-			i64 sz = 8*type_size_of(t);
-			auto args = array_make<irValue *>(ir_allocator(), 1);
-			args[0] = x;
-			switch (sz) {
-			case 32:  return ir_emit_runtime_call(proc, "abs_complex32",  args);
-			case 64:  return ir_emit_runtime_call(proc, "abs_complex64",  args);
-			case 128: return ir_emit_runtime_call(proc, "abs_complex128", args);
-			}
-			GB_PANIC("Unknown complex type");
-		} else if (is_type_float(t)) {
-			i64 sz = 8*type_size_of(t);
-			auto args = array_make<irValue *>(ir_allocator(), 1);
-			args[0] = x;
-			switch (sz) {
-			case 16: return ir_emit_runtime_call(proc, "abs_f16", args);
-			case 32: return ir_emit_runtime_call(proc, "abs_f32", args);
-			case 64: return ir_emit_runtime_call(proc, "abs_f64", args);
-			}
-			GB_PANIC("Unknown float type");
-		}
-		irValue *zero = ir_emit_conv(proc, v_zero, t);
-		irValue *cond = ir_emit_comp(proc, Token_Lt, x, zero);
-		irValue *neg = ir_emit(proc, ir_instr_unary_op(proc, Token_Sub, x, t));
-		return ir_emit_select(proc, cond, neg, x);
-	}
-
-	case BuiltinProc_clamp:
-		ir_emit_comment(proc, str_lit("clamp"));
-		return ir_emit_clamp(proc, type_of_expr(expr),
-		                     ir_build_expr(proc, ce->args[0]),
-		                     ir_build_expr(proc, ce->args[1]),
-		                     ir_build_expr(proc, ce->args[2]));
-
-
-
-	// "Intrinsics"
-	case BuiltinProc_alloca:
-		{
-			auto args = array_make<irValue *>(permanent_allocator(), 2);
-			args[0] = ir_emit_conv(proc, ir_build_expr(proc, ce->args[0]), t_i32);
-			args[1] = ir_build_expr(proc, ce->args[1]);
-			return ir_emit(proc, ir_instr_inline_code(proc, id, args, t_u8_ptr));
-		}
-
-	case BuiltinProc_cpu_relax:
-		return ir_emit(proc, ir_instr_inline_code(proc, id, {}, nullptr));
-
-	case BuiltinProc_volatile_store:  {
-		irValue *dst = ir_build_expr(proc, ce->args[0]);
-		irValue *val = ir_build_expr(proc, ce->args[1]);
-		val = ir_emit_conv(proc, val, type_deref(ir_type(dst)));
-		return ir_emit(proc, ir_instr_store(proc, dst, val, true));
-	}
-
-	case BuiltinProc_volatile_load: {
-		irValue *dst = ir_build_expr(proc, ce->args[0]);
-		return ir_emit(proc, ir_instr_load(proc, dst, true));
-	}
-
-	case BuiltinProc_atomic_fence:
-	case BuiltinProc_atomic_fence_acq:
-	case BuiltinProc_atomic_fence_rel:
-	case BuiltinProc_atomic_fence_acqrel:
-		return ir_emit(proc, ir_instr_atomic_fence(proc, id));
-
-	case BuiltinProc_atomic_store:
-	case BuiltinProc_atomic_store_rel:
-	case BuiltinProc_atomic_store_relaxed:
-	case BuiltinProc_atomic_store_unordered: {
-		irValue *dst = ir_build_expr(proc, ce->args[0]);
-		irValue *val = ir_build_expr(proc, ce->args[1]);
-		val = ir_emit_conv(proc, val, type_deref(ir_type(dst)));
-		return ir_emit(proc, ir_instr_atomic_store(proc, dst, val, id));
-	}
-
-	case BuiltinProc_atomic_load:
-	case BuiltinProc_atomic_load_acq:
-	case BuiltinProc_atomic_load_relaxed:
-	case BuiltinProc_atomic_load_unordered: {
-		irValue *dst = ir_build_expr(proc, ce->args[0]);
-		return ir_emit(proc, ir_instr_atomic_load(proc, dst, id));
-	}
-
-	case BuiltinProc_atomic_add:
-	case BuiltinProc_atomic_add_acq:
-	case BuiltinProc_atomic_add_rel:
-	case BuiltinProc_atomic_add_acqrel:
-	case BuiltinProc_atomic_add_relaxed:
-	case BuiltinProc_atomic_sub:
-	case BuiltinProc_atomic_sub_acq:
-	case BuiltinProc_atomic_sub_rel:
-	case BuiltinProc_atomic_sub_acqrel:
-	case BuiltinProc_atomic_sub_relaxed:
-	case BuiltinProc_atomic_and:
-	case BuiltinProc_atomic_and_acq:
-	case BuiltinProc_atomic_and_rel:
-	case BuiltinProc_atomic_and_acqrel:
-	case BuiltinProc_atomic_and_relaxed:
-	case BuiltinProc_atomic_nand:
-	case BuiltinProc_atomic_nand_acq:
-	case BuiltinProc_atomic_nand_rel:
-	case BuiltinProc_atomic_nand_acqrel:
-	case BuiltinProc_atomic_nand_relaxed:
-	case BuiltinProc_atomic_or:
-	case BuiltinProc_atomic_or_acq:
-	case BuiltinProc_atomic_or_rel:
-	case BuiltinProc_atomic_or_acqrel:
-	case BuiltinProc_atomic_or_relaxed:
-	case BuiltinProc_atomic_xor:
-	case BuiltinProc_atomic_xor_acq:
-	case BuiltinProc_atomic_xor_rel:
-	case BuiltinProc_atomic_xor_acqrel:
-	case BuiltinProc_atomic_xor_relaxed:
-	case BuiltinProc_atomic_xchg:
-	case BuiltinProc_atomic_xchg_acq:
-	case BuiltinProc_atomic_xchg_rel:
-	case BuiltinProc_atomic_xchg_acqrel:
-	case BuiltinProc_atomic_xchg_relaxed: {
-		irValue *dst = ir_build_expr(proc, ce->args[0]);
-		irValue *val = ir_build_expr(proc, ce->args[1]);
-		val = ir_emit_conv(proc, val, type_deref(ir_type(dst)));
-		return ir_emit(proc, ir_instr_atomic_rmw(proc, dst, val, id));
-	}
-
-	case BuiltinProc_atomic_cxchg:
-	case BuiltinProc_atomic_cxchg_acq:
-	case BuiltinProc_atomic_cxchg_rel:
-	case BuiltinProc_atomic_cxchg_acqrel:
-	case BuiltinProc_atomic_cxchg_relaxed:
-	case BuiltinProc_atomic_cxchg_failrelaxed:
-	case BuiltinProc_atomic_cxchg_failacq:
-	case BuiltinProc_atomic_cxchg_acq_failrelaxed:
-	case BuiltinProc_atomic_cxchg_acqrel_failrelaxed:
-	case BuiltinProc_atomic_cxchgweak:
-	case BuiltinProc_atomic_cxchgweak_acq:
-	case BuiltinProc_atomic_cxchgweak_rel:
-	case BuiltinProc_atomic_cxchgweak_acqrel:
-	case BuiltinProc_atomic_cxchgweak_relaxed:
-	case BuiltinProc_atomic_cxchgweak_failrelaxed:
-	case BuiltinProc_atomic_cxchgweak_failacq:
-	case BuiltinProc_atomic_cxchgweak_acq_failrelaxed:
-	case BuiltinProc_atomic_cxchgweak_acqrel_failrelaxed: {
-		Type *type = expr->tav.type;
-
-		irValue *address = ir_build_expr(proc, ce->args[0]);
-		Type *elem = type_deref(ir_type(address));
-		irValue *old_value = ir_build_expr(proc, ce->args[1]);
-		irValue *new_value = ir_build_expr(proc, ce->args[2]);
-		old_value = ir_emit_conv(proc, old_value, elem);
-		new_value = ir_emit_conv(proc, new_value, elem);
-
-		return ir_emit(proc, ir_instr_atomic_cxchg(proc, type, address, old_value, new_value, id));
-	}
-
-	case BuiltinProc_type_equal_proc:
-		return ir_get_equal_proc_for_type(proc->module, ce->args[0]->tav.type);
-
-	case BuiltinProc_type_hasher_proc:
-		return ir_get_hasher_proc_for_type(proc->module, ce->args[0]->tav.type);
-	}
-
-	GB_PANIC("Unhandled built-in procedure");
-	return nullptr;
-}
-
-
-irValue *ir_handle_param_value(irProcedure *proc, Type *parameter_type, ParameterValue const &param_value, TokenPos const &pos) {
-	switch (param_value.kind) {
-	case ParameterValue_Constant:
-		if (is_type_constant_type(parameter_type)) {
-			return ir_value_constant(parameter_type, param_value.value);
-		} else {
-			ExactValue ev = param_value.value;
-			irValue *arg = nullptr;
-			Type *type = type_of_expr(param_value.original_ast_expr);
-			if (type != nullptr) {
-				arg = ir_value_constant(type, ev);
-			} else {
-				arg = ir_value_constant(parameter_type, param_value.value);
-			}
-			return ir_emit_conv(proc, arg, parameter_type);
-		}
-
-	case ParameterValue_Nil:
-		return ir_value_nil(parameter_type);
-	case ParameterValue_Location:
-		{
-			String proc_name = {};
-			if (proc->entity != nullptr) {
-				proc_name = proc->entity->token.string;
-			}
-			return ir_emit_source_code_location(proc, proc_name, pos);
-		}
-	case ParameterValue_Value:
-		return ir_build_expr(proc, param_value.ast_value);
-	}
-	return ir_value_nil(parameter_type);
-}
-
-irValue *ir_build_expr_internal(irProcedure *proc, Ast *expr);
-
-
-irValue *ir_build_expr(irProcedure *proc, Ast *expr) {
-	u64 prev_state_flags = proc->module->state_flags;
-	defer (proc->module->state_flags = prev_state_flags);
-
-	if (expr->state_flags != 0) {
-		u64 in = expr->state_flags;
-		u64 out = proc->module->state_flags;
-
-		if (in & StateFlag_bounds_check) {
-			out |= StateFlag_bounds_check;
-			out &= ~StateFlag_no_bounds_check;
-		} else if (in & StateFlag_no_bounds_check) {
-			out |= StateFlag_no_bounds_check;
-			out &= ~StateFlag_bounds_check;
-		}
-
-		proc->module->state_flags = out;
-	}
-
-	irValue *v = ir_build_expr_internal(proc, expr);
-	return v;
-}
-
-
-irValue *ir_build_call_expr(irProcedure *proc, Ast *expr) {
-	ast_node(ce, CallExpr, expr);
-	TypeAndValue tv = type_and_value_of_expr(expr);
-	TypeAndValue proc_tv = type_and_value_of_expr(ce->proc);
-	AddressingMode proc_mode = proc_tv.mode;
-	if (proc_mode == Addressing_Type) {
-		GB_ASSERT(ce->args.count == 1);
-		irValue *x = ir_build_expr(proc, ce->args[0]);
-		irValue *y = ir_emit_conv(proc, x, tv.type);
-		return y;
-	}
-
-	Ast *p = unparen_expr(ce->proc);
-	if (proc_mode == Addressing_Builtin) {
-		Entity *e = entity_of_node(p);
-		BuiltinProcId id = BuiltinProc_Invalid;
-		if (e != nullptr) {
-			id = cast(BuiltinProcId)e->Builtin.id;
-		} else {
-			id = BuiltinProc_DIRECTIVE;
-		}
-		return ir_build_builtin_proc(proc, expr, tv, id);
-	}
-
-	// NOTE(bill): Regular call
-	irValue *value = nullptr;
-	Ast *proc_expr = unparen_expr(ce->proc);
-	if (proc_expr->tav.mode == Addressing_Constant) {
-		ExactValue v = proc_expr->tav.value;
-		switch (v.kind) {
-		case ExactValue_Integer:
-			{
-				u64 u = big_int_to_u64(&v.value_integer);
-				irValue *x = ir_const_uintptr(u);
-				x = ir_emit_conv(proc, x, t_rawptr);
-				value = ir_emit_conv(proc, x, proc_expr->tav.type);
-				break;
-			}
-		case ExactValue_Pointer:
-			{
-				u64 u = cast(u64)v.value_pointer;
-				irValue *x = ir_const_uintptr(u);
-				x = ir_emit_conv(proc, x, t_rawptr);
-				value = ir_emit_conv(proc, x, proc_expr->tav.type);
-				break;
-			}
-		}
-	}
-
-	Entity *proc_entity = entity_of_node(proc_expr);
-	if (proc_entity != nullptr) {
-		if (proc_entity->flags & EntityFlag_Disabled) {
-			return nullptr;
-		}
-	}
-
-	if (value == nullptr) {
-		value = ir_build_expr(proc, proc_expr);
-	}
-
-	GB_ASSERT(value != nullptr);
-	Type *proc_type_ = base_type(ir_type(value));
-	GB_ASSERT(proc_type_->kind == Type_Proc);
-	TypeProc *pt = &proc_type_->Proc;
-	set_procedure_abi_types(proc_type_);
-
-	if (is_call_expr_field_value(ce)) {
-		auto args = array_make<irValue *>(ir_allocator(), pt->param_count);
-
-		for_array(arg_index, ce->args) {
-			Ast *arg = ce->args[arg_index];
-			ast_node(fv, FieldValue, arg);
-			GB_ASSERT(fv->field->kind == Ast_Ident);
-			String name = fv->field->Ident.token.string;
-			isize index = lookup_procedure_parameter(pt, name);
-			GB_ASSERT(index >= 0);
-			TypeAndValue tav = type_and_value_of_expr(fv->value);
-			if (tav.mode == Addressing_Type) {
-				args[index] = ir_value_nil(tav.type);
-			} else {
-				args[index] = ir_build_expr(proc, fv->value);
-			}
-		}
-		TypeTuple *params = &pt->params->Tuple;
-		for (isize i = 0; i < args.count; i++) {
-			Entity *e = params->variables[i];
-			if (e->kind == Entity_TypeName) {
-				args[i] = ir_value_nil(e->type);
-			} else if (e->kind == Entity_Constant) {
-				continue;
-			} else {
-				GB_ASSERT(e->kind == Entity_Variable);
-				if (args[i] == nullptr) {
-					args[i] = ir_handle_param_value(proc, e->type, e->Variable.param_value, ast_token(expr).pos);
-				} else {
-					args[i] = ir_emit_conv(proc, args[i], e->type);
-				}
-			}
-		}
-
-		return ir_emit_call(proc, value, args, ce->inlining, proc->return_ptr_hint_ast == expr);
-	}
-
-	isize arg_index = 0;
-
-	isize arg_count = 0;
-	for_array(i, ce->args) {
-		Ast *arg = ce->args[i];
-		TypeAndValue tav = type_and_value_of_expr(arg);
-		GB_ASSERT_MSG(tav.mode != Addressing_Invalid, "%s %s", expr_to_string(arg), expr_to_string(expr));
-		GB_ASSERT_MSG(tav.mode != Addressing_ProcGroup, "%s", expr_to_string(arg));
-		Type *at = tav.type;
-		if (at->kind == Type_Tuple) {
-			arg_count += at->Tuple.variables.count;
-		} else {
-			arg_count++;
-		}
-	}
-
-	isize param_count = 0;
-	if (pt->params) {
-		GB_ASSERT(pt->params->kind == Type_Tuple);
-		param_count = pt->params->Tuple.variables.count;
-	}
-
-	auto args = array_make<irValue *>(ir_allocator(), cast(isize)gb_max(param_count, arg_count));
-	isize variadic_index = pt->variadic_index;
-	bool variadic = pt->variadic && variadic_index >= 0;
-	bool vari_expand = ce->ellipsis.pos.line != 0;
-	bool is_c_vararg = pt->c_vararg;
-
-	TypeTuple *param_tuple = nullptr;
-	if (pt->params) {
-		GB_ASSERT(pt->params->kind == Type_Tuple);
-		param_tuple = &pt->params->Tuple;
-	}
-
-	for_array(i, ce->args) {
-		Ast *arg = ce->args[i];
-		TypeAndValue arg_tv = type_and_value_of_expr(arg);
-		if (arg_tv.mode == Addressing_Type) {
-			args[arg_index++] = ir_value_nil(arg_tv.type);
-		} else {
-			irValue *a = ir_build_expr(proc, arg);
-			Type *at = ir_type(a);
-			if (at->kind == Type_Tuple) {
-				for_array(i, at->Tuple.variables) {
-					Entity *e = at->Tuple.variables[i];
-					irValue *v = ir_emit_struct_ev(proc, a, cast(i32)i);
-					args[arg_index++] = v;
-				}
-			} else {
-				args[arg_index++] = a;
-			}
-		}
-	}
-
-
-	if (param_count > 0) {
-		GB_ASSERT_MSG(pt->params != nullptr, "%s %td", expr_to_string(expr), pt->param_count);
-		GB_ASSERT(param_count < 1000000);
-
-		if (arg_count < param_count) {
-			isize end = cast(isize)param_count;
-			if (variadic) {
-				end = variadic_index;
-			}
-			while (arg_index < end) {
-				Entity *e = param_tuple->variables[arg_index];
-				GB_ASSERT(e->kind == Entity_Variable);
-				args[arg_index++] = ir_handle_param_value(proc, e->type, e->Variable.param_value, ast_token(expr).pos);
-			}
-		}
-
-		if (is_c_vararg) {
-			GB_ASSERT(variadic);
-			GB_ASSERT(!vari_expand);
-			isize i = 0;
-			for (; i < variadic_index; i++) {
-				Entity *e = param_tuple->variables[i];
-				if (e->kind == Entity_Variable) {
-					args[i] = ir_emit_conv(proc, args[i], e->type);
-				}
-			}
-			Type *variadic_type = param_tuple->variables[i]->type;
-			GB_ASSERT(is_type_slice(variadic_type));
-			variadic_type = base_type(variadic_type)->Slice.elem;
-			if (!is_type_any(variadic_type)) {
-				for (; i < arg_count; i++) {
-					args[i] = ir_emit_conv(proc, args[i], variadic_type);
-				}
-			} else {
-				for (; i < arg_count; i++) {
-					args[i] = ir_emit_conv(proc, args[i], default_type(ir_type(args[i])));
-				}
-			}
-		} else if (variadic) {
-			isize i = 0;
-			for (; i < variadic_index; i++) {
-				Entity *e = param_tuple->variables[i];
-				if (e->kind == Entity_Variable) {
-					args[i] = ir_emit_conv(proc, args[i], e->type);
-				}
-			}
-			if (!vari_expand) {
-				Type *variadic_type = param_tuple->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] = ir_emit_conv(proc, args[i], variadic_type);
-				}
-			}
-		} else {
-			for (isize i = 0; i < param_count; i++) {
-				Entity *e = param_tuple->variables[i];
-				if (e->kind == Entity_Variable) {
-					GB_ASSERT(args[i] != nullptr);
-					args[i] = ir_emit_conv(proc, args[i], e->type);
-				}
-			}
-		}
-
-		if (variadic && !vari_expand && !is_c_vararg) {
-			ir_emit_comment(proc, str_lit("variadic call argument generation"));
-			gbAllocator allocator = ir_allocator();
-			Type *slice_type = param_tuple->variables[variadic_index]->type;
-			Type *elem_type  = base_type(slice_type)->Slice.elem;
-			irValue *slice = ir_add_local_generated(proc, slice_type, true);
-			isize slice_len = arg_count+1 - (variadic_index+1);
-
-			if (slice_len > 0) {
-				irValue *base_array = ir_add_local_generated(proc, alloc_type_array(elem_type, slice_len), true);
-
-				for (isize i = variadic_index, j = 0; i < arg_count; i++, j++) {
-					irValue *addr = ir_emit_array_epi(proc, base_array, cast(i32)j);
-					ir_emit_store(proc, addr, args[i]);
-				}
-
-				irValue *base_elem = ir_emit_array_epi(proc, base_array, 0);
-				irValue *len = ir_const_int(slice_len);
-				ir_fill_slice(proc, slice, base_elem, len);
-			}
-
-			arg_count = param_count;
-			args[variadic_index] = ir_emit_load(proc, slice);
-		}
-	}
-
-	if (variadic && variadic_index+1 < param_count) {
-		for (isize i = variadic_index+1; i < param_count; i++) {
-			Entity *e = param_tuple->variables[i];
-			args[i] = ir_handle_param_value(proc, e->type, e->Variable.param_value, ast_token(expr).pos);
-		}
-	}
-
-	isize final_count = param_count;
-	if (is_c_vararg) {
-		final_count = arg_count;
-	}
-
-	auto call_args = array_slice(args, 0, final_count);
-	return ir_emit_call(proc, value, call_args, ce->inlining, proc->return_ptr_hint_ast == expr);
-}
-
-
-irValue *ir_build_expr_internal(irProcedure *proc, Ast *expr) {
-	Ast *original_expr = expr;
-	expr = unparen_expr(expr);
-
-	TokenPos expr_pos = ast_token(expr).pos;
-
-	TypeAndValue tv = type_and_value_of_expr(expr);
-	GB_ASSERT_MSG(tv.mode != Addressing_Invalid, "invalid expression '%s' @ %s", expr_to_string(expr), token_pos_to_string(expr_pos));
-	if (tv.mode == Addressing_Type) {
-		// HACK TODO(bill): This is hack but it should be safe in virtually all cases
-		irValue *v = ir_typeid(proc->module, tv.type);
-		return ir_emit_conv(proc, v, t_typeid);
-	}
-
-	if (tv.value.kind != ExactValue_Invalid) {
-		// NOTE(bill): Edge case
-		if (is_type_u8_array(tv.type) && tv.value.kind == ExactValue_String) {
-			return ir_add_module_constant(proc->module, tv.type, tv.value);
-		} else if (is_type_rune_array(tv.type) && tv.value.kind == ExactValue_String) {
-			return ir_add_module_constant(proc->module, tv.type, tv.value);
-		} else if (tv.value.kind != ExactValue_Compound &&
-		    is_type_array(tv.type)) {
-			Type *elem = core_array_type(tv.type);
-			ExactValue value = convert_exact_value_for_type(tv.value, elem);
-			irValue *x = ir_add_module_constant(proc->module, elem, value);
-			return ir_emit_conv(proc, x, tv.type);
-		}
-
-		if (tv.value.kind == ExactValue_Typeid) {
-			irValue *v = ir_typeid(proc->module, tv.value.value_typeid);
-			return ir_emit_conv(proc, v, tv.type);
-		}
-
-		if (tv.value.kind == ExactValue_Procedure) {
-			Ast *expr = tv.value.value_procedure;
-			if (expr->kind == Ast_ProcLit) {
-				return ir_gen_anonymous_proc_lit(proc->module, str_lit("_proclit"), expr);
-			}
-			Entity *e = entity_from_expr(expr);
-			e = strip_entity_wrapping(e);
-			GB_ASSERT(e != nullptr);
-			if (e->kind == Entity_Procedure && e->Procedure.is_foreign) {
-				// NOTE(bill): There can be duplicates of the foreign procedure; get the main one
-				String link_name = e->token.string;
-				if (e->Procedure.link_name.len != 0) {
-					link_name = e->Procedure.link_name;
-				}
-				auto *found = string_map_get(&proc->module->members, link_name);
-				if (found) {
-					return *found;
-				}
-			}
-
-			auto *found = map_get(&proc->module->values, hash_entity(e));
-			if (found) {
-				auto v = *found;
-				// NOTE(bill): This is because pointers are already pointers in LLVM
-				if (is_type_proc(ir_type(v))) {
-					return v;
-				}
-				return ir_emit_load(proc, v);
-			} else if (e != nullptr && e->kind == Entity_Variable) {
-				return ir_addr_load(proc, ir_build_addr(proc, expr));
-			}
-
-			GB_PANIC("Error in: %s %s\n", LIT(proc->name), token_pos_to_string(e->token.pos));
-		}
-
-		return ir_add_module_constant(proc->module, tv.type, tv.value);
-	}
-
-	if (tv.mode == Addressing_Variable) {
-		return ir_addr_load(proc, ir_build_addr(proc, expr));
-	}
-
-	if (tv.mode == Addressing_Constant) {
-		GB_ASSERT(tv.value.kind == ExactValue_Invalid);
-		// NOTE(bill): Zero value constant
-		return ir_add_module_constant(proc->module, tv.type, tv.value);
-	}
-
-
-	switch (expr->kind) {
-	case_ast_node(bl, BasicLit, expr);
-		TokenPos pos = bl->token.pos;
-		GB_PANIC("Non-constant basic literal %s - %.*s", token_pos_to_string(pos), LIT(token_strings[bl->token.kind]));
-	case_end;
-
-	case_ast_node(bd, BasicDirective, expr);
-		TokenPos pos = bd->token.pos;
-		GB_PANIC("Non-constant basic literal %s - %.*s", token_pos_to_string(pos), LIT(bd->name));
-	case_end;
-
-	case_ast_node(i, Implicit, expr);
-		return ir_addr_load(proc, ir_build_addr(proc, expr));
-	case_end;
-
-	case_ast_node(u, Undef, expr);
-		return ir_value_undef(tv.type);
-	case_end;
-
-	case_ast_node(i, Ident, expr);
-		Entity *e = entity_of_node(expr);
-		e = strip_entity_wrapping(e);
-
-		GB_ASSERT_MSG(e != nullptr, "%s", expr_to_string(expr));
-		if (e->kind == Entity_Builtin) {
-			Token token = ast_token(expr);
-			GB_PANIC("TODO(bill): ir_build_expr Entity_Builtin '%.*s'\n"
-			         "\t at %s", LIT(builtin_procs[e->Builtin.id].name),
-			         token_pos_to_string(token.pos));
-			return nullptr;
-		} else if (e->kind == Entity_Nil) {
-			return ir_value_nil(tv.type);
-		}
-
-		irValue **found = map_get(&proc->module->values, hash_entity(e));
-		if (found) {
-			irValue *v = *found;
-			if (v->kind == irValue_Proc) {
-				return v;
-			}
-			// if (e->kind == Entity_Variable && e->Variable.param) {
-				// return v;
-			// }
-			return ir_emit_load(proc, v);
-		} else if (e != nullptr && e->kind == Entity_Variable) {
-			return ir_addr_load(proc, ir_build_addr(proc, expr));
-		}
-		GB_PANIC("nullptr value for expression from identifier: %.*s : %s @ %p", LIT(i->token.string), type_to_string(e->type), expr);
-		return nullptr;
-	case_end;
-
-	case_ast_node(de, DerefExpr, expr);
-		return ir_addr_load(proc, ir_build_addr(proc, expr));
-	case_end;
-
-	case_ast_node(se, SelectorExpr, expr);
-		TypeAndValue tav = type_and_value_of_expr(expr);
-		GB_ASSERT(tav.mode != Addressing_Invalid);
-		return ir_addr_load(proc, ir_build_addr(proc, expr));
-	case_end;
-
-	case_ast_node(ise, ImplicitSelectorExpr, expr);
-		TypeAndValue tav = type_and_value_of_expr(expr);
-		GB_ASSERT(tav.mode == Addressing_Constant);
-
-		return ir_add_module_constant(proc->module, tv.type, tv.value);
-	case_end;
-
-	case_ast_node(se, SelectorCallExpr, expr);
-		GB_ASSERT(se->modified_call);
-		TypeAndValue tav = type_and_value_of_expr(expr);
-		GB_ASSERT(tav.mode != Addressing_Invalid);
-		return ir_build_expr(proc, se->call);
-	case_end;
-
-	case_ast_node(te, TernaryExpr, expr);
-		ir_emit_comment(proc, str_lit("TernaryExpr"));
-
-		auto edges = array_make<irValue *>(ir_allocator(), 0, 2);
-
-		GB_ASSERT(te->y != nullptr);
-		irBlock *then  = ir_new_block(proc, nullptr, "if.then");
-		irBlock *done  = ir_new_block(proc, nullptr, "if.done"); // NOTE(bill): Append later
-		irBlock *else_ = ir_new_block(proc, nullptr, "if.else");
-
-		irValue *cond = ir_build_cond(proc, te->cond, then, else_);
-		ir_start_block(proc, then);
-
-		Type *type = default_type(type_of_expr(expr));
-
-		ir_open_scope(proc);
-		array_add(&edges, ir_emit_conv(proc, ir_build_expr(proc, te->x), type));
-		ir_close_scope(proc, irDeferExit_Default, nullptr);
-
-		ir_emit_jump(proc, done);
-		ir_start_block(proc, else_);
-
-		ir_open_scope(proc);
-		array_add(&edges, ir_emit_conv(proc, ir_build_expr(proc, te->y), type));
-		ir_close_scope(proc, irDeferExit_Default, nullptr);
-
-		ir_emit_jump(proc, done);
-		ir_start_block(proc, done);
-
-		return ir_emit(proc, ir_instr_phi(proc, edges, type));
-	case_end;
-
-	case_ast_node(te, TernaryIfExpr, expr);
-		ir_emit_comment(proc, str_lit("TernaryIfExpr"));
-
-		auto edges = array_make<irValue *>(ir_allocator(), 0, 2);
-
-		GB_ASSERT(te->y != nullptr);
-		irBlock *then  = ir_new_block(proc, nullptr, "if.then");
-		irBlock *done  = ir_new_block(proc, nullptr, "if.done"); // NOTE(bill): Append later
-		irBlock *else_ = ir_new_block(proc, nullptr, "if.else");
-
-		irValue *cond = ir_build_cond(proc, te->cond, then, else_);
-		ir_start_block(proc, then);
-
-		Type *type = default_type(type_of_expr(expr));
-
-		ir_open_scope(proc);
-		array_add(&edges, ir_emit_conv(proc, ir_build_expr(proc, te->x), type));
-		ir_close_scope(proc, irDeferExit_Default, nullptr);
-
-		ir_emit_jump(proc, done);
-		ir_start_block(proc, else_);
-
-		ir_open_scope(proc);
-		array_add(&edges, ir_emit_conv(proc, ir_build_expr(proc, te->y), type));
-		ir_close_scope(proc, irDeferExit_Default, nullptr);
-
-		ir_emit_jump(proc, done);
-		ir_start_block(proc, done);
-
-		return ir_emit(proc, ir_instr_phi(proc, edges, type));
-	case_end;
-
-	case_ast_node(te, TernaryWhenExpr, expr);
-		TypeAndValue tav = type_and_value_of_expr(te->cond);
-		GB_ASSERT(tav.mode == Addressing_Constant);
-		GB_ASSERT(tav.value.kind == ExactValue_Bool);
-		if (tav.value.value_bool) {
-			return ir_build_expr(proc, te->x);
-		} else {
-			return ir_build_expr(proc, te->y);
-		}
-	case_end;
-
-	case_ast_node(ta, TypeAssertion, expr);
-		TokenPos pos = ast_token(expr).pos;
-		Type *type = tv.type;
-		irValue *e = ir_build_expr(proc, ta->expr);
-		Type *t = type_deref(ir_type(e));
-		if (is_type_union(t)) {
-			ir_emit_comment(proc, str_lit("cast - union_cast"));
-			return ir_emit_union_cast(proc, e, type, pos);
-		} else if (is_type_any(t)) {
-			ir_emit_comment(proc, str_lit("cast - any_cast"));
-			return ir_emit_any_cast(proc, e, type, pos);
-		} else {
-			GB_PANIC("TODO(bill): type assertion %s", type_to_string(ir_type(e)));
-		}
-	case_end;
-
-	case_ast_node(tc, TypeCast, expr);
-		irValue *e = ir_build_expr(proc, tc->expr);
-		switch (tc->token.kind) {
-		case Token_cast:
-			return ir_emit_conv(proc, e, tv.type);
-		case Token_transmute:
-			return ir_emit_transmute(proc, e, tv.type);
-		}
-		GB_PANIC("Invalid AST TypeCast");
-	case_end;
-
-	case_ast_node(ac, AutoCast, expr);
-		irValue *value = ir_build_expr(proc, ac->expr);
-		return ir_emit_conv(proc, value, tv.type);
-	case_end;
-
-	case_ast_node(ue, UnaryExpr, expr);
-		switch (ue->op.kind) {
-		case Token_And: {
-			Ast *ue_expr = unparen_expr(ue->expr);
-			if (ue_expr->kind == Ast_CompoundLit) {
-				irValue *v = ir_build_expr(proc, ue->expr);
-
-				Type *type = ir_type(v);
-				irValue *ptr = nullptr;
-				if (proc->is_startup) {
-					ptr = ir_add_global_generated(proc->module, type, v);
-				} else {
-					ptr = ir_add_local_generated(proc, type, false);
-				}
-				ir_emit_store(proc, ptr, v);
-				return ptr;
-
-			} else if (ue_expr->kind == Ast_TypeAssertion) {
-				gbAllocator a = ir_allocator();
-				GB_ASSERT(is_type_pointer(tv.type));
-
-				ast_node(ta, TypeAssertion, ue_expr);
-				TokenPos pos = ast_token(expr).pos;
-				Type *type = type_of_expr(ue_expr);
-				GB_ASSERT(!is_type_tuple(type));
-
-				irValue *e = ir_build_expr(proc, ta->expr);
-				Type *t = type_deref(ir_type(e));
-				if (is_type_union(t)) {
-					irValue *v = e;
-					if (!is_type_pointer(ir_type(v))) {
-						v = ir_address_from_load_or_generate_local(proc, v);
-					}
-					Type *src_type = type_deref(ir_type(v));
-					Type *dst_type = type;
-
-					irValue *src_tag = ir_emit_load(proc, ir_emit_union_tag_ptr(proc, v));
-					irValue *dst_tag = ir_const_union_tag(src_type, dst_type);
-
-					irValue *ok = ir_emit_comp(proc, Token_CmpEq, src_tag, dst_tag);
-					auto args = array_make<irValue *>(ir_allocator(), 6);
-					args[0] = ok;
-
-					args[1] = ir_find_or_add_entity_string(proc->module, get_file_path_string(pos.file_id));
-					args[2] = ir_const_i32(pos.line);
-					args[3] = ir_const_i32(pos.column);
-
-					args[4] = ir_typeid(proc->module, src_type);
-					args[5] = ir_typeid(proc->module, dst_type);
-					ir_emit_runtime_call(proc, "type_assertion_check", args);
-
-					irValue *data_ptr = v;
-					return ir_emit_conv(proc, data_ptr, tv.type);
-				} else if (is_type_any(t)) {
-					irValue *v = e;
-					if (is_type_pointer(ir_type(v))) {
-						v = ir_emit_load(proc, v);
-					}
-
-					irValue *data_ptr = ir_emit_struct_ev(proc, v, 0);
-					irValue *any_id = ir_emit_struct_ev(proc, v, 1);
-					irValue *id = ir_typeid(proc->module, type);
-
-
-					irValue *ok = ir_emit_comp(proc, Token_CmpEq, any_id, id);
-					auto args = array_make<irValue *>(ir_allocator(), 6);
-					args[0] = ok;
-
-					args[1] = ir_find_or_add_entity_string(proc->module, get_file_path_string(pos.file_id));
-					args[2] = ir_const_i32(pos.line);
-					args[3] = ir_const_i32(pos.column);
-
-					args[4] = any_id;
-					args[5] = id;
-					ir_emit_runtime_call(proc, "type_assertion_check", args);
-
-					return ir_emit_conv(proc, data_ptr, tv.type);
-				} else {
-					GB_PANIC("TODO(bill): type assertion %s", type_to_string(type));
-				}
-			} else if (ue_expr->kind == Ast_IndexExpr) {
-			#if 0
-				ast_node(ie, IndexExpr, ue_expr);
-				if (is_type_slice(ie->expr->tav.type)) {
-					auto tav = ie->index->tav;
-					if (tav.mode == Addressing_Constant) {
-						if (exact_value_to_i64(tav.value) == 0) {
-							irValue *s = ir_build_expr(proc, ie->expr);
-							if (is_type_pointer(ir_type(s))) {
-								s = ir_emit_load(proc, s);
-							}
-							return ir_slice_elem(proc, s);
-						}
-					}
-				}
-			#endif
-			}
-
-			bool allow_reference = true;
-			irAddr addr = ir_build_addr(proc, ue->expr);
-			return ir_addr_get_ptr(proc, addr, allow_reference);
-		}
-		default:
-			return ir_emit_unary_arith(proc, ue->op.kind, ir_build_expr(proc, ue->expr), tv.type);
-		}
-	case_end;
-
-	case_ast_node(be, BinaryExpr, expr);
-		switch (be->op.kind) {
-		case Token_Add:
-		case Token_Sub:
-		case Token_Mul:
-		case Token_Quo:
-		case Token_Mod:
-		case Token_ModMod:
-		case Token_And:
-		case Token_Or:
-		case Token_Xor:
-		case Token_AndNot:
-		case Token_Shl:
-		case Token_Shr: {
-			irValue *left = ir_build_expr(proc, be->left);
-			Type *type = default_type(tv.type);
-			irValue *right = ir_build_expr(proc, be->right);
-			return ir_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: {
-			irValue *left = ir_build_expr(proc, be->left);
-			Type *type = default_type(tv.type);
-			irValue *right = ir_build_expr(proc, be->right);
-			irValue *cmp = ir_emit_comp(proc, be->op.kind, left, right);
-			return ir_emit_conv(proc, cmp, type);
-		}
-
-		case Token_CmpAnd:
-		case Token_CmpOr:
-			return ir_emit_logical_binary_expr(proc, expr);
-
-
-		case Token_in:
-		case Token_not_in: {
-			irValue *left = ir_build_expr(proc, be->left);
-			Type *type = default_type(tv.type);
-			irValue *right = ir_build_expr(proc, be->right);
-			Type *rt = base_type(ir_type(right));
-			switch (rt->kind) {
-			case Type_Map:
-				{
-					if (be->op.kind == Token_in) {
-						ir_emit_comment(proc, str_lit("map in"));
-					} else {
-						ir_emit_comment(proc, str_lit("map not_in"));
-					}
-
-					irValue *addr = ir_address_from_load_or_generate_local(proc, right);
-					irValue *h = ir_gen_map_header(proc, addr, rt);
-					irValue *key = ir_gen_map_hash(proc, left, rt->Map.key);
-
-					auto args = array_make<irValue *>(ir_allocator(), 2);
-					args[0] = h;
-					args[1] = key;
-
-					irValue *ptr = ir_emit_runtime_call(proc, "__dynamic_map_get", args);
-					if (be->op.kind == Token_in) {
-						return ir_emit_conv(proc, ir_emit_comp(proc, Token_NotEq, ptr, v_raw_nil), t_bool);
-					} else {
-						return ir_emit_conv(proc, ir_emit_comp(proc, Token_CmpEq, ptr, v_raw_nil), t_bool);
-					}
-				}
-				break;
-			case Type_BitSet:
-				{
-					if (be->op.kind == Token_in) {
-						ir_emit_comment(proc, str_lit("bit_set in"));
-					} else {
-						ir_emit_comment(proc, str_lit("bit_set not_in"));
-					}
-
-					Type *key_type = rt->BitSet.elem;
-					GB_ASSERT(are_types_identical(ir_type(left), key_type));
-
-					Type *it = bit_set_to_int(rt);
-					left = ir_emit_conv(proc, left, it);
-
-					irValue *lower = ir_value_constant(it, exact_value_i64(rt->BitSet.lower));
-					irValue *key = ir_emit_arith(proc, Token_Sub, left, lower, it);
-					irValue *bit = ir_emit_arith(proc, Token_Shl, v_one, key, it);
-					bit = ir_emit_conv(proc, bit, it);
-
-					irValue *old_value = ir_emit_bitcast(proc, right, it);
-					irValue *new_value = ir_emit_arith(proc, Token_And, old_value, bit, it);
-
-					if (be->op.kind == Token_in) {
-						return ir_emit_conv(proc, ir_emit_comp(proc, Token_NotEq, new_value, v_zero), t_bool);
-					} else {
-						return ir_emit_conv(proc, ir_emit_comp(proc, Token_CmpEq, new_value, v_zero), t_bool);
-					}
-				}
-				break;
-			default:
-				GB_PANIC("Invalid 'in' type");
-			}
-			break;
-
-		}
-
-		default:
-			GB_PANIC("Invalid binary expression");
-			break;
-		}
-	case_end;
-
-	case_ast_node(pl, ProcLit, expr);
-		return ir_gen_anonymous_proc_lit(proc->module, proc->name, expr, proc);
-	case_end;
-
-
-	case_ast_node(cl, CompoundLit, expr);
-		return ir_addr_load(proc, ir_build_addr(proc, expr));
-	case_end;
-
-
-	case_ast_node(ce, CallExpr, expr);
-		irValue *res = ir_build_call_expr(proc, expr);
-		if (ce->optional_ok_one) { // TODO(bill): Minor hack for #optional_ok procedures
-			GB_ASSERT(is_type_tuple(ir_type(res)));
-			GB_ASSERT(ir_type(res)->Tuple.variables.count == 2);
-			return ir_emit_struct_ev(proc, res, 0);
-		}
-		return res;
-	case_end;
-
-	case_ast_node(se, SliceExpr, expr);
-		return ir_addr_load(proc, ir_build_addr(proc, expr));
-	case_end;
-
-	case_ast_node(ie, IndexExpr, expr);
-		return ir_addr_load(proc, ir_build_addr(proc, expr));
-	case_end;
-	}
-
-	GB_PANIC("Unexpected expression: %.*s", LIT(ast_strings[expr->kind]));
-	return nullptr;
-}
-
-irValue *ir_get_using_variable(irProcedure *proc, Entity *e) {
-	GB_ASSERT(e->kind == Entity_Variable && e->flags & EntityFlag_Using);
-	String name = e->token.string;
-	Entity *parent = e->using_parent;
-	Selection sel = lookup_field(parent->type, name, false);
-	GB_ASSERT(sel.entity != nullptr);
-	irValue **pv = map_get(&proc->module->values, hash_entity(parent));
-	irValue *v = nullptr;
-	if (pv != nullptr) {
-		v = *pv;
-	} else {
-		GB_ASSERT_MSG(e->using_expr != nullptr, "%.*s", LIT(name));
-		v = ir_build_addr_ptr(proc, e->using_expr);
-	}
-	GB_ASSERT(v != nullptr);
-	GB_ASSERT(parent->type == type_deref(ir_type(v)));
-	return ir_emit_deep_field_gep(proc, v, sel);
-}
-
-bool ir_is_elem_const(irModule *m, Ast *elem, Type *elem_type) {
-	if (!elem_type_can_be_constant(elem_type)) {
-		return false;
-	}
-	if (elem->kind == Ast_FieldValue) {
-		elem = elem->FieldValue.value;
-	}
-	TypeAndValue tav = type_and_value_of_expr(elem);
-	GB_ASSERT_MSG(tav.mode != Addressing_Invalid, "%s %s", expr_to_string(elem), type_to_string(tav.type));
-	return tav.value.kind != ExactValue_Invalid && tav.value.kind != ExactValue_Procedure;
-}
-
-irAddr ir_build_addr_from_entity(irProcedure *proc, Entity *e, Ast *expr) {
-	GB_ASSERT(e != nullptr);
-	if (e->kind == Entity_Constant) {
-		Type *t = default_type(type_of_expr(expr));
-		irValue *v = ir_add_module_constant(proc->module, t, e->Constant.value);
-		irValue *g = ir_add_global_generated(proc->module, ir_type(v), v);
-		return ir_addr(g);
-	}
-
-
-	irValue *v = nullptr;
-	irValue **found = map_get(&proc->module->values, hash_entity(e));
-	if (found) {
-		v = *found;
-	} else if (e->kind == Entity_Variable && e->flags & EntityFlag_Using) {
-		// NOTE(bill): Calculate the using variable every time
-		v = ir_get_using_variable(proc, e);
-	}
-
-	if (v == nullptr) {
-		error(expr, "%.*s Unknown value: %.*s, entity: %p %.*s",
-		      LIT(proc->name),
-		      LIT(e->token.string), e, LIT(entity_strings[e->kind]));
-		GB_PANIC("Unknown value");
-	}
-
-	return ir_addr(v);
-}
-
-
-struct irCompoundLitElemTempData {
-	Ast *expr;
-	irValue *value;
-	i32 elem_index;
-	irValue *gep;
-};
-
-irAddr ir_build_addr(irProcedure *proc, Ast *expr) {
-	switch (expr->kind) {
-	case_ast_node(i, Implicit, expr);
-		irValue *v = nullptr;
-		switch (i->kind) {
-		case Token_context:
-			v = ir_find_or_generate_context_ptr(proc);
-			break;
-		}
-
-		GB_ASSERT(v != nullptr);
-		return ir_addr_context(v);
-	case_end;
-
-	case_ast_node(i, Ident, expr);
-		if (is_blank_ident(expr)) {
-			irAddr val = {};
-			return val;
-		}
-		String name = i->token.string;
-		Entity *e = entity_of_node(expr);
-		// GB_ASSERT(name == e->token.string);
-		return ir_build_addr_from_entity(proc, e, expr);
-	case_end;
-
-	case_ast_node(pe, ParenExpr, expr);
-		return ir_build_addr(proc, unparen_expr(expr));
-	case_end;
-
-	case_ast_node(se, SelectorExpr, expr);
-		ir_emit_comment(proc, str_lit("SelectorExpr"));
-		Ast *sel = unparen_expr(se->selector);
-		if (sel->kind == Ast_Ident) {
-			String selector = sel->Ident.token.string;
-			TypeAndValue tav = type_and_value_of_expr(se->expr);
-
-			if (tav.mode == Addressing_Invalid) {
-				// NOTE(bill): Imports
-				Entity *imp = entity_of_node(se->expr);
-				if (imp != nullptr) {
-					GB_ASSERT(imp->kind == Entity_ImportName);
-				}
-				return ir_build_addr(proc, unparen_expr(se->selector));
-			}
-
-
-			Type *type = base_type(tav.type);
-			if (tav.mode == Addressing_Type) { // Addressing_Type
-				Selection sel = lookup_field(type, selector, true);
-				Entity *e = sel.entity;
-				GB_ASSERT(e->kind == Entity_Variable);
-				GB_ASSERT(e->flags & EntityFlag_TypeField);
-				String name = e->token.string;
-				if (name == "names") {
-					irValue *ti_ptr = ir_type_info(proc, type);
-					irValue *variant = ir_emit_struct_ep(proc, ti_ptr, 2);
-
-					irValue *names_ptr = nullptr;
-
-					if (is_type_enum(type)) {
-						irValue *enum_info = ir_emit_conv(proc, variant, t_type_info_enum_ptr);
-						names_ptr = ir_emit_struct_ep(proc, enum_info, 1);
-					} else if (type->kind == Type_Struct) {
-						irValue *struct_info = ir_emit_conv(proc, variant, t_type_info_struct_ptr);
-						names_ptr = ir_emit_struct_ep(proc, struct_info, 1);
-					}
-					return ir_addr(names_ptr);
-				} else {
-					GB_PANIC("Unhandled TypeField %.*s", LIT(name));
-				}
-				GB_PANIC("Unreachable");
-			}
-
-			Selection sel = lookup_field(type, selector, false);
-			GB_ASSERT(sel.entity != nullptr);
-
-
-			{
-				irAddr addr = ir_build_addr(proc, se->expr);
-				if (addr.kind == irAddr_Context) {
-					GB_ASSERT(sel.index.count > 0);
-					if (addr.ctx.sel.index.count >= 0) {
-						sel = selection_combine(addr.ctx.sel, sel);
-					}
-					addr.ctx.sel = sel;
-
-					return addr;
-				} else if (addr.kind == irAddr_SoaVariable) {
-					irValue *index = addr.soa.index;
-					i32 first_index = sel.index[0];
-					Selection sub_sel = sel;
-					sub_sel.index.data += 1;
-					sub_sel.index.count -= 1;
-
-					irValue *arr = ir_emit_struct_ep(proc, addr.addr, first_index);
-
-					Type *t = base_type(type_deref(ir_type(addr.addr)));
-					GB_ASSERT(is_type_soa_struct(t));
-
-					if (addr.soa.index->kind != irValue_Constant || t->Struct.soa_kind != StructSoa_Fixed) {
-						irValue *len = ir_soa_struct_len(proc, addr.addr);
-						ir_emit_bounds_check(proc, ast_token(addr.soa.index_expr), addr.soa.index, len);
-					}
-
-					irValue *item = nullptr;
-
-					if (t->Struct.soa_kind == StructSoa_Fixed) {
-						item = ir_emit_array_ep(proc, arr, index);
-					} else {
-						item = ir_emit_load(proc, ir_emit_ptr_offset(proc, arr, index));
-					}
-					if (sub_sel.index.count > 0) {
-						item = ir_emit_deep_field_gep(proc, item, sub_sel);
-					}
-					return ir_addr(item);
-				}
-				irValue *a = ir_addr_get_ptr(proc, addr);
-				a = ir_emit_deep_field_gep(proc, a, sel);
-				return ir_addr(a);
-			}
-		} else {
-			GB_PANIC("Unsupported selector expression");
-		}
-	case_end;
-
-	case_ast_node(se, SelectorCallExpr, expr);
-		GB_ASSERT(se->modified_call);
-		TypeAndValue tav = type_and_value_of_expr(expr);
-		GB_ASSERT(tav.mode != Addressing_Invalid);
-		return ir_build_addr(proc, se->call);
-	case_end;
-
-	case_ast_node(ta, TypeAssertion, expr);
-		gbAllocator a = ir_allocator();
-		TokenPos pos = ast_token(expr).pos;
-		irValue *e = ir_build_expr(proc, ta->expr);
-		Type *t = type_deref(ir_type(e));
-		if (is_type_union(t)) {
-			Type *type = type_of_expr(expr);
-			irValue *v = ir_add_local_generated(proc, type, false);
-			ir_emit_comment(proc, str_lit("cast - union_cast"));
-			ir_emit_store(proc, v, ir_emit_union_cast(proc, ir_build_expr(proc, ta->expr), type, pos));
-			return ir_addr(v);
-		} else if (is_type_any(t)) {
-			ir_emit_comment(proc, str_lit("cast - any_cast"));
-			Type *type = type_of_expr(expr);
-			return ir_emit_any_cast_addr(proc, ir_build_expr(proc, ta->expr), type, pos);
-		} else {
-			GB_PANIC("TODO(bill): type assertion %s", type_to_string(ir_type(e)));
-		}
-	case_end;
-
-	case_ast_node(ue, UnaryExpr, expr);
-		switch (ue->op.kind) {
-		case Token_And: {
-			return ir_build_addr(proc, ue->expr);
-		}
-		default:
-			GB_PANIC("Invalid unary expression for ir_build_addr");
-		}
-	case_end;
-
-	case_ast_node(be, BinaryExpr, expr);
-		irValue *v = ir_build_expr(proc, expr);
-		Type *t = ir_type(v);
-		if (is_type_pointer(t)) {
-			return ir_addr(v);
-		}
-		return ir_addr(ir_address_from_load_or_generate_local(proc, v));
-	case_end;
-
-	case_ast_node(ie, IndexExpr, expr);
-		ir_emit_comment(proc, str_lit("IndexExpr"));
-		Type *t = base_type(type_of_expr(ie->expr));
-		gbAllocator a = ir_allocator();
-
-		bool deref = is_type_pointer(t);
-		t = base_type(type_deref(t));
-		if (is_type_soa_struct(t)) {
-			// SOA STRUCTURES!!!!
-			irValue *val = ir_build_addr_ptr(proc, ie->expr);
-			if (deref) {
-				val = ir_emit_load(proc, val);
-			}
-
-			irValue *index = ir_build_expr(proc, ie->index);
-			return ir_addr_soa_variable(val, index, ie->index);
-		}
-
-		if (ie->expr->tav.mode == Addressing_SoaVariable) {
-			// SOA Structures for slices/dynamic arrays
-			GB_ASSERT(is_type_pointer(type_of_expr(ie->expr)));
-
-			irValue *field = ir_build_expr(proc, ie->expr);
-			irValue *index = ir_build_expr(proc, ie->index);
-
-
-			if (!build_context.no_bounds_check) {
-				// TODO HACK(bill): Clean up this hack to get the length for bounds checking
-				GB_ASSERT(field->kind == irValue_Instr);
-				irInstr *instr = &field->Instr;
-
-				GB_ASSERT(instr->kind == irInstr_Load);
-				irValue *a = instr->Load.address;
-
-				GB_ASSERT(a->kind == irValue_Instr);
-				irInstr *b = &a->Instr;
-				GB_ASSERT(b->kind == irInstr_StructElementPtr);
-				irValue *base_struct = b->StructElementPtr.address;
-
-				GB_ASSERT(is_type_soa_struct(type_deref(ir_type(base_struct))));
-				irValue *len = ir_soa_struct_len(proc, base_struct);
-				ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
-			}
-
-			irValue *val = ir_emit_ptr_offset(proc, field, index);
-			return ir_addr(val);
-		}
-
-		GB_ASSERT_MSG(is_type_indexable(t), "%s %s", type_to_string(t), expr_to_string(expr));
-
-		if (is_type_map(t)) {
-			irValue *map_val = ir_build_addr_ptr(proc, ie->expr);
-			if (deref) {
-				map_val = ir_emit_load(proc, map_val);
-			}
-
-			irValue *key = ir_build_expr(proc, ie->index);
-			key = ir_emit_conv(proc, key, t->Map.key);
-
-			Type *result_type = type_of_expr(expr);
-			return ir_addr_map(map_val, key, t, result_type);
-		}
-
-		switch (t->kind) {
-		case Type_Array: {
-			irValue *array = nullptr;
-			array = ir_build_addr_ptr(proc, ie->expr);
-			if (deref) {
-				array = ir_emit_load(proc, array);
-			}
-			irValue *index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
-			irValue *elem = ir_emit_array_ep(proc, array, index);
-
-			auto index_tv = type_and_value_of_expr(ie->index);
-			if (index_tv.mode != Addressing_Constant) {
-				irValue *len = ir_const_int(t->Array.count);
-				ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
-			}
-			return ir_addr(elem);
-		}
-
-		case Type_EnumeratedArray: {
-			irValue *array = nullptr;
-			array = ir_build_addr_ptr(proc, ie->expr);
-			if (deref) {
-				array = ir_emit_load(proc, array);
-			}
-			Type *index_type = t->EnumeratedArray.index;
-
-			auto index_tv = type_and_value_of_expr(ie->index);
-
-			irValue *index = nullptr;
-			if (compare_exact_values(Token_NotEq, t->EnumeratedArray.min_value, exact_value_i64(0))) {
-				if (index_tv.mode == Addressing_Constant) {
-					ExactValue idx = exact_value_sub(index_tv.value, t->EnumeratedArray.min_value);
-					index = ir_value_constant(index_type, idx);
-				} else {
-					index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
-					index = ir_emit_arith(proc, Token_Sub, index, ir_value_constant(index_type, t->EnumeratedArray.min_value), index_type);
-				}
-			} else {
-				index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
-			}
-
-			irValue *elem = ir_emit_array_ep(proc, array, index);
-
-			if (index_tv.mode != Addressing_Constant) {
-				irValue *len = ir_const_int(t->EnumeratedArray.count);
-				ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
-			}
-			return ir_addr(elem);
-		}
-
-		case Type_Slice: {
-			irValue *slice = nullptr;
-			slice = ir_build_expr(proc, ie->expr);
-			if (deref) {
-				slice = ir_emit_load(proc, slice);
-			}
-
-			irValue *elem = ir_slice_elem(proc, slice);
-			irValue *index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
-			irValue *len = ir_slice_len(proc, slice);
-			ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
-			irValue *v = ir_emit_ptr_offset(proc, elem, index);
-			return ir_addr(v);
-		}
-
-		case Type_RelativeSlice: {
-			irAddr addr = ir_build_addr(proc, ie->expr);
-			if (deref) {
-				addr = ir_addr(ir_addr_load(proc, addr));
-			}
-			irValue *slice = ir_addr_load(proc, addr);
-
-			irValue *elem = ir_slice_elem(proc, slice);
-			irValue *index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
-			irValue *len = ir_slice_len(proc, slice);
-			ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
-			irValue *v = ir_emit_ptr_offset(proc, elem, index);
-			return ir_addr(v);
-		}
-
-		case Type_DynamicArray: {
-			irValue *dynamic_array = nullptr;
-			dynamic_array = ir_build_expr(proc, ie->expr);
-			if (deref) {
-				dynamic_array = ir_emit_load(proc, dynamic_array);
-			}
-
-			irValue *elem = ir_dynamic_array_elem(proc, dynamic_array);
-			irValue *len = ir_dynamic_array_len(proc, dynamic_array);
-			irValue *index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
-			ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
-			irValue *v = ir_emit_ptr_offset(proc, elem, index);
-			return ir_addr(v);
-		}
-
-
-		case Type_Basic: { // Basic_string
-			irValue *str;
-			irValue *elem;
-			irValue *len;
-			irValue *index;
-
-			str = ir_build_expr(proc, ie->expr);
-			if (deref) {
-				str = ir_emit_load(proc, str);
-			}
-
-			elem = ir_string_elem(proc, str);
-			len = ir_string_len(proc, str);
-
-			index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
-			ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
-
-			return ir_addr(ir_emit_ptr_offset(proc, elem, index));
-		}
-		}
-	case_end;
-
-	case_ast_node(se, SliceExpr, expr);
-		ir_emit_comment(proc, str_lit("SliceExpr"));
-		gbAllocator a = ir_allocator();
-		irValue *low  = v_zero;
-		irValue *high = nullptr;
-
-		if (se->low  != nullptr) low  = ir_build_expr(proc, se->low);
-		if (se->high != nullptr) high = ir_build_expr(proc, se->high);
-
-		bool no_indices = se->low == nullptr && se->high == nullptr;
-
-		irAddr addr = ir_build_addr(proc, se->expr);
-		irValue *base = ir_addr_load(proc, addr);
-		Type *type = base_type(ir_type(base));
-
-		if (is_type_pointer(type)) {
-			type = base_type(type_deref(type));
-			addr = ir_addr(base);
-			base = ir_addr_load(proc, addr);
-		}
-		// TODO(bill): Cleanup like mad!
-
-		switch (type->kind) {
-		case Type_Slice: {
-			Type *slice_type = type;
-			irValue *len = ir_slice_len(proc, base);
-			if (high == nullptr) high = len;
-
-			if (!no_indices) {
-				ir_emit_slice_bounds_check(proc, se->open, low, high, len, se->low != nullptr);
-			}
-
-			irValue *elem   = ir_emit_ptr_offset(proc, ir_slice_elem(proc, base), low);
-			irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
-
-			irValue *slice = ir_add_local_generated(proc, slice_type, false);
-			ir_fill_slice(proc, slice, elem, new_len);
-			return ir_addr(slice);
-		}
-
-		case Type_DynamicArray: {
-			Type *elem_type = type->DynamicArray.elem;
-			Type *slice_type = alloc_type_slice(elem_type);
-
-			irValue *len = ir_dynamic_array_len(proc, base);
-			if (high == nullptr) high = len;
-
-			if (!no_indices) {
-				ir_emit_slice_bounds_check(proc, se->open, low, high, len, se->low != nullptr);
-			}
-
-			irValue *elem    = ir_emit_ptr_offset(proc, ir_dynamic_array_elem(proc, base), low);
-			irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
-
-			irValue *slice = ir_add_local_generated(proc, slice_type, false);
-			ir_fill_slice(proc, slice, elem, new_len);
-			return ir_addr(slice);
-		}
-
-
-		case Type_Array: {
-			Type *slice_type = alloc_type_slice(type->Array.elem);
-			irValue *len = ir_array_len(proc, base);
-
-			if (high == nullptr) high = len;
-
-			bool low_const  = type_and_value_of_expr(se->low).mode  == Addressing_Constant;
-			bool high_const = type_and_value_of_expr(se->high).mode == Addressing_Constant;
-
-			if (!low_const || !high_const) {
-				if (!no_indices) {
-					ir_emit_slice_bounds_check(proc, se->open, low, high, len, se->low != nullptr);
-				}
-			}
-			irValue *elem    = ir_emit_ptr_offset(proc, ir_array_elem(proc, ir_addr_get_ptr(proc, addr)), low);
-			irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
-
-			irValue *slice = ir_add_local_generated(proc, slice_type, false);
-			ir_fill_slice(proc, slice, elem, new_len);
-			return ir_addr(slice);
-		}
-
-		case Type_Basic: {
-			GB_ASSERT(type == t_string);
-			irValue *len = ir_string_len(proc, base);
-			if (high == nullptr) high = len;
-
-			if (!no_indices) {
-				ir_emit_slice_bounds_check(proc, se->open, low, high, len, se->low != nullptr);
-			}
-
-			irValue *elem    = ir_emit_ptr_offset(proc, ir_string_elem(proc, base), low);
-			irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
-
-			irValue *str = ir_add_local_generated(proc, t_string, false);
-			ir_fill_string(proc, str, elem, new_len);
-			return ir_addr(str);
-		}
-
-
-		case Type_Struct:
-			if (is_type_soa_struct(type)) {
-				irValue *len = ir_soa_struct_len(proc, ir_addr_get_ptr(proc, addr));
-				if (high == nullptr) high = len;
-
-				if (!no_indices) {
-					ir_emit_slice_bounds_check(proc, se->open, low, high, len, se->low != nullptr);
-				}
-
-				irValue *dst = ir_add_local_generated(proc, type_of_expr(expr), true);
-				if (type->Struct.soa_kind == StructSoa_Fixed) {
-					i32 field_count = cast(i32)type->Struct.fields.count;
-					for (i32 i = 0; i < field_count; i++) {
-						irValue *field_dst = ir_emit_struct_ep(proc, dst, i);
-						irValue *field_src = ir_emit_struct_ep(proc, ir_addr_get_ptr(proc, addr), i);
-						field_src = ir_emit_array_ep(proc, field_src, low);
-						ir_emit_store(proc, field_dst, field_src);
-					}
-
-					irValue *len_dst = ir_emit_struct_ep(proc, dst, field_count);
-					irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
-					ir_emit_store(proc, len_dst, new_len);
-				} else if (type->Struct.soa_kind == StructSoa_Slice) {
-					if (no_indices) {
-						ir_emit_store(proc, dst, base);
-					} else {
-						i32 field_count = cast(i32)type->Struct.fields.count - 1;
-						for (i32 i = 0; i < field_count; i++) {
-							irValue *field_dst = ir_emit_struct_ep(proc, dst, i);
-							irValue *field_src = ir_emit_struct_ev(proc, base, i);
-							field_src = ir_emit_ptr_offset(proc, field_src, low);
-							ir_emit_store(proc, field_dst, field_src);
-						}
-
-
-						irValue *len_dst = ir_emit_struct_ep(proc, dst, field_count);
-						irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
-						ir_emit_store(proc, len_dst, new_len);
-					}
-				} else if (type->Struct.soa_kind == StructSoa_Dynamic) {
-					i32 field_count = cast(i32)type->Struct.fields.count - 3;
-					for (i32 i = 0; i < field_count; i++) {
-						irValue *field_dst = ir_emit_struct_ep(proc, dst, i);
-						irValue *field_src = ir_emit_struct_ev(proc, base, i);
-						field_src = ir_emit_ptr_offset(proc, field_src, low);
-						ir_emit_store(proc, field_dst, field_src);
-					}
-
-
-					irValue *len_dst = ir_emit_struct_ep(proc, dst, field_count);
-					irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
-					ir_emit_store(proc, len_dst, new_len);
-				}
-
-				return ir_addr(dst);
-			}
-			break;
-
-		}
-
-		GB_PANIC("Unknown slicable type");
-	case_end;
-
-	case_ast_node(de, DerefExpr, expr);
-		if (is_type_relative_pointer(type_of_expr(de->expr))) {
-			irAddr addr = ir_build_addr(proc, de->expr);
-			addr.relative.deref = true;
-			return addr;
-		}
-
-		// TODO(bill): Is a ptr copy needed?
-		irValue *addr = ir_build_expr(proc, de->expr);
-		addr = ir_emit_ptr_offset(proc, addr, v_zero);
-		return ir_addr(addr);
-	case_end;
-
-	case_ast_node(ce, CallExpr, expr);
-		// NOTE(bill): This is make sure you never need to have an 'array_ev'
-		irValue *e = ir_build_expr(proc, expr);
-		irValue *v = ir_add_local_generated(proc, ir_type(e), false);
-		ir_emit_store(proc, v, e);
-		return ir_addr(v);
-	case_end;
-
-	case_ast_node(cl, CompoundLit, expr);
-		ir_emit_comment(proc, str_lit("CompoundLit"));
-		Type *type = type_of_expr(expr);
-		Type *bt = base_type(type);
-
-		irValue *v = ir_add_local_generated(proc, type, true);
-
-		Type *et = nullptr;
-		switch (bt->kind) {
-		case Type_Array:  et = bt->Array.elem;  break;
-		case Type_EnumeratedArray: et = bt->EnumeratedArray.elem; break;
-		case Type_Slice:  et = bt->Slice.elem;  break;
-		case Type_BitSet: et = bt->BitSet.elem; break;
-		case Type_SimdVector: et = bt->SimdVector.elem; break;
-		}
-
-		String proc_name = {};
-		if (proc->entity) {
-			proc_name = proc->entity->token.string;
-		}
-		TokenPos pos = ast_token(expr).pos;
-
-		switch (bt->kind) {
-		default: GB_PANIC("Unknown CompoundLit type: %s", type_to_string(type)); break;
-
-		case Type_Struct: {
-
-			// TODO(bill): "constant" '#raw_union's are not initialized constantly at the moment.
-			// NOTE(bill): This is due to the layout of the unions when printed to LLVM-IR
-			bool is_raw_union = is_type_raw_union(bt);
-			GB_ASSERT(is_type_struct(bt) || is_raw_union);
-			TypeStruct *st = &bt->Struct;
-			if (cl->elems.count > 0) {
-				ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr)));
-				for_array(field_index, cl->elems) {
-					Ast *elem = cl->elems[field_index];
-
-					irValue *field_expr = nullptr;
-					Entity *field = nullptr;
-					isize index = field_index;
-
-					if (elem->kind == Ast_FieldValue) {
-						ast_node(fv, FieldValue, elem);
-						String name = fv->field->Ident.token.string;
-						Selection sel = lookup_field(bt, name, false);
-						index = sel.index[0];
-						elem = fv->value;
-						TypeAndValue tav = type_and_value_of_expr(elem);
-					} else {
-						TypeAndValue tav = type_and_value_of_expr(elem);
-						Selection sel = lookup_field_from_index(bt, st->fields[field_index]->Variable.field_src_index);
-						index = sel.index[0];
-					}
-
-					field = st->fields[index];
-					Type *ft = field->type;
-					if (!is_raw_union && !is_type_typeid(ft) && ir_is_elem_const(proc->module, elem, ft)) {
-						continue;
-					}
-
-					field_expr = ir_build_expr(proc, elem);
-
-
-					GB_ASSERT(ir_type(field_expr)->kind != Type_Tuple);
-
-					Type *fet = ir_type(field_expr);
-					// HACK TODO(bill): THIS IS A MASSIVE HACK!!!!
-					if (is_type_union(ft) && !are_types_identical(fet, ft) && !is_type_untyped(fet)) {
-						GB_ASSERT_MSG(union_variant_index(ft, fet) > 0, "%s", type_to_string(fet));
-
-						irValue *gep = ir_emit_struct_ep(proc, v, cast(i32)index);
-						ir_emit_store_union_variant(proc, gep, field_expr, fet);
-					} else {
-						irValue *fv = ir_emit_conv(proc, field_expr, ft);
-						irValue *gep = ir_emit_struct_ep(proc, v, cast(i32)index);
-						ir_emit_store(proc, gep, fv);
-					}
-				}
-			}
-			break;
-		}
-
-		case Type_Map: {
-			if (cl->elems.count == 0) {
-				break;
-			}
-			gbAllocator a = ir_allocator();
-			{
-				auto args = array_make<irValue *>(a, 3);
-				args[0] = ir_gen_map_header(proc, v, type);
-				args[1] = ir_const_int(2*cl->elems.count);
-				args[2] = ir_emit_source_code_location(proc, proc_name, pos);
-				ir_emit_runtime_call(proc, "__dynamic_map_reserve", args);
-			}
-			for_array(field_index, cl->elems) {
-				Ast *elem = cl->elems[field_index];
-				ast_node(fv, FieldValue, elem);
-
-				irValue *key   = ir_build_expr(proc, fv->field);
-				irValue *value = ir_build_expr(proc, fv->value);
-				ir_insert_dynamic_map_key_and_value(proc, v, type, key, value, elem);
-			}
-			break;
-		}
-
-		case Type_Array: {
-			if (cl->elems.count > 0) {
-				ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr)));
-
-				auto temp_data = array_make<irCompoundLitElemTempData>(temporary_allocator(), 0, cl->elems.count);
-
-				// NOTE(bill): Separate value, gep, store into their own chunks
-				for_array(i, cl->elems) {
-					Ast *elem = cl->elems[i];
-					if (elem->kind == Ast_FieldValue) {
-						ast_node(fv, FieldValue, elem);
-						if (ir_is_elem_const(proc->module, fv->value, et)) {
-							continue;
-						}
-						if (is_ast_range(fv->field)) {
-							ast_node(ie, BinaryExpr, fv->field);
-							TypeAndValue lo_tav = ie->left->tav;
-							TypeAndValue hi_tav = ie->right->tav;
-							GB_ASSERT(lo_tav.mode == Addressing_Constant);
-							GB_ASSERT(hi_tav.mode == Addressing_Constant);
-
-							TokenKind op = ie->op.kind;
-							i64 lo = exact_value_to_i64(lo_tav.value);
-							i64 hi = exact_value_to_i64(hi_tav.value);
-							if (op == Token_Ellipsis) {
-								hi += 1;
-							}
-
-							irValue *value = ir_build_expr(proc, fv->value);
-
-							for (i64 k = lo; k < hi; k++) {
-								irCompoundLitElemTempData data = {};
-								data.value = value;
-								data.elem_index = cast(i32)k;
-								array_add(&temp_data, data);
-							}
-
-						} else {
-							auto tav = fv->field->tav;
-							GB_ASSERT(tav.mode == Addressing_Constant);
-							i64 index = exact_value_to_i64(tav.value);
-
-							irCompoundLitElemTempData data = {};
-							data.value = ir_emit_conv(proc, ir_build_expr(proc, fv->value), et);
-							data.expr = fv->value;
-							data.elem_index = cast(i32)index;
-							array_add(&temp_data, data);
-						}
-
-					} else {
-						if (ir_is_elem_const(proc->module, elem, et)) {
-							continue;
-						}
-						irCompoundLitElemTempData data = {};
-						data.expr = elem;
-						data.elem_index = cast(i32)i;
-						array_add(&temp_data, data);
-					}
-				}
-
-				for_array(i, temp_data) {
-					temp_data[i].gep = ir_emit_array_epi(proc, v, temp_data[i].elem_index);
-				}
-
-				for_array(i, temp_data) {
-					auto return_ptr_hint_ast   = proc->return_ptr_hint_ast;
-					auto return_ptr_hint_value = proc->return_ptr_hint_value;
-					auto return_ptr_hint_used  = proc->return_ptr_hint_used;
-					defer (proc->return_ptr_hint_ast   = return_ptr_hint_ast);
-					defer (proc->return_ptr_hint_value = return_ptr_hint_value);
-					defer (proc->return_ptr_hint_used  = return_ptr_hint_used);
-
-					irValue *field_expr = temp_data[i].value;
-					Ast *expr = temp_data[i].expr;
-
-					proc->return_ptr_hint_value = temp_data[i].gep;
-					proc->return_ptr_hint_ast = unparen_expr(expr);
-
-					if (field_expr == nullptr) {
-						field_expr = ir_build_expr(proc, expr);
-					}
-					Type *t = ir_type(field_expr);
-					GB_ASSERT(t->kind != Type_Tuple);
-					irValue *ev = ir_emit_conv(proc, field_expr, et);
-
-					if (!proc->return_ptr_hint_used) {
-						temp_data[i].value = ev;
-					}
-				}
-
-				for_array(i, temp_data) {
-					if (temp_data[i].value != nullptr) {
-						ir_emit_store(proc, temp_data[i].gep, temp_data[i].value, false);
-					}
-				}
-			}
-			break;
-		}
-		case Type_EnumeratedArray: {
-			if (cl->elems.count > 0) {
-				ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr)));
-
-				auto temp_data = array_make<irCompoundLitElemTempData>(temporary_allocator(), 0, cl->elems.count);
-
-				// NOTE(bill): Separate value, gep, store into their own chunks
-				for_array(i, cl->elems) {
-					Ast *elem = cl->elems[i];
-					if (elem->kind == Ast_FieldValue) {
-						ast_node(fv, FieldValue, elem);
-						if (ir_is_elem_const(proc->module, fv->value, et)) {
-							continue;
-						}
-						if (is_ast_range(fv->field)) {
-							ast_node(ie, BinaryExpr, fv->field);
-							TypeAndValue lo_tav = ie->left->tav;
-							TypeAndValue hi_tav = ie->right->tav;
-							GB_ASSERT(lo_tav.mode == Addressing_Constant);
-							GB_ASSERT(hi_tav.mode == Addressing_Constant);
-
-							TokenKind op = ie->op.kind;
-							i64 lo = exact_value_to_i64(lo_tav.value);
-							i64 hi = exact_value_to_i64(hi_tav.value);
-							if (op == Token_Ellipsis) {
-								hi += 1;
-							}
-
-							irValue *value = ir_build_expr(proc, fv->value);
-
-							for (i64 k = lo; k < hi; k++) {
-								irCompoundLitElemTempData data = {};
-								data.value = value;
-								data.elem_index = cast(i32)k;
-								array_add(&temp_data, data);
-							}
-
-						} else {
-							auto tav = fv->field->tav;
-							GB_ASSERT(tav.mode == Addressing_Constant);
-							i64 index = exact_value_to_i64(tav.value);
-
-							irCompoundLitElemTempData data = {};
-							data.value = ir_emit_conv(proc, ir_build_expr(proc, fv->value), et);
-							data.expr = fv->value;
-							data.elem_index = cast(i32)index;
-							array_add(&temp_data, data);
-						}
-
-					} else {
-						if (ir_is_elem_const(proc->module, elem, et)) {
-							continue;
-						}
-						irCompoundLitElemTempData data = {};
-						data.expr = elem;
-						data.elem_index = cast(i32)i;
-						array_add(&temp_data, data);
-					}
-				}
-
-
-				i32 index_offset = cast(i32)exact_value_to_i64(bt->EnumeratedArray.min_value);
-
-				for_array(i, temp_data) {
-					i32 index = temp_data[i].elem_index - index_offset;
-					temp_data[i].gep = ir_emit_array_epi(proc, v, index);
-				}
-
-				for_array(i, temp_data) {
-					auto return_ptr_hint_ast   = proc->return_ptr_hint_ast;
-					auto return_ptr_hint_value = proc->return_ptr_hint_value;
-					auto return_ptr_hint_used  = proc->return_ptr_hint_used;
-					defer (proc->return_ptr_hint_ast   = return_ptr_hint_ast);
-					defer (proc->return_ptr_hint_value = return_ptr_hint_value);
-					defer (proc->return_ptr_hint_used  = return_ptr_hint_used);
-
-					irValue *field_expr = temp_data[i].value;
-					Ast *expr = temp_data[i].expr;
-
-					proc->return_ptr_hint_value = temp_data[i].gep;
-					proc->return_ptr_hint_ast = unparen_expr(expr);
-
-					if (field_expr == nullptr) {
-						field_expr = ir_build_expr(proc, expr);
-					}
-					Type *t = ir_type(field_expr);
-					GB_ASSERT(t->kind != Type_Tuple);
-					irValue *ev = ir_emit_conv(proc, field_expr, et);
-
-					if (!proc->return_ptr_hint_used) {
-						temp_data[i].value = ev;
-					}
-				}
-
-				for_array(i, temp_data) {
-					if (temp_data[i].value != nullptr) {
-						ir_emit_store(proc, temp_data[i].gep, temp_data[i].value, false);
-					}
-				}
-			}
-			break;
-		}
-		case Type_Slice: {
-			if (cl->elems.count > 0) {
-				Type *elem_type = bt->Slice.elem;
-				Type *elem_ptr_type = alloc_type_pointer(elem_type);
-				Type *elem_ptr_ptr_type = alloc_type_pointer(elem_ptr_type);
-				irValue *slice = ir_add_module_constant(proc->module, type, exact_value_compound(expr));
-				GB_ASSERT(slice->kind == irValue_ConstantSlice);
-
-				irValue *data = ir_emit_array_ep(proc, slice->ConstantSlice.backing_array, v_zero32);
-
-				auto temp_data = array_make<irCompoundLitElemTempData>(temporary_allocator(), 0, cl->elems.count);
-
-				for_array(i, cl->elems) {
-					Ast *elem = cl->elems[i];
-					if (elem->kind == Ast_FieldValue) {
-						ast_node(fv, FieldValue, elem);
-
-						if (ir_is_elem_const(proc->module, fv->value, et)) {
-							continue;
-						}
-
-						if (is_ast_range(fv->field)) {
-							ast_node(ie, BinaryExpr, fv->field);
-							TypeAndValue lo_tav = ie->left->tav;
-							TypeAndValue hi_tav = ie->right->tav;
-							GB_ASSERT(lo_tav.mode == Addressing_Constant);
-							GB_ASSERT(hi_tav.mode == Addressing_Constant);
-
-							TokenKind op = ie->op.kind;
-							i64 lo = exact_value_to_i64(lo_tav.value);
-							i64 hi = exact_value_to_i64(hi_tav.value);
-							if (op == Token_Ellipsis) {
-								hi += 1;
-							}
-
-							irValue *value = ir_emit_conv(proc, ir_build_expr(proc, fv->value), et);
-
-							for (i64 k = lo; k < hi; k++) {
-								irCompoundLitElemTempData data = {};
-								data.value = value;
-								data.elem_index = cast(i32)k;
-								array_add(&temp_data, data);
-							}
-
-						} else {
-							GB_ASSERT(fv->field->tav.mode == Addressing_Constant);
-							i64 index = exact_value_to_i64(fv->field->tav.value);
-
-							irValue *field_expr = ir_build_expr(proc, fv->value);
-							GB_ASSERT(!is_type_tuple(ir_type(field_expr)));
-
-							irValue *ev = ir_emit_conv(proc, field_expr, et);
-
-							irCompoundLitElemTempData data = {};
-							data.value = ev;
-							data.elem_index = cast(i32)index;
-							array_add(&temp_data, data);
-						}
-					} else {
-						if (ir_is_elem_const(proc->module, elem, et)) {
-							continue;
-						}
-						irValue *field_expr = ir_build_expr(proc, elem);
-						GB_ASSERT(!is_type_tuple(ir_type(field_expr)));
-
-						irValue *ev = ir_emit_conv(proc, field_expr, et);
-
-						irCompoundLitElemTempData data = {};
-						data.value = ev;
-						data.elem_index = cast(i32)i;
-						array_add(&temp_data, data);
-					}
-				}
-
-				for_array(i, temp_data) {
-					temp_data[i].gep = ir_emit_ptr_offset(proc, data, ir_const_int(temp_data[i].elem_index));
-				}
-
-				for_array(i, temp_data) {
-					ir_emit_store(proc, temp_data[i].gep, temp_data[i].value);
-				}
-
-				irValue *count = ir_const_int(slice->ConstantSlice.count);
-				ir_fill_slice(proc, v, data, count);
-			}
-			break;
-		}
-
-		case Type_DynamicArray: {
-			if (cl->elems.count == 0) {
-				break;
-			}
-			Type *et = bt->DynamicArray.elem;
-			gbAllocator a = ir_allocator();
-			irValue *size  = ir_const_int(type_size_of(et));
-			irValue *align = ir_const_int(type_align_of(et));
-
-			i64 item_count = gb_max(cl->max_count, cl->elems.count);
-			{
-
-				auto args = array_make<irValue *>(a, 5);
-				args[0] = ir_emit_conv(proc, v, t_rawptr);
-				args[1] = size;
-				args[2] = align;
-				args[3] = ir_const_int(2*item_count); // TODO(bill): Is this too much waste?
-				args[4] = ir_emit_source_code_location(proc, proc_name, pos);
-				ir_emit_runtime_call(proc, "__dynamic_array_reserve", args);
-			}
-
-			irValue *items = ir_generate_array(proc->module, et, item_count, str_lit("dacl$"), cast(i64)cast(intptr)expr);
-
-			for_array(i, cl->elems) {
-				Ast *elem = cl->elems[i];
-				if (elem->kind == Ast_FieldValue) {
-					ast_node(fv, FieldValue, elem);
-					if (is_ast_range(fv->field)) {
-						ast_node(ie, BinaryExpr, fv->field);
-						TypeAndValue lo_tav = ie->left->tav;
-						TypeAndValue hi_tav = ie->right->tav;
-						GB_ASSERT(lo_tav.mode == Addressing_Constant);
-						GB_ASSERT(hi_tav.mode == Addressing_Constant);
-
-						TokenKind op = ie->op.kind;
-						i64 lo = exact_value_to_i64(lo_tav.value);
-						i64 hi = exact_value_to_i64(hi_tav.value);
-						if (op == Token_Ellipsis) {
-							hi += 1;
-						}
-
-						irValue *value = ir_emit_conv(proc, ir_build_expr(proc, fv->value), et);
-
-						for (i64 k = lo; k < hi; k++) {
-							irValue *ep = ir_emit_array_epi(proc, items, cast(i32)k);
-							ir_emit_store(proc, ep, value);
-						}
-					} else {
-						GB_ASSERT(fv->field->tav.mode == Addressing_Constant);
-
-						i64 field_index = exact_value_to_i64(fv->field->tav.value);
-
-						irValue *ev = ir_build_expr(proc, fv->value);
-						irValue *value = ir_emit_conv(proc, ev, et);
-						irValue *ep = ir_emit_array_epi(proc, items, cast(i32)field_index);
-						ir_emit_store(proc, ep, value);
-					}
-				} else {
-					irValue *value = ir_emit_conv(proc, ir_build_expr(proc, elem), et);
-					irValue *ep = ir_emit_array_epi(proc, items, cast(i32)i);
-					ir_emit_store(proc, ep, value);
-				}
-			}
-
-			{
-				auto args = array_make<irValue *>(a, 6);
-				args[0] = ir_emit_conv(proc, v, t_rawptr);
-				args[1] = size;
-				args[2] = align;
-				args[3] = ir_emit_conv(proc, items, t_rawptr);
-				args[4] = ir_const_int(item_count);
-				args[5] = ir_emit_source_code_location(proc, proc_name, pos);
-				ir_emit_runtime_call(proc, "__dynamic_array_append", args);
-			}
-			break;
-		}
-
-		case Type_Basic: {
-			GB_ASSERT(is_type_any(bt));
-			if (cl->elems.count > 0) {
-				ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr)));
-				String field_names[2] = {
-					str_lit("data"),
-					str_lit("id"),
-				};
-				Type *field_types[2] = {
-					t_rawptr,
-					t_typeid,
-				};
-
-				for_array(field_index, cl->elems) {
-					Ast *elem = cl->elems[field_index];
-
-					irValue *field_expr = nullptr;
-					isize index = field_index;
-
-					if (elem->kind == Ast_FieldValue) {
-						ast_node(fv, FieldValue, elem);
-						Selection sel = lookup_field(bt, fv->field->Ident.token.string, false);
-						index = sel.index[0];
-						elem = fv->value;
-					} else {
-						TypeAndValue tav = type_and_value_of_expr(elem);
-						Selection sel = lookup_field(bt, field_names[field_index], false);
-						index = sel.index[0];
-					}
-
-					field_expr = ir_build_expr(proc, elem);
-
-					GB_ASSERT(ir_type(field_expr)->kind != Type_Tuple);
-
-					Type *ft = field_types[index];
-					irValue *fv = ir_emit_conv(proc, field_expr, ft);
-					irValue *gep = ir_emit_struct_ep(proc, v, cast(i32)index);
-					ir_emit_store(proc, gep, fv);
-				}
-			}
-
-			break;
-		}
-
-		case Type_BitSet: {
-			i64 sz = type_size_of(type);
-			if (cl->elems.count > 0 && sz > 0) {
-				ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr)));
-
-				irValue *lower = ir_value_constant(t_int, exact_value_i64(bt->BitSet.lower));
-				for_array(i, cl->elems) {
-					Ast *elem = cl->elems[i];
-					GB_ASSERT(elem->kind != Ast_FieldValue);
-
-					if (ir_is_elem_const(proc->module, elem, et)) {
-						continue;
-					}
-
-					irValue *expr = ir_build_expr(proc, elem);
-					GB_ASSERT(ir_type(expr)->kind != Type_Tuple);
-
-					Type *it = bit_set_to_int(bt);
-					irValue *e = ir_emit_conv(proc, expr, it);
-					e = ir_emit_arith(proc, Token_Sub, e, lower, it);
-					e = ir_emit_arith(proc, Token_Shl, v_one, e, it);
-
-					irValue *old_value = ir_emit_bitcast(proc, ir_emit_load(proc, v), it);
-					irValue *new_value = ir_emit_arith(proc, Token_Or, old_value, e, it);
-					new_value = ir_emit_bitcast(proc, new_value, type);
-					ir_emit_store(proc, v, new_value);
-				}
-			}
-			break;
-		}
-
-		}
-
-		return ir_addr(v);
-	case_end;
-
-	case_ast_node(tc, TypeCast, expr);
-		Type *type = type_of_expr(expr);
-		irValue *x = ir_build_expr(proc, tc->expr);
-		irValue *e = nullptr;
-		switch (tc->token.kind) {
-		case Token_cast:
-			e = ir_emit_conv(proc, x, type);
-			break;
-		case Token_transmute:
-			e = ir_emit_transmute(proc, x, type);
-			break;
-		default:
-			GB_PANIC("Invalid AST TypeCast");
-		}
-		irValue *v = ir_add_local_generated(proc, type, false);
-		ir_emit_store(proc, v, e);
-		return ir_addr(v);
-	case_end;
-
-	case_ast_node(ac, AutoCast, expr);
-		return ir_build_addr(proc, ac->expr);
-	case_end;
-	}
-
-	TokenPos token_pos = ast_token(expr).pos;
-	GB_PANIC("Unexpected address expression\n"
-	         "\tAst: %.*s @ "
-	         "%s\n",
-	         LIT(ast_strings[expr->kind]),
-	         token_pos_to_string(token_pos));
-
-
-	return ir_addr(nullptr);
-}
-
-void ir_build_assign_op(irProcedure *proc, irAddr const &lhs, irValue *value, TokenKind op) {
-	irValue *old_value = ir_addr_load(proc, lhs);
-	Type *type = ir_type(old_value);
-
-	irValue *change = value;
-	if (is_type_pointer(type) && is_type_integer(ir_type(value))) {
-		change = ir_emit_conv(proc, value, default_type(ir_type(value)));
-	} else {
-		change = ir_emit_conv(proc, value, type);
-	}
-
-	irValue *new_value = ir_emit_arith(proc, op, old_value, change, type);
-	ir_addr_store(proc, lhs, new_value);
-}
-
-irValue *ir_build_cond(irProcedure *proc, Ast *cond, irBlock *true_block, irBlock *false_block) {
-	switch (cond->kind) {
-	case_ast_node(pe, ParenExpr, cond);
-		return ir_build_cond(proc, pe->expr, true_block, false_block);
-	case_end;
-
-	case_ast_node(ue, UnaryExpr, cond);
-		if (ue->op.kind == Token_Not) {
-			return ir_build_cond(proc, ue->expr, false_block, true_block);
-		}
-	case_end;
-
-	case_ast_node(be, BinaryExpr, cond);
-		if (be->op.kind == Token_CmpAnd) {
-			irBlock *block = ir_new_block(proc, nullptr, "cmp.and");
-			ir_build_cond(proc, be->left, block, false_block);
-			ir_start_block(proc, block);
-			return ir_build_cond(proc, be->right, true_block, false_block);
-		} else if (be->op.kind == Token_CmpOr) {
-			irBlock *block = ir_new_block(proc, nullptr, "cmp.or");
-			ir_build_cond(proc, be->left, true_block, block);
-			ir_start_block(proc, block);
-			return ir_build_cond(proc, be->right, true_block, false_block);
-		}
-	case_end;
-	}
-
-	irValue *v = ir_build_expr(proc, cond);
-	v = ir_emit_conv(proc, v, t_bool);
-	ir_emit_if(proc, v, true_block, false_block);
-	return v;
-}
-
-void ir_build_nested_proc(irProcedure *proc, AstProcLit *pd, Entity *e) {
-	GB_ASSERT(pd->body != nullptr);
-
-	if (ir_min_dep_entity(proc->module, e) == false) {
-		// NOTE(bill): Nothing depends upon it so doesn't need to be built
-		return;
-	}
-
-	// NOTE(bill): Generate a new name
-	// parent.name-guid
-	String original_name = e->token.string;
-	String pd_name = original_name;
-	if (e->Procedure.link_name.len > 0) {
-		pd_name = e->Procedure.link_name;
-	}
-
-	isize name_len = proc->name.len + 1 + pd_name.len + 1 + 10 + 1;
-	u8 *name_text = gb_alloc_array(ir_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);
-
-	set_procedure_abi_types(e->type);
-	irValue *value = ir_value_procedure(proc->module, e, e->type, pd->type, pd->body, name);
-
-	value->Proc.tags = pd->tags;
-	value->Proc.inlining = pd->inlining;
-	value->Proc.parent = proc;
-
-	ir_module_add_value(proc->module, e, value);
-	array_add(&proc->children, &value->Proc);
-	array_add(&proc->module->procs_to_generate, value);
-}
-
-
-void ir_build_constant_value_decl(irProcedure *proc, AstValueDecl *vd) {
-	if (vd == nullptr || vd->is_mutable) {
-		return;
-	}
-
-	for_array(i, vd->names) {
-		Ast *ident = vd->names[i];
-		GB_ASSERT(ident->kind == Ast_Ident);
-		Entity *e = entity_of_node(ident);
-		GB_ASSERT(e != nullptr);
-		switch (e->kind) {
-		case Entity_TypeName:
-		case Entity_Procedure:
-			break;
-		default:
-			continue;
-		}
-
-		if (e->kind == Entity_TypeName) {
-			bool polymorphic_struct = false;
-			if (e->type != nullptr && e->kind == Entity_TypeName) {
-			Type *bt = base_type(e->type);
-				if (bt->kind == Type_Struct) {
-					polymorphic_struct = bt->Struct.is_polymorphic;
-				}
-			}
-
-			if (!polymorphic_struct && !ir_min_dep_entity(proc->module, e)) {
-				continue;
-			}
-
-			// NOTE(bill): Generate a new name
-			// parent_proc.name-guid
-			String ts_name = e->token.string;
-
-			irModule *m = proc->module;
-			isize name_len = proc->name.len + 1 + ts_name.len + 1 + 10 + 1;
-			u8 *name_text = gb_alloc_array(ir_allocator(), u8, name_len);
-			i32 guid = cast(i32)m->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);
-
-			irValue *value = ir_value_type_name(name, e->type);
-			ir_add_entity_name(m, e, name);
-			ir_gen_global_type_name(m, e, name);
-		} else if (e->kind == Entity_Procedure) {
-			CheckerInfo *info = proc->module->info;
-			DeclInfo *decl = decl_info_of_entity(e);
-			ast_node(pl, ProcLit, decl->proc_lit);
-			if (pl->body != nullptr) {
-				auto *found = map_get(&info->gen_procs, hash_pointer(ident));
-				if (found) {
-					auto procs = *found;
-					for_array(i, procs) {
-						Entity *e = procs[i];
-						if (!ir_min_dep_entity(proc->module, e)) {
-							continue;
-						}
-						DeclInfo *d = decl_info_of_entity(e);
-						ir_build_nested_proc(proc, &d->proc_lit->ProcLit, e);
-					}
-				} else {
-					ir_build_nested_proc(proc, pl, e);
-				}
-			} else {
-
-				// FFI - Foreign function interace
-				String original_name = e->token.string;
-				String name = original_name;
-
-				if (e->Procedure.is_foreign) {
-					ir_add_foreign_library_path(proc->module, e->Procedure.foreign_library);
-				}
-
-				if (e->Procedure.link_name.len > 0) {
-					name = e->Procedure.link_name;
-				}
-
-				StringHashKey key = string_hash_string(name);
-				irValue **prev_value = string_map_get(&proc->module->members, key);
-				if (prev_value != nullptr) {
-					// NOTE(bill): Don't do mutliple declarations in the IR
-					return;
-				}
-
-				set_procedure_abi_types(e->type);
-				irValue *value = ir_value_procedure(proc->module, e, e->type, pl->type, pl->body, name);
-
-				value->Proc.tags = pl->tags;
-				value->Proc.inlining = pl->inlining;
-
-				if (value->Proc.is_foreign || value->Proc.is_export) {
-					string_map_set(&proc->module->members, key, value);
-				} else {
-					array_add(&proc->children, &value->Proc);
-				}
-
-				ir_module_add_value(proc->module, e, value);
-				ir_build_proc(value, proc);
-			}
-		}
-	}
-}
-
-void ir_build_stmt_list(irProcedure *proc, Slice<Ast *> stmts) {
-	// NOTE(bill): Precollect constant entities
-	for_array(i, stmts) {
-		Ast *stmt = stmts[i];
-		switch (stmt->kind) {
-		case_ast_node(vd, ValueDecl, stmt);
-			ir_build_constant_value_decl(proc, vd);
-		case_end;
-		case_ast_node(fb, ForeignBlockDecl, stmt);
-			ast_node(block, BlockStmt, fb->body);
-			ir_build_stmt_list(proc, block->stmts);
-		case_end;
-		}
-	}
-	for_array(i, stmts) {
-		ir_build_stmt(proc, stmts[i]);
-	}
-}
-
-void ir_build_stmt_internal(irProcedure *proc, Ast *node);
-void ir_build_stmt(irProcedure *proc, Ast *node) {
-	Ast *prev_stmt = proc->curr_stmt;
-	proc->curr_stmt = node;
-	u64 prev_state_flags = proc->module->state_flags;
-	defer (proc->module->state_flags = prev_state_flags);
-
-	if (node->state_flags != 0) {
-		u64 in = node->state_flags;
-		u64 out = proc->module->state_flags;
-
-		if (in & StateFlag_bounds_check) {
-			out |= StateFlag_bounds_check;
-			out &= ~StateFlag_no_bounds_check;
-		} else if (in & StateFlag_no_bounds_check) {
-			out |= StateFlag_no_bounds_check;
-			out &= ~StateFlag_bounds_check;
-		}
-
-		proc->module->state_flags = out;
-	}
-
-	ir_push_debug_location(proc->module, node, proc->debug_scope);
-	ir_build_stmt_internal(proc, node);
-	ir_pop_debug_location(proc->module);
-
-	proc->curr_stmt = prev_stmt;
-}
-
-void ir_build_when_stmt(irProcedure *proc, AstWhenStmt *ws) {
-	irValue *cond = ir_build_expr(proc, ws->cond);
-	GB_ASSERT(cond->kind == irValue_Constant &&
-	          is_type_boolean(ir_type(cond)));
-
-	GB_ASSERT(cond->Constant.value.kind == ExactValue_Bool);
-	if (cond->Constant.value.value_bool) {
-		ir_build_stmt_list(proc, ws->body->BlockStmt.stmts);
-	} else if (ws->else_stmt) {
-		switch (ws->else_stmt->kind) {
-		case Ast_BlockStmt:
-			ir_build_stmt_list(proc, ws->else_stmt->BlockStmt.stmts);
-			break;
-		case Ast_WhenStmt:
-			ir_build_when_stmt(proc, &ws->else_stmt->WhenStmt);
-			break;
-		default:
-			GB_PANIC("Invalid 'else' statement in 'when' statement");
-			break;
-		}
-	}
-}
-
-
-
-void ir_build_range_indexed(irProcedure *proc, irValue *expr, Type *val_type, irValue *count_ptr,
-                            irValue **val_, irValue **idx_, irBlock **loop_, irBlock **done_) {
-	irValue *count = nullptr;
-	Type *expr_type = base_type(type_deref(ir_type(expr)));
-	switch (expr_type->kind) {
-	case Type_Array:
-		count = ir_const_int(expr_type->Array.count);
-		break;
-	}
-
-	irValue *val = nullptr;
-	irValue *idx = nullptr;
-	irBlock *loop = nullptr;
-	irBlock *done = nullptr;
-	irBlock *body = nullptr;
-
-
-	irValue *index = ir_add_local_generated(proc, t_int, false);
-	ir_emit_store(proc, index, ir_const_int(-1));
-
-	loop = ir_new_block(proc, nullptr, "for.index.loop");
-	ir_emit_jump(proc, loop);
-	ir_start_block(proc, loop);
-
-	irValue *incr = ir_emit_arith(proc, Token_Add, ir_emit_load(proc, index), v_one, t_int);
-	ir_emit_store(proc, index, incr);
-
-	body = ir_new_block(proc, nullptr, "for.index.body");
-	done = ir_new_block(proc, nullptr, "for.index.done");
-	if (count == nullptr) {
-		GB_ASSERT(count_ptr != nullptr);
-		count = ir_emit_load(proc, count_ptr);
-	}
-	irValue *cond = ir_emit_comp(proc, Token_Lt, incr, count);
-	ir_emit_if(proc, cond, body, done);
-	ir_start_block(proc, body);
-
-	idx = ir_emit_load(proc, index);
-	switch (expr_type->kind) {
-	case Type_Array: {
-		if (val_type != nullptr) {
-			val = ir_emit_load(proc, ir_emit_array_ep(proc, expr, idx));
-		}
-		break;
-	}
-	case Type_EnumeratedArray: {
-		if (val_type != nullptr) {
-			val = ir_emit_load(proc, ir_emit_array_ep(proc, expr, idx));
-		}
-		// NOTE(bill): Override the idx value for the enumeration
-		Type *index_type =expr_type->EnumeratedArray.index;
-		if (compare_exact_values(Token_NotEq, expr_type->EnumeratedArray.min_value, exact_value_u64(0))) {
-			idx = ir_emit_arith(proc, Token_Add, idx, ir_value_constant(index_type, expr_type->EnumeratedArray.min_value), index_type);
-		}
-
-		idx = ir_emit_conv(proc, idx, expr_type->EnumeratedArray.index);
-		break;
-	}
-	case Type_Slice: {
-		if (val_type != nullptr) {
-			irValue *elem = ir_slice_elem(proc, expr);
-			val = ir_emit_load(proc, ir_emit_ptr_offset(proc, elem, idx));
-		}
-		break;
-	}
-	case Type_DynamicArray: {
-		if (val_type != nullptr) {
-			irValue *elem = ir_emit_struct_ep(proc, expr, 0);
-			elem = ir_emit_load(proc, elem);
-			val = ir_emit_load(proc, ir_emit_ptr_offset(proc, elem, idx));
-		}
-		break;
-	}
-	case Type_Map: {
-		irValue *entries = ir_map_entries_ptr(proc, expr);
-		irValue *elem = ir_emit_struct_ep(proc, entries, 0);
-		elem = ir_emit_load(proc, elem);
-
-		irValue *entry = ir_emit_ptr_offset(proc, elem, idx);
-		idx = ir_emit_load(proc, ir_emit_struct_ep(proc, entry, 2));
-		val = ir_emit_load(proc, ir_emit_struct_ep(proc, entry, 3));
-
-		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 ir_build_range_string(irProcedure *proc, irValue *expr, Type *val_type,
-                            irValue **val_, irValue **idx_, irBlock **loop_, irBlock **done_) {
-	irValue *count = v_zero;
-	Type *expr_type = base_type(ir_type(expr));
-	switch (expr_type->kind) {
-	case Type_Basic:
-		count = ir_string_len(proc, expr);
-		break;
-	default:
-		GB_PANIC("Cannot do range_string of %s", type_to_string(expr_type));
-		break;
-	}
-
-	irValue *val = nullptr;
-	irValue *idx = nullptr;
-	irBlock *loop = nullptr;
-	irBlock *done = nullptr;
-	irBlock *body = nullptr;
-
-
-	irValue *offset_ = ir_add_local_generated(proc, t_int, false);
-	ir_emit_store(proc, offset_, v_zero);
-
-	loop = ir_new_block(proc, nullptr, "for.string.loop");
-	ir_emit_jump(proc, loop);
-	ir_start_block(proc, loop);
-
-
-
-	body = ir_new_block(proc, nullptr, "for.string.body");
-	done = ir_new_block(proc, nullptr, "for.string.done");
-
-	irValue *offset = ir_emit_load(proc, offset_);
-	irValue *cond = ir_emit_comp(proc, Token_Lt, offset, count);
-	ir_emit_if(proc, cond, body, done);
-	ir_start_block(proc, body);
-
-
-	irValue *str_elem = ir_emit_ptr_offset(proc, ir_string_elem(proc, expr), offset);
-	irValue *str_len  = ir_emit_arith(proc, Token_Sub, count, offset, t_int);
-	auto args = array_make<irValue *>(ir_allocator(), 1);
-	args[0] = ir_emit_string(proc, str_elem, str_len);
-	irValue *rune_and_len = ir_emit_runtime_call(proc, "string_decode_rune", args);
-	irValue *len  = ir_emit_struct_ev(proc, rune_and_len, 1);
-	ir_emit_store(proc, offset_, ir_emit_arith(proc, Token_Add, offset, len, t_int));
-
-
-	idx = offset;
-	if (val_type != nullptr) {
-		val = ir_emit_struct_ev(proc, rune_and_len, 0);
-	}
-
-	if (val_)  *val_  = val;
-	if (idx_)  *idx_  = idx;
-	if (loop_) *loop_ = loop;
-	if (done_) *done_ = done;
-}
-
-
-void ir_build_range_interval(irProcedure *proc, AstBinaryExpr *node, Type *val_type,
-                             irValue **val_, irValue **idx_, irBlock **loop_, irBlock **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?
-
-	irValue *lower = ir_build_expr(proc, node->left);
-	irValue *upper = nullptr;
-
-	irValue *val = nullptr;
-	irValue *idx = nullptr;
-	irBlock *loop = nullptr;
-	irBlock *done = nullptr;
-	irBlock *body = nullptr;
-
-	if (val_type == nullptr) {
-		val_type = ir_type(lower);
-	}
-	irValue *value = ir_add_local_generated(proc, val_type, false);
-	ir_emit_store(proc, value, lower);
-
-	irValue *index = ir_add_local_generated(proc, t_int, false);
-	ir_emit_store(proc, index, ir_const_int(0));
-
-	loop = ir_new_block(proc, nullptr, "for.interval.loop");
-	ir_emit_jump(proc, loop);
-	ir_start_block(proc, loop);
-
-	body = ir_new_block(proc, nullptr, "for.interval.body");
-	done = ir_new_block(proc, nullptr, "for.interval.done");
-
-
-	TokenKind op = Token_Lt;
-	switch (node->op.kind) {
-	case Token_Ellipsis:  op = Token_LtEq; break;
-	case Token_RangeHalf: op = Token_Lt;  break;
-	default: GB_PANIC("Invalid interval operator"); break;
-	}
-
-	upper = ir_build_expr(proc, node->right);
-
-	irValue *curr_value = ir_emit_load(proc, value);
-	irValue *cond = ir_emit_comp(proc, op, curr_value, upper);
-	ir_emit_if(proc, cond, body, done);
-	ir_start_block(proc, body);
-
-	if (value != nullptr) {
-		val = ir_emit_load(proc, value);
-	}
-	idx = ir_emit_load(proc, index);
-
-	ir_emit_increment(proc, value);
-	ir_emit_increment(proc, index);
-
-	if (val_)  *val_  = val;
-	if (idx_)  *idx_  = idx;
-	if (loop_) *loop_ = loop;
-	if (done_) *done_ = done;
-}
-
-void ir_build_range_enum(irProcedure *proc, Type *enum_type, Type *val_type, irValue **val_, irValue **idx_, irBlock **loop_, irBlock **done_) {
-	Type *t = enum_type;
-	GB_ASSERT(is_type_enum(t));
-	Type *enum_ptr = alloc_type_pointer(t);
-	t = base_type(t);
-	Type *core_elem = core_type(t);
-	GB_ASSERT(t->kind == Type_Enum);
-	i64 enum_count = t->Enum.fields.count;
-	irValue *max_count = ir_const_int(enum_count);
-
-	irValue *ti          = ir_type_info(proc, t);
-	irValue *variant     = ir_emit_struct_ep(proc, ti, 4);
-	irValue *eti_ptr     = ir_emit_conv(proc, variant, t_type_info_enum_ptr);
-	irValue *values      = ir_emit_load(proc, ir_emit_struct_ep(proc, eti_ptr, 2));
-	irValue *values_data = ir_slice_elem(proc, values);
-
-	irValue *offset_ = ir_add_local_generated(proc, t_int, false);
-	ir_emit_store(proc, offset_, v_zero);
-
-	irBlock *loop = ir_new_block(proc, nullptr, "for.enum.loop");
-	ir_emit_jump(proc, loop);
-	ir_start_block(proc, loop);
-
-	irBlock *body = ir_new_block(proc, nullptr, "for.enum.body");
-	irBlock *done = ir_new_block(proc, nullptr, "for.enum.done");
-
-	irValue *offset = ir_emit_load(proc, offset_);
-	irValue *cond = ir_emit_comp(proc, Token_Lt, offset, max_count);
-	ir_emit_if(proc, cond, body, done);
-	ir_start_block(proc, body);
-
-	irValue *val_ptr = ir_emit_ptr_offset(proc, values_data, offset);
-	ir_emit_increment(proc, offset_);
-
-	irValue *val = nullptr;
-	if (val_type != nullptr) {
-		GB_ASSERT(are_types_identical(enum_type, val_type));
-
-		if (is_type_integer(core_elem)) {
-			irValue *i = ir_emit_load(proc, val_ptr);
-			val = ir_emit_conv(proc, i, t);
-		} else {
-			GB_PANIC("TODO(bill): enum core type %s", type_to_string(core_elem));
-		}
-	}
-
-	if (val_)  *val_  = val;
-	if (idx_)  *idx_  = offset;
-	if (loop_) *loop_ = loop;
-	if (done_) *done_ = done;
-}
-
-void ir_build_range_tuple(irProcedure *proc, Ast *expr, Type *val0_type, Type *val1_type,
-                          irValue **val0_, irValue **val1_, irBlock **loop_, irBlock **done_) {
-	irBlock *loop = ir_new_block(proc, nullptr, "for.tuple.loop");
-	ir_emit_jump(proc, loop);
-	ir_start_block(proc, loop);
-
-	irBlock *body = ir_new_block(proc, nullptr, "for.tuple.body");
-	irBlock *done = ir_new_block(proc, nullptr, "for.tuple.done");
-
-	irValue *tuple_value = ir_build_expr(proc, expr);
-	Type *tuple = ir_type(tuple_value);
-	GB_ASSERT(tuple->kind == Type_Tuple);
-	i32 tuple_count = cast(i32)tuple->Tuple.variables.count;
-	i32 cond_index = tuple_count-1;
-
-	irValue *cond = ir_emit_struct_ev(proc, tuple_value, cond_index);
-	ir_emit_if(proc, cond, body, done);
-	ir_start_block(proc, body);
-
-	irValue *val0 = nullptr;
-
-
-	if (val0_) *val0_ = ir_emit_struct_ev(proc, tuple_value, 0);
-	if (val1_) *val1_ = ir_emit_struct_ev(proc, tuple_value, 1);
-	if (loop_) *loop_ = loop;
-	if (done_) *done_ = done;
-}
-
-
-void ir_store_type_case_implicit(irProcedure *proc, Ast *clause, irValue *value) {
-	Entity *e = implicit_entity_of_node(clause);
-	GB_ASSERT(e != nullptr);
-
-	if (e->flags & EntityFlag_Value) {
-		// by value
-		irValue *x = ir_add_local(proc, e, nullptr, false);
-		GB_ASSERT(are_types_identical(ir_type(value), e->type));
-		ir_emit_store(proc, x, value);
-	} else {
-		// by reference
-		ir_module_add_value(proc->module, e, value);
-	}
-}
-
-irAddr ir_store_range_stmt_val(irProcedure *proc, Ast *stmt_val, irValue *value) {
-	Entity *e = entity_of_node(stmt_val);
-	if (e == nullptr) {
-		return {};
-	}
-
-	if ((e->flags & EntityFlag_Value) == 0) {
-		if (value->kind == irValue_Instr) {
-			if (value->Instr.kind == irInstr_Load) {
-				irValue *ptr = value->Instr.Load.address;
-				Type *vt = type_deref(ir_type(ptr));
-				if (!are_types_identical(vt, e->type)) {
-					GB_ASSERT(are_types_identical(base_type(vt), base_type(e->type)));
-					ptr = ir_emit_conv(proc, ptr, alloc_type_pointer(e->type));
-				}
-
-				ir_module_add_value(proc->module, e, ptr);
-				return ir_addr(ptr);
-			}
-		}
-	}
-
-	// by value
-	irAddr addr = ir_addr(ir_add_local(proc, e, nullptr, false));
-	Type *vt = ir_type(value);
-	Type *base_et = base_type(e->type);
-	Type *base_vt = base_type(vt);
-	if (!are_types_identical(e->type, vt)) {
-		if (are_types_identical(base_et, base_vt)) {
-			value = ir_emit_conv(proc, value, e->type);
-		} else {
-			// gb_printf_err("%s\n", expr_to_string(stmt_val));
-			// gb_printf_err("Entity: %s -> Value: %s\n", type_to_string(e->type), type_to_string(vt));
-			// Token tok = ast_token(stmt_val);
-		}
-	}
-	ir_addr_store(proc, addr, value);
-	return addr;
-}
-
-void ir_type_case_body(irProcedure *proc, Ast *label, Ast *clause, irBlock *body, irBlock *done) {
-	ast_node(cc, CaseClause, clause);
-
-	ir_push_target_list(proc, label, done, nullptr, nullptr);
-	ir_open_scope(proc);
-	ir_build_stmt_list(proc, cc->stmts);
-	ir_close_scope(proc, irDeferExit_Default, body);
-	ir_pop_target_list(proc);
-
-	ir_emit_jump(proc, done);
-}
-
-
-void ir_build_stmt_internal(irProcedure *proc, Ast *node) {
-	switch (node->kind) {
-	case_ast_node(bs, EmptyStmt, node);
-	case_end;
-
-	case_ast_node(us, UsingStmt, node);
-	case_end;
-
-	case_ast_node(ws, WhenStmt, node);
-		ir_build_when_stmt(proc, ws);
-	case_end;
-
-	case_ast_node(vd, ValueDecl, node);
-		if (vd->is_mutable) {
-			irModule *m = proc->module;
-
-			bool is_static = false;
-			if (vd->names.count > 0) {
-				Entity *e = entity_of_node(vd->names[0]);
-				if (e->flags & EntityFlag_Static) {
-					// NOTE(bill): If one of the entities is static, they all are
-					is_static = true;
-				}
-			}
-
-			if (is_static) {
-				for_array(i, vd->names) {
-					irValue *value = nullptr;
-					if (vd->values.count > 0) {
-						GB_ASSERT(vd->names.count == vd->values.count);
-						Ast *ast_value = vd->values[i];
-						GB_ASSERT(ast_value->tav.mode == Addressing_Constant ||
-						          ast_value->tav.mode == Addressing_Invalid);
-
-						value = ir_add_module_constant(m, ast_value->tav.type, ast_value->tav.value);
-					}
-
-					Ast *ident = vd->names[i];
-					GB_ASSERT(!is_blank_ident(ident));
-					Entity *e = entity_of_node(ident);
-					GB_ASSERT(e->flags & EntityFlag_Static);
-					String name = e->token.string;
-
-					String mangled_name = {};
-					{
-						gbString str = gb_string_make_length(permanent_allocator(), proc->name.text, proc->name.len);
-						str = gb_string_appendc(str, "-");
-						str = gb_string_append_fmt(str, ".%.*s-%llu", LIT(name), cast(long long)e->id);
-						mangled_name.text = cast(u8 *)str;
-						mangled_name.len = gb_string_length(str);
-					}
-
-					ir_add_entity_name(m, e, mangled_name);
-
-					irValue *g = ir_value_global(e, value);
-					g->Global.name = mangled_name;
-					g->Global.is_private = true;
-					if (e->Variable.thread_local_model != "") {
-						g->Global.thread_local_model = e->Variable.thread_local_model;
-					} else {
-						g->Global.is_internal = true;
-					}
-					ir_module_add_value(proc->module, e, g);
-					string_map_set(&proc->module->members, mangled_name, g);
-				}
-				return;
-			}
-
-			gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena);
-			defer (gb_temp_arena_memory_end(tmp));
-
-			if (vd->values.count == 0) { // declared and zero-initialized
-				for_array(i, vd->names) {
-					Ast *name = vd->names[i];
-					if (!is_blank_ident(name)) {
-						ir_add_local_for_identifier(proc, name, true);
-					}
-				}
-			} else { // Tuple(s)
-				auto lvals = array_make<irAddr>(m->tmp_allocator, 0, vd->names.count);
-				auto inits = array_make<irValue *>(m->tmp_allocator, 0, vd->names.count);
-
-				for_array(i, vd->names) {
-					Ast *name = vd->names[i];
-					irAddr lval = ir_addr(nullptr);
-					if (!is_blank_ident(name)) {
-						// NOTE(bill, 2020-06-10): This must be zero initialize because of weird LLVM optimization behaviours
-						ir_add_local_for_identifier(proc, name, true);
-						lval = ir_build_addr(proc, name);
-					}
-					array_add(&lvals, lval);
-				}
-
-				for_array(i, vd->values) {
-					irValue *init = ir_build_expr(proc, vd->values[i]);
-					Type *t = ir_type(init);
-					if (t->kind == Type_Tuple) {
-						for_array(i, t->Tuple.variables) {
-							Entity *e = t->Tuple.variables[i];
-							irValue *v = ir_emit_struct_ev(proc, init, cast(i32)i);
-							array_add(&inits, v);
-						}
-					} else {
-						array_add(&inits, init);
-					}
-				}
-
-
-				for_array(i, inits) {
-					ir_addr_store(proc, lvals[i], inits[i]);
-				}
-			}
-		}
-	case_end;
-
-	case_ast_node(as, AssignStmt, node);
-		ir_emit_comment(proc, str_lit("AssignStmt"));
-
-		irModule *m = proc->module;
-		gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena);
-
-		switch (as->op.kind) {
-		case Token_Eq: {
-			auto lvals = array_make<irAddr>(m->tmp_allocator, 0, as->lhs.count);
-
-			for_array(i, as->lhs) {
-				Ast *lhs = as->lhs[i];
-				irAddr lval = {};
-				if (!is_blank_ident(lhs)) {
-					lval = ir_build_addr(proc, lhs);
-				}
-				array_add(&lvals, lval);
-			}
-
-			if (as->lhs.count == as->rhs.count) {
-				if (as->lhs.count == 1) {
-					Ast *rhs = as->rhs[0];
-					irValue *init = ir_build_expr(proc, rhs);
-					ir_addr_store(proc, lvals[0], init);
-				} else {
-					auto inits = array_make<irValue *>(m->tmp_allocator, 0, lvals.count);
-
-					for_array(i, as->rhs) {
-						irValue *init = ir_build_expr(proc, as->rhs[i]);
-						array_add(&inits, init);
-					}
-
-					for_array(i, inits) {
-						auto lval = lvals[i];
-						ir_addr_store(proc, lval, inits[i]);
-					}
-				}
-			} else {
-				auto inits = array_make<irValue *>(m->tmp_allocator, 0, lvals.count);
-
-				for_array(i, as->rhs) {
-					irValue *init = ir_build_expr(proc, as->rhs[i]);
-					Type *t = ir_type(init);
-					// TODO(bill): refactor for code reuse as this is repeated a bit
-					if (t->kind == Type_Tuple) {
-						for_array(i, t->Tuple.variables) {
-							Entity *e = t->Tuple.variables[i];
-							irValue *v = ir_emit_struct_ev(proc, init, cast(i32)i);
-							array_add(&inits, v);
-						}
-					} else {
-						array_add(&inits, init);
-					}
-				}
-
-				for_array(i, inits) {
-					ir_addr_store(proc, lvals[i], inits[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 +
-			if (op == Token_CmpAnd || op == Token_CmpOr) {
-				Type *type = as->lhs[0]->tav.type;
-				irValue *new_value = ir_emit_logical_binary_expr(proc, cast(TokenKind)op, as->lhs[0], as->rhs[0], type);
-
-				irAddr lhs = ir_build_addr(proc, as->lhs[0]);
-				ir_addr_store(proc, lhs, new_value);
-			} else {
-				irAddr lhs = ir_build_addr(proc, as->lhs[0]);
-				irValue *value = ir_build_expr(proc, as->rhs[0]);
-				ir_build_assign_op(proc, lhs, value, cast(TokenKind)op);
-			}
-			return;
-		}
-		}
-	case_end;
-
-	case_ast_node(es, ExprStmt, node);
-		// NOTE(bill): No need to use return value
-		ir_build_expr(proc, es->expr);
-	case_end;
-
-	case_ast_node(bs, BlockStmt, node);
-		if (bs->label != nullptr) {
-			irBlock *done = ir_new_block(proc, node, "block.done");
-			irTargetList *tl = ir_push_target_list(proc, bs->label, done, nullptr, nullptr);
-			tl->is_block = true;
-
-			ir_open_scope(proc);
-			ir_build_stmt_list(proc, bs->stmts);
-			ir_close_scope(proc, irDeferExit_Default, nullptr);
-
-			ir_emit_jump(proc, done);
-			ir_start_block(proc, done);
-
-		} else {
-			ir_open_scope(proc);
-			ir_build_stmt_list(proc, bs->stmts);
-			ir_close_scope(proc, irDeferExit_Default, nullptr);
-		}
-	case_end;
-
-	case_ast_node(ds, DeferStmt, node);
-		ir_emit_comment(proc, str_lit("DeferStmt"));
-		isize scope_index = proc->scope_index;
-		// TODO(bill): What was the original rationale behind this line?
-		// if (ds->stmt->kind == Ast_BlockStmt) scope_index--;
-		ir_add_defer_node(proc, scope_index, ds->stmt);
-	case_end;
-
-	case_ast_node(rs, ReturnStmt, node);
-		ir_emit_comment(proc, str_lit("ReturnStmt"));
-		irValue *v = nullptr;
-		TypeTuple *tuple  = &proc->type->Proc.results->Tuple;
-		isize return_count = proc->type->Proc.result_count;
-		isize res_count = rs->results.count;
-
-		if (return_count == 0) {
-			// No return values
-		} else if (return_count == 1) {
-			Entity *e = tuple->variables[0];
-			if (res_count == 0) {
-				irValue **found = map_get(&proc->module->values, hash_entity(e));
-				GB_ASSERT(found);
-				v = ir_emit_load(proc, *found);
-			} else {
-				v = ir_build_expr(proc, rs->results[0]);
-				v = ir_emit_conv(proc, v, e->type);
-			}
-			if (proc->type->Proc.has_named_results) {
-				// NOTE(bill): store the named values before returning
-				if (e->token.string != "") {
-					irValue **found = map_get(&proc->module->values, hash_entity(e));
-					GB_ASSERT(found != nullptr);
-					ir_emit_store(proc, *found, v);
-				}
-			}
-		} else {
-			gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena);
-			defer (gb_temp_arena_memory_end(tmp));
-
-			auto results = array_make<irValue *>(proc->module->tmp_allocator, 0, return_count);
-
-			if (res_count != 0) {
-				for (isize res_index = 0; res_index < res_count; res_index++) {
-					irValue *res = ir_build_expr(proc, rs->results[res_index]);
-					Type *t = ir_type(res);
-					if (t->kind == Type_Tuple) {
-						for_array(i, t->Tuple.variables) {
-							Entity *e = t->Tuple.variables[i];
-							irValue *v = ir_emit_struct_ev(proc, res, cast(i32)i);
-							array_add(&results, v);
-						}
-					} else {
-						array_add(&results, res);
-					}
-				}
-			} else {
-				for (isize res_index = 0; res_index < return_count; res_index++) {
-					Entity *e = tuple->variables[res_index];
-					irValue **found = map_get(&proc->module->values, hash_entity(e));
-					GB_ASSERT(found);
-					irValue *res = ir_emit_load(proc, *found);
-					array_add(&results, res);
-				}
-			}
-
-			GB_ASSERT(results.count == return_count);
-
-			if (proc->type->Proc.has_named_results) {
-				// NOTE(bill): store the named values before returning
-				for_array(i, tuple->variables) {
-					Entity *e = tuple->variables[i];
-					if (e->kind != Entity_Variable) {
-						continue;
-					}
-
-					if (e->token.string == "") {
-						continue;
-					}
-					irValue **found = map_get(&proc->module->values, hash_entity(e));
-					GB_ASSERT(found != nullptr);
-					ir_emit_store(proc, *found, ir_emit_conv(proc, results[i], e->type));
-				}
-			}
-
-			Type *ret_type = proc->type->Proc.results;
-			// NOTE(bill): Doesn't need to be zero because it will be initialized in the loops
-			v = ir_add_local_generated(proc, ret_type, false);
-			for_array(i, results) {
-				Entity *e = tuple->variables[i];
-				irValue *res = ir_emit_conv(proc, results[i], e->type);
-				irValue *field = ir_emit_struct_ep(proc, v, cast(i32)i);
-				ir_emit_store(proc, field, res);
-			}
-
-			v = ir_emit_load(proc, v);
-		}
-
-		ir_emit_return(proc, v);
-
-	case_end;
-
-	case_ast_node(is, IfStmt, node);
-		ir_emit_comment(proc, str_lit("IfStmt"));
-		ir_open_scope(proc); // Scope #1
-
-		if (is->init != nullptr) {
-			// TODO(bill): Should this have a separate block to begin with?
-		#if 1
-			irBlock *init = ir_new_block(proc, node, "if.init");
-			ir_emit_jump(proc, init);
-			ir_start_block(proc, init);
-		#endif
-			ir_build_stmt(proc, is->init);
-		}
-		irBlock *then = ir_new_block(proc, node, "if.then");
-		irBlock *done = ir_new_block(proc, node, "if.done");
-		irBlock *else_ = done;
-		if (is->else_stmt != nullptr) {
-			else_ = ir_new_block(proc, is->else_stmt, "if.else");
-		}
-
-		ir_build_cond(proc, is->cond, then, else_);
-		ir_start_block(proc, then);
-
-		if (is->label != nullptr) {
-			irTargetList *tl = ir_push_target_list(proc, is->label, done, nullptr, nullptr);
-			tl->is_block = true;
-		}
-
-		// ir_open_scope(proc);
-		ir_build_stmt(proc, is->body);
-		// ir_close_scope(proc, irDeferExit_Default, nullptr);
-
-		ir_emit_jump(proc, done);
-
-		if (is->else_stmt != nullptr) {
-			ir_start_block(proc, else_);
-
-			ir_open_scope(proc);
-			ir_build_stmt(proc, is->else_stmt);
-			ir_close_scope(proc, irDeferExit_Default, nullptr);
-
-			ir_emit_jump(proc, done);
-		}
-
-
-		ir_start_block(proc, done);
-		ir_close_scope(proc, irDeferExit_Default, nullptr);
-
-	case_end;
-
-	case_ast_node(fs, ForStmt, node);
-		ir_emit_comment(proc, str_lit("ForStmt"));
-		ir_open_scope(proc); // Open Scope here
-
-		if (fs->init != nullptr) {
-		#if 1
-			irBlock *init = ir_new_block(proc, node, "for.init");
-			ir_emit_jump(proc, init);
-			ir_start_block(proc, init);
-		#endif
-			ir_build_stmt(proc, fs->init);
-		}
-		irBlock *body = ir_new_block(proc, node, "for.body");
-		irBlock *done = ir_new_block(proc, node, "for.done"); // NOTE(bill): Append later
-		irBlock *loop = body;
-		if (fs->cond != nullptr) {
-			loop = ir_new_block(proc, node, "for.loop");
-		}
-		irBlock *post = loop;
-		if (fs->post != nullptr) {
-			post = ir_new_block(proc, node, "for.post");
-		}
-
-
-		ir_emit_jump(proc, loop);
-		ir_start_block(proc, loop);
-
-		if (loop != body) {
-			ir_build_cond(proc, fs->cond, body, done);
-			ir_start_block(proc, body);
-		}
-
-		ir_push_target_list(proc, fs->label, done, post, nullptr);
-
-		ir_build_stmt(proc, fs->body);
-		ir_close_scope(proc, irDeferExit_Default, nullptr);
-
-		ir_pop_target_list(proc);
-
-		ir_emit_jump(proc, post);
-
-		if (fs->post != nullptr) {
-			ir_start_block(proc, post);
-			ir_build_stmt(proc, fs->post);
-			ir_emit_jump(proc, loop);
-		}
-
-		ir_start_block(proc, done);
-	case_end;
-
-
-	case_ast_node(rs, RangeStmt, node);
-		ir_emit_comment(proc, str_lit("RangeStmt"));
-		ir_open_scope(proc); // Open scope here
-
-		Type *val0_type = nullptr;
-		Type *val1_type = nullptr;
-		if (rs->vals.count > 0 && rs->vals[0] != nullptr && !is_blank_ident(rs->vals[0])) {
-			val0_type = type_of_expr(rs->vals[0]);
-		}
-		if (rs->vals.count > 1 && rs->vals[1] != nullptr && !is_blank_ident(rs->vals[1])) {
-			val1_type = type_of_expr(rs->vals[1]);
-		}
-
-		if (val0_type != nullptr) {
-			ir_add_local_for_identifier(proc, rs->vals[0], true);
-		}
-		if (val1_type != nullptr) {
-			ir_add_local_for_identifier(proc, rs->vals[1], true);
-		}
-
-		irValue *val = nullptr;
-		irValue *key = nullptr;
-		irBlock *loop = nullptr;
-		irBlock *done = nullptr;
-		Ast *expr = unparen_expr(rs->expr);
-		bool is_map = false;
-
-		TypeAndValue tav = type_and_value_of_expr(expr);
-
-		if (is_ast_range(expr)) {
-			ir_build_range_interval(proc, &expr->BinaryExpr, val0_type, &val, &key, &loop, &done);
-		} else if (tav.mode == Addressing_Type) {
-			ir_build_range_enum(proc, type_deref(tav.type), val0_type, &val, &key, &loop, &done);
-		} else {
-			Type *expr_type = type_of_expr(expr);
-			Type *et = base_type(type_deref(expr_type));
-			switch (et->kind) {
-			case Type_Map: {
-				is_map = true;
-				gbAllocator a = ir_allocator();
-				irAddr addr = ir_build_addr(proc, expr);
-				bool allow_reference = true;
-				irValue *map = ir_addr_get_ptr(proc, addr, allow_reference);
-				if (is_type_pointer(ir_addr_type(addr))) {
-					map = ir_addr_load(proc, addr);
-				}
-				irValue *entries_ptr = ir_map_entries_ptr(proc, map);
-				irValue *count_ptr = ir_emit_struct_ep(proc, entries_ptr, 1);
-				ir_build_range_indexed(proc, map, val1_type, count_ptr, &val, &key, &loop, &done);
-				break;
-			}
-			case Type_Array: {
-				irValue *count_ptr = nullptr;
-				irValue *array = ir_build_addr_ptr(proc, expr);
-				if (is_type_pointer(type_deref(ir_type(array)))) {
-					array = ir_emit_load(proc, array);
-				}
-				count_ptr = ir_add_local_generated(proc, t_int, false);
-				ir_emit_store(proc, count_ptr, ir_const_int(et->Array.count));
-				ir_build_range_indexed(proc, array, val0_type, count_ptr, &val, &key, &loop, &done);
-				break;
-			}
-			case Type_EnumeratedArray: {
-				irValue *count_ptr = nullptr;
-				irValue *array = ir_build_addr_ptr(proc, expr);
-				if (is_type_pointer(type_deref(ir_type(array)))) {
-					array = ir_emit_load(proc, array);
-				}
-				count_ptr = ir_add_local_generated(proc, t_int, false);
-				ir_emit_store(proc, count_ptr, ir_const_int(et->EnumeratedArray.count));
-				ir_build_range_indexed(proc, array, val0_type, count_ptr, &val, &key, &loop, &done);
-				break;
-			}
-			case Type_DynamicArray: {
-				irValue *count_ptr = nullptr;
-				irValue *array = ir_build_addr_ptr(proc, expr);
-				if (is_type_pointer(type_deref(ir_type(array)))) {
-					array = ir_emit_load(proc, array);
-				}
-				count_ptr = ir_emit_struct_ep(proc, array, 1);
-				ir_build_range_indexed(proc, array, val0_type, count_ptr, &val, &key, &loop, &done);
-				break;
-			}
-			case Type_Slice: {
-				irValue *count_ptr = nullptr;
-				irValue *slice = ir_build_expr(proc, expr);
-				if (is_type_pointer(ir_type(slice))) {
-					count_ptr = ir_emit_struct_ep(proc, slice, 1);
-					slice = ir_emit_load(proc, slice);
-				} else {
-					count_ptr = ir_add_local_generated(proc, t_int, false);
-					ir_emit_store(proc, count_ptr, ir_slice_len(proc, slice));
-				}
-				ir_build_range_indexed(proc, slice, val0_type, count_ptr, &val, &key, &loop, &done);
-				break;
-			}
-			case Type_Basic: {
-				irValue *string = ir_build_expr(proc, expr);
-				if (is_type_pointer(ir_type(string))) {
-					string = ir_emit_load(proc, string);
-				}
-				if (is_type_untyped(expr_type)) {
-					irValue *s = ir_add_local_generated(proc, default_type(ir_type(string)), false);
-					ir_emit_store(proc, s, string);
-					string = ir_emit_load(proc, s);
-				}
-				Type *t = base_type(ir_type(string));
-				GB_ASSERT(!is_type_cstring(t));
-				ir_build_range_string(proc, string, val0_type, &val, &key, &loop, &done);
-				break;
-			}
-			case Type_Tuple:
-				ir_build_range_tuple(proc, expr, val0_type, val1_type, &val, &key, &loop, &done);
-				break;
-			default:
-				GB_PANIC("Cannot range over %s", type_to_string(expr_type));
-				break;
-			}
-		}
-
-
-		if (is_map) {
-			if (val0_type) ir_store_range_stmt_val(proc, rs->vals[0], key);
-			if (val1_type) ir_store_range_stmt_val(proc, rs->vals[1], val);
-		} else {
-			if (val0_type) ir_store_range_stmt_val(proc, rs->vals[0], val);
-			if (val1_type) ir_store_range_stmt_val(proc, rs->vals[1], key);
-		}
-
-		ir_push_target_list(proc, rs->label, done, loop, nullptr);
-
-		ir_build_stmt(proc, rs->body);
-		ir_close_scope(proc, irDeferExit_Default, nullptr);
-
-		ir_pop_target_list(proc);
-		ir_emit_jump(proc, loop);
-		ir_start_block(proc, done);
-	case_end;
-
-	case_ast_node(rs, UnrollRangeStmt, node);
-		ir_emit_comment(proc, str_lit("UnrollRangeStmt"));
-		ir_open_scope(proc); // Open scope here
-
-		irBlock *done = ir_new_block(proc, node, "inline.for.done");
-
-		Type *val0_type = nullptr;
-		Type *val1_type = nullptr;
-		if (rs->val0 != nullptr && !is_blank_ident(rs->val0)) {
-			val0_type = type_of_expr(rs->val0);
-		}
-		if (rs->val1 != nullptr && !is_blank_ident(rs->val1)) {
-			val1_type = type_of_expr(rs->val1);
-		}
-
-		if (val0_type != nullptr) {
-			ir_add_local_for_identifier(proc, rs->val0, true);
-		}
-		if (val1_type != nullptr) {
-			ir_add_local_for_identifier(proc, rs->val1, true);
-		}
-
-		irValue *val = nullptr;
-		irValue *key = nullptr;
-		Ast *expr = unparen_expr(rs->expr);
-
-		TypeAndValue tav = type_and_value_of_expr(expr);
-
-		if (is_ast_range(expr)) {
-
-			irAddr val0_addr = {};
-			irAddr val1_addr = {};
-			if (val0_type) val0_addr = ir_build_addr(proc, rs->val0);
-			if (val1_type) val1_addr = ir_build_addr(proc, rs->val1);
-
-			TokenKind op = expr->BinaryExpr.op.kind;
-			Ast *start_expr = expr->BinaryExpr.left;
-			Ast *end_expr   = expr->BinaryExpr.right;
-			GB_ASSERT(start_expr->tav.mode == Addressing_Constant);
-			GB_ASSERT(end_expr->tav.mode == Addressing_Constant);
-
-			ExactValue start = start_expr->tav.value;
-			ExactValue end   = end_expr->tav.value;
-			if (op == Token_Ellipsis) { // .. [start, end]
-				ExactValue index = exact_value_i64(0);
-				for (ExactValue val = start;
-				     compare_exact_values(Token_LtEq, val, end);
-				     val = exact_value_increment_one(val), index = exact_value_increment_one(index)) {
-
-					irBlock *body = ir_new_block(proc, node, "inline.for.body");
-					ir_emit_jump(proc, body);
-
-					if (val0_type) ir_addr_store(proc, val0_addr, ir_value_constant(val0_type, val));
-					if (val1_type) ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, index));
-					ir_start_block(proc, body);
-
-					ir_build_stmt(proc, rs->body);
-				}
-			} else if (op == Token_RangeHalf) { // ..< [start, end)
-				ExactValue index = exact_value_i64(0);
-				for (ExactValue val = start;
-				     compare_exact_values(Token_Lt, val, end);
-				     val = exact_value_increment_one(val), index = exact_value_increment_one(index)) {
-
-					irBlock *body = ir_new_block(proc, node, "inline.for.body");
-					ir_emit_jump(proc, body);
-					ir_start_block(proc, body);
-
-					if (val0_type) ir_addr_store(proc, val0_addr, ir_value_constant(val0_type, val));
-					if (val1_type) ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, index));
-
-
-					ir_build_stmt(proc, rs->body);
-				}
-			}
-		} else if (tav.mode == Addressing_Type) {
-			GB_ASSERT(is_type_enum(type_deref(tav.type)));
-			Type *et = type_deref(tav.type);
-			Type *bet = base_type(et);
-
-			irAddr val0_addr = {};
-			irAddr val1_addr = {};
-			if (val0_type) val0_addr = ir_build_addr(proc, rs->val0);
-			if (val1_type) val1_addr = ir_build_addr(proc, rs->val1);
-
-			for_array(i, bet->Enum.fields) {
-				irBlock *body = ir_new_block(proc, node, "inline.for.body");
-				ir_emit_jump(proc, body);
-				ir_start_block(proc, body);
-
-				Entity *field = bet->Enum.fields[i];
-				GB_ASSERT(field->kind == Entity_Constant);
-				if (val0_type) ir_addr_store(proc, val0_addr, ir_value_constant(val0_type, field->Constant.value));
-				if (val1_type) ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, exact_value_i64(i)));
-
-				ir_build_stmt(proc, rs->body);
-			}
-		} else {
-			irAddr val0_addr = {};
-			irAddr val1_addr = {};
-			if (val0_type) val0_addr = ir_build_addr(proc, rs->val0);
-			if (val1_type) val1_addr = ir_build_addr(proc, rs->val1);
-
-			GB_ASSERT(expr->tav.mode == Addressing_Constant);
-
-			Type *t = base_type(expr->tav.type);
-
-
-			switch (t->kind) {
-			case Type_Basic:
-				GB_ASSERT(is_type_string(t));
-				{
-					ExactValue value = expr->tav.value;
-					GB_ASSERT(value.kind == ExactValue_String);
-					String str = value.value_string;
-					Rune codepoint = 0;
-					isize offset = 0;
-					do {
-						irBlock *body = ir_new_block(proc, node, "inline.for.body");
-						ir_emit_jump(proc, body);
-						ir_start_block(proc, body);
-
-						isize width = gb_utf8_decode(str.text+offset, str.len-offset, &codepoint);
-						if (val0_type) ir_addr_store(proc, val0_addr, ir_value_constant(val0_type, exact_value_i64(codepoint)));
-						if (val1_type) ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, exact_value_i64(offset)));
-						ir_build_stmt(proc, rs->body);
-
-						offset += width;
-					} while (offset < str.len);
-				}
-				break;
-			case Type_Array:
-				if (t->Array.count > 0) {
-					irValue *val = ir_build_expr(proc, expr);
-					irValue *val_addr = ir_address_from_load_or_generate_local(proc, val);
-
-					for (i64 i = 0; i < t->Array.count; i++) {
-						irBlock *body = ir_new_block(proc, node, "inline.for.body");
-						ir_emit_jump(proc, body);
-						ir_start_block(proc, body);
-
-						if (val0_type) {
-							// NOTE(bill): Due to weird legacy issues in LLVM, this needs to be an i32
-							irValue *elem = ir_emit_array_epi(proc, val_addr, cast(i32)i);
-							ir_addr_store(proc, val0_addr, ir_emit_load(proc, elem));
-						}
-						if (val1_type) ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, exact_value_i64(i)));
-
-						ir_build_stmt(proc, rs->body);
-					}
-
-				}
-				break;
-			case Type_EnumeratedArray:
-				if (t->EnumeratedArray.count > 0) {
-					irValue *val = ir_build_expr(proc, expr);
-					irValue *val_addr = ir_address_from_load_or_generate_local(proc, val);
-
-					for (i64 i = 0; i < t->EnumeratedArray.count; i++) {
-						irBlock *body = ir_new_block(proc, node, "inline.for.body");
-						ir_emit_jump(proc, body);
-						ir_start_block(proc, body);
-
-						if (val0_type) {
-							// NOTE(bill): Due to weird legacy issues in LLVM, this needs to be an i32
-							irValue *elem = ir_emit_array_epi(proc, val_addr, cast(i32)i);
-							ir_addr_store(proc, val0_addr, ir_emit_load(proc, elem));
-						}
-						if (val1_type) {
-							ExactValue idx = exact_value_add(exact_value_i64(i), t->EnumeratedArray.min_value);
-							ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, idx));
-						}
-
-						ir_build_stmt(proc, rs->body);
-					}
-
-				}
-				break;
-			default:
-				GB_PANIC("Invalid '#unroll for' type");
-				break;
-			}
-		}
-
-		ir_emit_jump(proc, done);
-		ir_start_block(proc, done);
-
-		ir_close_scope(proc, irDeferExit_Default, nullptr);
-	case_end;
-
-	case_ast_node(ss, SwitchStmt, node);
-		ir_emit_comment(proc, str_lit("SwitchStmt"));
-		if (ss->init != nullptr) {
-			ir_build_stmt(proc, ss->init);
-		}
-		irValue *tag = v_true;
-		if (ss->tag != nullptr) {
-			tag = ir_build_expr(proc, ss->tag);
-		}
-		irBlock *done = ir_new_block(proc, node, "switch.done"); // NOTE(bill): Append later
-
-		ast_node(body, BlockStmt, ss->body);
-
-		Slice<Ast *> default_stmts = {};
-		irBlock *default_fall = nullptr;
-		irBlock *default_block = nullptr;
-
-		irBlock *fall = nullptr;
-		bool append_fall = false;
-
-		isize case_count = body->stmts.count;
-		for_array(i, body->stmts) {
-			Ast *clause = body->stmts[i];
-			irBlock *body = fall;
-
-			ast_node(cc, CaseClause, clause);
-
-			if (body == nullptr) {
-				if (cc->list.count == 0) {
-					body = ir_new_block(proc, clause, "switch.dflt.body");
-				} else {
-					body = ir_new_block(proc, clause, "switch.case.body");
-				}
-			}
-			if (append_fall && body == fall) {
-				append_fall = false;
-			}
-
-			fall = done;
-			if (i+1 < case_count) {
-				append_fall = true;
-				fall = ir_new_block(proc, clause, "switch.fall.body");
-			}
-
-			if (cc->list.count == 0) {
-				// default case
-				default_stmts = cc->stmts;
-				default_fall  = fall;
-				default_block = body;
-				continue;
-			}
-
-			irBlock *next_cond = nullptr;
-			for_array(j, cc->list) {
-				Ast *expr = unparen_expr(cc->list[j]);
-				next_cond = ir_new_block(proc, clause, "switch.case.next");
-				irValue *cond = v_false;
-				if (is_ast_range(expr)) {
-					ast_node(ie, BinaryExpr, expr);
-					TokenKind op = Token_Invalid;
-					switch (ie->op.kind) {
-					case Token_Ellipsis:  op = Token_LtEq; break;
-					case Token_RangeHalf: op = Token_Lt;   break;
-					default: GB_PANIC("Invalid interval operator"); break;
-					}
-					irValue *lhs = ir_build_expr(proc, ie->left);
-					irValue *rhs = ir_build_expr(proc, ie->right);
-					// TODO(bill): do short circuit here
-					irValue *cond_lhs = ir_emit_comp(proc, Token_LtEq, lhs, tag);
-					irValue *cond_rhs = ir_emit_comp(proc, op, tag, rhs);
-					cond = ir_emit_arith(proc, Token_And, cond_lhs, cond_rhs, t_bool);
-				} else {
-					if (expr->tav.mode == Addressing_Type) {
-						GB_ASSERT(is_type_typeid(ir_type(tag)));
-						irValue *e = ir_typeid(proc->module, expr->tav.type);
-						e = ir_emit_conv(proc, e, ir_type(tag));
-						cond = ir_emit_comp(proc, Token_CmpEq, tag, e);
-					} else {
-						cond = ir_emit_comp(proc, Token_CmpEq, tag, ir_build_expr(proc, expr));
-					}
-				}
-				ir_emit_if(proc, cond, body, next_cond);
-				ir_start_block(proc, next_cond);
-			}
-			ir_start_block(proc, body);
-
-			ir_push_target_list(proc, ss->label, done, nullptr, fall);
-			ir_open_scope(proc);
-			ir_build_stmt_list(proc, cc->stmts);
-			ir_close_scope(proc, irDeferExit_Default, body);
-			ir_pop_target_list(proc);
-
-			ir_emit_jump(proc, done);
-			proc->curr_block = next_cond;
-			// ir_start_block(proc, next_cond);
-		}
-
-		if (default_block != nullptr) {
-			ir_emit_jump(proc, default_block);
-			ir_start_block(proc, default_block);
-
-			ir_push_target_list(proc, ss->label, done, nullptr, default_fall);
-			ir_open_scope(proc);
-			ir_build_stmt_list(proc, default_stmts);
-			ir_close_scope(proc, irDeferExit_Default, default_block);
-			ir_pop_target_list(proc);
-		}
-		ir_emit_jump(proc, done);
-		ir_start_block(proc, done);
-	case_end;
-
-
-	case_ast_node(ss, TypeSwitchStmt, node);
-		ir_emit_comment(proc, str_lit("TypeSwitchStmt"));
-		gbAllocator allocator = ir_allocator();
-
-		ast_node(as, AssignStmt, ss->tag);
-		GB_ASSERT(as->lhs.count == 1);
-		GB_ASSERT(as->rhs.count == 1);
-
-		irValue *parent = ir_build_expr(proc, as->rhs[0]);
-		Type *parent_type = ir_type(parent);
-		bool is_parent_ptr = is_type_pointer(ir_type(parent));
-
-		TypeSwitchKind switch_kind = check_valid_type_switch_type(ir_type(parent));
-		GB_ASSERT(switch_kind != TypeSwitch_Invalid);
-
-		irValue *parent_value = parent;
-
-		irValue *parent_ptr = parent;
-		if (!is_parent_ptr) {
-			parent_ptr = ir_address_from_load_or_generate_local(proc, parent_ptr);
-		}
-
-		irValue *tag_index = nullptr;
-		irValue *union_data = nullptr;
-		if (switch_kind == TypeSwitch_Union) {
-			ir_emit_comment(proc, str_lit("get union's tag"));
-			tag_index = ir_emit_load(proc, ir_emit_union_tag_ptr(proc, parent_ptr));
-			union_data = ir_emit_conv(proc, parent_ptr, t_rawptr);
-		}
-
-		irBlock *start_block = ir_new_block(proc, node, "typeswitch.case.first");
-		ir_emit_jump(proc, start_block);
-		ir_start_block(proc, start_block);
-
-		// NOTE(bill): Append this later
-		irBlock *done = ir_new_block(proc, node, "typeswitch.done");
-		Ast *default_ = nullptr;
-
-		ast_node(body, BlockStmt, ss->body);
-
-		gb_local_persist i32 weird_count = 0;
-
-		for_array(i, body->stmts) {
-			Ast *clause = body->stmts[i];
-			ast_node(cc, CaseClause, clause);
-			if (cc->list.count == 0) {
-				default_ = clause;
-				continue;
-			}
-
-			irBlock *body = ir_new_block(proc, clause, "typeswitch.body");
-			irBlock *next = nullptr;
-			Type *case_type = nullptr;
-			for_array(type_index, cc->list) {
-				next = ir_new_block(proc, nullptr, "typeswitch.next");
-				case_type = type_of_expr(cc->list[type_index]);
-				irValue *cond = nullptr;
-				if (switch_kind == TypeSwitch_Union) {
-					Type *ut = base_type(type_deref(parent_type));
-					irValue *variant_tag = ir_const_union_tag(ut, case_type);
-					cond = ir_emit_comp(proc, Token_CmpEq, tag_index, variant_tag);
-				} else if (switch_kind == TypeSwitch_Any) {
-					irValue *any_typeid  = ir_emit_load(proc, ir_emit_struct_ep(proc, parent_ptr, 1));
-					irValue *case_typeid = ir_typeid(proc->module, case_type);
-					cond = ir_emit_comp(proc, Token_CmpEq, any_typeid, case_typeid);
-				}
-				GB_ASSERT(cond != nullptr);
-
-				ir_emit_if(proc, cond, body, next);
-				ir_start_block(proc, next);
-			}
-
-			Entity *case_entity = implicit_entity_of_node(clause);
-
-			irValue *value = parent_value;
-
-			ir_start_block(proc, body);
-
-			// bool any_or_not_ptr = is_type_any(type_deref(parent_type)) || !is_parent_ptr;
-			if (cc->list.count == 1) {
-
-				irValue *data = nullptr;
-				if (switch_kind == TypeSwitch_Union) {
-					data = union_data;
-				} else if (switch_kind == TypeSwitch_Any) {
-					irValue *any_data = ir_emit_load(proc, ir_emit_struct_ep(proc, parent_ptr, 0));
-					data = any_data;
-				}
-				Type *ct = case_entity->type;
-				Type *ct_ptr = alloc_type_pointer(ct);
-
-
-				value = ir_emit_conv(proc, data, ct_ptr);
-
-				if (case_entity->flags & EntityFlag_Value) {
-					// by value
-					value = ir_emit_load(proc, value);
-				} else {
-					// by reference
-				}
-			}
-
-			ir_store_type_case_implicit(proc, clause, value);
-			ir_type_case_body(proc, ss->label, clause, body, done);
-			ir_start_block(proc, next);
-		}
-
-		if (default_ != nullptr) {
-			ir_store_type_case_implicit(proc, default_, parent_value);
-			ir_type_case_body(proc, ss->label, default_, proc->curr_block, done);
-		} else {
-			ir_emit_jump(proc, done);
-		}
-		ir_start_block(proc, done);
-	case_end;
-
-	case_ast_node(bs, BranchStmt, node);
-		irBlock *block = nullptr;
-
-		if (bs->label != nullptr) {
-			irBranchBlocks bb = ir_lookup_branch_blocks(proc, bs->label);
-			switch (bs->token.kind) {
-			case Token_break:    block = bb.break_;    break;
-			case Token_continue: block = bb.continue_; break;
-			case Token_fallthrough:
-				GB_PANIC("fallthrough cannot have a label");
-				break;
-			}
-		} else {
-			for (irTargetList *t = proc->target_list; t != nullptr && block == nullptr; t = t->prev) {
-				if (t->is_block) {
-					continue;
-				}
-
-				switch (bs->token.kind) {
-				case Token_break:       block = t->break_;       break;
-				case Token_continue:    block = t->continue_;    break;
-				case Token_fallthrough: block = t->fallthrough_; break;
-				}
-			}
-		}
-		if (block != nullptr) {
-			ir_emit_defer_stmts(proc, irDeferExit_Branch, block);
-		}
-		switch (bs->token.kind) {
-		case Token_break:       ir_emit_comment(proc, str_lit("break"));       break;
-		case Token_continue:    ir_emit_comment(proc, str_lit("continue"));    break;
-		case Token_fallthrough: ir_emit_comment(proc, str_lit("fallthrough")); break;
-		}
-		ir_emit_jump(proc, block);
-		ir_emit_unreachable(proc);
-	case_end;
-	}
-}
-
-
-
-
-
-
-
-////////////////////////////////////////////////////////////////
-//
-// @Procedure
-//
-////////////////////////////////////////////////////////////////
-
-void ir_number_proc_registers(irProcedure *proc) {
-	// i32 reg_index = proc->parameter_count;
-	i32 reg_index = 0;
-	for_array(i, proc->blocks) {
-		irBlock *b = proc->blocks[i];
-		b->index = cast(i32)i;
-		for_array(j, b->instrs) {
-			irValue *value = b->instrs[j];
-			GB_ASSERT_MSG(value->kind == irValue_Instr, "%.*s", LIT(proc->name));
-			irInstr *instr = &value->Instr;
-			if (ir_instr_type(instr) == nullptr) { // NOTE(bill): Ignore non-returning instructions
-				value->index = -1;
-				continue;
-			}
-			value->index = reg_index;
-			value->index_set = true;
-			reg_index++;
-		}
-	}
-}
-
-void ir_begin_procedure_body(irProcedure *proc) {
-	gbAllocator a = ir_allocator();
-	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());
-	array_init(&proc->branch_blocks,    heap_allocator());
-	array_init(&proc->context_stack,    heap_allocator());
-
-	DeclInfo *decl = decl_info_of_entity(proc->entity);
-	if (decl == nullptr && proc->proc_lit != nullptr) {
-		GB_ASSERT(proc->proc_lit->kind == Ast_ProcLit);
-		decl = proc->proc_lit->ProcLit.decl;
-	}
-	if (decl != nullptr) {
-		for_array(i, decl->labels) {
-			BlockLabel bl = decl->labels[i];
-			irBranchBlocks bb = {bl.label, nullptr, nullptr};
-			array_add(&proc->branch_blocks, bb);
-		}
-	}
-
-	// NOTE(lachsinc): This is somewhat of a fallback/catch-all; We use the procedure's identifer as a debug location..
-	// Additional debug locations should be pushed for the procedures statements/expressions themselves.
-	if (proc->module->generate_debug_info && proc->entity && proc->entity->identifier) { // TODO(lachsinc): Better way to determine if these procs are main/runtime_startup.
-		// TODO(lachsinc): Passing the file for the scope may not be correct for nested procedures? This should probably be
-		// handled all inside push_debug_location, with just the Ast * we can pull out everything we need to construct scope/file debug info etc.
-		ir_add_debug_info_proc(proc);
-		ir_push_debug_location(proc->module, proc->entity->identifier, proc->debug_scope);
-		GB_ASSERT_NOT_NULL(proc->debug_scope);
-	} else {
-		ir_push_debug_location(proc->module, nullptr, nullptr);
-	}
-
-	proc->decl_block  = ir_new_block(proc, proc->type_expr, "decls");
-	ir_start_block(proc, proc->decl_block);
-	proc->entry_block = ir_new_block(proc, proc->type_expr, "entry");
-	ir_start_block(proc, proc->entry_block);
-
-	i32 parameter_index = 0;
-
-	if (proc->type->Proc.return_by_pointer) {
-		// NOTE(bill): this must be the first parameter stored
-		Type *ptr_type = alloc_type_pointer(reduce_tuple_to_single_type(proc->type->Proc.results));
-		Entity *e = alloc_entity_param(nullptr, make_token_ident(str_lit("agg.result")), ptr_type, false, false);
-		e->flags |= EntityFlag_Sret | EntityFlag_NoAlias;
-
-		irValue *param = ir_value_param(proc, e, ptr_type, -1);
-		param->Param.kind = irParamPass_Pointer;
-
-		ir_module_add_value(proc->module, e, param);
-		proc->return_ptr = param;
-	}
-
-	GB_ASSERT(proc->type != nullptr);
-
-	if (proc->type->Proc.params != nullptr) {
-		TypeTuple *params = &proc->type->Proc.params->Tuple;
-		if (proc->type_expr != nullptr) {
-			ast_node(pt, ProcType, proc->type_expr);
-			isize param_index = 0;
-			isize q_index = 0;
-
-			for_array(i, params->variables) {
-				ast_node(fl, FieldList, pt->params);
-				GB_ASSERT(fl->list.count > 0);
-				GB_ASSERT(fl->list[0]->kind == Ast_Field);
-				if (q_index == fl->list[param_index]->Field.names.count) {
-					q_index = 0;
-					param_index++;
-				}
-				ast_node(field, Field, fl->list[param_index]);
-				Ast *name = field->names[q_index++];
-
-				Entity *e = params->variables[i];
-				if (e->kind != Entity_Variable) {
-					parameter_index += 1;
-					continue;
-				}
-
-				Type *abi_type = proc->type->Proc.abi_compat_params[i];
-				if (e->token.string != "") {
-					ir_add_param(proc, e, name, abi_type, parameter_index);
-				}
-
-				if (is_type_tuple(abi_type)) {
-					parameter_index += cast(i32)abi_type->Tuple.variables.count;
-				} else {
-					parameter_index += 1;
-				}
-			}
-		} else {
-			auto abi_types = proc->type->Proc.abi_compat_params;
-
-			for_array(i, params->variables) {
-				Entity *e = params->variables[i];
-				if (e->kind != Entity_Variable) {
-					parameter_index += 1;
-					continue;
-				}
-				Type *abi_type = e->type;
-				if (abi_types.count > 0) {
-					abi_type = abi_types[i];
-				}
-				if (e->token.string != "") {
-					ir_add_param(proc, e, nullptr, abi_type, parameter_index);
-				}
-				if (is_type_tuple(abi_type)) {
-					parameter_index += cast(i32)abi_type->Tuple.variables.count;
-				} else {
-					parameter_index += 1;
-				}
-			}
-		}
-	}
-
-	if (proc->type->Proc.has_named_results) {
-		GB_ASSERT(proc->type->Proc.result_count > 0);
-		TypeTuple *results = &proc->type->Proc.results->Tuple;
-
-		for_array(i, results->variables) {
-			Entity *e = results->variables[i];
-			GB_ASSERT(e->kind == Entity_Variable);
-
-			if (e->token.string != "") {
-				GB_ASSERT(!is_blank_ident(e->token));
-
-				irAddr res = {};
-				if (proc->type->Proc.return_by_pointer) {
-					irValue *ptr = proc->return_ptr;
-					if (results->variables.count != 1) {
-						ptr = ir_emit_struct_ep(proc, ptr, cast(i32)i);
-					}
-
-					res = ir_addr(ptr);
-					ir_module_add_value(proc->module, e, ptr);
-				} else {
-					res = ir_addr(ir_add_local(proc, e, e->identifier, true));
-				}
-
-				if (e->Variable.param_value.kind != ParameterValue_Invalid) {
-					irValue *c = ir_handle_param_value(proc, e->type, e->Variable.param_value, e->token.pos);
-					ir_addr_store(proc, res, c);
-				}
-			}
-		}
-	}
-
-
-	if (proc->type->Proc.calling_convention == ProcCC_Odin) {
-		Entity *e = alloc_entity_param(nullptr, make_token_ident(str_lit("__.context_ptr")), t_context_ptr, false, false);
-		e->flags |= EntityFlag_NoAlias;
-		irValue *param = ir_value_param(proc, e, e->type, -1);
-		ir_module_add_value(proc->module, e, param);
-		irContextData ctx = {param, proc->scope_index};
-		array_add(&proc->context_stack, ctx);
-	}
-
-	proc->parameter_count = parameter_index;
-}
-
-
-bool ir_remove_dead_instr(irProcedure *proc) {
-	if (proc->ignore_dead_instr) {
-		return false;
-	}
-	isize elimination_count = 0;
-retry:
-#if 1
-	for_array(i, proc->blocks) {
-		irBlock *b = proc->blocks[i];
-		b->index = cast(i32)i;
-		for (isize j = 0; j < b->instrs.count; /**/) {
-			irValue *value = b->instrs[j];
-			GB_ASSERT_MSG(value->kind == irValue_Instr, "%.*s", LIT(proc->name));
-			irInstr *instr = &value->Instr;
-			if (value->uses == 0) {
-				switch (instr->kind) {
-				case irInstr_Load:
-					instr->Load.address->uses -= 1;
-					array_ordered_remove(&b->instrs, j);
-					elimination_count += 1;
-					continue;
-				case irInstr_Local:
-					array_ordered_remove(&b->instrs, j);
-					elimination_count += 1;
-					continue;
-				case irInstr_AtomicLoad:
-					instr->AtomicLoad.address->uses -= 1;
-					array_ordered_remove(&b->instrs, j);
-					elimination_count += 1;
-					continue;
-				case irInstr_PtrOffset:
-					instr->PtrOffset.address->uses -= 1;
-					instr->PtrOffset.offset->uses -= 1;
-					array_ordered_remove(&b->instrs, j);
-					elimination_count += 1;
-					continue;
-				case irInstr_ArrayElementPtr:
-					instr->ArrayElementPtr.address->uses -= 1;
-					instr->ArrayElementPtr.elem_index->uses -= 1;
-					array_ordered_remove(&b->instrs, j);
-					elimination_count += 1;
-					continue;
-				case irInstr_StructElementPtr:
-					instr->StructElementPtr.address->uses -= 1;
-					array_ordered_remove(&b->instrs, j);
-					elimination_count += 1;
-					continue;
-				case irInstr_StructExtractValue:
-					instr->StructExtractValue.address->uses -= 1;
-					array_ordered_remove(&b->instrs, j);
-					elimination_count += 1;
-					continue;
-				case irInstr_UnionTagPtr:
-					instr->UnionTagPtr.address->uses -= 1;
-					array_ordered_remove(&b->instrs, j);
-					elimination_count += 1;
-					continue;
-				case irInstr_UnionTagValue:
-					instr->UnionTagValue.address->uses -= 1;
-					array_ordered_remove(&b->instrs, j);
-					elimination_count += 1;
-					continue;
-				// case irInstr_Conv:
-				// 	// instr->Conv.value->uses -= 1;
-				// 	array_ordered_remove(&b->instrs, j);
-				// 	elimination_count += 1;
-				// 	continue;
-				// case irInstr_UnaryOp:
-				// 	// instr->UnaryOp.expr->uses -= 1;
-				// 	array_ordered_remove(&b->instrs, j);
-				// 	elimination_count += 1;
-				// 	continue;
-				// case irInstr_BinaryOp:
-				// 	// instr->BinaryOp.left->uses -= 1;
-				// 	// instr->BinaryOp.right->uses -= 1;
-				// 	array_ordered_remove(&b->instrs, j);
-				// 	elimination_count += 1;
-				// 	continue;
-				}
-			}
-			j += 1;
-		}
-	}
-#endif
-	if (elimination_count > 0) {
-		// gb_printf_err("Retry ir_remove_dead_instr, count: %td; %.*s\n", elimination_count, LIT(proc->name));
-		elimination_count = 0;
-		goto retry;
-	}
-	return elimination_count > 0;
-}
-
-void ir_end_procedure_body(irProcedure *proc) {
-	if (proc->type->Proc.result_count == 0) {
-		ir_emit_return(proc, nullptr);
-	}
-
-	if (proc->curr_block->instrs.count == 0) {
-		ir_emit_unreachable(proc);
-	}
-
-	GB_ASSERT(proc->scope_index == 0);
-
-	proc->curr_block = proc->decl_block;
-	ir_emit_jump(proc, proc->entry_block);
-	proc->curr_block = nullptr;
-
-	ir_remove_dead_instr(proc);
-
-	ir_number_proc_registers(proc);
-
-	ir_pop_debug_location(proc->module);
-}
-
-
-void ir_insert_code_before_proc(irProcedure* proc, irProcedure *parent) {
-	// if (parent == nullptr) {
-		// if (proc->name == "main") {
-			// ir_emit_startup_runtime(proc);
-		// }
-	// }
-}
-
-void ir_build_proc(irValue *value, irProcedure *parent) {
-	irProcedure *proc = &value->Proc;
-
-	set_procedure_abi_types(proc->type);
-
-	proc->parent = parent;
-
-	if (proc->body != nullptr && proc->body->kind != Ast_Invalid) {
-		u64 prev_state_flags = proc->module->state_flags;
-
-		if (proc->tags != 0) {
-			u64 in = proc->tags;
-			u64 out = proc->module->state_flags;
-			if (in & ProcTag_bounds_check) {
-				out |= StateFlag_bounds_check;
-				out &= ~StateFlag_no_bounds_check;
-			} else if (in & ProcTag_no_bounds_check) {
-				out |= StateFlag_no_bounds_check;
-				out &= ~StateFlag_bounds_check;
-			}
-			proc->module->state_flags = out;
-		}
-
-		ir_begin_procedure_body(proc);
-		ir_insert_code_before_proc(proc, parent);
-		ir_build_stmt(proc, proc->body);
-		ir_end_procedure_body(proc);
-
-		proc->module->state_flags = prev_state_flags;
-	}
-
-	// NOTE(lachsinc): For now we pop the debug location inside ir_end_procedure_body().
-	// This may result in debug info being missing for below.
-
-	if (proc->type->Proc.has_proc_default_values) {
-		auto *p = &proc->type->Proc;
-		if (p->params != nullptr) for_array(i, p->params->Tuple.variables) {
-			Entity *f = p->params->Tuple.variables[i];
-			if (f->kind == Entity_Variable) {
-				ParameterValue pv = f->Variable.param_value;
-				if (pv.kind ==  ParameterValue_Constant && pv.value.kind == ExactValue_Procedure) {
-					Ast *expr = f->Variable.param_value.value.value_procedure;
-					GB_ASSERT(expr != nullptr);
-					if (expr->kind == Ast_ProcLit) {
-						ir_gen_anonymous_proc_lit(proc->module, proc->name, expr, proc);
-					}
-				}
-			}
-		}
-		if (p->results != nullptr) for_array(i, p->results->Tuple.variables) {
-			Entity *f = p->results->Tuple.variables[i];
-			if (f->kind == Entity_Variable) {
-				ParameterValue pv = f->Variable.param_value;
-				if (pv.kind ==  ParameterValue_Constant && pv.value.kind == ExactValue_Procedure) {
-					Ast *expr = f->Variable.param_value.value.value_procedure;
-					GB_ASSERT(expr != nullptr);
-					if (expr->kind == Ast_ProcLit) {
-						ir_gen_anonymous_proc_lit(proc->module, proc->name, expr, proc);
-					}
-				}
-			}
-		}
-	}
-
-}
-
-
-
-
-
-
-
-////////////////////////////////////////////////////////////////
-//
-// @Module
-//
-////////////////////////////////////////////////////////////////
-
-
-
-void ir_module_add_value(irModule *m, Entity *e, irValue *v) {
-	map_set(&m->values, hash_entity(e), v);
-	// TODO(lachsinc): This may not be the most sensible place to do this!
-	// it may be more sensible to look for more specific locations that call ir_value_global and assign it a value? maybe?
-	// ir_value_global itself doesn't have access to module though.
-	if (v->kind == irValue_Global && v->Global.value != nullptr && e->state == EntityState_Resolved) {
-		ir_add_debug_info_global(m, v);
-	}
-}
-
-void ir_init_module(irModule *m, Checker *c) {
-	// 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(irValue);
-	gb_arena_init_from_allocator(&m->tmp_arena, heap_allocator(), arena_size);
-	ir_allocator() = ir_allocator();
-	m->tmp_allocator = gb_arena_allocator(&m->tmp_arena);
-	m->info = &c->info;
-
-	m->generate_debug_info = false;
-	if (build_context.ODIN_DEBUG) {
-		m->generate_debug_info = build_context.ODIN_OS == "windows" && build_context.word_size == 8;
-	}
-
-	map_init(&m->values,                   heap_allocator());
-	string_map_init(&m->members,           heap_allocator());
-	map_init(&m->debug_info,               heap_allocator());
-	map_init(&m->entity_names,             heap_allocator());
-	map_init(&m->anonymous_proc_lits,      heap_allocator());
-	map_init(&m->equal_procs,              heap_allocator());
-	map_init(&m->hasher_procs,             heap_allocator());
-	array_init(&m->procs,                  heap_allocator());
-	array_init(&m->procs_to_generate,      heap_allocator());
-	array_init(&m->foreign_library_paths,  heap_allocator());
-	string_map_init(&m->const_strings,     heap_allocator());
-	string_map_init(&m->const_string_byte_slices, heap_allocator());
-	map_init(&m->constant_value_to_global, heap_allocator());
-
-	// Default states
-	m->state_flags = 0;
-	m->state_flags |= StateFlag_bounds_check;
-
-	{
-		// Add type info data
-		{
-			isize max_type_info_count = ir_type_info_count(m->info);
-
-			String name = str_lit(IR_TYPE_INFO_DATA_NAME);
-			Entity *e = alloc_entity_variable(nullptr, make_token_ident(name), alloc_type_array(t_type_info, max_type_info_count));
-			irValue *g = ir_value_global(e, nullptr);
-			g->Global.is_private = true;
-			ir_module_add_value(m, e, g);
-			string_map_set(&m->members, name, g);
-			ir_global_type_info_data = 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_types) {
-				Type *t = m->info->type_info_types[entry_index];
-
-				isize index = ir_type_info_index(m->info, t, false);
-				if (index < 0) {
-					continue;
-				}
-
-				switch (t->kind) {
-				case Type_Union:
-					count += t->Union.variants.count;
-					break;
-				case Type_Struct:
-					count += t->Struct.fields.count;
-					break;
-				case Type_Tuple:
-					count += t->Tuple.variables.count;
-					break;
-				}
-			}
-
-			if (count > 0) {
-				{
-					String name = str_lit(IR_TYPE_INFO_TYPES_NAME);
-					Entity *e = alloc_entity_variable(nullptr, make_token_ident(name),
-					                                  alloc_type_array(t_type_info_ptr, count));
-					irValue *g = ir_value_global(e, nullptr);
-					ir_module_add_value(m, e, g);
-					string_map_set(&m->members, name, g);
-					ir_global_type_info_member_types = g;
-				}
-				{
-					String name = str_lit(IR_TYPE_INFO_NAMES_NAME);
-					Entity *e = alloc_entity_variable(nullptr, make_token_ident(name),
-					                                  alloc_type_array(t_string, count));
-					irValue *g = ir_value_global(e, nullptr);
-					ir_module_add_value(m, e, g);
-					string_map_set(&m->members, name, g);
-					ir_global_type_info_member_names = g;
-				}
-				{
-					String name = str_lit(IR_TYPE_INFO_OFFSETS_NAME);
-					Entity *e = alloc_entity_variable(nullptr, make_token_ident(name),
-					                                  alloc_type_array(t_uintptr, count));
-					irValue *g = ir_value_global(e, nullptr);
-					ir_module_add_value(m, e, g);
-					string_map_set(&m->members, name, g);
-					ir_global_type_info_member_offsets = g;
-				}
-
-				{
-					String name = str_lit(IR_TYPE_INFO_USINGS_NAME);
-					Entity *e = alloc_entity_variable(nullptr, make_token_ident(name),
-					                                  alloc_type_array(t_bool, count));
-					irValue *g = ir_value_global(e, nullptr);
-					ir_module_add_value(m, e, g);
-					string_map_set(&m->members, name, g);
-					ir_global_type_info_member_usings = g;
-				}
-
-				{
-					String name = str_lit(IR_TYPE_INFO_TAGS_NAME);
-					Entity *e = alloc_entity_variable(nullptr, make_token_ident(name),
-					                                  alloc_type_array(t_string, count));
-					irValue *g = ir_value_global(e, nullptr);
-					ir_module_add_value(m, e, g);
-					string_map_set(&m->members, name, g);
-					ir_global_type_info_member_tags = g;
-				}
-			}
-		}
-	}
-
-	{
-		irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompileUnit);
-
-		GB_ASSERT(m->info->files.entries.count > 0);
-		AstFile *file = m->info->files.entries[0].value;
-
-		di->CompileUnit.file = file; // Zeroth is the init file
-		di->CompileUnit.producer = str_lit("odin");
-
-		map_set(&m->debug_info, hash_pointer(m), di);
-
-		m->debug_compile_unit = di;
-
-		irDebugInfo *enums_di = ir_alloc_debug_info(irDebugInfo_DebugInfoArray);
-		array_init(&enums_di->DebugInfoArray.elements, heap_allocator()); // TODO(lachsinc): ir_allocator() ??
-		map_set(&m->debug_info, hash_pointer(enums_di), enums_di);
-		m->debug_compile_unit->CompileUnit.enums = enums_di;
-
-		irDebugInfo *globals_di = ir_alloc_debug_info(irDebugInfo_DebugInfoArray);
-		array_init(&globals_di->DebugInfoArray.elements, heap_allocator()); // TODO(lachsinc): ir_allocator() ??
-		map_set(&m->debug_info, hash_pointer(globals_di), globals_di);
-		m->debug_compile_unit->CompileUnit.globals = globals_di;
-
-		array_init(&m->debug_location_stack, heap_allocator()); // TODO(lachsinc): ir_allocator() ??
-	}
-
-	{
-		for_array(i, m->info->files.entries) {
-			AstFile *file = m->info->files.entries[i].value;
-			ir_add_debug_info_file(m, file);
-		}
-	}
-}
-
-void ir_destroy_module(irModule *m) {
-	map_destroy(&m->values);
-	string_map_destroy(&m->members);
-	map_destroy(&m->entity_names);
-	map_destroy(&m->anonymous_proc_lits);
-	map_destroy(&m->debug_info);
-	string_map_destroy(&m->const_strings);
-	string_map_destroy(&m->const_string_byte_slices);
-	map_destroy(&m->constant_value_to_global);
-	array_free(&m->procs);
-	array_free(&m->procs_to_generate);
-	array_free(&m->foreign_library_paths);
-	array_free(&m->debug_location_stack);
-	gb_arena_free(&m->tmp_arena);
-}
-
-
-
-////////////////////////////////////////////////////////////////
-//
-// @Code Generation
-//
-////////////////////////////////////////////////////////////////
-
-
-bool ir_gen_init(irGen *s, Checker *c) {
-	if (global_error_collector.count != 0) {
-		return false;
-	}
-
-	isize tc = c->parser->total_token_count;
-	if (tc < 2) {
-		return false;
-	}
-
-	arena_init(&global_ir_arena, heap_allocator());
-
-	ir_init_module(&s->module, c);
-	// s->module.generate_debug_info = false;
-
-	String init_fullpath = c->parser->init_fullpath;
-
-	if (build_context.out_filepath.len == 0) {
-		s->output_name = remove_directory_from_path(init_fullpath);
-		s->output_name = remove_extension_from_path(s->output_name);
-		s->output_name = string_trim_whitespace(s->output_name);
-		if (s->output_name.len == 0) {
-			s->output_name = c->info.init_scope->pkg->name;
-		}
-		s->output_base = s->output_name;
-	} else {
-		s->output_name = build_context.out_filepath;
-		s->output_name = string_trim_whitespace(s->output_name);
-		if (s->output_name.len == 0) {
-			s->output_name = c->info.init_scope->pkg->name;
-		}
-		isize pos = string_extension_position(s->output_name);
-		if (pos < 0) {
-			s->output_base = s->output_name;
-		} else {
-			s->output_base = substring(s->output_name, 0, pos);
-		}
-	}
-	gbAllocator ha = heap_allocator();
-	s->output_base = path_to_full_path(ha, s->output_base);
-
-	gbString output_file_path = gb_string_make_length(ha, s->output_base.text, s->output_base.len);
-	output_file_path = gb_string_appendc(output_file_path, ".ll");
-	defer (gb_string_free(output_file_path));
-
-	gbFileError err = gb_file_create(&s->output_file, output_file_path);
-	if (err != gbFileError_None) {
-		gb_printf_err("Failed to create file %s\n", output_file_path);
-		return false;
-	}
-
-	return true;
-}
-
-void ir_gen_destroy(irGen *s) {
-	ir_destroy_module(&s->module);
-	gb_file_close(&s->output_file);
-}
-
-
-
-//
-// Type Info stuff
-//
-irValue *ir_get_type_info_ptr(irProcedure *proc, Type *type) {
-	i32 index = cast(i32)ir_type_info_index(proc->module->info, type);
-	// gb_printf_err("%d %s\n", index, type_to_string(type));
-	irValue *ptr = ir_emit_array_epi(proc, ir_global_type_info_data, index);
-	return ir_emit_bitcast(proc, ptr, t_type_info_ptr);
-}
-
-irValue *ir_type_info_member_types_offset(irProcedure *proc, isize count) {
-	irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_types, ir_global_type_info_member_types_index);
-	ir_global_type_info_member_types_index += cast(i32)count;
-	return offset;
-}
-irValue *ir_type_info_member_names_offset(irProcedure *proc, isize count) {
-	irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_names, ir_global_type_info_member_names_index);
-	ir_global_type_info_member_names_index += cast(i32)count;
-	return offset;
-}
-irValue *ir_type_info_member_offsets_offset(irProcedure *proc, isize count) {
-	irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_offsets, ir_global_type_info_member_offsets_index);
-	ir_global_type_info_member_offsets_index += cast(i32)count;
-	return offset;
-}
-irValue *ir_type_info_member_usings_offset(irProcedure *proc, isize count) {
-	irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_usings, ir_global_type_info_member_usings_index);
-	ir_global_type_info_member_usings_index += cast(i32)count;
-	return offset;
-}
-irValue *ir_type_info_member_tags_offset(irProcedure *proc, isize count) {
-	irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_tags, ir_global_type_info_member_tags_index);
-	ir_global_type_info_member_tags_index += cast(i32)count;
-	return offset;
-}
-
-
-
-
-
-
-void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info data
-	irModule *m = proc->module;
-	gbAllocator a = ir_allocator();
-	CheckerInfo *info = m->info;
-
-	if (true) {
-		irValue *global_type_table = ir_find_global_variable(proc, str_lit("type_table"));
-		Type *type = base_type(type_deref(ir_type(ir_global_type_info_data)));
-		GB_ASSERT(is_type_array(type));
-		irValue *len = ir_const_int(type->Array.count);
-		ir_fill_slice(proc, global_type_table,
-		              ir_emit_array_epi(proc, ir_global_type_info_data, 0),
-		              len);
-	}
-
-
-	// Useful types
-	Type *t_i64_slice_ptr    = alloc_type_pointer(alloc_type_slice(t_i64));
-	Type *t_string_slice_ptr = alloc_type_pointer(alloc_type_slice(t_string));
-	Entity *type_info_flags_entity = find_core_entity(info->checker, str_lit("Type_Info_Flags"));
-	Type *t_type_info_flags = type_info_flags_entity->type;
-
-	i32 type_info_member_types_index = 0;
-	i32 type_info_member_names_index = 0;
-	i32 type_info_member_offsets_index = 0;
-
-	for_array(type_info_type_index, info->type_info_types) {
-		Type *t = info->type_info_types[type_info_type_index];
-		t = default_type(t);
-		if (t == t_invalid) {
-			continue;
-		}
-
-		isize entry_index = ir_type_info_index(info, t, false);
-		if (entry_index <= 0) {
-			continue;
-		}
-
-		irValue *tag = nullptr;
-		irValue *ti_ptr = ir_emit_array_epi(proc, ir_global_type_info_data, cast(i32)entry_index);
-		irValue *variant_ptr = ir_emit_struct_ep(proc, ti_ptr, 4);
-
-		irValue *type_info_flags = ir_value_constant(t_type_info_flags, exact_value_i64(type_info_flags_of_type(t)));
-
-		ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 0), ir_const_int(type_size_of(t)));
-		ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 1), ir_const_int(type_align_of(t)));
-		ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 2), type_info_flags);
-		ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 3), ir_typeid(proc->module, t));
-
-
-		switch (t->kind) {
-		case Type_Named: {
-			ir_emit_comment(proc, str_lit("Type_Info_Named"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_named_ptr);
-
-			// TODO(bill): Which is better? The mangled name or actual name?
-			irValue *name = ir_const_string(proc->module, t->Named.type_name->token.string);
-			irValue *gtip = ir_get_type_info_ptr(proc, t->Named.base);
-
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), name);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), gtip);
-
-			if (t->Named.type_name->pkg) {
-				irValue *name = ir_const_string(proc->module, t->Named.type_name->pkg->name);
-				ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 2), name);
-			}
-
-			String proc_name = {};
-			if (t->Named.type_name->parent_proc_decl) {
-				DeclInfo *decl = t->Named.type_name->parent_proc_decl;
-				if (decl->entity && decl->entity->kind == Entity_Procedure) {
-					proc_name = decl->entity->token.string;
-				}
-			}
-			irValue *loc = ir_emit_source_code_location(proc, proc_name, t->Named.type_name->token.pos);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 3), loc);
-			break;
-		}
-
-		case Type_Basic:
-			ir_emit_comment(proc, str_lit("Type_Info_Basic"));
-			switch (t->Basic.kind) {
-			case Basic_bool:
-			case Basic_b8:
-			case Basic_b16:
-			case Basic_b32:
-			case Basic_b64:
-				tag = ir_emit_conv(proc, variant_ptr, t_type_info_boolean_ptr);
-				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_i16le:
-			case Basic_u16le:
-			case Basic_i32le:
-			case Basic_u32le:
-			case Basic_i64le:
-			case Basic_u64le:
-			case Basic_i128le:
-			case Basic_u128le:
-			case Basic_i16be:
-			case Basic_u16be:
-			case Basic_i32be:
-			case Basic_u32be:
-			case Basic_i64be:
-			case Basic_u64be:
-			case Basic_i128be:
-			case Basic_u128be:
-
-			case Basic_int:
-			case Basic_uint:
-			case Basic_uintptr: {
-				tag = ir_emit_conv(proc, variant_ptr, t_type_info_integer_ptr);
-				irValue *is_signed = ir_const_bool((t->Basic.flags & BasicFlag_Unsigned) == 0);
-				ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), is_signed);
-				// NOTE(bill): This is matches the runtime layout
-				u8 endianness_value = 0;
-				if (t->Basic.flags & BasicFlag_EndianLittle) {
-					endianness_value = 1;
-				} else if (t->Basic.flags & BasicFlag_EndianBig) {
-					endianness_value = 2;
-				}
-				irValue *endianness = ir_const_u8(endianness_value);
-				ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), endianness);
-				break;
-			}
-
-			case Basic_rune:
-				tag = ir_emit_conv(proc, variant_ptr, t_type_info_rune_ptr);
-				break;
-
-			case Basic_f16:
-			case Basic_f32:
-			case Basic_f64:
-			case Basic_f16le:
-			case Basic_f32le:
-			case Basic_f64le:
-			case Basic_f16be:
-			case Basic_f32be:
-			case Basic_f64be:
-				{
-					tag = ir_emit_conv(proc, variant_ptr, t_type_info_float_ptr);
-
-					// NOTE(bill): This is matches the runtime layout
-					u8 endianness_value = 0;
-					if (t->Basic.flags & BasicFlag_EndianLittle) {
-						endianness_value = 1;
-					} else if (t->Basic.flags & BasicFlag_EndianBig) {
-						endianness_value = 2;
-					}
-					irValue *endianness = ir_const_u8(endianness_value);
-					ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), endianness);
-				}
-				break;
-
-
-			case Basic_complex32:
-			case Basic_complex64:
-			case Basic_complex128:
-				tag = ir_emit_conv(proc, variant_ptr, t_type_info_complex_ptr);
-				break;
-
-			case Basic_quaternion64:
-			case Basic_quaternion128:
-			case Basic_quaternion256:
-				tag = ir_emit_conv(proc, variant_ptr, t_type_info_quaternion_ptr);
-				break;
-
-			case Basic_rawptr:
-				tag = ir_emit_conv(proc, variant_ptr, t_type_info_pointer_ptr);
-				break;
-
-			case Basic_string:
-				tag = ir_emit_conv(proc, variant_ptr, t_type_info_string_ptr);
-				break;
-
-			case Basic_cstring:
-				tag = ir_emit_conv(proc, variant_ptr, t_type_info_string_ptr);
-				ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), v_true); // is_cstring
-				break;
-
-			case Basic_any:
-				tag = ir_emit_conv(proc, variant_ptr, t_type_info_any_ptr);
-				break;
-
-			case Basic_typeid:
-				tag = ir_emit_conv(proc, variant_ptr, t_type_info_typeid_ptr);
-				break;
-			}
-			break;
-
-		case Type_Pointer: {
-			ir_emit_comment(proc, str_lit("Type_Info_Pointer"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_pointer_ptr);
-			irValue *gep = ir_get_type_info_ptr(proc, t->Pointer.elem);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
-			break;
-		}
-		case Type_Array: {
-			ir_emit_comment(proc, str_lit("Type_Info_Array"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_array_ptr);
-			irValue *gep = ir_get_type_info_ptr(proc, t->Array.elem);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
-
-			i64 ez = type_size_of(t->Array.elem);
-			irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
-			ir_emit_store(proc, elem_size, ir_const_int(ez));
-
-			irValue *count = ir_emit_struct_ep(proc, tag, 2);
-			ir_emit_store(proc, count, ir_const_int(t->Array.count));
-
-			break;
-		}
-		case Type_EnumeratedArray: {
-			ir_emit_comment(proc, str_lit("Type_Info_Enumerated_Array"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_enumerated_array_ptr);
-			irValue *elem = ir_get_type_info_ptr(proc, t->EnumeratedArray.elem);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), elem);
-
-			irValue *index = ir_get_type_info_ptr(proc, t->EnumeratedArray.index);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), index);
-
-			i64 ez = type_size_of(t->EnumeratedArray.elem);
-			irValue *elem_size = ir_emit_struct_ep(proc, tag, 2);
-			ir_emit_store(proc, elem_size, ir_const_int(ez));
-
-			irValue *count = ir_emit_struct_ep(proc, tag, 3);
-			ir_emit_store(proc, count, ir_const_int(t->EnumeratedArray.count));
-
-			irValue *min_value = ir_emit_struct_ep(proc, tag, 4);
-			irValue *max_value = ir_emit_struct_ep(proc, tag, 5);
-
-			irValue *min_v = ir_value_constant(t_i64, t->EnumeratedArray.min_value);
-			irValue *max_v = ir_value_constant(t_i64, t->EnumeratedArray.max_value);
-
-			ir_emit_store(proc, min_value, min_v);
-			ir_emit_store(proc, max_value, max_v);
-			break;
-		}
-		case Type_DynamicArray: {
-			ir_emit_comment(proc, str_lit("Type_Info_Dynamic_Array"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_dynamic_array_ptr);
-			irValue *gep = ir_get_type_info_ptr(proc, t->DynamicArray.elem);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
-
-			i64 ez = type_size_of(t->DynamicArray.elem);
-			irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
-			ir_emit_store(proc, elem_size, ir_const_int(ez));
-			break;
-		}
-		case Type_Slice: {
-			ir_emit_comment(proc, str_lit("Type_Info_Slice"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_slice_ptr);
-			irValue *gep = ir_get_type_info_ptr(proc, t->Slice.elem);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
-
-			i64 ez = type_size_of(t->Slice.elem);
-			irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
-			ir_emit_store(proc, elem_size, ir_const_int(ez));
-			break;
-		}
-		case Type_Proc: {
-			ir_emit_comment(proc, str_lit("Type_Info_Proc"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_procedure_ptr);
-
-			irValue *params     = ir_emit_struct_ep(proc, tag, 0);
-			irValue *results    = ir_emit_struct_ep(proc, tag, 1);
-			irValue *variadic   = ir_emit_struct_ep(proc, tag, 2);
-			irValue *convention = ir_emit_struct_ep(proc, tag, 3);
-
-			if (t->Proc.params != nullptr) {
-				ir_emit_store(proc, params, ir_get_type_info_ptr(proc, t->Proc.params));
-			}
-			if (t->Proc.results != nullptr) {
-				ir_emit_store(proc, results, ir_get_type_info_ptr(proc, t->Proc.results));
-			}
-			ir_emit_store(proc, variadic, ir_const_bool(t->Proc.variadic));
-			ir_emit_store(proc, convention, ir_const_u8(t->Proc.calling_convention));
-
-			// TODO(bill): TypeInfo for procedures
-			break;
-		}
-		case Type_Tuple: {
-			ir_emit_comment(proc, str_lit("Type_Info_Tuple"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_tuple_ptr);
-
-			irValue *memory_types = ir_type_info_member_types_offset(proc, t->Tuple.variables.count);
-			irValue *memory_names = ir_type_info_member_names_offset(proc, t->Tuple.variables.count);
-
-			for_array(i, t->Tuple.variables) {
-				// NOTE(bill): offset is not used for tuples
-				Entity *f = t->Tuple.variables[i];
-
-				irValue *index     = ir_const_int(i);
-				irValue *type_info = ir_emit_ptr_offset(proc, memory_types, index);
-
-				ir_emit_store(proc, type_info, ir_type_info(proc, f->type));
-				if (f->token.string.len > 0) {
-					irValue *name = ir_emit_ptr_offset(proc, memory_names, index);
-					ir_emit_store(proc, name, ir_const_string(proc->module, f->token.string));
-				}
-			}
-
-			irValue *count = ir_const_int(t->Tuple.variables.count);
-			ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 0), memory_types, count);
-			ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 1), memory_names, count);
-			break;
-		}
-		case Type_Enum:
-			ir_emit_comment(proc, str_lit("Type_Info_Enum"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_enum_ptr);
-			{
-				GB_ASSERT(t->Enum.base_type != nullptr);
-				irValue *base = ir_type_info(proc, t->Enum.base_type);
-				ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), base);
-
-				if (t->Enum.fields.count > 0) {
-					auto fields = t->Enum.fields;
-					irValue *name_array  = ir_generate_array(m, t_string, fields.count,
-					                                         str_lit("$enum_names"), cast(i64)entry_index);
-					irValue *value_array = ir_generate_array(m, t_type_info_enum_value, fields.count,
-					                                         str_lit("$enum_values"), cast(i64)entry_index);
-
-					GB_ASSERT(is_type_integer(t->Enum.base_type));
-
-					for_array(i, fields) {
-						irValue *name_ep  = ir_emit_array_epi(proc, name_array, cast(i32)i);
-						irValue *value_ep = ir_emit_array_epi(proc, value_array, cast(i32)i);
-
-						ExactValue value = fields[i]->Constant.value;
-						irValue *v = ir_value_constant(t_i64, value);
-
-						ir_emit_store(proc, value_ep, v);
-						ir_emit_store(proc, name_ep, ir_const_string(proc->module, fields[i]->token.string));
-					}
-
-					irValue *v_count = ir_const_int(fields.count);
-
-					irValue *names = ir_emit_struct_ep(proc, tag, 1);
-					irValue *name_array_elem = ir_array_elem(proc, name_array);
-					ir_fill_slice(proc, names, name_array_elem, v_count);
-
-					irValue *values = ir_emit_struct_ep(proc, tag, 2);
-					irValue *value_array_elem = ir_array_elem(proc, value_array);
-					ir_fill_slice(proc, values, value_array_elem, v_count);
-				}
-			}
-			break;
-
-		case Type_Union: {
-			ir_emit_comment(proc, str_lit("Type_Info_Union"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_union_ptr);
-
-			{
-				irValue *variant_types    = ir_emit_struct_ep(proc, tag, 0);
-				irValue *tag_offset_ptr   = ir_emit_struct_ep(proc, tag, 1);
-				irValue *tag_type_ptr     = ir_emit_struct_ep(proc, tag, 2);
-				irValue *custom_align_ptr = ir_emit_struct_ep(proc, tag, 3);
-				irValue *no_nil_ptr       = ir_emit_struct_ep(proc, tag, 4);
-				irValue *maybe_ptr        = ir_emit_struct_ep(proc, tag, 5);
-
-				isize variant_count = gb_max(0, t->Union.variants.count);
-				irValue *memory_types = ir_type_info_member_types_offset(proc, variant_count);
-
-				// NOTE(bill): Zeroth is nil so ignore it
-				for (isize variant_index = 0; variant_index < variant_count; variant_index++) {
-					Type *vt = t->Union.variants[variant_index];
-					irValue *tip = ir_get_type_info_ptr(proc, vt);
-
-					irValue *index     = ir_const_int(variant_index);
-					irValue *type_info = ir_emit_ptr_offset(proc, memory_types, index);
-					ir_emit_store(proc, type_info, ir_type_info(proc, vt));
-				}
-
-				irValue *count = ir_const_int(variant_count);
-				ir_fill_slice(proc, variant_types, memory_types, count);
-
-				i64 tag_size   = union_tag_size(t);
-				i64 tag_offset = align_formula(t->Union.variant_block_size, tag_size);
-
-				if (tag_size > 0) {
-					ir_emit_store(proc, tag_offset_ptr, ir_const_uintptr(tag_offset));
-					ir_emit_store(proc, tag_type_ptr,   ir_type_info(proc, union_tag_type(t)));
-				}
-
-				irValue *is_custom_align = ir_const_bool(t->Union.custom_align != 0);
-				ir_emit_store(proc, custom_align_ptr, is_custom_align);
-
-				ir_emit_store(proc, no_nil_ptr, ir_const_bool(t->Union.no_nil));
-				ir_emit_store(proc, maybe_ptr, ir_const_bool(t->Union.maybe));
-			}
-
-			break;
-		}
-
-		case Type_Struct: {
-			ir_emit_comment(proc, str_lit("Type_Info_Struct"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_struct_ptr);
-
-			{
-				irValue *is_packed       = ir_const_bool(t->Struct.is_packed);
-				irValue *is_raw_union    = ir_const_bool(t->Struct.is_raw_union);
-				irValue *is_custom_align = ir_const_bool(t->Struct.custom_align != 0);
-				ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 5), is_packed);
-				ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 6), is_raw_union);
-				ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 7), is_custom_align);
-
-				if (is_type_comparable(t) && !is_type_simple_compare(t)) {
-					ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 8), ir_get_equal_proc_for_type(proc->module, t));
-				}
-
-
-				if (t->Struct.soa_kind != StructSoa_None) {
-					irValue *kind = ir_emit_struct_ep(proc, tag, 9);
-					Type *kind_type = type_deref(ir_type(kind));
-
-					irValue *soa_kind = ir_value_constant(kind_type, exact_value_i64(t->Struct.soa_kind));
-					irValue *soa_type = ir_type_info(proc, t->Struct.soa_elem);
-					irValue *soa_len = ir_const_int(t->Struct.soa_count);
-
-
-					ir_emit_store(proc, kind, soa_kind);
-					ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 10), soa_type);
-					ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 11), soa_len);
-				}
-			}
-
-			isize count = t->Struct.fields.count;
-			if (count > 0) {
-				irValue *memory_types   = ir_type_info_member_types_offset  (proc, count);
-				irValue *memory_names   = ir_type_info_member_names_offset  (proc, count);
-				irValue *memory_offsets = ir_type_info_member_offsets_offset(proc, count);
-				irValue *memory_usings  = ir_type_info_member_usings_offset (proc, count);
-				irValue *memory_tags    = ir_type_info_member_tags_offset   (proc, count);
-
-				type_set_offsets(t); // NOTE(bill): Just incase the offsets have not been set yet
-				for (isize source_index = 0; source_index < count; source_index++) {
-					// TODO(bill): Order fields in source order not layout order
-					Entity *f = t->Struct.fields[source_index];
-					irValue *tip = ir_get_type_info_ptr(proc, f->type);
-					i64 foffset = 0;
-					if (!t->Struct.is_raw_union) {
-						foffset = t->Struct.offsets[f->Variable.field_index];
-					}
-					GB_ASSERT(f->kind == Entity_Variable && f->flags & EntityFlag_Field);
-
-					irValue *index     = ir_const_int(source_index);
-					irValue *type_info = ir_emit_ptr_offset(proc, memory_types,   index);
-					irValue *offset    = ir_emit_ptr_offset(proc, memory_offsets, index);
-					irValue *is_using  = ir_emit_ptr_offset(proc, memory_usings,  index);
-
-					ir_emit_store(proc, type_info, ir_type_info(proc, f->type));
-					if (f->token.string.len > 0) {
-						irValue *name = ir_emit_ptr_offset(proc, memory_names,   index);
-						ir_emit_store(proc, name, ir_const_string(proc->module, f->token.string));
-					}
-					ir_emit_store(proc, offset, ir_const_uintptr(foffset));
-					ir_emit_store(proc, is_using, ir_const_bool((f->flags&EntityFlag_Using) != 0));
-
-					if (t->Struct.tags.count > 0) {
-						String tag_string = t->Struct.tags[source_index];
-						if (tag_string.len > 0) {
-							irValue *tag_ptr = ir_emit_ptr_offset(proc, memory_tags, index);
-							ir_emit_store(proc, tag_ptr, ir_const_string(proc->module, tag_string));
-						}
-					}
-
-				}
-
-				irValue *cv = ir_const_int(count);
-				ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 0), memory_types,   cv);
-				ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 1), memory_names,   cv);
-				ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 2), memory_offsets, cv);
-				ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 3), memory_usings,  cv);
-				ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 4), memory_tags,    cv);
-			}
-			break;
-		}
-		case Type_Map: {
-			ir_emit_comment(proc, str_lit("Type_Info_Map"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_map_ptr);
-			init_map_internal_types(t);
-
-			irValue *key              = ir_emit_struct_ep(proc, tag, 0);
-			irValue *value            = ir_emit_struct_ep(proc, tag, 1);
-			irValue *generated_struct = ir_emit_struct_ep(proc, tag, 2);
-			irValue *key_equal        = ir_emit_struct_ep(proc, tag, 3);
-			irValue *key_hasher       = ir_emit_struct_ep(proc, tag, 4);
-
-			ir_emit_store(proc, key,              ir_get_type_info_ptr(proc, t->Map.key));
-			ir_emit_store(proc, value,            ir_get_type_info_ptr(proc, t->Map.value));
-			ir_emit_store(proc, generated_struct, ir_get_type_info_ptr(proc, t->Map.generated_struct_type));
-			ir_emit_store(proc, key_equal,        ir_get_equal_proc_for_type(proc->module, t->Map.key));
-			ir_emit_store(proc, key_hasher,       ir_get_hasher_proc_for_type(proc->module, t->Map.key));
-			break;
-		}
-
-		case Type_BitSet:
-			ir_emit_comment(proc, str_lit("Type_Info_Bit_Set"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_bit_set_ptr);
-
-			GB_ASSERT(is_type_typed(t->BitSet.elem));
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->BitSet.elem));
-			if (t->BitSet.underlying != nullptr) {
-				ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), ir_get_type_info_ptr(proc, t->BitSet.underlying));
-			}
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 2), ir_const_i64(t->BitSet.lower));
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 3), ir_const_i64(t->BitSet.upper));
-			break;
-
-		case Type_SimdVector:
-			ir_emit_comment(proc, str_lit("Type_SimdVector"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_simd_vector_ptr);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->SimdVector.elem));
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), ir_const_int(type_size_of(t->SimdVector.elem)));
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 2), ir_const_int(t->SimdVector.count));
-			break;
-
-		case Type_RelativePointer:
-			ir_emit_comment(proc, str_lit("Type_RelativePointer"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_relative_pointer_ptr);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->RelativePointer.pointer_type));
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->RelativePointer.base_integer));
-			break;
-
-		case Type_RelativeSlice:
-			ir_emit_comment(proc, str_lit("Type_RelativeSlice"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_relative_slice_ptr);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->RelativePointer.pointer_type));
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->RelativePointer.base_integer));
-			break;
-		}
-
-
-		if (tag != nullptr) {
-			Type *tag_type = type_deref(ir_type(tag));
-			GB_ASSERT(is_type_named(tag_type));
-			ir_emit_store_union_variant(proc, variant_ptr, ir_emit_load(proc, tag), tag_type);
-		} else {
-			if (t != t_llvm_bool) {
-				GB_PANIC("Unhandled Type_Info variant: %s", type_to_string(t));
-			}
-		}
-	}
-}
-
-void ir_gen_tree(irGen *s) {
-	irModule *m = &s->module;
-	CheckerInfo *info = m->info;
-	gbAllocator a = ir_allocator();
-
-	if (v_zero == nullptr) {
-		v_zero    = ir_const_int (0);
-		v_one     = ir_const_int (1);
-		v_zero32  = ir_const_i32 (0);
-		v_one32   = ir_const_i32 (1);
-		v_two32   = ir_const_i32 (2);
-		v_false   = ir_const_bool(false);
-		v_true    = ir_const_bool(true);
-		v_raw_nil = ir_value_constant(t_rawptr, exact_value_pointer(0));
-	}
-
-	isize global_variable_max_count = 0;
-	Entity *entry_point = info->entry_point;
-	bool has_dll_main = false;
-	bool has_win_main = false;
-
-	for_array(i, info->entities) {
-		Entity *e = info->entities[i];
-		String name = e->token.string;
-
-		bool is_global = e->pkg != nullptr;
-
-		if (e->kind == Entity_Variable) {
-			global_variable_max_count++;
-		} else if (e->kind == Entity_Procedure && !is_global) {
-			if ((e->scope->flags&ScopeFlag_Init) && name == "main") {
-				GB_ASSERT(e == entry_point);
-				// entry_point = e;
-			}
-			if (e->Procedure.is_export ||
-			    (e->Procedure.link_name.len > 0) ||
-			    ((e->scope->flags&ScopeFlag_File) && e->Procedure.link_name.len > 0)) {
-				if (!has_dll_main && name == "DllMain") {
-					has_dll_main = true;
-				} else if (!has_win_main && name == "WinMain") {
-					has_win_main = true;
-				}
-			}
-		}
-	}
-
-	struct irGlobalVariable {
-		irValue *var, *init;
-		DeclInfo *decl;
-	};
-	auto global_variables = array_make<irGlobalVariable>(m->tmp_allocator, 0, global_variable_max_count);
-
-	m->entry_point_entity = entry_point;
-	m->min_dep_set = info->minimum_dependency_set;
-
-	for_array(i, info->variable_init_order) {
-		DeclInfo *d = info->variable_init_order[i];
-
-		Entity *e = d->entity;
-
-		if ((e->scope->flags & ScopeFlag_File) == 0) {
-			continue;
-		}
-
-		if (!ir_min_dep_entity(m, e)) {
-			continue;
-		}
-
-
-		DeclInfo *decl = decl_info_of_entity(e);
-		if (decl == nullptr) {
-			continue;
-		}
-		GB_ASSERT(e->kind == Entity_Variable);
-
-		bool is_foreign = e->Variable.is_foreign;
-		bool is_export  = e->Variable.is_export;
-		bool no_name_mangle = e->Variable.link_name.len > 0 || is_foreign || is_export;
-
-		String name = e->token.string;
-		if (e->Variable.link_name.len > 0) {
-			name = e->Variable.link_name;
-		}
-		if (!no_name_mangle) {
-			name = ir_mangle_name(s, e);
-		}
-		ir_add_entity_name(m, e, name);
-
-		irValue *g = ir_value_global(e, nullptr);
-		g->Global.name = name;
-		g->Global.thread_local_model = e->Variable.thread_local_model;
-		g->Global.is_foreign = is_foreign;
-		g->Global.is_export  = is_export;
-
-		irGlobalVariable var = {};
-		var.var = g;
-		var.decl = decl;
-
-		if (decl->init_expr != nullptr && !is_type_any(e->type)) {
-			TypeAndValue tav = type_and_value_of_expr(decl->init_expr);
-			if (tav.mode != Addressing_Invalid) {
-				if (tav.value.kind != ExactValue_Invalid) {
-					ExactValue v = tav.value;
-					g->Global.value = ir_add_module_constant(m, tav.type, v);
-				}
-			}
-		}
-
-		array_add(&global_variables, var);
-
-		ir_module_add_value(m, e, g);
-		string_map_set(&m->members, name, g);
-	}
-
-	for_array(i, info->entities) {
-		Entity *  e     = info->entities[i];
-		String    name  = e->token.string;
-		DeclInfo *decl  = e->decl_info;
-		Scope *   scope = e->scope;
-
-		if ((scope->flags & ScopeFlag_File) == 0) {
-			continue;
-		}
-
-		Scope *package_scope = scope->parent;
-		GB_ASSERT(package_scope->flags & ScopeFlag_Pkg);
-
-		switch (e->kind) {
-		case Entity_Variable:
-			// NOTE(bill): Handled above as it requires a specific load order
-			continue;
-		case Entity_ProcGroup:
-			continue;
-
-		case Entity_Procedure:
-			break;
-		}
-
-		bool polymorphic_struct = false;
-		if (e->type != nullptr && e->kind == Entity_TypeName) {
-			Type *bt = base_type(e->type);
-			if (bt->kind == Type_Struct) {
-				polymorphic_struct = is_type_polymorphic(bt);
-			}
-		}
-
-		if (!polymorphic_struct && !ir_min_dep_entity(m, e)) {
-			// NOTE(bill): Nothing depends upon it so doesn't need to be built
-			continue;
-		}
-
-		String original_name = name;
-
-	#if 0
-		if (!package_scope->is_global || polymorphic_struct || is_type_polymorphic(e->type)) {
-			if (e->kind == Entity_Procedure && e->Procedure.is_export) {
-			} else if (e->kind == Entity_Procedure && e->Procedure.link_name.len > 0) {
-				// Handle later
-			} else {
-				name = ir_mangle_name(s, e);
-			}
-		}
-	#else
-			if (e->kind == Entity_Procedure && e->Procedure.is_export) {
-				// Okay
-			} else if (e->kind == Entity_Procedure && e->Procedure.link_name.len > 0) {
-				// Handle later
-			} else {
-				name = ir_mangle_name(s, e);
-			}
-	#endif
-
-		ir_add_entity_name(m, e, name);
-
-		switch (e->kind) {
-		case Entity_TypeName:
-			ir_gen_global_type_name(m, e, name);
-			break;
-
-		case Entity_Procedure: {
-			ast_node(pl, ProcLit, decl->proc_lit);
-			String original_name = name;
-			Ast *body = pl->body;
-
-			if (e->Procedure.is_foreign) {
-				name = e->token.string; // NOTE(bill): Don't use the mangled name
-				ir_add_foreign_library_path(m, e->Procedure.foreign_library);
-			}
-			if (e->Procedure.link_name.len > 0) {
-				name = e->Procedure.link_name;
-			}
-
-			Ast *type_expr = pl->type;
-
-			set_procedure_abi_types(e->type);
-			irValue *p = ir_value_procedure(m, e, e->type, type_expr, body, name);
-			p->Proc.tags = pl->tags;
-			p->Proc.inlining = pl->inlining;
-			p->Proc.is_export = e->Procedure.is_export;
-
-			ir_module_add_value(m, e, p);
-			StringHashKey hash_name = string_hash_string(name);
-			if (string_map_get(&m->members, hash_name) == nullptr) {
-				string_map_set(&m->members, hash_name, p);
-			}
-			break;
-		}
-		}
-	}
-
-	for_array(i, m->members.entries) {
-		auto *entry = &m->members.entries[i];
-		irValue *v = entry->value;
-		if (v->kind == irValue_Proc) {
-			ir_build_proc(v, nullptr);
-		}
-	}
-
-	irDebugInfo *compile_unit = m->debug_info.entries[0].value;
-	GB_ASSERT(compile_unit->kind == irDebugInfo_CompileUnit);
-
-	for_array(i, m->info->required_foreign_imports_through_force) {
-		Entity *e = m->info->required_foreign_imports_through_force[i];
-		ir_add_foreign_library_path(m, e);
-	}
-
-
-#if defined(GB_SYSTEM_WINDOWS)
-	if (build_context.build_mode == BuildMode_DynamicLibrary && !has_dll_main && !build_context.no_entry_point) {
-		// DllMain :: proc(inst: rawptr, reason: u32, reserved: rawptr) -> i32
-		String name = str_lit("DllMain");
-		Type *proc_params = alloc_type_tuple();
-		Type *proc_results = alloc_type_tuple();
-
-		Scope *proc_scope = gb_alloc_item(a, Scope);
-
-		array_init(&proc_params->Tuple.variables, a, 3);
-		array_init(&proc_results->Tuple.variables, a, 1);
-
-		proc_params->Tuple.variables[0] = alloc_entity_param(proc_scope, blank_token, t_rawptr, false, false);
-		proc_params->Tuple.variables[1] = alloc_entity_param(proc_scope, make_token_ident(str_lit("reason")), t_i32, false, false);
-		proc_params->Tuple.variables[2] = alloc_entity_param(proc_scope, blank_token, t_rawptr, false, false);
-
-
-		proc_results->Tuple.variables[0] = alloc_entity_param(proc_scope, empty_token, t_i32, false, false);
-
-
-		Type *proc_type = alloc_type_proc(proc_scope,
-		                                  proc_params, 3,
-		                                  proc_results, 1, false, ProcCC_StdCall);
-
-		// TODO(bill): make this more robust
-		proc_type->Proc.abi_compat_params = array_make<Type *>(a, proc_params->Tuple.variables.count);
-		for_array(i, proc_params->Tuple.variables) {
-			proc_type->Proc.abi_compat_params[i] = proc_params->Tuple.variables[i]->type;
-		}
-		proc_type->Proc.abi_compat_result_type = proc_results->Tuple.variables[0]->type;
-
-		Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
-		Entity *e = alloc_entity_procedure(nullptr, make_token_ident(name), proc_type, 0);
-		irValue *p = ir_value_procedure(m, e, proc_type, nullptr, body, name);
-		p->Proc.is_startup = true;
-
-		map_set(&m->values, hash_entity(e), p);
-		string_map_set(&m->members, name, p);
-
-		irProcedure *proc = &p->Proc;
-		proc->inlining = ProcInlining_no_inline; // TODO(bill): is no_inline a good idea?
-		proc->is_entry_point = true;
-		e->Procedure.link_name = name;
-
-		ir_begin_procedure_body(proc);
-		defer (ir_end_procedure_body(proc));
-
-		// NOTE(bill): https://msdn.microsoft.com/en-us/library/windows/desktop/ms682583(v=vs.85).aspx
-		// DLL_PROCESS_ATTACH == 1
-
-		irAddr reason_addr = ir_build_addr_from_entity(proc, proc_params->Tuple.variables[1], nullptr);
-		irValue *cond = ir_emit_comp(proc, Token_CmpEq, ir_addr_load(proc, reason_addr), v_one32);
-		irBlock *then = ir_new_block(proc, nullptr, "if.then");
-		irBlock *done = ir_new_block(proc, nullptr, "if.done"); // NOTE(bill): Append later
-		ir_emit_if(proc, cond, then, done);
-		ir_start_block(proc, then);
-
-		{
-			irValue **found = map_get(&m->values, hash_entity(entry_point));
-			ir_emit(proc, ir_alloc_instr(proc, irInstr_StartupRuntime));
-			if (found != nullptr) {
-				Array<irValue *> args = {};
-				ir_emit_call(proc, *found, args);
-			}
-		}
-
-		ir_emit_jump(proc, done);
-		ir_start_block(proc, done);
-
-		ir_emit_return(proc, v_one32);
-	}
-#endif
-	if (!(build_context.build_mode == BuildMode_DynamicLibrary && !has_dll_main) && !build_context.no_entry_point) {
-		// main :: proc(argc: i32, argv: ^^u8) -> i32
-		String name = str_lit("main");
-
-#if 0
-		if (str_eq_ignore_case(cross_compile_target, str_lit("Essence"))) {
-			// This is a bit hacky,
-			// because this makes this function the first function run in the executable
-			// so it won't actually have the argc/argv arguments.
-			name = str_lit("ProgramEntry");
-		}
-#endif
-
-		Type *proc_params = alloc_type_tuple();
-		Type *proc_results = alloc_type_tuple();
-
-		Scope *proc_scope = gb_alloc_item(a, Scope);
-
-		array_init(&proc_params->Tuple.variables, a, 2);
-		array_init(&proc_results->Tuple.variables, a, 1);
-
-		Type *cstring_ptr = alloc_type_pointer(t_cstring);
-		proc_params->Tuple.variables[0] = alloc_entity_param(proc_scope, make_token_ident(str_lit("argc")), t_i32, false, false);
-		proc_params->Tuple.variables[1] = alloc_entity_param(proc_scope, make_token_ident(str_lit("argv")), cstring_ptr, false, false);
-
-
-		proc_results->Tuple.variables[0] = alloc_entity_param(proc_scope, empty_token, t_i32, false, false);
-
-
-		Type *proc_type = alloc_type_proc(proc_scope,
-		                                  proc_params, 2,
-		                                  proc_results, 1, false, ProcCC_CDecl);
-
-		// TODO(bill): make this more robust
-		proc_type->Proc.abi_compat_params = array_make<Type *>(a, proc_params->Tuple.variables.count);
-		for_array(i, proc_params->Tuple.variables) {
-			proc_type->Proc.abi_compat_params[i] = proc_params->Tuple.variables[i]->type;
-		}
-		proc_type->Proc.abi_compat_result_type = proc_results->Tuple.variables[0]->type;
-
-		Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
-		Entity *e     = alloc_entity_procedure(nullptr, make_token_ident(name), proc_type, 0);
-		irValue *p    = ir_value_procedure(m, e, proc_type, nullptr, body, name);
-		p->Proc.is_startup = true;
-
-		map_set(&m->values, hash_entity(e), p);
-		string_map_set(&m->members, name, p);
-
-		irProcedure *proc = &p->Proc;
-		proc->inlining = ProcInlining_no_inline; // TODO(bill): is no_inline a good idea?
-		proc->is_entry_point = true;
-		e->Procedure.link_name = name;
-
-		ir_begin_procedure_body(proc);
-		defer (ir_end_procedure_body(proc));
-
-		// NOTE(bill): https://msdn.microsoft.com/en-us/library/windows/desktop/ms682583(v=vs.85).aspx
-		// DLL_PROCESS_ATTACH == 1
-
-		irValue *argc = ir_emit_load(proc, *map_get(&proc->module->values, hash_entity(proc_params->Tuple.variables[0])));
-		irValue *argv = ir_emit_load(proc, *map_get(&proc->module->values, hash_entity(proc_params->Tuple.variables[1])));
-
-		irValue *global_args = ir_find_global_variable(proc, str_lit("args__"));
-
-		ir_fill_slice(proc, global_args, argv, ir_emit_conv(proc, argc, t_int));
-
-		ir_emit(proc, ir_alloc_instr(proc, irInstr_StartupRuntime));
-		Array<irValue *> empty_args = {};
-		if (build_context.command_kind == Command_test) {
-			Type *t_Internal_Test = find_type_in_pkg(m->info, str_lit("testing"), str_lit("Internal_Test"));
-			Type *array_type = alloc_type_array(t_Internal_Test, m->info->testing_procedures.count);
-			Type *slice_type = alloc_type_slice(t_Internal_Test);
-			irValue *all_tests_array = ir_add_global_generated(proc->module, array_type, nullptr);
-
-			for_array(i, m->info->testing_procedures) {
-				Entity *testing_proc = m->info->testing_procedures[i];
-				String name = testing_proc->token.string;
-				irValue **found = map_get(&m->values, hash_entity(testing_proc));
-				GB_ASSERT(found != nullptr);
-
-				String pkg_name = {};
-				if (testing_proc->pkg != nullptr) {
-					pkg_name = testing_proc->pkg->name;
-				}
-				irValue *v_pkg = ir_find_or_add_entity_string(m, pkg_name);
-				irValue *v_name = ir_find_or_add_entity_string(m, name);
-				irValue *v_p = *found;
-
-
-				irValue *elem_ptr = ir_emit_array_epi(proc, all_tests_array, cast(i32)i);
-				irValue *pkg_ptr  = ir_emit_struct_ep(proc, elem_ptr, 0);
-				irValue *name_ptr = ir_emit_struct_ep(proc, elem_ptr, 1);
-				irValue *p_ptr    = ir_emit_struct_ep(proc, elem_ptr, 2);
-				ir_emit_store(proc, pkg_ptr,  v_pkg);
-				ir_emit_store(proc, name_ptr, v_name);
-				ir_emit_store(proc, p_ptr,    v_p);
-			}
-
-			irValue *all_tests_slice = ir_add_local_generated(proc, slice_type, true);
-			ir_fill_slice(proc, all_tests_slice,
-			              ir_array_elem(proc, all_tests_array),
-			              ir_const_int(m->info->testing_procedures.count));
-
-
-			irValue *runner = ir_get_package_value(m, str_lit("testing"), str_lit("runner"));
-
-			auto args = array_make<irValue *>(temporary_allocator(), 1);
-			args[0] = ir_emit_load(proc, all_tests_slice);
-			ir_emit_call(proc, runner, args);
-		} else {
-			irValue **found = map_get(&proc->module->values, hash_entity(entry_point));
-			if (found != nullptr) {
-				ir_emit_call(proc, *found, empty_args);
-			}
-		}
-
-		ir_emit_return(proc, v_zero32);
-	}
-
-#if defined(GB_SYSTEM_WINDOWS)
-	if (build_context.build_mode != BuildMode_DynamicLibrary && build_context.no_crt && !build_context.no_entry_point) {
-		s->print_chkstk = true;
-
-		{
-			// void mainCRTStartup(void)
-			String name = str_lit("mainCRTStartup");
-			Type *proc_params = alloc_type_tuple();
-			Type *proc_results = alloc_type_tuple();
-
-
-			Type *proc_type = alloc_type_proc(nullptr,
-			                                  nullptr, 0,
-			                                  nullptr, 0,
-			                                  false,
-			                                  ProcCC_StdCall);
-
-			Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
-			Entity *e = alloc_entity_procedure(nullptr, make_token_ident(name), proc_type, 0);
-			irValue *p = ir_value_procedure(m, e, proc_type, nullptr, body, name);
-			p->Proc.is_startup = true;
-
-			m->entry_point_entity = e;
-
-			map_set(&m->values, hash_entity(e), p);
-			string_map_set(&m->members, name, p);
-
-			irProcedure *proc = &p->Proc;
-			// proc->tags = ProcTag_no_inline; // TODO(bill): is no_inline a good idea?
-			e->Procedure.link_name = name;
-
-			ir_begin_procedure_body(proc);
-			ir_emit(proc, ir_alloc_instr(proc, irInstr_StartupRuntime));
-			irValue **found = map_get(&proc->module->values, hash_entity(entry_point));
-			if (found != nullptr) {
-				Array<irValue *> args = {};
-				ir_emit_call(proc, *found, args);
-			}
-			ir_end_procedure_body(proc);
-		}
-	}
-#endif
-
-	irValue *startup_type_info = nullptr;
-	{  // Startup Type Info
-		// Cleanup(bill): probably better way of doing code insertion
-		String name = str_lit(IR_STARTUP_TYPE_INFO_PROC_NAME);
-		Type *proc_type = alloc_type_proc(gb_alloc_item(a, Scope),
-		                                  nullptr, 0,
-		                                  nullptr, 0, false,
-		                                  ProcCC_Contextless);
-		Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
-		Entity *e = alloc_entity_procedure(nullptr, make_token_ident(name), proc_type, 0);
-		irValue *p = ir_value_procedure(m, e, proc_type, nullptr, body, name);
-		p->Proc.is_startup = true;
-		startup_type_info = p;
-
-		map_set(&m->values, hash_entity(e), p);
-		string_map_set(&m->members, name, p);
-
-		irProcedure *proc = &p->Proc;
-		proc->inlining = ProcInlining_no_inline; // TODO(bill): is no_inline a good idea?
-
-		ir_begin_procedure_body(proc);
-		ir_setup_type_info_data(proc);
-		ir_end_procedure_body(proc);
-	}
-
-	{ // Startup Runtime
-		// Cleanup(bill): probably better way of doing code insertion
-		String name = str_lit(IR_STARTUP_RUNTIME_PROC_NAME);
-		Type *proc_type = alloc_type_proc(gb_alloc_item(a, Scope),
-		                                  nullptr, 0,
-		                                  nullptr, 0, false,
-		                                  ProcCC_Contextless);
-		Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
-		Entity *e = alloc_entity_procedure(nullptr, make_token_ident(name), proc_type, 0);
-		irValue *p = ir_value_procedure(m, e, proc_type, nullptr, body, name);
-		p->Proc.is_startup = true;
-
-		map_set(&m->values, hash_entity(e), p);
-		string_map_set(&m->members, name, p);
-
-
-		irProcedure *proc = &p->Proc;
-		proc->inlining = ProcInlining_no_inline; // TODO(bill): is no_inline a good idea?
-
-		ir_begin_procedure_body(proc);
-		defer (ir_end_procedure_body(proc));
-
-		ir_emit(proc, ir_instr_call(proc, startup_type_info, nullptr, {}, nullptr, nullptr, ProcInlining_none));
-
-		for_array(i, global_variables) {
-			irGlobalVariable *var = &global_variables[i];
-			if (var->decl->init_expr != nullptr)  {
-				var->init = ir_build_expr(proc, var->decl->init_expr);
-			}
-
-			Entity *e = var->var->Global.entity;
-			GB_ASSERT(e->kind == Entity_Variable);
-
-			if (e->Variable.is_foreign) {
-				Entity *fl = e->Procedure.foreign_library;
-				ir_add_foreign_library_path(m, fl);
-			}
-
-			if (e->flags & EntityFlag_Static) {
-				var->var->Global.is_internal = true;
-			}
-
-			if (var->init != nullptr) {
-				Type *t = type_deref(ir_type(var->var));
-
-				if (is_type_any(t)) {
-					// NOTE(bill): Edge case for 'any' type
-					Type *var_type = default_type(ir_type(var->init));
-					irValue *g = ir_add_global_generated(proc->module, var_type, var->init);
-					ir_emit_store(proc, g, var->init);
-
-					irValue *data = ir_emit_struct_ep(proc, var->var, 0);
-					irValue *ti   = ir_emit_struct_ep(proc, var->var, 1);
-					ir_emit_store(proc, data, ir_emit_conv(proc, g, t_rawptr));
-					ir_emit_store(proc, ti,   ir_type_info(proc, var_type));
-				} else {
-					ir_emit_store(proc, var->var, ir_emit_conv(proc, var->init, t));
-				}
-			}
-		}
-
-	}
-
-	for_array(i, m->procs_to_generate) {
-		irValue *p = m->procs_to_generate[i];
-		ir_build_proc(p, p->Proc.parent);
-	}
-
-	GB_ASSERT_MSG(m->debug_location_stack.count == 0, "Debug location stack contains unpopped entries.");
-
-	// Number debug info
-	for_array(i, m->debug_info.entries) {
-		auto *entry = &m->debug_info.entries[i];
-		irDebugInfo *di = entry->value;
-		di->id = cast(i32)(i+1);
-	}
-
-
-	// 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");
-}
-