Commit a489ea0b2f38c67025c2b2424749a9a7320cdd5a | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-07-08 21:03:28-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-07-08 21:03:28-07:00
log	a489ea0b2f38c67025c2b2424749a9a7320cdd5a
tree	b27dffca9c3c26ef8cb33776dfbdf1941e7f6e55
parent	0e1c7209e8632ebf398e60de9053e2e0fe8b5661
parent	bf56cdd9edffd5b97d2084b46cda6e6a89a391c1

Merge branch 'register-allocation'

14 files changed, 1395 insertions(+), 438 deletions(-)

lib
- std
  - array_list.zig
  - hash_map.zig
  - math.zig
  - special
    test_runner.zig
  - std.zig
  - testing.zig
  - zig
    ast.zig
src-self-hosted

lib/std/array_list.zig+60

...	@@ -257,6 +257,24 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {	...	@@ -257,6 +257,24 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
257	return &self.items[self.items.len - 1];	257	return &self.items[self.items.len - 1];
258	}	258	}
259		259
		260	/// Resize the array, adding `n` new elements, which have `undefined` values.
		261	/// The return value is an array pointing to the newly allocated elements.
		262	pub fn addManyAsArray(self: Self, comptime n: usize) ![n]T {
		263	const prev_len = self.items.len;
		264	try self.resize(self.items.len + n);
		265	return self.items[prev_len..][0..n];
		266	}
		267
		268	/// Resize the array, adding `n` new elements, which have `undefined` values.
		269	/// The return value is an array pointing to the newly allocated elements.
		270	/// Asserts that there is already space for the new item without allocating more.
		271	pub fn addManyAsArrayAssumeCapacity(self: Self, comptime n: usize) [n]T {
		272	assert(self.items.len + n <= self.capacity);
		273	const prev_len = self.items.len;
		274	self.items.len += n;
		275	return self.items[prev_len..][0..n];
		276	}
		277
260	/// Remove and return the last element from the list.	278	/// Remove and return the last element from the list.
261	/// Asserts the list has at least one item.	279	/// Asserts the list has at least one item.
262	pub fn pop(self: *Self) T {	280	pub fn pop(self: *Self) T {
...	@@ -488,6 +506,24 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) typ	...	@@ -488,6 +506,24 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) typ
488	return &self.items[self.items.len - 1];	506	return &self.items[self.items.len - 1];
489	}	507	}
490		508
		509	/// Resize the array, adding `n` new elements, which have `undefined` values.
		510	/// The return value is an array pointing to the newly allocated elements.
		511	pub fn addManyAsArray(self: Self, allocator: Allocator, comptime n: usize) !*[n]T {
		512	const prev_len = self.items.len;
		513	try self.resize(allocator, self.items.len + n);
		514	return self.items[prev_len..][0..n];
		515	}
		516
		517	/// Resize the array, adding `n` new elements, which have `undefined` values.
		518	/// The return value is an array pointing to the newly allocated elements.
		519	/// Asserts that there is already space for the new item without allocating more.
		520	pub fn addManyAsArrayAssumeCapacity(self: Self, comptime n: usize) [n]T {
		521	assert(self.items.len + n <= self.capacity);
		522	const prev_len = self.items.len;
		523	self.items.len += n;
		524	return self.items[prev_len..][0..n];
		525	}
		526
491	/// Remove and return the last element from the list.	527	/// Remove and return the last element from the list.
492	/// Asserts the list has at least one item.	528	/// Asserts the list has at least one item.
493	/// This operation does not invalidate any element pointers.	529	/// This operation does not invalidate any element pointers.
...	@@ -727,3 +763,27 @@ test "std.ArrayList.writer" {	...	@@ -727,3 +763,27 @@ test "std.ArrayList.writer" {
727	try writer.writeAll("efg");	763	try writer.writeAll("efg");
728	testing.expectEqualSlices(u8, list.items, "abcdefg");	764	testing.expectEqualSlices(u8, list.items, "abcdefg");
729	}	765	}
		766
		767	test "addManyAsArray" {
		768	const a = std.testing.allocator;
		769	{
		770	var list = ArrayList(u8).init(a);
		771	defer list.deinit();
		772
		773	(try list.addManyAsArray(4)).* = "aoeu".*;
		774	try list.ensureCapacity(8);
		775	list.addManyAsArrayAssumeCapacity(4).* = "asdf".*;
		776
		777	testing.expectEqualSlices(u8, list.items, "aoeuasdf");
		778	}
		779	{
		780	var list = ArrayListUnmanaged(u8){};
		781	defer list.deinit(a);
		782
		783	(try list.addManyAsArray(a, 4)).* = "aoeu".*;
		784	try list.ensureCapacity(a, 8);
		785	list.addManyAsArrayAssumeCapacity(4).* = "asdf".*;
		786
		787	testing.expectEqualSlices(u8, list.items, "aoeuasdf");
		788	}
		789	}

lib/std/hash_map.zig+4

 @@ -15,6 +15,10 @@ pub fn AutoHashMap(comptime K: type, comptime V: type) type {
     return HashMap(K, V, getAutoHashFn(K), getAutoEqlFn(K), autoEqlIsCheap(K));
 }
+pub fn AutoHashMapUnmanaged(comptime K: type, comptime V: type) type {
+    return HashMapUnmanaged(K, V, getAutoHashFn(K), getAutoEqlFn(K), autoEqlIsCheap(K));
+}
 /// Builtin hashmap for strings as keys.
 pub fn StringHashMap(comptime V: type) type {
     return HashMap([]const u8, V, hashString, eqlString, true);

lib/std/math.zig-5

...	@@ -1047,19 +1047,14 @@ pub fn order(a: var, b: var) Order {	...	@@ -1047,19 +1047,14 @@ pub fn order(a: var, b: var) Order {
1047	pub const CompareOperator = enum {	1047	pub const CompareOperator = enum {
1048	/// Less than (`<`)	1048	/// Less than (`<`)
1049	lt,	1049	lt,
1050
1051	/// Less than or equal (`<=`)	1050	/// Less than or equal (`<=`)
1052	lte,	1051	lte,
1053
1054	/// Equal (`==`)	1052	/// Equal (`==`)
1055	eq,	1053	eq,
1056
1057	/// Greater than or equal (`>=`)	1054	/// Greater than or equal (`>=`)
1058	gte,	1055	gte,
1059
1060	/// Greater than (`>`)	1056	/// Greater than (`>`)
1061	gt,	1057	gt,
1062
1063	/// Not equal (`!=`)	1058	/// Not equal (`!=`)
1064	neq,	1059	neq,
1065	};	1060	};

lib/std/special/test_runner.zig+12

...	@@ -21,6 +21,7 @@ pub fn main() anyerror!void {	...	@@ -21,6 +21,7 @@ pub fn main() anyerror!void {
21		21
22	for (test_fn_list) \|test_fn, i\| {	22	for (test_fn_list) \|test_fn, i\| {
23	std.testing.base_allocator_instance.reset();	23	std.testing.base_allocator_instance.reset();
		24	std.testing.log_level = .warn;
24		25
25	var test_node = root_node.start(test_fn.name, null);	26	var test_node = root_node.start(test_fn.name, null);
26	test_node.activate();	27	test_node.activate();
...	@@ -73,3 +74,14 @@ pub fn main() anyerror!void {	...	@@ -73,3 +74,14 @@ pub fn main() anyerror!void {
73	std.debug.warn("{} passed; {} skipped.\n", .{ ok_count, skip_count });	74	std.debug.warn("{} passed; {} skipped.\n", .{ ok_count, skip_count });
74	}	75	}
75	}	76	}
		77
		78	pub fn log(
		79	comptime message_level: std.log.Level,
		80	comptime scope: @Type(.EnumLiteral),
		81	comptime format: []const u8,
		82	args: var,
		83	) void {
		84	if (@enumToInt(message_level) <= @enumToInt(std.testing.log_level)) {
		85	std.debug.print("[{}] ({}): " ++ format, .{@tagName(scope), @tagName(message_level)} ++ args);
		86	}
		87	}

lib/std/std.zig+5-3

 @@ -3,14 +3,16 @@ pub const ArrayListAligned = @import("array_list.zig").ArrayListAligned;
 pub const ArrayListAlignedUnmanaged = @import("array_list.zig").ArrayListAlignedUnmanaged;
 pub const ArrayListSentineled = @import("array_list_sentineled.zig").ArrayListSentineled;
 pub const ArrayListUnmanaged = @import("array_list.zig").ArrayListUnmanaged;
-pub const AutoHashMap = @import("hash_map.zig").AutoHashMap;
+pub const AutoHashMap = hash_map.AutoHashMap;
+pub const AutoHashMapUnmanaged = hash_map.AutoHashMapUnmanaged;
 pub const BloomFilter = @import("bloom_filter.zig").BloomFilter;
 pub const BufMap = @import("buf_map.zig").BufMap;
 pub const BufSet = @import("buf_set.zig").BufSet;
 pub const ChildProcess = @import("child_process.zig").ChildProcess;
 pub const ComptimeStringMap = @import("comptime_string_map.zig").ComptimeStringMap;
 pub const DynLib = @import("dynamic_library.zig").DynLib;
-pub const HashMap = @import("hash_map.zig").HashMap;
+pub const HashMap = hash_map.HashMap;
+pub const HashMapUnmanaged = hash_map.HashMapUnmanaged;
 pub const Mutex = @import("mutex.zig").Mutex;
 pub const PackedIntArray = @import("packed_int_array.zig").PackedIntArray;
 pub const PackedIntArrayEndian = @import("packed_int_array.zig").PackedIntArrayEndian;
 @@ -22,7 +24,7 @@ pub const ResetEvent = @import("reset_event.zig").ResetEvent;
 pub const SegmentedList = @import("segmented_list.zig").SegmentedList;
 pub const SinglyLinkedList = @import("linked_list.zig").SinglyLinkedList;
 pub const SpinLock = @import("spinlock.zig").SpinLock;
-pub const StringHashMap = @import("hash_map.zig").StringHashMap;
+pub const StringHashMap = hash_map.StringHashMap;
 pub const TailQueue = @import("linked_list.zig").TailQueue;
 pub const Target = @import("target.zig").Target;
 pub const Thread = @import("thread.zig").Thread;

lib/std/testing.zig+3

 @@ -14,6 +14,9 @@ pub var failing_allocator_instance = FailingAllocator.init(&base_allocator_insta
 pub var base_allocator_instance = std.mem.validationWrap(std.heap.ThreadSafeFixedBufferAllocator.init(allocator_mem[0..]));
 var allocator_mem: [2 * 1024 * 1024]u8 = undefined;
+/// TODO https://github.com/ziglang/zig/issues/5738
+pub var log_level = std.log.Level.warn;
 /// This function is intended to be used only in tests. It prints diagnostics to stderr
 /// and then aborts when actual_error_union is not expected_error.
 pub fn expectError(expected_error: anyerror, actual_error_union: var) void {

lib/std/zig/ast.zig+2

...	@@ -959,6 +959,8 @@ pub const Node = struct {	...	@@ -959,6 +959,8 @@ pub const Node = struct {
959	};	959	};
960		960
961	/// The params are directly after the FnProto in memory.	961	/// The params are directly after the FnProto in memory.
		962	/// TODO have a flags field for the optional nodes, and have them appended
		963	/// before or after the parameters in memory.
962	pub const FnProto = struct {	964	pub const FnProto = struct {
963	base: Node = Node{ .id = .FnProto },	965	base: Node = Node{ .id = .FnProto },
964	doc_comments: ?*DocComment,	966	doc_comments: ?*DocComment,

src-self-hosted/Module.zig+388-267

 @@ -18,9 +18,10 @@ const Inst = ir.Inst;
 const Body = ir.Body;
 const ast = std.zig.ast;
 const trace = @import("tracy.zig").trace;
+const liveness = @import("liveness.zig");
-/// General-purpose allocator.
+/// General-purpose allocator. Used for both temporary and long-term storage.
-allocator: *Allocator,
+gpa: *Allocator,
 /// Pointer to externally managed resource.
 root_pkg: *Package,
 /// Module owns this resource.
 @@ -32,7 +33,7 @@ bin_file_path: []const u8,
 /// It's rare for a decl to be exported, so we save memory by having a sparse map of
 /// Decl pointers to details about them being exported.
 /// The Export memory is owned by the `export_owners` table; the slice itself is owned by this table.
-decl_exports: std.AutoHashMap(*Decl, []*Export),
+decl_exports: std.AutoHashMapUnmanaged(*Decl, []*Export) = .{},
 /// We track which export is associated with the given symbol name for quick
 /// detection of symbol collisions.
 symbol_exports: std.StringHashMap(*Export),
 @@ -40,9 +41,9 @@ symbol_exports: std.StringHashMap(*Export),
 /// is modified. Note that the key of this table is not the Decl being exported, but the Decl that
 /// is performing the export of another Decl.
 /// This table owns the Export memory.
-export_owners: std.AutoHashMap(*Decl, []*Export),
+export_owners: std.AutoHashMapUnmanaged(*Decl, []*Export) = .{},
 /// Maps fully qualified namespaced names to the Decl struct for them.
-decl_table: DeclTable,
+decl_table: std.HashMapUnmanaged(Scope.NameHash, *Decl, Scope.name_hash_hash, Scope.name_hash_eql, false) = .{},
 optimize_mode: std.builtin.Mode,
 link_error_flags: link.File.ErrorFlags = .{},
 @@ -54,13 +55,13 @@ work_queue: std.fifo.LinearFifo(WorkItem, .Dynamic),
 /// The ErrorMsg memory is owned by the decl, using Module's allocator.
 /// Note that a Decl can succeed but the Fn it represents can fail. In this case,
 /// a Decl can have a failed_decls entry but have analysis status of success.
-failed_decls: std.AutoHashMap(*Decl, *ErrorMsg),
+failed_decls: std.AutoHashMapUnmanaged(*Decl, *ErrorMsg) = .{},
 /// Using a map here for consistency with the other fields here.
 /// The ErrorMsg memory is owned by the `Scope`, using Module's allocator.
-failed_files: std.AutoHashMap(*Scope, *ErrorMsg),
+failed_files: std.AutoHashMapUnmanaged(*Scope, *ErrorMsg) = .{},
 /// Using a map here for consistency with the other fields here.
 /// The ErrorMsg memory is owned by the `Export`, using Module's allocator.
-failed_exports: std.AutoHashMap(*Export, *ErrorMsg),
+failed_exports: std.AutoHashMapUnmanaged(*Export, *ErrorMsg) = .{},
 /// Incrementing integer used to compare against the corresponding Decl
 /// field to determine whether a Decl's status applies to an ongoing update, or a
 @@ -75,8 +76,6 @@ deletion_set: std.ArrayListUnmanaged(*Decl) = .{},
 keep_source_files_loaded: bool,
-const DeclTable = std.HashMap(Scope.NameHash, *Decl, Scope.name_hash_hash, Scope.name_hash_eql, false);
 const WorkItem = union(enum) {
     /// Write the machine code for a Decl to the output file.
     codegen_decl: *Decl,
 @@ -175,19 +174,23 @@ pub const Decl = struct {
     /// The shallow set of other decls whose typed_value could possibly change if this Decl's
     /// typed_value is modified.
-    dependants: ArrayListUnmanaged(*Decl) = ArrayListUnmanaged(*Decl){},
+    dependants: DepsTable = .{},
     /// The shallow set of other decls whose typed_value changing indicates that this Decl's
     /// typed_value may need to be regenerated.
-    dependencies: ArrayListUnmanaged(*Decl) = ArrayListUnmanaged(*Decl){},
+    dependencies: DepsTable = .{},
+    /// The reason this is not `std.AutoHashMapUnmanaged` is a workaround for
+    /// stage1 compiler giving me: `error: struct 'Module.Decl' depends on itself`
+    pub const DepsTable = std.HashMapUnmanaged(*Decl, void, std.hash_map.getAutoHashFn(*Decl), std.hash_map.getAutoEqlFn(*Decl), false);
-    pub fn destroy(self: *Decl, allocator: *Allocator) void {
+    pub fn destroy(self: *Decl, gpa: *Allocator) void {
-        allocator.free(mem.spanZ(self.name));
+        gpa.free(mem.spanZ(self.name));
         if (self.typedValueManaged()) |tvm| {
-            tvm.deinit(allocator);
+            tvm.deinit(gpa);
         }
-        self.dependants.deinit(allocator);
+        self.dependants.deinit(gpa);
-        self.dependencies.deinit(allocator);
+        self.dependencies.deinit(gpa);
-        allocator.destroy(self);
+        gpa.destroy(self);
     }
     pub fn src(self: Decl) usize {
 @@ -246,23 +249,11 @@ pub const Decl = struct {
     }
     fn removeDependant(self: *Decl, other: *Decl) void {
-        for (self.dependants.items) |item, i| {
+        self.dependants.removeAssertDiscard(other);
-            if (item == other) {
-                _ = self.dependants.swapRemove(i);
-                return;
-            }
-        }
-        unreachable;
     }
     fn removeDependency(self: *Decl, other: *Decl) void {
-        for (self.dependencies.items) |item, i| {
+        self.dependencies.removeAssertDiscard(other);
-            if (item == other) {
-                _ = self.dependencies.swapRemove(i);
-                return;
-            }
-        }
-        unreachable;
     }
 };
 @@ -312,14 +303,14 @@ pub const Scope = struct {
         switch (self.tag) {
             .block => return self.cast(Block).?.arena,
             .decl => return &self.cast(DeclAnalysis).?.arena.allocator,
-            .gen_zir => return &self.cast(GenZIR).?.arena.allocator,
+            .gen_zir => return self.cast(GenZIR).?.arena,
             .zir_module => return &self.cast(ZIRModule).?.contents.module.arena.allocator,
             .file => unreachable,
         }
     }
-    /// Asserts the scope has a parent which is a DeclAnalysis and
+    /// If the scope has a parent which is a `DeclAnalysis`,
-    /// returns the Decl.
+    /// returns the `Decl`, otherwise returns `null`.
     pub fn decl(self: *Scope) ?*Decl {
         return switch (self.tag) {
             .block => self.cast(Block).?.decl,
 @@ -389,10 +380,10 @@ pub const Scope = struct {
         }
     }
-    pub fn unload(base: *Scope, allocator: *Allocator) void {
+    pub fn unload(base: *Scope, gpa: *Allocator) void {
         switch (base.tag) {
-            .file => return @fieldParentPtr(File, "base", base).unload(allocator),
+            .file => return @fieldParentPtr(File, "base", base).unload(gpa),
-            .zir_module => return @fieldParentPtr(ZIRModule, "base", base).unload(allocator),
+            .zir_module => return @fieldParentPtr(ZIRModule, "base", base).unload(gpa),
             .block => unreachable,
             .gen_zir => unreachable,
             .decl => unreachable,
 @@ -421,17 +412,17 @@ pub const Scope = struct {
     }
     /// Asserts the scope is a File or ZIRModule and deinitializes it, then deallocates it.
-    pub fn destroy(base: *Scope, allocator: *Allocator) void {
+    pub fn destroy(base: *Scope, gpa: *Allocator) void {
         switch (base.tag) {
             .file => {
                 const scope_file = @fieldParentPtr(File, "base", base);
-                scope_file.deinit(allocator);
+                scope_file.deinit(gpa);
-                allocator.destroy(scope_file);
+                gpa.destroy(scope_file);
             },
             .zir_module => {
                 const scope_zir_module = @fieldParentPtr(ZIRModule, "base", base);
-                scope_zir_module.deinit(allocator);
+                scope_zir_module.deinit(gpa);
-                allocator.destroy(scope_zir_module);
+                gpa.destroy(scope_zir_module);
             },
             .block => unreachable,
             .gen_zir => unreachable,
 @@ -482,7 +473,7 @@ pub const Scope = struct {
         /// Direct children of the file.
         decls: ArrayListUnmanaged(*Decl),
-        pub fn unload(self: *File, allocator: *Allocator) void {
+        pub fn unload(self: *File, gpa: *Allocator) void {
             switch (self.status) {
                 .never_loaded,
                 .unloaded_parse_failure,
 @@ -496,16 +487,16 @@ pub const Scope = struct {
             }
             switch (self.source) {
                 .bytes => |bytes| {
-                    allocator.free(bytes);
+                    gpa.free(bytes);
                     self.source = .{ .unloaded = {} };
                 },
                 .unloaded => {},
             }
         }
-        pub fn deinit(self: *File, allocator: *Allocator) void {
+        pub fn deinit(self: *File, gpa: *Allocator) void {
-            self.decls.deinit(allocator);
+            self.decls.deinit(gpa);
-            self.unload(allocator);
+            self.unload(gpa);
             self.* = undefined;
         }
 @@ -527,7 +518,7 @@ pub const Scope = struct {
             switch (self.source) {
                 .unloaded => {
                     const source = try module.root_pkg.root_src_dir.readFileAllocOptions(
-                        module.allocator,
+                        module.gpa,
                         self.sub_file_path,
                         std.math.maxInt(u32),
                         1,
 @@ -575,7 +566,7 @@ pub const Scope = struct {
         /// not this one.
         decls: ArrayListUnmanaged(*Decl),
-        pub fn unload(self: *ZIRModule, allocator: *Allocator) void {
+        pub fn unload(self: *ZIRModule, gpa: *Allocator) void {
             switch (self.status) {
                 .never_loaded,
                 .unloaded_parse_failure,
 @@ -584,30 +575,30 @@ pub const Scope = struct {
                 => {},
                 .loaded_success => {
-                    self.contents.module.deinit(allocator);
+                    self.contents.module.deinit(gpa);
-                    allocator.destroy(self.contents.module);
+                    gpa.destroy(self.contents.module);
                     self.contents = .{ .not_available = {} };
                     self.status = .unloaded_success;
                 },
                 .loaded_sema_failure => {
-                    self.contents.module.deinit(allocator);
+                    self.contents.module.deinit(gpa);
-                    allocator.destroy(self.contents.module);
+                    gpa.destroy(self.contents.module);
                     self.contents = .{ .not_available = {} };
                     self.status = .unloaded_sema_failure;
                 },
             }
             switch (self.source) {
                 .bytes => |bytes| {
-                    allocator.free(bytes);
+                    gpa.free(bytes);
                     self.source = .{ .unloaded = {} };
                 },
                 .unloaded => {},
             }
         }
-        pub fn deinit(self: *ZIRModule, allocator: *Allocator) void {
+        pub fn deinit(self: *ZIRModule, gpa: *Allocator) void {
-            self.decls.deinit(allocator);
+            self.decls.deinit(gpa);
-            self.unload(allocator);
+            self.unload(gpa);
             self.* = undefined;
         }
 @@ -629,7 +620,7 @@ pub const Scope = struct {
             switch (self.source) {
                 .unloaded => {
                     const source = try module.root_pkg.root_src_dir.readFileAllocOptions(
-                        module.allocator,
+                        module.gpa,
                         self.sub_file_path,
                         std.math.maxInt(u32),
                         1,
 @@ -662,7 +653,7 @@ pub const Scope = struct {
         label: ?Label = null,
         pub const Label = struct {
-            name: []const u8,
+            zir_block: *zir.Inst.Block,
             results: ArrayListUnmanaged(*Inst),
             block_inst: *Inst.Block,
         };
 @@ -683,8 +674,8 @@ pub const Scope = struct {
         pub const base_tag: Tag = .gen_zir;
         base: Scope = Scope{ .tag = base_tag },
         decl: *Decl,
-        arena: std.heap.ArenaAllocator,
+        arena: *Allocator,
-        instructions: std.ArrayList(*zir.Inst),
+        instructions: std.ArrayListUnmanaged(*zir.Inst) = .{},
     };
 };
 @@ -700,8 +691,8 @@ pub const AllErrors = struct {
         msg: []const u8,
     };
-    pub fn deinit(self: *AllErrors, allocator: *Allocator) void {
+    pub fn deinit(self: *AllErrors, gpa: *Allocator) void {
-        self.arena.promote(allocator).deinit();
+        self.arena.promote(gpa).deinit();
     }
     fn add(
 @@ -773,20 +764,14 @@ pub fn init(gpa: *Allocator, options: InitOptions) !Module {
     };
     return Module{
-        .allocator = gpa,
+        .gpa = gpa,
         .root_pkg = options.root_pkg,
         .root_scope = root_scope,
         .bin_file_dir = bin_file_dir,
         .bin_file_path = options.bin_file_path,
         .bin_file = bin_file,
         .optimize_mode = options.optimize_mode,
-        .decl_table = DeclTable.init(gpa),
-        .decl_exports = std.AutoHashMap(*Decl, []*Export).init(gpa),
         .symbol_exports = std.StringHashMap(*Export).init(gpa),
-        .export_owners = std.AutoHashMap(*Decl, []*Export).init(gpa),
-        .failed_decls = std.AutoHashMap(*Decl, *ErrorMsg).init(gpa),
-        .failed_files = std.AutoHashMap(*Scope, *ErrorMsg).init(gpa),
-        .failed_exports = std.AutoHashMap(*Export, *ErrorMsg).init(gpa),
         .work_queue = std.fifo.LinearFifo(WorkItem, .Dynamic).init(gpa),
         .keep_source_files_loaded = options.keep_source_files_loaded,
     };
 @@ -794,51 +779,51 @@ pub fn init(gpa: *Allocator, options: InitOptions) !Module {
 pub fn deinit(self: *Module) void {
     self.bin_file.destroy();
-    const allocator = self.allocator;
+    const gpa = self.gpa;
-    self.deletion_set.deinit(allocator);
+    self.deletion_set.deinit(gpa);
     self.work_queue.deinit();
     for (self.decl_table.items()) |entry| {
-        entry.value.destroy(allocator);
+        entry.value.destroy(gpa);
     }
-    self.decl_table.deinit();
+    self.decl_table.deinit(gpa);
     for (self.failed_decls.items()) |entry| {
-        entry.value.destroy(allocator);
+        entry.value.destroy(gpa);
     }
-    self.failed_decls.deinit();
+    self.failed_decls.deinit(gpa);
     for (self.failed_files.items()) |entry| {
-        entry.value.destroy(allocator);
+        entry.value.destroy(gpa);
     }
-    self.failed_files.deinit();
+    self.failed_files.deinit(gpa);
     for (self.failed_exports.items()) |entry| {
-        entry.value.destroy(allocator);
+        entry.value.destroy(gpa);
     }
-    self.failed_exports.deinit();
+    self.failed_exports.deinit(gpa);
     for (self.decl_exports.items()) |entry| {
         const export_list = entry.value;
-        allocator.free(export_list);
+        gpa.free(export_list);
     }
-    self.decl_exports.deinit();
+    self.decl_exports.deinit(gpa);
     for (self.export_owners.items()) |entry| {
-        freeExportList(allocator, entry.value);
+        freeExportList(gpa, entry.value);
     }
-    self.export_owners.deinit();
+    self.export_owners.deinit(gpa);
     self.symbol_exports.deinit();
-    self.root_scope.destroy(allocator);
+    self.root_scope.destroy(gpa);
     self.* = undefined;
 }
-fn freeExportList(allocator: *Allocator, export_list: []*Export) void {
+fn freeExportList(gpa: *Allocator, export_list: []*Export) void {
     for (export_list) |exp| {
-        allocator.destroy(exp);
+        gpa.destroy(exp);
     }
-    allocator.free(export_list);
+    gpa.free(export_list);
 }
 pub fn target(self: Module) std.Target {
 @@ -856,7 +841,7 @@ pub fn update(self: *Module) !void {
     // Until then we simulate a full cache miss. Source files could have been loaded for any reason;
     // to force a refresh we unload now.
     if (self.root_scope.cast(Scope.File)) |zig_file| {
-        zig_file.unload(self.allocator);
+        zig_file.unload(self.gpa);
         self.analyzeRootSrcFile(zig_file) catch |err| switch (err) {
             error.AnalysisFail => {
                 assert(self.totalErrorCount() != 0);
 @@ -864,7 +849,7 @@ pub fn update(self: *Module) !void {
             else => |e| return e,
         };
     } else if (self.root_scope.cast(Scope.ZIRModule)) |zir_module| {
-        zir_module.unload(self.allocator);
+        zir_module.unload(self.gpa);
         self.analyzeRootZIRModule(zir_module) catch |err| switch (err) {
             error.AnalysisFail => {
                 assert(self.totalErrorCount() != 0);
 @@ -877,22 +862,25 @@ pub fn update(self: *Module) !void {
     // Process the deletion set.
     while (self.deletion_set.popOrNull()) |decl| {
-        if (decl.dependants.items.len != 0) {
+        if (decl.dependants.items().len != 0) {
             decl.deletion_flag = false;
             continue;
         }
         try self.deleteDecl(decl);
     }
+    if (self.totalErrorCount() == 0) {
+        // This is needed before reading the error flags.
+        try self.bin_file.flush();
+    }
     self.link_error_flags = self.bin_file.errorFlags();
+    std.log.debug(.module, "link_error_flags: {}\n", .{self.link_error_flags});
     // If there are any errors, we anticipate the source files being loaded
     // to report error messages. Otherwise we unload all source files to save memory.
-    if (self.totalErrorCount() == 0) {
+    if (self.totalErrorCount() == 0 and !self.keep_source_files_loaded) {
-        if (!self.keep_source_files_loaded) {
+        self.root_scope.unload(self.gpa);
-            self.root_scope.unload(self.allocator);
-        }
-        try self.bin_file.flush();
     }
 }
 @@ -916,10 +904,10 @@ pub fn totalErrorCount(self: *Module) usize {
 }
 pub fn getAllErrorsAlloc(self: *Module) !AllErrors {
-    var arena = std.heap.ArenaAllocator.init(self.allocator);
+    var arena = std.heap.ArenaAllocator.init(self.gpa);
     errdefer arena.deinit();
-    var errors = std.ArrayList(AllErrors.Message).init(self.allocator);
+    var errors = std.ArrayList(AllErrors.Message).init(self.gpa);
     defer errors.deinit();
     for (self.failed_files.items()) |entry| {
 @@ -988,6 +976,12 @@ pub fn performAllTheWork(self: *Module) error{OutOfMemory}!void {
                         .sema_failure, .dependency_failure => continue,
                         .success => {},
                     }
+                    // Here we tack on additional allocations to the Decl's arena. The allocations are
+                    // lifetime annotations in the ZIR.
+                    var decl_arena = decl.typed_value.most_recent.arena.?.promote(self.gpa);
+                    defer decl.typed_value.most_recent.arena.?.* = decl_arena.state;
+                    std.log.debug(.module, "analyze liveness of {}\n", .{decl.name});
+                    try liveness.analyze(self.gpa, &decl_arena.allocator, payload.func.analysis.success);
                 }
                 assert(decl.typed_value.most_recent.typed_value.ty.hasCodeGenBits());
 @@ -998,9 +992,9 @@ pub fn performAllTheWork(self: *Module) error{OutOfMemory}!void {
                         decl.analysis = .dependency_failure;
                     },
                     else => {
-                        try self.failed_decls.ensureCapacity(self.failed_decls.items().len + 1);
+                        try self.failed_decls.ensureCapacity(self.gpa, self.failed_decls.items().len + 1);
                         self.failed_decls.putAssumeCapacityNoClobber(decl, try ErrorMsg.create(
-                            self.allocator,
+                            self.gpa,
                             decl.src(),
                             "unable to codegen: {}",
                             .{@errorName(err)},
 @@ -1044,16 +1038,17 @@ fn ensureDeclAnalyzed(self: *Module, decl: *Decl) InnerError!void {
             // prior to re-analysis.
             self.deleteDeclExports(decl);
             // Dependencies will be re-discovered, so we remove them here prior to re-analysis.
-            for (decl.dependencies.items) |dep| {
+            for (decl.dependencies.items()) |entry| {
+                const dep = entry.key;
                 dep.removeDependant(decl);
-                if (dep.dependants.items.len == 0 and !dep.deletion_flag) {
+                if (dep.dependants.items().len == 0 and !dep.deletion_flag) {
                     // We don't perform a deletion here, because this Decl or another one
                     // may end up referencing it before the update is complete.
                     dep.deletion_flag = true;
-                    try self.deletion_set.append(self.allocator, dep);
+                    try self.deletion_set.append(self.gpa, dep);
                 }
             }
-            decl.dependencies.shrink(self.allocator, 0);
+            decl.dependencies.clearRetainingCapacity();
             break :blk true;
         },
 @@ -1068,9 +1063,9 @@ fn ensureDeclAnalyzed(self: *Module, decl: *Decl) InnerError!void {
             error.OutOfMemory => return error.OutOfMemory,
             error.AnalysisFail => return error.AnalysisFail,
             else => {
-                try self.failed_decls.ensureCapacity(self.failed_decls.items().len + 1);
+                try self.failed_decls.ensureCapacity(self.gpa, self.failed_decls.items().len + 1);
                 self.failed_decls.putAssumeCapacityNoClobber(decl, try ErrorMsg.create(
-                    self.allocator,
+                    self.gpa,
                     decl.src(),
                     "unable to analyze: {}",
                     .{@errorName(err)},
 @@ -1084,7 +1079,8 @@ fn ensureDeclAnalyzed(self: *Module, decl: *Decl) InnerError!void {
         // We may need to chase the dependants and re-analyze them.
         // However, if the decl is a function, and the type is the same, we do not need to.
         if (type_changed or decl.typed_value.most_recent.typed_value.val.tag() != .function) {
-            for (decl.dependants.items) |dep| {
+            for (decl.dependants.items()) |entry| {
+                const dep = entry.key;
                 switch (dep.analysis) {
                     .unreferenced => unreachable,
                     .in_progress => unreachable,
 @@ -1121,19 +1117,19 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             // This arena allocator's memory is discarded at the end of this function. It is used
             // to determine the type of the function, and hence the type of the decl, which is needed
             // to complete the Decl analysis.
+            var fn_type_scope_arena = std.heap.ArenaAllocator.init(self.gpa);
+            defer fn_type_scope_arena.deinit();
             var fn_type_scope: Scope.GenZIR = .{
                 .decl = decl,
-                .arena = std.heap.ArenaAllocator.init(self.allocator),
+                .arena = &fn_type_scope_arena.allocator,
-                .instructions = std.ArrayList(*zir.Inst).init(self.allocator),
             };
-            defer fn_type_scope.arena.deinit();
+            defer fn_type_scope.instructions.deinit(self.gpa);
-            defer fn_type_scope.instructions.deinit();
             const body_node = fn_proto.body_node orelse
                 return self.failTok(&fn_type_scope.base, fn_proto.fn_token, "TODO implement extern functions", .{});
             const param_decls = fn_proto.params();
-            const param_types = try fn_type_scope.arena.allocator.alloc(*zir.Inst, param_decls.len);
+            const param_types = try fn_type_scope.arena.alloc(*zir.Inst, param_decls.len);
             for (param_decls) |param_decl, i| {
                 const param_type_node = switch (param_decl.param_type) {
                     .var_type => |node| return self.failNode(&fn_type_scope.base, node, "TODO implement anytype parameter", .{}),
 @@ -1174,7 +1170,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             _ = try self.addZIRInst(&fn_type_scope.base, fn_src, zir.Inst.Return, .{ .operand = fn_type_inst }, .{});
             // We need the memory for the Type to go into the arena for the Decl
-            var decl_arena = std.heap.ArenaAllocator.init(self.allocator);
+            var decl_arena = std.heap.ArenaAllocator.init(self.gpa);
             errdefer decl_arena.deinit();
             const decl_arena_state = try decl_arena.allocator.create(std.heap.ArenaAllocator.State);
 @@ -1185,7 +1181,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                 .instructions = .{},
                 .arena = &decl_arena.allocator,
             };
-            defer block_scope.instructions.deinit(self.allocator);
+            defer block_scope.instructions.deinit(self.gpa);
             const fn_type = try self.analyzeBodyValueAsType(&block_scope, .{
                 .instructions = fn_type_scope.instructions.items,
 @@ -1196,24 +1192,24 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             const fn_zir = blk: {
                 // This scope's arena memory is discarded after the ZIR generation
                 // pass completes, and semantic analysis of it completes.
+                var gen_scope_arena = std.heap.ArenaAllocator.init(self.gpa);
+                errdefer gen_scope_arena.deinit();
                 var gen_scope: Scope.GenZIR = .{
                     .decl = decl,
-                    .arena = std.heap.ArenaAllocator.init(self.allocator),
+                    .arena = &gen_scope_arena.allocator,
-                    .instructions = std.ArrayList(*zir.Inst).init(self.allocator),
                 };
-                errdefer gen_scope.arena.deinit();
+                defer gen_scope.instructions.deinit(self.gpa);
-                defer gen_scope.instructions.deinit();
                 const body_block = body_node.cast(ast.Node.Block).?;
                 try self.astGenBlock(&gen_scope.base, body_block);
-                const fn_zir = try gen_scope.arena.allocator.create(Fn.ZIR);
+                const fn_zir = try gen_scope_arena.allocator.create(Fn.ZIR);
                 fn_zir.* = .{
                     .body = .{
-                        .instructions = try gen_scope.arena.allocator.dupe(*zir.Inst, gen_scope.instructions.items),
+                        .instructions = try gen_scope.arena.dupe(*zir.Inst, gen_scope.instructions.items),
                     },
-                    .arena = gen_scope.arena.state,
+                    .arena = gen_scope_arena.state,
                 };
                 break :blk fn_zir;
             };
 @@ -1231,7 +1227,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                 prev_type_has_bits = tvm.typed_value.ty.hasCodeGenBits();
                 type_changed = !tvm.typed_value.ty.eql(fn_type);
-                tvm.deinit(self.allocator);
+                tvm.deinit(self.gpa);
             }
             decl_arena_state.* = decl_arena.state;
 @@ -1315,6 +1311,33 @@ fn astGenInfixOp(self: *Module, scope: *Scope, infix_node: *ast.Node.InfixOp) In
             return self.addZIRInst(scope, src, zir.Inst.Add, .{ .lhs = lhs, .rhs = rhs }, .{});
         },
+        .BangEqual,
+        .EqualEqual,
+        .GreaterThan,
+        .GreaterOrEqual,
+        .LessThan,
+        .LessOrEqual,
+        => {
+            const lhs = try self.astGenExpr(scope, infix_node.lhs);
+            const rhs = try self.astGenExpr(scope, infix_node.rhs);
+            const tree = scope.tree();
+            const src = tree.token_locs[infix_node.op_token].start;
+            return self.addZIRInst(scope, src, zir.Inst.Cmp, .{
+                .lhs = lhs,
+                .op = @as(std.math.CompareOperator, switch (infix_node.op) {
+                    .BangEqual => .neq,
+                    .EqualEqual => .eq,
+                    .GreaterThan => .gt,
+                    .GreaterOrEqual => .gte,
+                    .LessThan => .lt,
+                    .LessOrEqual => .lte,
+                    else => unreachable,
+                }),
+                .rhs = rhs,
+            }, .{});
+        },
         else => |op| {
             return self.failNode(scope, &infix_node.base, "TODO implement infix operator {}", .{op});
         },
 @@ -1330,9 +1353,70 @@ fn astGenIf(self: *Module, scope: *Scope, if_node: *ast.Node.If) InnerError!*zir
             return self.failNode(scope, payload, "TODO implement astGenIf for error unions", .{});
         }
     }
-    const cond = try self.astGenExpr(scope, if_node.condition);
+    var block_scope: Scope.GenZIR = .{
-    const body = try self.astGenExpr(scope, if_node.condition);
+        .decl = scope.decl().?,
-    return self.failNode(scope, if_node.condition, "TODO implement astGenIf", .{});
+        .arena = scope.arena(),
+        .instructions = .{},
+    };
+    defer block_scope.instructions.deinit(self.gpa);
+    const cond = try self.astGenExpr(&block_scope.base, if_node.condition);
+    const tree = scope.tree();
+    const if_src = tree.token_locs[if_node.if_token].start;
+    const condbr = try self.addZIRInstSpecial(&block_scope.base, if_src, zir.Inst.CondBr, .{
+        .condition = cond,
+        .true_body = undefined, // populated below
+        .false_body = undefined, // populated below
+    }, .{});
+    const block = try self.addZIRInstBlock(scope, if_src, .{
+        .instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items),
+    });
+    var then_scope: Scope.GenZIR = .{
+        .decl = block_scope.decl,
+        .arena = block_scope.arena,
+        .instructions = .{},
+    };
+    defer then_scope.instructions.deinit(self.gpa);
+    const then_result = try self.astGenExpr(&then_scope.base, if_node.body);
+    const then_src = tree.token_locs[if_node.body.lastToken()].start;
+    _ = try self.addZIRInst(&then_scope.base, then_src, zir.Inst.Break, .{
+        .block = block,
+        .operand = then_result,
+    }, .{});
+    condbr.positionals.true_body = .{
+        .instructions = try then_scope.arena.dupe(*zir.Inst, then_scope.instructions.items),
+    };
+    var else_scope: Scope.GenZIR = .{
+        .decl = block_scope.decl,
+        .arena = block_scope.arena,
+        .instructions = .{},
+    };
+    defer else_scope.instructions.deinit(self.gpa);
+    if (if_node.@"else") |else_node| {
+        const else_result = try self.astGenExpr(&else_scope.base, else_node.body);
+        const else_src = tree.token_locs[else_node.body.lastToken()].start;
+        _ = try self.addZIRInst(&else_scope.base, else_src, zir.Inst.Break, .{
+            .block = block,
+            .operand = else_result,
+        }, .{});
+    } else {
+        // TODO Optimization opportunity: we can avoid an allocation and a memcpy here
+        // by directly allocating the body for this one instruction.
+        const else_src = tree.token_locs[if_node.lastToken()].start;
+        _ = try self.addZIRInst(&else_scope.base, else_src, zir.Inst.BreakVoid, .{
+            .block = block,
+        }, .{});
+    }
+    condbr.positionals.false_body = .{
+        .instructions = try else_scope.arena.dupe(*zir.Inst, else_scope.instructions.items),
+    };
+    return &block.base;
 }
 fn astGenControlFlowExpression(
 @@ -1358,12 +1442,12 @@ fn astGenControlFlowExpression(
 fn astGenIdent(self: *Module, scope: *Scope, ident: *ast.Node.Identifier) InnerError!*zir.Inst {
     const tree = scope.tree();
     const ident_name = tree.tokenSlice(ident.token);
+    const src = tree.token_locs[ident.token].start;
     if (mem.eql(u8, ident_name, "_")) {
         return self.failNode(scope, &ident.base, "TODO implement '_' identifier", .{});
     }
     if (getSimplePrimitiveValue(ident_name)) |typed_value| {
-        const src = tree.token_locs[ident.token].start;
         return self.addZIRInstConst(scope, src, typed_value);
     }
 @@ -1387,7 +1471,6 @@ fn astGenIdent(self: *Module, scope: *Scope, ident: *ast.Node.Identifier) InnerE
                 64 => if (is_signed) Value.initTag(.i64_type) else Value.initTag(.u64_type),
                 else => return self.failNode(scope, &ident.base, "TODO implement arbitrary integer bitwidth types", .{}),
             };
-            const src = tree.token_locs[ident.token].start;
             return self.addZIRInstConst(scope, src, .{
                 .ty = Type.initTag(.type),
                 .val = val,
 @@ -1396,10 +1479,21 @@ fn astGenIdent(self: *Module, scope: *Scope, ident: *ast.Node.Identifier) InnerE
     }
     if (self.lookupDeclName(scope, ident_name)) |decl| {
-        const src = tree.token_locs[ident.token].start;
         return try self.addZIRInst(scope, src, zir.Inst.DeclValInModule, .{ .decl = decl }, .{});
     }
+    // Function parameter
+    if (scope.decl()) |decl| {
+        if (tree.root_node.decls()[decl.src_index].cast(ast.Node.FnProto)) |fn_proto| {
+            for (fn_proto.params()) |param, i| {
+                const param_name = tree.tokenSlice(param.name_token.?);
+                if (mem.eql(u8, param_name, ident_name)) {
+                    return try self.addZIRInst(scope, src, zir.Inst.Arg, .{ .index = i }, .{});
+                }
+            }
+        }
+    }
     return self.failNode(scope, &ident.base, "TODO implement local variable identifier lookup", .{});
 }
 @@ -1542,7 +1636,7 @@ fn astGenCall(self: *Module, scope: *Scope, call: *ast.Node.Call) InnerError!*zi
     const lhs = try self.astGenExpr(scope, call.lhs);
     const param_nodes = call.params();
-    const args = try scope.cast(Scope.GenZIR).?.arena.allocator.alloc(*zir.Inst, param_nodes.len);
+    const args = try scope.cast(Scope.GenZIR).?.arena.alloc(*zir.Inst, param_nodes.len);
     for (param_nodes) |param_node, i| {
         args[i] = try self.astGenExpr(scope, param_node);
     }
 @@ -1622,40 +1716,31 @@ fn getSimplePrimitiveValue(name: []const u8) ?TypedValue {
 }
 fn declareDeclDependency(self: *Module, depender: *Decl, dependee: *Decl) !void {
-    try depender.dependencies.ensureCapacity(self.allocator, depender.dependencies.items.len + 1);
+    try depender.dependencies.ensureCapacity(self.gpa, depender.dependencies.items().len + 1);
-    try dependee.dependants.ensureCapacity(self.allocator, dependee.dependants.items.len + 1);
+    try dependee.dependants.ensureCapacity(self.gpa, dependee.dependants.items().len + 1);
-    for (depender.dependencies.items) |item| {
+    depender.dependencies.putAssumeCapacity(dependee, {});
-        if (item == dependee) break; // Already in the set.
+    dependee.dependants.putAssumeCapacity(depender, {});
-    } else {
-        depender.dependencies.appendAssumeCapacity(dependee);
-    }
-    for (dependee.dependants.items) |item| {
-        if (item == depender) break; // Already in the set.
-    } else {
-        dependee.dependants.appendAssumeCapacity(depender);
-    }
 }
 fn getSrcModule(self: *Module, root_scope: *Scope.ZIRModule) !*zir.Module {
     switch (root_scope.status) {
         .never_loaded, .unloaded_success => {
-            try self.failed_files.ensureCapacity(self.failed_files.items().len + 1);
+            try self.failed_files.ensureCapacity(self.gpa, self.failed_files.items().len + 1);
             const source = try root_scope.getSource(self);
             var keep_zir_module = false;
-            const zir_module = try self.allocator.create(zir.Module);
+            const zir_module = try self.gpa.create(zir.Module);
-            defer if (!keep_zir_module) self.allocator.destroy(zir_module);
+            defer if (!keep_zir_module) self.gpa.destroy(zir_module);
-            zir_module.* = try zir.parse(self.allocator, source);
+            zir_module.* = try zir.parse(self.gpa, source);
-            defer if (!keep_zir_module) zir_module.deinit(self.allocator);
+            defer if (!keep_zir_module) zir_module.deinit(self.gpa);
             if (zir_module.error_msg) |src_err_msg| {
                 self.failed_files.putAssumeCapacityNoClobber(
                     &root_scope.base,
-                    try ErrorMsg.create(self.allocator, src_err_msg.byte_offset, "{}", .{src_err_msg.msg}),
+                    try ErrorMsg.create(self.gpa, src_err_msg.byte_offset, "{}", .{src_err_msg.msg}),
                 );
                 root_scope.status = .unloaded_parse_failure;
                 return error.AnalysisFail;
 @@ -1682,22 +1767,22 @@ fn getAstTree(self: *Module, root_scope: *Scope.File) !*ast.Tree {
     switch (root_scope.status) {
         .never_loaded, .unloaded_success => {
-            try self.failed_files.ensureCapacity(self.failed_files.items().len + 1);
+            try self.failed_files.ensureCapacity(self.gpa, self.failed_files.items().len + 1);
             const source = try root_scope.getSource(self);
             var keep_tree = false;
-            const tree = try std.zig.parse(self.allocator, source);
+            const tree = try std.zig.parse(self.gpa, source);
             defer if (!keep_tree) tree.deinit();
             if (tree.errors.len != 0) {
                 const parse_err = tree.errors[0];
-                var msg = std.ArrayList(u8).init(self.allocator);
+                var msg = std.ArrayList(u8).init(self.gpa);
                 defer msg.deinit();
                 try parse_err.render(tree.token_ids, msg.outStream());
-                const err_msg = try self.allocator.create(ErrorMsg);
+                const err_msg = try self.gpa.create(ErrorMsg);
                 err_msg.* = .{
                     .msg = msg.toOwnedSlice(),
                     .byte_offset = tree.token_locs[parse_err.loc()].start,
 @@ -1728,11 +1813,11 @@ fn analyzeRootSrcFile(self: *Module, root_scope: *Scope.File) !void {
     const decls = tree.root_node.decls();
     try self.work_queue.ensureUnusedCapacity(decls.len);
-    try root_scope.decls.ensureCapacity(self.allocator, decls.len);
+    try root_scope.decls.ensureCapacity(self.gpa, decls.len);
     // Keep track of the decls that we expect to see in this file so that
     // we know which ones have been deleted.
-    var deleted_decls = std.AutoHashMap(*Decl, void).init(self.allocator);
+    var deleted_decls = std.AutoHashMap(*Decl, void).init(self.gpa);
     defer deleted_decls.deinit();
     try deleted_decls.ensureCapacity(root_scope.decls.items.len);
     for (root_scope.decls.items) |file_decl| {
 @@ -1756,9 +1841,9 @@ fn analyzeRootSrcFile(self: *Module, root_scope: *Scope.File) !void {
                 decl.src_index = decl_i;
                 if (deleted_decls.remove(decl) == null) {
                     decl.analysis = .sema_failure;
-                    const err_msg = try ErrorMsg.create(self.allocator, tree.token_locs[name_tok].start, "redefinition of '{}'", .{decl.name});
+                    const err_msg = try ErrorMsg.create(self.gpa, tree.token_locs[name_tok].start, "redefinition of '{}'", .{decl.name});
-                    errdefer err_msg.destroy(self.allocator);
+                    errdefer err_msg.destroy(self.gpa);
-                    try self.failed_decls.putNoClobber(decl, err_msg);
+                    try self.failed_decls.putNoClobber(self.gpa, decl, err_msg);
                 } else {
                     if (!srcHashEql(decl.contents_hash, contents_hash)) {
                         try self.markOutdatedDecl(decl);
 @@ -1792,14 +1877,14 @@ fn analyzeRootZIRModule(self: *Module, root_scope: *Scope.ZIRModule) !void {
     const src_module = try self.getSrcModule(root_scope);
     try self.work_queue.ensureUnusedCapacity(src_module.decls.len);
-    try root_scope.decls.ensureCapacity(self.allocator, src_module.decls.len);
+    try root_scope.decls.ensureCapacity(self.gpa, src_module.decls.len);
-    var exports_to_resolve = std.ArrayList(*zir.Decl).init(self.allocator);
+    var exports_to_resolve = std.ArrayList(*zir.Decl).init(self.gpa);
     defer exports_to_resolve.deinit();
     // Keep track of the decls that we expect to see in this file so that
     // we know which ones have been deleted.
-    var deleted_decls = std.AutoHashMap(*Decl, void).init(self.allocator);
+    var deleted_decls = std.AutoHashMap(*Decl, void).init(self.gpa);
     defer deleted_decls.deinit();
     try deleted_decls.ensureCapacity(self.decl_table.items().len);
     for (self.decl_table.items()) |entry| {
 @@ -1841,7 +1926,7 @@ fn analyzeRootZIRModule(self: *Module, root_scope: *Scope.ZIRModule) !void {
 }
 fn deleteDecl(self: *Module, decl: *Decl) !void {
-    try self.deletion_set.ensureCapacity(self.allocator, self.deletion_set.items.len + decl.dependencies.items.len);
+    try self.deletion_set.ensureCapacity(self.gpa, self.deletion_set.items.len + decl.dependencies.items().len);
     // Remove from the namespace it resides in. In the case of an anonymous Decl it will
     // not be present in the set, and this does nothing.
 @@ -1851,9 +1936,10 @@ fn deleteDecl(self: *Module, decl: *Decl) !void {
     const name_hash = decl.fullyQualifiedNameHash();
     self.decl_table.removeAssertDiscard(name_hash);
     // Remove itself from its dependencies, because we are about to destroy the decl pointer.
-    for (decl.dependencies.items) |dep| {
+    for (decl.dependencies.items()) |entry| {
+        const dep = entry.key;
         dep.removeDependant(decl);
-        if (dep.dependants.items.len == 0 and !dep.deletion_flag) {
+        if (dep.dependants.items().len == 0 and !dep.deletion_flag) {
             // We don't recursively perform a deletion here, because during the update,
             // another reference to it may turn up.
             dep.deletion_flag = true;
 @@ -1861,7 +1947,8 @@ fn deleteDecl(self: *Module, decl: *Decl) !void {
         }
     }
     // Anything that depends on this deleted decl certainly needs to be re-analyzed.
-    for (decl.dependants.items) |dep| {
+    for (decl.dependants.items()) |entry| {
+        const dep = entry.key;
         dep.removeDependency(decl);
         if (dep.analysis != .outdated) {
             // TODO Move this failure possibility to the top of the function.
 @@ -1869,11 +1956,11 @@ fn deleteDecl(self: *Module, decl: *Decl) !void {
         }
     }
     if (self.failed_decls.remove(decl)) |entry| {
-        entry.value.destroy(self.allocator);
+        entry.value.destroy(self.gpa);
     }
     self.deleteDeclExports(decl);
     self.bin_file.freeDecl(decl);
-    decl.destroy(self.allocator);
+    decl.destroy(self.gpa);
 }
 /// Delete all the Export objects that are caused by this Decl. Re-analysis of
 @@ -1895,7 +1982,7 @@ fn deleteDeclExports(self: *Module, decl: *Decl) void {
                     i += 1;
                 }
             }
-            decl_exports_kv.value = self.allocator.shrink(list, new_len);
+            decl_exports_kv.value = self.gpa.shrink(list, new_len);
             if (new_len == 0) {
                 self.decl_exports.removeAssertDiscard(exp.exported_decl);
             }
 @@ -1904,12 +1991,12 @@ fn deleteDeclExports(self: *Module, decl: *Decl) void {
             elf.deleteExport(exp.link);
         }
         if (self.failed_exports.remove(exp)) |entry| {
-            entry.value.destroy(self.allocator);
+            entry.value.destroy(self.gpa);
         }
         _ = self.symbol_exports.remove(exp.options.name);
-        self.allocator.destroy(exp);
+        self.gpa.destroy(exp);
     }
-    self.allocator.free(kv.value);
+    self.gpa.free(kv.value);
 }
 fn analyzeFnBody(self: *Module, decl: *Decl, func: *Fn) !void {
 @@ -1917,7 +2004,7 @@ fn analyzeFnBody(self: *Module, decl: *Decl, func: *Fn) !void {
     defer tracy.end();
     // Use the Decl's arena for function memory.
-    var arena = decl.typed_value.most_recent.arena.?.promote(self.allocator);
+    var arena = decl.typed_value.most_recent.arena.?.promote(self.gpa);
     defer decl.typed_value.most_recent.arena.?.* = arena.state;
     var inner_block: Scope.Block = .{
         .parent = null,
 @@ -1926,10 +2013,10 @@ fn analyzeFnBody(self: *Module, decl: *Decl, func: *Fn) !void {
         .instructions = .{},
         .arena = &arena.allocator,
     };
-    defer inner_block.instructions.deinit(self.allocator);
+    defer inner_block.instructions.deinit(self.gpa);
     const fn_zir = func.analysis.queued;
-    defer fn_zir.arena.promote(self.allocator).deinit();
+    defer fn_zir.arena.promote(self.gpa).deinit();
     func.analysis = .{ .in_progress = {} };
     //std.debug.warn("set {} to in_progress\n", .{decl.name});
 @@ -1944,7 +2031,7 @@ fn markOutdatedDecl(self: *Module, decl: *Decl) !void {
     //std.debug.warn("mark {} outdated\n", .{decl.name});
     try self.work_queue.writeItem(.{ .analyze_decl = decl });
     if (self.failed_decls.remove(decl)) |entry| {
-        entry.value.destroy(self.allocator);
+        entry.value.destroy(self.gpa);
     }
     decl.analysis = .outdated;
 }
 @@ -1955,7 +2042,7 @@ fn allocateNewDecl(
     src_index: usize,
     contents_hash: std.zig.SrcHash,
 ) !*Decl {
-    const new_decl = try self.allocator.create(Decl);
+    const new_decl = try self.gpa.create(Decl);
     new_decl.* = .{
         .name = "",
         .scope = scope.namespace(),
 @@ -1978,10 +2065,10 @@ fn createNewDecl(
     name_hash: Scope.NameHash,
     contents_hash: std.zig.SrcHash,
 ) !*Decl {
-    try self.decl_table.ensureCapacity(self.decl_table.items().len + 1);
+    try self.decl_table.ensureCapacity(self.gpa, self.decl_table.items().len + 1);
     const new_decl = try self.allocateNewDecl(scope, src_index, contents_hash);
-    errdefer self.allocator.destroy(new_decl);
+    errdefer self.gpa.destroy(new_decl);
-    new_decl.name = try mem.dupeZ(self.allocator, u8, decl_name);
+    new_decl.name = try mem.dupeZ(self.gpa, u8, decl_name);
     self.decl_table.putAssumeCapacityNoClobber(name_hash, new_decl);
     return new_decl;
 }
 @@ -1989,7 +2076,7 @@ fn createNewDecl(
 fn analyzeZirDecl(self: *Module, decl: *Decl, src_decl: *zir.Decl) InnerError!bool {
     var decl_scope: Scope.DeclAnalysis = .{
         .decl = decl,
-        .arena = std.heap.ArenaAllocator.init(self.allocator),
+        .arena = std.heap.ArenaAllocator.init(self.gpa),
     };
     errdefer decl_scope.arena.deinit();
 @@ -2005,7 +2092,7 @@ fn analyzeZirDecl(self: *Module, decl: *Decl, src_decl: *zir.Decl) InnerError!bo
         prev_type_has_bits = tvm.typed_value.ty.hasCodeGenBits();
         type_changed = !tvm.typed_value.ty.eql(typed_value.ty);
-        tvm.deinit(self.allocator);
+        tvm.deinit(self.gpa);
     }
     arena_state.* = decl_scope.arena.state;
 @@ -2143,11 +2230,11 @@ fn analyzeExport(self: *Module, scope: *Scope, src: usize, symbol_name: []const
         else => return self.fail(scope, src, "unable to export type '{}'", .{typed_value.ty}),
     }
-    try self.decl_exports.ensureCapacity(self.decl_exports.items().len + 1);
+    try self.decl_exports.ensureCapacity(self.gpa, self.decl_exports.items().len + 1);
-    try self.export_owners.ensureCapacity(self.export_owners.items().len + 1);
+    try self.export_owners.ensureCapacity(self.gpa, self.export_owners.items().len + 1);
-    const new_export = try self.allocator.create(Export);
+    const new_export = try self.gpa.create(Export);
-    errdefer self.allocator.destroy(new_export);
+    errdefer self.gpa.destroy(new_export);
     const owner_decl = scope.decl().?;
 @@ -2161,27 +2248,27 @@ fn analyzeExport(self: *Module, scope: *Scope, src: usize, symbol_name: []const
     };
     // Add to export_owners table.
-    const eo_gop = self.export_owners.getOrPut(owner_decl) catch unreachable;
+    const eo_gop = self.export_owners.getOrPut(self.gpa, owner_decl) catch unreachable;
     if (!eo_gop.found_existing) {
         eo_gop.entry.value = &[0]*Export{};
     }
-    eo_gop.entry.value = try self.allocator.realloc(eo_gop.entry.value, eo_gop.entry.value.len + 1);
+    eo_gop.entry.value = try self.gpa.realloc(eo_gop.entry.value, eo_gop.entry.value.len + 1);
     eo_gop.entry.value[eo_gop.entry.value.len - 1] = new_export;
-    errdefer eo_gop.entry.value = self.allocator.shrink(eo_gop.entry.value, eo_gop.entry.value.len - 1);
+    errdefer eo_gop.entry.value = self.gpa.shrink(eo_gop.entry.value, eo_gop.entry.value.len - 1);
     // Add to exported_decl table.
-    const de_gop = self.decl_exports.getOrPut(exported_decl) catch unreachable;
+    const de_gop = self.decl_exports.getOrPut(self.gpa, exported_decl) catch unreachable;
     if (!de_gop.found_existing) {
         de_gop.entry.value = &[0]*Export{};
     }
-    de_gop.entry.value = try self.allocator.realloc(de_gop.entry.value, de_gop.entry.value.len + 1);
+    de_gop.entry.value = try self.gpa.realloc(de_gop.entry.value, de_gop.entry.value.len + 1);
     de_gop.entry.value[de_gop.entry.value.len - 1] = new_export;
-    errdefer de_gop.entry.value = self.allocator.shrink(de_gop.entry.value, de_gop.entry.value.len - 1);
+    errdefer de_gop.entry.value = self.gpa.shrink(de_gop.entry.value, de_gop.entry.value.len - 1);
     if (self.symbol_exports.get(symbol_name)) |_| {
-        try self.failed_exports.ensureCapacity(self.failed_exports.items().len + 1);
+        try self.failed_exports.ensureCapacity(self.gpa, self.failed_exports.items().len + 1);
         self.failed_exports.putAssumeCapacityNoClobber(new_export, try ErrorMsg.create(
-            self.allocator,
+            self.gpa,
             src,
             "exported symbol collision: {}",
             .{symbol_name},
 @@ -2192,21 +2279,19 @@ fn analyzeExport(self: *Module, scope: *Scope, src: usize, symbol_name: []const
     }
     try self.symbol_exports.putNoClobber(symbol_name, new_export);
-    if (self.bin_file.cast(link.File.Elf)) |elf| {
+    self.bin_file.updateDeclExports(self, exported_decl, de_gop.entry.value) catch |err| switch (err) {
-        elf.updateDeclExports(self, exported_decl, de_gop.entry.value) catch |err| switch (err) {
+        error.OutOfMemory => return error.OutOfMemory,
-            error.OutOfMemory => return error.OutOfMemory,
+        else => {
-            else => {
+            try self.failed_exports.ensureCapacity(self.gpa, self.failed_exports.items().len + 1);
-                try self.failed_exports.ensureCapacity(self.failed_exports.items().len + 1);
+            self.failed_exports.putAssumeCapacityNoClobber(new_export, try ErrorMsg.create(
-                self.failed_exports.putAssumeCapacityNoClobber(new_export, try ErrorMsg.create(
+                self.gpa,
-                    self.allocator,
+                src,
-                    src,
+                "unable to export: {}",
-                    "unable to export: {}",
+                .{@errorName(err)},
-                    .{@errorName(err)},
+            ));
-                ));
+            new_export.status = .failed_retryable;
-                new_export.status = .failed_retryable;
+        },
-            },
+    };
-        };
-    }
 }
 fn addNewInstArgs(
 @@ -2223,13 +2308,13 @@ fn addNewInstArgs(
 }
 fn newZIRInst(
-    allocator: *Allocator,
+    gpa: *Allocator,
     src: usize,
     comptime T: type,
     positionals: std.meta.fieldInfo(T, "positionals").field_type,
     kw_args: std.meta.fieldInfo(T, "kw_args").field_type,
-) !*zir.Inst {
+) !*T {
-    const inst = try allocator.create(T);
+    const inst = try gpa.create(T);
     inst.* = .{
         .base = .{
             .tag = T.base_tag,
 @@ -2238,30 +2323,48 @@ fn newZIRInst(
         .positionals = positionals,
         .kw_args = kw_args,
     };
-    return &inst.base;
+    return inst;
 }
-fn addZIRInst(
+fn addZIRInstSpecial(
     self: *Module,
     scope: *Scope,
     src: usize,
     comptime T: type,
     positionals: std.meta.fieldInfo(T, "positionals").field_type,
     kw_args: std.meta.fieldInfo(T, "kw_args").field_type,
-) !*zir.Inst {
+) !*T {
     const gen_zir = scope.cast(Scope.GenZIR).?;
-    try gen_zir.instructions.ensureCapacity(gen_zir.instructions.items.len + 1);
+    try gen_zir.instructions.ensureCapacity(self.gpa, gen_zir.instructions.items.len + 1);
-    const inst = try newZIRInst(&gen_zir.arena.allocator, src, T, positionals, kw_args);
+    const inst = try newZIRInst(gen_zir.arena, src, T, positionals, kw_args);
-    gen_zir.instructions.appendAssumeCapacity(inst);
+    gen_zir.instructions.appendAssumeCapacity(&inst.base);
     return inst;
 }
+fn addZIRInst(
+    self: *Module,
+    scope: *Scope,
+    src: usize,
+    comptime T: type,
+    positionals: std.meta.fieldInfo(T, "positionals").field_type,
+    kw_args: std.meta.fieldInfo(T, "kw_args").field_type,
+) !*zir.Inst {
+    const inst_special = try self.addZIRInstSpecial(scope, src, T, positionals, kw_args);
+    return &inst_special.base;
+}
 /// TODO The existence of this function is a workaround for a bug in stage1.
 fn addZIRInstConst(self: *Module, scope: *Scope, src: usize, typed_value: TypedValue) !*zir.Inst {
     const P = std.meta.fieldInfo(zir.Inst.Const, "positionals").field_type;
     return self.addZIRInst(scope, src, zir.Inst.Const, P{ .typed_value = typed_value }, .{});
 }
+/// TODO The existence of this function is a workaround for a bug in stage1.
+fn addZIRInstBlock(self: *Module, scope: *Scope, src: usize, body: zir.Module.Body) !*zir.Inst.Block {
+    const P = std.meta.fieldInfo(zir.Inst.Block, "positionals").field_type;
+    return self.addZIRInstSpecial(scope, src, zir.Inst.Block, P{ .body = body }, .{});
+}
 fn addNewInst(self: *Module, block: *Scope.Block, src: usize, ty: Type, comptime T: type) !*T {
     const inst = try block.arena.create(T);
     inst.* = .{
 @@ -2272,7 +2375,7 @@ fn addNewInst(self: *Module, block: *Scope.Block, src: usize, ty: Type, comptime
         },
         .args = undefined,
     };
-    try block.instructions.append(self.allocator, &inst.base);
+    try block.instructions.append(self.gpa, &inst.base);
     return inst;
 }
 @@ -2392,6 +2495,7 @@ fn analyzeInst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*In
     switch (old_inst.tag) {
         .arg => return self.analyzeInstArg(scope, old_inst.cast(zir.Inst.Arg).?),
         .block => return self.analyzeInstBlock(scope, old_inst.cast(zir.Inst.Block).?),
+        .@"break" => return self.analyzeInstBreak(scope, old_inst.cast(zir.Inst.Break).?),
         .breakpoint => return self.analyzeInstBreakpoint(scope, old_inst.cast(zir.Inst.Breakpoint).?),
         .breakvoid => return self.analyzeInstBreakVoid(scope, old_inst.cast(zir.Inst.BreakVoid).?),
         .call => return self.analyzeInstCall(scope, old_inst.cast(zir.Inst.Call).?),
 @@ -2406,6 +2510,7 @@ fn analyzeInst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*In
             const big_int = old_inst.cast(zir.Inst.Int).?.positionals.int;
             return self.constIntBig(scope, old_inst.src, Type.initTag(.comptime_int), big_int);
         },
+        .inttype => return self.analyzeInstIntType(scope, old_inst.cast(zir.Inst.IntType).?),
         .ptrtoint => return self.analyzeInstPtrToInt(scope, old_inst.cast(zir.Inst.PtrToInt).?),
         .fieldptr => return self.analyzeInstFieldPtr(scope, old_inst.cast(zir.Inst.FieldPtr).?),
         .deref => return self.analyzeInstDeref(scope, old_inst.cast(zir.Inst.Deref).?),
 @@ -2422,6 +2527,7 @@ fn analyzeInst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*In
         .bitcast => return self.analyzeInstBitCast(scope, old_inst.cast(zir.Inst.BitCast).?),
         .elemptr => return self.analyzeInstElemPtr(scope, old_inst.cast(zir.Inst.ElemPtr).?),
         .add => return self.analyzeInstAdd(scope, old_inst.cast(zir.Inst.Add).?),
+        .sub => return self.analyzeInstSub(scope, old_inst.cast(zir.Inst.Sub).?),
         .cmp => return self.analyzeInstCmp(scope, old_inst.cast(zir.Inst.Cmp).?),
         .condbr => return self.analyzeInstCondBr(scope, old_inst.cast(zir.Inst.CondBr).?),
         .isnull => return self.analyzeInstIsNull(scope, old_inst.cast(zir.Inst.IsNull).?),
 @@ -2432,7 +2538,7 @@ fn analyzeInst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*In
 fn analyzeInstStr(self: *Module, scope: *Scope, str_inst: *zir.Inst.Str) InnerError!*Inst {
     // The bytes references memory inside the ZIR module, which can get deallocated
     // after semantic analysis is complete. We need the memory to be in the new anonymous Decl's arena.
-    var new_decl_arena = std.heap.ArenaAllocator.init(self.allocator);
+    var new_decl_arena = std.heap.ArenaAllocator.init(self.gpa);
     const arena_bytes = try new_decl_arena.allocator.dupe(u8, str_inst.positionals.bytes);
     const ty_payload = try scope.arena().create(Type.Payload.Array_u8_Sentinel0);
 @@ -2456,8 +2562,8 @@ fn createAnonymousDecl(
 ) !*Decl {
     const name_index = self.getNextAnonNameIndex();
     const scope_decl = scope.decl().?;
-    const name = try std.fmt.allocPrint(self.allocator, "{}__anon_{}", .{ scope_decl.name, name_index });
+    const name = try std.fmt.allocPrint(self.gpa, "{}__anon_{}", .{ scope_decl.name, name_index });
-    defer self.allocator.free(name);
+    defer self.gpa.free(name);
     const name_hash = scope.namespace().fullyQualifiedNameHash(name);
     const src_hash: std.zig.SrcHash = undefined;
     const new_decl = try self.createNewDecl(scope, name, scope_decl.src_index, name_hash, src_hash);
 @@ -2546,15 +2652,15 @@ fn analyzeInstBlock(self: *Module, scope: *Scope, inst: *zir.Inst.Block) InnerEr
         .arena = parent_block.arena,
         // TODO @as here is working around a miscompilation compiler bug :(
         .label = @as(?Scope.Block.Label, Scope.Block.Label{
-            .name = inst.positionals.label,
+            .zir_block = inst,
             .results = .{},
             .block_inst = block_inst,
         }),
     };
     const label = &child_block.label.?;
-    defer child_block.instructions.deinit(self.allocator);
+    defer child_block.instructions.deinit(self.gpa);
-    defer label.results.deinit(self.allocator);
+    defer label.results.deinit(self.gpa);
     try self.analyzeBody(&child_block.base, inst.positionals.body);
 @@ -2562,21 +2668,9 @@ fn analyzeInstBlock(self: *Module, scope: *Scope, inst: *zir.Inst.Block) InnerEr
     assert(child_block.instructions.items.len != 0);
     assert(child_block.instructions.items[child_block.instructions.items.len - 1].tag.isNoReturn());
-    if (label.results.items.len <= 1) {
-        // No need to add the Block instruction; we can add the instructions to the parent block directly.
-        // Blocks are terminated with a noreturn instruction which we do not want to include.
-        const instrs = child_block.instructions.items;
-        try parent_block.instructions.appendSlice(self.allocator, instrs[0 .. instrs.len - 1]);
-        if (label.results.items.len == 1) {
-            return label.results.items[0];
-        } else {
-            return self.constNoReturn(scope, inst.base.src);
-        }
-    }
     // Need to set the type and emit the Block instruction. This allows machine code generation
     // to emit a jump instruction to after the block when it encounters the break.
-    try parent_block.instructions.append(self.allocator, &block_inst.base);
+    try parent_block.instructions.append(self.gpa, &block_inst.base);
     block_inst.base.ty = try self.resolvePeerTypes(scope, label.results.items);
     block_inst.args.body = .{ .instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items) };
     return &block_inst.base;
 @@ -2587,22 +2681,39 @@ fn analyzeInstBreakpoint(self: *Module, scope: *Scope, inst: *zir.Inst.Breakpoin
     return self.addNewInstArgs(b, inst.base.src, Type.initTag(.void), Inst.Breakpoint, {});
 }
+fn analyzeInstBreak(self: *Module, scope: *Scope, inst: *zir.Inst.Break) InnerError!*Inst {
+    const operand = try self.resolveInst(scope, inst.positionals.operand);
+    const block = inst.positionals.block;
+    return self.analyzeBreak(scope, inst.base.src, block, operand);
+}
 fn analyzeInstBreakVoid(self: *Module, scope: *Scope, inst: *zir.Inst.BreakVoid) InnerError!*Inst {
-    const label_name = inst.positionals.label;
+    const block = inst.positionals.block;
     const void_inst = try self.constVoid(scope, inst.base.src);
+    return self.analyzeBreak(scope, inst.base.src, block, void_inst);
+}
+fn analyzeBreak(
+    self: *Module,
+    scope: *Scope,
+    src: usize,
+    zir_block: *zir.Inst.Block,
+    operand: *Inst,
+) InnerError!*Inst {
     var opt_block = scope.cast(Scope.Block);
     while (opt_block) |block| {
         if (block.label) |*label| {
-            if (mem.eql(u8, label.name, label_name)) {
+            if (label.zir_block == zir_block) {
-                try label.results.append(self.allocator, void_inst);
+                try label.results.append(self.gpa, operand);
-                return self.constNoReturn(scope, inst.base.src);
+                const b = try self.requireRuntimeBlock(scope, src);
+                return self.addNewInstArgs(b, src, Type.initTag(.noreturn), Inst.Br, .{
+                    .block = label.block_inst,
+                    .operand = operand,
+                });
             }
         }
         opt_block = block.parent;
-    } else {
+    } else unreachable;
-        return self.fail(scope, inst.base.src, "use of undeclared label '{}'", .{label_name});
-    }
 }
 fn analyzeInstDeclRefStr(self: *Module, scope: *Scope, inst: *zir.Inst.DeclRefStr) InnerError!*Inst {
 @@ -2718,8 +2829,8 @@ fn analyzeInstCall(self: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerErro
     // TODO handle function calls of generic functions
-    const fn_param_types = try self.allocator.alloc(Type, fn_params_len);
+    const fn_param_types = try self.gpa.alloc(Type, fn_params_len);
-    defer self.allocator.free(fn_param_types);
+    defer self.gpa.free(fn_param_types);
     func.ty.fnParamTypes(fn_param_types);
     const casted_args = try scope.arena().alloc(*Inst, fn_params_len);
 @@ -2738,7 +2849,7 @@ fn analyzeInstCall(self: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerErro
 fn analyzeInstFn(self: *Module, scope: *Scope, fn_inst: *zir.Inst.Fn) InnerError!*Inst {
     const fn_type = try self.resolveType(scope, fn_inst.positionals.fn_type);
     const fn_zir = blk: {
-        var fn_arena = std.heap.ArenaAllocator.init(self.allocator);
+        var fn_arena = std.heap.ArenaAllocator.init(self.gpa);
         errdefer fn_arena.deinit();
         const fn_zir = try scope.arena().create(Fn.ZIR);
 @@ -2763,6 +2874,10 @@ fn analyzeInstFn(self: *Module, scope: *Scope, fn_inst: *zir.Inst.Fn) InnerError
     });
 }
+fn analyzeInstIntType(self: *Module, scope: *Scope, inttype: *zir.Inst.IntType) InnerError!*Inst {
+    return self.fail(scope, inttype.base.src, "TODO implement inttype", .{});
+}
 fn analyzeInstFnType(self: *Module, scope: *Scope, fntype: *zir.Inst.FnType) InnerError!*Inst {
     const return_type = try self.resolveType(scope, fntype.positionals.return_type);
 @@ -2923,6 +3038,10 @@ fn analyzeInstElemPtr(self: *Module, scope: *Scope, inst: *zir.Inst.ElemPtr) Inn
     return self.fail(scope, inst.base.src, "TODO implement more analyze elemptr", .{});
 }
+fn analyzeInstSub(self: *Module, scope: *Scope, inst: *zir.Inst.Sub) InnerError!*Inst {
+    return self.fail(scope, inst.base.src, "TODO implement analysis of sub", .{});
+}
 fn analyzeInstAdd(self: *Module, scope: *Scope, inst: *zir.Inst.Add) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -3119,7 +3238,7 @@ fn analyzeInstCondBr(self: *Module, scope: *Scope, inst: *zir.Inst.CondBr) Inner
         .instructions = .{},
         .arena = parent_block.arena,
     };
-    defer true_block.instructions.deinit(self.allocator);
+    defer true_block.instructions.deinit(self.gpa);
     try self.analyzeBody(&true_block.base, inst.positionals.true_body);
     var false_block: Scope.Block = .{
 @@ -3129,7 +3248,7 @@ fn analyzeInstCondBr(self: *Module, scope: *Scope, inst: *zir.Inst.CondBr) Inner
         .instructions = .{},
         .arena = parent_block.arena,
     };
-    defer false_block.instructions.deinit(self.allocator);
+    defer false_block.instructions.deinit(self.gpa);
     try self.analyzeBody(&false_block.base, inst.positionals.false_body);
     return self.addNewInstArgs(parent_block, inst.base.src, Type.initTag(.void), Inst.CondBr, Inst.Args(Inst.CondBr){
 @@ -3283,7 +3402,7 @@ fn cmpNumeric(
             return self.constUndef(scope, src, Type.initTag(.bool));
         const is_unsigned = if (lhs_is_float) x: {
             var bigint_space: Value.BigIntSpace = undefined;
-            var bigint = try lhs_val.toBigInt(&bigint_space).toManaged(self.allocator);
+            var bigint = try lhs_val.toBigInt(&bigint_space).toManaged(self.gpa);
             defer bigint.deinit();
             const zcmp = lhs_val.orderAgainstZero();
             if (lhs_val.floatHasFraction()) {
 @@ -3318,7 +3437,7 @@ fn cmpNumeric(
             return self.constUndef(scope, src, Type.initTag(.bool));
         const is_unsigned = if (rhs_is_float) x: {
             var bigint_space: Value.BigIntSpace = undefined;
-            var bigint = try rhs_val.toBigInt(&bigint_space).toManaged(self.allocator);
+            var bigint = try rhs_val.toBigInt(&bigint_space).toManaged(self.gpa);
             defer bigint.deinit();
             const zcmp = rhs_val.orderAgainstZero();
             if (rhs_val.floatHasFraction()) {
 @@ -3355,7 +3474,7 @@ fn cmpNumeric(
         break :blk try self.makeIntType(scope, dest_int_is_signed, casted_bits);
     };
     const casted_lhs = try self.coerce(scope, dest_type, lhs);
-    const casted_rhs = try self.coerce(scope, dest_type, lhs);
+    const casted_rhs = try self.coerce(scope, dest_type, rhs);
     return self.addNewInstArgs(b, src, Type.initTag(.bool), Inst.Cmp, .{
         .lhs = casted_lhs,
 @@ -3379,6 +3498,8 @@ fn makeIntType(self: *Module, scope: *Scope, signed: bool, bits: u16) !Type {
 fn resolvePeerTypes(self: *Module, scope: *Scope, instructions: []*Inst) !Type {
     if (instructions.len == 0)
         return Type.initTag(.noreturn);
+    if (instructions.len == 1)
+        return instructions[0].ty;
     return self.fail(scope, instructions[0].src, "TODO peer type resolution", .{});
 }
 @@ -3456,7 +3577,7 @@ fn coerceArrayPtrToSlice(self: *Module, scope: *Scope, dest_type: Type, inst: *I
 fn fail(self: *Module, scope: *Scope, src: usize, comptime format: []const u8, args: var) InnerError {
     @setCold(true);
-    const err_msg = try ErrorMsg.create(self.allocator, src, format, args);
+    const err_msg = try ErrorMsg.create(self.gpa, src, format, args);
     return self.failWithOwnedErrorMsg(scope, src, err_msg);
 }
 @@ -3486,9 +3607,9 @@ fn failNode(
 fn failWithOwnedErrorMsg(self: *Module, scope: *Scope, src: usize, err_msg: *ErrorMsg) InnerError {
     {
-        errdefer err_msg.destroy(self.allocator);
+        errdefer err_msg.destroy(self.gpa);
-        try self.failed_decls.ensureCapacity(self.failed_decls.items().len + 1);
+        try self.failed_decls.ensureCapacity(self.gpa, self.failed_decls.items().len + 1);
-        try self.failed_files.ensureCapacity(self.failed_files.items().len + 1);
+        try self.failed_files.ensureCapacity(self.gpa, self.failed_files.items().len + 1);
     }
     switch (scope.tag) {
         .decl => {
 @@ -3541,28 +3662,28 @@ pub const ErrorMsg = struct {
     byte_offset: usize,
     msg: []const u8,
-    pub fn create(allocator: *Allocator, byte_offset: usize, comptime format: []const u8, args: var) !*ErrorMsg {
+    pub fn create(gpa: *Allocator, byte_offset: usize, comptime format: []const u8, args: var) !*ErrorMsg {
-        const self = try allocator.create(ErrorMsg);
+        const self = try gpa.create(ErrorMsg);
-        errdefer allocator.destroy(self);
+        errdefer gpa.destroy(self);
-        self.* = try init(allocator, byte_offset, format, args);
+        self.* = try init(gpa, byte_offset, format, args);
         return self;
     }
     /// Assumes the ErrorMsg struct and msg were both allocated with allocator.
-    pub fn destroy(self: *ErrorMsg, allocator: *Allocator) void {
+    pub fn destroy(self: *ErrorMsg, gpa: *Allocator) void {
-        self.deinit(allocator);
+        self.deinit(gpa);
-        allocator.destroy(self);
+        gpa.destroy(self);
     }
-    pub fn init(allocator: *Allocator, byte_offset: usize, comptime format: []const u8, args: var) !ErrorMsg {
+    pub fn init(gpa: *Allocator, byte_offset: usize, comptime format: []const u8, args: var) !ErrorMsg {
         return ErrorMsg{
             .byte_offset = byte_offset,
-            .msg = try std.fmt.allocPrint(allocator, format, args),
+            .msg = try std.fmt.allocPrint(gpa, format, args),
         };
     }
-    pub fn deinit(self: *ErrorMsg, allocator: *Allocator) void {
+    pub fn deinit(self: *ErrorMsg, gpa: *Allocator) void {
-        allocator.free(self.msg);
+        gpa.free(self.msg);
         self.* = undefined;
     }
 };

src-self-hosted/codegen.zig+460-83

...	@@ -12,6 +12,18 @@ const Target = std.Target;	...	@@ -12,6 +12,18 @@ const Target = std.Target;
12	const Allocator = mem.Allocator;	12	const Allocator = mem.Allocator;
13	const trace = @import("tracy.zig").trace;	13	const trace = @import("tracy.zig").trace;
14		14
		15	/// The codegen-related data that is stored in `ir.Inst.Block` instructions.
		16	pub const BlockData = struct {
		17	relocs: std.ArrayListUnmanaged(Reloc) = .{},
		18	};
		19
		20	pub const Reloc = union(enum) {
		21	/// The value is an offset into the `Function` `code` from the beginning.
		22	/// To perform the reloc, write 32-bit signed little-endian integer
		23	/// which is a relative jump, based on the address following the reloc.
		24	rel32: usize,
		25	};
		26
15	pub const Result = union(enum) {	27	pub const Result = union(enum) {
16	/// The `code` parameter passed to `generateSymbol` has the value appended.	28	/// The `code` parameter passed to `generateSymbol` has the value appended.
17	appended: void,	29	appended: void,
...	@@ -46,7 +58,14 @@ pub fn generateSymbol(	...	@@ -46,7 +58,14 @@ pub fn generateSymbol(
46	var mc_args = try std.ArrayList(Function.MCValue).initCapacity(bin_file.allocator, param_types.len);	58	var mc_args = try std.ArrayList(Function.MCValue).initCapacity(bin_file.allocator, param_types.len);
47	defer mc_args.deinit();	59	defer mc_args.deinit();
48		60
49	var next_stack_offset: u64 = 0;	61	var branch_stack = std.ArrayList(Function.Branch).init(bin_file.allocator);
		62	defer {
		63	assert(branch_stack.items.len == 1);
		64	branch_stack.items[0].deinit(bin_file.allocator);
		65	branch_stack.deinit();
		66	}
		67	const branch = try branch_stack.addOne();
		68	branch.* = .{};
50		69
51	switch (fn_type.fnCallingConvention()) {	70	switch (fn_type.fnCallingConvention()) {
52	.Naked => assert(mc_args.items.len == 0),	71	.Naked => assert(mc_args.items.len == 0),
...	@@ -61,8 +80,8 @@ pub fn generateSymbol(	...	@@ -61,8 +80,8 @@ pub fn generateSymbol(
61	switch (param_type.zigTypeTag()) {	80	switch (param_type.zigTypeTag()) {
62	.Bool, .Int => {	81	.Bool, .Int => {
63	if (next_int_reg >= integer_registers.len) {	82	if (next_int_reg >= integer_registers.len) {
64	try mc_args.append(.{ .stack_offset = next_stack_offset });	83	try mc_args.append(.{ .stack_offset = branch.next_stack_offset });
65	next_stack_offset += param_type.abiSize(bin_file.options.target);	84	branch.next_stack_offset += @intCast(u32, param_type.abiSize(bin_file.options.target));
66	} else {	85	} else {
67	try mc_args.append(.{ .register = @enumToInt(integer_registers[next_int_reg]) });	86	try mc_args.append(.{ .register = @enumToInt(integer_registers[next_int_reg]) });
68	next_int_reg += 1;	87	next_int_reg += 1;
...	@@ -100,16 +119,17 @@ pub fn generateSymbol(	...	@@ -100,16 +119,17 @@ pub fn generateSymbol(
100	}	119	}
101		120
102	var function = Function{	121	var function = Function{
		122	.gpa = bin_file.allocator,
103	.target = &bin_file.options.target,	123	.target = &bin_file.options.target,
104	.bin_file = bin_file,	124	.bin_file = bin_file,
105	.mod_fn = module_fn,	125	.mod_fn = module_fn,
106	.code = code,	126	.code = code,
107	.inst_table = std.AutoHashMap(*ir.Inst, Function.MCValue).init(bin_file.allocator),
108	.err_msg = null,	127	.err_msg = null,
109	.args = mc_args.items,	128	.args = mc_args.items,
		129	.branch_stack = &branch_stack,
110	};	130	};
111	defer function.inst_table.deinit();
112		131
		132	branch.max_end_stack = branch.next_stack_offset;
113	function.gen() catch \|err\| switch (err) {	133	function.gen() catch \|err\| switch (err) {
114	error.CodegenFail => return Result{ .fail = function.err_msg.? },	134	error.CodegenFail => return Result{ .fail = function.err_msg.? },
115	else => \|e\| return e,	135	else => \|e\| return e,
...	@@ -210,18 +230,67 @@ pub fn generateSymbol(	...	@@ -210,18 +230,67 @@ pub fn generateSymbol(
210	}	230	}
211	}	231	}
212		232
		233	const InnerError = error {
		234	OutOfMemory,
		235	CodegenFail,
		236	};
		237
213	const Function = struct {	238	const Function = struct {
		239	gpa: *Allocator,
214	bin_file: *link.File.Elf,	240	bin_file: *link.File.Elf,
215	target: *const std.Target,	241	target: *const std.Target,
216	mod_fn: *const Module.Fn,	242	mod_fn: *const Module.Fn,
217	code: *std.ArrayList(u8),	243	code: *std.ArrayList(u8),
218	inst_table: std.AutoHashMap(*ir.Inst, MCValue),
219	err_msg: ?*ErrorMsg,	244	err_msg: ?*ErrorMsg,
220	args: []MCValue,	245	args: []MCValue,
221		246
		247	/// Whenever there is a runtime branch, we push a Branch onto this stack,
		248	/// and pop it off when the runtime branch joins. This provides an "overlay"
		249	/// of the table of mappings from instructions to `MCValue` from within the branch.
		250	/// This way we can modify the `MCValue` for an instruction in different ways
		251	/// within different branches. Special consideration is needed when a branch
		252	/// joins with its parent, to make sure all instructions have the same MCValue
		253	/// across each runtime branch upon joining.
		254	branch_stack: *std.ArrayList(Branch),
		255
		256	const Branch = struct {
		257	inst_table: std.AutoHashMapUnmanaged(*ir.Inst, MCValue) = .{},
		258
		259	/// The key is an enum value of an arch-specific register.
		260	registers: std.AutoHashMapUnmanaged(usize, RegisterAllocation) = .{},
		261
		262	/// Maps offset to what is stored there.
		263	stack: std.AutoHashMapUnmanaged(usize, StackAllocation) = .{},
		264	/// Offset from the stack base, representing the end of the stack frame.
		265	max_end_stack: u32 = 0,
		266	/// Represents the current end stack offset. If there is no existing slot
		267	/// to place a new stack allocation, it goes here, and then bumps `max_end_stack`.
		268	next_stack_offset: u32 = 0,
		269
		270	fn deinit(self: Branch, gpa: Allocator) void {
		271	self.inst_table.deinit(gpa);
		272	self.registers.deinit(gpa);
		273	self.stack.deinit(gpa);
		274	self.* = undefined;
		275	}
		276	};
		277
		278	const RegisterAllocation = struct {
		279	inst: *ir.Inst,
		280	};
		281
		282	const StackAllocation = struct {
		283	inst: *ir.Inst,
		284	size: u32,
		285	};
		286
222	const MCValue = union(enum) {	287	const MCValue = union(enum) {
		288	/// No runtime bits. `void` types, empty structs, u0, enums with 1 tag, etc.
223	none,	289	none,
		290	/// Control flow will not allow this value to be observed.
224	unreach,	291	unreach,
		292	/// No more references to this value remain.
		293	dead,
225	/// A pointer-sized integer that fits in a register.	294	/// A pointer-sized integer that fits in a register.
226	immediate: u64,	295	immediate: u64,
227	/// The constant was emitted into the code, at this offset.	296	/// The constant was emitted into the code, at this offset.
...	@@ -233,6 +302,45 @@ const Function = struct {	...	@@ -233,6 +302,45 @@ const Function = struct {
233	memory: u64,	302	memory: u64,
234	/// The value is one of the stack variables.	303	/// The value is one of the stack variables.
235	stack_offset: u64,	304	stack_offset: u64,
		305	/// The value is in the compare flags assuming an unsigned operation,
		306	/// with this operator applied on top of it.
		307	compare_flags_unsigned: std.math.CompareOperator,
		308	/// The value is in the compare flags assuming a signed operation,
		309	/// with this operator applied on top of it.
		310	compare_flags_signed: std.math.CompareOperator,
		311
		312	fn isMemory(mcv: MCValue) bool {
		313	return switch (mcv) {
		314	.embedded_in_code, .memory, .stack_offset => true,
		315	else => false,
		316	};
		317	}
		318
		319	fn isImmediate(mcv: MCValue) bool {
		320	return switch (mcv) {
		321	.immediate => true,
		322	else => false,
		323	};
		324	}
		325
		326	fn isMutable(mcv: MCValue) bool {
		327	return switch (mcv) {
		328	.none => unreachable,
		329	.unreach => unreachable,
		330	.dead => unreachable,
		331
		332	.immediate,
		333	.embedded_in_code,
		334	.memory,
		335	.compare_flags_unsigned,
		336	.compare_flags_signed,
		337	=> false,
		338
		339	.register,
		340	.stack_offset,
		341	=> true,
		342	};
		343	}
236	};	344	};
237		345
238	fn gen(self: *Function) !void {	346	fn gen(self: *Function) !void {
...	@@ -292,9 +400,14 @@ const Function = struct {	...	@@ -292,9 +400,14 @@ const Function = struct {
292	}	400	}
293		401
294	fn genArch(self: *Function, comptime arch: std.Target.Cpu.Arch) !void {	402	fn genArch(self: *Function, comptime arch: std.Target.Cpu.Arch) !void {
295	for (self.mod_fn.analysis.success.instructions) \|inst\| {	403	return self.genBody(self.mod_fn.analysis.success, arch);
		404	}
		405
		406	fn genBody(self: *Function, body: ir.Body, comptime arch: std.Target.Cpu.Arch) InnerError!void {
		407	const inst_table = &self.branch_stack.items[0].inst_table;
		408	for (body.instructions) \|inst\| {
296	const new_inst = try self.genFuncInst(inst, arch);	409	const new_inst = try self.genFuncInst(inst, arch);
297	try self.inst_table.putNoClobber(inst, new_inst);	410	try inst_table.putNoClobber(self.gpa, inst, new_inst);
298	}	411	}
299	}	412	}
300		413
...	@@ -302,39 +415,166 @@ const Function = struct {	...	@@ -302,39 +415,166 @@ const Function = struct {
302	switch (inst.tag) {	415	switch (inst.tag) {
303	.add => return self.genAdd(inst.cast(ir.Inst.Add).?, arch),	416	.add => return self.genAdd(inst.cast(ir.Inst.Add).?, arch),
304	.arg => return self.genArg(inst.cast(ir.Inst.Arg).?),	417	.arg => return self.genArg(inst.cast(ir.Inst.Arg).?),
		418	.assembly => return self.genAsm(inst.cast(ir.Inst.Assembly).?, arch),
		419	.bitcast => return self.genBitCast(inst.cast(ir.Inst.BitCast).?),
305	.block => return self.genBlock(inst.cast(ir.Inst.Block).?, arch),	420	.block => return self.genBlock(inst.cast(ir.Inst.Block).?, arch),
		421	.br => return self.genBr(inst.cast(ir.Inst.Br).?, arch),
306	.breakpoint => return self.genBreakpoint(inst.src, arch),	422	.breakpoint => return self.genBreakpoint(inst.src, arch),
		423	.brvoid => return self.genBrVoid(inst.cast(ir.Inst.BrVoid).?, arch),
307	.call => return self.genCall(inst.cast(ir.Inst.Call).?, arch),	424	.call => return self.genCall(inst.cast(ir.Inst.Call).?, arch),
308	.unreach => return MCValue{ .unreach = {} },	425	.cmp => return self.genCmp(inst.cast(ir.Inst.Cmp).?, arch),
		426	.condbr => return self.genCondBr(inst.cast(ir.Inst.CondBr).?, arch),
309	.constant => unreachable, // excluded from function bodies	427	.constant => unreachable, // excluded from function bodies
310	.assembly => return self.genAsm(inst.cast(ir.Inst.Assembly).?, arch),	428	.isnonnull => return self.genIsNonNull(inst.cast(ir.Inst.IsNonNull).?, arch),
		429	.isnull => return self.genIsNull(inst.cast(ir.Inst.IsNull).?, arch),
311	.ptrtoint => return self.genPtrToInt(inst.cast(ir.Inst.PtrToInt).?),	430	.ptrtoint => return self.genPtrToInt(inst.cast(ir.Inst.PtrToInt).?),
312	.bitcast => return self.genBitCast(inst.cast(ir.Inst.BitCast).?),
313	.ret => return self.genRet(inst.cast(ir.Inst.Ret).?, arch),	431	.ret => return self.genRet(inst.cast(ir.Inst.Ret).?, arch),
314	.retvoid => return self.genRetVoid(inst.cast(ir.Inst.RetVoid).?, arch),	432	.retvoid => return self.genRetVoid(inst.cast(ir.Inst.RetVoid).?, arch),
315	.cmp => return self.genCmp(inst.cast(ir.Inst.Cmp).?, arch),	433	.sub => return self.genSub(inst.cast(ir.Inst.Sub).?, arch),
316	.condbr => return self.genCondBr(inst.cast(ir.Inst.CondBr).?, arch),	434	.unreach => return MCValue{ .unreach = {} },
317	.isnull => return self.genIsNull(inst.cast(ir.Inst.IsNull).?, arch),
318	.isnonnull => return self.genIsNonNull(inst.cast(ir.Inst.IsNonNull).?, arch),
319	}	435	}
320	}	436	}
321		437
322	fn genAdd(self: Function, inst: ir.Inst.Add, comptime arch: std.Target.Cpu.Arch) !MCValue {	438	fn genAdd(self: Function, inst: ir.Inst.Add, comptime arch: std.Target.Cpu.Arch) !MCValue {
323	const lhs = try self.resolveInst(inst.args.lhs);	439	// No side effects, so if it's unreferenced, do nothing.
324	const rhs = try self.resolveInst(inst.args.rhs);	440	if (inst.base.isUnused())
		441	return MCValue.dead;
325	switch (arch) {	442	switch (arch) {
326	.i386, .x86_64 => {	443	.x86_64 => {
327	// const lhs_reg = try self.instAsReg(lhs);	444	return try self.genX8664BinMath(&inst.base, inst.args.lhs, inst.args.rhs, 0, 0x00);
328	// const rhs_reg = try self.instAsReg(rhs);	445	},
329	// const result = try self.allocateReg();	446	else => return self.fail(inst.base.src, "TODO implement add for {}", .{self.target.cpu.arch}),
		447	}
		448	}
330		449
331	// try self.code.append(??);	450	fn genSub(self: Function, inst: ir.Inst.Sub, comptime arch: std.Target.Cpu.Arch) !MCValue {
		451	// No side effects, so if it's unreferenced, do nothing.
		452	if (inst.base.isUnused())
		453	return MCValue.dead;
		454	switch (arch) {
		455	.x86_64 => {
		456	return try self.genX8664BinMath(&inst.base, inst.args.lhs, inst.args.rhs, 5, 0x28);
		457	},
		458	else => return self.fail(inst.base.src, "TODO implement sub for {}", .{self.target.cpu.arch}),
		459	}
		460	}
		461
		462	/// ADD, SUB
		463	fn genX8664BinMath(self: Function, inst: ir.Inst, op_lhs: ir.Inst, op_rhs: ir.Inst, opx: u8, mr: u8) !MCValue {
		464	try self.code.ensureCapacity(self.code.items.len + 8);
		465
		466	const lhs = try self.resolveInst(op_lhs);
		467	const rhs = try self.resolveInst(op_rhs);
332		468
333	// lhs_reg.release();	469	// There are 2 operands, destination and source.
334	// rhs_reg.release();	470	// Either one, but not both, can be a memory operand.
335	return self.fail(inst.base.src, "TODO implement register allocation", .{});	471	// Source operand can be an immediate, 8 bits or 32 bits.
		472	// So, if either one of the operands dies with this instruction, we can use it
		473	// as the result MCValue.
		474	var dst_mcv: MCValue = undefined;
		475	var src_mcv: MCValue = undefined;
		476	var src_inst: *ir.Inst = undefined;
		477	if (inst.operandDies(0) and lhs.isMutable()) {
		478	// LHS dies; use it as the destination.
		479	// Both operands cannot be memory.
		480	src_inst = op_rhs;
		481	if (lhs.isMemory() and rhs.isMemory()) {
		482	dst_mcv = try self.copyToNewRegister(op_lhs);
		483	src_mcv = rhs;
		484	} else {
		485	dst_mcv = lhs;
		486	src_mcv = rhs;
		487	}
		488	} else if (inst.operandDies(1) and rhs.isMutable()) {
		489	// RHS dies; use it as the destination.
		490	// Both operands cannot be memory.
		491	src_inst = op_lhs;
		492	if (lhs.isMemory() and rhs.isMemory()) {
		493	dst_mcv = try self.copyToNewRegister(op_rhs);
		494	src_mcv = lhs;
		495	} else {
		496	dst_mcv = rhs;
		497	src_mcv = lhs;
		498	}
		499	} else {
		500	if (lhs.isMemory()) {
		501	dst_mcv = try self.copyToNewRegister(op_lhs);
		502	src_mcv = rhs;
		503	src_inst = op_rhs;
		504	} else {
		505	dst_mcv = try self.copyToNewRegister(op_rhs);
		506	src_mcv = lhs;
		507	src_inst = op_lhs;
		508	}
		509	}
		510	// This instruction supports only signed 32-bit immediates at most. If the immediate
		511	// value is larger than this, we put it in a register.
		512	// A potential opportunity for future optimization here would be keeping track
		513	// of the fact that the instruction is available both as an immediate
		514	// and as a register.
		515	switch (src_mcv) {
		516	.immediate => \|imm\| {
		517	if (imm > std.math.maxInt(u31)) {
		518	src_mcv = try self.copyToNewRegister(src_inst);
		519	}
		520	},
		521	else => {},
		522	}
		523
		524	try self.genX8664BinMathCode(inst.src, dst_mcv, src_mcv, opx, mr);
		525
		526	return dst_mcv;
		527	}
		528
		529	fn genX8664BinMathCode(self: *Function, src: usize, dst_mcv: MCValue, src_mcv: MCValue, opx: u8, mr: u8) !void {
		530	switch (dst_mcv) {
		531	.none => unreachable,
		532	.dead, .unreach, .immediate => unreachable,
		533	.compare_flags_unsigned => unreachable,
		534	.compare_flags_signed => unreachable,
		535	.register => \|dst_reg_usize\| {
		536	const dst_reg = @intToEnum(Reg(.x86_64), @intCast(u8, dst_reg_usize));
		537	switch (src_mcv) {
		538	.none => unreachable,
		539	.dead, .unreach => unreachable,
		540	.register => \|src_reg_usize\| {
		541	const src_reg = @intToEnum(Reg(.x86_64), @intCast(u8, src_reg_usize));
		542	self.rex(.{ .b = dst_reg.isExtended(), .r = src_reg.isExtended(), .w = dst_reg.size() == 64 });
		543	self.code.appendSliceAssumeCapacity(&[_]u8{ mr + 0x1, 0xC0 \| (@as(u8, src_reg.id() & 0b111) << 3) \| @as(u8, dst_reg.id() & 0b111) });
		544	},
		545	.immediate => \|imm\| {
		546	const imm32 = @intCast(u31, imm); // This case must be handled before calling genX8664BinMathCode.
		547	// 81 /opx id
		548	if (imm32 <= std.math.maxInt(u7)) {
		549	self.rex(.{ .b = dst_reg.isExtended(), .w = dst_reg.size() == 64 });
		550	self.code.appendSliceAssumeCapacity(&[_]u8{
		551	0x83,
		552	0xC0 \| (opx << 3) \| @truncate(u3, dst_reg.id()),
		553	@intCast(u8, imm32),
		554	});
		555	} else {
		556	self.rex(.{ .r = dst_reg.isExtended(), .w = dst_reg.size() == 64 });
		557	self.code.appendSliceAssumeCapacity(&[_]u8{
		558	0x81,
		559	0xC0 \| (opx << 3) \| @truncate(u3, dst_reg.id()),
		560	});
		561	std.mem.writeIntLittle(u32, self.code.addManyAsArrayAssumeCapacity(4), imm32);
		562	}
		563	},
		564	.embedded_in_code, .memory, .stack_offset => {
		565	return self.fail(src, "TODO implement x86 ADD/SUB/CMP source memory", .{});
		566	},
		567	.compare_flags_unsigned => {
		568	return self.fail(src, "TODO implement x86 ADD/SUB/CMP source compare flag (unsigned)", .{});
		569	},
		570	.compare_flags_signed => {
		571	return self.fail(src, "TODO implement x86 ADD/SUB/CMP source compare flag (signed)", .{});
		572	},
		573	}
		574	},
		575	.embedded_in_code, .memory, .stack_offset => {
		576	return self.fail(src, "TODO implement x86 ADD/SUB/CMP destination memory", .{});
336	},	577	},
337	else => return self.fail(inst.base.src, "TODO implement add for {}", .{self.target.cpu.arch}),
338	}	578	}
339	}	579	}
340		580
...	@@ -410,17 +650,86 @@ const Function = struct {	...	@@ -410,17 +650,86 @@ const Function = struct {
410	}	650	}
411		651
412	fn genCmp(self: Function, inst: ir.Inst.Cmp, comptime arch: std.Target.Cpu.Arch) !MCValue {	652	fn genCmp(self: Function, inst: ir.Inst.Cmp, comptime arch: std.Target.Cpu.Arch) !MCValue {
		653	// No side effects, so if it's unreferenced, do nothing.
		654	if (inst.base.isUnused())
		655	return MCValue.dead;
413	switch (arch) {	656	switch (arch) {
		657	.x86_64 => {
		658	try self.code.ensureCapacity(self.code.items.len + 8);
		659
		660	const lhs = try self.resolveInst(inst.args.lhs);
		661	const rhs = try self.resolveInst(inst.args.rhs);
		662
		663	// There are 2 operands, destination and source.
		664	// Either one, but not both, can be a memory operand.
		665	// Source operand can be an immediate, 8 bits or 32 bits.
		666	const dst_mcv = if (lhs.isImmediate() or (lhs.isMemory() and rhs.isMemory()))
		667	try self.copyToNewRegister(inst.args.lhs)
		668	else
		669	lhs;
		670	// This instruction supports only signed 32-bit immediates at most.
		671	const src_mcv = try self.limitImmediateType(inst.args.rhs, i32);
		672
		673	try self.genX8664BinMathCode(inst.base.src, dst_mcv, src_mcv, 7, 0x38);
		674	const info = inst.args.lhs.ty.intInfo(self.target.*);
		675	if (info.signed) {
		676	return MCValue{.compare_flags_signed = inst.args.op};
		677	} else {
		678	return MCValue{.compare_flags_unsigned = inst.args.op};
		679	}
		680	},
414	else => return self.fail(inst.base.src, "TODO implement cmp for {}", .{self.target.cpu.arch}),	681	else => return self.fail(inst.base.src, "TODO implement cmp for {}", .{self.target.cpu.arch}),
415	}	682	}
416	}	683	}
417		684
418	fn genCondBr(self: Function, inst: ir.Inst.CondBr, comptime arch: std.Target.Cpu.Arch) !MCValue {	685	fn genCondBr(self: Function, inst: ir.Inst.CondBr, comptime arch: std.Target.Cpu.Arch) !MCValue {
419	switch (arch) {	686	switch (arch) {
		687	.i386, .x86_64 => {
		688	try self.code.ensureCapacity(self.code.items.len + 6);
		689
		690	const cond = try self.resolveInst(inst.args.condition);
		691	switch (cond) {
		692	.compare_flags_signed => \|cmp_op\| {
		693	// Here we map to the opposite opcode because the jump is to the false branch.
		694	const opcode: u8 = switch (cmp_op) {
		695	.gte => 0x8c,
		696	.gt => 0x8e,
		697	.neq => 0x84,
		698	.lt => 0x8d,
		699	.lte => 0x8f,
		700	.eq => 0x85,
		701	};
		702	return self.genX86CondBr(inst, opcode, arch);
		703	},
		704	.compare_flags_unsigned => \|cmp_op\| {
		705	// Here we map to the opposite opcode because the jump is to the false branch.
		706	const opcode: u8 = switch (cmp_op) {
		707	.gte => 0x82,
		708	.gt => 0x86,
		709	.neq => 0x84,
		710	.lt => 0x83,
		711	.lte => 0x87,
		712	.eq => 0x85,
		713	};
		714	return self.genX86CondBr(inst, opcode, arch);
		715	},
		716	else => return self.fail(inst.base.src, "TODO implement condbr {} when condition not already in the compare flags", .{self.target.cpu.arch}),
		717	}
		718	},
420	else => return self.fail(inst.base.src, "TODO implement condbr for {}", .{self.target.cpu.arch}),	719	else => return self.fail(inst.base.src, "TODO implement condbr for {}", .{self.target.cpu.arch}),
421	}	720	}
422	}	721	}
423		722
		723	fn genX86CondBr(self: Function, inst: ir.Inst.CondBr, opcode: u8, comptime arch: std.Target.Cpu.Arch) !MCValue {
		724	self.code.appendSliceAssumeCapacity(&[_]u8{0x0f, opcode});
		725	const reloc = Reloc{ .rel32 = self.code.items.len };
		726	self.code.items.len += 4;
		727	try self.genBody(inst.args.true_body, arch);
		728	try self.performReloc(inst.base.src, reloc);
		729	try self.genBody(inst.args.false_body, arch);
		730	return MCValue.unreach;
		731	}
		732
424	fn genIsNull(self: Function, inst: ir.Inst.IsNull, comptime arch: std.Target.Cpu.Arch) !MCValue {	733	fn genIsNull(self: Function, inst: ir.Inst.IsNull, comptime arch: std.Target.Cpu.Arch) !MCValue {
425	switch (arch) {	734	switch (arch) {
426	else => return self.fail(inst.base.src, "TODO implement isnull for {}", .{self.target.cpu.arch}),	735	else => return self.fail(inst.base.src, "TODO implement isnull for {}", .{self.target.cpu.arch}),
...	@@ -435,29 +744,52 @@ const Function = struct {	...	@@ -435,29 +744,52 @@ const Function = struct {
435	}	744	}
436	}	745	}
437		746
438	fn genRelativeFwdJump(self: *Function, src: usize, comptime arch: std.Target.Cpu.Arch, amount: u32) !void {	747	fn genBlock(self: Function, inst: ir.Inst.Block, comptime arch: std.Target.Cpu.Arch) !MCValue {
439	switch (arch) {	748	if (inst.base.ty.hasCodeGenBits()) {
440	.i386, .x86_64 => {	749	return self.fail(inst.base.src, "TODO codegen Block with non-void type", .{});
441	// TODO x86 treats the operands as signed	750	}
442	if (amount <= std.math.maxInt(u8)) {	751	// A block is nothing but a setup to be able to jump to the end.
443	try self.code.resize(self.code.items.len + 2);	752	defer inst.codegen.relocs.deinit(self.gpa);
444	self.code.items[self.code.items.len - 2] = 0xeb;	753	try self.genBody(inst.args.body, arch);
445	self.code.items[self.code.items.len - 1] = @intCast(u8, amount);	754
446	} else {	755	for (inst.codegen.relocs.items) \|reloc\| try self.performReloc(inst.base.src, reloc);
447	try self.code.resize(self.code.items.len + 5);	756
448	self.code.items[self.code.items.len - 5] = 0xe9; // jmp rel32	757	return MCValue.none;
449	const imm_ptr = self.code.items[self.code.items.len - 4 ..][0..4];	758	}
450	mem.writeIntLittle(u32, imm_ptr, amount);	759
451	}	760	fn performReloc(self: *Function, src: usize, reloc: Reloc) !void {
		761	switch (reloc) {
		762	.rel32 => \|pos\| {
		763	const amt = self.code.items.len - (pos + 4);
		764	const s32_amt = std.math.cast(i32, amt) catch
		765	return self.fail(src, "unable to perform relocation: jump too far", .{});
		766	mem.writeIntLittle(i32, self.code.items[pos..][0..4], s32_amt);
452	},	767	},
453	else => return self.fail(src, "TODO implement relative forward jump for {}", .{self.target.cpu.arch}),
454	}	768	}
455	}	769	}
456		770
457	fn genBlock(self: Function, inst: ir.Inst.Block, comptime arch: std.Target.Cpu.Arch) !MCValue {	771	fn genBr(self: Function, inst: ir.Inst.Br, comptime arch: std.Target.Cpu.Arch) !MCValue {
458	switch (arch) {	772	switch (arch) {
459	else => return self.fail(inst.base.src, "TODO implement codegen Block for {}", .{self.target.cpu.arch}),	773	else => return self.fail(inst.base.src, "TODO implement br for {}", .{self.target.cpu.arch}),
		774	}
		775	}
		776
		777	fn genBrVoid(self: Function, inst: ir.Inst.BrVoid, comptime arch: std.Target.Cpu.Arch) !MCValue {
		778	// Emit a jump with a relocation. It will be patched up after the block ends.
		779	try inst.args.block.codegen.relocs.ensureCapacity(self.gpa, inst.args.block.codegen.relocs.items.len + 1);
		780
		781	switch (arch) {
		782	.i386, .x86_64 => {
		783	// TODO optimization opportunity: figure out when we can emit this as a 2 byte instruction
		784	// which is available if the jump is 127 bytes or less forward.
		785	try self.code.resize(self.code.items.len + 5);
		786	self.code.items[self.code.items.len - 5] = 0xe9; // jmp rel32
		787	// Leave the jump offset undefined
		788	inst.args.block.codegen.relocs.appendAssumeCapacity(.{ .rel32 = self.code.items.len - 4 });
		789	},
		790	else => return self.fail(inst.base.src, "TODO implement brvoid for {}", .{self.target.cpu.arch}),
460	}	791	}
		792	return .none;
461	}	793	}
462		794
463	fn genAsm(self: Function, inst: ir.Inst.Assembly, comptime arch: Target.Cpu.Arch) !MCValue {	795	fn genAsm(self: Function, inst: ir.Inst.Assembly, comptime arch: Target.Cpu.Arch) !MCValue {
...	@@ -502,30 +834,38 @@ const Function = struct {	...	@@ -502,30 +834,38 @@ const Function = struct {
502	/// resulting REX is meaningful, but will remain the same if it is not.	834	/// resulting REX is meaningful, but will remain the same if it is not.
503	/// * Deliberately inserting a "meaningless REX" requires explicit usage of	835	/// * Deliberately inserting a "meaningless REX" requires explicit usage of
504	/// 0x40, and cannot be done via this function.	836	/// 0x40, and cannot be done via this function.
505	fn REX(self: *Function, arg: struct { B: bool = false, W: bool = false, X: bool = false, R: bool = false }) !void {	837	fn rex(self: *Function, arg: struct { b: bool = false, w: bool = false, x: bool = false, r: bool = false }) void {
506	// From section 2.2.1.2 of the manual, REX is encoded as b0100WRXB.	838	// From section 2.2.1.2 of the manual, REX is encoded as b0100WRXB.
507	var value: u8 = 0x40;	839	var value: u8 = 0x40;
508	if (arg.B) {	840	if (arg.b) {
509	value \|= 0x1;	841	value \|= 0x1;
510	}	842	}
511	if (arg.X) {	843	if (arg.x) {
512	value \|= 0x2;	844	value \|= 0x2;
513	}	845	}
514	if (arg.R) {	846	if (arg.r) {
515	value \|= 0x4;	847	value \|= 0x4;
516	}	848	}
517	if (arg.W) {	849	if (arg.w) {
518	value \|= 0x8;	850	value \|= 0x8;
519	}	851	}
520	if (value != 0x40) {	852	if (value != 0x40) {
521	try self.code.append(value);	853	self.code.appendAssumeCapacity(value);
522	}	854	}
523	}	855	}
524		856
525	fn genSetReg(self: *Function, src: usize, comptime arch: Target.Cpu.Arch, reg: Reg(arch), mcv: MCValue) error{ CodegenFail, OutOfMemory }!void {	857	fn genSetReg(self: *Function, src: usize, comptime arch: Target.Cpu.Arch, reg: Reg(arch), mcv: MCValue) error{ CodegenFail, OutOfMemory }!void {
526	switch (arch) {	858	switch (arch) {
527	.x86_64 => switch (mcv) {	859	.x86_64 => switch (mcv) {
528	.none, .unreach => unreachable,	860	.dead => unreachable,
		861	.none => unreachable,
		862	.unreach => unreachable,
		863	.compare_flags_unsigned => \|op\| {
		864	return self.fail(src, "TODO set register with compare flags value (unsigned)", .{});
		865	},
		866	.compare_flags_signed => \|op\| {
		867	return self.fail(src, "TODO set register with compare flags value (signed)", .{});
		868	},
529	.immediate => \|x\| {	869	.immediate => \|x\| {
530	if (reg.size() != 64) {	870	if (reg.size() != 64) {
531	return self.fail(src, "TODO decide whether to implement non-64-bit loads", .{});	871	return self.fail(src, "TODO decide whether to implement non-64-bit loads", .{});
...	@@ -544,11 +884,11 @@ const Function = struct {	...	@@ -544,11 +884,11 @@ const Function = struct {
544	// If we're accessing e.g. r8d, we need to use a REX prefix before the actual operation. Since	884	// If we're accessing e.g. r8d, we need to use a REX prefix before the actual operation. Since
545	// this is a 32-bit operation, the W flag is set to zero. X is also zero, as we're not using a SIB.	885	// this is a 32-bit operation, the W flag is set to zero. X is also zero, as we're not using a SIB.
546	// Both R and B are set, as we're extending, in effect, the register bits and the operand.	886	// Both R and B are set, as we're extending, in effect, the register bits and the operand.
547	try self.REX(.{ .R = reg.isExtended(), .B = reg.isExtended() });	887	try self.code.ensureCapacity(self.code.items.len + 3);
		888	self.rex(.{ .r = reg.isExtended(), .b = reg.isExtended() });
548	const id = @as(u8, reg.id() & 0b111);	889	const id = @as(u8, reg.id() & 0b111);
549	return self.code.appendSlice(&[_]u8{	890	self.code.appendSliceAssumeCapacity(&[_]u8{ 0x31, 0xC0 \| id << 3 \| id });
550	0x31, 0xC0 \| id << 3 \| id,	891	return;
551	});
552	}	892	}
553	if (x <= std.math.maxInt(u32)) {	893	if (x <= std.math.maxInt(u32)) {
554	// Next best case: if we set the lower four bytes, the upper four will be zeroed.	894	// Next best case: if we set the lower four bytes, the upper four will be zeroed.
...	@@ -581,9 +921,9 @@ const Function = struct {	...	@@ -581,9 +921,9 @@ const Function = struct {
581	// Since we always need a REX here, let's just check if we also need to set REX.B.	921	// Since we always need a REX here, let's just check if we also need to set REX.B.
582	//	922	//
583	// In this case, the encoding of the REX byte is 0b0100100B	923	// In this case, the encoding of the REX byte is 0b0100100B
584		924	try self.code.ensureCapacity(self.code.items.len + 10);
585	try self.REX(.{ .W = true, .B = reg.isExtended() });	925	self.rex(.{ .w = true, .b = reg.isExtended() });
586	try self.code.resize(self.code.items.len + 9);	926	self.code.items.len += 9;
587	self.code.items[self.code.items.len - 9] = 0xB8 \| @as(u8, reg.id() & 0b111);	927	self.code.items[self.code.items.len - 9] = 0xB8 \| @as(u8, reg.id() & 0b111);
588	const imm_ptr = self.code.items[self.code.items.len - 8 ..][0..8];	928	const imm_ptr = self.code.items[self.code.items.len - 8 ..][0..8];
589	mem.writeIntLittle(u64, imm_ptr, x);	929	mem.writeIntLittle(u64, imm_ptr, x);
...	@@ -594,13 +934,13 @@ const Function = struct {	...	@@ -594,13 +934,13 @@ const Function = struct {
594	}	934	}
595	// We need the offset from RIP in a signed i32 twos complement.	935	// We need the offset from RIP in a signed i32 twos complement.
596	// The instruction is 7 bytes long and RIP points to the next instruction.	936	// The instruction is 7 bytes long and RIP points to the next instruction.
597	//	937	try self.code.ensureCapacity(self.code.items.len + 7);
598	// 64-bit LEA is encoded as REX.W 8D /r. If the register is extended, the REX byte is modified,	938	// 64-bit LEA is encoded as REX.W 8D /r. If the register is extended, the REX byte is modified,
599	// but the operation size is unchanged. Since we're using a disp32, we want mode 0 and lower three	939	// but the operation size is unchanged. Since we're using a disp32, we want mode 0 and lower three
600	// bits as five.	940	// bits as five.
601	// REX 0x8D 0b00RRR101, where RRR is the lower three bits of the id.	941	// REX 0x8D 0b00RRR101, where RRR is the lower three bits of the id.
602	try self.REX(.{ .W = true, .B = reg.isExtended() });	942	self.rex(.{ .w = true, .b = reg.isExtended() });
603	try self.code.resize(self.code.items.len + 6);	943	self.code.items.len += 6;
604	const rip = self.code.items.len;	944	const rip = self.code.items.len;
605	const big_offset = @intCast(i64, code_offset) - @intCast(i64, rip);	945	const big_offset = @intCast(i64, code_offset) - @intCast(i64, rip);
606	const offset = @intCast(i32, big_offset);	946	const offset = @intCast(i32, big_offset);
...	@@ -620,9 +960,10 @@ const Function = struct {	...	@@ -620,9 +960,10 @@ const Function = struct {
620	// If the source is extended, the B field must be 1.	960	// If the source is extended, the B field must be 1.
621	// Since the register is being accessed directly, the R/M mode is three. The reg field (the middle	961	// Since the register is being accessed directly, the R/M mode is three. The reg field (the middle
622	// three bits) contain the destination, and the R/M field (the lower three bits) contain the source.	962	// three bits) contain the destination, and the R/M field (the lower three bits) contain the source.
623	try self.REX(.{ .W = true, .R = reg.isExtended(), .B = src_reg.isExtended() });	963	try self.code.ensureCapacity(self.code.items.len + 3);
		964	self.rex(.{ .w = true, .r = reg.isExtended(), .b = src_reg.isExtended() });
624	const R = 0xC0 \| (@as(u8, reg.id() & 0b111) << 3) \| @as(u8, src_reg.id() & 0b111);	965	const R = 0xC0 \| (@as(u8, reg.id() & 0b111) << 3) \| @as(u8, src_reg.id() & 0b111);
625	try self.code.appendSlice(&[_]u8{ 0x8B, R });	966	self.code.appendSliceAssumeCapacity(&[_]u8{ 0x8B, R });
626	},	967	},
627	.memory => \|x\| {	968	.memory => \|x\| {
628	if (reg.size() != 64) {	969	if (reg.size() != 64) {
...	@@ -636,14 +977,14 @@ const Function = struct {	...	@@ -636,14 +977,14 @@ const Function = struct {
636	// The SIB must be 0x25, to indicate a disp32 with no scaled index.	977	// The SIB must be 0x25, to indicate a disp32 with no scaled index.
637	// 0b00RRR100, where RRR is the lower three bits of the register ID.	978	// 0b00RRR100, where RRR is the lower three bits of the register ID.
638	// The instruction is thus eight bytes; REX 0x8B 0b00RRR100 0x25 followed by a four-byte disp32.	979	// The instruction is thus eight bytes; REX 0x8B 0b00RRR100 0x25 followed by a four-byte disp32.
639	try self.REX(.{ .W = true, .B = reg.isExtended() });	980	try self.code.ensureCapacity(self.code.items.len + 8);
640	try self.code.resize(self.code.items.len + 7);	981	self.rex(.{ .w = true, .b = reg.isExtended() });
641	const r = 0x04 \| (@as(u8, reg.id() & 0b111) << 3);	982	self.code.appendSliceAssumeCapacity(&[_]u8{
642	self.code.items[self.code.items.len - 7] = 0x8B;	983	0x8B,
643	self.code.items[self.code.items.len - 6] = r;	984	0x04 \| (@as(u8, reg.id() & 0b111) << 3), // R
644	self.code.items[self.code.items.len - 5] = 0x25;	985	0x25,
645	const imm_ptr = self.code.items[self.code.items.len - 4 ..][0..4];	986	});
646	mem.writeIntLittle(u32, imm_ptr, @intCast(u32, x));	987	mem.writeIntLittle(u32, self.code.addManyAsArrayAssumeCapacity(4), @intCast(u32, x));
647	} else {	988	} else {
648	// If this is RAX, we can use a direct load; otherwise, we need to load the address, then indirectly load	989	// If this is RAX, we can use a direct load; otherwise, we need to load the address, then indirectly load
649	// the value.	990	// the value.
...	@@ -674,15 +1015,15 @@ const Function = struct {	...	@@ -674,15 +1015,15 @@ const Function = struct {
674	// Currently, we're only allowing 64-bit registers, so we need the `REX.W 8B /r` variant.	1015	// Currently, we're only allowing 64-bit registers, so we need the `REX.W 8B /r` variant.
675	// TODO: determine whether to allow other sized registers, and if so, handle them properly.	1016	// TODO: determine whether to allow other sized registers, and if so, handle them properly.
676	// This operation requires three bytes: REX 0x8B R/M	1017	// This operation requires three bytes: REX 0x8B R/M
677	//	1018	try self.code.ensureCapacity(self.code.items.len + 3);
678	// For this operation, we want R/M mode zero (use register indirectly), and the two register	1019	// For this operation, we want R/M mode zero (use register indirectly), and the two register
679	// values must match. Thus, it's 00ABCABC where ABC is the lower three bits of the register ID.	1020	// values must match. Thus, it's 00ABCABC where ABC is the lower three bits of the register ID.
680	//	1021	//
681	// Furthermore, if this is an extended register, both B and R must be set in the REX byte, as both	1022	// Furthermore, if this is an extended register, both B and R must be set in the REX byte, as both
682	// register operands need to be marked as extended.	1023	// register operands need to be marked as extended.
683	try self.REX(.{ .W = true, .B = reg.isExtended(), .R = reg.isExtended() });	1024	self.rex(.{ .w = true, .b = reg.isExtended(), .r = reg.isExtended() });
684	const RM = (@as(u8, reg.id() & 0b111) << 3) \| @truncate(u3, reg.id());	1025	const RM = (@as(u8, reg.id() & 0b111) << 3) \| @truncate(u3, reg.id());
685	try self.code.appendSlice(&[_]u8{ 0x8B, RM });	1026	self.code.appendSliceAssumeCapacity(&[_]u8{ 0x8B, RM });
686	}	1027	}
687	}	1028	}
688	},	1029	},
...	@@ -705,22 +1046,58 @@ const Function = struct {	...	@@ -705,22 +1046,58 @@ const Function = struct {
705	}	1046	}
706		1047
707	fn resolveInst(self: Function, inst: ir.Inst) !MCValue {	1048	fn resolveInst(self: Function, inst: ir.Inst) !MCValue {
708	if (self.inst_table.get(inst)) \|mcv\| {	1049	// Constants have static lifetimes, so they are always memoized in the outer most table.
709	return mcv;
710	}
711	if (inst.cast(ir.Inst.Constant)) \|const_inst\| {	1050	if (inst.cast(ir.Inst.Constant)) \|const_inst\| {
712	const mcvalue = try self.genTypedValue(inst.src, .{ .ty = inst.ty, .val = const_inst.val });	1051	const branch = &self.branch_stack.items[0];
713	try self.inst_table.putNoClobber(inst, mcvalue);	1052	const gop = try branch.inst_table.getOrPut(self.gpa, inst);
714	return mcvalue;	1053	if (!gop.found_existing) {
715	} else {	1054	gop.entry.value = try self.genTypedValue(inst.src, .{ .ty = inst.ty, .val = const_inst.val });
716	return self.inst_table.get(inst).?;	1055	}
		1056	return gop.entry.value;
		1057	}
		1058
		1059	// Treat each stack item as a "layer" on top of the previous one.
		1060	var i: usize = self.branch_stack.items.len;
		1061	while (true) {
		1062	i -= 1;
		1063	if (self.branch_stack.items[i].inst_table.get(inst)) \|mcv\| {
		1064	return mcv;
		1065	}
717	}	1066	}
718	}	1067	}
719		1068
		1069	fn copyToNewRegister(self: Function, inst: ir.Inst) !MCValue {
		1070	return self.fail(inst.src, "TODO implement copyToNewRegister", .{});
		1071	}
		1072
		1073	/// If the MCValue is an immediate, and it does not fit within this type,
		1074	/// we put it in a register.
		1075	/// A potential opportunity for future optimization here would be keeping track
		1076	/// of the fact that the instruction is available both as an immediate
		1077	/// and as a register.
		1078	fn limitImmediateType(self: Function, inst: ir.Inst, comptime T: type) !MCValue {
		1079	const mcv = try self.resolveInst(inst);
		1080	const ti = @typeInfo(T).Int;
		1081	switch (mcv) {
		1082	.immediate => \|imm\| {
		1083	// This immediate is unsigned.
		1084	const U = @Type(.{ .Int = .{
		1085	.bits = ti.bits - @boolToInt(ti.is_signed),
		1086	.is_signed = false,
		1087	}});
		1088	if (imm >= std.math.maxInt(U)) {
		1089	return self.copyToNewRegister(inst);
		1090	}
		1091	},
		1092	else => {},
		1093	}
		1094	return mcv;
		1095	}
		1096
		1097
720	fn genTypedValue(self: *Function, src: usize, typed_value: TypedValue) !MCValue {	1098	fn genTypedValue(self: *Function, src: usize, typed_value: TypedValue) !MCValue {
721	const ptr_bits = self.target.cpu.arch.ptrBitWidth();	1099	const ptr_bits = self.target.cpu.arch.ptrBitWidth();
722	const ptr_bytes: u64 = @divExact(ptr_bits, 8);	1100	const ptr_bytes: u64 = @divExact(ptr_bits, 8);
723	const allocator = self.code.allocator;
724	switch (typed_value.ty.zigTypeTag()) {	1101	switch (typed_value.ty.zigTypeTag()) {
725	.Pointer => {	1102	.Pointer => {
726	if (typed_value.val.cast(Value.Payload.DeclRef)) \|payload\| {	1103	if (typed_value.val.cast(Value.Payload.DeclRef)) \|payload\| {
...	@@ -747,7 +1124,7 @@ const Function = struct {	...	@@ -747,7 +1124,7 @@ const Function = struct {
747	fn fail(self: *Function, src: usize, comptime format: []const u8, args: var) error{ CodegenFail, OutOfMemory } {	1124	fn fail(self: *Function, src: usize, comptime format: []const u8, args: var) error{ CodegenFail, OutOfMemory } {
748	@setCold(true);	1125	@setCold(true);
749	assert(self.err_msg == null);	1126	assert(self.err_msg == null);
750	self.err_msg = try ErrorMsg.create(self.code.allocator, src, format, args);	1127	self.err_msg = try ErrorMsg.create(self.bin_file.allocator, src, format, args);
751	return error.CodegenFail;	1128	return error.CodegenFail;
752	}	1129	}
753	};	1130	};

src-self-hosted/ir.zig+68-1

...	@@ -2,6 +2,8 @@ const std = @import("std");	...	@@ -2,6 +2,8 @@ const std = @import("std");
2	const Value = @import("value.zig").Value;	2	const Value = @import("value.zig").Value;
3	const Type = @import("type.zig").Type;	3	const Type = @import("type.zig").Type;
4	const Module = @import("Module.zig");	4	const Module = @import("Module.zig");
		5	const assert = std.debug.assert;
		6	const codegen = @import("codegen.zig");
5		7
6	/// These are in-memory, analyzed instructions. See `zir.Inst` for the representation	8	/// These are in-memory, analyzed instructions. See `zir.Inst` for the representation
7	/// of instructions that correspond to the ZIR text format.	9	/// of instructions that correspond to the ZIR text format.
...	@@ -10,17 +12,43 @@ const Module = @import("Module.zig");	...	@@ -10,17 +12,43 @@ const Module = @import("Module.zig");
10	/// a memory location for the value to survive after a const instruction.	12	/// a memory location for the value to survive after a const instruction.
11	pub const Inst = struct {	13	pub const Inst = struct {
12	tag: Tag,	14	tag: Tag,
		15	/// Each bit represents the index of an `Inst` parameter in the `args` field.
		16	/// If a bit is set, it marks the end of the lifetime of the corresponding
		17	/// instruction parameter. For example, 0b000_00101 means that the first and
		18	/// third `Inst` parameters' lifetimes end after this instruction, and will
		19	/// not have any more following references.
		20	/// The most significant bit being set means that the instruction itself is
		21	/// never referenced, in other words its lifetime ends as soon as it finishes.
		22	/// If bit 7 (0b1xxx_xxxx) is set, it means this instruction itself is unreferenced.
		23	/// If bit 6 (0bx1xx_xxxx) is set, it means this is a special case and the
		24	/// lifetimes of operands are encoded elsewhere.
		25	deaths: u8 = undefined,
13	ty: Type,	26	ty: Type,
14	/// Byte offset into the source.	27	/// Byte offset into the source.
15	src: usize,	28	src: usize,
16		29
		30	pub fn isUnused(self: Inst) bool {
		31	return (self.deaths & 0b1000_0000) != 0;
		32	}
		33
		34	pub fn operandDies(self: Inst, index: u3) bool {
		35	assert(index < 6);
		36	return @truncate(u1, self.deaths << index) != 0;
		37	}
		38
		39	pub fn specialOperandDeaths(self: Inst) bool {
		40	return (self.deaths & 0b1000_0000) != 0;
		41	}
		42
17	pub const Tag = enum {	43	pub const Tag = enum {
18	add,	44	add,
19	arg,	45	arg,
20	assembly,	46	assembly,
21	bitcast,	47	bitcast,
22	block,	48	block,
		49	br,
23	breakpoint,	50	breakpoint,
		51	brvoid,
24	call,	52	call,
25	cmp,	53	cmp,
26	condbr,	54	condbr,
...	@@ -30,6 +58,7 @@ pub const Inst = struct {	...	@@ -30,6 +58,7 @@ pub const Inst = struct {
30	ptrtoint,	58	ptrtoint,
31	ret,	59	ret,
32	retvoid,	60	retvoid,
		61	sub,
33	unreach,	62	unreach,
34		63
35	/// Returns whether the instruction is one of the control flow "noreturn" types.	64	/// Returns whether the instruction is one of the control flow "noreturn" types.
...	@@ -43,14 +72,17 @@ pub const Inst = struct {	...	@@ -43,14 +72,17 @@ pub const Inst = struct {
43	.bitcast,	72	.bitcast,
44	.block,	73	.block,
45	.breakpoint,	74	.breakpoint,
		75	.call,
46	.cmp,	76	.cmp,
47	.constant,	77	.constant,
48	.isnonnull,	78	.isnonnull,
49	.isnull,	79	.isnull,
50	.ptrtoint,	80	.ptrtoint,
51	.call,	81	.sub,
52	=> false,	82	=> false,
53		83
		84	.br,
		85	.brvoid,
54	.condbr,	86	.condbr,
55	.ret,	87	.ret,
56	.retvoid,	88	.retvoid,
...	@@ -128,6 +160,17 @@ pub const Inst = struct {	...	@@ -128,6 +160,17 @@ pub const Inst = struct {
128	args: struct {	160	args: struct {
129	body: Body,	161	body: Body,
130	},	162	},
		163	/// This memory is reserved for codegen code to do whatever it needs to here.
		164	codegen: codegen.BlockData = .{},
		165	};
		166
		167	pub const Br = struct {
		168	pub const base_tag = Tag.br;
		169	base: Inst,
		170	args: struct {
		171	block: *Block,
		172	operand: *Inst,
		173	},
131	};	174	};
132		175
133	pub const Breakpoint = struct {	176	pub const Breakpoint = struct {
...	@@ -136,6 +179,14 @@ pub const Inst = struct {	...	@@ -136,6 +179,14 @@ pub const Inst = struct {
136	args: void,	179	args: void,
137	};	180	};
138		181
		182	pub const BrVoid = struct {
		183	pub const base_tag = Tag.brvoid;
		184	base: Inst,
		185	args: struct {
		186	block: *Block,
		187	},
		188	};
		189
139	pub const Call = struct {	190	pub const Call = struct {
140	pub const base_tag = Tag.call;	191	pub const base_tag = Tag.call;
141	base: Inst,	192	base: Inst,
...	@@ -165,6 +216,12 @@ pub const Inst = struct {	...	@@ -165,6 +216,12 @@ pub const Inst = struct {
165	true_body: Body,	216	true_body: Body,
166	false_body: Body,	217	false_body: Body,
167	},	218	},
		219	/// Set of instructions whose lifetimes end at the start of one of the branches.
		220	/// The `true` branch is first: `deaths[0..true_death_count]`.
		221	/// The `false` branch is next: `(deaths + true_death_count)[..false_death_count]`.
		222	deaths: []Inst = undefined,
		223	true_death_count: u32 = 0,
		224	false_death_count: u32 = 0,
168	};	225	};
169		226
170	pub const Constant = struct {	227	pub const Constant = struct {
...	@@ -215,6 +272,16 @@ pub const Inst = struct {	...	@@ -215,6 +272,16 @@ pub const Inst = struct {
215	args: void,	272	args: void,
216	};	273	};
217		274
		275	pub const Sub = struct {
		276	pub const base_tag = Tag.sub;
		277	base: Inst,
		278
		279	args: struct {
		280	lhs: *Inst,
		281	rhs: *Inst,
		282	},
		283	};
		284
218	pub const Unreach = struct {	285	pub const Unreach = struct {
219	pub const base_tag = Tag.unreach;	286	pub const base_tag = Tag.unreach;
220	base: Inst,	287	base: Inst,

src-self-hosted/link.zig+29-15

src-self-hosted/liveness.zig created+139

...	@@ -0,0 +1,139 @@
1	const std = @import("std");
2	const ir = @import("ir.zig");
3	const trace = @import("tracy.zig").trace;
4
5	/// Perform Liveness Analysis over the `Body`. Each `Inst` will have its `deaths` field populated.
6	pub fn analyze(
7	/// Used for temporary storage during the analysis.
8	gpa: *std.mem.Allocator,
9	/// Used to tack on extra allocations in the same lifetime as the existing instructions.
10	arena: *std.mem.Allocator,
11	body: ir.Body,
12	) error{OutOfMemory}!void {
13	const tracy = trace(@src());
14	defer tracy.end();
15
16	var table = std.AutoHashMap(*ir.Inst, void).init(gpa);
17	defer table.deinit();
18	try table.ensureCapacity(body.instructions.len);
19	try analyzeWithTable(arena, &table, body);
20	}
21
22	fn analyzeWithTable(arena: std.mem.Allocator, table: std.AutoHashMap(*ir.Inst, void), body: ir.Body) error{OutOfMemory}!void {
23	var i: usize = body.instructions.len;
24
25	while (i != 0) {
26	i -= 1;
27	const base = body.instructions[i];
28	try analyzeInstGeneric(arena, table, base);
29	}
30	}
31
32	fn analyzeInstGeneric(arena: std.mem.Allocator, table: std.AutoHashMap(ir.Inst, void), base: ir.Inst) error{OutOfMemory}!void {
33	// Obtain the corresponding instruction type based on the tag type.
34	inline for (std.meta.declarations(ir.Inst)) \|decl\| {
35	switch (decl.data) {
36	.Type => \|T\| {
37	if (@hasDecl(T, "base_tag")) {
38	if (T.base_tag == base.tag) {
39	return analyzeInst(arena, table, T, @fieldParentPtr(T, "base", base));
40	}
41	}
42	},
43	else => {},
44	}
45	}
46	unreachable;
47	}
48
49	fn analyzeInst(arena: std.mem.Allocator, table: std.AutoHashMap(ir.Inst, void), comptime T: type, inst: T) error{OutOfMemory}!void {
50	inst.base.deaths = 0;
51
52	switch (T) {
53	ir.Inst.Constant => return,
54	ir.Inst.Block => {
55	try analyzeWithTable(arena, table, inst.args.body);
56	// We let this continue so that it can possibly mark the block as
57	// unreferenced below.
58	},
59	ir.Inst.CondBr => {
60	var true_table = std.AutoHashMap(*ir.Inst, void).init(table.allocator);
61	defer true_table.deinit();
62	try true_table.ensureCapacity(inst.args.true_body.instructions.len);
63	try analyzeWithTable(arena, &true_table, inst.args.true_body);
64
65	var false_table = std.AutoHashMap(*ir.Inst, void).init(table.allocator);
66	defer false_table.deinit();
67	try false_table.ensureCapacity(inst.args.false_body.instructions.len);
68	try analyzeWithTable(arena, &false_table, inst.args.false_body);
69
70	// Each death that occurs inside one branch, but not the other, needs
71	// to be added as a death immediately upon entering the other branch.
72	// During the iteration of the table, we additionally propagate the
73	// deaths to the parent table.
74	var true_entry_deaths = std.ArrayList(*ir.Inst).init(table.allocator);
75	defer true_entry_deaths.deinit();
76	var false_entry_deaths = std.ArrayList(*ir.Inst).init(table.allocator);
77	defer false_entry_deaths.deinit();
78	{
79	var it = false_table.iterator();
80	while (it.next()) \|entry\| {
81	const false_death = entry.key;
82	if (!true_table.contains(false_death)) {
83	try true_entry_deaths.append(false_death);
84	// Here we are only adding to the parent table if the following iteration
85	// would miss it.
86	try table.putNoClobber(false_death, {});
87	}
88	}
89	}
90	{
91	var it = true_table.iterator();
92	while (it.next()) \|entry\| {
93	const true_death = entry.key;
94	try table.putNoClobber(true_death, {});
95	if (!false_table.contains(true_death)) {
96	try false_entry_deaths.append(true_death);
97	}
98	}
99	}
100	inst.true_death_count = std.math.cast(@TypeOf(inst.true_death_count), true_entry_deaths.items.len) catch return error.OutOfMemory;
101	inst.false_death_count = std.math.cast(@TypeOf(inst.false_death_count), false_entry_deaths.items.len) catch return error.OutOfMemory;
102	const allocated_slice = try arena.alloc(*ir.Inst, true_entry_deaths.items.len + false_entry_deaths.items.len);
103	inst.deaths = allocated_slice.ptr;
104
105	// Continue on with the instruction analysis. The following code will find the condition
106	// instruction, and the deaths flag for the CondBr instruction will indicate whether the
107	// condition's lifetime ends immediately before entering any branch.
108	},
109	else => {},
110	}
111
112	if (!table.contains(&inst.base)) {
113	// No tombstone for this instruction means it is never referenced,
114	// and its birth marks its own death. Very metal 🤘
115	inst.base.deaths \|= 1 << 7;
116	}
117
118	const Args = ir.Inst.Args(T);
119	if (Args == void) {
120	return;
121	}
122
123	comptime var arg_index: usize = 0;
124	inline for (std.meta.fields(Args)) \|field\| {
125	if (field.field_type == *ir.Inst) {
126	if (arg_index >= 6) {
127	@compileError("out of bits to mark deaths of operands");
128	}
129	const prev = try table.fetchPut(@field(inst.args, field.name), {});
130	if (prev == null) {
131	// Death.
132	inst.base.deaths \|= 1 << arg_index;
133	}
134	arg_index += 1;
135	}
136	}
137
138	std.log.debug(.liveness, "analyze {}: 0b{b}\n", .{inst.base.tag, inst.base.deaths});
139	}

src-self-hosted/main.zig+5-2

...	@@ -50,7 +50,10 @@ pub fn log(	...	@@ -50,7 +50,10 @@ pub fn log(
50	const scope_prefix = "(" ++ switch (scope) {	50	const scope_prefix = "(" ++ switch (scope) {
51	// Uncomment to hide logs	51	// Uncomment to hide logs
52	//.compiler,	52	//.compiler,
53	.link => return,	53	.module,
		54	.liveness,
		55	.link,
		56	=> return,
54		57
55	else => @tagName(scope),	58	else => @tagName(scope),
56	} ++ "): ";	59	} ++ "): ";
...	@@ -510,7 +513,7 @@ fn updateModule(gpa: Allocator, module: Module, zir_out_path: ?[]const u8) !vo	...	@@ -510,7 +513,7 @@ fn updateModule(gpa: Allocator, module: Module, zir_out_path: ?[]const u8) !vo
510	const update_nanos = timer.read();	513	const update_nanos = timer.read();
511		514
512	var errors = try module.getAllErrorsAlloc();	515	var errors = try module.getAllErrorsAlloc();
513	defer errors.deinit(module.allocator);	516	defer errors.deinit(module.gpa);
514		517
515	if (errors.list.len != 0) {	518	if (errors.list.len != 0) {
516	for (errors.list) \|full_err_msg\| {	519	for (errors.list) \|full_err_msg\| {

src-self-hosted/zir.zig+220-62

 @@ -38,6 +38,8 @@ pub const Inst = struct {
         arg,
         /// A labeled block of code, which can return a value.
         block,
+        /// Return a value from a `Block`.
+        @"break",
         breakpoint,
         /// Same as `break` but without an operand; the operand is assumed to be the void value.
         breakvoid,
 @@ -57,6 +59,7 @@ pub const Inst = struct {
         /// String Literal. Makes an anonymous Decl and then takes a pointer to it.
         str,
         int,
+        inttype,
         ptrtoint,
         fieldptr,
         deref,
 @@ -73,6 +76,7 @@ pub const Inst = struct {
         bitcast,
         elemptr,
         add,
+        sub,
         cmp,
         condbr,
         isnull,
 @@ -83,6 +87,7 @@ pub const Inst = struct {
         return switch (tag) {
             .arg => Arg,
             .block => Block,
+            .@"break" => Break,
             .breakpoint => Breakpoint,
             .breakvoid => BreakVoid,
             .call => Call,
 @@ -94,6 +99,7 @@ pub const Inst = struct {
             .@"const" => Const,
             .str => Str,
             .int => Int,
+            .inttype => IntType,
             .ptrtoint => PtrToInt,
             .fieldptr => FieldPtr,
             .deref => Deref,
 @@ -110,6 +116,7 @@ pub const Inst = struct {
             .bitcast => BitCast,
             .elemptr => ElemPtr,
             .add => Add,
+            .sub => Sub,
             .cmp => Cmp,
             .condbr => CondBr,
             .isnull => IsNull,
 @@ -139,12 +146,22 @@ pub const Inst = struct {
         base: Inst,
         positionals: struct {
-            label: []const u8,
             body: Module.Body,
         },
         kw_args: struct {},
     };
+    pub const Break = struct {
+        pub const base_tag = Tag.@"break";
+        base: Inst,
+        positionals: struct {
+            block: *Block,
+            operand: *Inst,
+        },
+        kw_args: struct {},
+    };
     pub const Breakpoint = struct {
         pub const base_tag = Tag.breakpoint;
         base: Inst,
 @@ -158,7 +175,7 @@ pub const Inst = struct {
         base: Inst,
         positionals: struct {
-            label: []const u8,
+            block: *Block,
         },
         kw_args: struct {},
     };
 @@ -367,6 +384,17 @@ pub const Inst = struct {
         },
     };
+    pub const IntType = struct {
+        pub const base_tag = Tag.inttype;
+        base: Inst,
+        positionals: struct {
+            signed: *Inst,
+            bits: *Inst,
+        },
+        kw_args: struct {},
+    };
     pub const Export = struct {
         pub const base_tag = Tag.@"export";
         base: Inst,
 @@ -512,6 +540,19 @@ pub const Inst = struct {
         kw_args: struct {},
     };
+    pub const Sub = struct {
+        pub const base_tag = Tag.sub;
+        base: Inst,
+        positionals: struct {
+            lhs: *Inst,
+            rhs: *Inst,
+        },
+        kw_args: struct {},
+    };
+    /// TODO get rid of the op positional arg and make that data part of
+    /// the base Inst tag.
     pub const Cmp = struct {
         pub const base_tag = Tag.cmp;
         base: Inst,
 @@ -582,8 +623,6 @@ pub const Module = struct {
         self.writeToStream(std.heap.page_allocator, std.io.getStdErr().outStream()) catch {};
     }
-    const InstPtrTable = std.AutoHashMap(*Inst, struct { inst: *Inst, index: ?usize, name: []const u8 });
     const DeclAndIndex = struct {
         decl: *Decl,
         index: usize,
 @@ -617,80 +656,100 @@ pub const Module = struct {
     /// The allocator is used for temporary storage, but this function always returns
     /// with no resources allocated.
     pub fn writeToStream(self: Module, allocator: *Allocator, stream: var) !void {
-        // First, build a map of *Inst to @ or % indexes
+        var write = Writer{
-        var inst_table = InstPtrTable.init(allocator);
+            .module = &self,
-        defer inst_table.deinit();
+            .inst_table = InstPtrTable.init(allocator),
+            .block_table = std.AutoHashMap(*Inst.Block, []const u8).init(allocator),
+            .arena = std.heap.ArenaAllocator.init(allocator),
+            .indent = 2,
+        };
+        defer write.arena.deinit();
+        defer write.inst_table.deinit();
+        defer write.block_table.deinit();
-        try inst_table.ensureCapacity(self.decls.len);
+        // First, build a map of *Inst to @ or % indexes
+        try write.inst_table.ensureCapacity(self.decls.len);
         for (self.decls) |decl, decl_i| {
-            try inst_table.putNoClobber(decl.inst, .{ .inst = decl.inst, .index = null, .name = decl.name });
+            try write.inst_table.putNoClobber(decl.inst, .{ .inst = decl.inst, .index = null, .name = decl.name });
             if (decl.inst.cast(Inst.Fn)) |fn_inst| {
                 for (fn_inst.positionals.body.instructions) |inst, inst_i| {
-                    try inst_table.putNoClobber(inst, .{ .inst = inst, .index = inst_i, .name = undefined });
+                    try write.inst_table.putNoClobber(inst, .{ .inst = inst, .index = inst_i, .name = undefined });
                 }
             }
         }
         for (self.decls) |decl, i| {
             try stream.print("@{} ", .{decl.name});
-            try self.writeInstToStream(stream, decl.inst, &inst_table);
+            try write.writeInstToStream(stream, decl.inst);
             try stream.writeByte('\n');
         }
     }
+};
+const InstPtrTable = std.AutoHashMap(*Inst, struct { inst: *Inst, index: ?usize, name: []const u8 });
+const Writer = struct {
+    module: *const Module,
+    inst_table: InstPtrTable,
+    block_table: std.AutoHashMap(*Inst.Block, []const u8),
+    arena: std.heap.ArenaAllocator,
+    indent: usize,
     fn writeInstToStream(
-        self: Module,
+        self: *Writer,
         stream: var,
         inst: *Inst,
-        inst_table: *const InstPtrTable,
+    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
-    ) @TypeOf(stream).Error!void {
         // TODO I tried implementing this with an inline for loop and hit a compiler bug
         switch (inst.tag) {
-            .arg => return self.writeInstToStreamGeneric(stream, .arg, inst, inst_table),
+            .arg => return self.writeInstToStreamGeneric(stream, .arg, inst),
-            .block => return self.writeInstToStreamGeneric(stream, .block, inst, inst_table),
+            .block => return self.writeInstToStreamGeneric(stream, .block, inst),
-            .breakpoint => return self.writeInstToStreamGeneric(stream, .breakpoint, inst, inst_table),
+            .@"break" => return self.writeInstToStreamGeneric(stream, .@"break", inst),
-            .breakvoid => return self.writeInstToStreamGeneric(stream, .breakvoid, inst, inst_table),
+            .breakpoint => return self.writeInstToStreamGeneric(stream, .breakpoint, inst),
-            .call => return self.writeInstToStreamGeneric(stream, .call, inst, inst_table),
+            .breakvoid => return self.writeInstToStreamGeneric(stream, .breakvoid, inst),
-            .declref => return self.writeInstToStreamGeneric(stream, .declref, inst, inst_table),
+            .call => return self.writeInstToStreamGeneric(stream, .call, inst),
-            .declref_str => return self.writeInstToStreamGeneric(stream, .declref_str, inst, inst_table),
+            .declref => return self.writeInstToStreamGeneric(stream, .declref, inst),
-            .declval => return self.writeInstToStreamGeneric(stream, .declval, inst, inst_table),
+            .declref_str => return self.writeInstToStreamGeneric(stream, .declref_str, inst),
-            .declval_in_module => return self.writeInstToStreamGeneric(stream, .declval_in_module, inst, inst_table),
+            .declval => return self.writeInstToStreamGeneric(stream, .declval, inst),
-            .compileerror => return self.writeInstToStreamGeneric(stream, .compileerror, inst, inst_table),
+            .declval_in_module => return self.writeInstToStreamGeneric(stream, .declval_in_module, inst),
-            .@"const" => return self.writeInstToStreamGeneric(stream, .@"const", inst, inst_table),
+            .compileerror => return self.writeInstToStreamGeneric(stream, .compileerror, inst),
-            .str => return self.writeInstToStreamGeneric(stream, .str, inst, inst_table),
+            .@"const" => return self.writeInstToStreamGeneric(stream, .@"const", inst),
-            .int => return self.writeInstToStreamGeneric(stream, .int, inst, inst_table),
+            .str => return self.writeInstToStreamGeneric(stream, .str, inst),
-            .ptrtoint => return self.writeInstToStreamGeneric(stream, .ptrtoint, inst, inst_table),
+            .int => return self.writeInstToStreamGeneric(stream, .int, inst),
-            .fieldptr => return self.writeInstToStreamGeneric(stream, .fieldptr, inst, inst_table),
+            .inttype => return self.writeInstToStreamGeneric(stream, .inttype, inst),
-            .deref => return self.writeInstToStreamGeneric(stream, .deref, inst, inst_table),
+            .ptrtoint => return self.writeInstToStreamGeneric(stream, .ptrtoint, inst),
-            .as => return self.writeInstToStreamGeneric(stream, .as, inst, inst_table),
+            .fieldptr => return self.writeInstToStreamGeneric(stream, .fieldptr, inst),
-            .@"asm" => return self.writeInstToStreamGeneric(stream, .@"asm", inst, inst_table),
+            .deref => return self.writeInstToStreamGeneric(stream, .deref, inst),
-            .@"unreachable" => return self.writeInstToStreamGeneric(stream, .@"unreachable", inst, inst_table),
+            .as => return self.writeInstToStreamGeneric(stream, .as, inst),
-            .@"return" => return self.writeInstToStreamGeneric(stream, .@"return", inst, inst_table),
+            .@"asm" => return self.writeInstToStreamGeneric(stream, .@"asm", inst),
-            .returnvoid => return self.writeInstToStreamGeneric(stream, .returnvoid, inst, inst_table),
+            .@"unreachable" => return self.writeInstToStreamGeneric(stream, .@"unreachable", inst),
-            .@"fn" => return self.writeInstToStreamGeneric(stream, .@"fn", inst, inst_table),
+            .@"return" => return self.writeInstToStreamGeneric(stream, .@"return", inst),
-            .@"export" => return self.writeInstToStreamGeneric(stream, .@"export", inst, inst_table),
+            .returnvoid => return self.writeInstToStreamGeneric(stream, .returnvoid, inst),
-            .primitive => return self.writeInstToStreamGeneric(stream, .primitive, inst, inst_table),
+            .@"fn" => return self.writeInstToStreamGeneric(stream, .@"fn", inst),
-            .fntype => return self.writeInstToStreamGeneric(stream, .fntype, inst, inst_table),
+            .@"export" => return self.writeInstToStreamGeneric(stream, .@"export", inst),
-            .intcast => return self.writeInstToStreamGeneric(stream, .intcast, inst, inst_table),
+            .primitive => return self.writeInstToStreamGeneric(stream, .primitive, inst),
-            .bitcast => return self.writeInstToStreamGeneric(stream, .bitcast, inst, inst_table),
+            .fntype => return self.writeInstToStreamGeneric(stream, .fntype, inst),
-            .elemptr => return self.writeInstToStreamGeneric(stream, .elemptr, inst, inst_table),
+            .intcast => return self.writeInstToStreamGeneric(stream, .intcast, inst),
-            .add => return self.writeInstToStreamGeneric(stream, .add, inst, inst_table),
+            .bitcast => return self.writeInstToStreamGeneric(stream, .bitcast, inst),
-            .cmp => return self.writeInstToStreamGeneric(stream, .cmp, inst, inst_table),
+            .elemptr => return self.writeInstToStreamGeneric(stream, .elemptr, inst),
-            .condbr => return self.writeInstToStreamGeneric(stream, .condbr, inst, inst_table),
+            .add => return self.writeInstToStreamGeneric(stream, .add, inst),
-            .isnull => return self.writeInstToStreamGeneric(stream, .isnull, inst, inst_table),
+            .sub => return self.writeInstToStreamGeneric(stream, .sub, inst),
-            .isnonnull => return self.writeInstToStreamGeneric(stream, .isnonnull, inst, inst_table),
+            .cmp => return self.writeInstToStreamGeneric(stream, .cmp, inst),
+            .condbr => return self.writeInstToStreamGeneric(stream, .condbr, inst),
+            .isnull => return self.writeInstToStreamGeneric(stream, .isnull, inst),
+            .isnonnull => return self.writeInstToStreamGeneric(stream, .isnonnull, inst),
         }
     }
     fn writeInstToStreamGeneric(
-        self: Module,
+        self: *Writer,
         stream: var,
         comptime inst_tag: Inst.Tag,
         base: *Inst,
-        inst_table: *const InstPtrTable,
+    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
-    ) !void {
         const SpecificInst = Inst.TagToType(inst_tag);
         const inst = @fieldParentPtr(SpecificInst, "base", base);
         const Positionals = @TypeOf(inst.positionals);
 @@ -700,7 +759,7 @@ pub const Module = struct {
             if (i != 0) {
                 try stream.writeAll(", ");
             }
-            try self.writeParamToStream(stream, @field(inst.positionals, arg_field.name), inst_table);
+            try self.writeParamToStream(stream, @field(inst.positionals, arg_field.name));
         }
         comptime var need_comma = pos_fields.len != 0;
 @@ -710,13 +769,13 @@ pub const Module = struct {
                 if (@field(inst.kw_args, arg_field.name)) |non_optional| {
                     if (need_comma) try stream.writeAll(", ");
                     try stream.print("{}=", .{arg_field.name});
-                    try self.writeParamToStream(stream, non_optional, inst_table);
+                    try self.writeParamToStream(stream, non_optional);
                     need_comma = true;
                 }
             } else {
                 if (need_comma) try stream.writeAll(", ");
                 try stream.print("{}=", .{arg_field.name});
-                try self.writeParamToStream(stream, @field(inst.kw_args, arg_field.name), inst_table);
+                try self.writeParamToStream(stream, @field(inst.kw_args, arg_field.name));
                 need_comma = true;
             }
         }
 @@ -724,29 +783,37 @@ pub const Module = struct {
         try stream.writeByte(')');
     }
-    fn writeParamToStream(self: Module, stream: var, param: var, inst_table: *const InstPtrTable) !void {
+    fn writeParamToStream(self: *Writer, stream: var, param: var) !void {
         if (@typeInfo(@TypeOf(param)) == .Enum) {
             return stream.writeAll(@tagName(param));
         }
         switch (@TypeOf(param)) {
-            *Inst => return self.writeInstParamToStream(stream, param, inst_table),
+            *Inst => return self.writeInstParamToStream(stream, param),
             []*Inst => {
                 try stream.writeByte('[');
                 for (param) |inst, i| {
                     if (i != 0) {
                         try stream.writeAll(", ");
                     }
-                    try self.writeInstParamToStream(stream, inst, inst_table);
+                    try self.writeInstParamToStream(stream, inst);
                 }
                 try stream.writeByte(']');
             },
             Module.Body => {
                 try stream.writeAll("{\n");
                 for (param.instructions) |inst, i| {
-                    try stream.print("  %{} ", .{i});
+                    try stream.writeByteNTimes(' ', self.indent);
-                    try self.writeInstToStream(stream, inst, inst_table);
+                    try stream.print("%{} ", .{i});
+                    if (inst.cast(Inst.Block)) |block| {
+                        const name = try std.fmt.allocPrint(&self.arena.allocator, "label_{}", .{i});
+                        try self.block_table.put(block, name);
+                    }
+                    self.indent += 2;
+                    try self.writeInstToStream(stream, inst);
+                    self.indent -= 2;
                     try stream.writeByte('\n');
                 }
+                try stream.writeByteNTimes(' ', self.indent - 2);
                 try stream.writeByte('}');
             },
             bool => return stream.writeByte("01"[@boolToInt(param)]),
 @@ -754,12 +821,16 @@ pub const Module = struct {
             BigIntConst, usize => return stream.print("{}", .{param}),
             TypedValue => unreachable, // this is a special case
             *IrModule.Decl => unreachable, // this is a special case
+            *Inst.Block => {
+                const name = self.block_table.get(param).?;
+                return std.zig.renderStringLiteral(name, stream);
+            },
             else => |T| @compileError("unimplemented: rendering parameter of type " ++ @typeName(T)),
         }
     }
-    fn writeInstParamToStream(self: Module, stream: var, inst: *Inst, inst_table: *const InstPtrTable) !void {
+    fn writeInstParamToStream(self: *Writer, stream: var, inst: *Inst) !void {
-        if (inst_table.get(inst)) |info| {
+        if (self.inst_table.get(inst)) |info| {
             if (info.index) |i| {
                 try stream.print("%{}", .{info.index});
             } else {
 @@ -789,7 +860,9 @@ pub fn parse(allocator: *Allocator, source: [:0]const u8) Allocator.Error!Module
         .global_name_map = &global_name_map,
         .decls = .{},
         .unnamed_index = 0,
+        .block_table = std.StringHashMap(*Inst.Block).init(allocator),
     };
+    defer parser.block_table.deinit();
     errdefer parser.arena.deinit();
     parser.parseRoot() catch |err| switch (err) {
 @@ -815,6 +888,7 @@ const Parser = struct {
     global_name_map: *std.StringHashMap(*Inst),
     error_msg: ?ErrorMsg = null,
     unnamed_index: usize,
+    block_table: std.StringHashMap(*Inst.Block),
     const Body = struct {
         instructions: std.ArrayList(*Inst),
 @@ -1023,6 +1097,10 @@ const Parser = struct {
             .tag = InstType.base_tag,
         };
+        if (InstType == Inst.Block) {
+            try self.block_table.put(inst_name, inst_specific);
+        }
         if (@hasField(InstType, "ty")) {
             inst_specific.ty = opt_type orelse {
                 return self.fail("instruction '" ++ fn_name ++ "' requires type", .{});
 @@ -1128,6 +1206,10 @@ const Parser = struct {
             },
             TypedValue => return self.fail("'const' is a special instruction; not legal in ZIR text", .{}),
             *IrModule.Decl => return self.fail("'declval_in_module' is a special instruction; not legal in ZIR text", .{}),
+            *Inst.Block => {
+                const name = try self.parseStringLiteral();
+                return self.block_table.get(name).?;
+            },
             else => @compileError("Unimplemented: ir parseParameterGeneric for type " ++ @typeName(T)),
         }
         return self.fail("TODO parse parameter {}", .{@typeName(T)});
 @@ -1191,7 +1273,10 @@ pub fn emit(allocator: *Allocator, old_module: IrModule) !Module {
         .next_auto_name = 0,
         .names = std.StringHashMap(void).init(allocator),
         .primitive_table = std.AutoHashMap(Inst.Primitive.Builtin, *Decl).init(allocator),
+        .indent = 0,
+        .block_table = std.AutoHashMap(*ir.Inst.Block, *Inst.Block).init(allocator),
     };
+    defer ctx.block_table.deinit();
     defer ctx.decls.deinit(allocator);
     defer ctx.names.deinit();
     defer ctx.primitive_table.deinit();
 @@ -1213,6 +1298,8 @@ const EmitZIR = struct {
     names: std.StringHashMap(void),
     next_auto_name: usize,
     primitive_table: std.AutoHashMap(Inst.Primitive.Builtin, *Decl),
+    indent: usize,
+    block_table: std.AutoHashMap(*ir.Inst.Block, *Inst.Block),
     fn emit(self: *EmitZIR) !void {
         // Put all the Decls in a list and sort them by name to avoid nondeterminism introduced
 @@ -1542,6 +1629,22 @@ const EmitZIR = struct {
                     };
                     break :blk &new_inst.base;
                 },
+                .sub => blk: {
+                    const old_inst = inst.cast(ir.Inst.Sub).?;
+                    const new_inst = try self.arena.allocator.create(Inst.Sub);
+                    new_inst.* = .{
+                        .base = .{
+                            .src = inst.src,
+                            .tag = Inst.Sub.base_tag,
+                        },
+                        .positionals = .{
+                            .lhs = try self.resolveInst(new_body, old_inst.args.lhs),
+                            .rhs = try self.resolveInst(new_body, old_inst.args.rhs),
+                        },
+                        .kw_args = .{},
+                    };
+                    break :blk &new_inst.base;
+                },
                 .arg => blk: {
                     const old_inst = inst.cast(ir.Inst.Arg).?;
                     const new_inst = try self.arena.allocator.create(Inst.Arg);
 @@ -1559,6 +1662,8 @@ const EmitZIR = struct {
                     const old_inst = inst.cast(ir.Inst.Block).?;
                     const new_inst = try self.arena.allocator.create(Inst.Block);
+                    try self.block_table.put(old_inst, new_inst);
                     var block_body = std.ArrayList(*Inst).init(self.allocator);
                     defer block_body.deinit();
 @@ -1570,14 +1675,47 @@ const EmitZIR = struct {
                             .tag = Inst.Block.base_tag,
                         },
                         .positionals = .{
-                            .label = try self.autoName(),
                             .body = .{ .instructions = block_body.toOwnedSlice() },
                         },
                         .kw_args = .{},
                     };
+                    break :blk &new_inst.base;
+                },
+                .br => blk: {
+                    const old_inst = inst.cast(ir.Inst.Br).?;
+                    const new_block = self.block_table.get(old_inst.args.block).?;
+                    const new_inst = try self.arena.allocator.create(Inst.Break);
+                    new_inst.* = .{
+                        .base = .{
+                            .src = inst.src,
+                            .tag = Inst.Break.base_tag,
+                        },
+                        .positionals = .{
+                            .block = new_block,
+                            .operand = try self.resolveInst(new_body, old_inst.args.operand),
+                        },
+                        .kw_args = .{},
+                    };
                     break :blk &new_inst.base;
                 },
                 .breakpoint => try self.emitTrivial(inst.src, Inst.Breakpoint),
+                .brvoid => blk: {
+                    const old_inst = inst.cast(ir.Inst.BrVoid).?;
+                    const new_block = self.block_table.get(old_inst.args.block).?;
+                    const new_inst = try self.arena.allocator.create(Inst.BreakVoid);
+                    new_inst.* = .{
+                        .base = .{
+                            .src = inst.src,
+                            .tag = Inst.BreakVoid.base_tag,
+                        },
+                        .positionals = .{
+                            .block = new_block,
+                        },
+                        .kw_args = .{},
+                    };
+                    break :blk &new_inst.base;
+                },
                 .call => blk: {
                     const old_inst = inst.cast(ir.Inst.Call).?;
                     const new_inst = try self.arena.allocator.create(Inst.Call);
 @@ -1765,7 +1903,7 @@ const EmitZIR = struct {
                 },
             };
             try instructions.append(new_inst);
-            try inst_table.putNoClobber(inst, new_inst);
+            try inst_table.put(inst, new_inst);
         }
     }
 @@ -1829,6 +1967,26 @@ const EmitZIR = struct {
                     };
                     return self.emitUnnamedDecl(&fntype_inst.base);
                 },
+                .Int => {
+                    const info = ty.intInfo(self.old_module.target());
+                    const signed = try self.emitPrimitive(src, if (info.signed) .@"true" else .@"false");
+                    const bits_payload = try self.arena.allocator.create(Value.Payload.Int_u64);
+                    bits_payload.* = .{ .int = info.bits };
+                    const bits = try self.emitComptimeIntVal(src, Value.initPayload(&bits_payload.base));
+                    const inttype_inst = try self.arena.allocator.create(Inst.IntType);
+                    inttype_inst.* = .{
+                        .base = .{
+                            .src = src,
+                            .tag = Inst.IntType.base_tag,
+                        },
+                        .positionals = .{
+                            .signed = signed.inst,
+                            .bits = bits.inst,
+                        },
+                        .kw_args = .{},
+                    };
+                    return self.emitUnnamedDecl(&inttype_inst.base);
+                },
                 else => std.debug.panic("TODO implement emitType for {}", .{ty}),
             },
         }

...	@@ -206,6 +206,19 @@ pub const File = struct {	...	@@ -206,6 +206,19 @@ pub const File = struct {
206	};	206	};
207	}	207	}
208		208
		209	/// Must be called only after a successful call to `updateDecl`.
		210	pub fn updateDeclExports(
		211	base: *File,
		212	module: *Module,
		213	decl: *const Module.Decl,
		214	exports: []const *Module.Export,
		215	) !void {
		216	switch (base.tag) {
		217	.Elf => return @fieldParentPtr(Elf, "base", base).updateDeclExports(module, decl, exports),
		218	.C => return {},
		219	}
		220	}
		221
209	pub const Tag = enum {	222	pub const Tag = enum {
210	Elf,	223	Elf,
211	C,	224	C,
...	@@ -248,7 +261,7 @@ pub const File = struct {	...	@@ -248,7 +261,7 @@ pub const File = struct {
248	pub fn updateDecl(self: File.C, module: Module, decl: *Module.Decl) !void {	261	pub fn updateDecl(self: File.C, module: Module, decl: *Module.Decl) !void {
249	cgen.generate(self, decl) catch \|err\| {	262	cgen.generate(self, decl) catch \|err\| {
250	if (err == error.CGenFailure) {	263	if (err == error.CGenFailure) {
251	try module.failed_decls.put(decl, self.error_msg);	264	try module.failed_decls.put(module.gpa, decl, self.error_msg);
252	}	265	}
253	return err;	266	return err;
254	};	267	};
...	@@ -566,7 +579,7 @@ pub const File = struct {	...	@@ -566,7 +579,7 @@ pub const File = struct {
566	const file_size = self.options.program_code_size_hint;	579	const file_size = self.options.program_code_size_hint;
567	const p_align = 0x1000;	580	const p_align = 0x1000;
568	const off = self.findFreeSpace(file_size, p_align);	581	const off = self.findFreeSpace(file_size, p_align);
569	//std.log.debug(.link, "found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });	582	std.log.debug(.link, "found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
570	try self.program_headers.append(self.allocator, .{	583	try self.program_headers.append(self.allocator, .{
571	.p_type = elf.PT_LOAD,	584	.p_type = elf.PT_LOAD,
572	.p_offset = off,	585	.p_offset = off,
...	@@ -587,7 +600,7 @@ pub const File = struct {	...	@@ -587,7 +600,7 @@ pub const File = struct {
587	// page align.	600	// page align.
588	const p_align = 0x1000;	601	const p_align = 0x1000;
589	const off = self.findFreeSpace(file_size, p_align);	602	const off = self.findFreeSpace(file_size, p_align);
590	//std.log.debug(.link, "found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });	603	std.log.debug(.link, "found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
591	// TODO instead of hard coding the vaddr, make a function to find a vaddr to put things at.	604	// TODO instead of hard coding the vaddr, make a function to find a vaddr to put things at.
592	// we'll need to re-use that function anyway, in case the GOT grows and overlaps something	605	// we'll need to re-use that function anyway, in case the GOT grows and overlaps something
593	// else in virtual memory.	606	// else in virtual memory.
...	@@ -609,7 +622,7 @@ pub const File = struct {	...	@@ -609,7 +622,7 @@ pub const File = struct {
609	assert(self.shstrtab.items.len == 0);	622	assert(self.shstrtab.items.len == 0);
610	try self.shstrtab.append(self.allocator, 0); // need a 0 at position 0	623	try self.shstrtab.append(self.allocator, 0); // need a 0 at position 0
611	const off = self.findFreeSpace(self.shstrtab.items.len, 1);	624	const off = self.findFreeSpace(self.shstrtab.items.len, 1);
612	//std.log.debug(.link, "found shstrtab free space 0x{x} to 0x{x}\n", .{ off, off + self.shstrtab.items.len });	625	std.log.debug(.link, "found shstrtab free space 0x{x} to 0x{x}\n", .{ off, off + self.shstrtab.items.len });
613	try self.sections.append(self.allocator, .{	626	try self.sections.append(self.allocator, .{
614	.sh_name = try self.makeString(".shstrtab"),	627	.sh_name = try self.makeString(".shstrtab"),
615	.sh_type = elf.SHT_STRTAB,	628	.sh_type = elf.SHT_STRTAB,
...	@@ -667,7 +680,7 @@ pub const File = struct {	...	@@ -667,7 +680,7 @@ pub const File = struct {
667	const each_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Sym) else @sizeOf(elf.Elf64_Sym);	680	const each_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Sym) else @sizeOf(elf.Elf64_Sym);
668	const file_size = self.options.symbol_count_hint * each_size;	681	const file_size = self.options.symbol_count_hint * each_size;
669	const off = self.findFreeSpace(file_size, min_align);	682	const off = self.findFreeSpace(file_size, min_align);
670	//std.log.debug(.link, "found symtab free space 0x{x} to 0x{x}\n", .{ off, off + file_size });	683	std.log.debug(.link, "found symtab free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
671		684
672	try self.sections.append(self.allocator, .{	685	try self.sections.append(self.allocator, .{
673	.sh_name = try self.makeString(".symtab"),	686	.sh_name = try self.makeString(".symtab"),
...	@@ -783,7 +796,7 @@ pub const File = struct {	...	@@ -783,7 +796,7 @@ pub const File = struct {
783	shstrtab_sect.sh_offset = self.findFreeSpace(needed_size, 1);	796	shstrtab_sect.sh_offset = self.findFreeSpace(needed_size, 1);
784	}	797	}
785	shstrtab_sect.sh_size = needed_size;	798	shstrtab_sect.sh_size = needed_size;
786	//std.log.debug(.link, "shstrtab start=0x{x} end=0x{x}\n", .{ shstrtab_sect.sh_offset, shstrtab_sect.sh_offset + needed_size });	799	std.log.debug(.link, "shstrtab start=0x{x} end=0x{x}\n", .{ shstrtab_sect.sh_offset, shstrtab_sect.sh_offset + needed_size });
787		800
788	try self.file.?.pwriteAll(self.shstrtab.items, shstrtab_sect.sh_offset);	801	try self.file.?.pwriteAll(self.shstrtab.items, shstrtab_sect.sh_offset);
789	if (!self.shdr_table_dirty) {	802	if (!self.shdr_table_dirty) {
...	@@ -829,7 +842,7 @@ pub const File = struct {	...	@@ -829,7 +842,7 @@ pub const File = struct {
829		842
830	for (buf) \|*shdr, i\| {	843	for (buf) \|*shdr, i\| {
831	shdr.* = self.sections.items[i];	844	shdr.* = self.sections.items[i];
832	//std.log.debug(.link, "writing section {}\n", .{shdr.*});	845	std.log.debug(.link, "writing section {}\n", .{shdr.*});
833	if (foreign_endian) {	846	if (foreign_endian) {
834	bswapAllFields(elf.Elf64_Shdr, shdr);	847	bswapAllFields(elf.Elf64_Shdr, shdr);
835	}	848	}
...	@@ -840,6 +853,7 @@ pub const File = struct {	...	@@ -840,6 +853,7 @@ pub const File = struct {
840	self.shdr_table_dirty = false;	853	self.shdr_table_dirty = false;
841	}	854	}
842	if (self.entry_addr == null and self.options.output_mode == .Exe) {	855	if (self.entry_addr == null and self.options.output_mode == .Exe) {
		856	std.log.debug(.link, "no_entry_point_found = true\n", .{});
843	self.error_flags.no_entry_point_found = true;	857	self.error_flags.no_entry_point_found = true;
844	} else {	858	} else {
845	self.error_flags.no_entry_point_found = false;	859	self.error_flags.no_entry_point_found = false;
...	@@ -1153,10 +1167,10 @@ pub const File = struct {	...	@@ -1153,10 +1167,10 @@ pub const File = struct {
1153	try self.offset_table_free_list.ensureCapacity(self.allocator, self.local_symbols.items.len);	1167	try self.offset_table_free_list.ensureCapacity(self.allocator, self.local_symbols.items.len);
1154		1168
1155	if (self.local_symbol_free_list.popOrNull()) \|i\| {	1169	if (self.local_symbol_free_list.popOrNull()) \|i\| {
1156	//std.log.debug(.link, "reusing symbol index {} for {}\n", .{i, decl.name});	1170	std.log.debug(.link, "reusing symbol index {} for {}\n", .{i, decl.name});
1157	decl.link.local_sym_index = i;	1171	decl.link.local_sym_index = i;
1158	} else {	1172	} else {
1159	//std.log.debug(.link, "allocating symbol index {} for {}\n", .{self.local_symbols.items.len, decl.name});	1173	std.log.debug(.link, "allocating symbol index {} for {}\n", .{self.local_symbols.items.len, decl.name});
1160	decl.link.local_sym_index = @intCast(u32, self.local_symbols.items.len);	1174	decl.link.local_sym_index = @intCast(u32, self.local_symbols.items.len);
1161	_ = self.local_symbols.addOneAssumeCapacity();	1175	_ = self.local_symbols.addOneAssumeCapacity();
1162	}	1176	}
...	@@ -1204,7 +1218,7 @@ pub const File = struct {	...	@@ -1204,7 +1218,7 @@ pub const File = struct {
1204	.appended => code_buffer.items,	1218	.appended => code_buffer.items,
1205	.fail => \|em\| {	1219	.fail => \|em\| {
1206	decl.analysis = .codegen_failure;	1220	decl.analysis = .codegen_failure;
1207	try module.failed_decls.put(decl, em);	1221	try module.failed_decls.put(module.gpa, decl, em);
1208	return;	1222	return;
1209	},	1223	},
1210	};	1224	};
...	@@ -1224,11 +1238,11 @@ pub const File = struct {	...	@@ -1224,11 +1238,11 @@ pub const File = struct {
1224	!mem.isAlignedGeneric(u64, local_sym.st_value, required_alignment);	1238	!mem.isAlignedGeneric(u64, local_sym.st_value, required_alignment);
1225	if (need_realloc) {	1239	if (need_realloc) {
1226	const vaddr = try self.growTextBlock(&decl.link, code.len, required_alignment);	1240	const vaddr = try self.growTextBlock(&decl.link, code.len, required_alignment);
1227	//std.log.debug(.link, "growing {} from 0x{x} to 0x{x}\n", .{ decl.name, local_sym.st_value, vaddr });	1241	std.log.debug(.link, "growing {} from 0x{x} to 0x{x}\n", .{ decl.name, local_sym.st_value, vaddr });
1228	if (vaddr != local_sym.st_value) {	1242	if (vaddr != local_sym.st_value) {
1229	local_sym.st_value = vaddr;	1243	local_sym.st_value = vaddr;
1230		1244
1231	//std.log.debug(.link, " (writing new offset table entry)\n", .{});	1245	std.log.debug(.link, " (writing new offset table entry)\n", .{});
1232	self.offset_table.items[decl.link.offset_table_index] = vaddr;	1246	self.offset_table.items[decl.link.offset_table_index] = vaddr;
1233	try self.writeOffsetTableEntry(decl.link.offset_table_index);	1247	try self.writeOffsetTableEntry(decl.link.offset_table_index);
1234	}	1248	}
...	@@ -1246,7 +1260,7 @@ pub const File = struct {	...	@@ -1246,7 +1260,7 @@ pub const File = struct {
1246	const decl_name = mem.spanZ(decl.name);	1260	const decl_name = mem.spanZ(decl.name);
1247	const name_str_index = try self.makeString(decl_name);	1261	const name_str_index = try self.makeString(decl_name);
1248	const vaddr = try self.allocateTextBlock(&decl.link, code.len, required_alignment);	1262	const vaddr = try self.allocateTextBlock(&decl.link, code.len, required_alignment);
1249	//std.log.debug(.link, "allocated text block for {} at 0x{x}\n", .{ decl_name, vaddr });	1263	std.log.debug(.link, "allocated text block for {} at 0x{x}\n", .{ decl_name, vaddr });
1250	errdefer self.freeTextBlock(&decl.link);	1264	errdefer self.freeTextBlock(&decl.link);
1251		1265
1252	local_sym.* = .{	1266	local_sym.* = .{
...	@@ -1290,7 +1304,7 @@ pub const File = struct {	...	@@ -1290,7 +1304,7 @@ pub const File = struct {
1290	for (exports) \|exp\| {	1304	for (exports) \|exp\| {
1291	if (exp.options.section) \|section_name\| {	1305	if (exp.options.section) \|section_name\| {
1292	if (!mem.eql(u8, section_name, ".text")) {	1306	if (!mem.eql(u8, section_name, ".text")) {
1293	try module.failed_exports.ensureCapacity(module.failed_exports.items().len + 1);	1307	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
1294	module.failed_exports.putAssumeCapacityNoClobber(	1308	module.failed_exports.putAssumeCapacityNoClobber(
1295	exp,	1309	exp,
1296	try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: ExportOptions.section", .{}),	1310	try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: ExportOptions.section", .{}),
...	@@ -1308,7 +1322,7 @@ pub const File = struct {	...	@@ -1308,7 +1322,7 @@ pub const File = struct {
1308	},	1322	},
1309	.Weak => elf.STB_WEAK,	1323	.Weak => elf.STB_WEAK,
1310	.LinkOnce => {	1324	.LinkOnce => {
1311	try module.failed_exports.ensureCapacity(module.failed_exports.items().len + 1);	1325	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
1312	module.failed_exports.putAssumeCapacityNoClobber(	1326	module.failed_exports.putAssumeCapacityNoClobber(
1313	exp,	1327	exp,
1314	try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: GlobalLinkage.LinkOnce", .{}),	1328	try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: GlobalLinkage.LinkOnce", .{}),