Commit 7598a00f34e91375bc8d4f57e8f5ecbc0d1b4d14 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-03-20 22:40:08-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-03-20 22:40:08-07:00
log	7598a00f34e91375bc8d4f57e8f5ecbc0d1b4d14
tree	75338d2cf30fb9092692d0b447d8e2cd610d3023
parent	d8692b8bdb4630f2bb2763cdbe609de7d73b28d8

stage2: fix memory management of ZIR code

 * free Module.Fn ZIR code when destroying the owner Decl
 * unreachable_safe and unreachable_unsafe are collapsed into one ZIR
   instruction with a safety flag.
 * astgen: emit an unreachable instruction for unreachable literals
 * don't forget to call deinit on ZIR code
 * astgen: implement some builtin functions

5 files changed, 114 insertions(+), 84 deletions(-)

src/Module.zig+23-10

...	@@ -224,6 +224,10 @@ pub const Decl = struct {	...	@@ -224,6 +224,10 @@ pub const Decl = struct {
224	const gpa = module.gpa;	224	const gpa = module.gpa;
225	gpa.free(mem.spanZ(decl.name));	225	gpa.free(mem.spanZ(decl.name));
226	if (decl.typedValueManaged()) \|tvm\| {	226	if (decl.typedValueManaged()) \|tvm\| {
		227	if (tvm.typed_value.val.castTag(.function)) \|payload\| {
		228	const func = payload.data;
		229	func.deinit(gpa);
		230	}
227	tvm.deinit(gpa);	231	tvm.deinit(gpa);
228	}	232	}
229	decl.dependants.deinit(gpa);	233	decl.dependants.deinit(gpa);
...	@@ -334,7 +338,7 @@ pub const EmitH = struct {	...	@@ -334,7 +338,7 @@ pub const EmitH = struct {
334	fwd_decl: std.ArrayListUnmanaged(u8) = .{},	338	fwd_decl: std.ArrayListUnmanaged(u8) = .{},
335	};	339	};
336		340
337	/// Fn struct memory is owned by the Decl's TypedValue.Managed arena allocator.	341	/// Some Fn struct memory is owned by the Decl's TypedValue.Managed arena allocator.
338	/// Extern functions do not have this data structure; they are represented by	342	/// Extern functions do not have this data structure; they are represented by
339	/// the `Decl` only, with a `Value` tag of `extern_fn`.	343	/// the `Decl` only, with a `Value` tag of `extern_fn`.
340	pub const Fn = struct {	344	pub const Fn = struct {
...	@@ -347,6 +351,7 @@ pub const Fn = struct {	...	@@ -347,6 +351,7 @@ pub const Fn = struct {
347	/// The number of parameters is determined by referring to the type.	351	/// The number of parameters is determined by referring to the type.
348	/// The first N elements of `extra` are indexes into `string_bytes` to	352	/// The first N elements of `extra` are indexes into `string_bytes` to
349	/// a null-terminated string.	353	/// a null-terminated string.
		354	/// This memory is managed with gpa, must be freed when the function is freed.
350	zir: zir.Code,	355	zir: zir.Code,
351	/// undefined unless analysis state is `success`.	356	/// undefined unless analysis state is `success`.
352	body: ir.Body,	357	body: ir.Body,
...	@@ -370,6 +375,10 @@ pub const Fn = struct {	...	@@ -370,6 +375,10 @@ pub const Fn = struct {
370	pub fn dump(func: *Fn, mod: Module) void {	375	pub fn dump(func: *Fn, mod: Module) void {
371	ir.dumpFn(mod, func);	376	ir.dumpFn(mod, func);
372	}	377	}
		378
		379	pub fn deinit(func: Fn, gpa: Allocator) void {
		380	func.zir.deinit(gpa);
		381	}
373	};	382	};
374		383
375	pub const Var = struct {	384	pub const Var = struct {
...	@@ -1502,8 +1511,7 @@ pub const WipZirCode = struct {	...	@@ -1502,8 +1511,7 @@ pub const WipZirCode = struct {
1502	.ret_node,	1511	.ret_node,
1503	.ret_tok,	1512	.ret_tok,
1504	.ret_coerce,	1513	.ret_coerce,
1505	.unreachable_unsafe,	1514	.@"unreachable",
1506	.unreachable_safe,
1507	.loop,	1515	.loop,
1508	.suspend_block,	1516	.suspend_block,
1509	.suspend_block_one,	1517	.suspend_block_one,
...	@@ -1521,6 +1529,7 @@ pub const WipZirCode = struct {	...	@@ -1521,6 +1529,7 @@ pub const WipZirCode = struct {
1521	pub fn deinit(wzc: *WipZirCode) void {	1529	pub fn deinit(wzc: *WipZirCode) void {
1522	wzc.instructions.deinit(wzc.gpa);	1530	wzc.instructions.deinit(wzc.gpa);
1523	wzc.extra.deinit(wzc.gpa);	1531	wzc.extra.deinit(wzc.gpa);
		1532	wzc.string_bytes.deinit(wzc.gpa);
1524	}	1533	}
1525	};	1534	};
1526		1535
...	@@ -2078,7 +2087,7 @@ fn astgenAndSemaDecl(mod: Module, decl: Decl) !bool {	...	@@ -2078,7 +2087,7 @@ fn astgenAndSemaDecl(mod: Module, decl: Decl) !bool {
2078	var analysis_arena = std.heap.ArenaAllocator.init(mod.gpa);	2087	var analysis_arena = std.heap.ArenaAllocator.init(mod.gpa);
2079	defer analysis_arena.deinit();	2088	defer analysis_arena.deinit();
2080		2089
2081	const code: zir.Code = blk: {	2090	var code: zir.Code = blk: {
2082	var wip_zir_code: WipZirCode = .{	2091	var wip_zir_code: WipZirCode = .{
2083	.decl = decl,	2092	.decl = decl,
2084	.arena = &analysis_arena.allocator,	2093	.arena = &analysis_arena.allocator,
...	@@ -2102,6 +2111,7 @@ fn astgenAndSemaDecl(mod: Module, decl: Decl) !bool {	...	@@ -2102,6 +2111,7 @@ fn astgenAndSemaDecl(mod: Module, decl: Decl) !bool {
2102	}	2111	}
2103	break :blk code;	2112	break :blk code;
2104	};	2113	};
		2114	defer code.deinit(mod.gpa);
2105		2115
2106	var sema: Sema = .{	2116	var sema: Sema = .{
2107	.mod = mod,	2117	.mod = mod,
...	@@ -2154,17 +2164,17 @@ fn astgenAndSemaFn(	...	@@ -2154,17 +2164,17 @@ fn astgenAndSemaFn(
2154	var fn_type_scope_arena = std.heap.ArenaAllocator.init(mod.gpa);	2164	var fn_type_scope_arena = std.heap.ArenaAllocator.init(mod.gpa);
2155	defer fn_type_scope_arena.deinit();	2165	defer fn_type_scope_arena.deinit();
2156		2166
2157	var fn_type_wip_zir_exec: WipZirCode = .{	2167	var fn_type_wip_zir_code: WipZirCode = .{
2158	.decl = decl,	2168	.decl = decl,
2159	.arena = &fn_type_scope_arena.allocator,	2169	.arena = &fn_type_scope_arena.allocator,
2160	.gpa = mod.gpa,	2170	.gpa = mod.gpa,
2161	};	2171	};
2162	defer fn_type_wip_zir_exec.deinit();	2172	defer fn_type_wip_zir_code.deinit();
2163		2173
2164	var fn_type_scope: Scope.GenZir = .{	2174	var fn_type_scope: Scope.GenZir = .{
2165	.force_comptime = true,	2175	.force_comptime = true,
2166	.parent = &decl.container.base,	2176	.parent = &decl.container.base,
2167	.zir_code = &fn_type_wip_zir_exec,	2177	.zir_code = &fn_type_wip_zir_code,
2168	};	2178	};
2169	defer fn_type_scope.instructions.deinit(mod.gpa);	2179	defer fn_type_scope.instructions.deinit(mod.gpa);
2170		2180
...	@@ -2317,7 +2327,8 @@ fn astgenAndSemaFn(	...	@@ -2317,7 +2327,8 @@ fn astgenAndSemaFn(
2317	errdefer decl_arena.deinit();	2327	errdefer decl_arena.deinit();
2318	const decl_arena_state = try decl_arena.allocator.create(std.heap.ArenaAllocator.State);	2328	const decl_arena_state = try decl_arena.allocator.create(std.heap.ArenaAllocator.State);
2319		2329
2320	const fn_type_code = try fn_type_scope.finish();	2330	var fn_type_code = try fn_type_scope.finish();
		2331	defer fn_type_code.deinit(mod.gpa);
2321	if (std.builtin.mode == .Debug and mod.comp.verbose_ir) {	2332	if (std.builtin.mode == .Debug and mod.comp.verbose_ir) {
2322	fn_type_code.dump(mod.gpa, "fn_type", &fn_type_scope.base, 0) catch {};	2333	fn_type_code.dump(mod.gpa, "fn_type", &fn_type_scope.base, 0) catch {};
2323	}	2334	}
...	@@ -2621,7 +2632,8 @@ fn astgenAndSemaVarDecl(	...	@@ -2621,7 +2632,8 @@ fn astgenAndSemaVarDecl(
2621	init_result_loc,	2632	init_result_loc,
2622	var_decl.ast.init_node,	2633	var_decl.ast.init_node,
2623	);	2634	);
2624	const code = try gen_scope.finish();	2635	var code = try gen_scope.finish();
		2636	defer code.deinit(mod.gpa);
2625	if (std.builtin.mode == .Debug and mod.comp.verbose_ir) {	2637	if (std.builtin.mode == .Debug and mod.comp.verbose_ir) {
2626	code.dump(mod.gpa, "var_init", &gen_scope.base, 0) catch {};	2638	code.dump(mod.gpa, "var_init", &gen_scope.base, 0) catch {};
2627	}	2639	}
...	@@ -2683,7 +2695,8 @@ fn astgenAndSemaVarDecl(	...	@@ -2683,7 +2695,8 @@ fn astgenAndSemaVarDecl(
2683	defer type_scope.instructions.deinit(mod.gpa);	2695	defer type_scope.instructions.deinit(mod.gpa);
2684		2696
2685	const var_type = try astgen.typeExpr(mod, &type_scope.base, var_decl.ast.type_node);	2697	const var_type = try astgen.typeExpr(mod, &type_scope.base, var_decl.ast.type_node);
2686	const code = try type_scope.finish();	2698	var code = try type_scope.finish();
		2699	defer code.deinit(mod.gpa);
2687	if (std.builtin.mode == .Debug and mod.comp.verbose_ir) {	2700	if (std.builtin.mode == .Debug and mod.comp.verbose_ir) {
2688	code.dump(mod.gpa, "var_type", &type_scope.base, 0) catch {};	2701	code.dump(mod.gpa, "var_type", &type_scope.base, 0) catch {};
2689	}	2702	}

src/Sema.zig+5-10

 @@ -137,8 +137,7 @@ pub fn analyzeBody(sema: *Sema, block: *Scope.Block, body: []const zir.Inst.Inde
             .as_node => try sema.zirAsNode(block, zir_inst),
             .@"asm" => try sema.zirAsm(block, zir_inst, false),
             .asm_volatile => try sema.zirAsm(block, zir_inst, true),
-            .unreachable_safe => try sema.zirUnreachable(block, zir_inst, true),
+            .@"unreachable" => try sema.zirUnreachable(block, zir_inst),
-            .unreachable_unsafe => try sema.zirUnreachable(block, zir_inst, false),
             .ret_coerce => try sema.zirRetTok(block, zir_inst, true),
             .ret_tok => try sema.zirRetTok(block, zir_inst, false),
             .ret_node => try sema.zirRetNode(block, zir_inst),
 @@ -2852,17 +2851,13 @@ fn zirCondbr(sema: *Sema, parent_block: *Scope.Block, inst: zir.Inst.Index) Inne
     return parent_block.addCondBr(src, cond, tzir_then_body, tzir_else_body);
 }
-fn zirUnreachable(
+fn zirUnreachable(sema: *Sema, block: *Scope.Block, inst: zir.Inst.Index) InnerError!*Inst {
-    sema: *Sema,
-    block: *Scope.Block,
-    inst: zir.Inst.Index,
-    safety_check: bool,
-) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    const src_node = sema.code.instructions.items(.data)[inst].node;
+    const inst_data = sema.code.instructions.items(.data)[inst].@"unreachable";
-    const src: LazySrcLoc = .{ .node_offset = src_node };
+    const src = inst_data.src();
+    const safety_check = inst_data.safety;
     try sema.requireRuntimeBlock(block, src);
     // TODO Add compile error for @optimizeFor occurring too late in a scope.
     if (safety_check and block.wantSafety()) {

src/astgen.zig+40-31

 @@ -415,10 +415,13 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
             return callExpr(mod, scope, rl, node, tree.callFull(node));
         },
-        .unreachable_literal => {
+        .unreachable_literal => return gz.add(.{
-            const result = @enumToInt(zir.Const.unreachable_value);
+            .tag = .@"unreachable",
-            return rvalue(mod, scope, rl, result, node);
+            .data = .{ .@"unreachable" = .{
-        },
+                .safety = true,
+                .src_node = gz.zir_code.decl.nodeIndexToRelative(node),
+            } },
+        }),
         .@"return" => return ret(mod, scope, node),
         .field_access => return fieldAccess(mod, scope, rl, node),
         .float_literal => return floatLiteral(mod, scope, rl, node),
 @@ -3012,10 +3015,11 @@ fn as(
     scope: *Scope,
     rl: ResultLoc,
     builtin_token: ast.TokenIndex,
-    src: usize,
+    node: ast.Node.Index,
     lhs: ast.Node.Index,
     rhs: ast.Node.Index,
 ) InnerError!zir.Inst.Ref {
+    if (true) @panic("TODO update for zir-memory-layout");
     const dest_type = try typeExpr(mod, scope, lhs);
     switch (rl) {
         .none, .discard, .ref, .ty => {
 @@ -3090,10 +3094,11 @@ fn bitCast(
     scope: *Scope,
     rl: ResultLoc,
     builtin_token: ast.TokenIndex,
-    src: usize,
+    node: ast.Node.Index,
     lhs: ast.Node.Index,
     rhs: ast.Node.Index,
 ) InnerError!zir.Inst.Ref {
+    if (true) @panic("TODO update for zir-memory-layout");
     const dest_type = try typeExpr(mod, scope, lhs);
     switch (rl) {
         .none => {
 @@ -3138,9 +3143,10 @@ fn typeOf(
     scope: *Scope,
     rl: ResultLoc,
     builtin_token: ast.TokenIndex,
-    src: usize,
+    node: ast.Node.Index,
     params: []const ast.Node.Index,
 ) InnerError!zir.Inst.Ref {
+    if (true) @panic("TODO update for zir-memory-layout");
     if (params.len < 1) {
         return mod.failTok(scope, builtin_token, "expected at least 1 argument, found 0", .{});
     }
 @@ -3158,14 +3164,13 @@ fn builtinCall(
     mod: *Module,
     scope: *Scope,
     rl: ResultLoc,
-    call: ast.Node.Index,
+    node: ast.Node.Index,
     params: []const ast.Node.Index,
 ) InnerError!zir.Inst.Ref {
-    if (true) @panic("TODO update for zir-memory-layout");
     const tree = scope.tree();
     const main_tokens = tree.nodes.items(.main_token);
-    const builtin_token = main_tokens[call];
+    const builtin_token = main_tokens[node];
     const builtin_name = tree.tokenSlice(builtin_token);
     // We handle the different builtins manually because they have different semantics depending
 @@ -3187,56 +3192,60 @@ fn builtinCall(
         }
     }
+    const gz = scope.getGenZir();
     switch (info.tag) {
         .ptr_to_int => {
             const operand = try expr(mod, scope, .none, params[0]);
-            const result = try addZIRUnOp(mod, scope, src, .ptrtoint, operand);
+            const result = try gz.addUnNode(.ptrtoint, operand, node);
-            return rvalue(mod, scope, rl, result);
+            return rvalue(mod, scope, rl, result, node);
         },
         .float_cast => {
+            if (true) @panic("TODO update for zir-memory-layout");
             const dest_type = try typeExpr(mod, scope, params[0]);
             const rhs = try expr(mod, scope, .none, params[1]);
             const result = try addZIRBinOp(mod, scope, src, .floatcast, dest_type, rhs);
-            return rvalue(mod, scope, rl, result);
+            return rvalue(mod, scope, rl, result, node);
         },
         .int_cast => {
+            if (true) @panic("TODO update for zir-memory-layout");
             const dest_type = try typeExpr(mod, scope, params[0]);
             const rhs = try expr(mod, scope, .none, params[1]);
             const result = try addZIRBinOp(mod, scope, src, .intcast, dest_type, rhs);
-            return rvalue(mod, scope, rl, result);
+            return rvalue(mod, scope, rl, result, node);
         },
         .breakpoint => {
+            if (true) @panic("TODO update for zir-memory-layout");
             const result = try addZIRNoOp(mod, scope, src, .breakpoint);
-            return rvalue(mod, scope, rl, result);
+            return rvalue(mod, scope, rl, result, node);
         },
         .import => {
             const target = try expr(mod, scope, .none, params[0]);
-            const result = try addZIRUnOp(mod, scope, src, .import, target);
+            const result = try gz.addUnNode(.import, target, node);
-            return rvalue(mod, scope, rl, result);
+            return rvalue(mod, scope, rl, result, node);
         },
         .compile_error => {
             const target = try expr(mod, scope, .none, params[0]);
-            const result = try addZIRUnOp(mod, scope, src, .compile_error, target);
+            const result = try gz.addUnNode(.compile_error, target, node);
-            return rvalue(mod, scope, rl, result);
+            return rvalue(mod, scope, rl, result, node);
         },
         .set_eval_branch_quota => {
-            const u32_type = try addZIRInstConst(mod, scope, src, .{
+            const u32_rl: ResultLoc = .{ .ty = @enumToInt(zir.Const.u32_type) };
-                .ty = Type.initTag(.type),
+            const quota = try expr(mod, scope, u32_rl, params[0]);
-                .val = Value.initTag(.u32_type),
+            const result = try gz.addUnNode(.set_eval_branch_quota, quota, node);
-            });
+            return rvalue(mod, scope, rl, result, node);
-            const quota = try expr(mod, scope, .{ .ty = u32_type }, params[0]);
-            const result = try addZIRUnOp(mod, scope, src, .set_eval_branch_quota, quota);
-            return rvalue(mod, scope, rl, result);
         },
         .compile_log => {
+            if (true) @panic("TODO update for zir-memory-layout");
             const arena = scope.arena();
             var targets = try arena.alloc(zir.Inst.Ref, params.len);
             for (params) |param, param_i|
                 targets[param_i] = try expr(mod, scope, .none, param);
             const result = try addZIRInst(mod, scope, src, zir.Inst.CompileLog, .{ .to_log = targets }, .{});
-            return rvalue(mod, scope, rl, result);
+            return rvalue(mod, scope, rl, result, node);
         },
         .field => {
+            if (true) @panic("TODO update for zir-memory-layout");
             const string_type = try addZIRInstConst(mod, scope, src, .{
                 .ty = Type.initTag(.type),
                 .val = Value.initTag(.const_slice_u8_type),
 @@ -3252,11 +3261,11 @@ fn builtinCall(
             return rvalue(mod, scope, rl, try addZirInstTag(mod, scope, src, .field_val_named, .{
                 .object = try expr(mod, scope, .none, params[0]),
                 .field_name = try comptimeExpr(mod, scope, string_rl, params[1]),
-            }));
+            }), node);
         },
-        .as => return as(mod, scope, rl, builtin_token, src, params[0], params[1]),
+        .as => return as(mod, scope, rl, builtin_token, node, params[0], params[1]),
-        .bit_cast => return bitCast(mod, scope, rl, builtin_token, src, params[0], params[1]),
+        .bit_cast => return bitCast(mod, scope, rl, builtin_token, node, params[0], params[1]),
-        .TypeOf => return typeOf(mod, scope, rl, builtin_token, src, params),
+        .TypeOf => return typeOf(mod, scope, rl, builtin_token, node, params),
         .add_with_overflow,
         .align_cast,

src/main.zig+13-20

 @@ -1750,15 +1750,12 @@ fn buildOutputType(
     }
     const self_exe_path = try fs.selfExePathAlloc(arena);
-    var zig_lib_directory: Compilation.Directory = if (override_lib_dir) |lib_dir|
+    var zig_lib_directory: Compilation.Directory = if (override_lib_dir) |lib_dir| .{
-        .{
+        .path = lib_dir,
-            .path = lib_dir,
+        .handle = try fs.cwd().openDir(lib_dir, .{}),
-            .handle = try fs.cwd().openDir(lib_dir, .{}),
+    } else introspect.findZigLibDirFromSelfExe(arena, self_exe_path) catch |err| {
-        }
+        fatal("unable to find zig installation directory: {s}", .{@errorName(err)});
-    else
+    };
-        introspect.findZigLibDirFromSelfExe(arena, self_exe_path) catch |err| {
-            fatal("unable to find zig installation directory: {s}", .{@errorName(err)});
-        };
     defer zig_lib_directory.handle.close();
     var thread_pool: ThreadPool = undefined;
 @@ -2461,15 +2458,12 @@ pub fn cmdBuild(gpa: *Allocator, arena: *Allocator, args: []const []const u8) !v
             }
         }
-        var zig_lib_directory: Compilation.Directory = if (override_lib_dir) |lib_dir|
+        var zig_lib_directory: Compilation.Directory = if (override_lib_dir) |lib_dir| .{
-            .{
+            .path = lib_dir,
-                .path = lib_dir,
+            .handle = try fs.cwd().openDir(lib_dir, .{}),
-                .handle = try fs.cwd().openDir(lib_dir, .{}),
+        } else introspect.findZigLibDirFromSelfExe(arena, self_exe_path) catch |err| {
-            }
+            fatal("unable to find zig installation directory: {s}", .{@errorName(err)});
-        else
+        };
-            introspect.findZigLibDirFromSelfExe(arena, self_exe_path) catch |err| {
-                fatal("unable to find zig installation directory: {s}", .{@errorName(err)});
-            };
         defer zig_lib_directory.handle.close();
         const std_special = "std" ++ fs.path.sep_str ++ "special";
 @@ -3281,8 +3275,7 @@ pub const ClangArgIterator = struct {
                 self.zig_equivalent = clang_arg.zig_equivalent;
                 break :find_clang_arg;
             },
-        }
+        } else {
-        else {
             fatal("Unknown Clang option: '{s}'", .{arg});
         }
     }

src/zir.zig+33-13

 @@ -67,6 +67,13 @@ pub const Code = struct {
         return code.string_bytes[index..end :0];
     }
+    pub fn deinit(code: *Code, gpa: *Allocator) void {
+        code.instructions.deinit(gpa);
+        gpa.free(code.string_bytes);
+        gpa.free(code.extra);
+        code.* = undefined;
+    }
     /// For debugging purposes, like dumpFn but for unanalyzed zir blocks
     pub fn dump(
         code: Code,
 @@ -737,15 +744,9 @@ pub const Inst = struct {
         /// of one or more params.
         /// Uses the `pl_node` field. AST node is the `@TypeOf` call. Payload is `MultiOp`.
         typeof_peer,
-        /// Asserts control-flow will not reach this instruction. Not safety checked - the compiler
+        /// Asserts control-flow will not reach this instruction (`unreachable`).
-        /// will assume the correctness of this instruction.
+        /// Uses the `unreachable` union field.
-        /// Uses the `node` union field.
+        @"unreachable",
-        unreachable_unsafe,
-        /// Asserts control-flow will not reach this instruction. In safety-checked modes,
-        /// this will generate a call to the panic function unless it can be proven unreachable
-        /// by the compiler.
-        /// Uses the `node` union field.
-        unreachable_safe,
         /// Bitwise XOR. `^`
         xor,
         /// Create an optional type '?T'
 @@ -989,8 +990,7 @@ pub const Inst = struct {
                 .ret_node,
                 .ret_tok,
                 .ret_coerce,
-                .unreachable_unsafe,
+                .@"unreachable",
-                .unreachable_safe,
                 .loop,
                 .suspend_block,
                 .suspend_block_one,
 @@ -1131,6 +1131,20 @@ pub const Inst = struct {
             callee: Ref,
             param_index: u32,
         },
+        @"unreachable": struct {
+            /// Offset from Decl AST node index.
+            /// `Tag` determines which kind of AST node this points to.
+            src_node: i32,
+            /// `false`: Not safety checked - the compiler will assume the
+            /// correctness of this instruction.
+            /// `true`: In safety-checked modes, this will generate a call
+            /// to the panic function unless it can be proven unreachable by the compiler.
+            safety: bool,
+            pub fn src(self: @This()) LazySrcLoc {
+                return .{ .node_offset = self.src_node };
+            }
+        },
         // Make sure we don't accidentally add a field to make this union
         // bigger than expected. Note that in Debug builds, Zig is allowed
 @@ -1408,8 +1422,6 @@ const Writer = struct {
             .dbg_stmt_node,
             .ret_ptr,
             .ret_type,
-            .unreachable_unsafe,
-            .unreachable_safe,
             => try self.writeNode(stream, inst),
             .decl_ref,
 @@ -1424,6 +1436,7 @@ const Writer = struct {
             .fn_type_cc => try self.writeFnTypeCc(stream, inst, false),
             .fn_type_var_args => try self.writeFnType(stream, inst, true),
             .fn_type_cc_var_args => try self.writeFnTypeCc(stream, inst, true),
+            .@"unreachable" => try self.writeUnreachable(stream, inst),
             .enum_literal_small => try self.writeSmallStr(stream, inst),
 @@ -1612,6 +1625,13 @@ const Writer = struct {
         return self.writeFnTypeCommon(stream, param_types, inst_data.return_type, var_args, cc);
     }
+    fn writeUnreachable(self: *Writer, stream: anytype, inst: Inst.Index) !void {
+        const inst_data = self.code.instructions.items(.data)[inst].@"unreachable";
+        const safety_str = if (inst_data.safety) "safe" else "unsafe";
+        try stream.print("{s}) ", .{safety_str});
+        try self.writeSrc(stream, inst_data.src());
+    }
     fn writeFnTypeCommon(
         self: *Writer,
         stream: anytype,