Commit e624c862894ec50998aafb3026d4ed45208acd6d | zig

author	Michael Dusan <michael.dusan@gmail.com> 2020-02-10 23:08:33-05:00
committer	GitHub <noreply@github.com> 2020-02-10 23:08:33-05:00
log	e624c862894ec50998aafb3026d4ed45208acd6d
tree	a01d54c8d5ba3178eaed1fa8d0ef9c081d95d9f2
parent	26183660558c43133d862912c602e316f43698c7
parent	edb210905dcbe666fa5222bceacd2e5bdb16bb89
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #4389 from mikdusan/stage1-mem

stage1: memory/report overhaul

33 files changed, 2210 insertions(+), 1082 deletions(-)

CMakeLists.txt+3-1

 @@ -450,7 +450,7 @@ set(ZIG_MAIN_SRC "${CMAKE_SOURCE_DIR}/src/main.cpp")
 set(ZIG0_SHIM_SRC "${CMAKE_SOURCE_DIR}/src/userland.cpp")
 if(ZIG_ENABLE_MEM_PROFILE)
-    set(ZIG_SOURCES_MEM_PROFILE "${CMAKE_SOURCE_DIR}/src/memory_profiling.cpp")
+    set(ZIG_SOURCES_MEM_PROFILE "${CMAKE_SOURCE_DIR}/src/mem_profile.cpp")
 endif()
 set(ZIG_SOURCES
 @@ -466,10 +466,12 @@ set(ZIG_SOURCES
     "${CMAKE_SOURCE_DIR}/src/errmsg.cpp"
     "${CMAKE_SOURCE_DIR}/src/error.cpp"
     "${CMAKE_SOURCE_DIR}/src/glibc.cpp"
+    "${CMAKE_SOURCE_DIR}/src/heap.cpp"
     "${CMAKE_SOURCE_DIR}/src/ir.cpp"
     "${CMAKE_SOURCE_DIR}/src/ir_print.cpp"
     "${CMAKE_SOURCE_DIR}/src/libc_installation.cpp"
     "${CMAKE_SOURCE_DIR}/src/link.cpp"
+    "${CMAKE_SOURCE_DIR}/src/mem.cpp"
     "${CMAKE_SOURCE_DIR}/src/os.cpp"
     "${CMAKE_SOURCE_DIR}/src/parser.cpp"
     "${CMAKE_SOURCE_DIR}/src/range_set.cpp"

src/all_types.hpp+3-1

...	@@ -2000,6 +2000,9 @@ struct CFile {	...	@@ -2000,6 +2000,9 @@ struct CFile {
2000		2000
2001	// When adding fields, check if they should be added to the hash computation in build_with_cache	2001	// When adding fields, check if they should be added to the hash computation in build_with_cache
2002	struct CodeGen {	2002	struct CodeGen {
		2003	// arena allocator destroyed just prior to codegen emit
		2004	heap::ArenaAllocator *pass1_arena;
		2005
2003	//////////////////////////// Runtime State	2006	//////////////////////////// Runtime State
2004	LLVMModuleRef module;	2007	LLVMModuleRef module;
2005	ZigList<ErrorMsg*> errors;	2008	ZigList<ErrorMsg*> errors;
...	@@ -2280,7 +2283,6 @@ struct ZigVar {	...	@@ -2280,7 +2283,6 @@ struct ZigVar {
2280	Scope *parent_scope;	2283	Scope *parent_scope;
2281	Scope *child_scope;	2284	Scope *child_scope;
2282	LLVMValueRef param_value_ref;	2285	LLVMValueRef param_value_ref;
2283	IrExecutableSrc *owner_exec;
2284		2286
2285	Buf *section_name;	2287	Buf *section_name;
2286		2288

src/analyze.cpp+92-97

src/analyze.hpp+10-11

 @@ -128,22 +128,22 @@ void init_const_str_lit(CodeGen *g, ZigValue *const_val, Buf *str);
 ZigValue *create_const_str_lit(CodeGen *g, Buf *str);
 void init_const_bigint(ZigValue *const_val, ZigType *type, const BigInt *bigint);
-ZigValue *create_const_bigint(ZigType *type, const BigInt *bigint);
+ZigValue *create_const_bigint(CodeGen *g, ZigType *type, const BigInt *bigint);
 void init_const_unsigned_negative(ZigValue *const_val, ZigType *type, uint64_t x, bool negative);
-ZigValue *create_const_unsigned_negative(ZigType *type, uint64_t x, bool negative);
+ZigValue *create_const_unsigned_negative(CodeGen *g, ZigType *type, uint64_t x, bool negative);
 void init_const_signed(ZigValue *const_val, ZigType *type, int64_t x);
-ZigValue *create_const_signed(ZigType *type, int64_t x);
+ZigValue *create_const_signed(CodeGen *g, ZigType *type, int64_t x);
 void init_const_usize(CodeGen *g, ZigValue *const_val, uint64_t x);
 ZigValue *create_const_usize(CodeGen *g, uint64_t x);
 void init_const_float(ZigValue *const_val, ZigType *type, double value);
-ZigValue *create_const_float(ZigType *type, double value);
+ZigValue *create_const_float(CodeGen *g, ZigType *type, double value);
 void init_const_enum(ZigValue *const_val, ZigType *type, const BigInt *tag);
-ZigValue *create_const_enum(ZigType *type, const BigInt *tag);
+ZigValue *create_const_enum(CodeGen *g, ZigType *type, const BigInt *tag);
 void init_const_bool(CodeGen *g, ZigValue *const_val, bool value);
 ZigValue *create_const_bool(CodeGen *g, bool value);
 @@ -152,7 +152,7 @@ void init_const_type(CodeGen *g, ZigValue *const_val, ZigType *type_value);
 ZigValue *create_const_type(CodeGen *g, ZigType *type_value);
 void init_const_runtime(ZigValue *const_val, ZigType *type);
-ZigValue *create_const_runtime(ZigType *type);
+ZigValue *create_const_runtime(CodeGen *g, ZigType *type);
 void init_const_ptr_ref(CodeGen *g, ZigValue *const_val, ZigValue *pointee_val, bool is_const);
 ZigValue *create_const_ptr_ref(CodeGen *g, ZigValue *pointee_val, bool is_const);
 @@ -172,11 +172,10 @@ void init_const_slice(CodeGen *g, ZigValue *const_val, ZigValue *array_val,
 ZigValue *create_const_slice(CodeGen *g, ZigValue *array_val, size_t start, size_t len, bool is_const);
 void init_const_null(ZigValue *const_val, ZigType *type);
-ZigValue *create_const_null(ZigType *type);
+ZigValue *create_const_null(CodeGen *g, ZigType *type);
-ZigValue *create_const_vals(size_t count);
+ZigValue **alloc_const_vals_ptrs(CodeGen *g, size_t count);
-ZigValue **alloc_const_vals_ptrs(size_t count);
+ZigValue **realloc_const_vals_ptrs(CodeGen *g, ZigValue **ptr, size_t old_count, size_t new_count);
-ZigValue **realloc_const_vals_ptrs(ZigValue **ptr, size_t old_count, size_t new_count);
 TypeStructField **alloc_type_struct_fields(size_t count);
 TypeStructField **realloc_type_struct_fields(TypeStructField **ptr, size_t old_count, size_t new_count);
 @@ -275,7 +274,7 @@ Error analyze_import(CodeGen *codegen, ZigType *source_import, Buf *import_targe
         ZigType **out_import, Buf **out_import_target_path, Buf *out_full_path);
 ZigValue *get_the_one_possible_value(CodeGen *g, ZigType *type_entry);
 bool is_anon_container(ZigType *ty);
-void copy_const_val(ZigValue *dest, ZigValue *src);
+void copy_const_val(CodeGen *g, ZigValue *dest, ZigValue *src);
 bool type_has_optional_repr(ZigType *ty);
 bool is_opt_err_set(ZigType *ty);
 bool type_is_numeric(ZigType *ty);

src/bigint.cpp+16-16

src/buffer.hpp+4-5

...	@@ -50,7 +50,7 @@ static inline void buf_resize(Buf *buf, size_t new_len) {	...	@@ -50,7 +50,7 @@ static inline void buf_resize(Buf *buf, size_t new_len) {
50	}	50	}
51		51
52	static inline Buf *buf_alloc_fixed(size_t size) {	52	static inline Buf *buf_alloc_fixed(size_t size) {
53	Buf *buf = allocate<Buf>(1);	53	Buf *buf = heap::c_allocator.create<Buf>();
54	buf_resize(buf, size);	54	buf_resize(buf, size);
55	return buf;	55	return buf;
56	}	56	}
...	@@ -65,7 +65,7 @@ static inline void buf_deinit(Buf *buf) {	...	@@ -65,7 +65,7 @@ static inline void buf_deinit(Buf *buf) {
65		65
66	static inline void buf_destroy(Buf *buf) {	66	static inline void buf_destroy(Buf *buf) {
67	buf_deinit(buf);	67	buf_deinit(buf);
68	free(buf);	68	heap::c_allocator.destroy(buf);
69	}	69	}
70		70
71	static inline void buf_init_from_mem(Buf buf, const char ptr, size_t len) {	71	static inline void buf_init_from_mem(Buf buf, const char ptr, size_t len) {
...	@@ -85,7 +85,7 @@ static inline void buf_init_from_buf(Buf buf, Buf other) {	...	@@ -85,7 +85,7 @@ static inline void buf_init_from_buf(Buf buf, Buf other) {
85		85
86	static inline Buf buf_create_from_mem(const char ptr, size_t len) {	86	static inline Buf buf_create_from_mem(const char ptr, size_t len) {
87	assert(len != SIZE_MAX);	87	assert(len != SIZE_MAX);
88	Buf *buf = allocate<Buf>(1);	88	Buf *buf = heap::c_allocator.create<Buf>();
89	buf_init_from_mem(buf, ptr, len);	89	buf_init_from_mem(buf, ptr, len);
90	return buf;	90	return buf;
91	}	91	}
...	@@ -108,7 +108,7 @@ static inline Buf buf_slice(Buf in_buf, size_t start, size_t end) {	...	@@ -108,7 +108,7 @@ static inline Buf buf_slice(Buf in_buf, size_t start, size_t end) {
108	assert(end != SIZE_MAX);	108	assert(end != SIZE_MAX);
109	assert(start < buf_len(in_buf));	109	assert(start < buf_len(in_buf));
110	assert(end <= buf_len(in_buf));	110	assert(end <= buf_len(in_buf));
111	Buf *out_buf = allocate<Buf>(1);	111	Buf *out_buf = heap::c_allocator.create<Buf>();
112	out_buf->list.resize(end - start + 1);	112	out_buf->list.resize(end - start + 1);
113	memcpy(buf_ptr(out_buf), buf_ptr(in_buf) + start, end - start);	113	memcpy(buf_ptr(out_buf), buf_ptr(in_buf) + start, end - start);
114	out_buf->list.at(buf_len(out_buf)) = 0;	114	out_buf->list.at(buf_len(out_buf)) = 0;
...	@@ -211,5 +211,4 @@ static inline void buf_replace(Buf* buf, char from, char to) {	...	@@ -211,5 +211,4 @@ static inline void buf_replace(Buf* buf, char from, char to) {
211	}	211	}
212	}	212	}
213		213
214
215	#endif	214	#endif

src/codegen.cpp+40-35

src/errmsg.cpp+2-2

...	@@ -99,7 +99,7 @@ void err_msg_add_note(ErrorMsg parent, ErrorMsg note) {	...	@@ -99,7 +99,7 @@ void err_msg_add_note(ErrorMsg parent, ErrorMsg note) {
99	ErrorMsg err_msg_create_with_offset(Buf path, size_t line, size_t column, size_t offset,	99	ErrorMsg err_msg_create_with_offset(Buf path, size_t line, size_t column, size_t offset,
100	const char source, Buf msg)	100	const char source, Buf msg)
101	{	101	{
102	ErrorMsg *err_msg = allocate<ErrorMsg>(1);	102	ErrorMsg *err_msg = heap::c_allocator.create<ErrorMsg>();
103	err_msg->path = path;	103	err_msg->path = path;
104	err_msg->line_start = line;	104	err_msg->line_start = line;
105	err_msg->column_start = column;	105	err_msg->column_start = column;
...	@@ -138,7 +138,7 @@ ErrorMsg err_msg_create_with_offset(Buf path, size_t line, size_t column, size	...	@@ -138,7 +138,7 @@ ErrorMsg err_msg_create_with_offset(Buf path, size_t line, size_t column, size
138	ErrorMsg err_msg_create_with_line(Buf path, size_t line, size_t column,	138	ErrorMsg err_msg_create_with_line(Buf path, size_t line, size_t column,
139	Buf source, ZigList<size_t> line_offsets, Buf *msg)	139	Buf source, ZigList<size_t> line_offsets, Buf *msg)
140	{	140	{
141	ErrorMsg *err_msg = allocate<ErrorMsg>(1);	141	ErrorMsg *err_msg = heap::c_allocator.create<ErrorMsg>();
142	err_msg->path = path;	142	err_msg->path = path;
143	err_msg->line_start = line;	143	err_msg->line_start = line;
144	err_msg->column_start = column;	144	err_msg->column_start = column;

src/glibc.cpp+4-4

src/hash_map.hpp+3-3

...	@@ -19,7 +19,7 @@ public:	...	@@ -19,7 +19,7 @@ public:
19	init_capacity(capacity);	19	init_capacity(capacity);
20	}	20	}
21	void deinit(void) {	21	void deinit(void) {
22	free(_entries);	22	heap::c_allocator.deallocate(_entries, _capacity);
23	}	23	}
24		24
25	struct Entry {	25	struct Entry {
...	@@ -57,7 +57,7 @@ public:	...	@@ -57,7 +57,7 @@ public:
57	if (old_entry->used)	57	if (old_entry->used)
58	internal_put(old_entry->key, old_entry->value);	58	internal_put(old_entry->key, old_entry->value);
59	}	59	}
60	free(old_entries);	60	heap::c_allocator.deallocate(old_entries, old_capacity);
61	}	61	}
62	}	62	}
63		63
...	@@ -164,7 +164,7 @@ private:	...	@@ -164,7 +164,7 @@ private:
164		164
165	void init_capacity(int capacity) {	165	void init_capacity(int capacity) {
166	_capacity = capacity;	166	_capacity = capacity;
167	_entries = allocate<Entry>(_capacity);	167	_entries = heap::c_allocator.allocate<Entry>(_capacity);
168	_size = 0;	168	_size = 0;
169	_max_distance_from_start_index = 0;	169	_max_distance_from_start_index = 0;
170	for (int i = 0; i < _capacity; i += 1) {	170	for (int i = 0; i < _capacity; i += 1) {

src/heap.cpp created+377

...	@@ -0,0 +1,377 @@
1	/*
2	* Copyright (c) 2020 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#include <new>
9	#include <string.h>
10
11	#include "config.h"
12	#include "heap.hpp"
13	#include "mem_profile.hpp"
14
15	namespace heap {
16
17	extern mem::Allocator &bootstrap_allocator;
18
19	//
20	// BootstrapAllocator implementation is identical to CAllocator minus
21	// profile profile functionality. Splitting off to a base interface doesn't
22	// seem worthwhile.
23	//
24
25	void BootstrapAllocator::init(const char *name) {}
26	void BootstrapAllocator::deinit() {}
27
28	void *BootstrapAllocator::internal_allocate(const mem::TypeInfo &info, size_t count) {
29	return mem::os::calloc(count, info.size);
30	}
31
32	void *BootstrapAllocator::internal_allocate_nonzero(const mem::TypeInfo &info, size_t count) {
33	return mem::os::malloc(count * info.size);
34	}
35
36	void BootstrapAllocator::internal_reallocate(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) {
37	auto new_ptr = this->internal_reallocate_nonzero(info, old_ptr, old_count, new_count);
38	if (new_count > old_count)
39	memset(reinterpret_cast<uint8_t >(new_ptr) + (old_count info.size), 0, (new_count - old_count) * info.size);
40	return new_ptr;
41	}
42
43	void BootstrapAllocator::internal_reallocate_nonzero(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) {
44	return mem::os::realloc(old_ptr, new_count * info.size);
45	}
46
47	void BootstrapAllocator::internal_deallocate(const mem::TypeInfo &info, void *ptr, size_t count) {
48	mem::os::free(ptr);
49	}
50
51	void CAllocator::init(const char *name) {
52	#ifdef ZIG_ENABLE_MEM_PROFILE
53	this->profile = bootstrap_allocator.create<mem::Profile>();
54	this->profile->init(name, "CAllocator");
55	#endif
56	}
57
58	void CAllocator::deinit() {
59	#ifdef ZIG_ENABLE_MEM_PROFILE
60	assert(this->profile);
61	this->profile->deinit();
62	bootstrap_allocator.destroy(this->profile);
63	this->profile = nullptr;
64	#endif
65	}
66
67	CAllocator CAllocator::construct(mem::Allocator allocator, const char *name) {
68	auto p = new(allocator->create<CAllocator>()) CAllocator();
69	p->init(name);
70	return p;
71	}
72
73	void CAllocator::destruct(mem::Allocator *allocator) {
74	this->deinit();
75	allocator->destroy(this);
76	}
77
78	#ifdef ZIG_ENABLE_MEM_PROFILE
79	void CAllocator::print_report(FILE *file) {
80	this->profile->print_report(file);
81	}
82	#endif
83
84	void *CAllocator::internal_allocate(const mem::TypeInfo &info, size_t count) {
85	#ifdef ZIG_ENABLE_MEM_PROFILE
86	this->profile->record_alloc(info, count);
87	#endif
88	return mem::os::calloc(count, info.size);
89	}
90
91	void *CAllocator::internal_allocate_nonzero(const mem::TypeInfo &info, size_t count) {
92	#ifdef ZIG_ENABLE_MEM_PROFILE
93	this->profile->record_alloc(info, count);
94	#endif
95	return mem::os::malloc(count * info.size);
96	}
97
98	void CAllocator::internal_reallocate(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) {
99	auto new_ptr = this->internal_reallocate_nonzero(info, old_ptr, old_count, new_count);
100	if (new_count > old_count)
101	memset(reinterpret_cast<uint8_t >(new_ptr) + (old_count info.size), 0, (new_count - old_count) * info.size);
102	return new_ptr;
103	}
104
105	void CAllocator::internal_reallocate_nonzero(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) {
106	#ifdef ZIG_ENABLE_MEM_PROFILE
107	this->profile->record_dealloc(info, old_count);
108	this->profile->record_alloc(info, new_count);
109	#endif
110	return mem::os::realloc(old_ptr, new_count * info.size);
111	}
112
113	void CAllocator::internal_deallocate(const mem::TypeInfo &info, void *ptr, size_t count) {
114	#ifdef ZIG_ENABLE_MEM_PROFILE
115	this->profile->record_dealloc(info, count);
116	#endif
117	mem::os::free(ptr);
118	}
119
120	struct ArenaAllocator::Impl {
121	Allocator *backing;
122
123	// regular allocations bump through a segment of static size
124	struct Segment {
125	static constexpr size_t size = 65536;
126	static constexpr size_t object_threshold = 4096;
127
128	uint8_t data[size];
129	};
130
131	// active segment
132	Segment *segment;
133	size_t segment_offset;
134
135	// keep track of segments
136	struct SegmentTrack {
137	static constexpr size_t size = (4096 - sizeof(SegmentTrack )) / sizeof(Segment );
138
139	// null if first
140	SegmentTrack *prev;
141	Segment *segments[size];
142	};
143	static_assert(sizeof(SegmentTrack) <= 4096, "unwanted struct padding");
144
145	// active segment track
146	SegmentTrack *segment_track;
147	size_t segment_track_remain;
148
149	// individual allocations punted to backing allocator
150	struct Object {
151	uint8_t *ptr;
152	size_t len;
153	};
154
155	// keep track of objects
156	struct ObjectTrack {
157	static constexpr size_t size = (4096 - sizeof(ObjectTrack *)) / sizeof(Object);
158
159	// null if first
160	ObjectTrack *prev;
161	Object objects[size];
162	};
163	static_assert(sizeof(ObjectTrack) <= 4096, "unwanted struct padding");
164
165	// active object track
166	ObjectTrack *object_track;
167	size_t object_track_remain;
168
169	ATTRIBUTE_RETURNS_NOALIAS inline void *allocate(const mem::TypeInfo& info, size_t count);
170	inline void reallocate(const mem::TypeInfo& info, void old_ptr, size_t old_count, size_t new_count);
171
172	inline void new_segment();
173	inline void track_segment();
174	inline void track_object(Object object);
175	};
176
177	void *ArenaAllocator::Impl::allocate(const mem::TypeInfo& info, size_t count) {
178	#ifndef NDEBUG
179	// make behavior when size == 0 portable
180	if (info.size == 0 \|\| count == 0)
181	return nullptr;
182	#endif
183	const size_t nbytes = info.size * count;
184	this->segment_offset = (this->segment_offset + (info.alignment - 1)) & ~(info.alignment - 1);
185	if (nbytes >= Segment::object_threshold) {
186	auto ptr = this->backing->allocate<uint8_t>(nbytes);
187	this->track_object({ptr, nbytes});
188	return ptr;
189	}
190	if (this->segment_offset + nbytes > Segment::size)
191	this->new_segment();
192	auto ptr = &this->segment->data[this->segment_offset];
193	this->segment_offset += nbytes;
194	return ptr;
195	}
196
197	void ArenaAllocator::Impl::reallocate(const mem::TypeInfo& info, void old_ptr, size_t old_count, size_t new_count) {
198	#ifndef NDEBUG
199	// make behavior when size == 0 portable
200	if (info.size == 0 && old_ptr == nullptr)
201	return nullptr;
202	#endif
203	const size_t new_nbytes = info.size * new_count;
204	if (new_nbytes <= info.size * old_count)
205	return old_ptr;
206	const size_t old_nbytes = info.size * old_count;
207	this->segment_offset = (this->segment_offset + (info.alignment - 1)) & ~(info.alignment - 1);
208	if (new_nbytes >= Segment::object_threshold) {
209	auto new_ptr = this->backing->allocate<uint8_t>(new_nbytes);
210	this->track_object({new_ptr, new_nbytes});
211	memcpy(new_ptr, old_ptr, old_nbytes);
212	return new_ptr;
213	}
214	if (this->segment_offset + new_nbytes > Segment::size)
215	this->new_segment();
216	auto new_ptr = &this->segment->data[this->segment_offset];
217	this->segment_offset += new_nbytes;
218	memcpy(new_ptr, old_ptr, old_nbytes);
219	return new_ptr;
220	}
221
222	void ArenaAllocator::Impl::new_segment() {
223	this->segment = this->backing->create<Segment>();
224	this->segment_offset = 0;
225	this->track_segment();
226	}
227
228	void ArenaAllocator::Impl::track_segment() {
229	assert(this->segment != nullptr);
230	if (this->segment_track_remain < 1) {
231	auto prev = this->segment_track;
232	this->segment_track = this->backing->create<SegmentTrack>();
233	this->segment_track->prev = prev;
234	this->segment_track_remain = SegmentTrack::size;
235	}
236	this->segment_track_remain -= 1;
237	this->segment_track->segments[this->segment_track_remain] = this->segment;
238	}
239
240	void ArenaAllocator::Impl::track_object(Object object) {
241	if (this->object_track_remain < 1) {
242	auto prev = this->object_track;
243	this->object_track = this->backing->create<ObjectTrack>();
244	this->object_track->prev = prev;
245	this->object_track_remain = ObjectTrack::size;
246	}
247	this->object_track_remain -= 1;
248	this->object_track->objects[this->object_track_remain] = object;
249	}
250
251	void ArenaAllocator::init(Allocator backing, const char name) {
252	#ifdef ZIG_ENABLE_MEM_PROFILE
253	this->profile = bootstrap_allocator.create<mem::Profile>();
254	this->profile->init(name, "ArenaAllocator");
255	#endif
256	this->impl = bootstrap_allocator.create<Impl>();
257	{
258	auto &r = *this->impl;
259	r.backing = backing;
260	r.segment_offset = Impl::Segment::size;
261	}
262	}
263
264	void ArenaAllocator::deinit() {
265	auto &backing = *this->impl->backing;
266
267	// segments
268	if (this->impl->segment_track) {
269	// active track is not full and bounded by track_remain
270	auto prev = this->impl->segment_track->prev;
271	{
272	auto t = this->impl->segment_track;
273	for (size_t i = this->impl->segment_track_remain; i < Impl::SegmentTrack::size; ++i)
274	backing.destroy(t->segments[i]);
275	backing.destroy(t);
276	}
277
278	// previous tracks are full
279	for (auto t = prev; t != nullptr;) {
280	for (size_t i = 0; i < Impl::SegmentTrack::size; ++i)
281	backing.destroy(t->segments[i]);
282	prev = t->prev;
283	backing.destroy(t);
284	t = prev;
285	}
286	}
287
288	// objects
289	if (this->impl->object_track) {
290	// active track is not full and bounded by track_remain
291	auto prev = this->impl->object_track->prev;
292	{
293	auto t = this->impl->object_track;
294	for (size_t i = this->impl->object_track_remain; i < Impl::ObjectTrack::size; ++i) {
295	auto &obj = t->objects[i];
296	backing.deallocate(obj.ptr, obj.len);
297	}
298	backing.destroy(t);
299	}
300
301	// previous tracks are full
302	for (auto t = prev; t != nullptr;) {
303	for (size_t i = 0; i < Impl::ObjectTrack::size; ++i) {
304	auto &obj = t->objects[i];
305	backing.deallocate(obj.ptr, obj.len);
306	}
307	prev = t->prev;
308	backing.destroy(t);
309	t = prev;
310	}
311	}
312
313	#ifdef ZIG_ENABLE_MEM_PROFILE
314	assert(this->profile);
315	this->profile->deinit();
316	bootstrap_allocator.destroy(this->profile);
317	this->profile = nullptr;
318	#endif
319	}
320
321	ArenaAllocator ArenaAllocator::construct(mem::Allocator allocator, mem::Allocator backing, const char name) {
322	auto p = new(allocator->create<ArenaAllocator>()) ArenaAllocator;
323	p->init(backing, name);
324	return p;
325	}
326
327	void ArenaAllocator::destruct(mem::Allocator *allocator) {
328	this->deinit();
329	allocator->destroy(this);
330	}
331
332	#ifdef ZIG_ENABLE_MEM_PROFILE
333	void ArenaAllocator::print_report(FILE *file) {
334	this->profile->print_report(file);
335	}
336	#endif
337
338	void *ArenaAllocator::internal_allocate(const mem::TypeInfo &info, size_t count) {
339	#ifdef ZIG_ENABLE_MEM_PROFILE
340	this->profile->record_alloc(info, count);
341	#endif
342	return this->impl->allocate(info, count);
343	}
344
345	void *ArenaAllocator::internal_allocate_nonzero(const mem::TypeInfo &info, size_t count) {
346	#ifdef ZIG_ENABLE_MEM_PROFILE
347	this->profile->record_alloc(info, count);
348	#endif
349	return this->impl->allocate(info, count);
350	}
351
352	void ArenaAllocator::internal_reallocate(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) {
353	return this->internal_reallocate_nonzero(info, old_ptr, old_count, new_count);
354	}
355
356	void ArenaAllocator::internal_reallocate_nonzero(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) {
357	#ifdef ZIG_ENABLE_MEM_PROFILE
358	this->profile->record_dealloc(info, old_count);
359	this->profile->record_alloc(info, new_count);
360	#endif
361	return this->impl->reallocate(info, old_ptr, old_count, new_count);
362	}
363
364	void ArenaAllocator::internal_deallocate(const mem::TypeInfo &info, void *ptr, size_t count) {
365	#ifdef ZIG_ENABLE_MEM_PROFILE
366	this->profile->record_dealloc(info, count);
367	#endif
368	// noop
369	}
370
371	BootstrapAllocator bootstrap_allocator_state;
372	mem::Allocator &bootstrap_allocator = bootstrap_allocator_state;
373
374	CAllocator c_allocator_state;
375	mem::Allocator &c_allocator = c_allocator_state;
376
377	} // namespace heap

src/heap.hpp created+101

...	@@ -0,0 +1,101 @@
1	/*
2	* Copyright (c) 2020 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#ifndef ZIG_HEAP_HPP
9	#define ZIG_HEAP_HPP
10
11	#include "config.h"
12	#include "util_base.hpp"
13	#include "mem.hpp"
14
15	#ifdef ZIG_ENABLE_MEM_PROFILE
16	namespace mem {
17	struct Profile;
18	}
19	#endif
20
21	namespace heap {
22
23	struct BootstrapAllocator final : mem::Allocator {
24	void init(const char *name);
25	void deinit();
26	void destruct(Allocator *allocator) {}
27
28	private:
29	ATTRIBUTE_RETURNS_NOALIAS void *internal_allocate(const mem::TypeInfo &info, size_t count) final;
30	ATTRIBUTE_RETURNS_NOALIAS void *internal_allocate_nonzero(const mem::TypeInfo &info, size_t count) final;
31	void internal_reallocate(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) final;
32	void internal_reallocate_nonzero(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) final;
33	void internal_deallocate(const mem::TypeInfo &info, void *ptr, size_t count) final;
34	};
35
36	struct CAllocator final : mem::Allocator {
37	void init(const char *name);
38	void deinit();
39
40	static CAllocator construct(mem::Allocator allocator, const char *name);
41	void destruct(mem::Allocator *allocator) final;
42
43	#ifdef ZIG_ENABLE_MEM_PROFILE
44	void print_report(FILE *file = nullptr);
45	#endif
46
47	private:
48	ATTRIBUTE_RETURNS_NOALIAS void *internal_allocate(const mem::TypeInfo &info, size_t count) final;
49	ATTRIBUTE_RETURNS_NOALIAS void *internal_allocate_nonzero(const mem::TypeInfo &info, size_t count) final;
50	void internal_reallocate(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) final;
51	void internal_reallocate_nonzero(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) final;
52	void internal_deallocate(const mem::TypeInfo &info, void *ptr, size_t count) final;
53
54	#ifdef ZIG_ENABLE_MEM_PROFILE
55	mem::Profile *profile;
56	#endif
57	};
58
59	//
60	// arena allocator
61	//
62	// - allocations are backed by the underlying allocator's memory
63	// - allocations are N:1 relationship to underlying allocations
64	// - dellocations are noops
65	// - deinit() releases all underlying memory
66	//
67	struct ArenaAllocator final : mem::Allocator {
68	void init(Allocator backing, const char name);
69	void deinit();
70
71	static ArenaAllocator construct(mem::Allocator allocator, mem::Allocator backing, const char name);
72	void destruct(mem::Allocator *allocator) final;
73
74	#ifdef ZIG_ENABLE_MEM_PROFILE
75	void print_report(FILE *file = nullptr);
76	#endif
77
78	private:
79	ATTRIBUTE_RETURNS_NOALIAS void *internal_allocate(const mem::TypeInfo &info, size_t count) final;
80	ATTRIBUTE_RETURNS_NOALIAS void *internal_allocate_nonzero(const mem::TypeInfo &info, size_t count) final;
81	void internal_reallocate(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) final;
82	void internal_reallocate_nonzero(const mem::TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) final;
83	void internal_deallocate(const mem::TypeInfo &info, void *ptr, size_t count) final;
84
85	#ifdef ZIG_ENABLE_MEM_PROFILE
86	mem::Profile *profile;
87	#endif
88
89	struct Impl;
90	Impl *impl;
91	};
92
93	extern BootstrapAllocator bootstrap_allocator_state;
94	extern mem::Allocator &bootstrap_allocator;
95
96	extern CAllocator c_allocator_state;
97	extern mem::Allocator &c_allocator;
98
99	} // namespace heap
100
101	#endif

src/ir.cpp+501-538

 @@ -269,477 +269,467 @@ static IrInstGen *ir_analyze_test_non_null(IrAnalyze *ira, IrInst *source_inst,
 static IrInstGen *ir_error_dependency_loop(IrAnalyze *ira, IrInst *source_instr);
 static void destroy_instruction_src(IrInstSrc *inst) {
-#ifdef ZIG_ENABLE_MEM_PROFILE
-    const char *name = ir_inst_src_type_str(inst->id);
-#else
-    const char *name = nullptr;
-#endif
     switch (inst->id) {
         case IrInstSrcIdInvalid:
             zig_unreachable();
         case IrInstSrcIdReturn:
-            return destroy(reinterpret_cast<IrInstSrcReturn *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcReturn *>(inst));
         case IrInstSrcIdConst:
-            return destroy(reinterpret_cast<IrInstSrcConst *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcConst *>(inst));
         case IrInstSrcIdBinOp:
-            return destroy(reinterpret_cast<IrInstSrcBinOp *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcBinOp *>(inst));
         case IrInstSrcIdMergeErrSets:
-            return destroy(reinterpret_cast<IrInstSrcMergeErrSets *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcMergeErrSets *>(inst));
         case IrInstSrcIdDeclVar:
-            return destroy(reinterpret_cast<IrInstSrcDeclVar *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcDeclVar *>(inst));
         case IrInstSrcIdCall:
-            return destroy(reinterpret_cast<IrInstSrcCall *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCall *>(inst));
         case IrInstSrcIdCallExtra:
-            return destroy(reinterpret_cast<IrInstSrcCallExtra *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCallExtra *>(inst));
         case IrInstSrcIdUnOp:
-            return destroy(reinterpret_cast<IrInstSrcUnOp *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcUnOp *>(inst));
         case IrInstSrcIdCondBr:
-            return destroy(reinterpret_cast<IrInstSrcCondBr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCondBr *>(inst));
         case IrInstSrcIdBr:
-            return destroy(reinterpret_cast<IrInstSrcBr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcBr *>(inst));
         case IrInstSrcIdPhi:
-            return destroy(reinterpret_cast<IrInstSrcPhi *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcPhi *>(inst));
         case IrInstSrcIdContainerInitList:
-            return destroy(reinterpret_cast<IrInstSrcContainerInitList *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcContainerInitList *>(inst));
         case IrInstSrcIdContainerInitFields:
-            return destroy(reinterpret_cast<IrInstSrcContainerInitFields *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcContainerInitFields *>(inst));
         case IrInstSrcIdUnreachable:
-            return destroy(reinterpret_cast<IrInstSrcUnreachable *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcUnreachable *>(inst));
         case IrInstSrcIdElemPtr:
-            return destroy(reinterpret_cast<IrInstSrcElemPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcElemPtr *>(inst));
         case IrInstSrcIdVarPtr:
-            return destroy(reinterpret_cast<IrInstSrcVarPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcVarPtr *>(inst));
         case IrInstSrcIdLoadPtr:
-            return destroy(reinterpret_cast<IrInstSrcLoadPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcLoadPtr *>(inst));
         case IrInstSrcIdStorePtr:
-            return destroy(reinterpret_cast<IrInstSrcStorePtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcStorePtr *>(inst));
         case IrInstSrcIdTypeOf:
-            return destroy(reinterpret_cast<IrInstSrcTypeOf *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcTypeOf *>(inst));
         case IrInstSrcIdFieldPtr:
-            return destroy(reinterpret_cast<IrInstSrcFieldPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFieldPtr *>(inst));
         case IrInstSrcIdSetCold:
-            return destroy(reinterpret_cast<IrInstSrcSetCold *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSetCold *>(inst));
         case IrInstSrcIdSetRuntimeSafety:
-            return destroy(reinterpret_cast<IrInstSrcSetRuntimeSafety *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSetRuntimeSafety *>(inst));
         case IrInstSrcIdSetFloatMode:
-            return destroy(reinterpret_cast<IrInstSrcSetFloatMode *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSetFloatMode *>(inst));
         case IrInstSrcIdArrayType:
-            return destroy(reinterpret_cast<IrInstSrcArrayType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcArrayType *>(inst));
         case IrInstSrcIdSliceType:
-            return destroy(reinterpret_cast<IrInstSrcSliceType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSliceType *>(inst));
         case IrInstSrcIdAnyFrameType:
-            return destroy(reinterpret_cast<IrInstSrcAnyFrameType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcAnyFrameType *>(inst));
         case IrInstSrcIdAsm:
-            return destroy(reinterpret_cast<IrInstSrcAsm *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcAsm *>(inst));
         case IrInstSrcIdSizeOf:
-            return destroy(reinterpret_cast<IrInstSrcSizeOf *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSizeOf *>(inst));
         case IrInstSrcIdTestNonNull:
-            return destroy(reinterpret_cast<IrInstSrcTestNonNull *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcTestNonNull *>(inst));
         case IrInstSrcIdOptionalUnwrapPtr:
-            return destroy(reinterpret_cast<IrInstSrcOptionalUnwrapPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcOptionalUnwrapPtr *>(inst));
         case IrInstSrcIdPopCount:
-            return destroy(reinterpret_cast<IrInstSrcPopCount *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcPopCount *>(inst));
         case IrInstSrcIdClz:
-            return destroy(reinterpret_cast<IrInstSrcClz *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcClz *>(inst));
         case IrInstSrcIdCtz:
-            return destroy(reinterpret_cast<IrInstSrcCtz *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCtz *>(inst));
         case IrInstSrcIdBswap:
-            return destroy(reinterpret_cast<IrInstSrcBswap *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcBswap *>(inst));
         case IrInstSrcIdBitReverse:
-            return destroy(reinterpret_cast<IrInstSrcBitReverse *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcBitReverse *>(inst));
         case IrInstSrcIdSwitchBr:
-            return destroy(reinterpret_cast<IrInstSrcSwitchBr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSwitchBr *>(inst));
         case IrInstSrcIdSwitchVar:
-            return destroy(reinterpret_cast<IrInstSrcSwitchVar *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSwitchVar *>(inst));
         case IrInstSrcIdSwitchElseVar:
-            return destroy(reinterpret_cast<IrInstSrcSwitchElseVar *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSwitchElseVar *>(inst));
         case IrInstSrcIdSwitchTarget:
-            return destroy(reinterpret_cast<IrInstSrcSwitchTarget *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSwitchTarget *>(inst));
         case IrInstSrcIdImport:
-            return destroy(reinterpret_cast<IrInstSrcImport *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcImport *>(inst));
         case IrInstSrcIdRef:
-            return destroy(reinterpret_cast<IrInstSrcRef *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcRef *>(inst));
         case IrInstSrcIdCompileErr:
-            return destroy(reinterpret_cast<IrInstSrcCompileErr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCompileErr *>(inst));
         case IrInstSrcIdCompileLog:
-            return destroy(reinterpret_cast<IrInstSrcCompileLog *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCompileLog *>(inst));
         case IrInstSrcIdErrName:
-            return destroy(reinterpret_cast<IrInstSrcErrName *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcErrName *>(inst));
         case IrInstSrcIdCImport:
-            return destroy(reinterpret_cast<IrInstSrcCImport *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCImport *>(inst));
         case IrInstSrcIdCInclude:
-            return destroy(reinterpret_cast<IrInstSrcCInclude *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCInclude *>(inst));
         case IrInstSrcIdCDefine:
-            return destroy(reinterpret_cast<IrInstSrcCDefine *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCDefine *>(inst));
         case IrInstSrcIdCUndef:
-            return destroy(reinterpret_cast<IrInstSrcCUndef *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCUndef *>(inst));
         case IrInstSrcIdEmbedFile:
-            return destroy(reinterpret_cast<IrInstSrcEmbedFile *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcEmbedFile *>(inst));
         case IrInstSrcIdCmpxchg:
-            return destroy(reinterpret_cast<IrInstSrcCmpxchg *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCmpxchg *>(inst));
         case IrInstSrcIdFence:
-            return destroy(reinterpret_cast<IrInstSrcFence *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFence *>(inst));
         case IrInstSrcIdTruncate:
-            return destroy(reinterpret_cast<IrInstSrcTruncate *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcTruncate *>(inst));
         case IrInstSrcIdIntCast:
-            return destroy(reinterpret_cast<IrInstSrcIntCast *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcIntCast *>(inst));
         case IrInstSrcIdFloatCast:
-            return destroy(reinterpret_cast<IrInstSrcFloatCast *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFloatCast *>(inst));
         case IrInstSrcIdErrSetCast:
-            return destroy(reinterpret_cast<IrInstSrcErrSetCast *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcErrSetCast *>(inst));
         case IrInstSrcIdFromBytes:
-            return destroy(reinterpret_cast<IrInstSrcFromBytes *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFromBytes *>(inst));
         case IrInstSrcIdToBytes:
-            return destroy(reinterpret_cast<IrInstSrcToBytes *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcToBytes *>(inst));
         case IrInstSrcIdIntToFloat:
-            return destroy(reinterpret_cast<IrInstSrcIntToFloat *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcIntToFloat *>(inst));
         case IrInstSrcIdFloatToInt:
-            return destroy(reinterpret_cast<IrInstSrcFloatToInt *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFloatToInt *>(inst));
         case IrInstSrcIdBoolToInt:
-            return destroy(reinterpret_cast<IrInstSrcBoolToInt *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcBoolToInt *>(inst));
         case IrInstSrcIdIntType:
-            return destroy(reinterpret_cast<IrInstSrcIntType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcIntType *>(inst));
         case IrInstSrcIdVectorType:
-            return destroy(reinterpret_cast<IrInstSrcVectorType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcVectorType *>(inst));
         case IrInstSrcIdShuffleVector:
-            return destroy(reinterpret_cast<IrInstSrcShuffleVector *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcShuffleVector *>(inst));
         case IrInstSrcIdSplat:
-            return destroy(reinterpret_cast<IrInstSrcSplat *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSplat *>(inst));
         case IrInstSrcIdBoolNot:
-            return destroy(reinterpret_cast<IrInstSrcBoolNot *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcBoolNot *>(inst));
         case IrInstSrcIdMemset:
-            return destroy(reinterpret_cast<IrInstSrcMemset *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcMemset *>(inst));
         case IrInstSrcIdMemcpy:
-            return destroy(reinterpret_cast<IrInstSrcMemcpy *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcMemcpy *>(inst));
         case IrInstSrcIdSlice:
-            return destroy(reinterpret_cast<IrInstSrcSlice *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSlice *>(inst));
         case IrInstSrcIdMemberCount:
-            return destroy(reinterpret_cast<IrInstSrcMemberCount *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcMemberCount *>(inst));
         case IrInstSrcIdMemberType:
-            return destroy(reinterpret_cast<IrInstSrcMemberType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcMemberType *>(inst));
         case IrInstSrcIdMemberName:
-            return destroy(reinterpret_cast<IrInstSrcMemberName *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcMemberName *>(inst));
         case IrInstSrcIdBreakpoint:
-            return destroy(reinterpret_cast<IrInstSrcBreakpoint *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcBreakpoint *>(inst));
         case IrInstSrcIdReturnAddress:
-            return destroy(reinterpret_cast<IrInstSrcReturnAddress *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcReturnAddress *>(inst));
         case IrInstSrcIdFrameAddress:
-            return destroy(reinterpret_cast<IrInstSrcFrameAddress *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFrameAddress *>(inst));
         case IrInstSrcIdFrameHandle:
-            return destroy(reinterpret_cast<IrInstSrcFrameHandle *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFrameHandle *>(inst));
         case IrInstSrcIdFrameType:
-            return destroy(reinterpret_cast<IrInstSrcFrameType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFrameType *>(inst));
         case IrInstSrcIdFrameSize:
-            return destroy(reinterpret_cast<IrInstSrcFrameSize *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFrameSize *>(inst));
         case IrInstSrcIdAlignOf:
-            return destroy(reinterpret_cast<IrInstSrcAlignOf *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcAlignOf *>(inst));
         case IrInstSrcIdOverflowOp:
-            return destroy(reinterpret_cast<IrInstSrcOverflowOp *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcOverflowOp *>(inst));
         case IrInstSrcIdTestErr:
-            return destroy(reinterpret_cast<IrInstSrcTestErr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcTestErr *>(inst));
         case IrInstSrcIdUnwrapErrCode:
-            return destroy(reinterpret_cast<IrInstSrcUnwrapErrCode *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcUnwrapErrCode *>(inst));
         case IrInstSrcIdUnwrapErrPayload:
-            return destroy(reinterpret_cast<IrInstSrcUnwrapErrPayload *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcUnwrapErrPayload *>(inst));
         case IrInstSrcIdFnProto:
-            return destroy(reinterpret_cast<IrInstSrcFnProto *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFnProto *>(inst));
         case IrInstSrcIdTestComptime:
-            return destroy(reinterpret_cast<IrInstSrcTestComptime *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcTestComptime *>(inst));
         case IrInstSrcIdPtrCast:
-            return destroy(reinterpret_cast<IrInstSrcPtrCast *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcPtrCast *>(inst));
         case IrInstSrcIdBitCast:
-            return destroy(reinterpret_cast<IrInstSrcBitCast *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcBitCast *>(inst));
         case IrInstSrcIdPtrToInt:
-            return destroy(reinterpret_cast<IrInstSrcPtrToInt *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcPtrToInt *>(inst));
         case IrInstSrcIdIntToPtr:
-            return destroy(reinterpret_cast<IrInstSrcIntToPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcIntToPtr *>(inst));
         case IrInstSrcIdIntToEnum:
-            return destroy(reinterpret_cast<IrInstSrcIntToEnum *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcIntToEnum *>(inst));
         case IrInstSrcIdIntToErr:
-            return destroy(reinterpret_cast<IrInstSrcIntToErr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcIntToErr *>(inst));
         case IrInstSrcIdErrToInt:
-            return destroy(reinterpret_cast<IrInstSrcErrToInt *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcErrToInt *>(inst));
         case IrInstSrcIdCheckSwitchProngs:
-            return destroy(reinterpret_cast<IrInstSrcCheckSwitchProngs *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCheckSwitchProngs *>(inst));
         case IrInstSrcIdCheckStatementIsVoid:
-            return destroy(reinterpret_cast<IrInstSrcCheckStatementIsVoid *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCheckStatementIsVoid *>(inst));
         case IrInstSrcIdTypeName:
-            return destroy(reinterpret_cast<IrInstSrcTypeName *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcTypeName *>(inst));
         case IrInstSrcIdTagName:
-            return destroy(reinterpret_cast<IrInstSrcTagName *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcTagName *>(inst));
         case IrInstSrcIdPtrType:
-            return destroy(reinterpret_cast<IrInstSrcPtrType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcPtrType *>(inst));
         case IrInstSrcIdDeclRef:
-            return destroy(reinterpret_cast<IrInstSrcDeclRef *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcDeclRef *>(inst));
         case IrInstSrcIdPanic:
-            return destroy(reinterpret_cast<IrInstSrcPanic *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcPanic *>(inst));
         case IrInstSrcIdFieldParentPtr:
-            return destroy(reinterpret_cast<IrInstSrcFieldParentPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFieldParentPtr *>(inst));
         case IrInstSrcIdByteOffsetOf:
-            return destroy(reinterpret_cast<IrInstSrcByteOffsetOf *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcByteOffsetOf *>(inst));
         case IrInstSrcIdBitOffsetOf:
-            return destroy(reinterpret_cast<IrInstSrcBitOffsetOf *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcBitOffsetOf *>(inst));
         case IrInstSrcIdTypeInfo:
-            return destroy(reinterpret_cast<IrInstSrcTypeInfo *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcTypeInfo *>(inst));
         case IrInstSrcIdType:
-            return destroy(reinterpret_cast<IrInstSrcType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcType *>(inst));
         case IrInstSrcIdHasField:
-            return destroy(reinterpret_cast<IrInstSrcHasField *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcHasField *>(inst));
         case IrInstSrcIdTypeId:
-            return destroy(reinterpret_cast<IrInstSrcTypeId *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcTypeId *>(inst));
         case IrInstSrcIdSetEvalBranchQuota:
-            return destroy(reinterpret_cast<IrInstSrcSetEvalBranchQuota *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSetEvalBranchQuota *>(inst));
         case IrInstSrcIdAlignCast:
-            return destroy(reinterpret_cast<IrInstSrcAlignCast *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcAlignCast *>(inst));
         case IrInstSrcIdImplicitCast:
-            return destroy(reinterpret_cast<IrInstSrcImplicitCast *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcImplicitCast *>(inst));
         case IrInstSrcIdResolveResult:
-            return destroy(reinterpret_cast<IrInstSrcResolveResult *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcResolveResult *>(inst));
         case IrInstSrcIdResetResult:
-            return destroy(reinterpret_cast<IrInstSrcResetResult *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcResetResult *>(inst));
         case IrInstSrcIdOpaqueType:
-            return destroy(reinterpret_cast<IrInstSrcOpaqueType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcOpaqueType *>(inst));
         case IrInstSrcIdSetAlignStack:
-            return destroy(reinterpret_cast<IrInstSrcSetAlignStack *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSetAlignStack *>(inst));
         case IrInstSrcIdArgType:
-            return destroy(reinterpret_cast<IrInstSrcArgType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcArgType *>(inst));
         case IrInstSrcIdTagType:
-            return destroy(reinterpret_cast<IrInstSrcTagType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcTagType *>(inst));
         case IrInstSrcIdExport:
-            return destroy(reinterpret_cast<IrInstSrcExport *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcExport *>(inst));
         case IrInstSrcIdErrorReturnTrace:
-            return destroy(reinterpret_cast<IrInstSrcErrorReturnTrace *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcErrorReturnTrace *>(inst));
         case IrInstSrcIdErrorUnion:
-            return destroy(reinterpret_cast<IrInstSrcErrorUnion *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcErrorUnion *>(inst));
         case IrInstSrcIdAtomicRmw:
-            return destroy(reinterpret_cast<IrInstSrcAtomicRmw *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcAtomicRmw *>(inst));
         case IrInstSrcIdSaveErrRetAddr:
-            return destroy(reinterpret_cast<IrInstSrcSaveErrRetAddr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSaveErrRetAddr *>(inst));
         case IrInstSrcIdAddImplicitReturnType:
-            return destroy(reinterpret_cast<IrInstSrcAddImplicitReturnType *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcAddImplicitReturnType *>(inst));
         case IrInstSrcIdFloatOp:
-            return destroy(reinterpret_cast<IrInstSrcFloatOp *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcFloatOp *>(inst));
         case IrInstSrcIdMulAdd:
-            return destroy(reinterpret_cast<IrInstSrcMulAdd *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcMulAdd *>(inst));
         case IrInstSrcIdAtomicLoad:
-            return destroy(reinterpret_cast<IrInstSrcAtomicLoad *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcAtomicLoad *>(inst));
         case IrInstSrcIdAtomicStore:
-            return destroy(reinterpret_cast<IrInstSrcAtomicStore *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcAtomicStore *>(inst));
         case IrInstSrcIdEnumToInt:
-            return destroy(reinterpret_cast<IrInstSrcEnumToInt *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcEnumToInt *>(inst));
         case IrInstSrcIdCheckRuntimeScope:
-            return destroy(reinterpret_cast<IrInstSrcCheckRuntimeScope *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCheckRuntimeScope *>(inst));
         case IrInstSrcIdHasDecl:
-            return destroy(reinterpret_cast<IrInstSrcHasDecl *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcHasDecl *>(inst));
         case IrInstSrcIdUndeclaredIdent:
-            return destroy(reinterpret_cast<IrInstSrcUndeclaredIdent *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcUndeclaredIdent *>(inst));
         case IrInstSrcIdAlloca:
-            return destroy(reinterpret_cast<IrInstSrcAlloca *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcAlloca *>(inst));
         case IrInstSrcIdEndExpr:
-            return destroy(reinterpret_cast<IrInstSrcEndExpr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcEndExpr *>(inst));
         case IrInstSrcIdUnionInitNamedField:
-            return destroy(reinterpret_cast<IrInstSrcUnionInitNamedField *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcUnionInitNamedField *>(inst));
         case IrInstSrcIdSuspendBegin:
-            return destroy(reinterpret_cast<IrInstSrcSuspendBegin *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSuspendBegin *>(inst));
         case IrInstSrcIdSuspendFinish:
-            return destroy(reinterpret_cast<IrInstSrcSuspendFinish *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSuspendFinish *>(inst));
         case IrInstSrcIdResume:
-            return destroy(reinterpret_cast<IrInstSrcResume *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcResume *>(inst));
         case IrInstSrcIdAwait:
-            return destroy(reinterpret_cast<IrInstSrcAwait *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcAwait *>(inst));
         case IrInstSrcIdSpillBegin:
-            return destroy(reinterpret_cast<IrInstSrcSpillBegin *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSpillBegin *>(inst));
         case IrInstSrcIdSpillEnd:
-            return destroy(reinterpret_cast<IrInstSrcSpillEnd *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSpillEnd *>(inst));
         case IrInstSrcIdCallArgs:
-            return destroy(reinterpret_cast<IrInstSrcCallArgs *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcCallArgs *>(inst));
     }
     zig_unreachable();
 }
 void destroy_instruction_gen(IrInstGen *inst) {
-#ifdef ZIG_ENABLE_MEM_PROFILE
-    const char *name = ir_inst_gen_type_str(inst->id);
-#else
-    const char *name = nullptr;
-#endif
     switch (inst->id) {
         case IrInstGenIdInvalid:
             zig_unreachable();
         case IrInstGenIdReturn:
-            return destroy(reinterpret_cast<IrInstGenReturn *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenReturn *>(inst));
         case IrInstGenIdConst:
-            return destroy(reinterpret_cast<IrInstGenConst *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenConst *>(inst));
         case IrInstGenIdBinOp:
-            return destroy(reinterpret_cast<IrInstGenBinOp *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenBinOp *>(inst));
         case IrInstGenIdCast:
-            return destroy(reinterpret_cast<IrInstGenCast *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenCast *>(inst));
         case IrInstGenIdCall:
-            return destroy(reinterpret_cast<IrInstGenCall *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenCall *>(inst));
         case IrInstGenIdCondBr:
-            return destroy(reinterpret_cast<IrInstGenCondBr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenCondBr *>(inst));
         case IrInstGenIdBr:
-            return destroy(reinterpret_cast<IrInstGenBr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenBr *>(inst));
         case IrInstGenIdPhi:
-            return destroy(reinterpret_cast<IrInstGenPhi *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenPhi *>(inst));
         case IrInstGenIdUnreachable:
-            return destroy(reinterpret_cast<IrInstGenUnreachable *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenUnreachable *>(inst));
         case IrInstGenIdElemPtr:
-            return destroy(reinterpret_cast<IrInstGenElemPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenElemPtr *>(inst));
         case IrInstGenIdVarPtr:
-            return destroy(reinterpret_cast<IrInstGenVarPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenVarPtr *>(inst));
         case IrInstGenIdReturnPtr:
-            return destroy(reinterpret_cast<IrInstGenReturnPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenReturnPtr *>(inst));
         case IrInstGenIdLoadPtr:
-            return destroy(reinterpret_cast<IrInstGenLoadPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenLoadPtr *>(inst));
         case IrInstGenIdStorePtr:
-            return destroy(reinterpret_cast<IrInstGenStorePtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenStorePtr *>(inst));
         case IrInstGenIdVectorStoreElem:
-            return destroy(reinterpret_cast<IrInstGenVectorStoreElem *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenVectorStoreElem *>(inst));
         case IrInstGenIdStructFieldPtr:
-            return destroy(reinterpret_cast<IrInstGenStructFieldPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenStructFieldPtr *>(inst));
         case IrInstGenIdUnionFieldPtr:
-            return destroy(reinterpret_cast<IrInstGenUnionFieldPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenUnionFieldPtr *>(inst));
         case IrInstGenIdAsm:
-            return destroy(reinterpret_cast<IrInstGenAsm *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenAsm *>(inst));
         case IrInstGenIdTestNonNull:
-            return destroy(reinterpret_cast<IrInstGenTestNonNull *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenTestNonNull *>(inst));
         case IrInstGenIdOptionalUnwrapPtr:
-            return destroy(reinterpret_cast<IrInstGenOptionalUnwrapPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenOptionalUnwrapPtr *>(inst));
         case IrInstGenIdPopCount:
-            return destroy(reinterpret_cast<IrInstGenPopCount *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenPopCount *>(inst));
         case IrInstGenIdClz:
-            return destroy(reinterpret_cast<IrInstGenClz *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenClz *>(inst));
         case IrInstGenIdCtz:
-            return destroy(reinterpret_cast<IrInstGenCtz *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenCtz *>(inst));
         case IrInstGenIdBswap:
-            return destroy(reinterpret_cast<IrInstGenBswap *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenBswap *>(inst));
         case IrInstGenIdBitReverse:
-            return destroy(reinterpret_cast<IrInstGenBitReverse *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenBitReverse *>(inst));
         case IrInstGenIdSwitchBr:
-            return destroy(reinterpret_cast<IrInstGenSwitchBr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenSwitchBr *>(inst));
         case IrInstGenIdUnionTag:
-            return destroy(reinterpret_cast<IrInstGenUnionTag *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenUnionTag *>(inst));
         case IrInstGenIdRef:
-            return destroy(reinterpret_cast<IrInstGenRef *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenRef *>(inst));
         case IrInstGenIdErrName:
-            return destroy(reinterpret_cast<IrInstGenErrName *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenErrName *>(inst));
         case IrInstGenIdCmpxchg:
-            return destroy(reinterpret_cast<IrInstGenCmpxchg *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenCmpxchg *>(inst));
         case IrInstGenIdFence:
-            return destroy(reinterpret_cast<IrInstGenFence *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenFence *>(inst));
         case IrInstGenIdTruncate:
-            return destroy(reinterpret_cast<IrInstGenTruncate *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenTruncate *>(inst));
         case IrInstGenIdShuffleVector:
-            return destroy(reinterpret_cast<IrInstGenShuffleVector *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenShuffleVector *>(inst));
         case IrInstGenIdSplat:
-            return destroy(reinterpret_cast<IrInstGenSplat *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenSplat *>(inst));
         case IrInstGenIdBoolNot:
-            return destroy(reinterpret_cast<IrInstGenBoolNot *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenBoolNot *>(inst));
         case IrInstGenIdMemset:
-            return destroy(reinterpret_cast<IrInstGenMemset *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenMemset *>(inst));
         case IrInstGenIdMemcpy:
-            return destroy(reinterpret_cast<IrInstGenMemcpy *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenMemcpy *>(inst));
         case IrInstGenIdSlice:
-            return destroy(reinterpret_cast<IrInstGenSlice *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenSlice *>(inst));
         case IrInstGenIdBreakpoint:
-            return destroy(reinterpret_cast<IrInstGenBreakpoint *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenBreakpoint *>(inst));
         case IrInstGenIdReturnAddress:
-            return destroy(reinterpret_cast<IrInstGenReturnAddress *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenReturnAddress *>(inst));
         case IrInstGenIdFrameAddress:
-            return destroy(reinterpret_cast<IrInstGenFrameAddress *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenFrameAddress *>(inst));
         case IrInstGenIdFrameHandle:
-            return destroy(reinterpret_cast<IrInstGenFrameHandle *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenFrameHandle *>(inst));
         case IrInstGenIdFrameSize:
-            return destroy(reinterpret_cast<IrInstGenFrameSize *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenFrameSize *>(inst));
         case IrInstGenIdOverflowOp:
-            return destroy(reinterpret_cast<IrInstGenOverflowOp *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenOverflowOp *>(inst));
         case IrInstGenIdTestErr:
-            return destroy(reinterpret_cast<IrInstGenTestErr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenTestErr *>(inst));
         case IrInstGenIdUnwrapErrCode:
-            return destroy(reinterpret_cast<IrInstGenUnwrapErrCode *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenUnwrapErrCode *>(inst));
         case IrInstGenIdUnwrapErrPayload:
-            return destroy(reinterpret_cast<IrInstGenUnwrapErrPayload *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenUnwrapErrPayload *>(inst));
         case IrInstGenIdOptionalWrap:
-            return destroy(reinterpret_cast<IrInstGenOptionalWrap *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenOptionalWrap *>(inst));
         case IrInstGenIdErrWrapCode:
-            return destroy(reinterpret_cast<IrInstGenErrWrapCode *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenErrWrapCode *>(inst));
         case IrInstGenIdErrWrapPayload:
-            return destroy(reinterpret_cast<IrInstGenErrWrapPayload *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenErrWrapPayload *>(inst));
         case IrInstGenIdPtrCast:
-            return destroy(reinterpret_cast<IrInstGenPtrCast *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenPtrCast *>(inst));
         case IrInstGenIdBitCast:
-            return destroy(reinterpret_cast<IrInstGenBitCast *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenBitCast *>(inst));
         case IrInstGenIdWidenOrShorten:
-            return destroy(reinterpret_cast<IrInstGenWidenOrShorten *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenWidenOrShorten *>(inst));
         case IrInstGenIdPtrToInt:
-            return destroy(reinterpret_cast<IrInstGenPtrToInt *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenPtrToInt *>(inst));
         case IrInstGenIdIntToPtr:
-            return destroy(reinterpret_cast<IrInstGenIntToPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenIntToPtr *>(inst));
         case IrInstGenIdIntToEnum:
-            return destroy(reinterpret_cast<IrInstGenIntToEnum *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenIntToEnum *>(inst));
         case IrInstGenIdIntToErr:
-            return destroy(reinterpret_cast<IrInstGenIntToErr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenIntToErr *>(inst));
         case IrInstGenIdErrToInt:
-            return destroy(reinterpret_cast<IrInstGenErrToInt *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenErrToInt *>(inst));
         case IrInstGenIdTagName:
-            return destroy(reinterpret_cast<IrInstGenTagName *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenTagName *>(inst));
         case IrInstGenIdPanic:
-            return destroy(reinterpret_cast<IrInstGenPanic *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenPanic *>(inst));
         case IrInstGenIdFieldParentPtr:
-            return destroy(reinterpret_cast<IrInstGenFieldParentPtr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenFieldParentPtr *>(inst));
         case IrInstGenIdAlignCast:
-            return destroy(reinterpret_cast<IrInstGenAlignCast *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenAlignCast *>(inst));
         case IrInstGenIdErrorReturnTrace:
-            return destroy(reinterpret_cast<IrInstGenErrorReturnTrace *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenErrorReturnTrace *>(inst));
         case IrInstGenIdAtomicRmw:
-            return destroy(reinterpret_cast<IrInstGenAtomicRmw *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenAtomicRmw *>(inst));
         case IrInstGenIdSaveErrRetAddr:
-            return destroy(reinterpret_cast<IrInstGenSaveErrRetAddr *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenSaveErrRetAddr *>(inst));
         case IrInstGenIdFloatOp:
-            return destroy(reinterpret_cast<IrInstGenFloatOp *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenFloatOp *>(inst));
         case IrInstGenIdMulAdd:
-            return destroy(reinterpret_cast<IrInstGenMulAdd *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenMulAdd *>(inst));
         case IrInstGenIdAtomicLoad:
-            return destroy(reinterpret_cast<IrInstGenAtomicLoad *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenAtomicLoad *>(inst));
         case IrInstGenIdAtomicStore:
-            return destroy(reinterpret_cast<IrInstGenAtomicStore *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenAtomicStore *>(inst));
         case IrInstGenIdDeclVar:
-            return destroy(reinterpret_cast<IrInstGenDeclVar *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenDeclVar *>(inst));
         case IrInstGenIdArrayToVector:
-            return destroy(reinterpret_cast<IrInstGenArrayToVector *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenArrayToVector *>(inst));
         case IrInstGenIdVectorToArray:
-            return destroy(reinterpret_cast<IrInstGenVectorToArray *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenVectorToArray *>(inst));
         case IrInstGenIdPtrOfArrayToSlice:
-            return destroy(reinterpret_cast<IrInstGenPtrOfArrayToSlice *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenPtrOfArrayToSlice *>(inst));
         case IrInstGenIdAssertZero:
-            return destroy(reinterpret_cast<IrInstGenAssertZero *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenAssertZero *>(inst));
         case IrInstGenIdAssertNonNull:
-            return destroy(reinterpret_cast<IrInstGenAssertNonNull *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenAssertNonNull *>(inst));
         case IrInstGenIdResizeSlice:
-            return destroy(reinterpret_cast<IrInstGenResizeSlice *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenResizeSlice *>(inst));
         case IrInstGenIdAlloca:
-            return destroy(reinterpret_cast<IrInstGenAlloca *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenAlloca *>(inst));
         case IrInstGenIdSuspendBegin:
-            return destroy(reinterpret_cast<IrInstGenSuspendBegin *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenSuspendBegin *>(inst));
         case IrInstGenIdSuspendFinish:
-            return destroy(reinterpret_cast<IrInstGenSuspendFinish *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenSuspendFinish *>(inst));
         case IrInstGenIdResume:
-            return destroy(reinterpret_cast<IrInstGenResume *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenResume *>(inst));
         case IrInstGenIdAwait:
-            return destroy(reinterpret_cast<IrInstGenAwait *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenAwait *>(inst));
         case IrInstGenIdSpillBegin:
-            return destroy(reinterpret_cast<IrInstGenSpillBegin *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenSpillBegin *>(inst));
         case IrInstGenIdSpillEnd:
-            return destroy(reinterpret_cast<IrInstGenSpillEnd *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenSpillEnd *>(inst));
         case IrInstGenIdVectorExtractElem:
-            return destroy(reinterpret_cast<IrInstGenVectorExtractElem *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenVectorExtractElem *>(inst));
         case IrInstGenIdBinaryNot:
-            return destroy(reinterpret_cast<IrInstGenBinaryNot *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenBinaryNot *>(inst));
         case IrInstGenIdNegation:
-            return destroy(reinterpret_cast<IrInstGenNegation *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenNegation *>(inst));
         case IrInstGenIdNegationWrapping:
-            return destroy(reinterpret_cast<IrInstGenNegationWrapping *>(inst), name);
+            return heap::c_allocator.destroy(reinterpret_cast<IrInstGenNegationWrapping *>(inst));
     }
     zig_unreachable();
 }
 @@ -760,15 +750,14 @@ static void ira_deref(IrAnalyze *ira) {
             IrInstSrc *pass1_inst = pass1_bb->instruction_list.items[inst_i];
             destroy_instruction_src(pass1_inst);
         }
-        destroy(pass1_bb, "IrBasicBlockSrc");
+        heap::c_allocator.destroy(pass1_bb);
     }
     ira->old_irb.exec->basic_block_list.deinit();
     ira->old_irb.exec->tld_list.deinit();
-    // cannot destroy here because of var->owner_exec
+    heap::c_allocator.destroy(ira->old_irb.exec);
-    //destroy(ira->old_irb.exec, "IrExecutableSrc");
     ira->src_implicit_return_type_list.deinit();
     ira->resume_stack.deinit();
-    destroy(ira, "IrAnalyze");
+    heap::c_allocator.destroy(ira);
 }
 static ZigValue *const_ptr_pointee_unchecked_no_isf(CodeGen *g, ZigValue *const_val) {
 @@ -1017,8 +1006,8 @@ static void ir_ref_var(ZigVar *var) {
 static void create_result_ptr(CodeGen *codegen, ZigType *expected_type,
         ZigValue **out_result, ZigValue **out_result_ptr)
 {
-    ZigValue *result = create_const_vals(1);
+    ZigValue *result = codegen->pass1_arena->create<ZigValue>();
-    ZigValue *result_ptr = create_const_vals(1);
+    ZigValue *result_ptr = codegen->pass1_arena->create<ZigValue>();
     result->special = ConstValSpecialUndef;
     result->type = expected_type;
     result_ptr->special = ConstValSpecialStatic;
 @@ -1050,14 +1039,11 @@ ZigType *ir_analyze_type_expr(IrAnalyze *ira, Scope *scope, AstNode *node) {
     assert(result->special != ConstValSpecialRuntime);
     ZigType *res_type = result->data.x_type;
-    destroy(result_ptr, "ZigValue");
-    destroy(result, "ZigValue");
     return res_type;
 }
 static IrBasicBlockSrc *ir_create_basic_block(IrBuilderSrc *irb, Scope *scope, const char *name_hint) {
-    IrBasicBlockSrc *result = allocate<IrBasicBlockSrc>(1, "IrBasicBlockSrc");
+    IrBasicBlockSrc *result = heap::c_allocator.create<IrBasicBlockSrc>();
     result->scope = scope;
     result->name_hint = name_hint;
     result->debug_id = exec_next_debug_id(irb->exec);
 @@ -1066,7 +1052,7 @@ static IrBasicBlockSrc *ir_create_basic_block(IrBuilderSrc *irb, Scope *scope, c
 }
 static IrBasicBlockGen *ir_create_basic_block_gen(IrAnalyze *ira, Scope *scope, const char *name_hint) {
-    IrBasicBlockGen *result = allocate<IrBasicBlockGen>(1, "IrBasicBlockGen");
+    IrBasicBlockGen *result = heap::c_allocator.create<IrBasicBlockGen>();
     result->scope = scope;
     result->name_hint = name_hint;
     result->debug_id = exec_next_debug_id_gen(ira->new_irb.exec);
 @@ -1983,12 +1969,7 @@ static constexpr IrInstGenId ir_inst_id(IrInstGenConst *) {
 template<typename T>
 static T *ir_create_instruction(IrBuilderSrc *irb, Scope *scope, AstNode *source_node) {
-    const char *name = nullptr;
+    T *special_instruction = heap::c_allocator.create<T>();
-#ifdef ZIG_ENABLE_MEM_PROFILE
-    T *dummy = nullptr;
-    name = ir_inst_src_type_str(ir_inst_id(dummy));
-#endif
-    T *special_instruction = allocate<T>(1, name);
     special_instruction->base.id = ir_inst_id(special_instruction);
     special_instruction->base.base.scope = scope;
     special_instruction->base.base.source_node = source_node;
 @@ -1999,29 +1980,19 @@ static T *ir_create_instruction(IrBuilderSrc *irb, Scope *scope, AstNode *source
 template<typename T>
 static T *ir_create_inst_gen(IrBuilderGen *irb, Scope *scope, AstNode *source_node) {
-    const char *name = nullptr;
+    T *special_instruction = heap::c_allocator.create<T>();
-#ifdef ZIG_ENABLE_MEM_PROFILE
-    T *dummy = nullptr;
-    name = ir_inst_gen_type_str(ir_inst_id(dummy));
-#endif
-    T *special_instruction = allocate<T>(1, name);
     special_instruction->base.id = ir_inst_id(special_instruction);
     special_instruction->base.base.scope = scope;
     special_instruction->base.base.source_node = source_node;
     special_instruction->base.base.debug_id = exec_next_debug_id_gen(irb->exec);
     special_instruction->base.owner_bb = irb->current_basic_block;
-    special_instruction->base.value = allocate<ZigValue>(1, "ZigValue");
+    special_instruction->base.value = irb->codegen->pass1_arena->create<ZigValue>();
     return special_instruction;
 }
 template<typename T>
 static T *ir_create_inst_noval(IrBuilderGen *irb, Scope *scope, AstNode *source_node) {
-    const char *name = nullptr;
+    T *special_instruction = heap::c_allocator.create<T>();
-#ifdef ZIG_ENABLE_MEM_PROFILE
-    T *dummy = nullptr;
-    name = ir_inst_gen_type_str(ir_inst_id(dummy));
-#endif
-    T *special_instruction = allocate<T>(1, name);
     special_instruction->base.id = ir_inst_id(special_instruction);
     special_instruction->base.base.scope = scope;
     special_instruction->base.base.source_node = source_node;
 @@ -2063,11 +2034,11 @@ static T *ir_build_inst_void(IrBuilderGen *irb, Scope *scope, AstNode *source_no
 IrInstGen *ir_create_alloca(CodeGen *g, Scope *scope, AstNode *source_node, ZigFn *fn,
         ZigType *var_type, const char *name_hint)
 {
-    IrInstGenAlloca *alloca_gen = allocate<IrInstGenAlloca>(1);
+    IrInstGenAlloca *alloca_gen = heap::c_allocator.create<IrInstGenAlloca>();
     alloca_gen->base.id = IrInstGenIdAlloca;
     alloca_gen->base.base.source_node = source_node;
     alloca_gen->base.base.scope = scope;
-    alloca_gen->base.value = allocate<ZigValue>(1, "ZigValue");
+    alloca_gen->base.value = g->pass1_arena->create<ZigValue>();
     alloca_gen->base.value->type = get_pointer_to_type(g, var_type, false);
     alloca_gen->base.base.ref_count = 1;
     alloca_gen->name_hint = name_hint;
 @@ -2157,7 +2128,7 @@ static IrInstSrc *ir_build_const_undefined(IrBuilderSrc *irb, Scope *scope, AstN
 static IrInstSrc *ir_build_const_uint(IrBuilderSrc *irb, Scope *scope, AstNode *source_node, uint64_t value) {
     IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
-    const_instruction->value = create_const_vals(1);
+    const_instruction->value = irb->codegen->pass1_arena->create<ZigValue>();
     const_instruction->value->type = irb->codegen->builtin_types.entry_num_lit_int;
     const_instruction->value->special = ConstValSpecialStatic;
     bigint_init_unsigned(&const_instruction->value->data.x_bigint, value);
 @@ -2166,7 +2137,7 @@ static IrInstSrc *ir_build_const_uint(IrBuilderSrc *irb, Scope *scope, AstNode *
 static IrInstSrc *ir_build_const_bigint(IrBuilderSrc *irb, Scope *scope, AstNode *source_node, BigInt *bigint) {
     IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
-    const_instruction->value = create_const_vals(1);
+    const_instruction->value = irb->codegen->pass1_arena->create<ZigValue>();
     const_instruction->value->type = irb->codegen->builtin_types.entry_num_lit_int;
     const_instruction->value->special = ConstValSpecialStatic;
     bigint_init_bigint(&const_instruction->value->data.x_bigint, bigint);
 @@ -2175,7 +2146,7 @@ static IrInstSrc *ir_build_const_bigint(IrBuilderSrc *irb, Scope *scope, AstNode
 static IrInstSrc *ir_build_const_bigfloat(IrBuilderSrc *irb, Scope *scope, AstNode *source_node, BigFloat *bigfloat) {
     IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
-    const_instruction->value = create_const_vals(1);
+    const_instruction->value = irb->codegen->pass1_arena->create<ZigValue>();
     const_instruction->value->type = irb->codegen->builtin_types.entry_num_lit_float;
     const_instruction->value->special = ConstValSpecialStatic;
     bigfloat_init_bigfloat(&const_instruction->value->data.x_bigfloat, bigfloat);
 @@ -2191,7 +2162,7 @@ static IrInstSrc *ir_build_const_null(IrBuilderSrc *irb, Scope *scope, AstNode *
 static IrInstSrc *ir_build_const_usize(IrBuilderSrc *irb, Scope *scope, AstNode *source_node, uint64_t value) {
     IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
-    const_instruction->value = create_const_vals(1);
+    const_instruction->value = irb->codegen->pass1_arena->create<ZigValue>();
     const_instruction->value->type = irb->codegen->builtin_types.entry_usize;
     const_instruction->value->special = ConstValSpecialStatic;
     bigint_init_unsigned(&const_instruction->value->data.x_bigint, value);
 @@ -2202,7 +2173,7 @@ static IrInstSrc *ir_create_const_type(IrBuilderSrc *irb, Scope *scope, AstNode
         ZigType *type_entry)
 {
     IrInstSrcConst *const_instruction = ir_create_instruction<IrInstSrcConst>(irb, scope, source_node);
-    const_instruction->value = create_const_vals(1);
+    const_instruction->value = irb->codegen->pass1_arena->create<ZigValue>();
     const_instruction->value->type = irb->codegen->builtin_types.entry_type;
     const_instruction->value->special = ConstValSpecialStatic;
     const_instruction->value->data.x_type = type_entry;
 @@ -2219,7 +2190,7 @@ static IrInstSrc *ir_build_const_type(IrBuilderSrc *irb, Scope *scope, AstNode *
 static IrInstSrc *ir_build_const_import(IrBuilderSrc *irb, Scope *scope, AstNode *source_node, ZigType *import) {
     IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
-    const_instruction->value = create_const_vals(1);
+    const_instruction->value = irb->codegen->pass1_arena->create<ZigValue>();
     const_instruction->value->type = irb->codegen->builtin_types.entry_type;
     const_instruction->value->special = ConstValSpecialStatic;
     const_instruction->value->data.x_type = import;
 @@ -2228,7 +2199,7 @@ static IrInstSrc *ir_build_const_import(IrBuilderSrc *irb, Scope *scope, AstNode
 static IrInstSrc *ir_build_const_bool(IrBuilderSrc *irb, Scope *scope, AstNode *source_node, bool value) {
     IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
-    const_instruction->value = create_const_vals(1);
+    const_instruction->value = irb->codegen->pass1_arena->create<ZigValue>();
     const_instruction->value->type = irb->codegen->builtin_types.entry_bool;
     const_instruction->value->special = ConstValSpecialStatic;
     const_instruction->value->data.x_bool = value;
 @@ -2237,7 +2208,7 @@ static IrInstSrc *ir_build_const_bool(IrBuilderSrc *irb, Scope *scope, AstNode *
 static IrInstSrc *ir_build_const_enum_literal(IrBuilderSrc *irb, Scope *scope, AstNode *source_node, Buf *name) {
     IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
-    const_instruction->value = create_const_vals(1);
+    const_instruction->value = irb->codegen->pass1_arena->create<ZigValue>();
     const_instruction->value->type = irb->codegen->builtin_types.entry_enum_literal;
     const_instruction->value->special = ConstValSpecialStatic;
     const_instruction->value->data.x_enum_literal = name;
 @@ -2246,7 +2217,7 @@ static IrInstSrc *ir_build_const_enum_literal(IrBuilderSrc *irb, Scope *scope, A
 static IrInstSrc *ir_create_const_str_lit(IrBuilderSrc *irb, Scope *scope, AstNode *source_node, Buf *str) {
     IrInstSrcConst *const_instruction = ir_create_instruction<IrInstSrcConst>(irb, scope, source_node);
-    const_instruction->value = create_const_vals(1);
+    const_instruction->value = irb->codegen->pass1_arena->create<ZigValue>();
     init_const_str_lit(irb->codegen, const_instruction->value, str);
     return &const_instruction->base;
 @@ -5244,7 +5215,7 @@ static IrInstSrc *ir_gen_return(IrBuilderSrc *irb, Scope *scope, AstNode *node,
     switch (node->data.return_expr.kind) {
         case ReturnKindUnconditional:
             {
-                ResultLocReturn *result_loc_ret = allocate<ResultLocReturn>(1, "ResultLocReturn");
+                ResultLocReturn *result_loc_ret = heap::c_allocator.create<ResultLocReturn>();
                 result_loc_ret->base.id = ResultLocIdReturn;
                 ir_build_reset_result(irb, scope, node, &result_loc_ret->base);
 @@ -5332,7 +5303,7 @@ static IrInstSrc *ir_gen_return(IrBuilderSrc *irb, Scope *scope, AstNode *node,
                 ir_mark_gen(ir_build_add_implicit_return_type(irb, scope, node, err_val, nullptr));
                 IrInstSrcSpillBegin *spill_begin = ir_build_spill_begin_src(irb, scope, node, err_val,
                         SpillIdRetErrCode);
-                ResultLocReturn *result_loc_ret = allocate<ResultLocReturn>(1, "ResultLocReturn");
+                ResultLocReturn *result_loc_ret = heap::c_allocator.create<ResultLocReturn>();
                 result_loc_ret->base.id = ResultLocIdReturn;
                 ir_build_reset_result(irb, scope, node, &result_loc_ret->base);
                 ir_build_end_expr(irb, scope, node, err_val, &result_loc_ret->base);
 @@ -5360,12 +5331,12 @@ static ZigVar *create_local_var(CodeGen *codegen, AstNode *node, Scope *parent_s
         Buf *name, bool src_is_const, bool gen_is_const, bool is_shadowable, IrInstSrc *is_comptime,
         bool skip_name_check)
 {
-    ZigVar *variable_entry = allocate<ZigVar>(1, "ZigVar");
+    ZigVar *variable_entry = heap::c_allocator.create<ZigVar>();
     variable_entry->parent_scope = parent_scope;
     variable_entry->shadowable = is_shadowable;
     variable_entry->is_comptime = is_comptime;
     variable_entry->src_arg_index = SIZE_MAX;
-    variable_entry->const_value = create_const_vals(1);
+    variable_entry->const_value = codegen->pass1_arena->create<ZigValue>();
     if (is_comptime != nullptr) {
         is_comptime->base.ref_count += 1;
 @@ -5425,15 +5396,12 @@ static ZigVar *ir_create_var(IrBuilderSrc *irb, AstNode *node, Scope *scope, Buf
     ZigVar *var = create_local_var(irb->codegen, node, scope,
             (is_underscored ? nullptr : name), src_is_const, gen_is_const,
             (is_underscored ? true : is_shadowable), is_comptime, false);
-    if (is_comptime != nullptr || gen_is_const) {
-        var->owner_exec = irb->exec;
-    }
     assert(var->child_scope);
     return var;
 }
 static ResultLocPeer *create_peer_result(ResultLocPeerParent *peer_parent) {
-    ResultLocPeer *result = allocate<ResultLocPeer>(1, "ResultLocPeer");
+    ResultLocPeer *result = heap::c_allocator.create<ResultLocPeer>();
     result->base.id = ResultLocIdPeer;
     result->base.source_instruction = peer_parent->base.source_instruction;
     result->parent = peer_parent;
 @@ -5472,7 +5440,7 @@ static IrInstSrc *ir_gen_block(IrBuilderSrc *irb, Scope *parent_scope, AstNode *
         scope_block->is_comptime = ir_build_const_bool(irb, parent_scope, block_node,
                 ir_should_inline(irb->exec, parent_scope));
-        scope_block->peer_parent = allocate<ResultLocPeerParent>(1, "ResultLocPeerParent");
+        scope_block->peer_parent = heap::c_allocator.create<ResultLocPeerParent>();
         scope_block->peer_parent->base.id = ResultLocIdPeerParent;
         scope_block->peer_parent->base.source_instruction = scope_block->is_comptime;
         scope_block->peer_parent->base.allow_write_through_const = result_loc->allow_write_through_const;
 @@ -5562,7 +5530,7 @@ static IrInstSrc *ir_gen_block(IrBuilderSrc *irb, Scope *parent_scope, AstNode *
     // only generate unconditional defers
     ir_mark_gen(ir_build_add_implicit_return_type(irb, child_scope, block_node, result, nullptr));
-    ResultLocReturn *result_loc_ret = allocate<ResultLocReturn>(1, "ResultLocReturn");
+    ResultLocReturn *result_loc_ret = heap::c_allocator.create<ResultLocReturn>();
     result_loc_ret->base.id = ResultLocIdReturn;
     ir_build_reset_result(irb, parent_scope, block_node, &result_loc_ret->base);
     ir_mark_gen(ir_build_end_expr(irb, parent_scope, block_node, result, &result_loc_ret->base));
 @@ -5604,7 +5572,7 @@ static IrInstSrc *ir_gen_assign(IrBuilderSrc *irb, Scope *scope, AstNode *node)
     if (lvalue == irb->codegen->invalid_inst_src)
         return irb->codegen->invalid_inst_src;
-    ResultLocInstruction *result_loc_inst = allocate<ResultLocInstruction>(1, "ResultLocInstruction");
+    ResultLocInstruction *result_loc_inst = heap::c_allocator.create<ResultLocInstruction>();
     result_loc_inst->base.id = ResultLocIdInstruction;
     result_loc_inst->base.source_instruction = lvalue;
     ir_ref_instruction(lvalue, irb->current_basic_block);
 @@ -5676,10 +5644,10 @@ static IrInstSrc *ir_gen_bool_or(IrBuilderSrc *irb, Scope *scope, AstNode *node)
     ir_set_cursor_at_end_and_append_block(irb, true_block);
-    IrInstSrc **incoming_values = allocate<IrInstSrc *>(2, "IrInstSrc *");
+    IrInstSrc **incoming_values = heap::c_allocator.allocate<IrInstSrc *>(2);
     incoming_values[0] = val1;
     incoming_values[1] = val2;
-    IrBasicBlockSrc **incoming_blocks = allocate<IrBasicBlockSrc *>(2, "IrBasicBlockSrc *");
+    IrBasicBlockSrc **incoming_blocks = heap::c_allocator.allocate<IrBasicBlockSrc *>(2);
     incoming_blocks[0] = post_val1_block;
     incoming_blocks[1] = post_val2_block;
 @@ -5718,10 +5686,10 @@ static IrInstSrc *ir_gen_bool_and(IrBuilderSrc *irb, Scope *scope, AstNode *node
     ir_set_cursor_at_end_and_append_block(irb, false_block);
-    IrInstSrc **incoming_values = allocate<IrInstSrc *>(2);
+    IrInstSrc **incoming_values = heap::c_allocator.allocate<IrInstSrc *>(2);
     incoming_values[0] = val1;
     incoming_values[1] = val2;
-    IrBasicBlockSrc **incoming_blocks = allocate<IrBasicBlockSrc *>(2, "IrBasicBlockSrc *");
+    IrBasicBlockSrc **incoming_blocks = heap::c_allocator.allocate<IrBasicBlockSrc *>(2);
     incoming_blocks[0] = post_val1_block;
     incoming_blocks[1] = post_val2_block;
 @@ -5731,7 +5699,7 @@ static IrInstSrc *ir_gen_bool_and(IrBuilderSrc *irb, Scope *scope, AstNode *node
 static ResultLocPeerParent *ir_build_result_peers(IrBuilderSrc *irb, IrInstSrc *cond_br_inst,
         IrBasicBlockSrc *end_block, ResultLoc *parent, IrInstSrc *is_comptime)
 {
-    ResultLocPeerParent *peer_parent = allocate<ResultLocPeerParent>(1);
+    ResultLocPeerParent *peer_parent = heap::c_allocator.create<ResultLocPeerParent>();
     peer_parent->base.id = ResultLocIdPeerParent;
     peer_parent->base.source_instruction = cond_br_inst;
     peer_parent->base.allow_write_through_const = parent->allow_write_through_const;
 @@ -5809,10 +5777,10 @@ static IrInstSrc *ir_gen_orelse(IrBuilderSrc *irb, Scope *parent_scope, AstNode
     ir_build_br(irb, parent_scope, node, end_block, is_comptime);
     ir_set_cursor_at_end_and_append_block(irb, end_block);
-    IrInstSrc **incoming_values = allocate<IrInstSrc *>(2);
+    IrInstSrc **incoming_values = heap::c_allocator.allocate<IrInstSrc *>(2);
     incoming_values[0] = null_result;
     incoming_values[1] = unwrapped_payload;
-    IrBasicBlockSrc **incoming_blocks = allocate<IrBasicBlockSrc *>(2, "IrBasicBlockSrc *");
+    IrBasicBlockSrc **incoming_blocks = heap::c_allocator.allocate<IrBasicBlockSrc *>(2);
     incoming_blocks[0] = after_null_block;
     incoming_blocks[1] = after_ok_block;
     IrInstSrc *phi = ir_build_phi(irb, parent_scope, node, 2, incoming_blocks, incoming_values, peer_parent);
 @@ -5966,7 +5934,7 @@ static void populate_invalid_variable_in_scope(CodeGen *g, Scope *scope, AstNode
         }
         scope = scope->parent;
     }
-    TldVar *tld_var = allocate<TldVar>(1);
+    TldVar *tld_var = heap::c_allocator.create<TldVar>();
     init_tld(&tld_var->base, TldIdVar, var_name, VisibModPub, node, &scope_decls->base);
     tld_var->base.resolution = TldResolutionInvalid;
     tld_var->var = add_variable(g, node, &scope_decls->base, var_name, false,
 @@ -5983,7 +5951,7 @@ static IrInstSrc *ir_gen_symbol(IrBuilderSrc *irb, Scope *scope, AstNode *node,
     if (buf_eql_str(variable_name, "_")) {
         if (lval == LValPtr) {
             IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, node);
-            const_instruction->value = create_const_vals(1);
+            const_instruction->value = irb->codegen->pass1_arena->create<ZigValue>();
             const_instruction->value->type = get_pointer_to_type(irb->codegen,
                     irb->codegen->builtin_types.entry_void, false);
             const_instruction->value->special = ConstValSpecialStatic;
 @@ -6177,7 +6145,7 @@ static IrInstSrc *ir_gen_async_call(IrBuilderSrc *irb, Scope *scope, AstNode *aw
         return fn_ref;
     size_t arg_count = call_node->data.fn_call_expr.params.length - arg_offset;
-    IrInstSrc **args = allocate<IrInstSrc*>(arg_count);
+    IrInstSrc **args = heap::c_allocator.allocate<IrInstSrc*>(arg_count);
     for (size_t i = 0; i < arg_count; i += 1) {
         AstNode *arg_node = call_node->data.fn_call_expr.params.at(i + arg_offset);
         IrInstSrc *arg = ir_gen_node(irb, arg_node, scope);
 @@ -6203,7 +6171,7 @@ static IrInstSrc *ir_gen_fn_call_with_args(IrBuilderSrc *irb, Scope *scope, AstN
     IrInstSrc *fn_type = ir_build_typeof(irb, scope, source_node, fn_ref);
-    IrInstSrc **args = allocate<IrInstSrc*>(args_len);
+    IrInstSrc **args = heap::c_allocator.allocate<IrInstSrc*>(args_len);
     for (size_t i = 0; i < args_len; i += 1) {
         AstNode *arg_node = args_ptr[i];
 @@ -6388,7 +6356,7 @@ static IrInstSrc *ir_gen_builtin_fn_call(IrBuilderSrc *irb, Scope *scope, AstNod
             }
         case BuiltinFnIdCompileLog:
             {
-                IrInstSrc **args = allocate<IrInstSrc*>(actual_param_count);
+                IrInstSrc **args = heap::c_allocator.allocate<IrInstSrc*>(actual_param_count);
                 for (size_t i = 0; i < actual_param_count; i += 1) {
                     AstNode *arg_node = node->data.fn_call_expr.params.at(i);
 @@ -7013,7 +6981,7 @@ static IrInstSrc *ir_gen_builtin_fn_call(IrBuilderSrc *irb, Scope *scope, AstNod
                 if (dest_type == irb->codegen->invalid_inst_src)
                     return dest_type;
-                ResultLocBitCast *result_loc_bit_cast = allocate<ResultLocBitCast>(1);
+                ResultLocBitCast *result_loc_bit_cast = heap::c_allocator.create<ResultLocBitCast>();
                 result_loc_bit_cast->base.id = ResultLocIdBitCast;
                 result_loc_bit_cast->base.source_instruction = dest_type;
                 result_loc_bit_cast->base.allow_write_through_const = result_loc->allow_write_through_const;
 @@ -7166,7 +7134,7 @@ static IrInstSrc *ir_gen_builtin_fn_call(IrBuilderSrc *irb, Scope *scope, AstNod
                 size_t arg_count = node->data.fn_call_expr.params.length - 2;
-                IrInstSrc **args = allocate<IrInstSrc*>(arg_count);
+                IrInstSrc **args = heap::c_allocator.allocate<IrInstSrc*>(arg_count);
                 for (size_t i = 0; i < arg_count; i += 1) {
                     AstNode *arg_node = node->data.fn_call_expr.params.at(i + 2);
                     args[i] = ir_gen_node(irb, arg_node, scope);
 @@ -7595,10 +7563,10 @@ static IrInstSrc *ir_gen_if_bool_expr(IrBuilderSrc *irb, Scope *scope, AstNode *
         ir_mark_gen(ir_build_br(irb, scope, node, endif_block, is_comptime));
     ir_set_cursor_at_end_and_append_block(irb, endif_block);
-    IrInstSrc **incoming_values = allocate<IrInstSrc *>(2);
+    IrInstSrc **incoming_values = heap::c_allocator.allocate<IrInstSrc *>(2);
     incoming_values[0] = then_expr_result;
     incoming_values[1] = else_expr_result;
-    IrBasicBlockSrc **incoming_blocks = allocate<IrBasicBlockSrc *>(2, "IrBasicBlockSrc *");
+    IrBasicBlockSrc **incoming_blocks = heap::c_allocator.allocate<IrBasicBlockSrc *>(2);
     incoming_blocks[0] = after_then_block;
     incoming_blocks[1] = after_else_block;
 @@ -7799,7 +7767,7 @@ static IrInstSrc *ir_gen_union_init_expr(IrBuilderSrc *irb, Scope *scope, AstNod
     IrInstSrc *field_ptr = ir_build_field_ptr_instruction(irb, scope, source_node, container_ptr,
             field_name, true);
-    ResultLocInstruction *result_loc_inst = allocate<ResultLocInstruction>(1);
+    ResultLocInstruction *result_loc_inst = heap::c_allocator.create<ResultLocInstruction>();
     result_loc_inst->base.id = ResultLocIdInstruction;
     result_loc_inst->base.source_instruction = field_ptr;
     ir_ref_instruction(field_ptr, irb->current_basic_block);
 @@ -7875,7 +7843,7 @@ static IrInstSrc *ir_gen_container_init_expr(IrBuilderSrc *irb, Scope *scope, As
                     nullptr);
             size_t field_count = container_init_expr->entries.length;
-            IrInstSrcContainerInitFieldsField *fields = allocate<IrInstSrcContainerInitFieldsField>(field_count);
+            IrInstSrcContainerInitFieldsField *fields = heap::c_allocator.allocate<IrInstSrcContainerInitFieldsField>(field_count);
             for (size_t i = 0; i < field_count; i += 1) {
                 AstNode *entry_node = container_init_expr->entries.at(i);
                 assert(entry_node->type == NodeTypeStructValueField);
 @@ -7884,7 +7852,7 @@ static IrInstSrc *ir_gen_container_init_expr(IrBuilderSrc *irb, Scope *scope, As
                 AstNode *expr_node = entry_node->data.struct_val_field.expr;
                 IrInstSrc *field_ptr = ir_build_field_ptr(irb, scope, entry_node, container_ptr, name, true);
-                ResultLocInstruction *result_loc_inst = allocate<ResultLocInstruction>(1);
+                ResultLocInstruction *result_loc_inst = heap::c_allocator.create<ResultLocInstruction>();
                 result_loc_inst->base.id = ResultLocIdInstruction;
                 result_loc_inst->base.source_instruction = field_ptr;
                 result_loc_inst->base.allow_write_through_const = true;
 @@ -7914,14 +7882,14 @@ static IrInstSrc *ir_gen_container_init_expr(IrBuilderSrc *irb, Scope *scope, As
             IrInstSrc *container_ptr = ir_build_resolve_result(irb, scope, node, child_result_loc,
                     nullptr);
-            IrInstSrc **result_locs = allocate<IrInstSrc *>(item_count);
+            IrInstSrc **result_locs = heap::c_allocator.allocate<IrInstSrc *>(item_count);
             for (size_t i = 0; i < item_count; i += 1) {
                 AstNode *expr_node = container_init_expr->entries.at(i);
                 IrInstSrc *elem_index = ir_build_const_usize(irb, scope, expr_node, i);
                 IrInstSrc *elem_ptr = ir_build_elem_ptr(irb, scope, expr_node, container_ptr,
                         elem_index, false, PtrLenSingle, init_array_type_source_node);
-                ResultLocInstruction *result_loc_inst = allocate<ResultLocInstruction>(1);
+                ResultLocInstruction *result_loc_inst = heap::c_allocator.create<ResultLocInstruction>();
                 result_loc_inst->base.id = ResultLocIdInstruction;
                 result_loc_inst->base.source_instruction = elem_ptr;
                 result_loc_inst->base.allow_write_through_const = true;
 @@ -7947,7 +7915,7 @@ static IrInstSrc *ir_gen_container_init_expr(IrBuilderSrc *irb, Scope *scope, As
 }
 static ResultLocVar *ir_build_var_result_loc(IrBuilderSrc *irb, IrInstSrc *alloca, ZigVar *var) {
-    ResultLocVar *result_loc_var = allocate<ResultLocVar>(1);
+    ResultLocVar *result_loc_var = heap::c_allocator.create<ResultLocVar>();
     result_loc_var->base.id = ResultLocIdVar;
     result_loc_var->base.source_instruction = alloca;
     result_loc_var->base.allow_write_through_const = true;
 @@ -7961,7 +7929,7 @@ static ResultLocVar *ir_build_var_result_loc(IrBuilderSrc *irb, IrInstSrc *alloc
 static ResultLocCast *ir_build_cast_result_loc(IrBuilderSrc *irb, IrInstSrc *dest_type,
         ResultLoc *parent_result_loc)
 {
-    ResultLocCast *result_loc_cast = allocate<ResultLocCast>(1);
+    ResultLocCast *result_loc_cast = heap::c_allocator.create<ResultLocCast>();
     result_loc_cast->base.id = ResultLocIdCast;
     result_loc_cast->base.source_instruction = dest_type;
     result_loc_cast->base.allow_write_through_const = parent_result_loc->allow_write_through_const;
 @@ -8804,9 +8772,9 @@ static IrInstSrc *ir_gen_asm_expr(IrBuilderSrc *irb, Scope *scope, AstNode *node
                                 nullptr, 0, is_volatile, true);
     }
-    IrInstSrc **input_list = allocate<IrInstSrc *>(asm_expr->input_list.length);
+    IrInstSrc **input_list = heap::c_allocator.allocate<IrInstSrc *>(asm_expr->input_list.length);
-    IrInstSrc **output_types = allocate<IrInstSrc *>(asm_expr->output_list.length);
+    IrInstSrc **output_types = heap::c_allocator.allocate<IrInstSrc *>(asm_expr->output_list.length);
-    ZigVar **output_vars = allocate<ZigVar *>(asm_expr->output_list.length);
+    ZigVar **output_vars = heap::c_allocator.allocate<ZigVar *>(asm_expr->output_list.length);
     size_t return_count = 0;
     if (!is_volatile && asm_expr->output_list.length == 0) {
         add_node_error(irb->codegen, node,
 @@ -8940,10 +8908,10 @@ static IrInstSrc *ir_gen_if_optional_expr(IrBuilderSrc *irb, Scope *scope, AstNo
         ir_mark_gen(ir_build_br(irb, scope, node, endif_block, is_comptime));
     ir_set_cursor_at_end_and_append_block(irb, endif_block);
-    IrInstSrc **incoming_values = allocate<IrInstSrc *>(2);
+    IrInstSrc **incoming_values = heap::c_allocator.allocate<IrInstSrc *>(2);
     incoming_values[0] = then_expr_result;
     incoming_values[1] = else_expr_result;
-    IrBasicBlockSrc **incoming_blocks = allocate<IrBasicBlockSrc *>(2, "IrBasicBlockSrc *");
+    IrBasicBlockSrc **incoming_blocks = heap::c_allocator.allocate<IrBasicBlockSrc *>(2);
     incoming_blocks[0] = after_then_block;
     incoming_blocks[1] = after_else_block;
 @@ -9037,10 +9005,10 @@ static IrInstSrc *ir_gen_if_err_expr(IrBuilderSrc *irb, Scope *scope, AstNode *n
         ir_mark_gen(ir_build_br(irb, scope, node, endif_block, is_comptime));
     ir_set_cursor_at_end_and_append_block(irb, endif_block);
-    IrInstSrc **incoming_values = allocate<IrInstSrc *>(2);
+    IrInstSrc **incoming_values = heap::c_allocator.allocate<IrInstSrc *>(2);
     incoming_values[0] = then_expr_result;
     incoming_values[1] = else_expr_result;
-    IrBasicBlockSrc **incoming_blocks = allocate<IrBasicBlockSrc *>(2, "IrBasicBlockSrc *");
+    IrBasicBlockSrc **incoming_blocks = heap::c_allocator.allocate<IrBasicBlockSrc *>(2);
     incoming_blocks[0] = after_then_block;
     incoming_blocks[1] = after_else_block;
 @@ -9133,7 +9101,7 @@ static IrInstSrc *ir_gen_switch_expr(IrBuilderSrc *irb, Scope *scope, AstNode *n
     IrInstSrcSwitchElseVar *switch_else_var = nullptr;
-    ResultLocPeerParent *peer_parent = allocate<ResultLocPeerParent>(1);
+    ResultLocPeerParent *peer_parent = heap::c_allocator.create<ResultLocPeerParent>();
     peer_parent->base.id = ResultLocIdPeerParent;
     peer_parent->base.allow_write_through_const = result_loc->allow_write_through_const;
     peer_parent->end_bb = end_block;
 @@ -9295,7 +9263,7 @@ static IrInstSrc *ir_gen_switch_expr(IrBuilderSrc *irb, Scope *scope, AstNode *n
         ResultLocPeer *this_peer_result_loc = create_peer_result(peer_parent);
         IrBasicBlockSrc *prong_block = ir_create_basic_block(irb, scope, "SwitchProng");
-        IrInstSrc **items = allocate<IrInstSrc *>(prong_item_count);
+        IrInstSrc **items = heap::c_allocator.allocate<IrInstSrc *>(prong_item_count);
         for (size_t item_i = 0; item_i < prong_item_count; item_i += 1) {
             AstNode *item_node = prong_node->data.switch_prong.items.at(item_i);
 @@ -9677,10 +9645,10 @@ static IrInstSrc *ir_gen_catch(IrBuilderSrc *irb, Scope *parent_scope, AstNode *
     ir_build_br(irb, parent_scope, node, end_block, is_comptime);
     ir_set_cursor_at_end_and_append_block(irb, end_block);
-    IrInstSrc **incoming_values = allocate<IrInstSrc *>(2);
+    IrInstSrc **incoming_values = heap::c_allocator.allocate<IrInstSrc *>(2);
     incoming_values[0] = err_result;
     incoming_values[1] = unwrapped_payload;
-    IrBasicBlockSrc **incoming_blocks = allocate<IrBasicBlockSrc *>(2, "IrBasicBlockSrc *");
+    IrBasicBlockSrc **incoming_blocks = heap::c_allocator.allocate<IrBasicBlockSrc *>(2);
     incoming_blocks[0] = after_err_block;
     incoming_blocks[1] = after_ok_block;
     IrInstSrc *phi = ir_build_phi(irb, parent_scope, node, 2, incoming_blocks, incoming_values, peer_parent);
 @@ -9747,7 +9715,7 @@ static IrInstSrc *ir_gen_container_decl(IrBuilderSrc *irb, Scope *parent_scope,
         scan_decls(irb->codegen, child_scope, child_node);
     }
-    TldContainer *tld_container = allocate<TldContainer>(1);
+    TldContainer *tld_container = heap::c_allocator.create<TldContainer>();
     init_tld(&tld_container->base, TldIdContainer, bare_name, VisibModPub, node, parent_scope);
     tld_container->type_entry = container_type;
     tld_container->decls_scope = child_scope;
 @@ -9790,7 +9758,7 @@ static ZigType *get_error_set_union(CodeGen *g, ErrorTableEntry **errors, ZigTyp
     }
     err_set_type->data.error_set.err_count = count;
-    err_set_type->data.error_set.errors = allocate<ErrorTableEntry *>(count);
+    err_set_type->data.error_set.errors = heap::c_allocator.allocate<ErrorTableEntry *>(count);
     bool need_comma = false;
     for (uint32_t i = 0; i < set1->data.error_set.err_count; i += 1) {
 @@ -9837,7 +9805,7 @@ static ZigType *make_err_set_with_one_item(CodeGen *g, Scope *parent_scope, AstN
     err_set_type->abi_align = g->builtin_types.entry_global_error_set->abi_align;
     err_set_type->abi_size = g->builtin_types.entry_global_error_set->abi_size;
     err_set_type->data.error_set.err_count = 1;
-    err_set_type->data.error_set.errors = allocate<ErrorTableEntry *>(1);
+    err_set_type->data.error_set.errors = heap::c_allocator.create<ErrorTableEntry *>();
     err_set_type->data.error_set.errors[0] = err_entry;
 @@ -9868,16 +9836,16 @@ static IrInstSrc *ir_gen_err_set_decl(IrBuilderSrc *irb, Scope *parent_scope, As
     err_set_type->size_in_bits = irb->codegen->builtin_types.entry_global_error_set->size_in_bits;
     err_set_type->abi_align = irb->codegen->builtin_types.entry_global_error_set->abi_align;
     err_set_type->abi_size = irb->codegen->builtin_types.entry_global_error_set->abi_size;
-    err_set_type->data.error_set.errors = allocate<ErrorTableEntry *>(err_count);
+    err_set_type->data.error_set.errors = heap::c_allocator.allocate<ErrorTableEntry *>(err_count);
     size_t errors_count = irb->codegen->errors_by_index.length + err_count;
-    ErrorTableEntry **errors = allocate<ErrorTableEntry *>(errors_count, "ErrorTableEntry *");
+    ErrorTableEntry **errors = heap::c_allocator.allocate<ErrorTableEntry *>(errors_count);
     for (uint32_t i = 0; i < err_count; i += 1) {
         AstNode *field_node = node->data.err_set_decl.decls.at(i);
         AstNode *symbol_node = ast_field_to_symbol_node(field_node);
         Buf *err_name = symbol_node->data.symbol_expr.symbol;
-        ErrorTableEntry *err = allocate<ErrorTableEntry>(1);
+        ErrorTableEntry *err = heap::c_allocator.create<ErrorTableEntry>();
         err->decl_node = field_node;
         buf_init_from_buf(&err->name, err_name);
 @@ -9902,7 +9870,7 @@ static IrInstSrc *ir_gen_err_set_decl(IrBuilderSrc *irb, Scope *parent_scope, As
         }
         errors[err->value] = err;
     }
-    deallocate(errors, errors_count, "ErrorTableEntry *");
+    heap::c_allocator.deallocate(errors, errors_count);
     return ir_build_const_type(irb, parent_scope, node, err_set_type);
 }
 @@ -9910,7 +9878,7 @@ static IrInstSrc *ir_gen_fn_proto(IrBuilderSrc *irb, Scope *parent_scope, AstNod
     assert(node->type == NodeTypeFnProto);
     size_t param_count = node->data.fn_proto.params.length;
-    IrInstSrc **param_types = allocate<IrInstSrc*>(param_count);
+    IrInstSrc **param_types = heap::c_allocator.allocate<IrInstSrc*>(param_count);
     bool is_var_args = false;
     for (size_t i = 0; i < param_count; i += 1) {
 @@ -10191,7 +10159,7 @@ static IrInstSrc *ir_gen_node_raw(IrBuilderSrc *irb, AstNode *node, Scope *scope
 }
 static ResultLoc *no_result_loc(void) {
-    ResultLocNone *result_loc_none = allocate<ResultLocNone>(1);
+    ResultLocNone *result_loc_none = heap::c_allocator.create<ResultLocNone>();
     result_loc_none->base.id = ResultLocIdNone;
     return &result_loc_none->base;
 }
 @@ -10280,7 +10248,7 @@ bool ir_gen(CodeGen *codegen, AstNode *node, Scope *scope, IrExecutableSrc *ir_e
     if (!instr_is_unreachable(result)) {
         ir_mark_gen(ir_build_add_implicit_return_type(irb, scope, result->base.source_node, result, nullptr));
         // no need for save_err_ret_addr because this cannot return error
-        ResultLocReturn *result_loc_ret = allocate<ResultLocReturn>(1, "ResultLocReturn");
+        ResultLocReturn *result_loc_ret = heap::c_allocator.create<ResultLocReturn>();
         result_loc_ret->base.id = ResultLocIdReturn;
         ir_build_reset_result(irb, scope, node, &result_loc_ret->base);
         ir_mark_gen(ir_build_end_expr(irb, scope, node, result, &result_loc_ret->base));
 @@ -10372,7 +10340,7 @@ static Error eval_comptime_ptr_reinterpret(IrAnalyze *ira, CodeGen *codegen, Ast
     if ((err = ir_read_const_ptr(ira, codegen, source_node, &tmp, ptr_val)))
         return err;
     ZigValue *child_val = const_ptr_pointee_unchecked(codegen, ptr_val);
-    copy_const_val(child_val, &tmp);
+    copy_const_val(codegen, child_val, &tmp);
     return ErrorNone;
 }
 @@ -11522,7 +11490,7 @@ static ZigType *get_error_set_intersection(IrAnalyze *ira, ZigType *set1, ZigTyp
         return set1;
     }
     size_t errors_count = ira->codegen->errors_by_index.length;
-    ErrorTableEntry **errors = allocate<ErrorTableEntry *>(errors_count, "ErrorTableEntry *");
+    ErrorTableEntry **errors = heap::c_allocator.allocate<ErrorTableEntry *>(errors_count);
     populate_error_set_table(errors, set1);
     ZigList<ErrorTableEntry *> intersection_list = {};
 @@ -11543,7 +11511,7 @@ static ZigType *get_error_set_intersection(IrAnalyze *ira, ZigType *set1, ZigTyp
             buf_appendf(&err_set_type->name, "%s%s", comma, buf_ptr(&existing_entry_with_docs->name));
         }
     }
-    deallocate(errors, errors_count, "ErrorTableEntry *");
+    heap::c_allocator.deallocate(errors, errors_count);
     err_set_type->data.error_set.err_count = intersection_list.length;
     err_set_type->data.error_set.errors = intersection_list.items;
 @@ -11596,7 +11564,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             actual_ptr_type->data.pointer.ptr_len == PtrLenC;
         if (!ok_null_term_ptrs) {
             result.id = ConstCastResultIdPtrSentinel;
-            result.data.bad_ptr_sentinel = allocate_nonzero<ConstCastPtrSentinel>(1);
+            result.data.bad_ptr_sentinel = heap::c_allocator.allocate_nonzero<ConstCastPtrSentinel>(1);
             result.data.bad_ptr_sentinel->wanted_type = wanted_ptr_type;
             result.data.bad_ptr_sentinel->actual_type = actual_ptr_type;
             return result;
 @@ -11612,7 +11580,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             (!actual_ptr_type->data.pointer.is_volatile || wanted_ptr_type->data.pointer.is_volatile);
         if (!ok_cv_qualifiers) {
             result.id = ConstCastResultIdCV;
-            result.data.bad_cv = allocate_nonzero<ConstCastBadCV>(1);
+            result.data.bad_cv = heap::c_allocator.allocate_nonzero<ConstCastBadCV>(1);
             result.data.bad_cv->wanted_type = wanted_ptr_type;
             result.data.bad_cv->actual_type = actual_ptr_type;
             return result;
 @@ -11624,7 +11592,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             return child;
         if (child.id != ConstCastResultIdOk) {
             result.id = ConstCastResultIdPointerChild;
-            result.data.pointer_mismatch = allocate_nonzero<ConstCastPointerMismatch>(1);
+            result.data.pointer_mismatch = heap::c_allocator.allocate_nonzero<ConstCastPointerMismatch>(1);
             result.data.pointer_mismatch->child = child;
             result.data.pointer_mismatch->wanted_child = wanted_ptr_type->data.pointer.child_type;
             result.data.pointer_mismatch->actual_child = actual_ptr_type->data.pointer.child_type;
 @@ -11635,7 +11603,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             (!wanted_allows_zero && !actual_allows_zero);
         if (!ok_allows_zero) {
             result.id = ConstCastResultIdBadAllowsZero;
-            result.data.bad_allows_zero = allocate_nonzero<ConstCastBadAllowsZero>(1);
+            result.data.bad_allows_zero = heap::c_allocator.allocate_nonzero<ConstCastBadAllowsZero>(1);
             result.data.bad_allows_zero->wanted_type = wanted_type;
             result.data.bad_allows_zero->actual_type = actual_type;
             return result;
 @@ -11675,7 +11643,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             return child;
         if (child.id != ConstCastResultIdOk) {
             result.id = ConstCastResultIdArrayChild;
-            result.data.array_mismatch = allocate_nonzero<ConstCastArrayMismatch>(1);
+            result.data.array_mismatch = heap::c_allocator.allocate_nonzero<ConstCastArrayMismatch>(1);
             result.data.array_mismatch->child = child;
             result.data.array_mismatch->wanted_child = wanted_type->data.array.child_type;
             result.data.array_mismatch->actual_child = actual_type->data.array.child_type;
 @@ -11686,7 +11654,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             const_values_equal(ira->codegen, wanted_type->data.array.sentinel, actual_type->data.array.sentinel));
         if (!ok_null_terminated) {
             result.id = ConstCastResultIdSentinelArrays;
-            result.data.sentinel_arrays = allocate_nonzero<ConstCastBadNullTermArrays>(1);
+            result.data.sentinel_arrays = heap::c_allocator.allocate_nonzero<ConstCastBadNullTermArrays>(1);
             result.data.sentinel_arrays->child = child;
             result.data.sentinel_arrays->wanted_type = wanted_type;
             result.data.sentinel_arrays->actual_type = actual_type;
 @@ -11714,7 +11682,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
                  actual_ptr_type->data.pointer.sentinel));
         if (!ok_sentinels) {
             result.id = ConstCastResultIdPtrSentinel;
-            result.data.bad_ptr_sentinel = allocate_nonzero<ConstCastPtrSentinel>(1);
+            result.data.bad_ptr_sentinel = heap::c_allocator.allocate_nonzero<ConstCastPtrSentinel>(1);
             result.data.bad_ptr_sentinel->wanted_type = wanted_ptr_type;
             result.data.bad_ptr_sentinel->actual_type = actual_ptr_type;
             return result;
 @@ -11731,7 +11699,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
                 return child;
             if (child.id != ConstCastResultIdOk) {
                 result.id = ConstCastResultIdSliceChild;
-                result.data.slice_mismatch = allocate_nonzero<ConstCastSliceMismatch>(1);
+                result.data.slice_mismatch = heap::c_allocator.allocate_nonzero<ConstCastSliceMismatch>(1);
                 result.data.slice_mismatch->child = child;
                 result.data.slice_mismatch->actual_child = actual_ptr_type->data.pointer.child_type;
                 result.data.slice_mismatch->wanted_child = wanted_ptr_type->data.pointer.child_type;
 @@ -11748,7 +11716,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             return child;
         if (child.id != ConstCastResultIdOk) {
             result.id = ConstCastResultIdOptionalChild;
-            result.data.optional = allocate_nonzero<ConstCastOptionalMismatch>(1);
+            result.data.optional = heap::c_allocator.allocate_nonzero<ConstCastOptionalMismatch>(1);
             result.data.optional->child = child;
             result.data.optional->wanted_child = wanted_type->data.maybe.child_type;
             result.data.optional->actual_child = actual_type->data.maybe.child_type;
 @@ -11764,7 +11732,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             return payload_child;
         if (payload_child.id != ConstCastResultIdOk) {
             result.id = ConstCastResultIdErrorUnionPayload;
-            result.data.error_union_payload = allocate_nonzero<ConstCastErrUnionPayloadMismatch>(1);
+            result.data.error_union_payload = heap::c_allocator.allocate_nonzero<ConstCastErrUnionPayloadMismatch>(1);
             result.data.error_union_payload->child = payload_child;
             result.data.error_union_payload->wanted_payload = wanted_type->data.error_union.payload_type;
             result.data.error_union_payload->actual_payload = actual_type->data.error_union.payload_type;
 @@ -11776,7 +11744,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             return error_set_child;
         if (error_set_child.id != ConstCastResultIdOk) {
             result.id = ConstCastResultIdErrorUnionErrorSet;
-            result.data.error_union_error_set = allocate_nonzero<ConstCastErrUnionErrSetMismatch>(1);
+            result.data.error_union_error_set = heap::c_allocator.allocate_nonzero<ConstCastErrUnionErrSetMismatch>(1);
             result.data.error_union_error_set->child = error_set_child;
             result.data.error_union_error_set->wanted_err_set = wanted_type->data.error_union.err_set_type;
             result.data.error_union_error_set->actual_err_set = actual_type->data.error_union.err_set_type;
 @@ -11810,7 +11778,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
         }
         size_t errors_count = g->errors_by_index.length;
-        ErrorTableEntry **errors = allocate<ErrorTableEntry *>(errors_count, "ErrorTableEntry *");
+        ErrorTableEntry **errors = heap::c_allocator.allocate<ErrorTableEntry *>(errors_count);
         for (uint32_t i = 0; i < container_set->data.error_set.err_count; i += 1) {
             ErrorTableEntry *error_entry = container_set->data.error_set.errors[i];
             assert(errors[error_entry->value] == nullptr);
 @@ -11822,12 +11790,12 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             if (error_entry == nullptr) {
                 if (result.id == ConstCastResultIdOk) {
                     result.id = ConstCastResultIdErrSet;
-                    result.data.error_set_mismatch = allocate<ConstCastErrSetMismatch>(1);
+                    result.data.error_set_mismatch = heap::c_allocator.create<ConstCastErrSetMismatch>();
                 }
                 result.data.error_set_mismatch->missing_errors.append(contained_error_entry);
             }
         }
-        deallocate(errors, errors_count, "ErrorTableEntry *");
+        heap::c_allocator.deallocate(errors, errors_count);
         return result;
     }
 @@ -11856,7 +11824,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
                 return child;
             if (child.id != ConstCastResultIdOk) {
                 result.id = ConstCastResultIdFnReturnType;
-                result.data.return_type = allocate_nonzero<ConstCastOnly>(1);
+                result.data.return_type = heap::c_allocator.allocate_nonzero<ConstCastOnly>(1);
                 *result.data.return_type = child;
                 return result;
             }
 @@ -11885,7 +11853,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
                 result.data.fn_arg.arg_index = i;
                 result.data.fn_arg.actual_param_type = actual_param_info->type;
                 result.data.fn_arg.expected_param_type = expected_param_info->type;
-                result.data.fn_arg.child = allocate_nonzero<ConstCastOnly>(1);
+                result.data.fn_arg.child = heap::c_allocator.allocate_nonzero<ConstCastOnly>(1);
                 *result.data.fn_arg.child = arg_child;
                 return result;
             }
 @@ -11906,14 +11874,14 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
     if (wanted_type->id == ZigTypeIdInt && actual_type->id == ZigTypeIdInt) {
         result.id = ConstCastResultIdIntShorten;
-        result.data.int_shorten = allocate_nonzero<ConstCastIntShorten>(1);
+        result.data.int_shorten = heap::c_allocator.allocate_nonzero<ConstCastIntShorten>(1);
         result.data.int_shorten->wanted_type = wanted_type;
         result.data.int_shorten->actual_type = actual_type;
         return result;
     }
     result.id = ConstCastResultIdType;
-    result.data.type_mismatch = allocate_nonzero<ConstCastTypeMismatch>(1);
+    result.data.type_mismatch = heap::c_allocator.allocate_nonzero<ConstCastTypeMismatch>(1);
     result.data.type_mismatch->wanted_type = wanted_type;
     result.data.type_mismatch->actual_type = actual_type;
     return result;
 @@ -11922,7 +11890,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
 static void update_errors_helper(CodeGen *g, ErrorTableEntry ***errors, size_t *errors_count) {
     size_t old_errors_count = *errors_count;
     *errors_count = g->errors_by_index.length;
-    *errors = reallocate(*errors, old_errors_count, *errors_count);
+    *errors = heap::c_allocator.reallocate(*errors, old_errors_count, *errors_count);
 }
 static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigType *expected_type,
 @@ -12592,7 +12560,7 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
         return ira->codegen->builtin_types.entry_invalid;
     }
-    free(errors);
+    heap::c_allocator.deallocate(errors, errors_count);
     if (convert_to_const_slice) {
         if (prev_inst->value->type->id == ZigTypeIdPointer) {
 @@ -12671,7 +12639,7 @@ static bool eval_const_expr_implicit_cast(IrAnalyze *ira, IrInst *source_instr,
         case CastOpBitCast:
             zig_panic("TODO");
         case CastOpNoop: {
-            copy_const_val(const_val, other_val);
+            copy_const_val(ira->codegen, const_val, other_val);
             const_val->type = new_type;
             break;
         }
 @@ -13200,7 +13168,7 @@ Error ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
     if (type_is_invalid(return_ptr->type))
         return ErrorSemanticAnalyzeFail;
-    IrExecutableSrc *ir_executable = allocate<IrExecutableSrc>(1, "IrExecutableSrc");
+    IrExecutableSrc *ir_executable = heap::c_allocator.create<IrExecutableSrc>();
     ir_executable->source_node = source_node;
     ir_executable->parent_exec = parent_exec;
     ir_executable->name = exec_name;
 @@ -13224,7 +13192,7 @@ Error ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
         ir_print_src(codegen, stderr, ir_executable, 2);
         fprintf(stderr, "}\n");
     }
-    IrExecutableGen *analyzed_executable = allocate<IrExecutableGen>(1, "IrExecutableGen");
+    IrExecutableGen *analyzed_executable = heap::c_allocator.create<IrExecutableGen>();
     analyzed_executable->source_node = source_node;
     analyzed_executable->parent_exec = parent_exec;
     analyzed_executable->source_exec = ir_executable;
 @@ -13425,7 +13393,7 @@ static IrInstGen *ir_analyze_optional_wrap(IrAnalyze *ira, IrInst* source_instr,
                 source_instr->scope, source_instr->source_node);
         const_instruction->base.value->special = ConstValSpecialStatic;
         if (types_have_same_zig_comptime_repr(ira->codegen, wanted_type, payload_type)) {
-            copy_const_val(const_instruction->base.value, val);
+            copy_const_val(ira->codegen, const_instruction->base.value, val);
         } else {
             const_instruction->base.value->data.x_optional = val;
         }
 @@ -13466,7 +13434,7 @@ static IrInstGen *ir_analyze_err_wrap_payload(IrAnalyze *ira, IrInst* source_ins
         if (val == nullptr)
             return ira->codegen->invalid_inst_gen;
-        ZigValue *err_set_val = create_const_vals(1);
+        ZigValue *err_set_val = ira->codegen->pass1_arena->create<ZigValue>();
         err_set_val->type = err_set_type;
         err_set_val->special = ConstValSpecialStatic;
         err_set_val->data.x_err_set = nullptr;
 @@ -13578,7 +13546,7 @@ static IrInstGen *ir_analyze_err_wrap_code(IrAnalyze *ira, IrInst* source_instr,
         if (!val)
             return ira->codegen->invalid_inst_gen;
-        ZigValue *err_set_val = create_const_vals(1);
+        ZigValue *err_set_val = ira->codegen->pass1_arena->create<ZigValue>();
         err_set_val->special = ConstValSpecialStatic;
         err_set_val->type = wanted_type->data.error_union.err_set_type;
         err_set_val->data.x_err_set = val->data.x_err_set;
 @@ -13843,7 +13811,7 @@ static IrInstGen *ir_analyze_enum_to_union(IrAnalyze *ira, IrInst* source_instr,
         result->value->special = ConstValSpecialStatic;
         result->value->type = wanted_type;
         bigint_init_bigint(&result->value->data.x_union.tag, &val->data.x_enum_tag);
-        result->value->data.x_union.payload = create_const_vals(1);
+        result->value->data.x_union.payload = ira->codegen->pass1_arena->create<ZigValue>();
         result->value->data.x_union.payload->special = ConstValSpecialStatic;
         result->value->data.x_union.payload->type = field_type;
         return result;
 @@ -14148,7 +14116,7 @@ static IrInstGen *ir_analyze_ptr_to_array(IrAnalyze *ira, IrInst* source_instr,
         if (pointee == nullptr)
             return ira->codegen->invalid_inst_gen;
         if (pointee->special != ConstValSpecialRuntime) {
-            ZigValue *array_val = create_const_vals(1);
+            ZigValue *array_val = ira->codegen->pass1_arena->create<ZigValue>();
             array_val->special = ConstValSpecialStatic;
             array_val->type = array_type;
             array_val->data.x_array.special = ConstArraySpecialNone;
 @@ -14362,7 +14330,7 @@ static IrInstGen *ir_analyze_array_to_vector(IrAnalyze *ira, IrInst* source_inst
     if (instr_is_comptime(array)) {
         // arrays and vectors have the same ZigValue representation
         IrInstGen *result = ir_const(ira, source_instr, vector_type);
-        copy_const_val(result->value, array->value);
+        copy_const_val(ira->codegen, result->value, array->value);
         result->value->type = vector_type;
         return result;
     }
 @@ -14375,7 +14343,7 @@ static IrInstGen *ir_analyze_vector_to_array(IrAnalyze *ira, IrInst* source_inst
     if (instr_is_comptime(vector)) {
         // arrays and vectors have the same ZigValue representation
         IrInstGen *result = ir_const(ira, source_instr, array_type);
-        copy_const_val(result->value, vector->value);
+        copy_const_val(ira->codegen, result->value, vector->value);
         result->value->type = array_type;
         return result;
     }
 @@ -14675,7 +14643,7 @@ static IrInstGen *ir_analyze_cast(IrAnalyze *ira, IrInst *source_instr,
             if (wanted_type->id == ZigTypeIdComptimeInt || wanted_type->id == ZigTypeIdInt) {
                 IrInstGen *result = ir_const(ira, source_instr, wanted_type);
                 if (actual_type->id == ZigTypeIdComptimeInt || actual_type->id == ZigTypeIdInt) {
-                    copy_const_val(result->value, value->value);
+                    copy_const_val(ira->codegen, result->value, value->value);
                     result->value->type = wanted_type;
                 } else {
                     float_init_bigint(&result->value->data.x_bigint, value->value);
 @@ -16508,7 +16476,7 @@ static IrInstGen *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstSrcBinOp *bin_op_i
         IrInstGen *result = ir_const(ira, &bin_op_instruction->base.base,
             get_vector_type(ira->codegen, resolved_type->data.vector.len, ira->codegen->builtin_types.entry_bool));
         result->value->data.x_array.data.s_none.elements =
-            create_const_vals(resolved_type->data.vector.len);
+            ira->codegen->pass1_arena->allocate<ZigValue>(resolved_type->data.vector.len);
         expand_undef_array(ira->codegen, result->value);
         for (size_t i = 0;i < resolved_type->data.vector.len;i++) {
 @@ -16516,7 +16484,7 @@ static IrInstGen *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstSrcBinOp *bin_op_i
                 &op1_val->data.x_array.data.s_none.elements[i],
                 &op2_val->data.x_array.data.s_none.elements[i],
                 bin_op_instruction, op_id, one_possible_value);
-            copy_const_val(&result->value->data.x_array.data.s_none.elements[i], cur_res->value);
+            copy_const_val(ira->codegen, &result->value->data.x_array.data.s_none.elements[i], cur_res->value);
         }
         return result;
     }
 @@ -17416,7 +17384,7 @@ static IrInstGen *ir_analyze_array_cat(IrAnalyze *ira, IrInstSrcBinOp *instructi
     ZigValue *out_array_val;
     size_t new_len = (op1_array_end - op1_array_index) + (op2_array_end - op2_array_index);
     if (op1_type->id == ZigTypeIdPointer || op2_type->id == ZigTypeIdPointer) {
-        out_array_val = create_const_vals(1);
+        out_array_val = ira->codegen->pass1_arena->create<ZigValue>();
         out_array_val->special = ConstValSpecialStatic;
         out_array_val->type = get_array_type(ira->codegen, child_type, new_len, sentinel);
 @@ -17428,11 +17396,11 @@ static IrInstGen *ir_analyze_array_cat(IrAnalyze *ira, IrInstSrcBinOp *instructi
                 true, false, PtrLenUnknown, 0, 0, 0, false,
                 VECTOR_INDEX_NONE, nullptr, sentinel);
         result->value->type = get_slice_type(ira->codegen, ptr_type);
-        out_array_val = create_const_vals(1);
+        out_array_val = ira->codegen->pass1_arena->create<ZigValue>();
         out_array_val->special = ConstValSpecialStatic;
         out_array_val->type = get_array_type(ira->codegen, child_type, new_len, sentinel);
-        out_val->data.x_struct.fields = alloc_const_vals_ptrs(2);
+        out_val->data.x_struct.fields = alloc_const_vals_ptrs(ira->codegen, 2);
         out_val->data.x_struct.fields[slice_ptr_index]->type = ptr_type;
         out_val->data.x_struct.fields[slice_ptr_index]->special = ConstValSpecialStatic;
 @@ -17449,7 +17417,7 @@ static IrInstGen *ir_analyze_array_cat(IrAnalyze *ira, IrInstSrcBinOp *instructi
     } else {
         result->value->type = get_pointer_to_type_extra2(ira->codegen, child_type, true, false, PtrLenUnknown,
                 0, 0, 0, false, VECTOR_INDEX_NONE, nullptr, sentinel);
-        out_array_val = create_const_vals(1);
+        out_array_val = ira->codegen->pass1_arena->create<ZigValue>();
         out_array_val->special = ConstValSpecialStatic;
         out_array_val->type = get_array_type(ira->codegen, child_type, new_len, sentinel);
         out_val->data.x_ptr.special = ConstPtrSpecialBaseArray;
 @@ -17465,7 +17433,7 @@ static IrInstGen *ir_analyze_array_cat(IrAnalyze *ira, IrInstSrcBinOp *instructi
     }
     uint64_t full_len = new_len + ((sentinel != nullptr) ? 1 : 0);
-    out_array_val->data.x_array.data.s_none.elements = create_const_vals(full_len);
+    out_array_val->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(full_len);
     // TODO handle the buf case here for an optimization
     expand_undef_array(ira->codegen, op1_array_val);
     expand_undef_array(ira->codegen, op2_array_val);
 @@ -17473,21 +17441,21 @@ static IrInstGen *ir_analyze_array_cat(IrAnalyze *ira, IrInstSrcBinOp *instructi
     size_t next_index = 0;
     for (size_t i = op1_array_index; i < op1_array_end; i += 1, next_index += 1) {
         ZigValue *elem_dest_val = &out_array_val->data.x_array.data.s_none.elements[next_index];
-        copy_const_val(elem_dest_val, &op1_array_val->data.x_array.data.s_none.elements[i]);
+        copy_const_val(ira->codegen, elem_dest_val, &op1_array_val->data.x_array.data.s_none.elements[i]);
         elem_dest_val->parent.id = ConstParentIdArray;
         elem_dest_val->parent.data.p_array.array_val = out_array_val;
         elem_dest_val->parent.data.p_array.elem_index = next_index;
     }
     for (size_t i = op2_array_index; i < op2_array_end; i += 1, next_index += 1) {
         ZigValue *elem_dest_val = &out_array_val->data.x_array.data.s_none.elements[next_index];
-        copy_const_val(elem_dest_val, &op2_array_val->data.x_array.data.s_none.elements[i]);
+        copy_const_val(ira->codegen, elem_dest_val, &op2_array_val->data.x_array.data.s_none.elements[i]);
         elem_dest_val->parent.id = ConstParentIdArray;
         elem_dest_val->parent.data.p_array.array_val = out_array_val;
         elem_dest_val->parent.data.p_array.elem_index = next_index;
     }
     if (next_index < full_len) {
         ZigValue *elem_dest_val = &out_array_val->data.x_array.data.s_none.elements[next_index];
-        copy_const_val(elem_dest_val, sentinel);
+        copy_const_val(ira->codegen, elem_dest_val, sentinel);
         elem_dest_val->parent.id = ConstParentIdArray;
         elem_dest_val->parent.data.p_array.array_val = out_array_val;
         elem_dest_val->parent.data.p_array.elem_index = next_index;
 @@ -17566,13 +17534,13 @@ static IrInstGen *ir_analyze_array_mult(IrAnalyze *ira, IrInstSrcBinOp *instruct
         // TODO optimize the buf case
         expand_undef_array(ira->codegen, array_val);
         size_t extra_null_term = (array_type->data.array.sentinel != nullptr) ? 1 : 0;
-        out_val->data.x_array.data.s_none.elements = create_const_vals(new_array_len + extra_null_term);
+        out_val->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(new_array_len + extra_null_term);
         uint64_t i = 0;
         for (uint64_t x = 0; x < mult_amt; x += 1) {
             for (uint64_t y = 0; y < old_array_len; y += 1) {
                 ZigValue *elem_dest_val = &out_val->data.x_array.data.s_none.elements[i];
-                copy_const_val(elem_dest_val, &array_val->data.x_array.data.s_none.elements[y]);
+                copy_const_val(ira->codegen, elem_dest_val, &array_val->data.x_array.data.s_none.elements[y]);
                 elem_dest_val->parent.id = ConstParentIdArray;
                 elem_dest_val->parent.data.p_array.array_val = out_val;
                 elem_dest_val->parent.data.p_array.elem_index = i;
 @@ -17583,7 +17551,7 @@ static IrInstGen *ir_analyze_array_mult(IrAnalyze *ira, IrInstSrcBinOp *instruct
         if (array_type->data.array.sentinel != nullptr) {
             ZigValue *elem_dest_val = &out_val->data.x_array.data.s_none.elements[i];
-            copy_const_val(elem_dest_val, array_type->data.array.sentinel);
+            copy_const_val(ira->codegen, elem_dest_val, array_type->data.array.sentinel);
             elem_dest_val->parent.id = ConstParentIdArray;
             elem_dest_val->parent.data.p_array.array_val = out_val;
             elem_dest_val->parent.data.p_array.elem_index = i;
 @@ -17624,14 +17592,14 @@ static IrInstGen *ir_analyze_instruction_merge_err_sets(IrAnalyze *ira,
     }
     size_t errors_count = ira->codegen->errors_by_index.length;
-    ErrorTableEntry **errors = allocate<ErrorTableEntry *>(errors_count, "ErrorTableEntry *");
+    ErrorTableEntry **errors = heap::c_allocator.allocate<ErrorTableEntry *>(errors_count);
     for (uint32_t i = 0, count = op1_type->data.error_set.err_count; i < count; i += 1) {
         ErrorTableEntry *error_entry = op1_type->data.error_set.errors[i];
         assert(errors[error_entry->value] == nullptr);
         errors[error_entry->value] = error_entry;
     }
     ZigType *result_type = get_error_set_union(ira->codegen, errors, op1_type, op2_type, instruction->type_name);
-    deallocate(errors, errors_count, "ErrorTableEntry *");
+    heap::c_allocator.deallocate(errors, errors_count);
     return ir_const_type(ira, &instruction->base.base, result_type);
 }
 @@ -17730,8 +17698,8 @@ static IrInstGen *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstSrcDeclV
             if (var->gen_is_const) {
                 var->const_value = init_val;
             } else {
-                var->const_value = create_const_vals(1);
+                var->const_value = ira->codegen->pass1_arena->create<ZigValue>();
-                copy_const_val(var->const_value, init_val);
+                copy_const_val(ira->codegen, var->const_value, init_val);
             }
         }
     }
 @@ -17905,7 +17873,7 @@ static IrInstGen *ir_analyze_instruction_export(IrAnalyze *ira, IrInstSrcExport
     // It's not clear how all the different types are supposed to be handled.
     // Need comprehensive tests for exporting one thing in one file and declaring an extern var
     // in another file.
-    TldFn *tld_fn = allocate<TldFn>(1);
+    TldFn *tld_fn = heap::c_allocator.create<TldFn>();
     tld_fn->base.id = TldIdFn;
     tld_fn->base.source_node = instruction->base.base.source_node;
 @@ -18134,7 +18102,7 @@ static IrInstGen *ir_analyze_instruction_error_union(IrAnalyze *ira, IrInstSrcEr
     IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_type);
     result->value->special = ConstValSpecialLazy;
-    LazyValueErrUnionType *lazy_err_union_type = allocate<LazyValueErrUnionType>(1, "LazyValueErrUnionType");
+    LazyValueErrUnionType *lazy_err_union_type = heap::c_allocator.create<LazyValueErrUnionType>();
     lazy_err_union_type->ira = ira; ira_ref(ira);
     result->value->data.x_lazy = &lazy_err_union_type->base;
     lazy_err_union_type->base.id = LazyValueIdErrUnionType;
 @@ -18155,7 +18123,7 @@ static IrInstGen *ir_analyze_alloca(IrAnalyze *ira, IrInst *source_inst, ZigType
 {
     Error err;
-    ZigValue *pointee = create_const_vals(1);
+    ZigValue *pointee = ira->codegen->pass1_arena->create<ZigValue>();
     pointee->special = ConstValSpecialUndef;
     pointee->llvm_align = align;
 @@ -18236,8 +18204,8 @@ static bool type_can_bit_cast(ZigType *t) {
     }
 }
-static void set_up_result_loc_for_inferred_comptime(IrInstGen *ptr) {
+static void set_up_result_loc_for_inferred_comptime(IrAnalyze *ira, IrInstGen *ptr) {
-    ZigValue *undef_child = create_const_vals(1);
+    ZigValue *undef_child = ira->codegen->pass1_arena->create<ZigValue>();
     undef_child->type = ptr->value->type->data.pointer.child_type;
     undef_child->special = ConstValSpecialUndef;
     ptr->value->special = ConstValSpecialStatic;
 @@ -18283,7 +18251,7 @@ static IrInstGen *ir_resolve_no_result_loc(IrAnalyze *ira, IrInst *suspend_sourc
     IrInstGenAlloca *alloca_gen = ir_build_alloca_gen(ira, suspend_source_instr, 0, "");
     alloca_gen->base.value->type = get_pointer_to_type_extra(ira->codegen, value_type, false, false,
             PtrLenSingle, 0, 0, 0, false);
-    set_up_result_loc_for_inferred_comptime(&alloca_gen->base);
+    set_up_result_loc_for_inferred_comptime(ira, &alloca_gen->base);
     ZigFn *fn_entry = ira->new_irb.exec->fn_entry;
     if (fn_entry != nullptr && get_scope_typeof(suspend_source_instr->scope) == nullptr) {
         fn_entry->alloca_gen_list.append(alloca_gen);
 @@ -18347,7 +18315,6 @@ static IrInstGen *ir_resolve_result_raw(IrAnalyze *ira, IrInst *suspend_source_i
                 ZigVar *new_var = create_local_var(ira->codegen, var->decl_node, var->child_scope,
                     buf_create_from_str(var->name), var->src_is_const, var->gen_is_const,
                     var->shadowable, var->is_comptime, true);
-                new_var->owner_exec = var->owner_exec;
                 new_var->align_bytes = var->align_bytes;
                 var->next_var = new_var;
 @@ -18686,15 +18653,15 @@ static IrInstGen *ir_resolve_result(IrAnalyze *ira, IrInst *suspend_source_instr
                 if (!val)
                     return ira->codegen->invalid_inst_gen;
                 field->is_comptime = true;
-                field->init_val = create_const_vals(1);
+                field->init_val = ira->codegen->pass1_arena->create<ZigValue>();
-                copy_const_val(field->init_val, val);
+                copy_const_val(ira->codegen, field->init_val, val);
                 return result_loc;
             }
             ZigType *struct_ptr_type = get_pointer_to_type(ira->codegen, isf->inferred_struct_type, false);
             if (instr_is_comptime(result_loc)) {
                 casted_ptr = ir_const(ira, suspend_source_instr, struct_ptr_type);
-                copy_const_val(casted_ptr->value, result_loc->value);
+                copy_const_val(ira->codegen, casted_ptr->value, result_loc->value);
                 casted_ptr->value->type = struct_ptr_type;
             } else {
                 casted_ptr = result_loc;
 @@ -18707,8 +18674,8 @@ static IrInstGen *ir_resolve_result(IrAnalyze *ira, IrInst *suspend_source_instr
                     ZigValue *struct_val = const_ptr_pointee(ira, ira->codegen, ptr_val,
                             suspend_source_instr->source_node);
                     struct_val->special = ConstValSpecialStatic;
-                    struct_val->data.x_struct.fields = realloc_const_vals_ptrs(struct_val->data.x_struct.fields,
+                    struct_val->data.x_struct.fields = realloc_const_vals_ptrs(ira->codegen,
-                            old_field_count, new_field_count);
+                            struct_val->data.x_struct.fields, old_field_count, new_field_count);
                     ZigValue *field_val = struct_val->data.x_struct.fields[old_field_count];
                     field_val->special = ConstValSpecialUndef;
 @@ -19008,10 +18975,10 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
         if (!arg_val)
             return false;
     } else {
-        arg_val = create_const_runtime(casted_arg->value->type);
+        arg_val = create_const_runtime(ira->codegen, casted_arg->value->type);
     }
     if (arg_part_of_generic_id) {
-        copy_const_val(&generic_id->params[generic_id->param_count], arg_val);
+        copy_const_val(ira->codegen, &generic_id->params[generic_id->param_count], arg_val);
         generic_id->param_count += 1;
     }
 @@ -19160,7 +19127,7 @@ static IrInstGen *ir_analyze_store_ptr(IrAnalyze *ira, IrInst* source_instr,
                 if (dest_val == nullptr)
                     return ira->codegen->invalid_inst_gen;
                 if (dest_val->special != ConstValSpecialRuntime) {
-                    copy_const_val(dest_val, value->value);
+                    copy_const_val(ira->codegen, dest_val, value->value);
                     if (ptr->value->data.x_ptr.mut == ConstPtrMutComptimeVar &&
                         !ira->new_irb.current_basic_block->must_be_comptime_source_instr)
 @@ -19395,8 +19362,6 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
             {
                 return ira->codegen->invalid_inst_gen;
             }
-            destroy(result_ptr, "ZigValue");
-            result_ptr = nullptr;
             if (inferred_err_set_type != nullptr) {
                 inferred_err_set_type->data.error_set.incomplete = false;
 @@ -19404,7 +19369,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
                     ErrorTableEntry *err = result->data.x_err_union.error_set->data.x_err_set;
                     if (err != nullptr) {
                         inferred_err_set_type->data.error_set.err_count = 1;
-                        inferred_err_set_type->data.error_set.errors = allocate<ErrorTableEntry *>(1);
+                        inferred_err_set_type->data.error_set.errors = heap::c_allocator.create<ErrorTableEntry *>();
                         inferred_err_set_type->data.error_set.errors[0] = err;
                     }
                     ZigType *fn_inferred_err_set_type = result->type->data.error_union.err_set_type;
 @@ -19438,12 +19403,12 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
         size_t new_fn_arg_count = first_arg_1_or_0 + args_len;
-        IrInstGen **casted_args = allocate<IrInstGen *>(new_fn_arg_count);
+        IrInstGen **casted_args = heap::c_allocator.allocate<IrInstGen *>(new_fn_arg_count);
         // Fork a scope of the function with known values for the parameters.
         Scope *parent_scope = fn_entry->fndef_scope->base.parent;
         ZigFn *impl_fn = create_fn(ira->codegen, fn_proto_node);
-        impl_fn->param_source_nodes = allocate<AstNode *>(new_fn_arg_count);
+        impl_fn->param_source_nodes = heap::c_allocator.allocate<AstNode *>(new_fn_arg_count);
         buf_init_from_buf(&impl_fn->symbol_name, &fn_entry->symbol_name);
         impl_fn->fndef_scope = create_fndef_scope(ira->codegen, impl_fn->body_node, parent_scope, impl_fn);
         impl_fn->child_scope = &impl_fn->fndef_scope->base;
 @@ -19454,10 +19419,10 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
         // TODO maybe GenericFnTypeId can be replaced with using the child_scope directly
         // as the key in generic_table
-        GenericFnTypeId *generic_id = allocate<GenericFnTypeId>(1);
+        GenericFnTypeId *generic_id = heap::c_allocator.create<GenericFnTypeId>();
         generic_id->fn_entry = fn_entry;
         generic_id->param_count = 0;
-        generic_id->params = create_const_vals(new_fn_arg_count);
+        generic_id->params = ira->codegen->pass1_arena->allocate<ZigValue>(new_fn_arg_count);
         size_t next_proto_i = 0;
         if (first_arg_ptr) {
 @@ -19517,7 +19482,6 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
             IrInstGenConst *const_instruction = ir_create_inst_noval<IrInstGenConst>(&ira->new_irb,
                     impl_fn->child_scope, fn_proto_node->data.fn_proto.align_expr);
             const_instruction->base.value = align_result;
-            destroy(result_ptr, "ZigValue");
             uint32_t align_bytes = 0;
             ir_resolve_align(ira, &const_instruction->base, nullptr, &align_bytes);
 @@ -19650,7 +19614,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
     }
-    IrInstGen **casted_args = allocate<IrInstGen *>(call_param_count);
+    IrInstGen **casted_args = heap::c_allocator.allocate<IrInstGen *>(call_param_count);
     size_t next_arg_index = 0;
     if (first_arg_ptr) {
         assert(first_arg_ptr->value->type->id == ZigTypeIdPointer);
 @@ -19782,7 +19746,7 @@ static IrInstGen *ir_analyze_fn_call_src(IrAnalyze *ira, IrInstSrcCall *call_ins
             return ira->codegen->invalid_inst_gen;
         new_stack_src = &call_instruction->new_stack->base;
     }
-    IrInstGen **args_ptr = allocate<IrInstGen *>(call_instruction->arg_count, "IrInstGen *");
+    IrInstGen **args_ptr = heap::c_allocator.allocate<IrInstGen *>(call_instruction->arg_count);
     for (size_t i = 0; i < call_instruction->arg_count; i += 1) {
         args_ptr[i] = call_instruction->args[i]->child;
         if (type_is_invalid(args_ptr[i]->value->type))
 @@ -19798,7 +19762,7 @@ static IrInstGen *ir_analyze_fn_call_src(IrAnalyze *ira, IrInstSrcCall *call_ins
             first_arg_ptr, first_arg_ptr_src, modifier, new_stack, new_stack_src,
             call_instruction->is_async_call_builtin, args_ptr, call_instruction->arg_count, ret_ptr,
             call_instruction->result_loc);
-    deallocate(args_ptr, call_instruction->arg_count, "IrInstGen *");
+    heap::c_allocator.deallocate(args_ptr, call_instruction->arg_count);
     return result;
 }
 @@ -19918,7 +19882,7 @@ static IrInstGen *ir_analyze_instruction_call_extra(IrAnalyze *ira, IrInstSrcCal
     if (is_tuple(args_type)) {
         args_len = args_type->data.structure.src_field_count;
-        args_ptr = allocate<IrInstGen *>(args_len, "IrInstGen *");
+        args_ptr = heap::c_allocator.allocate<IrInstGen *>(args_len);
         for (size_t i = 0; i < args_len; i += 1) {
             TypeStructField *arg_field = args_type->data.structure.fields[i];
             args_ptr[i] = ir_analyze_struct_value_field_value(ira, &instruction->base.base, args, arg_field);
 @@ -19931,12 +19895,12 @@ static IrInstGen *ir_analyze_instruction_call_extra(IrAnalyze *ira, IrInstSrcCal
     }
     IrInstGen *result = ir_analyze_call_extra(ira, &instruction->base.base, instruction->options,
             instruction->fn_ref, args_ptr, args_len, instruction->result_loc);
-    deallocate(args_ptr, args_len, "IrInstGen *");
+    heap::c_allocator.deallocate(args_ptr, args_len);
     return result;
 }
 static IrInstGen *ir_analyze_instruction_call_args(IrAnalyze *ira, IrInstSrcCallArgs *instruction) {
-    IrInstGen **args_ptr = allocate<IrInstGen *>(instruction->args_len, "IrInstGen *");
+    IrInstGen **args_ptr = heap::c_allocator.allocate<IrInstGen *>(instruction->args_len);
     for (size_t i = 0; i < instruction->args_len; i += 1) {
         args_ptr[i] = instruction->args_ptr[i]->child;
         if (type_is_invalid(args_ptr[i]->value->type))
 @@ -19945,7 +19909,7 @@ static IrInstGen *ir_analyze_instruction_call_args(IrAnalyze *ira, IrInstSrcCall
     IrInstGen *result = ir_analyze_call_extra(ira, &instruction->base.base, instruction->options,
             instruction->fn_ref, args_ptr, instruction->args_len, instruction->result_loc);
-    deallocate(args_ptr, instruction->args_len, "IrInstGen *");
+    heap::c_allocator.deallocate(args_ptr, instruction->args_len);
     return result;
 }
 @@ -20020,7 +19984,7 @@ static Error ir_read_const_ptr(IrAnalyze *ira, CodeGen *codegen, AstNode *source
     if (dst_size <= src_size) {
         if (src_size == dst_size && types_have_same_zig_comptime_repr(codegen, out_val->type, pointee->type)) {
-            copy_const_val(out_val, pointee);
+            copy_const_val(codegen, out_val, pointee);
             return ErrorNone;
         }
         Buf buf = BUF_INIT;
 @@ -20088,7 +20052,7 @@ static IrInstGen *ir_analyze_optional_type(IrAnalyze *ira, IrInstSrcUnOp *instru
     IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_type);
     result->value->special = ConstValSpecialLazy;
-    LazyValueOptType *lazy_opt_type = allocate<LazyValueOptType>(1, "LazyValueOptType");
+    LazyValueOptType *lazy_opt_type = heap::c_allocator.create<LazyValueOptType>();
     lazy_opt_type->ira = ira; ira_ref(ira);
     result->value->data.x_lazy = &lazy_opt_type->base;
     lazy_opt_type->base.id = LazyValueIdOptType;
 @@ -20372,7 +20336,7 @@ static IrInstGen *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstSrcPhi *phi_i
             if (value->value->special != ConstValSpecialRuntime) {
                 IrInstGen *result = ir_const(ira, &phi_instruction->base.base, nullptr);
-                copy_const_val(result->value, value->value);
+                copy_const_val(ira->codegen, result->value, value->value);
                 return result;
             } else {
                 return value;
 @@ -20386,7 +20350,7 @@ static IrInstGen *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstSrcPhi *phi_i
         peer_parent->peers.length >= 2)
     {
         if (peer_parent->resolved_type == nullptr) {
-            IrInstGen **instructions = allocate<IrInstGen *>(peer_parent->peers.length);
+            IrInstGen **instructions = heap::c_allocator.allocate<IrInstGen *>(peer_parent->peers.length);
             for (size_t i = 0; i < peer_parent->peers.length; i += 1) {
                 ResultLocPeer *this_peer = peer_parent->peers.at(i);
 @@ -20759,7 +20723,7 @@ static IrInstGen *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstSrcElemP
             if (index == array_len && array_type->data.array.sentinel != nullptr) {
                 ZigType *elem_type = array_type->data.array.child_type;
                 IrInstGen *sentinel_elem = ir_const(ira, &elem_ptr_instruction->base.base, elem_type);
-                copy_const_val(sentinel_elem->value, array_type->data.array.sentinel);
+                copy_const_val(ira->codegen, sentinel_elem->value, array_type->data.array.sentinel);
                 return ir_get_ref(ira, &elem_ptr_instruction->base.base, sentinel_elem, true, false);
             }
             if (index >= array_len) {
 @@ -20823,7 +20787,7 @@ static IrInstGen *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstSrcElemP
             {
                 if (array_type->id == ZigTypeIdArray || array_type->id == ZigTypeIdVector) {
                     array_ptr_val->data.x_array.special = ConstArraySpecialNone;
-                    array_ptr_val->data.x_array.data.s_none.elements = create_const_vals(array_type->data.array.len);
+                    array_ptr_val->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(array_type->data.array.len);
                     array_ptr_val->special = ConstValSpecialStatic;
                     for (size_t i = 0; i < array_type->data.array.len; i += 1) {
                         ZigValue *elem_val = &array_ptr_val->data.x_array.data.s_none.elements[i];
 @@ -20846,11 +20810,11 @@ static IrInstGen *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstSrcElemP
                         return ira->codegen->invalid_inst_gen;
                     }
-                    ZigValue *array_init_val = create_const_vals(1);
+                    ZigValue *array_init_val = ira->codegen->pass1_arena->create<ZigValue>();
                     array_init_val->special = ConstValSpecialStatic;
                     array_init_val->type = actual_array_type;
                     array_init_val->data.x_array.special = ConstArraySpecialNone;
-                    array_init_val->data.x_array.data.s_none.elements = create_const_vals(actual_array_type->data.array.len);
+                    array_init_val->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(actual_array_type->data.array.len);
                     array_init_val->special = ConstValSpecialStatic;
                     for (size_t i = 0; i < actual_array_type->data.array.len; i += 1) {
                         ZigValue *elem_val = &array_init_val->data.x_array.data.s_none.elements[i];
 @@ -21176,7 +21140,7 @@ static IrInstGen *ir_analyze_struct_field_ptr(IrAnalyze *ira, IrInst* source_ins
     if (field->is_comptime) {
         IrInstGen *elem = ir_const(ira, source_instr, field_type);
         memoize_field_init_val(ira->codegen, struct_type, field);
-        copy_const_val(elem->value, field->init_val);
+        copy_const_val(ira->codegen, elem->value, field->init_val);
         return ir_get_ref2(ira, source_instr, elem, field_type, true, false);
     }
     switch (type_has_one_possible_value(ira->codegen, field_type)) {
 @@ -21224,7 +21188,7 @@ static IrInstGen *ir_analyze_struct_field_ptr(IrAnalyze *ira, IrInst* source_ins
             if (type_is_invalid(struct_val->type))
                 return ira->codegen->invalid_inst_gen;
             if (initializing && struct_val->special == ConstValSpecialUndef) {
-                struct_val->data.x_struct.fields = alloc_const_vals_ptrs(struct_type->data.structure.src_field_count);
+                struct_val->data.x_struct.fields = alloc_const_vals_ptrs(ira->codegen, struct_type->data.structure.src_field_count);
                 struct_val->special = ConstValSpecialStatic;
                 for (size_t i = 0; i < struct_type->data.structure.src_field_count; i += 1) {
                     ZigValue *field_val = struct_val->data.x_struct.fields[i];
 @@ -21266,7 +21230,7 @@ static IrInstGen *ir_analyze_inferred_field_ptr(IrAnalyze *ira, Buf *field_name,
     ZigType *container_ptr_type = container_ptr->value->type;
     ir_assert(container_ptr_type->id == ZigTypeIdPointer, source_instr);
-    InferredStructField *inferred_struct_field = allocate<InferredStructField>(1, "InferredStructField");
+    InferredStructField *inferred_struct_field = heap::c_allocator.create<InferredStructField>();
     inferred_struct_field->inferred_struct_type = container_type;
     inferred_struct_field->field_name = field_name;
 @@ -21286,7 +21250,7 @@ static IrInstGen *ir_analyze_inferred_field_ptr(IrAnalyze *ira, Buf *field_name,
         } else {
             result = ir_const(ira, source_instr, field_ptr_type);
         }
-        copy_const_val(result->value, ptr_val);
+        copy_const_val(ira->codegen, result->value, ptr_val);
         result->value->type = field_ptr_type;
         return result;
     }
 @@ -21357,7 +21321,7 @@ static IrInstGen *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_name
                     return ira->codegen->invalid_inst_gen;
                 if (initializing) {
-                    ZigValue *payload_val = create_const_vals(1);
+                    ZigValue *payload_val = ira->codegen->pass1_arena->create<ZigValue>();
                     payload_val->special = ConstValSpecialUndef;
                     payload_val->type = field_type;
                     payload_val->parent.id = ConstParentIdUnion;
 @@ -21540,7 +21504,7 @@ static IrInstGen *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstSrcFiel
         }
     } else if (is_array_ref(container_type) && !field_ptr_instruction->initializing) {
         if (buf_eql_str(field_name, "len")) {
-            ZigValue *len_val = create_const_vals(1);
+            ZigValue *len_val = ira->codegen->pass1_arena->create<ZigValue>();
             if (container_type->id == ZigTypeIdPointer) {
                 init_const_usize(ira->codegen, len_val, container_type->data.pointer.child_type->data.array.len);
             } else {
 @@ -21586,7 +21550,7 @@ static IrInstGen *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstSrcFiel
                     bool ptr_is_const = true;
                     bool ptr_is_volatile = false;
                     return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
-                            create_const_enum(child_type, &field->value), child_type,
+                            create_const_enum(ira->codegen, child_type, &field->value), child_type,
                             ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
                 }
             }
 @@ -21615,7 +21579,7 @@ static IrInstGen *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstSrcFiel
                     bool ptr_is_const = true;
                     bool ptr_is_volatile = false;
                     return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
-                            create_const_enum(enum_type, &field->enum_field->value), enum_type,
+                            create_const_enum(ira->codegen, enum_type, &field->enum_field->value), enum_type,
                             ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
                 }
             }
 @@ -21633,7 +21597,7 @@ static IrInstGen *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstSrcFiel
                 if (existing_entry) {
                     err_entry = existing_entry->value;
                 } else {
-                    err_entry = allocate<ErrorTableEntry>(1);
+                    err_entry = heap::c_allocator.create<ErrorTableEntry>();
                     err_entry->decl_node = field_ptr_instruction->base.base.source_node;
                     buf_init_from_buf(&err_entry->name, field_name);
                     size_t error_value_count = ira->codegen->errors_by_index.length;
 @@ -21660,7 +21624,7 @@ static IrInstGen *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstSrcFiel
                 }
                 err_set_type = child_type;
             }
-            ZigValue *const_val = create_const_vals(1);
+            ZigValue *const_val = ira->codegen->pass1_arena->create<ZigValue>();
             const_val->special = ConstValSpecialStatic;
             const_val->type = err_set_type;
             const_val->data.x_err_set = err_entry;
 @@ -21674,7 +21638,7 @@ static IrInstGen *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstSrcFiel
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
                 return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
-                    create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
+                    create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
                         child_type->data.integral.bit_count, false),
                     ira->codegen->builtin_types.entry_num_lit_int,
                     ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
 @@ -21696,7 +21660,7 @@ static IrInstGen *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstSrcFiel
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
                 return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
-                    create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
+                    create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
                         child_type->data.floating.bit_count, false),
                     ira->codegen->builtin_types.entry_num_lit_int,
                     ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
 @@ -21723,7 +21687,7 @@ static IrInstGen *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstSrcFiel
                     return ira->codegen->invalid_inst_gen;
                 }
                 return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
-                    create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
+                    create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
                         get_ptr_align(ira->codegen, child_type), false),
                     ira->codegen->builtin_types.entry_num_lit_int,
                     ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
 @@ -21745,7 +21709,7 @@ static IrInstGen *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstSrcFiel
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
                 return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
-                    create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
+                    create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
                         child_type->data.array.len, false),
                     ira->codegen->builtin_types.entry_num_lit_int,
                     ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
 @@ -22025,7 +21989,7 @@ static IrInstGen *ir_analyze_instruction_slice_type(IrAnalyze *ira, IrInstSrcSli
     IrInstGen *result = ir_const(ira, &slice_type_instruction->base.base, ira->codegen->builtin_types.entry_type);
     result->value->special = ConstValSpecialLazy;
-    LazyValueSliceType *lazy_slice_type = allocate<LazyValueSliceType>(1, "LazyValueSliceType");
+    LazyValueSliceType *lazy_slice_type = heap::c_allocator.create<LazyValueSliceType>();
     lazy_slice_type->ira = ira; ira_ref(ira);
     result->value->data.x_lazy = &lazy_slice_type->base;
     lazy_slice_type->base.id = LazyValueIdSliceType;
 @@ -22098,8 +22062,8 @@ static IrInstGen *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstSrcAsm *asm_i
     // TODO validate the output types and variable types
-    IrInstGen **input_list = allocate<IrInstGen *>(asm_expr->input_list.length);
+    IrInstGen **input_list = heap::c_allocator.allocate<IrInstGen *>(asm_expr->input_list.length);
-    IrInstGen **output_types = allocate<IrInstGen *>(asm_expr->output_list.length);
+    IrInstGen **output_types = heap::c_allocator.allocate<IrInstGen *>(asm_expr->output_list.length);
     ZigType *return_type = ira->codegen->builtin_types.entry_void;
     for (size_t i = 0; i < asm_expr->output_list.length; i += 1) {
 @@ -22138,7 +22102,7 @@ static IrInstGen *ir_analyze_instruction_array_type(IrAnalyze *ira, IrInstSrcArr
     IrInstGen *result = ir_const(ira, &array_type_instruction->base.base, ira->codegen->builtin_types.entry_type);
     result->value->special = ConstValSpecialLazy;
-    LazyValueArrayType *lazy_array_type = allocate<LazyValueArrayType>(1, "LazyValueArrayType");
+    LazyValueArrayType *lazy_array_type = heap::c_allocator.create<LazyValueArrayType>();
     lazy_array_type->ira = ira; ira_ref(ira);
     result->value->data.x_lazy = &lazy_array_type->base;
     lazy_array_type->base.id = LazyValueIdArrayType;
 @@ -22163,7 +22127,7 @@ static IrInstGen *ir_analyze_instruction_size_of(IrAnalyze *ira, IrInstSrcSizeOf
     IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_num_lit_int);
     result->value->special = ConstValSpecialLazy;
-    LazyValueSizeOf *lazy_size_of = allocate<LazyValueSizeOf>(1, "LazyValueSizeOf");
+    LazyValueSizeOf *lazy_size_of = heap::c_allocator.create<LazyValueSizeOf>();
     lazy_size_of->ira = ira; ira_ref(ira);
     result->value->data.x_lazy = &lazy_size_of->base;
     lazy_size_of->base.id = LazyValueIdSizeOf;
 @@ -22283,7 +22247,7 @@ static IrInstGen *ir_analyze_unwrap_optional_payload(IrAnalyze *ira, IrInst* sou
                         return ira->codegen->invalid_inst_gen;
                     case OnePossibleValueNo:
                         if (!same_comptime_repr) {
-                            ZigValue *payload_val = create_const_vals(1);
+                            ZigValue *payload_val = ira->codegen->pass1_arena->create<ZigValue>();
                             payload_val->type = child_type;
                             payload_val->special = ConstValSpecialUndef;
                             payload_val->parent.id = ConstParentIdOptionalPayload;
 @@ -22530,7 +22494,7 @@ static IrInstGen *ir_analyze_instruction_switch_br(IrAnalyze *ira,
         }
     }
-    IrInstGenSwitchBrCase *cases = allocate<IrInstGenSwitchBrCase>(case_count);
+    IrInstGenSwitchBrCase *cases = heap::c_allocator.allocate<IrInstGenSwitchBrCase>(case_count);
     for (size_t i = 0; i < case_count; i += 1) {
         IrInstSrcSwitchBrCase *old_case = &switch_br_instruction->cases[i];
         IrInstGenSwitchBrCase *new_case = &cases[i];
 @@ -22615,7 +22579,7 @@ static IrInstGen *ir_analyze_instruction_switch_target(IrAnalyze *ira,
         case ZigTypeIdErrorSet: {
             if (pointee_val) {
                 IrInstGen *result = ir_const(ira, &switch_target_instruction->base.base, nullptr);
-                copy_const_val(result->value, pointee_val);
+                copy_const_val(ira->codegen, result->value, pointee_val);
                 result->value->type = target_type;
                 return result;
             }
 @@ -22835,7 +22799,7 @@ static IrInstGen *ir_analyze_instruction_switch_else_var(IrAnalyze *ira,
             return target_value_ptr;
         }
         // Make note of the errors handled by other cases
-        ErrorTableEntry **errors = allocate<ErrorTableEntry *>(ira->codegen->errors_by_index.length);
+        ErrorTableEntry **errors = heap::c_allocator.allocate<ErrorTableEntry *>(ira->codegen->errors_by_index.length);
         // We may not have any case in the switch if this is a lone else
         const size_t switch_cases = instruction->switch_br ? instruction->switch_br->case_count : 0;
         for (size_t case_i = 0; case_i < switch_cases; case_i += 1) {
 @@ -22871,7 +22835,7 @@ static IrInstGen *ir_analyze_instruction_switch_else_var(IrAnalyze *ira,
                 buf_appendf(&err_set_type->name, "%s,", buf_ptr(&error_entry->name));
             }
         }
-        free(errors);
+        heap::c_allocator.deallocate(errors, ira->codegen->errors_by_index.length);
         err_set_type->data.error_set.err_count = result_list.length;
         err_set_type->data.error_set.errors = result_list.items;
 @@ -23019,7 +22983,7 @@ static IrInstGen *ir_analyze_container_init_fields(IrAnalyze *ira, IrInst *sourc
     IrInstGen *first_non_const_instruction = nullptr;
-    AstNode **field_assign_nodes = allocate<AstNode *>(actual_field_count);
+    AstNode **field_assign_nodes = heap::c_allocator.allocate<AstNode *>(actual_field_count);
     ZigList<IrInstGen *> const_ptrs = {};
     bool is_comptime = ir_should_inline(ira->old_irb.exec, source_instr->scope)
 @@ -23090,7 +23054,7 @@ static IrInstGen *ir_analyze_container_init_fields(IrAnalyze *ira, IrInst *sourc
             return ira->codegen->invalid_inst_gen;
         IrInstGen *runtime_inst = ir_const(ira, source_instr, field->init_val->type);
-        copy_const_val(runtime_inst->value, field->init_val);
+        copy_const_val(ira->codegen, runtime_inst->value, field->init_val);
         IrInstGen *field_ptr = ir_analyze_struct_field_ptr(ira, source_instr, field, result_loc,
                 container_type, true);
 @@ -23354,7 +23318,7 @@ static IrInstGen *ir_analyze_instruction_err_name(IrAnalyze *ira, IrInstSrcErrNa
             err->cached_error_name_val = create_const_slice(ira->codegen, array_val, 0, buf_len(&err->name), true);
         }
         IrInstGen *result = ir_const(ira, &instruction->base.base, nullptr);
-        copy_const_val(result->value, err->cached_error_name_val);
+        copy_const_val(ira->codegen, result->value, err->cached_error_name_val);
         result->value->type = str_type;
         return result;
     }
 @@ -23680,11 +23644,11 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInst* source_instr, ZigVa
         }
     }
-    ZigValue *declaration_array = create_const_vals(1);
+    ZigValue *declaration_array = ira->codegen->pass1_arena->create<ZigValue>();
     declaration_array->special = ConstValSpecialStatic;
     declaration_array->type = get_array_type(ira->codegen, type_info_declaration_type, declaration_count, nullptr);
     declaration_array->data.x_array.special = ConstArraySpecialNone;
-    declaration_array->data.x_array.data.s_none.elements = create_const_vals(declaration_count);
+    declaration_array->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(declaration_count);
     init_const_slice(ira->codegen, out_val, declaration_array, 0, declaration_count, false);
     // Loop through the declarations and generate info.
 @@ -23706,7 +23670,7 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInst* source_instr, ZigVa
         declaration_val->special = ConstValSpecialStatic;
         declaration_val->type = type_info_declaration_type;
-        ZigValue **inner_fields = alloc_const_vals_ptrs(3);
+        ZigValue **inner_fields = alloc_const_vals_ptrs(ira->codegen, 3);
         ZigValue *name = create_const_str_lit(ira->codegen, curr_entry->key)->data.x_ptr.data.ref.pointee;
         init_const_slice(ira->codegen, inner_fields[0], name, 0, buf_len(curr_entry->key), true);
         inner_fields[1]->special = ConstValSpecialStatic;
 @@ -23737,7 +23701,7 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInst* source_instr, ZigVa
                         // 1: Data.Var: type
                         bigint_init_unsigned(&inner_fields[2]->data.x_union.tag, 1);
-                        ZigValue *payload = create_const_vals(1);
+                        ZigValue *payload = ira->codegen->pass1_arena->create<ZigValue>();
                         payload->special = ConstValSpecialStatic;
                         payload->type = ira->codegen->builtin_types.entry_type;
                         payload->data.x_type = var->const_value->type;
 @@ -23758,13 +23722,13 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInst* source_instr, ZigVa
                     AstNodeFnProto *fn_node = &fn_entry->proto_node->data.fn_proto;
-                    ZigValue *fn_decl_val = create_const_vals(1);
+                    ZigValue *fn_decl_val = ira->codegen->pass1_arena->create<ZigValue>();
                     fn_decl_val->special = ConstValSpecialStatic;
                     fn_decl_val->type = type_info_fn_decl_type;
                     fn_decl_val->parent.id = ConstParentIdUnion;
                     fn_decl_val->parent.data.p_union.union_val = inner_fields[2];
-                    ZigValue **fn_decl_fields = alloc_const_vals_ptrs(9);
+                    ZigValue **fn_decl_fields = alloc_const_vals_ptrs(ira->codegen, 9);
                     fn_decl_val->data.x_struct.fields = fn_decl_fields;
                     // fn_type: type
 @@ -23802,7 +23766,7 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInst* source_instr, ZigVa
                         0, 0, 0, false);
                     fn_decl_fields[5]->type = get_optional_type(ira->codegen, get_slice_type(ira->codegen, u8_ptr));
                     if (fn_node->is_extern && fn_node->lib_name != nullptr && buf_len(fn_node->lib_name) > 0) {
-                        fn_decl_fields[5]->data.x_optional = create_const_vals(1);
+                        fn_decl_fields[5]->data.x_optional = ira->codegen->pass1_arena->create<ZigValue>();
                         ZigValue *lib_name = create_const_str_lit(ira->codegen, fn_node->lib_name)->data.x_ptr.data.ref.pointee;
                         init_const_slice(ira->codegen, fn_decl_fields[5]->data.x_optional, lib_name, 0,
                                 buf_len(fn_node->lib_name), true);
 @@ -23817,12 +23781,12 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInst* source_instr, ZigVa
                     // arg_names: [][] const u8
                     ensure_field_index(fn_decl_val->type, "arg_names", 7);
                     size_t fn_arg_count = fn_entry->variable_list.length;
-                    ZigValue *fn_arg_name_array = create_const_vals(1);
+                    ZigValue *fn_arg_name_array = ira->codegen->pass1_arena->create<ZigValue>();
                     fn_arg_name_array->special = ConstValSpecialStatic;
                     fn_arg_name_array->type = get_array_type(ira->codegen,
                             get_slice_type(ira->codegen, u8_ptr), fn_arg_count, nullptr);
                     fn_arg_name_array->data.x_array.special = ConstArraySpecialNone;
-                    fn_arg_name_array->data.x_array.data.s_none.elements = create_const_vals(fn_arg_count);
+                    fn_arg_name_array->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(fn_arg_count);
                     init_const_slice(ira->codegen, fn_decl_fields[7], fn_arg_name_array, 0, fn_arg_count, false);
 @@ -23849,7 +23813,7 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInst* source_instr, ZigVa
                     // This is a type.
                     bigint_init_unsigned(&inner_fields[2]->data.x_union.tag, 0);
-                    ZigValue *payload = create_const_vals(1);
+                    ZigValue *payload = ira->codegen->pass1_arena->create<ZigValue>();
                     payload->special = ConstValSpecialStatic;
                     payload->type = ira->codegen->builtin_types.entry_type;
                     payload->data.x_type = type_entry;
 @@ -23915,11 +23879,11 @@ static ZigValue *create_ptr_like_type_info(IrAnalyze *ira, ZigType *ptr_type_ent
     ZigType *type_info_pointer_type = ir_type_info_get_type(ira, "Pointer", nullptr);
     assertNoError(type_resolve(ira->codegen, type_info_pointer_type, ResolveStatusSizeKnown));
-    ZigValue *result = create_const_vals(1);
+    ZigValue *result = ira->codegen->pass1_arena->create<ZigValue>();
     result->special = ConstValSpecialStatic;
     result->type = type_info_pointer_type;
-    ZigValue **fields = alloc_const_vals_ptrs(7);
+    ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 7);
     result->data.x_struct.fields = fields;
     // size: Size
 @@ -23974,7 +23938,7 @@ static void make_enum_field_val(IrAnalyze *ira, ZigValue *enum_field_val, TypeEn
     enum_field_val->special = ConstValSpecialStatic;
     enum_field_val->type = type_info_enum_field_type;
-    ZigValue **inner_fields = alloc_const_vals_ptrs(2);
+    ZigValue **inner_fields = alloc_const_vals_ptrs(ira->codegen, 2);
     inner_fields[1]->special = ConstValSpecialStatic;
     inner_fields[1]->type = ira->codegen->builtin_types.entry_num_lit_int;
 @@ -24020,11 +23984,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
             break;
         case ZigTypeIdInt:
             {
-                result = create_const_vals(1);
+                result = ira->codegen->pass1_arena->create<ZigValue>();
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "Int", nullptr);
-                ZigValue **fields = alloc_const_vals_ptrs(2);
+                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 2);
                 result->data.x_struct.fields = fields;
                 // is_signed: bool
 @@ -24042,11 +24006,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
             }
         case ZigTypeIdFloat:
             {
-                result = create_const_vals(1);
+                result = ira->codegen->pass1_arena->create<ZigValue>();
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "Float", nullptr);
-                ZigValue **fields = alloc_const_vals_ptrs(1);
+                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 1);
                 result->data.x_struct.fields = fields;
                 // bits: u8
 @@ -24066,11 +24030,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
             }
         case ZigTypeIdArray:
             {
-                result = create_const_vals(1);
+                result = ira->codegen->pass1_arena->create<ZigValue>();
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "Array", nullptr);
-                ZigValue **fields = alloc_const_vals_ptrs(3);
+                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 3);
                 result->data.x_struct.fields = fields;
                 // len: usize
 @@ -24090,11 +24054,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                 break;
             }
         case ZigTypeIdVector: {
-            result = create_const_vals(1);
+            result = ira->codegen->pass1_arena->create<ZigValue>();
             result->special = ConstValSpecialStatic;
             result->type = ir_type_info_get_type(ira, "Vector", nullptr);
-            ZigValue **fields = alloc_const_vals_ptrs(2);
+            ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 2);
             result->data.x_struct.fields = fields;
             // len: usize
 @@ -24112,11 +24076,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
         }
         case ZigTypeIdOptional:
             {
-                result = create_const_vals(1);
+                result = ira->codegen->pass1_arena->create<ZigValue>();
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "Optional", nullptr);
-                ZigValue **fields = alloc_const_vals_ptrs(1);
+                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 1);
                 result->data.x_struct.fields = fields;
                 // child: type
 @@ -24128,11 +24092,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                 break;
             }
         case ZigTypeIdAnyFrame: {
-            result = create_const_vals(1);
+            result = ira->codegen->pass1_arena->create<ZigValue>();
             result->special = ConstValSpecialStatic;
             result->type = ir_type_info_get_type(ira, "AnyFrame", nullptr);
-            ZigValue **fields = alloc_const_vals_ptrs(1);
+            ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 1);
             result->data.x_struct.fields = fields;
             // child: ?type
 @@ -24145,11 +24109,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
         }
         case ZigTypeIdEnum:
             {
-                result = create_const_vals(1);
+                result = ira->codegen->pass1_arena->create<ZigValue>();
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "Enum", nullptr);
-                ZigValue **fields = alloc_const_vals_ptrs(5);
+                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 5);
                 result->data.x_struct.fields = fields;
                 // layout: ContainerLayout
 @@ -24171,11 +24135,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                 }
                 uint32_t enum_field_count = type_entry->data.enumeration.src_field_count;
-                ZigValue *enum_field_array = create_const_vals(1);
+                ZigValue *enum_field_array = ira->codegen->pass1_arena->create<ZigValue>();
                 enum_field_array->special = ConstValSpecialStatic;
                 enum_field_array->type = get_array_type(ira->codegen, type_info_enum_field_type, enum_field_count, nullptr);
                 enum_field_array->data.x_array.special = ConstArraySpecialNone;
-                enum_field_array->data.x_array.data.s_none.elements = create_const_vals(enum_field_count);
+                enum_field_array->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(enum_field_count);
                 init_const_slice(ira->codegen, fields[2], enum_field_array, 0, enum_field_count, false);
 @@ -24205,7 +24169,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
             }
         case ZigTypeIdErrorSet:
             {
-                result = create_const_vals(1);
+                result = ira->codegen->pass1_arena->create<ZigValue>();
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "ErrorSet", nullptr);
 @@ -24220,15 +24184,15 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                 if ((err = type_resolve(ira->codegen, type_info_error_type, ResolveStatusSizeKnown))) {
                     zig_unreachable();
                 }
-                ZigValue *slice_val = create_const_vals(1);
+                ZigValue *slice_val = ira->codegen->pass1_arena->create<ZigValue>();
                 result->data.x_optional = slice_val;
                 uint32_t error_count = type_entry->data.error_set.err_count;
-                ZigValue *error_array = create_const_vals(1);
+                ZigValue *error_array = ira->codegen->pass1_arena->create<ZigValue>();
                 error_array->special = ConstValSpecialStatic;
                 error_array->type = get_array_type(ira->codegen, type_info_error_type, error_count, nullptr);
                 error_array->data.x_array.special = ConstArraySpecialNone;
-                error_array->data.x_array.data.s_none.elements = create_const_vals(error_count);
+                error_array->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(error_count);
                 init_const_slice(ira->codegen, slice_val, error_array, 0, error_count, false);
                 for (uint32_t error_index = 0; error_index < error_count; error_index++) {
 @@ -24238,7 +24202,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                     error_val->special = ConstValSpecialStatic;
                     error_val->type = type_info_error_type;
-                    ZigValue **inner_fields = alloc_const_vals_ptrs(2);
+                    ZigValue **inner_fields = alloc_const_vals_ptrs(ira->codegen, 2);
                     inner_fields[1]->special = ConstValSpecialStatic;
                     inner_fields[1]->type = ira->codegen->builtin_types.entry_num_lit_int;
 @@ -24260,11 +24224,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
             }
         case ZigTypeIdErrorUnion:
             {
-                result = create_const_vals(1);
+                result = ira->codegen->pass1_arena->create<ZigValue>();
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "ErrorUnion", nullptr);
-                ZigValue **fields = alloc_const_vals_ptrs(2);
+                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 2);
                 result->data.x_struct.fields = fields;
                 // error_set: type
 @@ -24283,11 +24247,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
             }
         case ZigTypeIdUnion:
             {
-                result = create_const_vals(1);
+                result = ira->codegen->pass1_arena->create<ZigValue>();
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "Union", nullptr);
-                ZigValue **fields = alloc_const_vals_ptrs(4);
+                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 4);
                 result->data.x_struct.fields = fields;
                 // layout: ContainerLayout
 @@ -24304,7 +24268,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                 if (union_decl_node->data.container_decl.auto_enum ||
                     union_decl_node->data.container_decl.init_arg_expr != nullptr)
                 {
-                    ZigValue *tag_type = create_const_vals(1);
+                    ZigValue *tag_type = ira->codegen->pass1_arena->create<ZigValue>();
                     tag_type->special = ConstValSpecialStatic;
                     tag_type->type = ira->codegen->builtin_types.entry_type;
                     tag_type->data.x_type = type_entry->data.unionation.tag_type;
 @@ -24320,11 +24284,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                     zig_unreachable();
                 uint32_t union_field_count = type_entry->data.unionation.src_field_count;
-                ZigValue *union_field_array = create_const_vals(1);
+                ZigValue *union_field_array = ira->codegen->pass1_arena->create<ZigValue>();
                 union_field_array->special = ConstValSpecialStatic;
                 union_field_array->type = get_array_type(ira->codegen, type_info_union_field_type, union_field_count, nullptr);
                 union_field_array->data.x_array.special = ConstArraySpecialNone;
-                union_field_array->data.x_array.data.s_none.elements = create_const_vals(union_field_count);
+                union_field_array->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(union_field_count);
                 init_const_slice(ira->codegen, fields[2], union_field_array, 0, union_field_count, false);
 @@ -24337,14 +24301,14 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                     union_field_val->special = ConstValSpecialStatic;
                     union_field_val->type = type_info_union_field_type;
-                    ZigValue **inner_fields = alloc_const_vals_ptrs(3);
+                    ZigValue **inner_fields = alloc_const_vals_ptrs(ira->codegen, 3);
                     inner_fields[1]->special = ConstValSpecialStatic;
                     inner_fields[1]->type = get_optional_type(ira->codegen, type_info_enum_field_type);
                     if (fields[1]->data.x_optional == nullptr) {
                         inner_fields[1]->data.x_optional = nullptr;
                     } else {
-                        inner_fields[1]->data.x_optional = create_const_vals(1);
+                        inner_fields[1]->data.x_optional = ira->codegen->pass1_arena->create<ZigValue>();
                         make_enum_field_val(ira, inner_fields[1]->data.x_optional, union_field->enum_field, type_info_enum_field_type);
                     }
 @@ -24379,11 +24343,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                     break;
                 }
-                result = create_const_vals(1);
+                result = ira->codegen->pass1_arena->create<ZigValue>();
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "Struct", nullptr);
-                ZigValue **fields = alloc_const_vals_ptrs(3);
+                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 3);
                 result->data.x_struct.fields = fields;
                 // layout: ContainerLayout
 @@ -24400,11 +24364,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                 }
                 uint32_t struct_field_count = type_entry->data.structure.src_field_count;
-                ZigValue *struct_field_array = create_const_vals(1);
+                ZigValue *struct_field_array = ira->codegen->pass1_arena->create<ZigValue>();
                 struct_field_array->special = ConstValSpecialStatic;
                 struct_field_array->type = get_array_type(ira->codegen, type_info_struct_field_type, struct_field_count, nullptr);
                 struct_field_array->data.x_array.special = ConstArraySpecialNone;
-                struct_field_array->data.x_array.data.s_none.elements = create_const_vals(struct_field_count);
+                struct_field_array->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(struct_field_count);
                 init_const_slice(ira->codegen, fields[1], struct_field_array, 0, struct_field_count, false);
 @@ -24415,7 +24379,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                     struct_field_val->special = ConstValSpecialStatic;
                     struct_field_val->type = type_info_struct_field_type;
-                    ZigValue **inner_fields = alloc_const_vals_ptrs(4);
+                    ZigValue **inner_fields = alloc_const_vals_ptrs(ira->codegen, 4);
                     inner_fields[1]->special = ConstValSpecialStatic;
                     inner_fields[1]->type = get_optional_type(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int);
 @@ -24428,7 +24392,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                         inner_fields[1]->data.x_optional = nullptr;
                     } else {
                         size_t byte_offset = struct_field->offset;
-                        inner_fields[1]->data.x_optional = create_const_vals(1);
+                        inner_fields[1]->data.x_optional = ira->codegen->pass1_arena->create<ZigValue>();
                         inner_fields[1]->data.x_optional->special = ConstValSpecialStatic;
                         inner_fields[1]->data.x_optional->type = ira->codegen->builtin_types.entry_num_lit_int;
                         bigint_init_unsigned(&inner_fields[1]->data.x_optional->data.x_bigint, byte_offset);
 @@ -24464,11 +24428,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
             }
         case ZigTypeIdFn:
             {
-                result = create_const_vals(1);
+                result = ira->codegen->pass1_arena->create<ZigValue>();
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "Fn", nullptr);
-                ZigValue **fields = alloc_const_vals_ptrs(5);
+                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 5);
                 result->data.x_struct.fields = fields;
                 // calling_convention: TypeInfo.CallingConvention
 @@ -24495,7 +24459,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                 if (type_entry->data.fn.fn_type_id.return_type == nullptr)
                     fields[3]->data.x_optional = nullptr;
                 else {
-                    ZigValue *return_type = create_const_vals(1);
+                    ZigValue *return_type = ira->codegen->pass1_arena->create<ZigValue>();
                     return_type->special = ConstValSpecialStatic;
                     return_type->type = ira->codegen->builtin_types.entry_type;
                     return_type->data.x_type = type_entry->data.fn.fn_type_id.return_type;
 @@ -24509,11 +24473,11 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                 size_t fn_arg_count = type_entry->data.fn.fn_type_id.param_count -
                         (is_varargs && type_entry->data.fn.fn_type_id.cc != CallingConventionC);
-                ZigValue *fn_arg_array = create_const_vals(1);
+                ZigValue *fn_arg_array = ira->codegen->pass1_arena->create<ZigValue>();
                 fn_arg_array->special = ConstValSpecialStatic;
                 fn_arg_array->type = get_array_type(ira->codegen, type_info_fn_arg_type, fn_arg_count, nullptr);
                 fn_arg_array->data.x_array.special = ConstArraySpecialNone;
-                fn_arg_array->data.x_array.data.s_none.elements = create_const_vals(fn_arg_count);
+                fn_arg_array->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(fn_arg_count);
                 init_const_slice(ira->codegen, fields[4], fn_arg_array, 0, fn_arg_count, false);
 @@ -24527,7 +24491,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                     bool arg_is_generic = fn_param_info->type == nullptr;
                     if (arg_is_generic) assert(is_generic);
-                    ZigValue **inner_fields = alloc_const_vals_ptrs(3);
+                    ZigValue **inner_fields = alloc_const_vals_ptrs(ira->codegen, 3);
                     inner_fields[0]->special = ConstValSpecialStatic;
                     inner_fields[0]->type = ira->codegen->builtin_types.entry_bool;
                     inner_fields[0]->data.x_bool = arg_is_generic;
 @@ -24540,7 +24504,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                     if (arg_is_generic)
                         inner_fields[2]->data.x_optional = nullptr;
                     else {
-                        ZigValue *arg_type = create_const_vals(1);
+                        ZigValue *arg_type = ira->codegen->pass1_arena->create<ZigValue>();
                         arg_type->special = ConstValSpecialStatic;
                         arg_type->type = ira->codegen->builtin_types.entry_type;
                         arg_type->data.x_type = fn_param_info->type;
 @@ -24866,7 +24830,7 @@ static IrInstGen *ir_analyze_instruction_type_name(IrAnalyze *ira, IrInstSrcType
         type_entry->cached_const_name_val = create_const_str_lit(ira->codegen, type_bare_name(type_entry));
     }
     IrInstGen *result = ir_const(ira, &instruction->base.base, nullptr);
-    copy_const_val(result->value, type_entry->cached_const_name_val);
+    copy_const_val(ira->codegen, result->value, type_entry->cached_const_name_val);
     return result;
 }
 @@ -24898,7 +24862,6 @@ static IrInstGen *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstSrcCImpo
     }
     if (type_is_invalid(cimport_result->type))
         return ira->codegen->invalid_inst_gen;
-    destroy(result_ptr, "ZigValue");
     ZigPackage *cur_scope_pkg = scope_package(instruction->base.base.scope);
     Buf *namespace_name = buf_sprintf("%s.cimport:%" ZIG_PRI_usize ":%" ZIG_PRI_usize,
 @@ -25577,11 +25540,11 @@ static IrInstGen *ir_analyze_instruction_to_bytes(IrAnalyze *ira, IrInstSrcToByt
             return ira->codegen->invalid_inst_gen;
         IrInstGen *result = ir_const(ira, &instruction->base.base, dest_slice_type);
-        result->value->data.x_struct.fields = alloc_const_vals_ptrs(2);
+        result->value->data.x_struct.fields = alloc_const_vals_ptrs(ira->codegen, 2);
         ZigValue *ptr_val = result->value->data.x_struct.fields[slice_ptr_index];
         ZigValue *target_ptr_val = target_val->data.x_struct.fields[slice_ptr_index];
-        copy_const_val(ptr_val, target_ptr_val);
+        copy_const_val(ira->codegen, ptr_val, target_ptr_val);
         ptr_val->type = dest_ptr_type;
         ZigValue *len_val = result->value->data.x_struct.fields[slice_len_index];
 @@ -25868,7 +25831,7 @@ static IrInstGen *ir_analyze_shuffle_vector(IrAnalyze *ira, IrInst* source_instr
         expand_undef_array(ira->codegen, b_val);
         IrInstGen *result = ir_const(ira, source_instr, result_type);
-        result->value->data.x_array.data.s_none.elements = create_const_vals(len_mask);
+        result->value->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(len_mask);
         for (uint32_t i = 0; i < mask_val->type->data.vector.len; i += 1) {
             ZigValue *mask_elem_val = &mask_val->data.x_array.data.s_none.elements[i];
             ZigValue *result_elem_val = &result->value->data.x_array.data.s_none.elements[i];
 @@ -25881,7 +25844,7 @@ static IrInstGen *ir_analyze_shuffle_vector(IrAnalyze *ira, IrInst* source_instr
             ZigValue *src_elem_val = (v >= 0) ?
                 &a->value->data.x_array.data.s_none.elements[v] :
                 &b->value->data.x_array.data.s_none.elements[~v];
-            copy_const_val(result_elem_val, src_elem_val);
+            copy_const_val(ira->codegen, result_elem_val, src_elem_val);
             ir_assert(result_elem_val->special == ConstValSpecialStatic, source_instr);
         }
 @@ -25901,7 +25864,7 @@ static IrInstGen *ir_analyze_shuffle_vector(IrAnalyze *ira, IrInst* source_instr
         IrInstGen *expand_mask = ir_const(ira, &mask->base,
             get_vector_type(ira->codegen, len_max, ira->codegen->builtin_types.entry_i32));
-        expand_mask->value->data.x_array.data.s_none.elements = create_const_vals(len_max);
+        expand_mask->value->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(len_max);
         uint32_t i = 0;
         for (; i < len_min; i += 1)
             bigint_init_unsigned(&expand_mask->value->data.x_array.data.s_none.elements[i].data.x_bigint, i);
 @@ -25971,9 +25934,9 @@ static IrInstGen *ir_analyze_instruction_splat(IrAnalyze *ira, IrInstSrcSplat *i
             return ir_const_undef(ira, &instruction->base.base, return_type);
         IrInstGen *result = ir_const(ira, &instruction->base.base, return_type);
-        result->value->data.x_array.data.s_none.elements = create_const_vals(len_int);
+        result->value->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(len_int);
         for (uint32_t i = 0; i < len_int; i += 1) {
-            copy_const_val(&result->value->data.x_array.data.s_none.elements[i], scalar_val);
+            copy_const_val(ira->codegen, &result->value->data.x_array.data.s_none.elements[i], scalar_val);
         }
         return result;
     }
 @@ -26111,7 +26074,7 @@ static IrInstGen *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstSrcMemset
             }
             for (size_t i = start; i < end; i += 1) {
-                copy_const_val(&dest_elements[i], byte_val);
+                copy_const_val(ira->codegen, &dest_elements[i], byte_val);
             }
             return ir_const_void(ira, &instruction->base.base);
 @@ -26287,7 +26250,7 @@ static IrInstGen *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstSrcMemcpy
             // TODO check for noalias violations - this should be generalized to work for any function
             for (size_t i = 0; i < count; i += 1) {
-                copy_const_val(&dest_elements[dest_start + i], &src_elements[src_start + i]);
+                copy_const_val(ira->codegen, &dest_elements[dest_start + i], &src_elements[src_start + i]);
             }
             return ir_const_void(ira, &instruction->base.base);
 @@ -26571,7 +26534,7 @@ static IrInstGen *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstSrcSlice *i
         IrInstGen *result = ir_const(ira, &instruction->base.base, return_type);
         ZigValue *out_val = result->value;
-        out_val->data.x_struct.fields = alloc_const_vals_ptrs(2);
+        out_val->data.x_struct.fields = alloc_const_vals_ptrs(ira->codegen, 2);
         ZigValue *ptr_val = out_val->data.x_struct.fields[slice_ptr_index];
 @@ -26866,7 +26829,7 @@ static IrInstGen *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstSrcAlign
     IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_num_lit_int);
     result->value->special = ConstValSpecialLazy;
-    LazyValueAlignOf *lazy_align_of = allocate<LazyValueAlignOf>(1, "LazyValueAlignOf");
+    LazyValueAlignOf *lazy_align_of = heap::c_allocator.create<LazyValueAlignOf>();
     lazy_align_of->ira = ira; ira_ref(ira);
     result->value->data.x_lazy = &lazy_align_of->base;
     lazy_align_of->base.id = LazyValueIdAlignOf;
 @@ -27192,7 +27155,7 @@ static IrInstGen *ir_analyze_unwrap_err_code(IrAnalyze *ira, IrInst* source_inst
                 return ira->codegen->invalid_inst_gen;
             if (initializing && err_union_val->special == ConstValSpecialUndef) {
-                ZigValue *vals = create_const_vals(2);
+                ZigValue *vals = ira->codegen->pass1_arena->allocate<ZigValue>(2);
                 ZigValue *err_set_val = &vals[0];
                 ZigValue *payload_val = &vals[1];
 @@ -27273,7 +27236,7 @@ static IrInstGen *ir_analyze_unwrap_error_payload(IrAnalyze *ira, IrInst* source
             if (err_union_val == nullptr)
                 return ira->codegen->invalid_inst_gen;
             if (initializing && err_union_val->special == ConstValSpecialUndef) {
-                ZigValue *vals = create_const_vals(2);
+                ZigValue *vals = ira->codegen->pass1_arena->allocate<ZigValue>(2);
                 ZigValue *err_set_val = &vals[0];
                 ZigValue *payload_val = &vals[1];
 @@ -27335,7 +27298,7 @@ static IrInstGen *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstSrcFnPro
     IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_type);
     result->value->special = ConstValSpecialLazy;
-    LazyValueFnType *lazy_fn_type = allocate<LazyValueFnType>(1, "LazyValueFnType");
+    LazyValueFnType *lazy_fn_type = heap::c_allocator.create<LazyValueFnType>();
     lazy_fn_type->ira = ira; ira_ref(ira);
     result->value->data.x_lazy = &lazy_fn_type->base;
     lazy_fn_type->base.id = LazyValueIdFnType;
 @@ -27363,7 +27326,7 @@ static IrInstGen *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstSrcFnPro
     size_t param_count = proto_node->data.fn_proto.params.length;
     lazy_fn_type->proto_node = proto_node;
-    lazy_fn_type->param_types = allocate<IrInstGen *>(param_count);
+    lazy_fn_type->param_types = heap::c_allocator.allocate<IrInstGen *>(param_count);
     for (size_t param_index = 0; param_index < param_count; param_index += 1) {
         AstNode *param_node = proto_node->data.fn_proto.params.at(param_index);
 @@ -27518,7 +27481,7 @@ static IrInstGen *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
         }
         size_t field_prev_uses_count = ira->codegen->errors_by_index.length;
-        AstNode **field_prev_uses = allocate<AstNode *>(field_prev_uses_count, "AstNode *");
+        AstNode **field_prev_uses = heap::c_allocator.allocate<AstNode *>(field_prev_uses_count);
         for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
             IrInstSrcCheckSwitchProngsRange *range = &instruction->ranges[range_i];
 @@ -27575,7 +27538,7 @@ static IrInstGen *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
             }
         }
-        deallocate(field_prev_uses, field_prev_uses_count, "AstNode *");
+        heap::c_allocator.deallocate(field_prev_uses, field_prev_uses_count);
     } else if (switch_type->id == ZigTypeIdInt) {
         RangeSet rs = {0};
         for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
 @@ -27768,7 +27731,7 @@ static IrInstGen *ir_align_cast(IrAnalyze *ira, IrInstGen *target, uint32_t alig
         }
         IrInstGen *result = ir_const(ira, &target->base, result_type);
-        copy_const_val(result->value, val);
+        copy_const_val(ira->codegen, result->value, val);
         result->value->type = result_type;
         return result;
     }
 @@ -27864,7 +27827,7 @@ static IrInstGen *ir_analyze_ptr_cast(IrAnalyze *ira, IrInst* source_instr, IrIn
         InferredStructField *isf = (val->type->id == ZigTypeIdPointer) ?
             val->type->data.pointer.inferred_struct_field : nullptr;
         if (isf == nullptr) {
-            copy_const_val(result->value, val);
+            copy_const_val(ira->codegen, result->value, val);
         } else {
             // The destination value should have x_ptr struct pointing to underlying struct value
             result->value->data.x_ptr.mut = val->data.x_ptr.mut;
 @@ -28021,7 +27984,7 @@ static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ZigValue *val)
                     while (gen_i < gen_field_count) {
                         size_t big_int_byte_count = val->type->data.structure.host_int_bytes[gen_i];
                         if (big_int_byte_count > child_buf_len) {
-                            child_buf = allocate_nonzero<uint8_t>(big_int_byte_count);
+                            child_buf = heap::c_allocator.allocate_nonzero<uint8_t>(big_int_byte_count);
                             child_buf_len = big_int_byte_count;
                         }
                         BigInt big_int;
 @@ -28084,7 +28047,7 @@ static Error buf_read_value_bytes_array(IrAnalyze *ira, CodeGen *codegen, AstNod
     switch (val->data.x_array.special) {
         case ConstArraySpecialNone:
-            val->data.x_array.data.s_none.elements = create_const_vals(len);
+            val->data.x_array.data.s_none.elements = codegen->pass1_arena->allocate<ZigValue>(len);
             for (size_t i = 0; i < len; i++) {
                 ZigValue *elem = &val->data.x_array.data.s_none.elements[i];
                 elem->special = ConstValSpecialStatic;
 @@ -28170,7 +28133,7 @@ static Error buf_read_value_bytes(IrAnalyze *ira, CodeGen *codegen, AstNode *sou
                 }
                 case ContainerLayoutExtern: {
                     size_t src_field_count = val->type->data.structure.src_field_count;
-                    val->data.x_struct.fields = alloc_const_vals_ptrs(src_field_count);
+                    val->data.x_struct.fields = alloc_const_vals_ptrs(codegen, src_field_count);
                     for (size_t field_i = 0; field_i < src_field_count; field_i += 1) {
                         ZigValue *field_val = val->data.x_struct.fields[field_i];
                         field_val->special = ConstValSpecialStatic;
 @@ -28187,7 +28150,7 @@ static Error buf_read_value_bytes(IrAnalyze *ira, CodeGen *codegen, AstNode *sou
                 }
                 case ContainerLayoutPacked: {
                     size_t src_field_count = val->type->data.structure.src_field_count;
-                    val->data.x_struct.fields = alloc_const_vals_ptrs(src_field_count);
+                    val->data.x_struct.fields = alloc_const_vals_ptrs(codegen, src_field_count);
                     size_t gen_field_count = val->type->data.structure.gen_field_count;
                     size_t gen_i = 0;
                     size_t src_i = 0;
 @@ -28199,7 +28162,7 @@ static Error buf_read_value_bytes(IrAnalyze *ira, CodeGen *codegen, AstNode *sou
                     while (gen_i < gen_field_count) {
                         size_t big_int_byte_count = val->type->data.structure.host_int_bytes[gen_i];
                         if (big_int_byte_count > child_buf_len) {
-                            child_buf = allocate_nonzero<uint8_t>(big_int_byte_count);
+                            child_buf = heap::c_allocator.allocate_nonzero<uint8_t>(big_int_byte_count);
                             child_buf_len = big_int_byte_count;
                         }
                         BigInt big_int;
 @@ -28309,7 +28272,7 @@ static IrInstGen *ir_analyze_bit_cast(IrAnalyze *ira, IrInst* source_instr, IrIn
             return ira->codegen->invalid_inst_gen;
         IrInstGen *result = ir_const(ira, source_instr, dest_type);
-        uint8_t *buf = allocate_nonzero<uint8_t>(src_size_bytes);
+        uint8_t *buf = heap::c_allocator.allocate_nonzero<uint8_t>(src_size_bytes);
         buf_write_value_bytes(ira->codegen, buf, val);
         if ((err = buf_read_value_bytes(ira, ira->codegen, source_instr->source_node, buf, result->value)))
             return ira->codegen->invalid_inst_gen;
 @@ -28451,7 +28414,7 @@ static IrInstGen *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstSrcPtrTy
     IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_type);
     result->value->special = ConstValSpecialLazy;
-    LazyValuePtrType *lazy_ptr_type = allocate<LazyValuePtrType>(1, "LazyValuePtrType");
+    LazyValuePtrType *lazy_ptr_type = heap::c_allocator.create<LazyValuePtrType>();
     lazy_ptr_type->ira = ira; ira_ref(ira);
     result->value->data.x_lazy = &lazy_ptr_type->base;
     lazy_ptr_type->base.id = LazyValueIdPtrType;
 @@ -29150,11 +29113,11 @@ static IrInstGen *ir_analyze_instruction_bswap(IrAnalyze *ira, IrInstSrcBswap *i
             return ir_const_undef(ira, &instruction->base.base, op_type);
         IrInstGen *result = ir_const(ira, &instruction->base.base, op_type);
-        size_t buf_size = int_type->data.integral.bit_count / 8;
+        const size_t buf_size = int_type->data.integral.bit_count / 8;
-        uint8_t *buf = allocate_nonzero<uint8_t>(buf_size);
+        uint8_t *buf = heap::c_allocator.allocate_nonzero<uint8_t>(buf_size);
         if (is_vector) {
             expand_undef_array(ira->codegen, val);
-            result->value->data.x_array.data.s_none.elements = create_const_vals(op_type->data.vector.len);
+            result->value->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(op_type->data.vector.len);
             for (unsigned i = 0; i < op_type->data.vector.len; i += 1) {
                 ZigValue *op_elem_val = &val->data.x_array.data.s_none.elements[i];
                 if ((err = ir_resolve_const_val(ira->codegen, ira->new_irb.exec, instruction->base.base.source_node,
 @@ -29178,7 +29141,7 @@ static IrInstGen *ir_analyze_instruction_bswap(IrAnalyze *ira, IrInstSrcBswap *i
             bigint_read_twos_complement(&result->value->data.x_bigint, buf, int_type->data.integral.bit_count, false,
                     int_type->data.integral.is_signed);
         }
-        free(buf);
+        heap::c_allocator.deallocate(buf, buf_size);
         return result;
     }
 @@ -29210,8 +29173,8 @@ static IrInstGen *ir_analyze_instruction_bit_reverse(IrAnalyze *ira, IrInstSrcBi
         IrInstGen *result = ir_const(ira, &instruction->base.base, int_type);
         size_t num_bits = int_type->data.integral.bit_count;
         size_t buf_size = (num_bits + 7) / 8;
-        uint8_t *comptime_buf = allocate_nonzero<uint8_t>(buf_size);
+        uint8_t *comptime_buf = heap::c_allocator.allocate_nonzero<uint8_t>(buf_size);
-        uint8_t *result_buf = allocate_nonzero<uint8_t>(buf_size);
+        uint8_t *result_buf = heap::c_allocator.allocate_nonzero<uint8_t>(buf_size);
         memset(comptime_buf,0,buf_size);
         memset(result_buf,0,buf_size);
 @@ -29897,7 +29860,7 @@ ZigType *ir_analyze(CodeGen *codegen, IrExecutableSrc *old_exec, IrExecutableGen
     assert(old_exec->first_err_trace_msg == nullptr);
     assert(expected_type == nullptr || !type_is_invalid(expected_type));
-    IrAnalyze *ira = allocate<IrAnalyze>(1, "IrAnalyze");
+    IrAnalyze *ira = heap::c_allocator.create<IrAnalyze>();
     ira->ref_count = 1;
     old_exec->analysis = ira;
     ira->codegen = codegen;

src/ir.hpp-2

...	@@ -37,6 +37,4 @@ ZigValue const_ptr_pointee(IrAnalyze ira, CodeGen codegen, ZigValue const_va	...	@@ -37,6 +37,4 @@ ZigValue const_ptr_pointee(IrAnalyze ira, CodeGen codegen, ZigValue const_va
37	void dbg_ir_break(const char *src_file, uint32_t line);	37	void dbg_ir_break(const char *src_file, uint32_t line);
38	void dbg_ir_clear(void);	38	void dbg_ir_clear(void);
39		39
40	void destroy_instruction_gen(IrInstGen *inst);
41
42	#endif	40	#endif

src/link.cpp+19-19

src/list.hpp+2-4

...	@@ -13,7 +13,7 @@	...	@@ -13,7 +13,7 @@
13	template<typename T>	13	template<typename T>
14	struct ZigList {	14	struct ZigList {
15	void deinit() {	15	void deinit() {
16	deallocate(items, capacity);	16	heap::c_allocator.deallocate(items, capacity);
17	}	17	}
18	void append(const T& item) {	18	void append(const T& item) {
19	ensure_capacity(length + 1);	19	ensure_capacity(length + 1);
...	@@ -70,7 +70,7 @@ struct ZigList {	...	@@ -70,7 +70,7 @@ struct ZigList {
70	better_capacity = better_capacity * 5 / 2 + 8;	70	better_capacity = better_capacity * 5 / 2 + 8;
71	} while (better_capacity < new_capacity);	71	} while (better_capacity < new_capacity);
72		72
73	items = reallocate_nonzero(items, capacity, better_capacity);	73	items = heap::c_allocator.reallocate_nonzero(items, capacity, better_capacity);
74	capacity = better_capacity;	74	capacity = better_capacity;
75	}	75	}
76		76
...	@@ -91,5 +91,3 @@ struct ZigList {	...	@@ -91,5 +91,3 @@ struct ZigList {
91	};	91	};
92		92
93	#endif	93	#endif
94
95

src/main.cpp+27-21

 @@ -11,12 +11,14 @@
 #include "compiler.hpp"
 #include "config.h"
 #include "error.hpp"
+#include "heap.hpp"
 #include "os.hpp"
 #include "target.hpp"
 #include "libc_installation.hpp"
 #include "userland.h"
 #include "glibc.hpp"
 #include "dump_analysis.hpp"
+#include "mem_profile.hpp"
 #include <stdio.h>
 @@ -243,21 +245,10 @@ int main_exit(Stage2ProgressNode *root_progress_node, int exit_code) {
     if (root_progress_node != nullptr) {
         stage2_progress_end(root_progress_node);
     }
-#ifdef ZIG_ENABLE_MEM_PROFILE
-    if (mem_report) {
-        memprof_dump_stats(stderr);
-    }
-#endif
     return exit_code;
 }
-int main(int argc, char **argv) {
+static int main0(int argc, char **argv) {
-    stage2_attach_segfault_handler();
-#ifdef ZIG_ENABLE_MEM_PROFILE
-    memprof_init();
-#endif
     char *arg0 = argv[0];
     Error err;
 @@ -278,9 +269,6 @@ int main(int argc, char **argv) {
         return ZigClang_main(argc, argv);
     }
-    // Must be before all os.hpp function calls.
-    os_init();
     if (argc == 2 && strcmp(argv[1], "id") == 0) {
         Buf *compiler_id;
         if ((err = get_compiler_id(&compiler_id))) {
 @@ -439,7 +427,7 @@ int main(int argc, char **argv) {
     bool enable_doc_generation = false;
     bool disable_bin_generation = false;
     const char *cache_dir = nullptr;
-    CliPkg *cur_pkg = allocate<CliPkg>(1);
+    CliPkg *cur_pkg = heap::c_allocator.create<CliPkg>();
     BuildMode build_mode = BuildModeDebug;
     ZigList<const char *> test_exec_args = {0};
     int runtime_args_start = -1;
 @@ -635,6 +623,7 @@ int main(int argc, char **argv) {
             } else if (strcmp(arg, "-fmem-report") == 0) {
 #ifdef ZIG_ENABLE_MEM_PROFILE
                 mem_report = true;
+                mem::report_print = true;
 #else
                 fprintf(stderr, "-fmem-report requires configuring with -DZIG_ENABLE_MEM_PROFILE=ON\n");
                 return print_error_usage(arg0);
 @@ -695,7 +684,7 @@ int main(int argc, char **argv) {
                     fprintf(stderr, "Expected 2 arguments after --pkg-begin\n");
                     return print_error_usage(arg0);
                 }
-                CliPkg *new_cur_pkg = allocate<CliPkg>(1);
+                CliPkg *new_cur_pkg = heap::c_allocator.create<CliPkg>();
                 i += 1;
                 new_cur_pkg->name = argv[i];
                 i += 1;
 @@ -810,7 +799,7 @@ int main(int argc, char **argv) {
                 } else if (strcmp(arg, "--object") == 0) {
                     objects.append(argv[i]);
                 } else if (strcmp(arg, "--c-source") == 0) {
-                    CFile *c_file = allocate<CFile>(1);
+                    CFile *c_file = heap::c_allocator.create<CFile>();
                     for (;;) {
                         if (argv[i][0] == '-') {
                             c_file->args.append(argv[i]);
 @@ -990,7 +979,7 @@ int main(int argc, char **argv) {
             }
         }
         if (target_is_glibc(&target)) {
-            target.glibc_version = allocate<ZigGLibCVersion>(1);
+            target.glibc_version = heap::c_allocator.create<ZigGLibCVersion>();
             if (target_glibc != nullptr) {
                 if ((err = target_parse_glibc_version(target.glibc_version, target_glibc))) {
 @@ -1138,7 +1127,7 @@ int main(int argc, char **argv) {
             }
             ZigLibCInstallation *libc = nullptr;
             if (libc_txt != nullptr) {
-                libc = allocate<ZigLibCInstallation>(1);
+                libc = heap::c_allocator.create<ZigLibCInstallation>();
                 if ((err = zig_libc_parse(libc, buf_create_from_str(libc_txt), &target, true))) {
                     fprintf(stderr, "Unable to parse --libc text file: %s\n", err_str(err));
                     return main_exit(root_progress_node, EXIT_FAILURE);
 @@ -1269,7 +1258,8 @@ int main(int argc, char **argv) {
                 if (cmd == CmdRun) {
 #ifdef ZIG_ENABLE_MEM_PROFILE
-                    memprof_dump_stats(stderr);
+                    if (mem::report_print)
+                        mem::print_report();
 #endif
                     const char *exec_path = buf_ptr(&g->output_file_path);
 @@ -1384,4 +1374,20 @@ int main(int argc, char **argv) {
     case CmdNone:
         return print_full_usage(arg0, stderr, EXIT_FAILURE);
     }
+    zig_unreachable();
+}
+int main(int argc, char **argv) {
+    stage2_attach_segfault_handler();
+    os_init();
+    mem::init();
+    auto result = main0(argc, argv);
+#ifdef ZIG_ENABLE_MEM_PROFILE
+    if (mem::report_print)
+        mem::intern_counters.print_report();
+#endif
+    mem::deinit();
+    return result;
 }

src/mem.cpp created+37

...	@@ -0,0 +1,37 @@
1	/*
2	* Copyright (c) 2020 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#include "config.h"
9	#include "mem.hpp"
10	#include "mem_profile.hpp"
11	#include "heap.hpp"
12
13	namespace mem {
14
15	void init() {
16	heap::bootstrap_allocator_state.init("heap::bootstrap_allocator");
17	heap::c_allocator_state.init("heap::c_allocator");
18	}
19
20	void deinit() {
21	heap::c_allocator_state.deinit();
22	heap::bootstrap_allocator_state.deinit();
23	}
24
25	#ifdef ZIG_ENABLE_MEM_PROFILE
26	void print_report(FILE *file) {
27	heap::c_allocator_state.print_report(file);
28	intern_counters.print_report(file);
29	}
30	#endif
31
32	#ifdef ZIG_ENABLE_MEM_PROFILE
33	bool report_print = false;
34	FILE *report_file{nullptr};
35	#endif
36
37	} // namespace mem

src/mem.hpp created+149

...	@@ -0,0 +1,149 @@
1	/*
2	* Copyright (c) 2020 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#ifndef ZIG_MEM_HPP
9	#define ZIG_MEM_HPP
10
11	#include <stdint.h>
12	#include <stdio.h>
13	#include <stdlib.h>
14
15	#include "config.h"
16	#include "util_base.hpp"
17	#include "mem_type_info.hpp"
18
19	//
20	// -- Memory Allocation General Notes --
21	//
22	// `heap::c_allocator` is the preferred general allocator.
23	//
24	// `heap::bootstrap_allocator` is an implementation detail for use
25	// by allocators themselves when incidental heap may be required for
26	// profiling and statistics. It breaks the infinite recursion cycle.
27	//
28	// `mem::os` contains a raw wrapper for system malloc API used in
29	// preference to calling ::{malloc, free, calloc, realloc} directly.
30	// This isolates usage and helps with audits:
31	//
32	// mem::os::malloc
33	// mem::os::free
34	// mem::os::calloc
35	// mem::os::realloc
36	//
37	namespace mem {
38
39	// initialize mem module before any use
40	void init();
41
42	// deinitialize mem module to free memory and print report
43	void deinit();
44
45	// isolate system/libc allocators
46	namespace os {
47
48	ATTRIBUTE_RETURNS_NOALIAS
49	inline void *malloc(size_t size) {
50	#ifndef NDEBUG
51	// make behavior when size == 0 portable
52	if (size == 0)
53	return nullptr;
54	#endif
55	auto ptr = ::malloc(size);
56	if (ptr == nullptr)
57	zig_panic("allocation failed");
58	return ptr;
59	}
60
61	inline void free(void *ptr) {
62	::free(ptr);
63	}
64
65	ATTRIBUTE_RETURNS_NOALIAS
66	inline void *calloc(size_t count, size_t size) {
67	#ifndef NDEBUG
68	// make behavior when size == 0 portable
69	if (count == 0 \|\| size == 0)
70	return nullptr;
71	#endif
72	auto ptr = ::calloc(count, size);
73	if (ptr == nullptr)
74	zig_panic("allocation failed");
75	return ptr;
76	}
77
78	inline void realloc(void old_ptr, size_t size) {
79	#ifndef NDEBUG
80	// make behavior when size == 0 portable
81	if (old_ptr == nullptr && size == 0)
82	return nullptr;
83	#endif
84	auto ptr = ::realloc(old_ptr, size);
85	if (ptr == nullptr)
86	zig_panic("allocation failed");
87	return ptr;
88	}
89
90	} // namespace os
91
92	struct Allocator {
93	virtual void destruct(Allocator *allocator) = 0;
94
95	template <typename T> ATTRIBUTE_RETURNS_NOALIAS
96	T *allocate(size_t count) {
97	return reinterpret_cast<T *>(this->internal_allocate(TypeInfo::make<T>(), count));
98	}
99
100	template <typename T> ATTRIBUTE_RETURNS_NOALIAS
101	T *allocate_nonzero(size_t count) {
102	return reinterpret_cast<T *>(this->internal_allocate_nonzero(TypeInfo::make<T>(), count));
103	}
104
105	template <typename T>
106	T reallocate(T old_ptr, size_t old_count, size_t new_count) {
107	return reinterpret_cast<T *>(this->internal_reallocate(TypeInfo::make<T>(), old_ptr, old_count, new_count));
108	}
109
110	template <typename T>
111	T reallocate_nonzero(T old_ptr, size_t old_count, size_t new_count) {
112	return reinterpret_cast<T *>(this->internal_reallocate_nonzero(TypeInfo::make<T>(), old_ptr, old_count, new_count));
113	}
114
115	template<typename T>
116	void deallocate(T *ptr, size_t count) {
117	this->internal_deallocate(TypeInfo::make<T>(), ptr, count);
118	}
119
120	template<typename T>
121	T *create() {
122	return reinterpret_cast<T *>(this->internal_allocate(TypeInfo::make<T>(), 1));
123	}
124
125	template<typename T>
126	void destroy(T *ptr) {
127	this->internal_deallocate(TypeInfo::make<T>(), ptr, 1);
128	}
129
130	protected:
131	ATTRIBUTE_RETURNS_NOALIAS virtual void *internal_allocate(const TypeInfo &info, size_t count) = 0;
132	ATTRIBUTE_RETURNS_NOALIAS virtual void *internal_allocate_nonzero(const TypeInfo &info, size_t count) = 0;
133	virtual void internal_reallocate(const TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) = 0;
134	virtual void internal_reallocate_nonzero(const TypeInfo &info, void old_ptr, size_t old_count, size_t new_count) = 0;
135	virtual void internal_deallocate(const TypeInfo &info, void *ptr, size_t count) = 0;
136	};
137
138	#ifdef ZIG_ENABLE_MEM_PROFILE
139	void print_report(FILE *file = nullptr);
140
141	// global memory report flag
142	extern bool report_print;
143	// global memory report default destination
144	extern FILE *report_file;
145	#endif
146
147	} // namespace mem
148
149	#endif

src/mem_hash_map.hpp created+244

...	@@ -0,0 +1,244 @@
1	/*
2	* Copyright (c) 2015 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#ifndef ZIG_MEM_HASH_MAP_HPP
9	#define ZIG_MEM_HASH_MAP_HPP
10
11	#include "mem.hpp"
12
13	namespace mem {
14
15	template<typename K, typename V, uint32_t (HashFunction)(K key), bool (EqualFn)(K a, K b)>
16	class HashMap {
17	public:
18	void init(Allocator& allocator, int capacity) {
19	init_capacity(allocator, capacity);
20	}
21	void deinit(Allocator& allocator) {
22	allocator.deallocate(_entries, _capacity);
23	}
24
25	struct Entry {
26	K key;
27	V value;
28	bool used;
29	int distance_from_start_index;
30	};
31
32	void clear() {
33	for (int i = 0; i < _capacity; i += 1) {
34	_entries[i].used = false;
35	}
36	_size = 0;
37	_max_distance_from_start_index = 0;
38	_modification_count += 1;
39	}
40
41	int size() const {
42	return _size;
43	}
44
45	void put(Allocator& allocator, const K &key, const V &value) {
46	_modification_count += 1;
47	internal_put(key, value);
48
49	// if we get too full (60%), double the capacity
50	if (_size * 5 >= _capacity * 3) {
51	Entry *old_entries = _entries;
52	int old_capacity = _capacity;
53	init_capacity(allocator, _capacity * 2);
54	// dump all of the old elements into the new table
55	for (int i = 0; i < old_capacity; i += 1) {
56	Entry *old_entry = &old_entries[i];
57	if (old_entry->used)
58	internal_put(old_entry->key, old_entry->value);
59	}
60	allocator.deallocate(old_entries, old_capacity);
61	}
62	}
63
64	Entry *put_unique(Allocator& allocator, const K &key, const V &value) {
65	// TODO make this more efficient
66	Entry *entry = internal_get(key);
67	if (entry)
68	return entry;
69	put(allocator, key, value);
70	return nullptr;
71	}
72
73	const V &get(const K &key) const {
74	Entry *entry = internal_get(key);
75	if (!entry)
76	zig_panic("key not found");
77	return entry->value;
78	}
79
80	Entry *maybe_get(const K &key) const {
81	return internal_get(key);
82	}
83
84	void maybe_remove(const K &key) {
85	if (maybe_get(key)) {
86	remove(key);
87	}
88	}
89
90	void remove(const K &key) {
91	_modification_count += 1;
92	int start_index = key_to_index(key);
93	for (int roll_over = 0; roll_over <= _max_distance_from_start_index; roll_over += 1) {
94	int index = (start_index + roll_over) % _capacity;
95	Entry *entry = &_entries[index];
96
97	if (!entry->used)
98	zig_panic("key not found");
99
100	if (!EqualFn(entry->key, key))
101	continue;
102
103	for (; roll_over < _capacity; roll_over += 1) {
104	int next_index = (start_index + roll_over + 1) % _capacity;
105	Entry *next_entry = &_entries[next_index];
106	if (!next_entry->used \|\| next_entry->distance_from_start_index == 0) {
107	entry->used = false;
108	_size -= 1;
109	return;
110	}
111	entry = next_entry;
112	entry->distance_from_start_index -= 1;
113	entry = next_entry;
114	}
115	zig_panic("shifting everything in the table");
116	}
117	zig_panic("key not found");
118	}
119
120	class Iterator {
121	public:
122	Entry *next() {
123	if (_inital_modification_count != _table->_modification_count)
124	zig_panic("concurrent modification");
125	if (_count >= _table->size())
126	return NULL;
127	for (; _index < _table->_capacity; _index += 1) {
128	Entry *entry = &_table->_entries[_index];
129	if (entry->used) {
130	_index += 1;
131	_count += 1;
132	return entry;
133	}
134	}
135	zig_panic("no next item");
136	}
137
138	private:
139	const HashMap * _table;
140	// how many items have we returned
141	int _count = 0;
142	// iterator through the entry array
143	int _index = 0;
144	// used to detect concurrent modification
145	uint32_t _inital_modification_count;
146	Iterator(const HashMap * table) :
147	_table(table), _inital_modification_count(table->_modification_count) {
148	}
149	friend HashMap;
150	};
151
152	// you must not modify the underlying HashMap while this iterator is still in use
153	Iterator entry_iterator() const {
154	return Iterator(this);
155	}
156
157	private:
158	Entry *_entries;
159	int _capacity;
160	int _size;
161	int _max_distance_from_start_index;
162	// this is used to detect bugs where a hashtable is edited while an iterator is running.
163	uint32_t _modification_count;
164
165	void init_capacity(Allocator& allocator, int capacity) {
166	_capacity = capacity;
167	_entries = allocator.allocate<Entry>(_capacity);
168	_size = 0;
169	_max_distance_from_start_index = 0;
170	for (int i = 0; i < _capacity; i += 1) {
171	_entries[i].used = false;
172	}
173	}
174
175	void internal_put(K key, V value) {
176	int start_index = key_to_index(key);
177	for (int roll_over = 0, distance_from_start_index = 0;
178	roll_over < _capacity; roll_over += 1, distance_from_start_index += 1)
179	{
180	int index = (start_index + roll_over) % _capacity;
181	Entry *entry = &_entries[index];
182
183	if (entry->used && !EqualFn(entry->key, key)) {
184	if (entry->distance_from_start_index < distance_from_start_index) {
185	// robin hood to the rescue
186	Entry tmp = *entry;
187	if (distance_from_start_index > _max_distance_from_start_index)
188	_max_distance_from_start_index = distance_from_start_index;
189	*entry = {
190	key,
191	value,
192	true,
193	distance_from_start_index,
194	};
195	key = tmp.key;
196	value = tmp.value;
197	distance_from_start_index = tmp.distance_from_start_index;
198	}
199	continue;
200	}
201
202	if (!entry->used) {
203	// adding an entry. otherwise overwriting old value with
204	// same key
205	_size += 1;
206	}
207
208	if (distance_from_start_index > _max_distance_from_start_index)
209	_max_distance_from_start_index = distance_from_start_index;
210	*entry = {
211	key,
212	value,
213	true,
214	distance_from_start_index,
215	};
216	return;
217	}
218	zig_panic("put into a full HashMap");
219	}
220
221
222	Entry *internal_get(const K &key) const {
223	int start_index = key_to_index(key);
224	for (int roll_over = 0; roll_over <= _max_distance_from_start_index; roll_over += 1) {
225	int index = (start_index + roll_over) % _capacity;
226	Entry *entry = &_entries[index];
227
228	if (!entry->used)
229	return NULL;
230
231	if (EqualFn(entry->key, key))
232	return entry;
233	}
234	return NULL;
235	}
236
237	int key_to_index(const K &key) const {
238	return (int)(HashFunction(key) % ((uint32_t)_capacity));
239	}
240	};
241
242	} // namespace mem
243
244	#endif

src/mem_list.hpp created+101

...	@@ -0,0 +1,101 @@
1	/*
2	* Copyright (c) 2015 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#ifndef ZIG_MEM_LIST_HPP
9	#define ZIG_MEM_LIST_HPP
10
11	#include "mem.hpp"
12
13	namespace mem {
14
15	template<typename T>
16	struct List {
17	void deinit(Allocator& allocator) {
18	allocator.deallocate<T>(items, capacity);
19	}
20
21	void append(Allocator& allocator, const T& item) {
22	ensure_capacity(allocator, length + 1);
23	items[length++] = item;
24	}
25
26	// remember that the pointer to this item is invalid after you
27	// modify the length of the list
28	const T & at(size_t index) const {
29	assert(index != SIZE_MAX);
30	assert(index < length);
31	return items[index];
32	}
33
34	T & at(size_t index) {
35	assert(index != SIZE_MAX);
36	assert(index < length);
37	return items[index];
38	}
39
40	T pop() {
41	assert(length >= 1);
42	return items[--length];
43	}
44
45	T *add_one() {
46	resize(length + 1);
47	return &last();
48	}
49
50	const T & last() const {
51	assert(length >= 1);
52	return items[length - 1];
53	}
54
55	T & last() {
56	assert(length >= 1);
57	return items[length - 1];
58	}
59
60	void resize(Allocator& allocator, size_t new_length) {
61	assert(new_length != SIZE_MAX);
62	ensure_capacity(allocator, new_length);
63	length = new_length;
64	}
65
66	void clear() {
67	length = 0;
68	}
69
70	void ensure_capacity(Allocator& allocator, size_t new_capacity) {
71	if (capacity >= new_capacity)
72	return;
73
74	size_t better_capacity = capacity;
75	do {
76	better_capacity = better_capacity * 5 / 2 + 8;
77	} while (better_capacity < new_capacity);
78
79	items = allocator.reallocate_nonzero<T>(items, capacity, better_capacity);
80	capacity = better_capacity;
81	}
82
83	T swap_remove(size_t index) {
84	if (length - 1 == index) return pop();
85
86	assert(index != SIZE_MAX);
87	assert(index < length);
88
89	T old_item = items[index];
90	items[index] = pop();
91	return old_item;
92	}
93
94	T *items{nullptr};
95	size_t length{0};
96	size_t capacity{0};
97	};
98
99	} // namespace mem
100
101	#endif

src/mem_profile.cpp created+181

...	@@ -0,0 +1,181 @@
1	/*
2	* Copyright (c) 2020 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#include "config.h"
9
10	#ifdef ZIG_ENABLE_MEM_PROFILE
11
12	#include "mem.hpp"
13	#include "mem_list.hpp"
14	#include "mem_profile.hpp"
15	#include "heap.hpp"
16
17	namespace mem {
18
19	void Profile::init(const char name, const char kind) {
20	this->name = name;
21	this->kind = kind;
22	this->usage_table.init(heap::bootstrap_allocator, 1024);
23	}
24
25	void Profile::deinit() {
26	assert(this->name != nullptr);
27	if (mem::report_print)
28	this->print_report();
29	this->usage_table.deinit(heap::bootstrap_allocator);
30	this->name = nullptr;
31	}
32
33	void Profile::record_alloc(const TypeInfo &info, size_t count) {
34	if (count == 0) return;
35	auto existing_entry = this->usage_table.put_unique(
36	heap::bootstrap_allocator,
37	UsageKey{info.name_ptr, info.name_len},
38	Entry{info, 1, count, 0, 0} );
39	if (existing_entry != nullptr) {
40	assert(existing_entry->value.info.size == info.size); // allocated name does not match type
41	existing_entry->value.alloc.calls += 1;
42	existing_entry->value.alloc.objects += count;
43	}
44	}
45
46	void Profile::record_dealloc(const TypeInfo &info, size_t count) {
47	if (count == 0) return;
48	auto existing_entry = this->usage_table.maybe_get(UsageKey{info.name_ptr, info.name_len});
49	if (existing_entry == nullptr) {
50	fprintf(stderr, "deallocated name '");
51	for (size_t i = 0; i < info.name_len; ++i)
52	fputc(info.name_ptr[i], stderr);
53	zig_panic("' (size %zu) not found in allocated table; compromised memory usage stats", info.size);
54	}
55	if (existing_entry->value.info.size != info.size) {
56	fprintf(stderr, "deallocated name '");
57	for (size_t i = 0; i < info.name_len; ++i)
58	fputc(info.name_ptr[i], stderr);
59	zig_panic("' does not match expected type size %zu", info.size);
60	}
61	assert(existing_entry->value.alloc.calls - existing_entry->value.dealloc.calls > 0);
62	assert(existing_entry->value.alloc.objects - existing_entry->value.dealloc.objects >= count);
63	existing_entry->value.dealloc.calls += 1;
64	existing_entry->value.dealloc.objects += count;
65	}
66
67	static size_t entry_remain_total_bytes(const Profile::Entry *entry) {
68	return (entry->alloc.objects - entry->dealloc.objects) * entry->info.size;
69	}
70
71	static int entry_compare(const void a, const void b) {
72	size_t total_a = entry_remain_total_bytes(reinterpret_cast<Profile::Entry const *>(a));
73	size_t total_b = entry_remain_total_bytes(reinterpret_cast<Profile::Entry const *>(b));
74	if (total_a > total_b)
75	return -1;
76	if (total_a < total_b)
77	return 1;
78	return 0;
79	};
80
81	void Profile::print_report(FILE *file) {
82	if (!file) {
83	file = report_file;
84	if (!file)
85	file = stderr;
86	}
87	fprintf(file, "\n--- MEMORY PROFILE REPORT [%s]: %s ---\n", this->kind, this->name);
88
89	List<const Entry *> list;
90	auto it = this->usage_table.entry_iterator();
91	for (;;) {
92	auto entry = it.next();
93	if (!entry)
94	break;
95	list.append(heap::bootstrap_allocator, &entry->value);
96	}
97
98	qsort(list.items, list.length, sizeof(const Entry *), entry_compare);
99
100	size_t total_bytes_alloc = 0;
101	size_t total_bytes_dealloc = 0;
102
103	size_t total_calls_alloc = 0;
104	size_t total_calls_dealloc = 0;
105
106	for (size_t i = 0; i < list.length; i += 1) {
107	const Entry *entry = list.at(i);
108	fprintf(file, " ");
109	for (size_t j = 0; j < entry->info.name_len; ++j)
110	fputc(entry->info.name_ptr[j], file);
111	fprintf(file, ": %zu bytes each", entry->info.size);
112
113	fprintf(file, ", alloc{ %zu calls, %zu objects, total ", entry->alloc.calls, entry->alloc.objects);
114	const auto alloc_num_bytes = entry->alloc.objects * entry->info.size;
115	zig_pretty_print_bytes(file, alloc_num_bytes);
116
117	fprintf(file, " }, dealloc{ %zu calls, %zu objects, total ", entry->dealloc.calls, entry->dealloc.objects);
118	const auto dealloc_num_bytes = entry->dealloc.objects * entry->info.size;
119	zig_pretty_print_bytes(file, dealloc_num_bytes);
120
121	fprintf(file, " }, remain{ %zu calls, %zu objects, total ",
122	entry->alloc.calls - entry->dealloc.calls,
123	entry->alloc.objects - entry->dealloc.objects );
124	const auto remain_num_bytes = alloc_num_bytes - dealloc_num_bytes;
125	zig_pretty_print_bytes(file, remain_num_bytes);
126
127	fprintf(file, " }\n");
128
129	total_bytes_alloc += alloc_num_bytes;
130	total_bytes_dealloc += dealloc_num_bytes;
131
132	total_calls_alloc += entry->alloc.calls;
133	total_calls_dealloc += entry->dealloc.calls;
134	}
135
136	fprintf(file, "\n Total bytes allocated: ");
137	zig_pretty_print_bytes(file, total_bytes_alloc);
138	fprintf(file, ", deallocated: ");
139	zig_pretty_print_bytes(file, total_bytes_dealloc);
140	fprintf(file, ", remaining: ");
141	zig_pretty_print_bytes(file, total_bytes_alloc - total_bytes_dealloc);
142
143	fprintf(file, "\n Total calls alloc: %zu, dealloc: %zu, remain: %zu\n",
144	total_calls_alloc, total_calls_dealloc, (total_calls_alloc - total_calls_dealloc));
145
146	list.deinit(heap::bootstrap_allocator);
147	}
148
149	uint32_t Profile::usage_hash(UsageKey key) {
150	// FNV 32-bit hash
151	uint32_t h = 2166136261;
152	for (size_t i = 0; i < key.name_len; ++i) {
153	h = h ^ key.name_ptr[i];
154	h = h * 16777619;
155	}
156	return h;
157	}
158
159	bool Profile::usage_equal(UsageKey a, UsageKey b) {
160	return memcmp(a.name_ptr, b.name_ptr, a.name_len > b.name_len ? a.name_len : b.name_len) == 0;
161	}
162
163	void InternCounters::print_report(FILE *file) {
164	if (!file) {
165	file = report_file;
166	if (!file)
167	file = stderr;
168	}
169	fprintf(file, "\n--- IR INTERNING REPORT ---\n");
170	fprintf(file, " undefined: interned %zu times\n", intern_counters.x_undefined);
171	fprintf(file, " void: interned %zu times\n", intern_counters.x_void);
172	fprintf(file, " null: interned %zu times\n", intern_counters.x_null);
173	fprintf(file, " unreachable: interned %zu times\n", intern_counters.x_unreachable);
174	fprintf(file, " zero_byte: interned %zu times\n", intern_counters.zero_byte);
175	}
176
177	InternCounters intern_counters;
178
179	} // namespace mem
180
181	#endif

src/mem_profile.hpp created+71

...	@@ -0,0 +1,71 @@
1	/*
2	* Copyright (c) 2020 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#ifndef ZIG_MEM_PROFILE_HPP
9	#define ZIG_MEM_PROFILE_HPP
10
11	#include "config.h"
12
13	#ifdef ZIG_ENABLE_MEM_PROFILE
14
15	#include <stdio.h>
16
17	#include "mem.hpp"
18	#include "mem_hash_map.hpp"
19	#include "util.hpp"
20
21	namespace mem {
22
23	struct Profile {
24	void init(const char name, const char kind);
25	void deinit();
26
27	void record_alloc(const TypeInfo &info, size_t count);
28	void record_dealloc(const TypeInfo &info, size_t count);
29
30	void print_report(FILE *file = nullptr);
31
32	struct Entry {
33	TypeInfo info;
34
35	struct Use {
36	size_t calls;
37	size_t objects;
38	} alloc, dealloc;
39	};
40
41	private:
42	const char *name;
43	const char *kind;
44
45	struct UsageKey {
46	const char *name_ptr;
47	size_t name_len;
48	};
49
50	static uint32_t usage_hash(UsageKey key);
51	static bool usage_equal(UsageKey a, UsageKey b);
52
53	HashMap<UsageKey, Entry, usage_hash, usage_equal> usage_table;
54	};
55
56	struct InternCounters {
57	size_t x_undefined;
58	size_t x_void;
59	size_t x_null;
60	size_t x_unreachable;
61	size_t zero_byte;
62
63	void print_report(FILE *file = nullptr);
64	};
65
66	extern InternCounters intern_counters;
67
68	} // namespace mem
69
70	#endif
71	#endif

src/mem_type_info.hpp created+136

...	@@ -0,0 +1,136 @@
1	/*
2	* Copyright (c) 2020 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#ifndef ZIG_MEM_TYPE_INFO_HPP
9	#define ZIG_MEM_TYPE_INFO_HPP
10
11	#include "config.h"
12
13	#ifndef ZIG_TYPE_INFO_IMPLEMENTATION
14	# ifdef ZIG_ENABLE_MEM_PROFILE
15	# define ZIG_TYPE_INFO_IMPLEMENTATION 1
16	# else
17	# define ZIG_TYPE_INFO_IMPLEMENTATION 0
18	# endif
19	#endif
20
21	namespace mem {
22
23	#if ZIG_TYPE_INFO_IMPLEMENTATION == 0
24
25	struct TypeInfo {
26	size_t size;
27	size_t alignment;
28
29	template <typename T>
30	static constexpr TypeInfo make() {
31	return {sizeof(T), alignof(T)};
32	}
33	};
34
35	#elif ZIG_TYPE_INFO_IMPLEMENTATION == 1
36
37	//
38	// A non-portable way to get a human-readable type-name compatible with
39	// non-RTTI C++ compiler mode; eg. `-fno-rtti`.
40	//
41	// Minimum requirements are c++11 and a compiler that has a constant for the
42	// current function's decorated name whereby a template-type name can be
43	// computed. eg. `__PRETTY_FUNCTION__` or `__FUNCSIG__`.
44	//
45	// given the following snippet:
46	//
47	// \| #include <stdio.h>
48	// \|
49	// \| struct Top {};
50	// \| namespace mynamespace {
51	// \| using custom = unsigned int;
52	// \| struct Foo {
53	// \| struct Bar {};
54	// \| };
55	// \| };
56	// \|
57	// \| template <typename T>
58	// \| void foobar() {
59	// \| #ifdef _MSC_VER
60	// \| fprintf(stderr, "--> %s\n", __FUNCSIG__);
61	// \| #else
62	// \| fprintf(stderr, "--> %s\n", __PRETTY_FUNCTION__);
63	// \| #endif
64	// \| }
65	// \|
66	// \| int main() {
67	// \| foobar<Top>();
68	// \| foobar<unsigned int>();
69	// \| foobar<mynamespace::custom>();
70	// \| foobar<mynamespace::Foo*>();
71	// \| foobar<mynamespace::Foo::Bar*>();
72	// \| }
73	//
74	// gcc 9.2.0 produces:
75	// --> void foobar() [with T = Top]
76	// --> void foobar() [with T = unsigned int]
77	// --> void foobar() [with T = unsigned int]
78	// --> void foobar() [with T = mynamespace::Foo*]
79	// --> void foobar() [with T = mynamespace::Foo::Bar*]
80	//
81	// xcode 11.3.1/clang produces:
82	// --> void foobar() [T = Top]
83	// --> void foobar() [T = unsigned int]
84	// --> void foobar() [T = unsigned int]
85	// --> void foobar() [T = mynamespace::Foo *]
86	// --> void foobar() [T = mynamespace::Foo::Bar *]
87	//
88	// VStudio 2019 16.5.0/msvc produces:
89	// --> void __cdecl foobar<struct Top>(void)
90	// --> void __cdecl foobar<unsigned int>(void)
91	// --> void __cdecl foobar<unsigned int>(void)
92	// --> void __cdecl foobar<structmynamespace::Foo*>(void)
93	// --> void __cdecl foobar<structmynamespace::Foo::Bar*>(void)
94	//
95	struct TypeInfo {
96	const char *name_ptr;
97	size_t name_len;
98	size_t size;
99	size_t alignment;
100
101	static constexpr TypeInfo to_type_info(const char *str, size_t start, size_t end, size_t size, size_t alignment) {
102	return TypeInfo{str + start, end - start, size, alignment};
103	}
104
105	static constexpr size_t index_of(const char *str, char c) {
106	return *str == c ? 0 : 1 + index_of(str + 1, c);
107	}
108
109	template <typename T>
110	static constexpr const char *decorated_name() {
111	#ifdef _MSC_VER
112	return __FUNCSIG__;
113	#else
114	return __PRETTY_FUNCTION__;
115	#endif
116	}
117
118	static constexpr TypeInfo extract(const char *decorated, size_t size, size_t alignment) {
119	#ifdef _MSC_VER
120	return to_type_info(decorated, index_of(decorated, '<') + 1, index_of(decorated, '>'), size, alignment);
121	#else
122	return to_type_info(decorated, index_of(decorated, '=') + 2, index_of(decorated, ']'), size, alignment);
123	#endif
124	}
125
126	template <typename T>
127	static constexpr TypeInfo make() {
128	return TypeInfo::extract(TypeInfo::decorated_name<T>(), sizeof(T), alignof(T));
129	}
130	};
131
132	#endif // ZIG_TYPE_INFO_IMPLEMENTATION
133
134	} // namespace mem
135
136	#endif

src/memory_profiling.cpp deleted-150

...	@@ -1,150 +0,0 @@
1	#include "memory_profiling.hpp"
2	#include "hash_map.hpp"
3	#include "list.hpp"
4	#include "util.hpp"
5	#include <string.h>
6
7	#ifdef ZIG_ENABLE_MEM_PROFILE
8
9	MemprofInternCount memprof_intern_count;
10
11	static bool str_eql_str(const char a, const char b) {
12	return strcmp(a, b) == 0;
13	}
14
15	static uint32_t str_hash(const char *s) {
16	// FNV 32-bit hash
17	uint32_t h = 2166136261;
18	for (; *s; s += 1) {
19	h = h ^ *s;
20	h = h * 16777619;
21	}
22	return h;
23	}
24
25	struct CountAndSize {
26	size_t item_count;
27	size_t type_size;
28	};
29
30	ZigList<const char *> unknown_names = {};
31	HashMap<const char *, CountAndSize, str_hash, str_eql_str> usage_table = {};
32	bool table_active = false;
33
34	static const char get_default_name(const char name_or_null, size_t type_size) {
35	if (name_or_null != nullptr) return name_or_null;
36	if (type_size >= unknown_names.length) {
37	table_active = false;
38	while (type_size >= unknown_names.length) {
39	unknown_names.append(nullptr);
40	}
41	table_active = true;
42	}
43	if (unknown_names.at(type_size) == nullptr) {
44	char buf[100];
45	sprintf(buf, "Unknown_%zu%c", type_size, 0);
46	unknown_names.at(type_size) = strdup(buf);
47	}
48	return unknown_names.at(type_size);
49	}
50
51	void memprof_alloc(const char *name, size_t count, size_t type_size) {
52	if (!table_active) return;
53	if (count == 0) return;
54	// temporarily disable during table put
55	table_active = false;
56	name = get_default_name(name, type_size);
57	auto existing_entry = usage_table.put_unique(name, {count, type_size});
58	if (existing_entry != nullptr) {
59	assert(existing_entry->value.type_size == type_size); // allocated name does not match type
60	existing_entry->value.item_count += count;
61	}
62	table_active = true;
63	}
64
65	void memprof_dealloc(const char *name, size_t count, size_t type_size) {
66	if (!table_active) return;
67	if (count == 0) return;
68	name = get_default_name(name, type_size);
69	auto existing_entry = usage_table.maybe_get(name);
70	if (existing_entry == nullptr) {
71	zig_panic("deallocated name '%s' (size %zu) not found in allocated table; compromised memory usage stats",
72	name, type_size);
73	}
74	if (existing_entry->value.type_size != type_size) {
75	zig_panic("deallocated name '%s' does not match expected type size %zu", name, type_size);
76	}
77	existing_entry->value.item_count -= count;
78	}
79
80	void memprof_init(void) {
81	usage_table.init(1024);
82	table_active = true;
83	}
84
85	struct MemItem {
86	const char *type_name;
87	CountAndSize count_and_size;
88	};
89
90	static size_t get_bytes(const MemItem *item) {
91	return item->count_and_size.item_count * item->count_and_size.type_size;
92	}
93
94	static int compare_bytes_desc(const void a, const void b) {
95	size_t size_a = get_bytes((const MemItem *)(a));
96	size_t size_b = get_bytes((const MemItem *)(b));
97	if (size_a > size_b)
98	return -1;
99	if (size_a < size_b)
100	return 1;
101	return 0;
102	}
103
104	void memprof_dump_stats(FILE *file) {
105	assert(table_active);
106	// disable modifications from this function
107	table_active = false;
108
109	ZigList<MemItem> list = {};
110
111	auto it = usage_table.entry_iterator();
112	for (;;) {
113	auto *entry = it.next();
114	if (!entry)
115	break;
116
117	list.append({entry->key, entry->value});
118	}
119
120	qsort(list.items, list.length, sizeof(MemItem), compare_bytes_desc);
121
122	size_t total_bytes_used = 0;
123
124	for (size_t i = 0; i < list.length; i += 1) {
125	const MemItem *item = &list.at(i);
126	fprintf(file, "%s: %zu items, %zu bytes each, total ", item->type_name,
127	item->count_and_size.item_count, item->count_and_size.type_size);
128	size_t bytes = get_bytes(item);
129	zig_pretty_print_bytes(file, bytes);
130	fprintf(file, "\n");
131
132	total_bytes_used += bytes;
133	}
134
135	fprintf(stderr, "Total bytes used: ");
136	zig_pretty_print_bytes(file, total_bytes_used);
137	fprintf(file, "\n");
138
139	list.deinit();
140	table_active = true;
141
142	fprintf(stderr, "\n");
143	fprintf(stderr, "undefined: interned %zu times\n", memprof_intern_count.x_undefined);
144	fprintf(stderr, "void: interned %zu times\n", memprof_intern_count.x_void);
145	fprintf(stderr, "null: interned %zu times\n", memprof_intern_count.x_null);
146	fprintf(stderr, "unreachable: interned %zu times\n", memprof_intern_count.x_unreachable);
147	fprintf(stderr, "zero_byte: interned %zu times\n", memprof_intern_count.zero_byte);
148	}
149
150	#endif

src/memory_profiling.hpp deleted-31

...	@@ -1,31 +0,0 @@
1	/*
2	* Copyright (c) 2019 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#ifndef ZIG_MEMORY_PROFILING_HPP
9	#define ZIG_MEMORY_PROFILING_HPP
10
11	#include "config.h"
12
13	#include <stddef.h>
14	#include <stdio.h>
15
16	struct MemprofInternCount {
17	size_t x_undefined;
18	size_t x_void;
19	size_t x_null;
20	size_t x_unreachable;
21	size_t zero_byte;
22	};
23	extern MemprofInternCount memprof_intern_count;
24
25	void memprof_init(void);
26
27	void memprof_alloc(const char *name, size_t item_count, size_t type_size);
28	void memprof_dealloc(const char *name, size_t item_count, size_t type_size);
29
30	void memprof_dump_stats(FILE *file);
31	#endif

src/os.cpp+7-7

...	@@ -107,7 +107,7 @@ static void populate_termination(Termination *term, int status) {	...	@@ -107,7 +107,7 @@ static void populate_termination(Termination *term, int status) {
107	}	107	}
108		108
109	static void os_spawn_process_posix(ZigList<const char > &args, Termination term) {	109	static void os_spawn_process_posix(ZigList<const char > &args, Termination term) {
110	const char *argv = allocate<const char >(args.length + 1);	110	const char *argv = heap::c_allocator.allocate<const char >(args.length + 1);
111	for (size_t i = 0; i < args.length; i += 1) {	111	for (size_t i = 0; i < args.length; i += 1) {
112	argv[i] = args.at(i);	112	argv[i] = args.at(i);
113	}	113	}
...	@@ -688,7 +688,7 @@ static Buf os_path_resolve_posix(Buf **paths_ptr, size_t paths_len) {	...	@@ -688,7 +688,7 @@ static Buf os_path_resolve_posix(Buf **paths_ptr, size_t paths_len) {
688		688
689	if (have_abs) {	689	if (have_abs) {
690	result_len = max_size;	690	result_len = max_size;
691	result_ptr = allocate_nonzero<uint8_t>(result_len);	691	result_ptr = heap::c_allocator.allocate_nonzero<uint8_t>(result_len);
692	} else {	692	} else {
693	Buf cwd = BUF_INIT;	693	Buf cwd = BUF_INIT;
694	int err;	694	int err;
...	@@ -696,7 +696,7 @@ static Buf os_path_resolve_posix(Buf **paths_ptr, size_t paths_len) {	...	@@ -696,7 +696,7 @@ static Buf os_path_resolve_posix(Buf **paths_ptr, size_t paths_len) {
696	zig_panic("get cwd failed");	696	zig_panic("get cwd failed");
697	}	697	}
698	result_len = max_size + buf_len(&cwd) + 1;	698	result_len = max_size + buf_len(&cwd) + 1;
699	result_ptr = allocate_nonzero<uint8_t>(result_len);	699	result_ptr = heap::c_allocator.allocate_nonzero<uint8_t>(result_len);
700	memcpy(result_ptr, buf_ptr(&cwd), buf_len(&cwd));	700	memcpy(result_ptr, buf_ptr(&cwd), buf_len(&cwd));
701	result_index += buf_len(&cwd);	701	result_index += buf_len(&cwd);
702	}	702	}
...	@@ -816,7 +816,7 @@ static Error os_exec_process_posix(ZigList<const char *> &args,	...	@@ -816,7 +816,7 @@ static Error os_exec_process_posix(ZigList<const char *> &args,
816	if (dup2(stderr_pipe[1], STDERR_FILENO) == -1)	816	if (dup2(stderr_pipe[1], STDERR_FILENO) == -1)
817	zig_panic("dup2 failed");	817	zig_panic("dup2 failed");
818		818
819	const char *argv = allocate<const char >(args.length + 1);	819	const char *argv = heap::c_allocator.allocate<const char >(args.length + 1);
820	argv[args.length] = nullptr;	820	argv[args.length] = nullptr;
821	for (size_t i = 0; i < args.length; i += 1) {	821	for (size_t i = 0; i < args.length; i += 1) {
822	argv[i] = args.at(i);	822	argv[i] = args.at(i);
...	@@ -1134,7 +1134,7 @@ static bool is_stderr_cyg_pty(void) {	...	@@ -1134,7 +1134,7 @@ static bool is_stderr_cyg_pty(void) {
1134	if (stderr_handle == INVALID_HANDLE_VALUE)	1134	if (stderr_handle == INVALID_HANDLE_VALUE)
1135	return false;	1135	return false;
1136		1136
1137	int size = sizeof(FILE_NAME_INFO) + sizeof(WCHAR) * MAX_PATH;	1137	const int size = sizeof(FILE_NAME_INFO) + sizeof(WCHAR) * MAX_PATH;
1138	FILE_NAME_INFO *nameinfo;	1138	FILE_NAME_INFO *nameinfo;
1139	WCHAR *p = NULL;	1139	WCHAR *p = NULL;
1140		1140
...	@@ -1142,7 +1142,7 @@ static bool is_stderr_cyg_pty(void) {	...	@@ -1142,7 +1142,7 @@ static bool is_stderr_cyg_pty(void) {
1142	if (GetFileType(stderr_handle) != FILE_TYPE_PIPE) {	1142	if (GetFileType(stderr_handle) != FILE_TYPE_PIPE) {
1143	return 0;	1143	return 0;
1144	}	1144	}
1145	nameinfo = (FILE_NAME_INFO *)allocate<char>(size);	1145	nameinfo = reinterpret_cast<FILE_NAME_INFO *>(heap::c_allocator.allocate<char>(size));
1146	if (nameinfo == NULL) {	1146	if (nameinfo == NULL) {
1147	return 0;	1147	return 0;
1148	}	1148	}
...	@@ -1179,7 +1179,7 @@ static bool is_stderr_cyg_pty(void) {	...	@@ -1179,7 +1179,7 @@ static bool is_stderr_cyg_pty(void) {
1179	}	1179	}
1180	}	1180	}
1181	}	1181	}
1182	free(nameinfo);	1182	heap::c_allocator.deallocate(reinterpret_cast<char *>(nameinfo), size);
1183	return (p != NULL);	1183	return (p != NULL);
1184	}	1184	}
1185	#endif	1185	#endif

src/parser.cpp+3-3

src/target.cpp+1-1

...	@@ -520,7 +520,7 @@ void get_native_target(ZigTarget *target) {	...	@@ -520,7 +520,7 @@ void get_native_target(ZigTarget *target) {
520	target->abi = target_default_abi(target->arch, target->os);	520	target->abi = target_default_abi(target->arch, target->os);
521	}	521	}
522	if (target_is_glibc(target)) {	522	if (target_is_glibc(target)) {
523	target->glibc_version = allocate<ZigGLibCVersion>(1);	523	target->glibc_version = heap::c_allocator.create<ZigGLibCVersion>();
524	target_init_default_glibc_version(target);	524	target_init_default_glibc_version(target);
525	#ifdef ZIG_OS_LINUX	525	#ifdef ZIG_OS_LINUX
526	Error err;	526	Error err;

src/tokenizer.cpp+2-2

...	@@ -397,10 +397,10 @@ static void invalid_char_error(Tokenize *t, uint8_t c) {	...	@@ -397,10 +397,10 @@ static void invalid_char_error(Tokenize *t, uint8_t c) {
397	void tokenize(Buf buf, Tokenization out) {	397	void tokenize(Buf buf, Tokenization out) {
398	Tokenize t = {0};	398	Tokenize t = {0};
399	t.out = out;	399	t.out = out;
400	t.tokens = out->tokens = allocate<ZigList<Token>>(1);	400	t.tokens = out->tokens = heap::c_allocator.create<ZigList<Token>>();
401	t.buf = buf;	401	t.buf = buf;
402		402
403	out->line_offsets = allocate<ZigList<size_t>>(1);	403	out->line_offsets = heap::c_allocator.create<ZigList<size_t>>();
404	out->line_offsets->append(0);	404	out->line_offsets->append(0);
405		405
406	// Skip the UTF-8 BOM if present	406	// Skip the UTF-8 BOM if present

src/userland.cpp+2-2

...	@@ -101,7 +101,7 @@ Error stage2_cpu_features_parse(struct Stage2CpuFeatures *out, const char zig_	...	@@ -101,7 +101,7 @@ Error stage2_cpu_features_parse(struct Stage2CpuFeatures *out, const char zig_
101	const char cpu_name, const char cpu_features)	101	const char cpu_name, const char cpu_features)
102	{	102	{
103	if (zig_triple == nullptr) {	103	if (zig_triple == nullptr) {
104	Stage2CpuFeatures *result = allocate<Stage2CpuFeatures>(1, "Stage2CpuFeatures");	104	Stage2CpuFeatures *result = heap::c_allocator.create<Stage2CpuFeatures>();
105	result->llvm_cpu_name = ZigLLVMGetHostCPUName();	105	result->llvm_cpu_name = ZigLLVMGetHostCPUName();
106	result->llvm_cpu_features = ZigLLVMGetNativeFeatures();	106	result->llvm_cpu_features = ZigLLVMGetNativeFeatures();
107	result->builtin_str = "arch.getBaselineCpuFeatures();\n";	107	result->builtin_str = "arch.getBaselineCpuFeatures();\n";
...	@@ -110,7 +110,7 @@ Error stage2_cpu_features_parse(struct Stage2CpuFeatures *out, const char zig_	...	@@ -110,7 +110,7 @@ Error stage2_cpu_features_parse(struct Stage2CpuFeatures *out, const char zig_
110	return ErrorNone;	110	return ErrorNone;
111	}	111	}
112	if (cpu_name == nullptr && cpu_features == nullptr) {	112	if (cpu_name == nullptr && cpu_features == nullptr) {
113	Stage2CpuFeatures *result = allocate<Stage2CpuFeatures>(1, "Stage2CpuFeatures");	113	Stage2CpuFeatures *result = heap::c_allocator.create<Stage2CpuFeatures>();
114	result->builtin_str = "arch.getBaselineCpuFeatures();\n";	114	result->builtin_str = "arch.getBaselineCpuFeatures();\n";
115	result->cache_hash = "\n\n";	115	result->cache_hash = "\n\n";
116	*out = result;	116	*out = result;

src/util.hpp+5-127

...	@@ -8,69 +8,19 @@	...	@@ -8,69 +8,19 @@
8	#ifndef ZIG_UTIL_HPP	8	#ifndef ZIG_UTIL_HPP
9	#define ZIG_UTIL_HPP	9	#define ZIG_UTIL_HPP
10		10
11	#include "memory_profiling.hpp"
12
13	#include <stdlib.h>	11	#include <stdlib.h>
14	#include <stdint.h>	12	#include <stdint.h>
15	#include <string.h>	13	#include <string.h>
16	#include <assert.h>
17	#include <ctype.h>	14	#include <ctype.h>
18		15
19	#if defined(_MSC_VER)	16	#if defined(_MSC_VER)
20
21	#include <intrin.h>	17	#include <intrin.h>
22
23	#define ATTRIBUTE_COLD __declspec(noinline)
24	#define ATTRIBUTE_PRINTF(a, b)
25	#define ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
26	#define ATTRIBUTE_NORETURN __declspec(noreturn)
27	#define ATTRIBUTE_MUST_USE
28
29	#define BREAKPOINT __debugbreak()
30
31	#else
32
33	#define ATTRIBUTE_COLD __attribute__((cold))
34	#define ATTRIBUTE_PRINTF(a, b) __attribute__((format(printf, a, b)))
35	#define ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
36	#define ATTRIBUTE_NORETURN __attribute__((noreturn))
37	#define ATTRIBUTE_MUST_USE __attribute__((warn_unused_result))
38
39	#if defined(__MINGW32__) \|\| defined(__MINGW64__)
40	#define BREAKPOINT __debugbreak()
41	#elif defined(__i386__) \|\| defined(__x86_64__)
42	#define BREAKPOINT __asm__ volatile("int $0x03");
43	#elif defined(__clang__)
44	#define BREAKPOINT __builtin_debugtrap()
45	#elif defined(__GNUC__)
46	#define BREAKPOINT __builtin_trap()
47	#else
48	#include <signal.h>
49	#define BREAKPOINT raise(SIGTRAP)
50	#endif
51
52	#endif
53
54	ATTRIBUTE_COLD
55	ATTRIBUTE_NORETURN
56	ATTRIBUTE_PRINTF(1, 2)
57	void zig_panic(const char *format, ...);
58
59	static inline void zig_assert(bool ok, const char file, int line, const char func) {
60	if (!ok) {
61	zig_panic("Assertion failed at %s:%d in %s. This is a bug in the Zig compiler.", file, line, func);
62	}
63	}
64
65	#ifdef _WIN32
66	#define __func__ __FUNCTION__
67	#endif	18	#endif
68		19
69	#define zig_unreachable() zig_panic("Unreachable at %s:%d in %s. This is a bug in the Zig compiler.", __FILE__, __LINE__, __func__)	20	#include "config.h"
70		21	#include "util_base.hpp"
71	// Assertions in stage1 are always on, and they call zig @panic.	22	#include "heap.hpp"
72	#undef assert	23	#include "mem.hpp"
73	#define assert(ok) zig_assert(ok, __FILE__, __LINE__, __func__)
74		24
75	#if defined(_MSC_VER)	25	#if defined(_MSC_VER)
76	static inline int clzll(unsigned long long mask) {	26	static inline int clzll(unsigned long long mask) {
...	@@ -107,78 +57,6 @@ static inline int ctzll(unsigned long long mask) {	...	@@ -107,78 +57,6 @@ static inline int ctzll(unsigned long long mask) {
107	#define ctzll(x) __builtin_ctzll(x)	57	#define ctzll(x) __builtin_ctzll(x)
108	#endif	58	#endif
109		59
110
111	template<typename T>
112	ATTRIBUTE_RETURNS_NOALIAS static inline T allocate_nonzero(size_t count, const char name = nullptr) {
113	#ifdef ZIG_ENABLE_MEM_PROFILE
114	memprof_alloc(name, count, sizeof(T));
115	#endif
116	#ifndef NDEBUG
117	// make behavior when size == 0 portable
118	if (count == 0)
119	return nullptr;
120	#endif
121	T ptr = reinterpret_cast<T>(malloc(count * sizeof(T)));
122	if (!ptr)
123	zig_panic("allocation failed");
124	return ptr;
125	}
126
127	template<typename T>
128	ATTRIBUTE_RETURNS_NOALIAS static inline T allocate(size_t count, const char name = nullptr) {
129	#ifdef ZIG_ENABLE_MEM_PROFILE
130	memprof_alloc(name, count, sizeof(T));
131	#endif
132	#ifndef NDEBUG
133	// make behavior when size == 0 portable
134	if (count == 0)
135	return nullptr;
136	#endif
137	T ptr = reinterpret_cast<T>(calloc(count, sizeof(T)));
138	if (!ptr)
139	zig_panic("allocation failed");
140	return ptr;
141	}
142
143	template<typename T>
144	static inline T reallocate(T old, size_t old_count, size_t new_count, const char *name = nullptr) {
145	T *ptr = reallocate_nonzero(old, old_count, new_count);
146	if (new_count > old_count) {
147	memset(&ptr[old_count], 0, (new_count - old_count) * sizeof(T));
148	}
149	return ptr;
150	}
151
152	template<typename T>
153	static inline T reallocate_nonzero(T old, size_t old_count, size_t new_count, const char *name = nullptr) {
154	#ifdef ZIG_ENABLE_MEM_PROFILE
155	memprof_dealloc(name, old_count, sizeof(T));
156	memprof_alloc(name, new_count, sizeof(T));
157	#endif
158	#ifndef NDEBUG
159	// make behavior when size == 0 portable
160	if (new_count == 0 && old == nullptr)
161	return nullptr;
162	#endif
163	T ptr = reinterpret_cast<T>(realloc(old, new_count * sizeof(T)));
164	if (!ptr)
165	zig_panic("allocation failed");
166	return ptr;
167	}
168
169	template<typename T>
170	static inline void deallocate(T old, size_t count, const char name = nullptr) {
171	#ifdef ZIG_ENABLE_MEM_PROFILE
172	memprof_dealloc(name, count, sizeof(T));
173	#endif
174	free(old);
175	}
176
177	template<typename T>
178	static inline void destroy(T old, const char name = nullptr) {
179	return deallocate(old, 1, name);
180	}
181
182	template <typename T, size_t n>	60	template <typename T, size_t n>
183	constexpr size_t array_length(const T (&)[n]) {	61	constexpr size_t array_length(const T (&)[n]) {
184	return n;	62	return n;
...	@@ -293,7 +171,7 @@ struct Slice {	...	@@ -293,7 +171,7 @@ struct Slice {
293	}	171	}
294		172
295	static inline Slice<T> alloc(size_t n) {	173	static inline Slice<T> alloc(size_t n) {
296	return {allocate_nonzero<T>(n), n};	174	return {heap::c_allocator.allocate_nonzero<T>(n), n};
297	}	175	}
298	};	176	};
299		177

src/util_base.hpp created+67

...	@@ -0,0 +1,67 @@
1	/*
2	* Copyright (c) 2015 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#ifndef ZIG_UTIL_BASE_HPP
9	#define ZIG_UTIL_BASE_HPP
10
11	#include <assert.h>
12
13	#if defined(_MSC_VER)
14
15	#define ATTRIBUTE_COLD __declspec(noinline)
16	#define ATTRIBUTE_PRINTF(a, b)
17	#define ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
18	#define ATTRIBUTE_NORETURN __declspec(noreturn)
19	#define ATTRIBUTE_MUST_USE
20
21	#define BREAKPOINT __debugbreak()
22
23	#else
24
25	#define ATTRIBUTE_COLD __attribute__((cold))
26	#define ATTRIBUTE_PRINTF(a, b) __attribute__((format(printf, a, b)))
27	#define ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
28	#define ATTRIBUTE_NORETURN __attribute__((noreturn))
29	#define ATTRIBUTE_MUST_USE __attribute__((warn_unused_result))
30
31	#if defined(__MINGW32__) \|\| defined(__MINGW64__)
32	#define BREAKPOINT __debugbreak()
33	#elif defined(__i386__) \|\| defined(__x86_64__)
34	#define BREAKPOINT __asm__ volatile("int $0x03");
35	#elif defined(__clang__)
36	#define BREAKPOINT __builtin_debugtrap()
37	#elif defined(__GNUC__)
38	#define BREAKPOINT __builtin_trap()
39	#else
40	#include <signal.h>
41	#define BREAKPOINT raise(SIGTRAP)
42	#endif
43
44	#endif
45
46	ATTRIBUTE_COLD
47	ATTRIBUTE_NORETURN
48	ATTRIBUTE_PRINTF(1, 2)
49	void zig_panic(const char *format, ...);
50
51	static inline void zig_assert(bool ok, const char file, int line, const char func) {
52	if (!ok) {
53	zig_panic("Assertion failed at %s:%d in %s. This is a bug in the Zig compiler.", file, line, func);
54	}
55	}
56
57	#ifdef _WIN32
58	#define __func__ __FUNCTION__
59	#endif
60
61	#define zig_unreachable() zig_panic("Unreachable at %s:%d in %s. This is a bug in the Zig compiler.", __FILE__, __LINE__, __func__)
62
63	// Assertions in stage1 are always on, and they call zig @panic.
64	#undef assert
65	#define assert(ok) zig_assert(ok, __FILE__, __LINE__, __func__)
66
67	#endif

...	@@ -93,7 +93,7 @@ static void to_twos_complement(BigInt dest, const BigInt op, size_t bit_count)	...	@@ -93,7 +93,7 @@ static void to_twos_complement(BigInt dest, const BigInt op, size_t bit_count)
93	if (dest->data.digit == 0) dest->digit_count = 0;	93	if (dest->data.digit == 0) dest->digit_count = 0;
94	return;	94	return;
95	}	95	}
96	dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);	96	dest->data.digits = heap::c_allocator.allocate_nonzero<uint64_t>(dest->digit_count);
97	for (size_t i = 0; i < digits_to_copy; i += 1) {	97	for (size_t i = 0; i < digits_to_copy; i += 1) {
98	uint64_t digit = (i < op->digit_count) ? op_digits[i] : 0;	98	uint64_t digit = (i < op->digit_count) ? op_digits[i] : 0;
99	dest->data.digits[i] = digit;	99	dest->data.digits[i] = digit;
...	@@ -174,7 +174,7 @@ void bigint_init_data(BigInt dest, const uint64_t digits, size_t digit_count,	...	@@ -174,7 +174,7 @@ void bigint_init_data(BigInt dest, const uint64_t digits, size_t digit_count,
174		174
175	dest->digit_count = digit_count;	175	dest->digit_count = digit_count;
176	dest->is_negative = is_negative;	176	dest->is_negative = is_negative;
177	dest->data.digits = allocate_nonzero<uint64_t>(digit_count);	177	dest->data.digits = heap::c_allocator.allocate_nonzero<uint64_t>(digit_count);
178	memcpy(dest->data.digits, digits, sizeof(uint64_t) * digit_count);	178	memcpy(dest->data.digits, digits, sizeof(uint64_t) * digit_count);
179		179
180	bigint_normalize(dest);	180	bigint_normalize(dest);
...	@@ -191,13 +191,13 @@ void bigint_init_bigint(BigInt dest, const BigInt src) {	...	@@ -191,13 +191,13 @@ void bigint_init_bigint(BigInt dest, const BigInt src) {
191	}	191	}
192	dest->is_negative = src->is_negative;	192	dest->is_negative = src->is_negative;
193	dest->digit_count = src->digit_count;	193	dest->digit_count = src->digit_count;
194	dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);	194	dest->data.digits = heap::c_allocator.allocate_nonzero<uint64_t>(dest->digit_count);
195	memcpy(dest->data.digits, src->data.digits, sizeof(uint64_t) * dest->digit_count);	195	memcpy(dest->data.digits, src->data.digits, sizeof(uint64_t) * dest->digit_count);
196	}	196	}
197		197
198	void bigint_deinit(BigInt *bi) {	198	void bigint_deinit(BigInt *bi) {
199	if (bi->digit_count > 1)	199	if (bi->digit_count > 1)
200	deallocate<uint64_t>(bi->data.digits, bi->digit_count);	200	heap::c_allocator.deallocate(bi->data.digits, bi->digit_count);
201	}	201	}
202		202
203	void bigint_init_bigfloat(BigInt dest, const BigFloat op) {	203	void bigint_init_bigfloat(BigInt dest, const BigFloat op) {
...	@@ -227,7 +227,7 @@ void bigint_init_bigfloat(BigInt dest, const BigFloat op) {	...	@@ -227,7 +227,7 @@ void bigint_init_bigfloat(BigInt dest, const BigFloat op) {
227	f128M_rem(&abs_val, &max_u64, &remainder);	227	f128M_rem(&abs_val, &max_u64, &remainder);
228		228
229	dest->digit_count = 2;	229	dest->digit_count = 2;
230	dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);	230	dest->data.digits = heap::c_allocator.allocate_nonzero<uint64_t>(dest->digit_count);
231	dest->data.digits[0] = f128M_to_ui64(&remainder, softfloat_round_minMag, false);	231	dest->data.digits[0] = f128M_to_ui64(&remainder, softfloat_round_minMag, false);
232	dest->data.digits[1] = f128M_to_ui64(&amt, softfloat_round_minMag, false);	232	dest->data.digits[1] = f128M_to_ui64(&amt, softfloat_round_minMag, false);
233	bigint_normalize(dest);	233	bigint_normalize(dest);
...	@@ -345,7 +345,7 @@ void bigint_read_twos_complement(BigInt dest, const uint8_t buf, size_t bit_co	...	@@ -345,7 +345,7 @@ void bigint_read_twos_complement(BigInt dest, const uint8_t buf, size_t bit_co
345	if (dest->digit_count == 1) {	345	if (dest->digit_count == 1) {
346	digits = &dest->data.digit;	346	digits = &dest->data.digit;
347	} else {	347	} else {
348	digits = allocate_nonzero<uint64_t>(dest->digit_count);	348	digits = heap::c_allocator.allocate_nonzero<uint64_t>(dest->digit_count);
349	dest->data.digits = digits;	349	dest->data.digits = digits;
350	}	350	}
351		351
...	@@ -464,7 +464,7 @@ void bigint_add(BigInt dest, const BigInt op1, const BigInt *op2) {	...	@@ -464,7 +464,7 @@ void bigint_add(BigInt dest, const BigInt op1, const BigInt *op2) {
464	}	464	}
465	size_t i = 1;	465	size_t i = 1;
466	uint64_t first_digit = dest->data.digit;	466	uint64_t first_digit = dest->data.digit;
467	dest->data.digits = allocate_nonzero<uint64_t>(max(op1->digit_count, op2->digit_count) + 1);	467	dest->data.digits = heap::c_allocator.allocate_nonzero<uint64_t>(max(op1->digit_count, op2->digit_count) + 1);
468	dest->data.digits[0] = first_digit;	468	dest->data.digits[0] = first_digit;
469		469
470	for (;;) {	470	for (;;) {
...	@@ -532,7 +532,7 @@ void bigint_add(BigInt dest, const BigInt op1, const BigInt *op2) {	...	@@ -532,7 +532,7 @@ void bigint_add(BigInt dest, const BigInt op1, const BigInt *op2) {
532	return;	532	return;
533	}	533	}
534	uint64_t first_digit = dest->data.digit;	534	uint64_t first_digit = dest->data.digit;
535	dest->data.digits = allocate_nonzero<uint64_t>(bigger_op->digit_count);	535	dest->data.digits = heap::c_allocator.allocate_nonzero<uint64_t>(bigger_op->digit_count);
536	dest->data.digits[0] = first_digit;	536	dest->data.digits[0] = first_digit;
537	size_t i = 1;	537	size_t i = 1;
538		538
...	@@ -1032,7 +1032,7 @@ static void bigint_unsigned_division(const BigInt op1, const BigInt op2, BigIn	...	@@ -1032,7 +1032,7 @@ static void bigint_unsigned_division(const BigInt op1, const BigInt op2, BigIn
1032	if (lhsWords == 1) {	1032	if (lhsWords == 1) {
1033	Quotient->data.digit = Make_64(Q[1], Q[0]);	1033	Quotient->data.digit = Make_64(Q[1], Q[0]);
1034	} else {	1034	} else {
1035	Quotient->data.digits = allocate<uint64_t>(lhsWords);	1035	Quotient->data.digits = heap::c_allocator.allocate<uint64_t>(lhsWords);
1036	for (size_t i = 0; i < lhsWords; i += 1) {	1036	for (size_t i = 0; i < lhsWords; i += 1) {
1037	Quotient->data.digits[i] = Make_64(Q[i2+1], Q[i2]);	1037	Quotient->data.digits[i] = Make_64(Q[i2+1], Q[i2]);
1038	}	1038	}
...	@@ -1046,7 +1046,7 @@ static void bigint_unsigned_division(const BigInt op1, const BigInt op2, BigIn	...	@@ -1046,7 +1046,7 @@ static void bigint_unsigned_division(const BigInt op1, const BigInt op2, BigIn
1046	if (rhsWords == 1) {	1046	if (rhsWords == 1) {
1047	Remainder->data.digit = Make_64(R[1], R[0]);	1047	Remainder->data.digit = Make_64(R[1], R[0]);
1048	} else {	1048	} else {
1049	Remainder->data.digits = allocate<uint64_t>(rhsWords);	1049	Remainder->data.digits = heap::c_allocator.allocate<uint64_t>(rhsWords);
1050	for (size_t i = 0; i < rhsWords; i += 1) {	1050	for (size_t i = 0; i < rhsWords; i += 1) {
1051	Remainder->data.digits[i] = Make_64(R[i2+1], R[i2]);	1051	Remainder->data.digits[i] = Make_64(R[i2+1], R[i2]);
1052	}	1052	}
...	@@ -1218,7 +1218,7 @@ void bigint_or(BigInt dest, const BigInt op1, const BigInt *op2) {	...	@@ -1218,7 +1218,7 @@ void bigint_or(BigInt dest, const BigInt op1, const BigInt *op2) {
1218	return;	1218	return;
1219	}	1219	}
1220	dest->digit_count = max(op1->digit_count, op2->digit_count);	1220	dest->digit_count = max(op1->digit_count, op2->digit_count);
1221	dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);	1221	dest->data.digits = heap::c_allocator.allocate_nonzero<uint64_t>(dest->digit_count);
1222	for (size_t i = 0; i < dest->digit_count; i += 1) {	1222	for (size_t i = 0; i < dest->digit_count; i += 1) {
1223	uint64_t digit = 0;	1223	uint64_t digit = 0;
1224	if (i < op1->digit_count) {	1224	if (i < op1->digit_count) {
...	@@ -1262,7 +1262,7 @@ void bigint_and(BigInt dest, const BigInt op1, const BigInt *op2) {	...	@@ -1262,7 +1262,7 @@ void bigint_and(BigInt dest, const BigInt op1, const BigInt *op2) {
1262	}	1262	}
1263		1263
1264	dest->digit_count = max(op1->digit_count, op2->digit_count);	1264	dest->digit_count = max(op1->digit_count, op2->digit_count);
1265	dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);	1265	dest->data.digits = heap::c_allocator.allocate_nonzero<uint64_t>(dest->digit_count);
1266		1266
1267	size_t i = 0;	1267	size_t i = 0;
1268	for (; i < op1->digit_count && i < op2->digit_count; i += 1) {	1268	for (; i < op1->digit_count && i < op2->digit_count; i += 1) {
...	@@ -1308,7 +1308,7 @@ void bigint_xor(BigInt dest, const BigInt op1, const BigInt *op2) {	...	@@ -1308,7 +1308,7 @@ void bigint_xor(BigInt dest, const BigInt op1, const BigInt *op2) {
1308	return;	1308	return;
1309	}	1309	}
1310	dest->digit_count = max(op1->digit_count, op2->digit_count);	1310	dest->digit_count = max(op1->digit_count, op2->digit_count);
1311	dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);	1311	dest->data.digits = heap::c_allocator.allocate_nonzero<uint64_t>(dest->digit_count);
1312	size_t i = 0;	1312	size_t i = 0;
1313	for (; i < op1->digit_count && i < op2->digit_count; i += 1) {	1313	for (; i < op1->digit_count && i < op2->digit_count; i += 1) {
1314	dest->data.digits[i] = op1_digits[i] ^ op2_digits[i];	1314	dest->data.digits[i] = op1_digits[i] ^ op2_digits[i];
...	@@ -1358,7 +1358,7 @@ void bigint_shl(BigInt dest, const BigInt op1, const BigInt *op2) {	...	@@ -1358,7 +1358,7 @@ void bigint_shl(BigInt dest, const BigInt op1, const BigInt *op2) {
1358	uint64_t digit_shift_count = shift_amt / 64;	1358	uint64_t digit_shift_count = shift_amt / 64;
1359	uint64_t leftover_shift_count = shift_amt % 64;	1359	uint64_t leftover_shift_count = shift_amt % 64;
1360		1360
1361	dest->data.digits = allocate<uint64_t>(op1->digit_count + digit_shift_count + 1);	1361	dest->data.digits = heap::c_allocator.allocate<uint64_t>(op1->digit_count + digit_shift_count + 1);
1362	dest->digit_count = digit_shift_count;	1362	dest->digit_count = digit_shift_count;
1363	uint64_t carry = 0;	1363	uint64_t carry = 0;
1364	for (size_t i = 0; i < op1->digit_count; i += 1) {	1364	for (size_t i = 0; i < op1->digit_count; i += 1) {
...	@@ -1421,7 +1421,7 @@ void bigint_shr(BigInt dest, const BigInt op1, const BigInt *op2) {	...	@@ -1421,7 +1421,7 @@ void bigint_shr(BigInt dest, const BigInt op1, const BigInt *op2) {
1421	if (dest->digit_count == 1) {	1421	if (dest->digit_count == 1) {
1422	digits = &dest->data.digit;	1422	digits = &dest->data.digit;
1423	} else {	1423	} else {
1424	digits = allocate<uint64_t>(dest->digit_count);	1424	digits = heap::c_allocator.allocate<uint64_t>(dest->digit_count);
1425	dest->data.digits = digits;	1425	dest->data.digits = digits;
1426	}	1426	}
1427		1427
...	@@ -1492,7 +1492,7 @@ void bigint_not(BigInt dest, const BigInt op, size_t bit_count, bool is_signed	...	@@ -1492,7 +1492,7 @@ void bigint_not(BigInt dest, const BigInt op, size_t bit_count, bool is_signed
1492	}	1492	}
1493	dest->digit_count = (bit_count + 63) / 64;	1493	dest->digit_count = (bit_count + 63) / 64;
1494	assert(dest->digit_count >= op->digit_count);	1494	assert(dest->digit_count >= op->digit_count);
1495	dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);	1495	dest->data.digits = heap::c_allocator.allocate_nonzero<uint64_t>(dest->digit_count);
1496	size_t i = 0;	1496	size_t i = 0;
1497	for (; i < op->digit_count; i += 1) {	1497	for (; i < op->digit_count; i += 1) {
1498	dest->data.digits[i] = ~op_digits[i];	1498	dest->data.digits[i] = ~op_digits[i];

...	@@ -21,7 +21,7 @@ static const ZigGLibCLib glibc_libs[] = {	...	@@ -21,7 +21,7 @@ static const ZigGLibCLib glibc_libs[] = {
21	Error glibc_load_metadata(ZigGLibCAbi *out_result, Buf zig_lib_dir, bool verbose) {	21	Error glibc_load_metadata(ZigGLibCAbi *out_result, Buf zig_lib_dir, bool verbose) {
22	Error err;	22	Error err;
23		23
24	ZigGLibCAbi *glibc_abi = allocate<ZigGLibCAbi>(1);	24	ZigGLibCAbi *glibc_abi = heap::c_allocator.create<ZigGLibCAbi>();
25	glibc_abi->vers_txt_path = buf_sprintf("%s" OS_SEP "libc" OS_SEP "glibc" OS_SEP "vers.txt", buf_ptr(zig_lib_dir));	25	glibc_abi->vers_txt_path = buf_sprintf("%s" OS_SEP "libc" OS_SEP "glibc" OS_SEP "vers.txt", buf_ptr(zig_lib_dir));
26	glibc_abi->fns_txt_path = buf_sprintf("%s" OS_SEP "libc" OS_SEP "glibc" OS_SEP "fns.txt", buf_ptr(zig_lib_dir));	26	glibc_abi->fns_txt_path = buf_sprintf("%s" OS_SEP "libc" OS_SEP "glibc" OS_SEP "fns.txt", buf_ptr(zig_lib_dir));
27	glibc_abi->abi_txt_path = buf_sprintf("%s" OS_SEP "libc" OS_SEP "glibc" OS_SEP "abi.txt", buf_ptr(zig_lib_dir));	27	glibc_abi->abi_txt_path = buf_sprintf("%s" OS_SEP "libc" OS_SEP "glibc" OS_SEP "abi.txt", buf_ptr(zig_lib_dir));
...	@@ -100,10 +100,10 @@ Error glibc_load_metadata(ZigGLibCAbi *out_result, Buf zig_lib_dir, bool verbo	...	@@ -100,10 +100,10 @@ Error glibc_load_metadata(ZigGLibCAbi *out_result, Buf zig_lib_dir, bool verbo
100	Optional<Slice<uint8_t>> opt_line = SplitIterator_next_separate(&it);	100	Optional<Slice<uint8_t>> opt_line = SplitIterator_next_separate(&it);
101	if (!opt_line.is_some) break;	101	if (!opt_line.is_some) break;
102		102
103	ver_list_base = allocate<ZigGLibCVerList>(glibc_abi->all_functions.length);	103	ver_list_base = heap::c_allocator.allocate<ZigGLibCVerList>(glibc_abi->all_functions.length);
104	SplitIterator line_it = memSplit(opt_line.value, str(" "));	104	SplitIterator line_it = memSplit(opt_line.value, str(" "));
105	for (;;) {	105	for (;;) {
106	ZigTarget *target = allocate<ZigTarget>(1);	106	ZigTarget *target = heap::c_allocator.create<ZigTarget>();
107	Optional<Slice<uint8_t>> opt_target = SplitIterator_next(&line_it);	107	Optional<Slice<uint8_t>> opt_target = SplitIterator_next(&line_it);
108	if (!opt_target.is_some) break;	108	if (!opt_target.is_some) break;
109		109
...	@@ -174,7 +174,7 @@ Error glibc_build_dummies_and_maps(CodeGen g, const ZigGLibCAbi glibc_abi, con	...	@@ -174,7 +174,7 @@ Error glibc_build_dummies_and_maps(CodeGen g, const ZigGLibCAbi glibc_abi, con
174	Error err;	174	Error err;
175		175
176	Buf *cache_dir = get_global_cache_dir();	176	Buf *cache_dir = get_global_cache_dir();
177	CacheHash *cache_hash = allocate<CacheHash>(1);	177	CacheHash *cache_hash = heap::c_allocator.create<CacheHash>();
178	Buf *manifest_dir = buf_sprintf("%s" OS_SEP CACHE_HASH_SUBDIR, buf_ptr(cache_dir));	178	Buf *manifest_dir = buf_sprintf("%s" OS_SEP CACHE_HASH_SUBDIR, buf_ptr(cache_dir));
179	cache_init(cache_hash, manifest_dir);	179	cache_init(cache_hash, manifest_dir);
180		180

...	@@ -650,7 +650,7 @@ static const char build_libunwind(CodeGen parent, Stage2ProgressNode *progress	...	@@ -650,7 +650,7 @@ static const char build_libunwind(CodeGen parent, Stage2ProgressNode *progress
650	};	650	};
651	ZigList<CFile *> c_source_files = {0};	651	ZigList<CFile *> c_source_files = {0};
652	for (size_t i = 0; i < array_length(unwind_src); i += 1) {	652	for (size_t i = 0; i < array_length(unwind_src); i += 1) {
653	CFile *c_file = allocate<CFile>(1);	653	CFile *c_file = heap::c_allocator.create<CFile>();
654	c_file->source_path = path_from_libunwind(parent, unwind_src[i].path);	654	c_file->source_path = path_from_libunwind(parent, unwind_src[i].path);
655	switch (unwind_src[i].kind) {	655	switch (unwind_src[i].kind) {
656	case SrcC:	656	case SrcC:
...	@@ -1111,7 +1111,7 @@ static const char build_musl(CodeGen parent, Stage2ProgressNode *progress_node	...	@@ -1111,7 +1111,7 @@ static const char build_musl(CodeGen parent, Stage2ProgressNode *progress_node
1111	Buf *full_path = buf_sprintf("%s" OS_SEP "libc" OS_SEP "%s",	1111	Buf *full_path = buf_sprintf("%s" OS_SEP "libc" OS_SEP "%s",
1112	buf_ptr(parent->zig_lib_dir), buf_ptr(src_file));	1112	buf_ptr(parent->zig_lib_dir), buf_ptr(src_file));
1113		1113
1114	CFile *c_file = allocate<CFile>(1);	1114	CFile *c_file = heap::c_allocator.create<CFile>();
1115	c_file->source_path = buf_ptr(full_path);	1115	c_file->source_path = buf_ptr(full_path);
1116		1116
1117	musl_add_cc_args(parent, c_file, src_kind == MuslSrcO3);	1117	musl_add_cc_args(parent, c_file, src_kind == MuslSrcO3);
...	@@ -1127,7 +1127,7 @@ static const char build_musl(CodeGen parent, Stage2ProgressNode *progress_node	...	@@ -1127,7 +1127,7 @@ static const char build_musl(CodeGen parent, Stage2ProgressNode *progress_node
1127	}	1127	}
1128		1128
1129	static void add_msvcrt_os_dep(CodeGen parent, CodeGen child_gen, const char *src_path) {	1129	static void add_msvcrt_os_dep(CodeGen parent, CodeGen child_gen, const char *src_path) {
1130	CFile *c_file = allocate<CFile>(1);	1130	CFile *c_file = heap::c_allocator.create<CFile>();
1131	c_file->source_path = buf_ptr(buf_sprintf("%s" OS_SEP "libc" OS_SEP "mingw" OS_SEP "%s",	1131	c_file->source_path = buf_ptr(buf_sprintf("%s" OS_SEP "libc" OS_SEP "mingw" OS_SEP "%s",
1132	buf_ptr(parent->zig_lib_dir), src_path));	1132	buf_ptr(parent->zig_lib_dir), src_path));
1133	c_file->args.append("-DHAVE_CONFIG_H");	1133	c_file->args.append("-DHAVE_CONFIG_H");
...	@@ -1151,7 +1151,7 @@ static void add_msvcrt_os_dep(CodeGen parent, CodeGen child_gen, const char *s	...	@@ -1151,7 +1151,7 @@ static void add_msvcrt_os_dep(CodeGen parent, CodeGen child_gen, const char *s
1151	}	1151	}
1152		1152
1153	static void add_mingwex_os_dep(CodeGen parent, CodeGen child_gen, const char *src_path) {	1153	static void add_mingwex_os_dep(CodeGen parent, CodeGen child_gen, const char *src_path) {
1154	CFile *c_file = allocate<CFile>(1);	1154	CFile *c_file = heap::c_allocator.create<CFile>();
1155	c_file->source_path = buf_ptr(buf_sprintf("%s" OS_SEP "libc" OS_SEP "mingw" OS_SEP "%s",	1155	c_file->source_path = buf_ptr(buf_sprintf("%s" OS_SEP "libc" OS_SEP "mingw" OS_SEP "%s",
1156	buf_ptr(parent->zig_lib_dir), src_path));	1156	buf_ptr(parent->zig_lib_dir), src_path));
1157	c_file->args.append("-DHAVE_CONFIG_H");	1157	c_file->args.append("-DHAVE_CONFIG_H");
...	@@ -1178,7 +1178,7 @@ static void add_mingwex_os_dep(CodeGen parent, CodeGen child_gen, const char *	...	@@ -1178,7 +1178,7 @@ static void add_mingwex_os_dep(CodeGen parent, CodeGen child_gen, const char *
1178	static const char get_libc_crt_file(CodeGen parent, const char file, Stage2ProgressNode progress_node) {	1178	static const char get_libc_crt_file(CodeGen parent, const char file, Stage2ProgressNode progress_node) {
1179	if (parent->libc == nullptr && parent->zig_target->os == OsWindows) {	1179	if (parent->libc == nullptr && parent->zig_target->os == OsWindows) {
1180	if (strcmp(file, "crt2.o") == 0) {	1180	if (strcmp(file, "crt2.o") == 0) {
1181	CFile *c_file = allocate<CFile>(1);	1181	CFile *c_file = heap::c_allocator.create<CFile>();
1182	c_file->source_path = buf_ptr(buf_sprintf(	1182	c_file->source_path = buf_ptr(buf_sprintf(
1183	"%s" OS_SEP "libc" OS_SEP "mingw" OS_SEP "crt" OS_SEP "crtexe.c", buf_ptr(parent->zig_lib_dir)));	1183	"%s" OS_SEP "libc" OS_SEP "mingw" OS_SEP "crt" OS_SEP "crtexe.c", buf_ptr(parent->zig_lib_dir)));
1184	mingw_add_cc_args(parent, c_file);	1184	mingw_add_cc_args(parent, c_file);
...	@@ -1190,7 +1190,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr	...	@@ -1190,7 +1190,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr
1190	//c_file->args.append("-DWPRFLAG=1");	1190	//c_file->args.append("-DWPRFLAG=1");
1191	return build_libc_object(parent, "crt2", c_file, progress_node);	1191	return build_libc_object(parent, "crt2", c_file, progress_node);
1192	} else if (strcmp(file, "dllcrt2.o") == 0) {	1192	} else if (strcmp(file, "dllcrt2.o") == 0) {
1193	CFile *c_file = allocate<CFile>(1);	1193	CFile *c_file = heap::c_allocator.create<CFile>();
1194	c_file->source_path = buf_ptr(buf_sprintf(	1194	c_file->source_path = buf_ptr(buf_sprintf(
1195	"%s" OS_SEP "libc" OS_SEP "mingw" OS_SEP "crt" OS_SEP "crtdll.c", buf_ptr(parent->zig_lib_dir)));	1195	"%s" OS_SEP "libc" OS_SEP "mingw" OS_SEP "crt" OS_SEP "crtdll.c", buf_ptr(parent->zig_lib_dir)));
1196	mingw_add_cc_args(parent, c_file);	1196	mingw_add_cc_args(parent, c_file);
...	@@ -1231,7 +1231,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr	...	@@ -1231,7 +1231,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr
1231	"mingw" OS_SEP "crt" OS_SEP "cxa_atexit.c",	1231	"mingw" OS_SEP "crt" OS_SEP "cxa_atexit.c",
1232	};	1232	};
1233	for (size_t i = 0; i < array_length(deps); i += 1) {	1233	for (size_t i = 0; i < array_length(deps); i += 1) {
1234	CFile *c_file = allocate<CFile>(1);	1234	CFile *c_file = heap::c_allocator.create<CFile>();
1235	c_file->source_path = path_from_libc(parent, deps[i]);	1235	c_file->source_path = path_from_libc(parent, deps[i]);
1236	c_file->args.append("-DHAVE_CONFIG_H");	1236	c_file->args.append("-DHAVE_CONFIG_H");
1237	c_file->args.append("-D_SYSCRT=1");	1237	c_file->args.append("-D_SYSCRT=1");
...	@@ -1301,7 +1301,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr	...	@@ -1301,7 +1301,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr
1301	}	1301	}
1302	} else if (parent->libc == nullptr && target_is_glibc(parent->zig_target)) {	1302	} else if (parent->libc == nullptr && target_is_glibc(parent->zig_target)) {
1303	if (strcmp(file, "crti.o") == 0) {	1303	if (strcmp(file, "crti.o") == 0) {
1304	CFile *c_file = allocate<CFile>(1);	1304	CFile *c_file = heap::c_allocator.create<CFile>();
1305	c_file->source_path = glibc_start_asm_path(parent, "crti.S");	1305	c_file->source_path = glibc_start_asm_path(parent, "crti.S");
1306	glibc_add_include_dirs(parent, c_file);	1306	glibc_add_include_dirs(parent, c_file);
1307	c_file->args.append("-D_LIBC_REENTRANT");	1307	c_file->args.append("-D_LIBC_REENTRANT");
...	@@ -1317,7 +1317,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr	...	@@ -1317,7 +1317,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr
1317	c_file->args.append("-Wa,--noexecstack");	1317	c_file->args.append("-Wa,--noexecstack");
1318	return build_libc_object(parent, "crti", c_file, progress_node);	1318	return build_libc_object(parent, "crti", c_file, progress_node);
1319	} else if (strcmp(file, "crtn.o") == 0) {	1319	} else if (strcmp(file, "crtn.o") == 0) {
1320	CFile *c_file = allocate<CFile>(1);	1320	CFile *c_file = heap::c_allocator.create<CFile>();
1321	c_file->source_path = glibc_start_asm_path(parent, "crtn.S");	1321	c_file->source_path = glibc_start_asm_path(parent, "crtn.S");
1322	glibc_add_include_dirs(parent, c_file);	1322	glibc_add_include_dirs(parent, c_file);
1323	c_file->args.append("-D_LIBC_REENTRANT");	1323	c_file->args.append("-D_LIBC_REENTRANT");
...	@@ -1328,7 +1328,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr	...	@@ -1328,7 +1328,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr
1328	c_file->args.append("-Wa,--noexecstack");	1328	c_file->args.append("-Wa,--noexecstack");
1329	return build_libc_object(parent, "crtn", c_file, progress_node);	1329	return build_libc_object(parent, "crtn", c_file, progress_node);
1330	} else if (strcmp(file, "start.os") == 0) {	1330	} else if (strcmp(file, "start.os") == 0) {
1331	CFile *c_file = allocate<CFile>(1);	1331	CFile *c_file = heap::c_allocator.create<CFile>();
1332	c_file->source_path = glibc_start_asm_path(parent, "start.S");	1332	c_file->source_path = glibc_start_asm_path(parent, "start.S");
1333	glibc_add_include_dirs(parent, c_file);	1333	glibc_add_include_dirs(parent, c_file);
1334	c_file->args.append("-D_LIBC_REENTRANT");	1334	c_file->args.append("-D_LIBC_REENTRANT");
...	@@ -1346,7 +1346,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr	...	@@ -1346,7 +1346,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr
1346	c_file->args.append("-Wa,--noexecstack");	1346	c_file->args.append("-Wa,--noexecstack");
1347	return build_libc_object(parent, "start", c_file, progress_node);	1347	return build_libc_object(parent, "start", c_file, progress_node);
1348	} else if (strcmp(file, "abi-note.o") == 0) {	1348	} else if (strcmp(file, "abi-note.o") == 0) {
1349	CFile *c_file = allocate<CFile>(1);	1349	CFile *c_file = heap::c_allocator.create<CFile>();
1350	c_file->source_path = path_from_libc(parent, "glibc" OS_SEP "csu" OS_SEP "abi-note.S");	1350	c_file->source_path = path_from_libc(parent, "glibc" OS_SEP "csu" OS_SEP "abi-note.S");
1351	c_file->args.append("-I");	1351	c_file->args.append("-I");
1352	c_file->args.append(path_from_libc(parent, "glibc" OS_SEP "csu"));	1352	c_file->args.append(path_from_libc(parent, "glibc" OS_SEP "csu"));
...	@@ -1369,7 +1369,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr	...	@@ -1369,7 +1369,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr
1369	} else if (strcmp(file, "libc_nonshared.a") == 0) {	1369	} else if (strcmp(file, "libc_nonshared.a") == 0) {
1370	CodeGen *child_gen = create_child_codegen(parent, nullptr, OutTypeLib, nullptr, "c_nonshared", progress_node);	1370	CodeGen *child_gen = create_child_codegen(parent, nullptr, OutTypeLib, nullptr, "c_nonshared", progress_node);
1371	{	1371	{
1372	CFile *c_file = allocate<CFile>(1);	1372	CFile *c_file = heap::c_allocator.create<CFile>();
1373	c_file->source_path = path_from_libc(parent, "glibc" OS_SEP "csu" OS_SEP "elf-init.c");	1373	c_file->source_path = path_from_libc(parent, "glibc" OS_SEP "csu" OS_SEP "elf-init.c");
1374	c_file->args.append("-std=gnu11");	1374	c_file->args.append("-std=gnu11");
1375	c_file->args.append("-fgnu89-inline");	1375	c_file->args.append("-fgnu89-inline");
...	@@ -1419,7 +1419,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr	...	@@ -1419,7 +1419,7 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr
1419	{"stack_chk_fail_local", "glibc" OS_SEP "debug" OS_SEP "stack_chk_fail_local.c"},	1419	{"stack_chk_fail_local", "glibc" OS_SEP "debug" OS_SEP "stack_chk_fail_local.c"},
1420	};	1420	};
1421	for (size_t i = 0; i < array_length(deps); i += 1) {	1421	for (size_t i = 0; i < array_length(deps); i += 1) {
1422	CFile *c_file = allocate<CFile>(1);	1422	CFile *c_file = heap::c_allocator.create<CFile>();
1423	c_file->source_path = path_from_libc(parent, deps[i].path);	1423	c_file->source_path = path_from_libc(parent, deps[i].path);
1424	c_file->args.append("-std=gnu11");	1424	c_file->args.append("-std=gnu11");
1425	c_file->args.append("-fgnu89-inline");	1425	c_file->args.append("-fgnu89-inline");
...	@@ -1451,26 +1451,26 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr	...	@@ -1451,26 +1451,26 @@ static const char get_libc_crt_file(CodeGen parent, const char *file, Stage2Pr
1451	}	1451	}
1452	} else if (parent->libc == nullptr && target_is_musl(parent->zig_target)) {	1452	} else if (parent->libc == nullptr && target_is_musl(parent->zig_target)) {
1453	if (strcmp(file, "crti.o") == 0) {	1453	if (strcmp(file, "crti.o") == 0) {
1454	CFile *c_file = allocate<CFile>(1);	1454	CFile *c_file = heap::c_allocator.create<CFile>();
1455	c_file->source_path = musl_start_asm_path(parent, "crti.s");	1455	c_file->source_path = musl_start_asm_path(parent, "crti.s");
1456	musl_add_cc_args(parent, c_file, false);	1456	musl_add_cc_args(parent, c_file, false);
1457	c_file->args.append("-Qunused-arguments");	1457	c_file->args.append("-Qunused-arguments");
1458	return build_libc_object(parent, "crti", c_file, progress_node);	1458	return build_libc_object(parent, "crti", c_file, progress_node);
1459	} else if (strcmp(file, "crtn.o") == 0) {	1459	} else if (strcmp(file, "crtn.o") == 0) {
1460	CFile *c_file = allocate<CFile>(1);	1460	CFile *c_file = heap::c_allocator.create<CFile>();
1461	c_file->source_path = musl_start_asm_path(parent, "crtn.s");	1461	c_file->source_path = musl_start_asm_path(parent, "crtn.s");
1462	c_file->args.append("-Qunused-arguments");	1462	c_file->args.append("-Qunused-arguments");
1463	musl_add_cc_args(parent, c_file, false);	1463	musl_add_cc_args(parent, c_file, false);
1464	return build_libc_object(parent, "crtn", c_file, progress_node);	1464	return build_libc_object(parent, "crtn", c_file, progress_node);
1465	} else if (strcmp(file, "crt1.o") == 0) {	1465	} else if (strcmp(file, "crt1.o") == 0) {
1466	CFile *c_file = allocate<CFile>(1);	1466	CFile *c_file = heap::c_allocator.create<CFile>();
1467	c_file->source_path = path_from_libc(parent, "musl" OS_SEP "crt" OS_SEP "crt1.c");	1467	c_file->source_path = path_from_libc(parent, "musl" OS_SEP "crt" OS_SEP "crt1.c");
1468	musl_add_cc_args(parent, c_file, false);	1468	musl_add_cc_args(parent, c_file, false);
1469	c_file->args.append("-fno-stack-protector");	1469	c_file->args.append("-fno-stack-protector");
1470	c_file->args.append("-DCRT");	1470	c_file->args.append("-DCRT");
1471	return build_libc_object(parent, "crt1", c_file, progress_node);	1471	return build_libc_object(parent, "crt1", c_file, progress_node);
1472	} else if (strcmp(file, "Scrt1.o") == 0) {	1472	} else if (strcmp(file, "Scrt1.o") == 0) {
1473	CFile *c_file = allocate<CFile>(1);	1473	CFile *c_file = heap::c_allocator.create<CFile>();
1474	c_file->source_path = path_from_libc(parent, "musl" OS_SEP "crt" OS_SEP "Scrt1.c");	1474	c_file->source_path = path_from_libc(parent, "musl" OS_SEP "crt" OS_SEP "Scrt1.c");
1475	musl_add_cc_args(parent, c_file, false);	1475	musl_add_cc_args(parent, c_file, false);
1476	c_file->args.append("-fPIC");	1476	c_file->args.append("-fPIC");
...	@@ -1982,7 +1982,7 @@ static const char get_def_lib(CodeGen parent, const char name, Buf def_in_fi	...	@@ -1982,7 +1982,7 @@ static const char get_def_lib(CodeGen parent, const char name, Buf def_in_fi
1982	Buf *def_include_dir = buf_sprintf("%s" OS_SEP "libc" OS_SEP "mingw" OS_SEP "def-include",	1982	Buf *def_include_dir = buf_sprintf("%s" OS_SEP "libc" OS_SEP "mingw" OS_SEP "def-include",
1983	buf_ptr(parent->zig_lib_dir));	1983	buf_ptr(parent->zig_lib_dir));
1984		1984
1985	CacheHash *cache_hash = allocate<CacheHash>(1);	1985	CacheHash *cache_hash = heap::c_allocator.create<CacheHash>();
1986	cache_init(cache_hash, manifest_dir);	1986	cache_init(cache_hash, manifest_dir);
1987		1987
1988	cache_buf(cache_hash, compiler_id);	1988	cache_buf(cache_hash, compiler_id);
...	@@ -2367,7 +2367,7 @@ static void construct_linker_job_coff(LinkJob *lj) {	...	@@ -2367,7 +2367,7 @@ static void construct_linker_job_coff(LinkJob *lj) {
2367		2367
2368	lj->args.append(get_def_lib(g, name, &lib_path));	2368	lj->args.append(get_def_lib(g, name, &lib_path));
2369		2369
2370	free(name);	2370	mem::os::free(name);
2371	}	2371	}
2372	}	2372	}
2373		2373

...	@@ -147,7 +147,7 @@ static void ast_invalid_token_error(ParseContext pc, Token token) {	...	@@ -147,7 +147,7 @@ static void ast_invalid_token_error(ParseContext pc, Token token) {
147	}	147	}
148		148
149	static AstNode ast_create_node_no_line_info(ParseContext pc, NodeType type) {	149	static AstNode ast_create_node_no_line_info(ParseContext pc, NodeType type) {
150	AstNode *node = allocate<AstNode>(1, "AstNode");	150	AstNode *node = heap::c_allocator.create<AstNode>();
151	node->type = type;	151	node->type = type;
152	node->owner = pc->owner;	152	node->owner = pc->owner;
153	return node;	153	return node;
...	@@ -1966,7 +1966,7 @@ static AsmOutput ast_parse_asm_output_item(ParseContext pc) {	...	@@ -1966,7 +1966,7 @@ static AsmOutput ast_parse_asm_output_item(ParseContext pc) {
1966		1966
1967	expect_token(pc, TokenIdRParen);	1967	expect_token(pc, TokenIdRParen);
1968		1968
1969	AsmOutput *res = allocate<AsmOutput>(1);	1969	AsmOutput *res = heap::c_allocator.create<AsmOutput>();
1970	res->asm_symbolic_name = token_buf(sym_name);	1970	res->asm_symbolic_name = token_buf(sym_name);
1971	res->constraint = token_buf(str);	1971	res->constraint = token_buf(str);
1972	res->variable_name = token_buf(var_name);	1972	res->variable_name = token_buf(var_name);
...	@@ -2003,7 +2003,7 @@ static AsmInput ast_parse_asm_input_item(ParseContext pc) {	...	@@ -2003,7 +2003,7 @@ static AsmInput ast_parse_asm_input_item(ParseContext pc) {
2003	AstNode *expr = ast_expect(pc, ast_parse_expr);	2003	AstNode *expr = ast_expect(pc, ast_parse_expr);
2004	expect_token(pc, TokenIdRParen);	2004	expect_token(pc, TokenIdRParen);
2005		2005
2006	AsmInput *res = allocate<AsmInput>(1);	2006	AsmInput *res = heap::c_allocator.create<AsmInput>();
2007	res->asm_symbolic_name = token_buf(sym_name);	2007	res->asm_symbolic_name = token_buf(sym_name);
2008	res->constraint = token_buf(constraint);	2008	res->constraint = token_buf(constraint);
2009	res->expr = expr;	2009	res->expr = expr;

...	@@ -80,7 +80,7 @@ ErrorMsg add_error_note(CodeGen g, ErrorMsg parent_msg, const AstNode node,	...	@@ -80,7 +80,7 @@ ErrorMsg add_error_note(CodeGen g, ErrorMsg parent_msg, const AstNode node,
80	}	80	}
81		81
82	ZigType *new_type_table_entry(ZigTypeId id) {	82	ZigType *new_type_table_entry(ZigTypeId id) {
83	ZigType *entry = allocate<ZigType>(1);	83	ZigType *entry = heap::c_allocator.create<ZigType>();
84	entry->id = id;	84	entry->id = id;
85	return entry;	85	return entry;
86	}	86	}
...	@@ -140,7 +140,7 @@ void init_scope(CodeGen g, Scope dest, ScopeId id, AstNode *source_node, Scope	...	@@ -140,7 +140,7 @@ void init_scope(CodeGen g, Scope dest, ScopeId id, AstNode *source_node, Scope
140	static ScopeDecls create_decls_scope(CodeGen g, AstNode node, Scope parent, ZigType *container_type,	140	static ScopeDecls create_decls_scope(CodeGen g, AstNode node, Scope parent, ZigType *container_type,
141	ZigType import, Buf bare_name)	141	ZigType import, Buf bare_name)
142	{	142	{
143	ScopeDecls *scope = allocate<ScopeDecls>(1);	143	ScopeDecls *scope = heap::c_allocator.create<ScopeDecls>();
144	init_scope(g, &scope->base, ScopeIdDecls, node, parent);	144	init_scope(g, &scope->base, ScopeIdDecls, node, parent);
145	scope->decl_table.init(4);	145	scope->decl_table.init(4);
146	scope->container_type = container_type;	146	scope->container_type = container_type;
...	@@ -151,7 +151,7 @@ static ScopeDecls create_decls_scope(CodeGen g, AstNode node, Scope parent,	...	@@ -151,7 +151,7 @@ static ScopeDecls create_decls_scope(CodeGen g, AstNode node, Scope parent,
151		151
152	ScopeBlock create_block_scope(CodeGen g, AstNode node, Scope parent) {	152	ScopeBlock create_block_scope(CodeGen g, AstNode node, Scope parent) {
153	assert(node->type == NodeTypeBlock);	153	assert(node->type == NodeTypeBlock);
154	ScopeBlock *scope = allocate<ScopeBlock>(1);	154	ScopeBlock *scope = heap::c_allocator.create<ScopeBlock>();
155	init_scope(g, &scope->base, ScopeIdBlock, node, parent);	155	init_scope(g, &scope->base, ScopeIdBlock, node, parent);
156	scope->name = node->data.block.name;	156	scope->name = node->data.block.name;
157	return scope;	157	return scope;
...	@@ -159,20 +159,20 @@ ScopeBlock create_block_scope(CodeGen g, AstNode node, Scope parent) {	...	@@ -159,20 +159,20 @@ ScopeBlock create_block_scope(CodeGen g, AstNode node, Scope parent) {
159		159
160	ScopeDefer create_defer_scope(CodeGen g, AstNode node, Scope parent) {	160	ScopeDefer create_defer_scope(CodeGen g, AstNode node, Scope parent) {
161	assert(node->type == NodeTypeDefer);	161	assert(node->type == NodeTypeDefer);
162	ScopeDefer *scope = allocate<ScopeDefer>(1);	162	ScopeDefer *scope = heap::c_allocator.create<ScopeDefer>();
163	init_scope(g, &scope->base, ScopeIdDefer, node, parent);	163	init_scope(g, &scope->base, ScopeIdDefer, node, parent);
164	return scope;	164	return scope;
165	}	165	}
166		166
167	ScopeDeferExpr create_defer_expr_scope(CodeGen g, AstNode node, Scope parent) {	167	ScopeDeferExpr create_defer_expr_scope(CodeGen g, AstNode node, Scope parent) {
168	assert(node->type == NodeTypeDefer);	168	assert(node->type == NodeTypeDefer);
169	ScopeDeferExpr *scope = allocate<ScopeDeferExpr>(1);	169	ScopeDeferExpr *scope = heap::c_allocator.create<ScopeDeferExpr>();
170	init_scope(g, &scope->base, ScopeIdDeferExpr, node, parent);	170	init_scope(g, &scope->base, ScopeIdDeferExpr, node, parent);
171	return scope;	171	return scope;
172	}	172	}
173		173

...	@@ -21,6 +21,7 @@	...	@@ -21,6 +21,7 @@
21	#include "userland.h"	21	#include "userland.h"
22	#include "dump_analysis.hpp"	22	#include "dump_analysis.hpp"
23	#include "softfloat.hpp"	23	#include "softfloat.hpp"
		24	#include "mem_profile.hpp"
24		25
25	#include <stdio.h>	26	#include <stdio.h>
26	#include <errno.h>	27	#include <errno.h>
...	@@ -57,7 +58,7 @@ static void init_darwin_native(CodeGen *g) {	...	@@ -57,7 +58,7 @@ static void init_darwin_native(CodeGen *g) {
57	}	58	}
58		59
59	static ZigPackage new_package(const char root_src_dir, const char root_src_path, const char pkg_path) {	60	static ZigPackage new_package(const char root_src_dir, const char root_src_path, const char pkg_path) {
60	ZigPackage *entry = allocate<ZigPackage>(1);	61	ZigPackage *entry = heap::c_allocator.create<ZigPackage>();
61	entry->package_table.init(4);	62	entry->package_table.init(4);
62	buf_init_from_str(&entry->root_src_dir, root_src_dir);	63	buf_init_from_str(&entry->root_src_dir, root_src_dir);
63	buf_init_from_str(&entry->root_src_path, root_src_path);	64	buf_init_from_str(&entry->root_src_path, root_src_path);
...	@@ -4327,7 +4328,7 @@ static LLVMValueRef ir_render_call(CodeGen g, IrExecutableGen executable, IrIn	...	@@ -4327,7 +4328,7 @@ static LLVMValueRef ir_render_call(CodeGen g, IrExecutableGen executable, IrIn
4327	}	4328	}
4328	size_t field_count = arg_calc.field_index;	4329	size_t field_count = arg_calc.field_index;
4329		4330
4330	LLVMTypeRef *field_types = allocate_nonzero<LLVMTypeRef>(field_count);	4331	LLVMTypeRef *field_types = heap::c_allocator.allocate_nonzero<LLVMTypeRef>(field_count);
4331	LLVMGetStructElementTypes(LLVMGetElementType(LLVMTypeOf(frame_result_loc)), field_types);	4332	LLVMGetStructElementTypes(LLVMGetElementType(LLVMTypeOf(frame_result_loc)), field_types);
4332	assert(LLVMCountStructElementTypes(LLVMGetElementType(LLVMTypeOf(frame_result_loc))) == arg_calc_start.field_index);	4333	assert(LLVMCountStructElementTypes(LLVMGetElementType(LLVMTypeOf(frame_result_loc))) == arg_calc_start.field_index);
4333		4334
...	@@ -4680,8 +4681,8 @@ static LLVMValueRef ir_render_asm_gen(CodeGen g, IrExecutableGen executable, I	...	@@ -4680,8 +4681,8 @@ static LLVMValueRef ir_render_asm_gen(CodeGen g, IrExecutableGen executable, I
4680	instruction->return_count;	4681	instruction->return_count;
4681	size_t total_index = 0;	4682	size_t total_index = 0;
4682	size_t param_index = 0;	4683	size_t param_index = 0;
4683	LLVMTypeRef *param_types = allocate<LLVMTypeRef>(input_and_output_count);	4684	LLVMTypeRef *param_types = heap::c_allocator.allocate<LLVMTypeRef>(input_and_output_count);
4684	LLVMValueRef *param_values = allocate<LLVMValueRef>(input_and_output_count);	4685	LLVMValueRef *param_values = heap::c_allocator.allocate<LLVMValueRef>(input_and_output_count);
4685	for (size_t i = 0; i < asm_expr->output_list.length; i += 1, total_index += 1) {	4686	for (size_t i = 0; i < asm_expr->output_list.length; i += 1, total_index += 1) {
4686	AsmOutput *asm_output = asm_expr->output_list.at(i);	4687	AsmOutput *asm_output = asm_expr->output_list.at(i);
4687	bool is_return = (asm_output->return_type != nullptr);	4688	bool is_return = (asm_output->return_type != nullptr);
...	@@ -4923,7 +4924,7 @@ static LLVMValueRef ir_render_shuffle_vector(CodeGen g, IrExecutableGen execut	...	@@ -4923,7 +4924,7 @@ static LLVMValueRef ir_render_shuffle_vector(CodeGen g, IrExecutableGen execut
4923	// second vector. These start at -1 and go down, and are easiest to use	4924	// second vector. These start at -1 and go down, and are easiest to use
4924	// with the ~ operator. Here we convert between the two formats.	4925	// with the ~ operator. Here we convert between the two formats.
4925	IrInstGen *mask = instruction->mask;	4926	IrInstGen *mask = instruction->mask;
4926	LLVMValueRef *values = allocate<LLVMValueRef>(len_mask);	4927	LLVMValueRef *values = heap::c_allocator.allocate<LLVMValueRef>(len_mask);
4927	for (uint64_t i = 0; i < len_mask; i++) {	4928	for (uint64_t i = 0; i < len_mask; i++) {
4928	if (mask->value->data.x_array.data.s_none.elements[i].special == ConstValSpecialUndef) {	4929	if (mask->value->data.x_array.data.s_none.elements[i].special == ConstValSpecialUndef) {