Begin clarifying allocation patterns by changing from `heap_allocator` to specific arenas

1 files changed, 114 insertions, 165 deletions

diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 1f20c607d..43f4125ba 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -144,7 +144,7 @@ lbValue lb_addr_get_ptr(lbProcedure *p, lbAddr const &addr) {
 		lbValue h = lb_gen_map_header(p, addr.addr, map_type);
 		lbValue key = lb_gen_map_key(p, addr.map.key, map_type->Map.key);
 
-		auto args = array_make<lbValue>(heap_allocator(), 2);
+		auto args = array_make<lbValue>(permanent_allocator(), 2);
 		args[0] = h;
 		args[1] = key;
 
@@ -209,7 +209,7 @@ void lb_emit_bounds_check(lbProcedure *p, Token token, lbValue index, lbValue le
 	lbValue line = lb_const_int(p->module, t_int, token.pos.line);
 	lbValue column = lb_const_int(p->module, t_int, token.pos.column);
 
-	auto args = array_make<lbValue>(heap_allocator(), 5);
+	auto args = array_make<lbValue>(permanent_allocator(), 5);
 	args[0] = file;
 	args[1] = line;
 	args[2] = column;
@@ -233,7 +233,7 @@ void lb_emit_slice_bounds_check(lbProcedure *p, Token token, lbValue low, lbValu
 	high = lb_emit_conv(p, high, t_int);
 
 	if (!lower_value_used) {
-		auto args = array_make<lbValue>(heap_allocator(), 5);
+		auto args = array_make<lbValue>(permanent_allocator(), 5);
 		args[0] = file;
 		args[1] = line;
 		args[2] = column;
@@ -245,7 +245,7 @@ void lb_emit_slice_bounds_check(lbProcedure *p, Token token, lbValue low, lbValu
 		// No need to convert unless used
 		low  = lb_emit_conv(p, low, t_int);
 
-		auto args = array_make<lbValue>(heap_allocator(), 6);
+		auto args = array_make<lbValue>(permanent_allocator(), 6);
 		args[0] = file;
 		args[1] = line;
 		args[2] = column;
@@ -357,7 +357,7 @@ void lb_addr_store(lbProcedure *p, lbAddr addr, lbValue value) {
 		}
 
 
-		auto args = array_make<lbValue>(heap_allocator(), gb_max(arg_count, param_count));
+		auto args = array_make<lbValue>(permanent_allocator(), gb_max(arg_count, param_count));
 		args[0] = ptr;
 		args[1] = index;
 		args[2] = value;
@@ -594,7 +594,7 @@ lbValue lb_addr_load(lbProcedure *p, lbAddr const &addr) {
 		lbValue h = lb_gen_map_header(p, addr.addr, map_type);
 		lbValue key = lb_gen_map_key(p, addr.map.key, map_type->Map.key);
 
-		auto args = array_make<lbValue>(heap_allocator(), 2);
+		auto args = array_make<lbValue>(permanent_allocator(), 2);
 		args[0] = h;
 		args[1] = key;
 
@@ -773,7 +773,6 @@ void lb_emit_store_union_variant_tag(lbProcedure *p, lbValue parent, Type *varia
 }
 
 void lb_emit_store_union_variant(lbProcedure *p, lbValue parent, lbValue variant, Type *variant_type) {
-	gbAllocator a = heap_allocator();
 	lbValue underlying = lb_emit_conv(p, parent, alloc_type_pointer(variant_type));
 
 	lb_emit_store(p, underlying, variant);
@@ -783,10 +782,9 @@ void lb_emit_store_union_variant(lbProcedure *p, lbValue parent, lbValue variant
 
 void lb_clone_struct_type(LLVMTypeRef dst, LLVMTypeRef src) {
 	unsigned field_count = LLVMCountStructElementTypes(src);
-	LLVMTypeRef *fields = gb_alloc_array(heap_allocator(), LLVMTypeRef, field_count);
+	LLVMTypeRef *fields = gb_alloc_array(temporary_allocator(), LLVMTypeRef, field_count);
 	LLVMGetStructElementTypes(src, fields);
 	LLVMStructSetBody(dst, fields, field_count, LLVMIsPackedStruct(src));
-	gb_free(heap_allocator(), fields);
 }
 
 LLVMTypeRef lb_alignment_prefix_type_hack(lbModule *m, i64 alignment) {
@@ -821,8 +819,6 @@ bool lb_is_elem_const(Ast *elem, Type *elem_type) {
 }
 
 String lb_mangle_name(lbModule *m, Entity *e) {
-	gbAllocator a = heap_allocator();
-
 	String name = e->token.string;
 
 	AstPackage *pkg = e->pkg;
@@ -848,7 +844,7 @@ String lb_mangle_name(lbModule *m, Entity *e) {
 		max_len += 21;
 	}
 
-	char *new_name = gb_alloc_array(a, char, max_len);
+	char *new_name = gb_alloc_array(permanent_allocator(), char, max_len);
 	isize new_name_len = gb_snprintf(
 		new_name, max_len,
 		"%.*s.%.*s", LIT(pkgn), LIT(name)
@@ -899,7 +895,7 @@ String lb_set_nested_type_name_ir_mangled_name(Entity *e, lbProcedure *p) {
 
 	if (p != nullptr) {
 		isize name_len = p->name.len + 1 + ts_name.len + 1 + 10 + 1;
-		char *name_text = gb_alloc_array(heap_allocator(), char, name_len);
+		char *name_text = gb_alloc_array(permanent_allocator(), char, name_len);
 		u32 guid = ++p->module->nested_type_name_guid;
 		name_len = gb_snprintf(name_text, name_len, "%.*s.%.*s-%u", LIT(p->name), LIT(ts_name), guid);
 
@@ -909,7 +905,7 @@ String lb_set_nested_type_name_ir_mangled_name(Entity *e, lbProcedure *p) {
 	} else {
 		// NOTE(bill): a nested type be required before its parameter procedure exists. Just give it a temp name for now
 		isize name_len = 9 + 1 + ts_name.len + 1 + 10 + 1;
-		char *name_text = gb_alloc_array(heap_allocator(), char, name_len);
+		char *name_text = gb_alloc_array(permanent_allocator(), char, name_len);
 		static u32 guid = 0;
 		guid += 1;
 		name_len = gb_snprintf(name_text, name_len, "_internal.%.*s-%u", LIT(ts_name), guid);
@@ -1191,7 +1187,7 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 			if (found) {
 				LLVMTypeKind kind = LLVMGetTypeKind(*found);
 				if (kind == LLVMStructTypeKind) {
-					char const *name = alloc_cstring(heap_allocator(), lb_get_entity_name(m, type->Named.type_name));
+					char const *name = alloc_cstring(permanent_allocator(), lb_get_entity_name(m, type->Named.type_name));
 					LLVMTypeRef llvm_type = LLVMGetTypeByName(m->mod, name);
 					if (llvm_type != nullptr) {
 						return llvm_type;
@@ -1208,7 +1204,7 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 			case Type_Union:
 			case Type_BitField:
 				{
-					char const *name = alloc_cstring(heap_allocator(), lb_get_entity_name(m, type->Named.type_name));
+					char const *name = alloc_cstring(permanent_allocator(), lb_get_entity_name(m, type->Named.type_name));
 					LLVMTypeRef llvm_type = LLVMGetTypeByName(m->mod, name);
 					if (llvm_type != nullptr) {
 						return llvm_type;
@@ -1265,7 +1261,7 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 		{
 			if (type->Struct.is_raw_union) {
 				unsigned field_count = 2;
-				LLVMTypeRef *fields = gb_alloc_array(heap_allocator(), LLVMTypeRef, field_count);
+				LLVMTypeRef *fields = gb_alloc_array(permanent_allocator(), LLVMTypeRef, field_count);
 				i64 alignment = type_align_of(type);
 				unsigned size_of_union = cast(unsigned)type_size_of(type);
 				fields[0] = lb_alignment_prefix_type_hack(m, alignment);
@@ -1282,9 +1278,8 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 			defer (m->internal_type_level -= 1);
 
 			unsigned field_count = cast(unsigned)(type->Struct.fields.count + offset);
-			LLVMTypeRef *fields = gb_alloc_array(heap_allocator(), LLVMTypeRef, field_count);
+			LLVMTypeRef *fields = gb_alloc_array(temporary_allocator(), LLVMTypeRef, field_count);
 			GB_ASSERT(fields != nullptr);
-			defer (gb_free(heap_allocator(), fields));
 
 			for_array(i, type->Struct.fields) {
 				Entity *field = type->Struct.fields[i];
@@ -1344,8 +1339,7 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 			return lb_type(m, type->Tuple.variables[0]->type);
 		} else {
 			unsigned field_count = cast(unsigned)(type->Tuple.variables.count);
-			LLVMTypeRef *fields = gb_alloc_array(heap_allocator(), LLVMTypeRef, field_count);
-			defer (gb_free(heap_allocator(), fields));
+			LLVMTypeRef *fields = gb_alloc_array(temporary_allocator(), LLVMTypeRef, field_count);
 
 			for_array(i, type->Tuple.variables) {
 				Entity *field = type->Tuple.variables[i];
@@ -1444,8 +1438,7 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 			}
 
 			isize param_count = type->Proc.abi_compat_params.count + extra_param_count;
-			auto param_types = array_make<LLVMTypeRef>(heap_allocator(), 0, param_count);
-			defer (array_free(&param_types));
+			auto param_types = array_make<LLVMTypeRef>(temporary_allocator(), 0, param_count);
 
 			if (type->Proc.return_by_pointer) {
 				array_add(&param_types, LLVMPointerType(lb_type(m, type->Proc.abi_compat_result_type), 0));
@@ -1492,8 +1485,7 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 			{
 				GB_ASSERT(type->BitField.fields.count == type->BitField.sizes.count);
 				unsigned field_count = cast(unsigned)type->BitField.fields.count;
-				LLVMTypeRef *fields = gb_alloc_array(heap_allocator(), LLVMTypeRef, field_count);
-				defer (gb_free(heap_allocator(), fields));
+				LLVMTypeRef *fields = gb_alloc_array(temporary_allocator(), LLVMTypeRef, field_count);
 
 				for_array(i, type->BitField.sizes) {
 					u32 size = type->BitField.sizes[i];
@@ -2135,7 +2127,7 @@ lbProcedure *lb_create_procedure(lbModule *m, Entity *entity) {
 	}
 
 
-	lbProcedure *p = gb_alloc_item(heap_allocator(), lbProcedure);
+	lbProcedure *p = gb_alloc_item(permanent_allocator(), lbProcedure);
 
 	p->module = m;
 	entity->code_gen_module = m;
@@ -2149,7 +2141,7 @@ lbProcedure *lb_create_procedure(lbModule *m, Entity *entity) {
 	Type *pt = base_type(entity->type);
 	GB_ASSERT(pt->kind == Type_Proc);
 
-	set_procedure_abi_types(heap_allocator(), entity->type);
+	set_procedure_abi_types(permanent_allocator(), entity->type);
 
 	p->type           = entity->type;
 	p->type_expr      = decl->type_expr;
@@ -2172,7 +2164,7 @@ lbProcedure *lb_create_procedure(lbModule *m, Entity *entity) {
 		lb_add_foreign_library_path(p->module, entity->Procedure.foreign_library);
 	}
 
-	char *c_link_name = alloc_cstring(heap_allocator(), p->name);
+	char *c_link_name = alloc_cstring(permanent_allocator(), p->name);
 	LLVMTypeRef func_ptr_type = lb_type(m, p->type);
 	LLVMTypeRef func_type = LLVMGetElementType(func_ptr_type);
 
@@ -2209,19 +2201,19 @@ lbProcedure *lb_create_procedure(lbModule *m, Entity *entity) {
 		LLVMSetVisibility(p->value, LLVMDefaultVisibility);
 
 		if (build_context.metrics.os == TargetOs_js) {
-			char const *export_name = alloc_cstring(heap_allocator(), p->name);
+			char const *export_name = alloc_cstring(permanent_allocator(), p->name);
 			LLVMAddTargetDependentFunctionAttr(p->value, "wasm-export-name", export_name);
 		}
 	}
 	if (p->is_foreign) {
 		if (build_context.metrics.os == TargetOs_js) {
-			char const *import_name = alloc_cstring(heap_allocator(), p->name);
+			char const *import_name = alloc_cstring(permanent_allocator(), p->name);
 			char const *module_name = "env";
 			if (entity->Procedure.foreign_library != nullptr) {
 				Entity *foreign_library = entity->Procedure.foreign_library;
 				GB_ASSERT(foreign_library->kind == Entity_LibraryName);
 				if (foreign_library->LibraryName.paths.count > 0)  {
-					module_name = alloc_cstring(heap_allocator(), foreign_library->LibraryName.paths[0]);
+					module_name = alloc_cstring(permanent_allocator(), foreign_library->LibraryName.paths[0]);
 				}
 			}
 			LLVMAddTargetDependentFunctionAttr(p->value, "wasm-import-name",   import_name);
@@ -2310,7 +2302,7 @@ lbProcedure *lb_create_dummy_procedure(lbModule *m, String link_name, Type *type
 		GB_ASSERT(found == nullptr);
 	}
 
-	lbProcedure *p = gb_alloc_item(heap_allocator(), lbProcedure);
+	lbProcedure *p = gb_alloc_item(permanent_allocator(), lbProcedure);
 
 	p->module = m;
 	p->name = link_name;
@@ -2324,7 +2316,7 @@ lbProcedure *lb_create_dummy_procedure(lbModule *m, String link_name, Type *type
 	p->is_export      = false;
 	p->is_entry_point = false;
 
-	gbAllocator a = heap_allocator();
+	gbAllocator a = permanent_allocator();
 	p->children.allocator      = a;
 	p->params.allocator        = a;
 	p->defer_stmts.allocator   = a;
@@ -2333,7 +2325,7 @@ lbProcedure *lb_create_dummy_procedure(lbModule *m, String link_name, Type *type
 	p->context_stack.allocator = a;
 
 
-	char *c_link_name = alloc_cstring(heap_allocator(), p->name);
+	char *c_link_name = alloc_cstring(permanent_allocator(), p->name);
 	LLVMTypeRef func_ptr_type = lb_type(m, p->type);
 	LLVMTypeRef func_type = LLVMGetElementType(func_ptr_type);
 
@@ -2833,7 +2825,7 @@ void lb_add_edge(lbBlock *from, lbBlock *to) {
 
 
 lbBlock *lb_create_block(lbProcedure *p, char const *name, bool append) {
-	lbBlock *b = gb_alloc_item(heap_allocator(), lbBlock);
+	lbBlock *b = gb_alloc_item(permanent_allocator(), lbBlock);
 	b->block = LLVMCreateBasicBlockInContext(p->module->ctx, name);
 	b->appended = false;
 	if (append) {
@@ -2932,7 +2924,7 @@ lbAddr lb_add_local(lbProcedure *p, Type *type, Entity *e, bool zero_init, i32 p
 
 	char const *name = "";
 	if (e != nullptr) {
-		// name = alloc_cstring(heap_allocator(), e->token.string);
+		// name = alloc_cstring(permanent_allocator(), e->token.string);
 	}
 
 	LLVMTypeRef llvm_type = lb_type(p->module, type);
@@ -2980,13 +2972,13 @@ void lb_build_nested_proc(lbProcedure *p, AstProcLit *pd, Entity *e) {
 
 
 	isize name_len = p->name.len + 1 + pd_name.len + 1 + 10 + 1;
-	char *name_text = gb_alloc_array(heap_allocator(), char, name_len);
+	char *name_text = gb_alloc_array(permanent_allocator(), char, name_len);
 
 	i32 guid = cast(i32)p->children.count;
 	name_len = gb_snprintf(name_text, name_len, "%.*s.%.*s-%d", LIT(p->name), LIT(pd_name), guid);
 	String name = make_string(cast(u8 *)name_text, name_len-1);
 
-	set_procedure_abi_types(heap_allocator(), e->type);
+	set_procedure_abi_types(permanent_allocator(), e->type);
 
 
 	e->Procedure.link_name = name;
@@ -3123,7 +3115,7 @@ void lb_build_constant_value_decl(lbProcedure *p, AstValueDecl *vd) {
 				return;
 			}
 
-			set_procedure_abi_types(heap_allocator(), e->type);
+			set_procedure_abi_types(permanent_allocator(), e->type);
 			e->Procedure.link_name = name;
 
 			lbProcedure *nested_proc = lb_create_procedure(p->module, e);
@@ -3179,7 +3171,7 @@ lbBranchBlocks lb_lookup_branch_blocks(lbProcedure *p, Ast *ident) {
 
 
 lbTargetList *lb_push_target_list(lbProcedure *p, Ast *label, lbBlock *break_, lbBlock *continue_, lbBlock *fallthrough_) {
-	lbTargetList *tl = gb_alloc_item(heap_allocator(), lbTargetList);
+	lbTargetList *tl = gb_alloc_item(permanent_allocator(), lbTargetList);
 	tl->prev = p->target_list;
 	tl->break_ = break_;
 	tl->continue_ = continue_;
@@ -3400,7 +3392,7 @@ void lb_build_range_string(lbProcedure *p, lbValue expr, Type *val_type,
 
 	lbValue str_elem = lb_emit_ptr_offset(p, lb_string_elem(p, expr), offset);
 	lbValue str_len  = lb_emit_arith(p, Token_Sub, count, offset, t_int);
-	auto args = array_make<lbValue>(heap_allocator(), 1);
+	auto args = array_make<lbValue>(permanent_allocator(), 1);
 	args[0] = lb_emit_string(p, str_elem, str_len);
 	lbValue rune_and_len = lb_emit_runtime_call(p, "string_decode_rune", args);
 	lbValue len  = lb_emit_struct_ev(p, rune_and_len, 1);
@@ -4275,14 +4267,14 @@ void lb_build_stmt(lbProcedure *p, Ast *node) {
 
 				String mangled_name = {};
 				{
-					gbString str = gb_string_make_length(heap_allocator(), p->name.text, p->name.len);
+					gbString str = gb_string_make_length(permanent_allocator(), p->name.text, p->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);
 				}
 
-				char *c_name = alloc_cstring(heap_allocator(), mangled_name);
+				char *c_name = alloc_cstring(permanent_allocator(), mangled_name);
 
 				LLVMValueRef global = LLVMAddGlobal(p->module->mod, lb_type(p->module, e->type), c_name);
 				LLVMSetInitializer(global, LLVMConstNull(lb_type(p->module, e->type)));
@@ -4329,8 +4321,8 @@ void lb_build_stmt(lbProcedure *p, Ast *node) {
 				}
 			}
 		} else { // Tuple(s)
-			auto lvals = array_make<lbAddr>(heap_allocator(), 0, vd->names.count);
-			auto inits = array_make<lbValue>(heap_allocator(), 0, vd->names.count);
+			auto lvals = array_make<lbAddr>(permanent_allocator(), 0, vd->names.count);
+			auto inits = array_make<lbValue>(permanent_allocator(), 0, vd->names.count);
 
 			for_array(i, vd->names) {
 				Ast *name = vd->names[i];
@@ -4367,7 +4359,7 @@ void lb_build_stmt(lbProcedure *p, Ast *node) {
 
 	case_ast_node(as, AssignStmt, node);
 		if (as->op.kind == Token_Eq) {
-			auto lvals = array_make<lbAddr>(heap_allocator(), 0, as->lhs.count);
+			auto lvals = array_make<lbAddr>(permanent_allocator(), 0, as->lhs.count);
 
 			for_array(i, as->lhs) {
 				Ast *lhs = as->lhs[i];
@@ -4385,7 +4377,7 @@ void lb_build_stmt(lbProcedure *p, Ast *node) {
 					lbValue init = lb_build_expr(p, rhs);
 					lb_addr_store(p, lvals[0], init);
 				} else {
-					auto inits = array_make<lbValue>(heap_allocator(), 0, lvals.count);
+					auto inits = array_make<lbValue>(permanent_allocator(), 0, lvals.count);
 
 					for_array(i, as->rhs) {
 						lbValue init = lb_build_expr(p, as->rhs[i]);
@@ -4399,7 +4391,7 @@ void lb_build_stmt(lbProcedure *p, Ast *node) {
 					}
 				}
 			} else {
-				auto inits = array_make<lbValue>(heap_allocator(), 0, lvals.count);
+				auto inits = array_make<lbValue>(permanent_allocator(), 0, lvals.count);
 
 				for_array(i, as->rhs) {
 					lbValue init = lb_build_expr(p, as->rhs[i]);
@@ -4491,7 +4483,7 @@ void lb_build_stmt(lbProcedure *p, Ast *node) {
 			}
 
 		} else {
-			auto results = array_make<lbValue>(heap_allocator(), 0, return_count);
+			auto results = array_make<lbValue>(permanent_allocator(), 0, return_count);
 
 			if (res_count != 0) {
 				for (isize res_index = 0; res_index < res_count; res_index++) {
@@ -4794,9 +4786,8 @@ lbValue lb_emit_min(lbProcedure *p, Type *t, lbValue x, lbValue y) {
 	y = lb_emit_conv(p, y, t);
 
 	if (is_type_float(t)) {
-		gbAllocator a = heap_allocator();
 		i64 sz = 8*type_size_of(t);
-		auto args = array_make<lbValue>(heap_allocator(), 2);
+		auto args = array_make<lbValue>(permanent_allocator(), 2);
 		args[0] = x;
 		args[1] = y;
 		switch (sz) {
@@ -4812,9 +4803,8 @@ lbValue lb_emit_max(lbProcedure *p, Type *t, lbValue x, lbValue y) {
 	y = lb_emit_conv(p, y, t);
 
 	if (is_type_float(t)) {
-		gbAllocator a = heap_allocator();
 		i64 sz = 8*type_size_of(t);
-		auto args = array_make<lbValue>(heap_allocator(), 2);
+		auto args = array_make<lbValue>(permanent_allocator(), 2);
 		args[0] = x;
 		args[1] = y;
 		switch (sz) {
@@ -4850,7 +4840,7 @@ LLVMValueRef lb_find_or_add_entity_string_ptr(lbModule *m, String const &str) {
 
 
 		isize max_len = 7+8+1;
-		char *name = gb_alloc_array(heap_allocator(), char, max_len);
+		char *name = gb_alloc_array(permanent_allocator(), char, max_len);
 		isize len = gb_snprintf(name, max_len, "csbs$%x", m->global_array_index);
 		len -= 1;
 		m->global_array_index++;
@@ -4892,7 +4882,7 @@ lbValue lb_find_or_add_entity_string_byte_slice(lbModule *m, String const &str)
 	char *name = nullptr;
 	{
 		isize max_len = 7+8+1;
-		name = gb_alloc_array(heap_allocator(), char, max_len);
+		name = gb_alloc_array(permanent_allocator(), char, max_len);
 		isize len = gb_snprintf(name, max_len, "csbs$%x", m->global_array_index);
 		len -= 1;
 		m->global_array_index++;
@@ -5103,7 +5093,7 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bool allow_loc
 				}
 			} else {
 				isize max_len = 7+8+1;
-				char *str = gb_alloc_array(heap_allocator(), char, max_len);
+				char *str = gb_alloc_array(permanent_allocator(), char, max_len);
 				isize len = gb_snprintf(str, max_len, "csba$%x", m->global_array_index);
 				m->global_array_index++;
 
@@ -5151,7 +5141,7 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bool allow_loc
 
 		lbValue single_elem = lb_const_value(m, elem, value, allow_local);
 
-		LLVMValueRef *elems = gb_alloc_array(heap_allocator(), LLVMValueRef, count);
+		LLVMValueRef *elems = gb_alloc_array(permanent_allocator(), LLVMValueRef, count);
 		for (i64 i = 0; i < count; i++) {
 			elems[i] = single_elem.value;
 		}
@@ -5204,7 +5194,7 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bool allow_loc
 					isize byte_len = gb_size_of(u64)*len;
 					u8 *old_bytes = cast(u8 *)words;
 					// TODO(bill): Use a different allocator here for a temporary allocation
-					u8 *new_bytes = cast(u8 *)gb_alloc_align(heap_allocator(), byte_len, gb_align_of(u64));
+					u8 *new_bytes = cast(u8 *)gb_alloc_align(permanent_allocator(), byte_len, gb_align_of(u64));
 					for (i64 i = 0; i < sz; i++) {
 						new_bytes[i] = old_bytes[sz-1-i];
 					}
@@ -5291,8 +5281,7 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bool allow_loc
 			if (cl->elems[0]->kind == Ast_FieldValue) {
 				// TODO(bill): This is O(N*M) and will be quite slow; it should probably be sorted before hand
 
-				LLVMValueRef *values = gb_alloc_array(heap_allocator(), LLVMValueRef, type->Array.count);
-				defer (gb_free(heap_allocator(), values));
+				LLVMValueRef *values = gb_alloc_array(temporary_allocator(), LLVMValueRef, type->Array.count);
 
 				isize value_index = 0;
 				for (i64 i = 0; i < type->Array.count; i++) {
@@ -5349,8 +5338,7 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bool allow_loc
 			} else {
 				GB_ASSERT_MSG(elem_count == type->Array.count, "%td != %td", elem_count, type->Array.count);
 
-				LLVMValueRef *values = gb_alloc_array(heap_allocator(), LLVMValueRef, type->Array.count);
-				defer (gb_free(heap_allocator(), values));
+				LLVMValueRef *values = gb_alloc_array(temporary_allocator(), LLVMValueRef, type->Array.count);
 
 				for (isize i = 0; i < elem_count; i++) {
 					TypeAndValue tav = cl->elems[i]->tav;
@@ -5374,8 +5362,7 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bool allow_loc
 			if (cl->elems[0]->kind == Ast_FieldValue) {
 				// TODO(bill): This is O(N*M) and will be quite slow; it should probably be sorted before hand
 
-				LLVMValueRef *values = gb_alloc_array(heap_allocator(), LLVMValueRef, type->EnumeratedArray.count);
-				defer (gb_free(heap_allocator(), values));
+				LLVMValueRef *values = gb_alloc_array(temporary_allocator(), LLVMValueRef, type->EnumeratedArray.count);
 
 				isize value_index = 0;
 
@@ -5436,8 +5423,7 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bool allow_loc
 			} else {
 				GB_ASSERT_MSG(elem_count == type->EnumeratedArray.count, "%td != %td", elem_count, type->EnumeratedArray.count);
 
-				LLVMValueRef *values = gb_alloc_array(heap_allocator(), LLVMValueRef, type->EnumeratedArray.count);
-				defer (gb_free(heap_allocator(), values));
+				LLVMValueRef *values = gb_alloc_array(temporary_allocator(), LLVMValueRef, type->EnumeratedArray.count);
 
 				for (isize i = 0; i < elem_count; i++) {
 					TypeAndValue tav = cl->elems[i]->tav;
@@ -5462,8 +5448,7 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bool allow_loc
 			GB_ASSERT(elem_type_can_be_constant(elem_type));
 
 			isize total_elem_count = type->SimdVector.count;
-			LLVMValueRef *values = gb_alloc_array(heap_allocator(), LLVMValueRef, total_elem_count);
-			defer (gb_free(heap_allocator(), values));
+			LLVMValueRef *values = gb_alloc_array(temporary_allocator(), LLVMValueRef, total_elem_count);
 
 			for (isize i = 0; i < elem_count; i++) {
 				TypeAndValue tav = cl->elems[i]->tav;
@@ -5489,11 +5474,8 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bool allow_loc
 			}
 
 			isize value_count = type->Struct.fields.count + offset;
-			LLVMValueRef *values = gb_alloc_array(heap_allocator(), LLVMValueRef, value_count);
-			bool *visited = gb_alloc_array(heap_allocator(), bool, value_count);
-			defer (gb_free(heap_allocator(), values));
-			defer (gb_free(heap_allocator(), visited));
-
+			LLVMValueRef *values = gb_alloc_array(temporary_allocator(), LLVMValueRef, value_count);
+			bool *visited = gb_alloc_array(temporary_allocator(), bool, value_count);
 
 
 			if (cl->elems.count > 0) {
@@ -5822,7 +5804,7 @@ lbValue lb_emit_arith(lbProcedure *p, TokenKind op, lbValue lhs, lbValue rhs, Ty
 		Type *ft = base_complex_elem_type(type);
 
 		if (op == Token_Quo) {
-			auto args = array_make<lbValue>(heap_allocator(), 2);
+			auto args = array_make<lbValue>(permanent_allocator(), 2);
 			args[0] = lhs;
 			args[1] = rhs;
 
@@ -5896,7 +5878,7 @@ lbValue lb_emit_arith(lbProcedure *p, TokenKind op, lbValue lhs, lbValue rhs, Ty
 
 			return lb_addr_load(p, res);
 		} else if (op == Token_Mul) {
-			auto args = array_make<lbValue>(heap_allocator(), 2);
+			auto args = array_make<lbValue>(permanent_allocator(), 2);
 			args[0] = lhs;
 			args[1] = rhs;
 
@@ -5906,7 +5888,7 @@ lbValue lb_emit_arith(lbProcedure *p, TokenKind op, lbValue lhs, lbValue rhs, Ty
 			default: GB_PANIC("Unknown float type"); break;
 			}
 		} else if (op == Token_Quo) {
-			auto args = array_make<lbValue>(heap_allocator(), 2);
+			auto args = array_make<lbValue>(permanent_allocator(), 2);
 			args[0] = lhs;
 			args[1] = rhs;
 
@@ -6132,7 +6114,7 @@ lbValue lb_build_binary_expr(lbProcedure *p, Ast *expr) {
 					lbValue h = lb_gen_map_header(p, addr, rt);
 					lbValue key = lb_gen_map_key(p, left, rt->Map.key);
 
-					auto args = array_make<lbValue>(heap_allocator(), 2);
+					auto args = array_make<lbValue>(permanent_allocator(), 2);
 					args[0] = h;
 					args[1] = key;
 
@@ -6378,7 +6360,7 @@ lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) {
 
 	if (are_types_identical(src, t_cstring) && are_types_identical(dst, t_string)) {
 		lbValue c = lb_emit_conv(p, value, t_cstring);
-		auto args = array_make<lbValue>(heap_allocator(), 1);
+		auto args = array_make<lbValue>(permanent_allocator(), 1);
 		args[0] = c;
 		lbValue s = lb_emit_runtime_call(p, "cstring_to_string", args);
 		return lb_emit_conv(p, s, dst);
@@ -6395,7 +6377,6 @@ lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) {
 
 	// float -> float
 	if (is_type_float(src) && is_type_float(dst)) {
-		gbAllocator a = heap_allocator();
 		i64 sz = type_size_of(src);
 		i64 dz = type_size_of(dst);
 
@@ -6837,8 +6818,7 @@ void lb_emit_init_context(lbProcedure *p, lbAddr addr) {
 	GB_ASSERT(addr.ctx.sel.index.count == 0);
 
 	lbModule *m = p->module;
-	gbAllocator a = heap_allocator();
-	auto args = array_make<lbValue>(a, 1);
+	auto args = array_make<lbValue>(permanent_allocator(), 1);
 	args[0] = addr.addr;
 	lb_emit_runtime_call(p, "__init_context", args);
 }
@@ -6907,7 +6887,6 @@ lbValue lb_copy_value_to_ptr(lbProcedure *p, lbValue val, Type *new_type, i64 al
 }
 
 lbValue lb_emit_struct_ep(lbProcedure *p, lbValue s, i32 index) {
-	gbAllocator a = heap_allocator();
 	GB_ASSERT(is_type_pointer(s.type));
 	Type *t = base_type(type_deref(s.type));
 	Type *result_type = nullptr;
@@ -7015,7 +6994,6 @@ lbValue lb_emit_struct_ev(lbProcedure *p, lbValue s, i32 index) {
 		return lb_emit_load(p, ptr);
 	}
 
-	gbAllocator a = heap_allocator();
 	Type *t = base_type(s.type);
 	Type *result_type = nullptr;
 
@@ -7121,7 +7099,6 @@ lbValue lb_emit_struct_ev(lbProcedure *p, lbValue s, i32 index) {
 lbValue lb_emit_deep_field_gep(lbProcedure *p, lbValue e, Selection sel) {
 	GB_ASSERT(sel.index.count > 0);
 	Type *type = type_deref(e.type);
-	gbAllocator a = heap_allocator();
 
 	for_array(i, sel.index) {
 		i32 index = cast(i32)sel.index[i];
@@ -7292,14 +7269,14 @@ Array<lbValue> lb_value_to_array(lbProcedure *p, lbValue value) {
 		GB_ASSERT(t->kind == Type_Tuple);
 		auto *rt = &t->Tuple;
 		if (rt->variables.count > 0) {
-			array = array_make<lbValue>(heap_allocator(), rt->variables.count);
+			array = array_make<lbValue>(permanent_allocator(), rt->variables.count);
 			for_array(i, rt->variables) {
 				lbValue elem = lb_emit_struct_ev(p, value, cast(i32)i);
 				array[i] = elem;
 			}
 		}
 	} else {
-		array = array_make<lbValue>(heap_allocator(), 1);
+		array = array_make<lbValue>(permanent_allocator(), 1);
 		array[0] = value;
 	}
 	return array;
@@ -7316,7 +7293,7 @@ lbValue lb_emit_call_internal(lbProcedure *p, lbValue value, lbValue return_ptr,
 		arg_count += 1;
 	}
 
-	LLVMValueRef *args = gb_alloc_array(heap_allocator(), LLVMValueRef, arg_count);
+	LLVMValueRef *args = gb_alloc_array(permanent_allocator(), LLVMValueRef, arg_count);
 	isize arg_index = 0;
 	if (return_ptr.value != nullptr) {
 		args[arg_index++] = return_ptr.value;
@@ -7399,7 +7376,7 @@ lbValue lb_emit_call(lbProcedure *p, lbValue value, Array<lbValue> const &args,
 		LLVMBuildUnreachable(p->builder);
 	});
 
-	set_procedure_abi_types(heap_allocator(), pt);
+	set_procedure_abi_types(permanent_allocator(), pt);
 
 	bool is_c_vararg = pt->Proc.c_vararg;
 	isize param_count = pt->Proc.param_count;
@@ -7412,7 +7389,7 @@ lbValue lb_emit_call(lbProcedure *p, lbValue value, Array<lbValue> const &args,
 
 	lbValue result = {};
 
-	auto processed_args = array_make<lbValue>(heap_allocator(), 0, args.count);
+	auto processed_args = array_make<lbValue>(permanent_allocator(), 0, args.count);
 
 	if (USE_LLVM_ABI) {
 		lbFunctionType **ft_found = nullptr;
@@ -7635,7 +7612,7 @@ lbValue lb_emit_call(lbProcedure *p, lbValue value, Array<lbValue> const &args,
 			case DeferredProcedure_in_out:
 				{
 					auto out_args = lb_value_to_array(p, result);
-					array_init(&result_as_args, heap_allocator(), in_args.count + out_args.count);
+					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);
 				}
@@ -7744,7 +7721,7 @@ lbValue lb_string_len(lbProcedure *p, lbValue string) {
 
 lbValue lb_cstring_len(lbProcedure *p, lbValue value) {
 	GB_ASSERT(is_type_cstring(value.type));
-	auto args = array_make<lbValue>(heap_allocator(), 1);
+	auto args = array_make<lbValue>(permanent_allocator(), 1);
 	args[0] = lb_emit_conv(p, value, t_cstring);
 	return lb_emit_runtime_call(p, "cstring_len", args);
 }
@@ -7782,7 +7759,6 @@ lbValue lb_dynamic_array_allocator(lbProcedure *p, lbValue da) {
 }
 
 lbValue lb_map_entries(lbProcedure *p, lbValue value) {
-	gbAllocator a = heap_allocator();
 	Type *t = base_type(value.type);
 	GB_ASSERT_MSG(t->kind == Type_Map, "%s", type_to_string(t));
 	init_map_internal_types(t);
@@ -7793,7 +7769,6 @@ lbValue lb_map_entries(lbProcedure *p, lbValue value) {
 }
 
 lbValue lb_map_entries_ptr(lbProcedure *p, lbValue value) {
-	gbAllocator a = heap_allocator();
 	Type *t = base_type(type_deref(value.type));
 	GB_ASSERT_MSG(t->kind == Type_Map, "%s", type_to_string(t));
 	init_map_internal_types(t);
@@ -7917,7 +7892,7 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 		}
 		GB_ASSERT(is_type_typeid(tav.type));
 
-		auto args = array_make<lbValue>(heap_allocator(), 1);
+		auto args = array_make<lbValue>(permanent_allocator(), 1);
 		args[0] = lb_build_expr(p, arg);
 		return lb_emit_runtime_call(p, "__type_info_of", args);
 	}
@@ -7994,7 +7969,7 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 			}
 
 			unsigned mask_len = cast(unsigned)index_count;
-			LLVMValueRef *mask_elems = gb_alloc_array(heap_allocator(), LLVMValueRef, index_count);
+			LLVMValueRef *mask_elems = gb_alloc_array(permanent_allocator(), LLVMValueRef, index_count);
 			for (isize i = 1; i < ce->args.count; i++) {
 				TypeAndValue tv = type_and_value_of_expr(ce->args[i]);
 				GB_ASSERT(is_type_integer(tv.type));
@@ -8224,7 +8199,6 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 	}
 
 	case BuiltinProc_abs: {
-		gbAllocator a = heap_allocator();
 		lbValue x = lb_build_expr(p, ce->args[0]);
 		Type *t = x.type;
 		if (is_type_unsigned(t)) {
@@ -8232,7 +8206,7 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 		}
 		if (is_type_quaternion(t)) {
 			i64 sz = 8*type_size_of(t);
-			auto args = array_make<lbValue>(heap_allocator(), 1);
+			auto args = array_make<lbValue>(permanent_allocator(), 1);
 			args[0] = x;
 			switch (sz) {
 			case 128: return lb_emit_runtime_call(p, "abs_quaternion128", args);
@@ -8241,7 +8215,7 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 			GB_PANIC("Unknown complex type");
 		} else if (is_type_complex(t)) {
 			i64 sz = 8*type_size_of(t);
-			auto args = array_make<lbValue>(heap_allocator(), 1);
+			auto args = array_make<lbValue>(permanent_allocator(), 1);
 			args[0] = x;
 			switch (sz) {
 			case 64:  return lb_emit_runtime_call(p, "abs_complex64",  args);
@@ -8250,7 +8224,7 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 			GB_PANIC("Unknown complex type");
 		} else if (is_type_float(t)) {
 			i64 sz = 8*type_size_of(t);
-			auto args = array_make<lbValue>(heap_allocator(), 1);
+			auto args = array_make<lbValue>(permanent_allocator(), 1);
 			args[0] = x;
 			switch (sz) {
 			case 32: return lb_emit_runtime_call(p, "abs_f32", args);
@@ -8506,7 +8480,7 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 
 		GB_ASSERT(tv.type->kind == Type_Tuple);
 		Type *fix_typed = alloc_type_tuple();
-		array_init(&fix_typed->Tuple.variables, heap_allocator(), 2);
+		array_init(&fix_typed->Tuple.variables, permanent_allocator(), 2);
 		fix_typed->Tuple.variables[0] = tv.type->Tuple.variables[0];
 		fix_typed->Tuple.variables[1] = alloc_entity_field(nullptr, blank_token, t_llvm_bool, false, 1);
 
@@ -8621,10 +8595,10 @@ lbValue lb_build_call_expr(lbProcedure *p, Ast *expr) {
 	Type *proc_type_ = base_type(value.type);
 	GB_ASSERT(proc_type_->kind == Type_Proc);
 	TypeProc *pt = &proc_type_->Proc;
-	set_procedure_abi_types(heap_allocator(), proc_type_);
+	set_procedure_abi_types(permanent_allocator(), proc_type_);
 
 	if (is_call_expr_field_value(ce)) {
-		auto args = array_make<lbValue>(heap_allocator(), pt->param_count);
+		auto args = array_make<lbValue>(permanent_allocator(), pt->param_count);
 
 		for_array(arg_index, ce->args) {
 			Ast *arg = ce->args[arg_index];
@@ -8693,7 +8667,7 @@ lbValue lb_build_call_expr(lbProcedure *p, Ast *expr) {
 		param_count = pt->params->Tuple.variables.count;
 	}
 
-	auto args = array_make<lbValue>(heap_allocator(), cast(isize)gb_max(param_count, arg_count));
+	auto args = array_make<lbValue>(permanent_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;
@@ -8801,7 +8775,6 @@ lbValue lb_build_call_expr(lbProcedure *p, Ast *expr) {
 
 		if (variadic && !vari_expand && !is_c_vararg) {
 			// variadic call argument generation
-			gbAllocator allocator = heap_allocator();
 			Type *slice_type = param_tuple->variables[variadic_index]->type;
 			Type *elem_type  = base_type(slice_type)->Slice.elem;
 			lbAddr slice = lb_add_local_generated(p, slice_type, true);
@@ -9077,7 +9050,7 @@ lbValue lb_emit_comp_against_nil(lbProcedure *p, TokenKind op_kind, lbValue x) {
 		lbValue invalid_typeid = lb_const_value(p->module, t_typeid, exact_value_i64(0));
 		return lb_emit_comp(p, op_kind, x, invalid_typeid);
 	} else if (is_type_bit_field(t)) {
-		auto args = array_make<lbValue>(heap_allocator(), 2);
+		auto args = array_make<lbValue>(permanent_allocator(), 2);
 		lbValue lhs = lb_address_from_load_or_generate_local(p, x);
 		args[0] = lb_emit_conv(p, lhs, t_rawptr);
 		args[1] = lb_const_int(p->module, t_int, type_size_of(t));
@@ -9106,7 +9079,7 @@ lbValue lb_emit_comp_against_nil(lbProcedure *p, TokenKind op_kind, lbValue x) {
 			}
 		}
 	} else if (is_type_struct(t) && type_has_nil(t)) {
-		auto args = array_make<lbValue>(heap_allocator(), 2);
+		auto args = array_make<lbValue>(permanent_allocator(), 2);
 		lbValue lhs = lb_address_from_load_or_generate_local(p, x);
 		args[0] = lb_emit_conv(p, lhs, t_rawptr);
 		args[1] = lb_const_int(p->module, t_int, type_size_of(t));
@@ -9141,8 +9114,6 @@ lbValue lb_emit_comp(lbProcedure *p, TokenKind op_kind, lbValue left, lbValue ri
 	} else if (lb_is_const(right) || lb_is_const_nil(right)) {
 		right = lb_emit_conv(p, right, left.type);
 	} else {
-		gbAllocator a = heap_allocator();
-
 		Type *lt = left.type;
 		Type *rt = right.type;
 
@@ -9222,7 +9193,7 @@ lbValue lb_emit_comp(lbProcedure *p, TokenKind op_kind, lbValue left, lbValue ri
 		} 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<lbValue>(heap_allocator(), 3);
+				auto args = array_make<lbValue>(permanent_allocator(), 3);
 				args[0] = lb_emit_conv(p, lhs, t_rawptr);
 				args[1] = lb_emit_conv(p, rhs, t_rawptr);
 				args[2] = lb_const_int(p->module, t_int, type_size_of(tl));
@@ -9265,7 +9236,7 @@ lbValue lb_emit_comp(lbProcedure *p, TokenKind op_kind, lbValue left, lbValue ri
 		}
 		GB_ASSERT(runtime_procedure != nullptr);
 
-		auto args = array_make<lbValue>(heap_allocator(), 2);
+		auto args = array_make<lbValue>(permanent_allocator(), 2);
 		args[0] = left;
 		args[1] = right;
 		return lb_emit_runtime_call(p, runtime_procedure, args);
@@ -9290,7 +9261,7 @@ lbValue lb_emit_comp(lbProcedure *p, TokenKind op_kind, lbValue left, lbValue ri
 		}
 		GB_ASSERT(runtime_procedure != nullptr);
 
-		auto args = array_make<lbValue>(heap_allocator(), 2);
+		auto args = array_make<lbValue>(permanent_allocator(), 2);
 		args[0] = left;
 		args[1] = right;
 		return lb_emit_runtime_call(p, runtime_procedure, args);
@@ -9315,7 +9286,7 @@ lbValue lb_emit_comp(lbProcedure *p, TokenKind op_kind, lbValue left, lbValue ri
 		}
 		GB_ASSERT(runtime_procedure != nullptr);
 
-		auto args = array_make<lbValue>(heap_allocator(), 2);
+		auto args = array_make<lbValue>(permanent_allocator(), 2);
 		args[0] = left;
 		args[1] = right;
 		return lb_emit_runtime_call(p, runtime_procedure, args);
@@ -9464,14 +9435,14 @@ lbValue lb_generate_anonymous_proc_lit(lbModule *m, String const &prefix_name, A
 	// NOTE(bill): Generate a new name
 	// parent$count
 	isize name_len = prefix_name.len + 1 + 8 + 1;
-	char *name_text = gb_alloc_array(heap_allocator(), char, name_len);
+	char *name_text = gb_alloc_array(permanent_allocator(), char, name_len);
 	i32 name_id = cast(i32)m->anonymous_proc_lits.entries.count;
 
 	name_len = gb_snprintf(name_text, name_len, "%.*s$anon-%d", LIT(prefix_name), name_id);
 	String name = make_string((u8 *)name_text, name_len-1);
 
 	Type *type = type_of_expr(expr);
-	set_procedure_abi_types(heap_allocator(), type);
+	set_procedure_abi_types(permanent_allocator(), type);
 
 
 	Token token = {};
@@ -9567,7 +9538,7 @@ lbValue lb_emit_union_cast(lbProcedure *p, lbValue value, Type *type, TokenPos p
 			Type *dst_type = tuple->Tuple.variables[0]->type;
 
 			lbValue ok = lb_emit_load(p, lb_emit_struct_ep(p, v.addr, 1));
-			auto args = array_make<lbValue>(heap_allocator(), 6);
+			auto args = array_make<lbValue>(permanent_allocator(), 6);
 			args[0] = ok;
 
 			args[1] = lb_const_string(m, pos.file);
@@ -9628,7 +9599,7 @@ lbAddr lb_emit_any_cast_addr(lbProcedure *p, lbValue value, Type *type, TokenPos
 		// NOTE(bill): Panic on invalid conversion
 
 		lbValue ok = lb_emit_load(p, lb_emit_struct_ep(p, v.addr, 1));
-		auto args = array_make<lbValue>(heap_allocator(), 6);
+		auto args = array_make<lbValue>(permanent_allocator(), 6);
 		args[0] = ok;
 
 		args[1] = lb_const_string(m, pos.file);
@@ -9912,7 +9883,6 @@ lbValue lb_build_expr(lbProcedure *p, Ast *expr) {
 				return addr.addr;
 
 			} else if (ue_expr->kind == Ast_TypeAssertion) {
-				gbAllocator a = heap_allocator();
 				GB_ASSERT(is_type_pointer(tv.type));
 
 				ast_node(ta, TypeAssertion, ue_expr);
@@ -9934,7 +9904,7 @@ lbValue lb_build_expr(lbProcedure *p, Ast *expr) {
 					lbValue dst_tag = lb_const_union_tag(p->module, src_type, dst_type);
 
 					lbValue ok = lb_emit_comp(p, Token_CmpEq, src_tag, dst_tag);
-					auto args = array_make<lbValue>(heap_allocator(), 6);
+					auto args = array_make<lbValue>(permanent_allocator(), 6);
 					args[0] = ok;
 
 					args[1] = lb_find_or_add_entity_string(p->module, pos.file);
@@ -9959,7 +9929,7 @@ lbValue lb_build_expr(lbProcedure *p, Ast *expr) {
 
 
 					lbValue ok = lb_emit_comp(p, Token_CmpEq, any_id, id);
-					auto args = array_make<lbValue>(heap_allocator(), 6);
+					auto args = array_make<lbValue>(permanent_allocator(), 6);
 					args[0] = ok;
 
 					args[1] = lb_find_or_add_entity_string(p->module, pos.file);
@@ -10110,7 +10080,6 @@ lbAddr lb_build_addr_from_entity(lbProcedure *p, Entity *e, Ast *expr) {
 
 lbValue lb_gen_map_header(lbProcedure *p, lbValue map_val_ptr, Type *map_type) {
 	GB_ASSERT_MSG(is_type_pointer(map_val_ptr.type), "%s", type_to_string(map_val_ptr.type));
-	gbAllocator a = heap_allocator();
 	lbAddr h = lb_add_local_generated(p, t_map_header, false); // all the values will be initialzed later
 	map_type = base_type(map_type);
 	GB_ASSERT(map_type->kind == Type_Map);
@@ -10154,7 +10123,7 @@ lbValue lb_gen_map_key(lbProcedure *p, lbValue key, Type *key_type) {
 			u64 hs = fnv64a(v.text, v.len);
 			hashed_str = lb_const_int(p->module, t_u64, hs);
 		} else {
-			auto args = array_make<lbValue>(heap_allocator(), 1);
+			auto args = array_make<lbValue>(permanent_allocator(), 1);
 			args[0] = str;
 			hashed_str = lb_emit_runtime_call(p, "default_hash_string", args);
 		}
@@ -10167,7 +10136,7 @@ lbValue lb_gen_map_key(lbProcedure *p, lbValue key, Type *key_type) {
 		i64 sz = type_size_of(t);
 		GB_ASSERT(sz <= 8);
 		if (sz != 0) {
-			auto args = array_make<lbValue>(heap_allocator(), 2);
+			auto args = array_make<lbValue>(permanent_allocator(), 2);
 			args[0] = lb_address_from_load_or_generate_local(p, key);
 			args[1] = lb_const_int(p->module, t_int, sz);
 			lbValue hash = lb_emit_runtime_call(p, "default_hash_ptr", args);
@@ -10197,7 +10166,7 @@ void lb_insert_dynamic_map_key_and_value(lbProcedure *p, lbAddr addr, Type *map_
 	lbAddr value_addr = lb_add_local_generated(p, v.type, false);
 	lb_addr_store(p, value_addr, v);
 
-	auto args = array_make<lbValue>(heap_allocator(), 4);
+	auto args = array_make<lbValue>(permanent_allocator(), 4);
 	args[0] = h;
 	args[1] = key;
 	args[2] = lb_emit_conv(p, value_addr.addr, t_rawptr);
@@ -10356,7 +10325,6 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) {
 	case_end;
 
 	case_ast_node(ta, TypeAssertion, expr);
-		gbAllocator a = heap_allocator();
 		TokenPos pos = ast_token(expr).pos;
 		lbValue e = lb_build_expr(p, ta->expr);
 		Type *t = type_deref(e.type);
@@ -10393,7 +10361,6 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) {
 
 	case_ast_node(ie, IndexExpr, expr);
 		Type *t = base_type(type_of_expr(ie->expr));
-		gbAllocator a = heap_allocator();
 
 		bool deref = is_type_pointer(t);
 		t = base_type(type_deref(t));
@@ -10593,7 +10560,6 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) {
 	case_end;
 
 	case_ast_node(se, SliceExpr, expr);
-		gbAllocator a = heap_allocator();
 		lbValue low  = lb_const_int(p->module, t_int, 0);
 		lbValue high = {};
 
@@ -10892,9 +10858,8 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) {
 			if (cl->elems.count == 0) {
 				break;
 			}
-			gbAllocator a = heap_allocator();
 			{
-				auto args = array_make<lbValue>(a, 3);
+				auto args = array_make<lbValue>(permanent_allocator(), 3);
 				args[0] = lb_gen_map_header(p, v.addr, type);
 				args[1] = lb_const_int(p->module, t_int, 2*cl->elems.count);
 				args[2] = lb_emit_source_code_location(p, proc_name, pos);
@@ -10915,8 +10880,7 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) {
 			if (cl->elems.count > 0) {
 				lb_addr_store(p, v, lb_const_value(p->module, type, exact_value_compound(expr)));
 
-				auto temp_data = array_make<lbCompoundLitElemTempData>(heap_allocator(), 0, cl->elems.count);
-				defer (array_free(&temp_data));
+				auto temp_data = array_make<lbCompoundLitElemTempData>(temporary_allocator(), 0, cl->elems.count);
 
 				// NOTE(bill): Separate value, gep, store into their own chunks
 				for_array(i, cl->elems) {
@@ -11015,8 +10979,7 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) {
 			if (cl->elems.count > 0) {
 				lb_addr_store(p, v, lb_const_value(p->module, type, exact_value_compound(expr)));
 
-				auto temp_data = array_make<lbCompoundLitElemTempData>(heap_allocator(), 0, cl->elems.count);
-				defer (array_free(&temp_data));
+				auto temp_data = array_make<lbCompoundLitElemTempData>(temporary_allocator(), 0, cl->elems.count);
 
 				// NOTE(bill): Separate value, gep, store into their own chunks
 				for_array(i, cl->elems) {
@@ -11124,8 +11087,7 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) {
 
 				lbValue data = lb_slice_elem(p, slice);
 
-				auto temp_data = array_make<lbCompoundLitElemTempData>(heap_allocator(), 0, cl->elems.count);
-				defer (array_free(&temp_data));
+				auto temp_data = array_make<lbCompoundLitElemTempData>(temporary_allocator(), 0, cl->elems.count);
 
 				for_array(i, cl->elems) {
 					Ast *elem = cl->elems[i];
@@ -11218,14 +11180,13 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) {
 				break;
 			}
 			Type *et = bt->DynamicArray.elem;
-			gbAllocator a = heap_allocator();
 			lbValue size  = lb_const_int(p->module, t_int, type_size_of(et));
 			lbValue align = lb_const_int(p->module, t_int, type_align_of(et));
 
 			i64 item_count = gb_max(cl->max_count, cl->elems.count);
 			{
 
-				auto args = array_make<lbValue>(a, 5);
+				auto args = array_make<lbValue>(permanent_allocator(), 5);
 				args[0] = lb_emit_conv(p, lb_addr_get_ptr(p, v), t_rawptr);
 				args[1] = size;
 				args[2] = align;
@@ -11279,7 +11240,7 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) {
 			}
 
 			{
-				auto args = array_make<lbValue>(a, 6);
+				auto args = array_make<lbValue>(permanent_allocator(), 6);
 				args[0] = lb_emit_conv(p, v.addr, t_rawptr);
 				args[1] = size;
 				args[2] = align;
@@ -11491,7 +11452,7 @@ lbAddr lb_add_global_generated(lbModule *m, Type *type, lbValue value) {
 	type = default_type(type);
 
 	isize max_len = 7+8+1;
-	u8 *str = cast(u8 *)gb_alloc_array(heap_allocator(), u8, max_len);
+	u8 *str = cast(u8 *)gb_alloc_array(permanent_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);
@@ -11571,12 +11532,11 @@ lbValue lb_generate_local_array(lbProcedure *p, Type *elem_type, i64 count, bool
 }
 
 lbValue lb_generate_global_array(lbModule *m, Type *elem_type, i64 count, String prefix, i64 id) {
-	gbAllocator a = heap_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);
+	char *text = gb_alloc_array(permanent_allocator(), char, name_len+1);
 	gb_snprintf(text, name_len,
 	            "%.*s-%llu", LIT(prefix), suffix_id);
 	text[name_len] = 0;
@@ -11598,7 +11558,6 @@ lbValue lb_generate_global_array(lbModule *m, Type *elem_type, i64 count, String
 void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup type_info data
 	lbModule *m = p->module;
 	LLVMContextRef ctx = m->ctx;
-	gbAllocator a = heap_allocator();
 	CheckerInfo *info = m->info;
 
 	{
@@ -11976,10 +11935,8 @@ void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup type_info da
 					                                        str_lit("$enum_values"), cast(i64)entry_index);
 
 
-					LLVMValueRef *name_values = gb_alloc_array(heap_allocator(), LLVMValueRef, fields.count);
-					LLVMValueRef *value_values = gb_alloc_array(heap_allocator(), LLVMValueRef, fields.count);
-					defer (gb_free(heap_allocator(), name_values));
-					defer (gb_free(heap_allocator(), value_values));
+					LLVMValueRef *name_values = gb_alloc_array(temporary_allocator(), LLVMValueRef, fields.count);
+					LLVMValueRef *value_values = gb_alloc_array(temporary_allocator(), LLVMValueRef, fields.count);
 
 					GB_ASSERT(is_type_integer(t->Enum.base_type));
 
@@ -12328,10 +12285,6 @@ void lb_generate_code(lbGenerator *gen) {
 	LLVMModuleRef mod = gen->module.mod;
 	CheckerInfo *info = gen->info;
 
-	Arena temp_arena = {};
-	arena_init(&temp_arena, heap_allocator());
-	gbAllocator temp_allocator = arena_allocator(&temp_arena);
-
 	auto *min_dep_set = &info->minimum_dependency_set;
 
 
@@ -12344,8 +12297,8 @@ void lb_generate_code(lbGenerator *gen) {
 	LLVMInitializeNativeTarget();
 
 
-	char const *target_triple = alloc_cstring(heap_allocator(), build_context.metrics.target_triplet);
-	char const *target_data_layout = alloc_cstring(heap_allocator(), build_context.metrics.target_data_layout);
+	char const *target_triple = alloc_cstring(permanent_allocator(), build_context.metrics.target_triplet);
+	char const *target_data_layout = alloc_cstring(permanent_allocator(), build_context.metrics.target_data_layout);
 	LLVMSetTarget(mod, target_triple);
 
 	LLVMTargetRef target = {};
@@ -12367,7 +12320,7 @@ void lb_generate_code(lbGenerator *gen) {
 		if (build_context.microarch == "native") {
 			llvm_cpu = host_cpu_name;
 		} else {
-			llvm_cpu = alloc_cstring(heap_allocator(), build_context.microarch);
+			llvm_cpu = alloc_cstring(permanent_allocator(), build_context.microarch);
 		}
 		if (gb_strcmp(llvm_cpu, host_cpu_name) == 0) {
 			llvm_features = LLVMGetHostCPUFeatures();
@@ -12538,7 +12491,7 @@ void lb_generate_code(lbGenerator *gen) {
 		lbValue init;
 		DeclInfo *decl;
 	};
-	auto global_variables = array_make<GlobalVariable>(heap_allocator(), 0, global_variable_max_count);
+	auto global_variables = array_make<GlobalVariable>(permanent_allocator(), 0, global_variable_max_count);
 
 	for_array(i, info->variable_init_order) {
 		DeclInfo *d = info->variable_init_order[i];
@@ -12565,7 +12518,7 @@ void lb_generate_code(lbGenerator *gen) {
 
 
 		lbValue g = {};
-		g.value = LLVMAddGlobal(m->mod, lb_type(m, e->type), alloc_cstring(heap_allocator(), name));
+		g.value = LLVMAddGlobal(m->mod, lb_type(m, e->type), alloc_cstring(permanent_allocator(), name));
 		g.type = alloc_type_pointer(e->type);
 		if (e->Variable.thread_local_model != "") {
 			LLVMSetThreadLocal(g.value, true);
@@ -12619,9 +12572,6 @@ void lb_generate_code(lbGenerator *gen) {
 
 	TIME_SECTION("LLVM Global Procedures and Types");
 	for_array(i, info->entities) {
-		// arena_free_all(&temp_arena);
-		// gbAllocator a = temp_allocator;
-
 		Entity *e = info->entities[i];
 		String    name  = e->token.string;
 		DeclInfo *decl  = e->decl_info;
@@ -12906,12 +12856,12 @@ void lb_generate_code(lbGenerator *gen) {
 		if (build_context.metrics.os == TargetOs_windows && build_context.metrics.arch == TargetArch_386) {
 			name = str_lit("mainCRTStartup");
 		} else {
-			array_init(&params->Tuple.variables, heap_allocator(), 2);
+			array_init(&params->Tuple.variables, permanent_allocator(), 2);
 			params->Tuple.variables[0] = alloc_entity_param(nullptr, make_token_ident("argc"), t_i32, false, true);
 			params->Tuple.variables[1] = alloc_entity_param(nullptr, make_token_ident("argv"), alloc_type_pointer(t_cstring), false, true);
 		}
 
-		array_init(&results->Tuple.variables, heap_allocator(), 1);
+		array_init(&results->Tuple.variables, permanent_allocator(), 1);
 		results->Tuple.variables[0] = alloc_entity_param(nullptr, make_token_ident("_"),   t_i32, false, true);
 
 		Type *proc_type = alloc_type_proc(nullptr,
@@ -12944,8 +12894,7 @@ void lb_generate_code(lbGenerator *gen) {
 	}
 
 
-	String filepath_ll  = concatenate_strings(heap_allocator(), gen->output_base, STR_LIT(".ll"));
-	defer (gb_free(heap_allocator(), filepath_ll.text));
+	String filepath_ll = concatenate_strings(temporary_allocator(), gen->output_base, STR_LIT(".ll"));
 
 	TIME_SECTION("LLVM Procedure Generation");
 	for_array(i, m->procedures_to_generate) {
@@ -13032,20 +12981,20 @@ void lb_generate_code(lbGenerator *gen) {
 	LLVMCodeGenFileType code_gen_file_type = LLVMObjectFile;
 
 	if (build_context.build_mode == BuildMode_Assembly) {
-		filepath_obj = concatenate_strings(heap_allocator(), gen->output_base, STR_LIT(".S"));
+		filepath_obj = concatenate_strings(permanent_allocator(), gen->output_base, STR_LIT(".S"));
 		code_gen_file_type = LLVMAssemblyFile;
 	} else {
 		switch (build_context.metrics.os) {
 		case TargetOs_windows:
-			filepath_obj = concatenate_strings(heap_allocator(), gen->output_base, STR_LIT(".obj"));
+			filepath_obj = concatenate_strings(permanent_allocator(), gen->output_base, STR_LIT(".obj"));
 			break;
 		case TargetOs_darwin:
 		case TargetOs_linux:
 		case TargetOs_essence:
-			filepath_obj = concatenate_strings(heap_allocator(), gen->output_base, STR_LIT(".o"));
+			filepath_obj = concatenate_strings(permanent_allocator(), gen->output_base, STR_LIT(".o"));
 			break;
 		case TargetOs_js:
-			filepath_obj = concatenate_strings(heap_allocator(), gen->output_base, STR_LIT(".wasm-obj"));
+			filepath_obj = concatenate_strings(permanent_allocator(), gen->output_base, STR_LIT(".wasm-obj"));
 			break;
 		}
 	}