Commit d8f3f14532c4b5d65377efaef015c3855137dccf | zig

build.zig-2

...	@@ -220,7 +220,6 @@ pub fn build(b: *Builder) !void {	...	@@ -220,7 +220,6 @@ pub fn build(b: *Builder) !void {
220	}	220	}
221		221
222	const log_scopes = b.option([]const []const u8, "log", "Which log scopes to enable") orelse &[0][]const u8{};	222	const log_scopes = b.option([]const []const u8, "log", "Which log scopes to enable") orelse &[0][]const u8{};
223	const zir_dumps = b.option([]const []const u8, "dump-zir", "Which functions to dump ZIR for before codegen") orelse &[0][]const u8{};
224		223
225	const opt_version_string = b.option([]const u8, "version-string", "Override Zig version string. Default is to find out with git.");	224	const opt_version_string = b.option([]const u8, "version-string", "Override Zig version string. Default is to find out with git.");
226	const version = if (opt_version_string) \|version\| version else v: {	225	const version = if (opt_version_string) \|version\| version else v: {
...	@@ -277,7 +276,6 @@ pub fn build(b: *Builder) !void {	...	@@ -277,7 +276,6 @@ pub fn build(b: *Builder) !void {
277	exe.addBuildOption(std.SemanticVersion, "semver", semver);	276	exe.addBuildOption(std.SemanticVersion, "semver", semver);
278		277
279	exe.addBuildOption([]const []const u8, "log_scopes", log_scopes);	278	exe.addBuildOption([]const []const u8, "log_scopes", log_scopes);
280	exe.addBuildOption([]const []const u8, "zir_dumps", zir_dumps);
281	exe.addBuildOption(bool, "enable_tracy", tracy != null);	279	exe.addBuildOption(bool, "enable_tracy", tracy != null);
282	exe.addBuildOption(bool, "is_stage1", is_stage1);	280	exe.addBuildOption(bool, "is_stage1", is_stage1);
283	if (tracy) \|tracy_path\| {	281	if (tracy) \|tracy_path\| {

src/Compilation.zig+10-5

 @@ -1459,24 +1459,29 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
                 const module = self.bin_file.options.module.?;
                 if (decl.typed_value.most_recent.typed_value.val.castTag(.function)) |payload| {
                     const func = payload.data;
-                    switch (func.analysis) {
+                    switch (func.state) {
                         .queued => module.analyzeFnBody(decl, func) catch |err| switch (err) {
                             error.AnalysisFail => {
-                                assert(func.analysis != .in_progress);
+                                assert(func.state != .in_progress);
                                 continue;
                             },
                             error.OutOfMemory => return error.OutOfMemory,
                         },
                         .in_progress => unreachable,
+                        .inline_only => unreachable, // don't queue work for this
                         .sema_failure, .dependency_failure => continue,
                         .success => {},
                     }
-                    // Here we tack on additional allocations to the Decl's arena. The allocations are
+                    // Here we tack on additional allocations to the Decl's arena. The allocations
-                    // lifetime annotations in the ZIR.
+                    // are lifetime annotations in the ZIR.
                     var decl_arena = decl.typed_value.most_recent.arena.?.promote(module.gpa);
                     defer decl.typed_value.most_recent.arena.?.* = decl_arena.state;
                     log.debug("analyze liveness of {s}\n", .{decl.name});
-                    try liveness.analyze(module.gpa, &decl_arena.allocator, func.analysis.success);
+                    try liveness.analyze(module.gpa, &decl_arena.allocator, func.body);
+                    if (std.builtin.mode == .Debug and self.verbose_ir) {
+                        func.dump(module.*);
+                    }
                 }
                 assert(decl.typed_value.most_recent.typed_value.ty.hasCodeGenBits());

src/Module.zig+188-76

 @@ -268,6 +268,11 @@ pub const Decl = struct {
         }
     }
+    /// Asserts that the `Decl` is part of AST and not ZIRModule.
+    pub fn getFileScope(self: *Decl) *Scope.File {
+        return self.scope.cast(Scope.Container).?.file_scope;
+    }
     fn removeDependant(self: *Decl, other: *Decl) void {
         self.dependants.removeAssertDiscard(other);
     }
 @@ -281,46 +286,32 @@ pub const Decl = struct {
 /// Extern functions do not have this data structure; they are represented by
 /// the `Decl` only, with a `Value` tag of `extern_fn`.
 pub const Fn = struct {
-    /// This memory owned by the Decl's TypedValue.Managed arena allocator.
+    owner_decl: *Decl,
-    analysis: union(enum) {
+    /// Contains un-analyzed ZIR instructions generated from Zig source AST.
-        queued: *ZIR,
+    /// Even after we finish analysis, the ZIR is kept in memory, so that
+    /// comptime and inline function calls can happen.
+    zir: zir.Module.Body,
+    /// undefined unless analysis state is `success`.
+    body: Body,
+    state: Analysis,
+    pub const Analysis = enum {
+        queued,
+        /// This function intentionally only has ZIR generated because it is marked
+        /// inline, which means no runtime version of the function will be generated.
+        inline_only,
         in_progress,
         /// There will be a corresponding ErrorMsg in Module.failed_decls
         sema_failure,
-        /// This Fn might be OK but it depends on another Decl which did not successfully complete
+        /// This Fn might be OK but it depends on another Decl which did not
-        /// semantic analysis.
+        /// successfully complete semantic analysis.
         dependency_failure,
-        success: Body,
+        success,
-    },
-    owner_decl: *Decl,
-    /// This memory is temporary and points to stack memory for the duration
-    /// of Fn analysis.
-    pub const Analysis = struct {
-        inner_block: Scope.Block,
-    };
-    /// Contains un-analyzed ZIR instructions generated from Zig source AST.
-    pub const ZIR = struct {
-        body: zir.Module.Body,
-        arena: std.heap.ArenaAllocator.State,
     };
     /// For debugging purposes.
     pub fn dump(self: *Fn, mod: Module) void {
-        std.debug.print("Module.Function(name={s}) ", .{self.owner_decl.name});
+        zir.dumpFn(mod, self);
-        switch (self.analysis) {
-            .queued => {
-                std.debug.print("queued\n", .{});
-            },
-            .in_progress => {
-                std.debug.print("in_progress\n", .{});
-            },
-            else => {
-                std.debug.print("\n", .{});
-                zir.dumpFn(mod, self);
-            },
-        }
     }
 };
 @@ -761,21 +752,60 @@ pub const Scope = struct {
     /// during semantic analysis of the block.
     pub const Block = struct {
         pub const base_tag: Tag = .block;
         base: Scope = Scope{ .tag = base_tag },
         parent: ?*Block,
+        /// Maps ZIR to TZIR. Shared to sub-blocks.
+        inst_table: *InstTable,
         func: ?*Fn,
         decl: *Decl,
         instructions: ArrayListUnmanaged(*Inst),
         /// Points to the arena allocator of DeclAnalysis
         arena: *Allocator,
         label: ?Label = null,
+        inlining: ?*Inlining,
         is_comptime: bool,
+        pub const InstTable = std.AutoHashMap(*zir.Inst, *Inst);
+        /// This `Block` maps a block ZIR instruction to the corresponding
+        /// TZIR instruction for break instruction analysis.
         pub const Label = struct {
             zir_block: *zir.Inst.Block,
+            merges: Merges,
+        };
+        /// This `Block` indicates that an inline function call is happening
+        /// and return instructions should be analyzed as a break instruction
+        /// to this TZIR block instruction.
+        /// It is shared among all the blocks in an inline or comptime called
+        /// function.
+        pub const Inlining = struct {
+            /// Shared state among the entire inline/comptime call stack.
+            shared: *Shared,
+            /// We use this to count from 0 so that arg instructions know
+            /// which parameter index they are, without having to store
+            /// a parameter index with each arg instruction.
+            param_index: usize,
+            casted_args: []*Inst,
+            merges: Merges,
+            pub const Shared = struct {
+                caller: ?*Fn,
+                branch_count: u64,
+                branch_quota: u64,
+            };
+        };
+        pub const Merges = struct {
             results: ArrayListUnmanaged(*Inst),
             block_inst: *Inst.Block,
         };
+        /// For debugging purposes.
+        pub fn dump(self: *Block, mod: Module) void {
+            zir.dumpBlock(mod, self);
+        }
     };
     /// This is a temporary structure, references to it are valid only
 @@ -992,11 +1022,11 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
     defer tracy.end();
     const container_scope = decl.scope.cast(Scope.Container).?;
-    const tree = try self.getAstTree(container_scope);
+    const tree = try self.getAstTree(container_scope.file_scope);
     const ast_node = tree.root_node.decls()[decl.src_index];
     switch (ast_node.tag) {
         .FnProto => {
-            const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", ast_node);
+            const fn_proto = ast_node.castTag(.FnProto).?;
             decl.analysis = .in_progress;
 @@ -1062,7 +1092,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                 .param_types = param_types,
             }, .{});
-            if (self.comp.verbose_ir) {
+            if (std.builtin.mode == .Debug and self.comp.verbose_ir) {
                 zir.dumpZir(self.gpa, "fn_type", decl.name, fn_type_scope.instructions.items) catch {};
             }
 @@ -1071,12 +1101,17 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             errdefer decl_arena.deinit();
             const decl_arena_state = try decl_arena.allocator.create(std.heap.ArenaAllocator.State);
+            var inst_table = Scope.Block.InstTable.init(self.gpa);
+            defer inst_table.deinit();
             var block_scope: Scope.Block = .{
                 .parent = null,
+                .inst_table = &inst_table,
                 .func = null,
                 .decl = decl,
                 .instructions = .{},
                 .arena = &decl_arena.allocator,
+                .inlining = null,
                 .is_comptime = false,
             };
             defer block_scope.instructions.deinit(self.gpa);
 @@ -1113,14 +1148,11 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             const new_func = try decl_arena.allocator.create(Fn);
             const fn_payload = try decl_arena.allocator.create(Value.Payload.Function);
-            const fn_zir = blk: {
+            const fn_zir: zir.Module.Body = blk: {
-                // This scope's arena memory is discarded after the ZIR generation
+                // We put the ZIR inside the Decl arena.
-                // 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 = &gen_scope_arena.allocator,
+                    .arena = &decl_arena.allocator,
                     .parent = decl.scope,
                 };
                 defer gen_scope.instructions.deinit(self.gpa);
 @@ -1131,8 +1163,8 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                 for (fn_proto.params()) |param, i| {
                     const name_token = param.name_token.?;
                     const src = tree.token_locs[name_token].start;
-                    const param_name = tree.tokenSlice(name_token); // TODO: call identifierTokenString
+                    const param_name = try self.identifierTokenString(&gen_scope.base, name_token);
-                    const arg = try gen_scope_arena.allocator.create(zir.Inst.Arg);
+                    const arg = try decl_arena.allocator.create(zir.Inst.Arg);
                     arg.* = .{
                         .base = .{
                             .tag = .arg,
 @@ -1144,7 +1176,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                         .kw_args = .{},
                     };
                     gen_scope.instructions.items[i] = &arg.base;
-                    const sub_scope = try gen_scope_arena.allocator.create(Scope.LocalVal);
+                    const sub_scope = try decl_arena.allocator.create(Scope.LocalVal);
                     sub_scope.* = .{
                         .parent = params_scope,
                         .gen_zir = &gen_scope,
 @@ -1165,22 +1197,29 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                     _ = try astgen.addZIRNoOp(self, &gen_scope.base, src, .returnvoid);
                 }
-                if (self.comp.verbose_ir) {
+                if (std.builtin.mode == .Debug and self.comp.verbose_ir) {
                     zir.dumpZir(self.gpa, "fn_body", decl.name, gen_scope.instructions.items) catch {};
                 }
-                const fn_zir = try gen_scope_arena.allocator.create(Fn.ZIR);
+                break :blk .{
-                fn_zir.* = .{
+                    .instructions = try gen_scope.arena.dupe(*zir.Inst, gen_scope.instructions.items),
-                    .body = .{
-                        .instructions = try gen_scope.arena.dupe(*zir.Inst, gen_scope.instructions.items),
-                    },
-                    .arena = gen_scope_arena.state,
                 };
-                break :blk fn_zir;
             };
+            const is_inline = blk: {
+                if (fn_proto.getExternExportInlineToken()) |maybe_inline_token| {
+                    if (tree.token_ids[maybe_inline_token] == .Keyword_inline) {
+                        break :blk true;
+                    }
+                }
+                break :blk false;
+            };
+            const anal_state = ([2]Fn.Analysis{ .queued, .inline_only })[@boolToInt(is_inline)];
             new_func.* = .{
-                .analysis = .{ .queued = fn_zir },
+                .state = anal_state,
+                .zir = fn_zir,
+                .body = undefined,
                 .owner_decl = decl,
             };
             fn_payload.* = .{
 @@ -1189,11 +1228,16 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             };
             var prev_type_has_bits = false;
+            var prev_is_inline = false;
             var type_changed = true;
             if (decl.typedValueManaged()) |tvm| {
                 prev_type_has_bits = tvm.typed_value.ty.hasCodeGenBits();
                 type_changed = !tvm.typed_value.ty.eql(fn_type);
+                if (tvm.typed_value.val.castTag(.function)) |payload| {
+                    const prev_func = payload.data;
+                    prev_is_inline = prev_func.state == .inline_only;
+                }
                 tvm.deinit(self.gpa);
             }
 @@ -1211,18 +1255,26 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             decl.analysis = .complete;
             decl.generation = self.generation;
-            if (fn_type.hasCodeGenBits()) {
+            if (!is_inline and fn_type.hasCodeGenBits()) {
                 // We don't fully codegen the decl until later, but we do need to reserve a global
                 // offset table index for it. This allows us to codegen decls out of dependency order,
                 // increasing how many computations can be done in parallel.
                 try self.comp.bin_file.allocateDeclIndexes(decl);
                 try self.comp.work_queue.writeItem(.{ .codegen_decl = decl });
-            } else if (prev_type_has_bits) {
+            } else if (!prev_is_inline and prev_type_has_bits) {
                 self.comp.bin_file.freeDecl(decl);
             }
             if (fn_proto.getExternExportInlineToken()) |maybe_export_token| {
                 if (tree.token_ids[maybe_export_token] == .Keyword_export) {
+                    if (is_inline) {
+                        return self.failTok(
+                            &block_scope.base,
+                            maybe_export_token,
+                            "export of inline function",
+                            .{},
+                        );
+                    }
                     const export_src = tree.token_locs[maybe_export_token].start;
                     const name_loc = tree.token_locs[fn_proto.getNameToken().?];
                     const name = tree.tokenSliceLoc(name_loc);
 @@ -1230,7 +1282,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                     try self.analyzeExport(&block_scope.base, export_src, name, decl);
                 }
             }
-            return type_changed;
+            return type_changed or is_inline != prev_is_inline;
         },
         .VarDecl => {
             const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", ast_node);
 @@ -1242,12 +1294,17 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             errdefer decl_arena.deinit();
             const decl_arena_state = try decl_arena.allocator.create(std.heap.ArenaAllocator.State);
+            var decl_inst_table = Scope.Block.InstTable.init(self.gpa);
+            defer decl_inst_table.deinit();
             var block_scope: Scope.Block = .{
                 .parent = null,
+                .inst_table = &decl_inst_table,
                 .func = null,
                 .decl = decl,
                 .instructions = .{},
                 .arena = &decl_arena.allocator,
+                .inlining = null,
                 .is_comptime = true,
             };
             defer block_scope.instructions.deinit(self.gpa);
 @@ -1303,23 +1360,30 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                 const src = tree.token_locs[init_node.firstToken()].start;
                 const init_inst = try astgen.expr(self, &gen_scope.base, init_result_loc, init_node);
-                if (self.comp.verbose_ir) {
+                if (std.builtin.mode == .Debug and self.comp.verbose_ir) {
                     zir.dumpZir(self.gpa, "var_init", decl.name, gen_scope.instructions.items) catch {};
                 }
+                var var_inst_table = Scope.Block.InstTable.init(self.gpa);
+                defer var_inst_table.deinit();
                 var inner_block: Scope.Block = .{
                     .parent = null,
+                    .inst_table = &var_inst_table,
                     .func = null,
                     .decl = decl,
                     .instructions = .{},
                     .arena = &gen_scope_arena.allocator,
+                    .inlining = null,
                     .is_comptime = true,
                 };
                 defer inner_block.instructions.deinit(self.gpa);
-                try zir_sema.analyzeBody(self, &inner_block.base, .{ .instructions = gen_scope.instructions.items });
+                try zir_sema.analyzeBody(self, &inner_block, .{
+                    .instructions = gen_scope.instructions.items,
+                });
                 // The result location guarantees the type coercion.
-                const analyzed_init_inst = init_inst.analyzed_inst.?;
+                const analyzed_init_inst = var_inst_table.get(init_inst).?;
                 // The is_comptime in the Scope.Block guarantees the result is comptime-known.
                 const val = analyzed_init_inst.value().?;
 @@ -1347,7 +1411,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                     .val = Value.initTag(.type_type),
                 });
                 const var_type = try astgen.expr(self, &type_scope.base, .{ .ty = type_type }, type_node);
-                if (self.comp.verbose_ir) {
+                if (std.builtin.mode == .Debug and self.comp.verbose_ir) {
                     zir.dumpZir(self.gpa, "var_type", decl.name, type_scope.instructions.items) catch {};
                 }
 @@ -1423,21 +1487,26 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             defer gen_scope.instructions.deinit(self.gpa);
             _ = try astgen.comptimeExpr(self, &gen_scope.base, .none, comptime_decl.expr);
-            if (self.comp.verbose_ir) {
+            if (std.builtin.mode == .Debug and self.comp.verbose_ir) {
                 zir.dumpZir(self.gpa, "comptime_block", decl.name, gen_scope.instructions.items) catch {};
             }
+            var inst_table = Scope.Block.InstTable.init(self.gpa);
+            defer inst_table.deinit();
             var block_scope: Scope.Block = .{
                 .parent = null,
+                .inst_table = &inst_table,
                 .func = null,
                 .decl = decl,
                 .instructions = .{},
                 .arena = &analysis_arena.allocator,
+                .inlining = null,
                 .is_comptime = true,
             };
             defer block_scope.instructions.deinit(self.gpa);
-            _ = try zir_sema.analyzeBody(self, &block_scope.base, .{
+            _ = try zir_sema.analyzeBody(self, &block_scope, .{
                 .instructions = gen_scope.instructions.items,
             });
 @@ -1496,12 +1565,10 @@ fn getSrcModule(self: *Module, root_scope: *Scope.ZIRModule) !*zir.Module {
     }
 }
-fn getAstTree(self: *Module, container_scope: *Scope.Container) !*ast.Tree {
+pub fn getAstTree(self: *Module, root_scope: *Scope.File) !*ast.Tree {
     const tracy = trace(@src());
     defer tracy.end();
-    const root_scope = container_scope.file_scope;
     switch (root_scope.status) {
         .never_loaded, .unloaded_success => {
             try self.failed_files.ensureCapacity(self.gpa, self.failed_files.items().len + 1);
 @@ -1549,7 +1616,7 @@ pub fn analyzeContainer(self: *Module, container_scope: *Scope.Container) !void
     // We may be analyzing it for the first time, or this may be
     // an incremental update. This code handles both cases.
-    const tree = try self.getAstTree(container_scope);
+    const tree = try self.getAstTree(container_scope.file_scope);
     const decls = tree.root_node.decls();
     try self.comp.work_queue.ensureUnusedCapacity(decls.len);
 @@ -1806,25 +1873,28 @@ pub fn analyzeFnBody(self: *Module, decl: *Decl, func: *Fn) !void {
     // Use the Decl's arena for function memory.
     var arena = decl.typed_value.most_recent.arena.?.promote(self.gpa);
     defer decl.typed_value.most_recent.arena.?.* = arena.state;
+    var inst_table = Scope.Block.InstTable.init(self.gpa);
+    defer inst_table.deinit();
     var inner_block: Scope.Block = .{
         .parent = null,
+        .inst_table = &inst_table,
         .func = func,
         .decl = decl,
         .instructions = .{},
         .arena = &arena.allocator,
+        .inlining = null,
         .is_comptime = false,
     };
     defer inner_block.instructions.deinit(self.gpa);
-    const fn_zir = func.analysis.queued;
+    func.state = .in_progress;
-    defer fn_zir.arena.promote(self.gpa).deinit();
-    func.analysis = .{ .in_progress = {} };
     log.debug("set {s} to in_progress\n", .{decl.name});
-    try zir_sema.analyzeBody(self, &inner_block.base, fn_zir.body);
+    try zir_sema.analyzeBody(self, &inner_block, func.zir);
     const instructions = try arena.allocator.dupe(*Inst, inner_block.instructions.items);
-    func.analysis = .{ .success = .{ .instructions = instructions } };
+    func.state = .success;
+    func.body = .{ .instructions = instructions };
     log.debug("set {s} to success\n", .{decl.name});
 }
 @@ -2321,7 +2391,7 @@ pub fn analyzeDeclRef(self: *Module, scope: *Scope, src: usize, decl: *Decl) Inn
     self.ensureDeclAnalyzed(decl) catch |err| {
         if (scope.cast(Scope.Block)) |block| {
             if (block.func) |func| {
-                func.analysis = .dependency_failure;
+                func.state = .dependency_failure;
             } else {
                 block.decl.analysis = .dependency_failure;
             }
 @@ -3020,11 +3090,20 @@ fn failWithOwnedErrorMsg(self: *Module, scope: *Scope, src: usize, err_msg: *Com
         },
         .block => {
             const block = scope.cast(Scope.Block).?;
-            if (block.func) |func| {
+            if (block.inlining) |inlining| {
-                func.analysis = .sema_failure;
+                if (inlining.shared.caller) |func| {
+                    func.state = .sema_failure;
+                } else {
+                    block.decl.analysis = .sema_failure;
+                    block.decl.generation = self.generation;
+                }
             } else {
-                block.decl.analysis = .sema_failure;
+                if (block.func) |func| {
-                block.decl.generation = self.generation;
+                    func.state = .sema_failure;
+                } else {
+                    block.decl.analysis = .sema_failure;
+                    block.decl.generation = self.generation;
+                }
             }
             self.failed_decls.putAssumeCapacityNoClobber(block.decl, err_msg);
         },
 @@ -3380,10 +3459,12 @@ pub fn addSafetyCheck(mod: *Module, parent_block: *Scope.Block, ok: *Inst, panic
     var fail_block: Scope.Block = .{
         .parent = parent_block,
+        .inst_table = parent_block.inst_table,
         .func = parent_block.func,
         .decl = parent_block.decl,
         .instructions = .{},
         .arena = parent_block.arena,
+        .inlining = parent_block.inlining,
         .is_comptime = parent_block.is_comptime,
     };
     defer fail_block.instructions.deinit(mod.gpa);
 @@ -3427,3 +3508,34 @@ pub fn validateVarType(mod: *Module, scope: *Scope, src: usize, ty: Type) !void
         return mod.fail(scope, src, "variable of type '{}' must be const or comptime", .{ty});
     }
 }
+/// Identifier token -> String (allocated in scope.arena())
+pub fn identifierTokenString(mod: *Module, scope: *Scope, token: ast.TokenIndex) InnerError![]const u8 {
+    const tree = scope.tree();
+    const ident_name = tree.tokenSlice(token);
+    if (mem.startsWith(u8, ident_name, "@")) {
+        const raw_string = ident_name[1..];
+        var bad_index: usize = undefined;
+        return std.zig.parseStringLiteral(scope.arena(), raw_string, &bad_index) catch |err| switch (err) {
+            error.InvalidCharacter => {
+                const bad_byte = raw_string[bad_index];
+                const src = tree.token_locs[token].start;
+                return mod.fail(scope, src + 1 + bad_index, "invalid string literal character: '{c}'\n", .{bad_byte});
+            },
+            else => |e| return e,
+        };
+    }
+    return ident_name;
+}
+pub fn emitBackwardBranch(mod: *Module, block: *Scope.Block, src: usize) !void {
+    const shared = block.inlining.?.shared;
+    shared.branch_count += 1;
+    if (shared.branch_count > shared.branch_quota) {
+        // TODO show the "called from here" stack
+        return mod.fail(&block.base, src, "evaluation exceeded {d} backwards branches", .{
+            shared.branch_quota,
+        });
+    }
+}

src/astgen.zig+9-29

 @@ -384,7 +384,7 @@ fn breakExpr(mod: *Module, parent_scope: *Scope, node: *ast.Node.ControlFlowExpr
             .local_val => scope = scope.cast(Scope.LocalVal).?.parent,
             .local_ptr => scope = scope.cast(Scope.LocalPtr).?.parent,
             else => if (node.getLabel()) |break_label| {
-                const label_name = try identifierTokenString(mod, parent_scope, break_label);
+                const label_name = try mod.identifierTokenString(parent_scope, break_label);
                 return mod.failTok(parent_scope, break_label, "label not found: '{s}'", .{label_name});
             } else {
                 return mod.failTok(parent_scope, src, "break expression outside loop", .{});
 @@ -426,7 +426,7 @@ fn continueExpr(mod: *Module, parent_scope: *Scope, node: *ast.Node.ControlFlowE
             .local_val => scope = scope.cast(Scope.LocalVal).?.parent,
             .local_ptr => scope = scope.cast(Scope.LocalPtr).?.parent,
             else => if (node.getLabel()) |break_label| {
-                const label_name = try identifierTokenString(mod, parent_scope, break_label);
+                const label_name = try mod.identifierTokenString(parent_scope, break_label);
                 return mod.failTok(parent_scope, break_label, "label not found: '{s}'", .{label_name});
             } else {
                 return mod.failTok(parent_scope, src, "continue expression outside loop", .{});
 @@ -551,7 +551,7 @@ fn varDecl(
     }
     const tree = scope.tree();
     const name_src = tree.token_locs[node.name_token].start;
-    const ident_name = try identifierTokenString(mod, scope, node.name_token);
+    const ident_name = try mod.identifierTokenString(scope, node.name_token);
     // Local variables shadowing detection, including function parameters.
     {
 @@ -843,7 +843,7 @@ fn typeInixOp(mod: *Module, scope: *Scope, node: *ast.Node.SimpleInfixOp, op_ins
 fn enumLiteral(mod: *Module, scope: *Scope, node: *ast.Node.EnumLiteral) !*zir.Inst {
     const tree = scope.tree();
     const src = tree.token_locs[node.name].start;
-    const name = try identifierTokenString(mod, scope, node.name);
+    const name = try mod.identifierTokenString(scope, node.name);
     return addZIRInst(mod, scope, src, zir.Inst.EnumLiteral, .{ .name = name }, .{});
 }
 @@ -864,7 +864,7 @@ fn errorSetDecl(mod: *Module, scope: *Scope, rl: ResultLoc, node: *ast.Node.Erro
     for (decls) |decl, i| {
         const tag = decl.castTag(.ErrorTag).?;
-        fields[i] = try identifierTokenString(mod, scope, tag.name_token);
+        fields[i] = try mod.identifierTokenString(scope, tag.name_token);
     }
     // analyzing the error set results in a decl ref, so we might need to dereference it
 @@ -988,36 +988,16 @@ fn orelseCatchExpr(
 /// Return whether the identifier names of two tokens are equal. Resolves @"" tokens without allocating.
 /// OK in theory it could do it without allocating. This implementation allocates when the @"" form is used.
 fn tokenIdentEql(mod: *Module, scope: *Scope, token1: ast.TokenIndex, token2: ast.TokenIndex) !bool {
-    const ident_name_1 = try identifierTokenString(mod, scope, token1);
+    const ident_name_1 = try mod.identifierTokenString(scope, token1);
-    const ident_name_2 = try identifierTokenString(mod, scope, token2);
+    const ident_name_2 = try mod.identifierTokenString(scope, token2);
     return mem.eql(u8, ident_name_1, ident_name_2);
 }
-/// Identifier token -> String (allocated in scope.arena())
-fn identifierTokenString(mod: *Module, scope: *Scope, token: ast.TokenIndex) InnerError![]const u8 {
-    const tree = scope.tree();
-    const ident_name = tree.tokenSlice(token);
-    if (mem.startsWith(u8, ident_name, "@")) {
-        const raw_string = ident_name[1..];
-        var bad_index: usize = undefined;
-        return std.zig.parseStringLiteral(scope.arena(), raw_string, &bad_index) catch |err| switch (err) {
-            error.InvalidCharacter => {
-                const bad_byte = raw_string[bad_index];
-                const src = tree.token_locs[token].start;
-                return mod.fail(scope, src + 1 + bad_index, "invalid string literal character: '{c}'\n", .{bad_byte});
-            },
-            else => |e| return e,
-        };
-    }
-    return ident_name;
-}
 pub fn identifierStringInst(mod: *Module, scope: *Scope, node: *ast.Node.OneToken) InnerError!*zir.Inst {
     const tree = scope.tree();
     const src = tree.token_locs[node.token].start;
-    const ident_name = try identifierTokenString(mod, scope, node.token);
+    const ident_name = try mod.identifierTokenString(scope, node.token);
     return addZIRInst(mod, scope, src, zir.Inst.Str, .{ .bytes = ident_name }, .{});
 }
 @@ -1936,7 +1916,7 @@ fn identifier(mod: *Module, scope: *Scope, rl: ResultLoc, ident: *ast.Node.OneTo
     defer tracy.end();
     const tree = scope.tree();
-    const ident_name = try identifierTokenString(mod, scope, ident.token);
+    const ident_name = try mod.identifierTokenString(scope, ident.token);
     const src = tree.token_locs[ident.token].start;
     if (mem.eql(u8, ident_name, "_")) {
         return mod.failNode(scope, &ident.base, "TODO implement '_' identifier", .{});

src/codegen.zig+5-5

...	@@ -532,7 +532,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {	...	@@ -532,7 +532,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
532	self.code.items.len += 4;	532	self.code.items.len += 4;
533		533
534	try self.dbgSetPrologueEnd();	534	try self.dbgSetPrologueEnd();
535	try self.genBody(self.mod_fn.analysis.success);	535	try self.genBody(self.mod_fn.body);
536		536
537	const stack_end = self.max_end_stack;	537	const stack_end = self.max_end_stack;
538	if (stack_end > math.maxInt(i32))	538	if (stack_end > math.maxInt(i32))
...	@@ -576,7 +576,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {	...	@@ -576,7 +576,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
576	});	576	});
577	} else {	577	} else {
578	try self.dbgSetPrologueEnd();	578	try self.dbgSetPrologueEnd();
579	try self.genBody(self.mod_fn.analysis.success);	579	try self.genBody(self.mod_fn.body);
580	try self.dbgSetEpilogueBegin();	580	try self.dbgSetEpilogueBegin();
581	}	581	}
582	},	582	},
...	@@ -593,7 +593,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {	...	@@ -593,7 +593,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
593		593
594	try self.dbgSetPrologueEnd();	594	try self.dbgSetPrologueEnd();
595		595
596	try self.genBody(self.mod_fn.analysis.success);	596	try self.genBody(self.mod_fn.body);
597		597
598	// Backpatch stack offset	598	// Backpatch stack offset
599	const stack_end = self.max_end_stack;	599	const stack_end = self.max_end_stack;
...	@@ -638,13 +638,13 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {	...	@@ -638,13 +638,13 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
638	writeInt(u32, try self.code.addManyAsArray(4), Instruction.pop(.al, .{ .fp, .pc }).toU32());	638	writeInt(u32, try self.code.addManyAsArray(4), Instruction.pop(.al, .{ .fp, .pc }).toU32());
639	} else {	639	} else {
640	try self.dbgSetPrologueEnd();	640	try self.dbgSetPrologueEnd();
641	try self.genBody(self.mod_fn.analysis.success);	641	try self.genBody(self.mod_fn.body);
642	try self.dbgSetEpilogueBegin();	642	try self.dbgSetEpilogueBegin();
643	}	643	}
644	},	644	},
645	else => {	645	else => {
646	try self.dbgSetPrologueEnd();	646	try self.dbgSetPrologueEnd();
647	try self.genBody(self.mod_fn.analysis.success);	647	try self.genBody(self.mod_fn.body);
648	try self.dbgSetEpilogueBegin();	648	try self.dbgSetEpilogueBegin();
649	},	649	},
650	}	650	}

src/codegen/c.zig+1-1

...	@@ -275,7 +275,7 @@ pub fn generate(file: C, module: Module, decl: *Decl) !void {	...	@@ -275,7 +275,7 @@ pub fn generate(file: C, module: Module, decl: *Decl) !void {
275	try writer.writeAll(" {");	275	try writer.writeAll(" {");
276		276
277	const func: *Module.Fn = func_payload.data;	277	const func: *Module.Fn = func_payload.data;
278	const instructions = func.analysis.success.instructions;	278	const instructions = func.body.instructions;
279	if (instructions.len > 0) {	279	if (instructions.len > 0) {
280	try writer.writeAll("\n");	280	try writer.writeAll("\n");
281	for (instructions) \|inst\| {	281	for (instructions) \|inst\| {

src/codegen/wasm.zig+1-1

...	@@ -63,7 +63,7 @@ pub fn genCode(buf: ArrayList(u8), decl: Decl) !void {	...	@@ -63,7 +63,7 @@ pub fn genCode(buf: ArrayList(u8), decl: Decl) !void {
63	// TODO: check for and handle death of instructions	63	// TODO: check for and handle death of instructions
64	const tv = decl.typed_value.most_recent.typed_value;	64	const tv = decl.typed_value.most_recent.typed_value;
65	const mod_fn = tv.val.castTag(.function).?.data;	65	const mod_fn = tv.val.castTag(.function).?.data;
66	for (mod_fn.analysis.success.instructions) \|inst\| try genInst(buf, decl, inst);	66	for (mod_fn.body.instructions) \|inst\| try genInst(buf, decl, inst);
67		67
68	// Write 'end' opcode	68	// Write 'end' opcode
69	try writer.writeByte(0x0B);	69	try writer.writeByte(0x0B);

src/config.zig.in-1

...	@@ -2,7 +2,6 @@ pub const have_llvm = true;	...	@@ -2,7 +2,6 @@ pub const have_llvm = true;
2	pub const version: [:0]const u8 = "@ZIG_VERSION@";	2	pub const version: [:0]const u8 = "@ZIG_VERSION@";
3	pub const semver = try @import("std").SemanticVersion.parse(version);	3	pub const semver = try @import("std").SemanticVersion.parse(version);
4	pub const log_scopes: []const []const u8 = &[_][]const u8{};	4	pub const log_scopes: []const []const u8 = &[_][]const u8{};
5	pub const zir_dumps: []const []const u8 = &[_][]const u8{};
6	pub const enable_tracy = false;	5	pub const enable_tracy = false;
7	pub const is_stage1 = true;	6	pub const is_stage1 = true;
8	pub const skip_non_native = false;	7	pub const skip_non_native = false;

src/link/Elf.zig-10

...	@@ -2178,16 +2178,6 @@ pub fn updateDecl(self: Elf, module: Module, decl: *Module.Decl) !void {	...	@@ -2178,16 +2178,6 @@ pub fn updateDecl(self: Elf, module: Module, decl: *Module.Decl) !void {
2178	else => false,	2178	else => false,
2179	};	2179	};
2180	if (is_fn) {	2180	if (is_fn) {
2181	const zir_dumps = if (std.builtin.is_test) &[0][]const u8{} else build_options.zir_dumps;
2182	if (zir_dumps.len != 0) {
2183	for (zir_dumps) \|fn_name\| {
2184	if (mem.eql(u8, mem.spanZ(decl.name), fn_name)) {
2185	std.debug.print("\n{s}\n", .{decl.name});
2186	typed_value.val.castTag(.function).?.data.dump(module.*);
2187	}
2188	}
2189	}
2190
2191	// For functions we need to add a prologue to the debug line program.	2181	// For functions we need to add a prologue to the debug line program.
2192	try dbg_line_buffer.ensureCapacity(26);	2182	try dbg_line_buffer.ensureCapacity(26);
2193		2183

src/link/MachO/DebugSymbols.zig-10

...	@@ -936,16 +936,6 @@ pub fn initDeclDebugBuffers(	...	@@ -936,16 +936,6 @@ pub fn initDeclDebugBuffers(
936	const typed_value = decl.typed_value.most_recent.typed_value;	936	const typed_value = decl.typed_value.most_recent.typed_value;
937	switch (typed_value.ty.zigTypeTag()) {	937	switch (typed_value.ty.zigTypeTag()) {
938	.Fn => {	938	.Fn => {
939	const zir_dumps = if (std.builtin.is_test) &[0][]const u8{} else build_options.zir_dumps;
940	if (zir_dumps.len != 0) {
941	for (zir_dumps) \|fn_name\| {
942	if (mem.eql(u8, mem.spanZ(decl.name), fn_name)) {
943	std.debug.print("\n{}\n", .{decl.name});
944	typed_value.val.cast(Value.Payload.Function).?.func.dump(module.*);
945	}
946	}
947	}
948
949	// For functions we need to add a prologue to the debug line program.	939	// For functions we need to add a prologue to the debug line program.
950	try dbg_line_buffer.ensureCapacity(26);	940	try dbg_line_buffer.ensureCapacity(26);
951		941

src/llvm_backend.zig+1-1

...	@@ -294,7 +294,7 @@ pub const LLVMIRModule = struct {	...	@@ -294,7 +294,7 @@ pub const LLVMIRModule = struct {
294	const entry_block = llvm_func.appendBasicBlock("Entry");	294	const entry_block = llvm_func.appendBasicBlock("Entry");
295	self.builder.positionBuilderAtEnd(entry_block);	295	self.builder.positionBuilderAtEnd(entry_block);
296		296
297	const instructions = func.analysis.success.instructions;	297	const instructions = func.body.instructions;
298	for (instructions) \|inst\| {	298	for (instructions) \|inst\| {
299	switch (inst.tag) {	299	switch (inst.tag) {
300	.breakpoint => try self.genBreakpoint(inst.castTag(.breakpoint).?),	300	.breakpoint => try self.genBreakpoint(inst.castTag(.breakpoint).?),

src/main.zig+1-1

...	@@ -1818,7 +1818,7 @@ fn buildOutputType(	...	@@ -1818,7 +1818,7 @@ fn buildOutputType(
1818	};	1818	};
1819		1819
1820	updateModule(gpa, comp, zir_out_path, hook) catch \|err\| switch (err) {	1820	updateModule(gpa, comp, zir_out_path, hook) catch \|err\| switch (err) {
1821	error.SemanticAnalyzeFail => process.exit(1),	1821	error.SemanticAnalyzeFail => if (!watch) process.exit(1),
1822	else => \|e\| return e,	1822	else => \|e\| return e,
1823	};	1823	};
1824	try comp.makeBinFileExecutable();	1824	try comp.makeBinFileExecutable();

src/value.zig+8-5

 @@ -330,11 +330,14 @@ pub const Value = extern union {
             .int_type => return self.copyPayloadShallow(allocator, Payload.IntType),
             .int_u64 => return self.copyPayloadShallow(allocator, Payload.U64),
             .int_i64 => return self.copyPayloadShallow(allocator, Payload.I64),
-            .int_big_positive => {
+            .int_big_positive, .int_big_negative => {
-                @panic("TODO implement copying of big ints");
+                const old_payload = self.cast(Payload.BigInt).?;
-            },
+                const new_payload = try allocator.create(Payload.BigInt);
-            .int_big_negative => {
+                new_payload.* = .{
-                @panic("TODO implement copying of big ints");
+                    .base = .{ .tag = self.ptr_otherwise.tag },
+                    .data = try allocator.dupe(std.math.big.Limb, old_payload.data),
+                };
+                return Value{ .ptr_otherwise = &new_payload.base };
             },
             .function => return self.copyPayloadShallow(allocator, Payload.Function),
             .extern_fn => return self.copyPayloadShallow(allocator, Payload.Decl),

src/zir.zig+324-37

...	@@ -25,12 +25,13 @@ pub const Decl = struct {	...	@@ -25,12 +25,13 @@ pub const Decl = struct {
25		25
26	/// These are instructions that correspond to the ZIR text format. See `ir.Inst` for	26	/// These are instructions that correspond to the ZIR text format. See `ir.Inst` for
27	/// in-memory, analyzed instructions with types and values.	27	/// in-memory, analyzed instructions with types and values.
		28	/// We use a table to map these instruction to their respective semantically analyzed
		29	/// instructions because it is possible to have multiple analyses on the same ZIR
		30	/// happening at the same time.
28	pub const Inst = struct {	31	pub const Inst = struct {
29	tag: Tag,	32	tag: Tag,
30	/// Byte offset into the source.	33	/// Byte offset into the source.
31	src: usize,	34	src: usize,
32	/// Pre-allocated field for mapping ZIR text instructions to post-analysis instructions.
33	analyzed_inst: ?*ir.Inst = null,
34		35
35	/// These names are used directly as the instruction names in the text format.	36	/// These names are used directly as the instruction names in the text format.
36	pub const Tag = enum {	37	pub const Tag = enum {
...	@@ -793,7 +794,9 @@ pub const Inst = struct {	...	@@ -793,7 +794,9 @@ pub const Inst = struct {
793	fn_type: *Inst,	794	fn_type: *Inst,
794	body: Module.Body,	795	body: Module.Body,
795	},	796	},
796	kw_args: struct {},	797	kw_args: struct {
		798	is_inline: bool = false,
		799	},
797	};	800	};
798		801
799	pub const FnType = struct {	802	pub const FnType = struct {
...	@@ -1847,44 +1850,325 @@ pub fn emit(allocator: Allocator, old_module: IrModule) !Module {	...	@@ -1847,44 +1850,325 @@ pub fn emit(allocator: Allocator, old_module: IrModule) !Module {
1847	/// For debugging purposes, prints a function representation to stderr.	1850	/// For debugging purposes, prints a function representation to stderr.
1848	pub fn dumpFn(old_module: IrModule, module_fn: *IrModule.Fn) void {	1851	pub fn dumpFn(old_module: IrModule, module_fn: *IrModule.Fn) void {
1849	const allocator = old_module.gpa;	1852	const allocator = old_module.gpa;
1850	var ctx: EmitZIR = .{	1853	var ctx: DumpTzir = .{
1851	.allocator = allocator,	1854	.allocator = allocator,
1852	.decls = .{},
1853	.arena = std.heap.ArenaAllocator.init(allocator),	1855	.arena = std.heap.ArenaAllocator.init(allocator),
1854	.old_module = &old_module,	1856	.old_module = &old_module,
1855	.next_auto_name = 0,	1857	.module_fn = module_fn,
1856	.names = std.StringArrayHashMap(void).init(allocator),	1858	.indent = 2,
1857	.primitive_table = std.AutoHashMap(Inst.Primitive.Builtin, *Decl).init(allocator),	1859	.inst_table = DumpTzir.InstTable.init(allocator),
1858	.indent = 0,	1860	.partial_inst_table = DumpTzir.InstTable.init(allocator),
1859	.block_table = std.AutoHashMap(ir.Inst.Block, Inst.Block).init(allocator),	1861	.const_table = DumpTzir.InstTable.init(allocator),
1860	.loop_table = std.AutoHashMap(ir.Inst.Loop, Inst.Loop).init(allocator),
1861	.metadata = std.AutoHashMap(*Inst, Module.MetaData).init(allocator),
1862	.body_metadata = std.AutoHashMap(*Module.Body, Module.BodyMetaData).init(allocator),
1863	};	1862	};
1864	defer ctx.metadata.deinit();	1863	defer ctx.inst_table.deinit();
1865	defer ctx.body_metadata.deinit();	1864	defer ctx.partial_inst_table.deinit();
1866	defer ctx.block_table.deinit();	1865	defer ctx.const_table.deinit();
1867	defer ctx.loop_table.deinit();
1868	defer ctx.decls.deinit(allocator);
1869	defer ctx.names.deinit();
1870	defer ctx.primitive_table.deinit();
1871	defer ctx.arena.deinit();	1866	defer ctx.arena.deinit();
1872		1867
1873	const fn_ty = module_fn.owner_decl.typed_value.most_recent.typed_value.ty;	1868	switch (module_fn.state) {
1874	_ = ctx.emitFn(module_fn, 0, fn_ty) catch \|err\| {	1869	.queued => std.debug.print("(queued)", .{}),
1875	std.debug.print("unable to dump function: {s}\n", .{@errorName(err)});	1870	.inline_only => std.debug.print("(inline_only)", .{}),
1876	return;	1871	.in_progress => std.debug.print("(in_progress)", .{}),
1877	};	1872	.sema_failure => std.debug.print("(sema_failure)", .{}),
1878	var module = Module{	1873	.dependency_failure => std.debug.print("(dependency_failure)", .{}),
1879	.decls = ctx.decls.items,	1874	.success => {
1880	.arena = ctx.arena,	1875	const writer = std.io.getStdErr().writer();
1881	.metadata = ctx.metadata,	1876	ctx.dump(module_fn.body, writer) catch @panic("failed to dump TZIR");
1882	.body_metadata = ctx.body_metadata,	1877	},
1883	};	1878	}
1884
1885	module.dump();
1886	}	1879	}
1887		1880
		1881	const DumpTzir = struct {
		1882	allocator: *Allocator,
		1883	arena: std.heap.ArenaAllocator,
		1884	old_module: *const IrModule,
		1885	module_fn: *IrModule.Fn,
		1886	indent: usize,
		1887	inst_table: InstTable,
		1888	partial_inst_table: InstTable,
		1889	const_table: InstTable,
		1890	next_index: usize = 0,
		1891	next_partial_index: usize = 0,
		1892	next_const_index: usize = 0,
		1893
		1894	const InstTable = std.AutoArrayHashMap(*ir.Inst, usize);
		1895
		1896	fn dump(dtz: *DumpTzir, body: ir.Body, writer: std.fs.File.Writer) !void {
		1897	// First pass to pre-populate the table so that we can show even invalid references.
		1898	// Must iterate the same order we iterate the second time.
		1899	// We also look for constants and put them in the const_table.
		1900	for (body.instructions) \|inst\| {
		1901	try dtz.inst_table.put(inst, dtz.next_index);
		1902	dtz.next_index += 1;
		1903	switch (inst.tag) {
		1904	.alloc,
		1905	.retvoid,
		1906	.unreach,
		1907	.breakpoint,
		1908	.dbg_stmt,
		1909	=> {},
		1910
		1911	.ref,
		1912	.ret,
		1913	.bitcast,
		1914	.not,
		1915	.isnonnull,
		1916	.isnull,
		1917	.iserr,
		1918	.ptrtoint,
		1919	.floatcast,
		1920	.intcast,
		1921	.load,
		1922	.unwrap_optional,
		1923	.wrap_optional,
		1924	=> {
		1925	const un_op = inst.cast(ir.Inst.UnOp).?;
		1926	try dtz.findConst(un_op.operand);
		1927	},
		1928
		1929	.add,
		1930	.sub,
		1931	.cmp_lt,
		1932	.cmp_lte,
		1933	.cmp_eq,
		1934	.cmp_gte,
		1935	.cmp_gt,
		1936	.cmp_neq,
		1937	.store,
		1938	.booland,
		1939	.boolor,
		1940	.bitand,
		1941	.bitor,
		1942	.xor,
		1943	=> {
		1944	const bin_op = inst.cast(ir.Inst.BinOp).?;
		1945	try dtz.findConst(bin_op.lhs);
		1946	try dtz.findConst(bin_op.rhs);
		1947	},
		1948
		1949	.arg => {},
		1950
		1951	.br => {
		1952	const br = inst.castTag(.br).?;
		1953	try dtz.findConst(&br.block.base);
		1954	try dtz.findConst(br.operand);
		1955	},
		1956
		1957	.brvoid => {
		1958	const brvoid = inst.castTag(.brvoid).?;
		1959	try dtz.findConst(&brvoid.block.base);
		1960	},
		1961
		1962	// TODO fill out this debug printing
		1963	.assembly,
		1964	.block,
		1965	.call,
		1966	.condbr,
		1967	.constant,
		1968	.loop,
		1969	.varptr,
		1970	.switchbr,
		1971	=> {},
		1972	}
		1973	}
		1974
		1975	std.debug.print("Module.Function(name={s}):\n", .{dtz.module_fn.owner_decl.name});
		1976
		1977	for (dtz.const_table.items()) \|entry\| {
		1978	const constant = entry.key.castTag(.constant).?;
		1979	try writer.print(" @{d}: {} = {};\n", .{
		1980	entry.value, constant.base.ty, constant.val,
		1981	});
		1982	}
		1983
		1984	return dtz.dumpBody(body, writer);
		1985	}
		1986
		1987	fn dumpBody(dtz: *DumpTzir, body: ir.Body, writer: std.fs.File.Writer) !void {
		1988	for (body.instructions) \|inst\| {
		1989	const my_index = dtz.next_partial_index;
		1990	try dtz.partial_inst_table.put(inst, my_index);
		1991	dtz.next_partial_index += 1;
		1992
		1993	try writer.writeByteNTimes(' ', dtz.indent);
		1994	try writer.print("%{d}: {} = {s}(", .{
		1995	my_index, inst.ty, @tagName(inst.tag),
		1996	});
		1997	switch (inst.tag) {
		1998	.alloc,
		1999	.retvoid,
		2000	.unreach,
		2001	.breakpoint,
		2002	.dbg_stmt,
		2003	=> try writer.writeAll(")\n"),
		2004
		2005	.ref,
		2006	.ret,
		2007	.bitcast,
		2008	.not,
		2009	.isnonnull,
		2010	.isnull,
		2011	.iserr,
		2012	.ptrtoint,
		2013	.floatcast,
		2014	.intcast,
		2015	.load,
		2016	.unwrap_optional,
		2017	.wrap_optional,
		2018	=> {
		2019	const un_op = inst.cast(ir.Inst.UnOp).?;
		2020	if (dtz.partial_inst_table.get(un_op.operand)) \|operand_index\| {
		2021	try writer.print("%{d})\n", .{operand_index});
		2022	} else if (dtz.const_table.get(un_op.operand)) \|operand_index\| {
		2023	try writer.print("@{d})\n", .{operand_index});
		2024	} else if (dtz.inst_table.get(un_op.operand)) \|operand_index\| {
		2025	try writer.print("%{d}) // Instruction does not dominate all uses!\n", .{
		2026	operand_index,
		2027	});
		2028	} else {
		2029	try writer.writeAll("!BADREF!)\n");
		2030	}
		2031	},
		2032
		2033	.add,
		2034	.sub,
		2035	.cmp_lt,
		2036	.cmp_lte,
		2037	.cmp_eq,
		2038	.cmp_gte,
		2039	.cmp_gt,
		2040	.cmp_neq,
		2041	.store,
		2042	.booland,
		2043	.boolor,
		2044	.bitand,
		2045	.bitor,
		2046	.xor,
		2047	=> {
		2048	var lhs_kinky: ?usize = null;
		2049	var rhs_kinky: ?usize = null;
		2050
		2051	const bin_op = inst.cast(ir.Inst.BinOp).?;
		2052	if (dtz.partial_inst_table.get(bin_op.lhs)) \|operand_index\| {
		2053	try writer.print("%{d}, ", .{operand_index});
		2054	} else if (dtz.const_table.get(bin_op.lhs)) \|operand_index\| {
		2055	try writer.print("@{d}, ", .{operand_index});
		2056	} else if (dtz.inst_table.get(bin_op.lhs)) \|operand_index\| {
		2057	lhs_kinky = operand_index;
		2058	try writer.print("%{d}, ", .{operand_index});
		2059	} else {
		2060	try writer.writeAll("!BADREF!, ");
		2061	}
		2062	if (dtz.partial_inst_table.get(bin_op.rhs)) \|operand_index\| {
		2063	try writer.print("%{d}", .{operand_index});
		2064	} else if (dtz.const_table.get(bin_op.rhs)) \|operand_index\| {
		2065	try writer.print("@{d}", .{operand_index});
		2066	} else if (dtz.inst_table.get(bin_op.rhs)) \|operand_index\| {
		2067	rhs_kinky = operand_index;
		2068	try writer.print("%{d}", .{operand_index});
		2069	} else {
		2070	try writer.writeAll("!BADREF!");
		2071	}
		2072	if (lhs_kinky != null or rhs_kinky != null) {
		2073	try writer.writeAll(") // Instruction does not dominate all uses!");
		2074	if (lhs_kinky) \|lhs\| {
		2075	try writer.print(" %{d}", .{lhs});
		2076	}
		2077	if (rhs_kinky) \|rhs\| {
		2078	try writer.print(" %{d}", .{rhs});
		2079	}
		2080	try writer.writeAll("\n");
		2081	} else {
		2082	try writer.writeAll(")\n");
		2083	}
		2084	},
		2085
		2086	.arg => {
		2087	const arg = inst.castTag(.arg).?;
		2088	try writer.print("{s})\n", .{arg.name});
		2089	},
		2090
		2091	.br => {
		2092	const br = inst.castTag(.br).?;
		2093
		2094	var lhs_kinky: ?usize = null;
		2095	var rhs_kinky: ?usize = null;
		2096
		2097	if (dtz.partial_inst_table.get(&br.block.base)) \|operand_index\| {
		2098	try writer.print("%{d}, ", .{operand_index});
		2099	} else if (dtz.const_table.get(&br.block.base)) \|operand_index\| {
		2100	try writer.print("@{d}, ", .{operand_index});
		2101	} else if (dtz.inst_table.get(&br.block.base)) \|operand_index\| {
		2102	lhs_kinky = operand_index;
		2103	try writer.print("%{d}, ", .{operand_index});
		2104	} else {
		2105	try writer.writeAll("!BADREF!, ");
		2106	}
		2107
		2108	if (dtz.partial_inst_table.get(br.operand)) \|operand_index\| {
		2109	try writer.print("%{d}", .{operand_index});
		2110	} else if (dtz.const_table.get(br.operand)) \|operand_index\| {
		2111	try writer.print("@{d}", .{operand_index});
		2112	} else if (dtz.inst_table.get(br.operand)) \|operand_index\| {
		2113	rhs_kinky = operand_index;
		2114	try writer.print("%{d}", .{operand_index});
		2115	} else {
		2116	try writer.writeAll("!BADREF!");
		2117	}
		2118
		2119	if (lhs_kinky != null or rhs_kinky != null) {
		2120	try writer.writeAll(") // Instruction does not dominate all uses!");
		2121	if (lhs_kinky) \|lhs\| {
		2122	try writer.print(" %{d}", .{lhs});
		2123	}
		2124	if (rhs_kinky) \|rhs\| {
		2125	try writer.print(" %{d}", .{rhs});
		2126	}
		2127	try writer.writeAll("\n");
		2128	} else {
		2129	try writer.writeAll(")\n");
		2130	}
		2131	},
		2132
		2133	.brvoid => {
		2134	const brvoid = inst.castTag(.brvoid).?;
		2135	if (dtz.partial_inst_table.get(&brvoid.block.base)) \|operand_index\| {
		2136	try writer.print("%{d})\n", .{operand_index});
		2137	} else if (dtz.const_table.get(&brvoid.block.base)) \|operand_index\| {
		2138	try writer.print("@{d})\n", .{operand_index});
		2139	} else if (dtz.inst_table.get(&brvoid.block.base)) \|operand_index\| {
		2140	try writer.print("%{d}) // Instruction does not dominate all uses!\n", .{
		2141	operand_index,
		2142	});
		2143	} else {
		2144	try writer.writeAll("!BADREF!)\n");
		2145	}
		2146	},
		2147
		2148	// TODO fill out this debug printing
		2149	.assembly,
		2150	.block,
		2151	.call,
		2152	.condbr,
		2153	.constant,
		2154	.loop,
		2155	.varptr,
		2156	.switchbr,
		2157	=> {
		2158	try writer.writeAll("!TODO!)\n");
		2159	},
		2160	}
		2161	}
		2162	}
		2163
		2164	fn findConst(dtz: DumpTzir, operand: ir.Inst) !void {
		2165	if (operand.tag == .constant) {
		2166	try dtz.const_table.put(operand, dtz.next_const_index);
		2167	dtz.next_const_index += 1;
		2168	}
		2169	}
		2170	};
		2171
1888	const EmitZIR = struct {	2172	const EmitZIR = struct {
1889	allocator: *Allocator,	2173	allocator: *Allocator,
1890	arena: std.heap.ArenaAllocator,	2174	arena: std.heap.ArenaAllocator,
...	@@ -2072,11 +2356,12 @@ const EmitZIR = struct {	...	@@ -2072,11 +2356,12 @@ const EmitZIR = struct {
2072	var instructions = std.ArrayList(*Inst).init(self.allocator);	2356	var instructions = std.ArrayList(*Inst).init(self.allocator);
2073	defer instructions.deinit();	2357	defer instructions.deinit();
2074		2358
2075	switch (module_fn.analysis) {	2359	switch (module_fn.state) {
2076	.queued => unreachable,	2360	.queued => unreachable,
2077	.in_progress => unreachable,	2361	.in_progress => unreachable,
2078	.success => \|body\| {	2362	.inline_only => unreachable,
2079	try self.emitBody(body, &inst_table, &instructions);	2363	.success => {
		2364	try self.emitBody(module_fn.body, &inst_table, &instructions);
2080	},	2365	},
2081	.sema_failure => {	2366	.sema_failure => {
2082	const err_msg = self.old_module.failed_decls.get(module_fn.owner_decl).?;	2367	const err_msg = self.old_module.failed_decls.get(module_fn.owner_decl).?;
...	@@ -2154,7 +2439,9 @@ const EmitZIR = struct {	...	@@ -2154,7 +2439,9 @@ const EmitZIR = struct {
2154	.fn_type = fn_type.inst,	2439	.fn_type = fn_type.inst,
2155	.body = .{ .instructions = arena_instrs },	2440	.body = .{ .instructions = arena_instrs },
2156	},	2441	},
2157	.kw_args = .{},	2442	.kw_args = .{
		2443	.is_inline = module_fn.state == .inline_only,
		2444	},
2158	};	2445	};
2159	return self.emitUnnamedDecl(&fn_inst.base);	2446	return self.emitUnnamedDecl(&fn_inst.base);
2160	}	2447	}

src/zir_sema.zig+189-88

 @@ -159,16 +159,11 @@ pub fn analyzeInst(mod: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!
     }
 }
-pub fn analyzeBody(mod: *Module, scope: *Scope, body: zir.Module.Body) !void {
+pub fn analyzeBody(mod: *Module, block: *Scope.Block, body: zir.Module.Body) !void {
-    for (body.instructions) |src_inst, i| {
+    for (body.instructions) |src_inst| {
-        const analyzed_inst = try analyzeInst(mod, scope, src_inst);
+        const analyzed_inst = try analyzeInst(mod, &block.base, src_inst);
-        src_inst.analyzed_inst = analyzed_inst;
+        try block.inst_table.putNoClobber(src_inst, analyzed_inst);
         if (analyzed_inst.ty.zigTypeTag() == .NoReturn) {
-            for (body.instructions[i..]) |unreachable_inst| {
-                if (unreachable_inst.castTag(.dbg_stmt)) |dbg_stmt| {
-                    return mod.fail(scope, dbg_stmt.base.src, "unreachable code", .{});
-                }
-            }
             break;
         }
     }
 @@ -180,8 +175,8 @@ pub fn analyzeBodyValueAsType(
     zir_result_inst: *zir.Inst,
     body: zir.Module.Body,
 ) !Type {
-    try analyzeBody(mod, &block_scope.base, body);
+    try analyzeBody(mod, block_scope, body);
-    const result_inst = zir_result_inst.analyzed_inst.?;
+    const result_inst = block_scope.inst_table.get(zir_result_inst).?;
     const val = try mod.resolveConstValue(&block_scope.base, result_inst);
     return val.toType(block_scope.base.arena());
 }
 @@ -264,30 +259,9 @@ fn resolveCompleteZirDecl(mod: *Module, scope: *Scope, src_decl: *zir.Decl) Inne
     return decl;
 }
-/// TODO Look into removing this function. The body is only needed for .zir files, not .zig files.
+pub fn resolveInst(mod: *Module, scope: *Scope, zir_inst: *zir.Inst) InnerError!*Inst {
-pub fn resolveInst(mod: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*Inst {
+    const block = scope.cast(Scope.Block).?;
-    if (old_inst.analyzed_inst) |inst| return inst;
+    return block.inst_table.get(zir_inst).?; // Instruction does not dominate all uses!
-    // If this assert trips, the instruction that was referenced did not get properly
-    // analyzed before it was referenced.
-    const zir_module = scope.namespace().cast(Scope.ZIRModule).?;
-    const entry = if (old_inst.cast(zir.Inst.DeclVal)) |declval| blk: {
-        const decl_name = declval.positionals.name;
-        const entry = zir_module.contents.module.findDecl(decl_name) orelse
-            return mod.fail(scope, old_inst.src, "decl '{s}' not found", .{decl_name});
-        break :blk entry;
-    } else blk: {
-        // If this assert trips, the instruction that was referenced did not get
-        // properly analyzed by a previous instruction analysis before it was
-        // referenced by the current one.
-        break :blk zir_module.contents.module.findInstDecl(old_inst).?;
-    };
-    const decl = try resolveCompleteZirDecl(mod, scope, entry.decl);
-    const decl_ref = try mod.analyzeDeclRef(scope, old_inst.src, decl);
-    // Note: it would be tempting here to store the result into old_inst.analyzed_inst field,
-    // but this would prevent the analyzeDeclRef from happening, which is needed to properly
-    // detect Decl dependencies and dependency failures on updates.
-    return mod.analyzeDeref(scope, old_inst.src, decl_ref, old_inst.src);
 }
 fn resolveConstString(mod: *Module, scope: *Scope, old_inst: *zir.Inst) ![]u8 {
 @@ -575,7 +549,12 @@ fn analyzeInstCompileError(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) In
 }
 fn analyzeInstArg(mod: *Module, scope: *Scope, inst: *zir.Inst.Arg) InnerError!*Inst {
-    const b = try mod.requireRuntimeBlock(scope, inst.base.src);
+    const b = try mod.requireFunctionBlock(scope, inst.base.src);
+    if (b.inlining) |inlining| {
+        const param_index = inlining.param_index;
+        inlining.param_index += 1;
+        return inlining.casted_args[param_index];
+    }
     const fn_ty = b.func.?.owner_decl.typed_value.most_recent.typed_value.ty;
     const param_index = b.instructions.items.len;
     const param_count = fn_ty.fnParamLen();
 @@ -608,15 +587,17 @@ fn analyzeInstLoop(mod: *Module, scope: *Scope, inst: *zir.Inst.Loop) InnerError
     var child_block: Scope.Block = .{
         .parent = parent_block,
+        .inst_table = parent_block.inst_table,
         .func = parent_block.func,
         .decl = parent_block.decl,
         .instructions = .{},
         .arena = parent_block.arena,
+        .inlining = parent_block.inlining,
         .is_comptime = parent_block.is_comptime,
     };
     defer child_block.instructions.deinit(mod.gpa);
-    try analyzeBody(mod, &child_block.base, inst.positionals.body);
+    try analyzeBody(mod, &child_block, inst.positionals.body);
     // Loop repetition is implied so the last instruction may or may not be a noreturn instruction.
 @@ -630,16 +611,18 @@ fn analyzeInstBlockFlat(mod: *Module, scope: *Scope, inst: *zir.Inst.Block, is_c
     var child_block: Scope.Block = .{
         .parent = parent_block,
+        .inst_table = parent_block.inst_table,
         .func = parent_block.func,
         .decl = parent_block.decl,
         .instructions = .{},
         .arena = parent_block.arena,
         .label = null,
+        .inlining = parent_block.inlining,
         .is_comptime = parent_block.is_comptime or is_comptime,
     };
     defer child_block.instructions.deinit(mod.gpa);
-    try analyzeBody(mod, &child_block.base, inst.positionals.body);
+    try analyzeBody(mod, &child_block, inst.positionals.body);
     try parent_block.instructions.appendSlice(mod.gpa, child_block.instructions.items);
 @@ -668,6 +651,7 @@ fn analyzeInstBlock(mod: *Module, scope: *Scope, inst: *zir.Inst.Block, is_compt
     var child_block: Scope.Block = .{
         .parent = parent_block,
+        .inst_table = parent_block.inst_table,
         .func = parent_block.func,
         .decl = parent_block.decl,
         .instructions = .{},
 @@ -675,38 +659,53 @@ fn analyzeInstBlock(mod: *Module, scope: *Scope, inst: *zir.Inst.Block, is_compt
         // TODO @as here is working around a stage1 miscompilation bug :(
         .label = @as(?Scope.Block.Label, Scope.Block.Label{
             .zir_block = inst,
-            .results = .{},
+            .merges = .{
-            .block_inst = block_inst,
+                .results = .{},
+                .block_inst = block_inst,
+            },
         }),
+        .inlining = parent_block.inlining,
         .is_comptime = is_comptime or parent_block.is_comptime,
     };
-    const label = &child_block.label.?;
+    const merges = &child_block.label.?.merges;
     defer child_block.instructions.deinit(mod.gpa);
-    defer label.results.deinit(mod.gpa);
+    defer merges.results.deinit(mod.gpa);
-    try analyzeBody(mod, &child_block.base, inst.positionals.body);
+    try analyzeBody(mod, &child_block, inst.positionals.body);
+    return analyzeBlockBody(mod, scope, &child_block, merges);
+}
+fn analyzeBlockBody(
+    mod: *Module,
+    scope: *Scope,
+    child_block: *Scope.Block,
+    merges: *Scope.Block.Merges,
+) InnerError!*Inst {
+    const parent_block = scope.cast(Scope.Block).?;
     // Blocks must terminate with noreturn instruction.
     assert(child_block.instructions.items.len != 0);
     assert(child_block.instructions.items[child_block.instructions.items.len - 1].ty.isNoReturn());
-    if (label.results.items.len == 0) {
+    if (merges.results.items.len == 0) {
-        // No need for a block instruction. We can put the new instructions directly into the parent block.
+        // No need for a block instruction. We can put the new instructions
+        // directly into the parent block.
         const copied_instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items);
         try parent_block.instructions.appendSlice(mod.gpa, copied_instructions);
         return copied_instructions[copied_instructions.len - 1];
     }
-    if (label.results.items.len == 1) {
+    if (merges.results.items.len == 1) {
         const last_inst_index = child_block.instructions.items.len - 1;
         const last_inst = child_block.instructions.items[last_inst_index];
         if (last_inst.breakBlock()) |br_block| {
-            if (br_block == block_inst) {
+            if (br_block == merges.block_inst) {
                 // No need for a block instruction. We can put the new instructions directly into the parent block.
                 // Here we omit the break instruction.
                 const copied_instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items[0..last_inst_index]);
                 try parent_block.instructions.appendSlice(mod.gpa, copied_instructions);
-                return label.results.items[0];
+                return merges.results.items[0];
             }
         }
     }
 @@ -715,10 +714,10 @@ fn analyzeInstBlock(mod: *Module, scope: *Scope, inst: *zir.Inst.Block, is_compt
     // 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(mod.gpa, &block_inst.base);
+    try parent_block.instructions.append(mod.gpa, &merges.block_inst.base);
-    block_inst.base.ty = try mod.resolvePeerTypes(scope, label.results.items);
+    merges.block_inst.base.ty = try mod.resolvePeerTypes(scope, merges.results.items);
-    block_inst.body = .{ .instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items) };
+    merges.block_inst.body = .{ .instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items) };
-    return &block_inst.base;
+    return &merges.block_inst.base;
 }
 fn analyzeInstBreakpoint(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
 @@ -826,28 +825,108 @@ fn analyzeInstCall(mod: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerError
     const ret_type = func.ty.fnReturnType();
-    const b = try mod.requireRuntimeBlock(scope, inst.base.src);
+    const b = try mod.requireFunctionBlock(scope, inst.base.src);
+    const is_comptime_call = b.is_comptime or inst.kw_args.modifier == .compile_time;
+    const is_inline_call = is_comptime_call or inst.kw_args.modifier == .always_inline or blk: {
+        // This logic will get simplified by
+        // https://github.com/ziglang/zig/issues/6429
+        if (try mod.resolveDefinedValue(scope, func)) |func_val| {
+            const module_fn = switch (func_val.tag()) {
+                .function => func_val.castTag(.function).?.data,
+                else => break :blk false,
+            };
+            break :blk module_fn.state == .inline_only;
+        }
+        break :blk false;
+    };
+    if (is_inline_call) {
+        const func_val = try mod.resolveConstValue(scope, func);
+        const module_fn = switch (func_val.tag()) {
+            .function => func_val.castTag(.function).?.data,
+            .extern_fn => return mod.fail(scope, inst.base.src, "{s} call of extern function", .{
+                @as([]const u8, if (is_comptime_call) "comptime" else "inline"),
+            }),
+            else => unreachable,
+        };
+        // Analyze the ZIR. The same ZIR gets analyzed into a runtime function
+        // or an inlined call depending on what union tag the `label` field is
+        // set to in the `Scope.Block`.
+        // This block instruction will be used to capture the return value from the
+        // inlined function.
+        const block_inst = try scope.arena().create(Inst.Block);
+        block_inst.* = .{
+            .base = .{
+                .tag = Inst.Block.base_tag,
+                .ty = ret_type,
+                .src = inst.base.src,
+            },
+            .body = undefined,
+        };
+        // If this is the top of the inline/comptime call stack, we use this data.
+        // Otherwise we pass on the shared data from the parent scope.
+        var shared_inlining = Scope.Block.Inlining.Shared{
+            .branch_count = 0,
+            .branch_quota = 1000,
+            .caller = b.func,
+        };
+        // This one is shared among sub-blocks within the same callee, but not
+        // shared among the entire inline/comptime call stack.
+        var inlining = Scope.Block.Inlining{
+            .shared = if (b.inlining) |inlining| inlining.shared else &shared_inlining,
+            .param_index = 0,
+            .casted_args = casted_args,
+            .merges = .{
+                .results = .{},
+                .block_inst = block_inst,
+            },
+        };
+        var inst_table = Scope.Block.InstTable.init(mod.gpa);
+        defer inst_table.deinit();
+        var child_block: Scope.Block = .{
+            .parent = null,
+            .inst_table = &inst_table,
+            .func = module_fn,
+            // Note that we pass the caller's Decl, not the callee. This causes
+            // compile errors to be attached (correctly) to the caller's Decl.
+            .decl = scope.decl().?,
+            .instructions = .{},
+            .arena = scope.arena(),
+            .label = null,
+            .inlining = &inlining,
+            .is_comptime = is_comptime_call,
+        };
+        const merges = &child_block.inlining.?.merges;
+        defer child_block.instructions.deinit(mod.gpa);
+        defer merges.results.deinit(mod.gpa);
+        try mod.emitBackwardBranch(&child_block, inst.base.src);
+        // This will have return instructions analyzed as break instructions to
+        // the block_inst above.
+        try analyzeBody(mod, &child_block, module_fn.zir);
+        const result = try analyzeBlockBody(mod, scope, &child_block, merges);
+        if (result.castTag(.constant)) |constant| {
+            log.debug("inline call resulted in {}", .{constant.val});
+        } else {
+            log.debug("inline call resulted in {}", .{result});
+        }
+        return result;
+    }
     return mod.addCall(b, inst.base.src, ret_type, func, casted_args);
 }
 fn analyzeInstFn(mod: *Module, scope: *Scope, fn_inst: *zir.Inst.Fn) InnerError!*Inst {
     const fn_type = try resolveType(mod, scope, fn_inst.positionals.fn_type);
-    const fn_zir = blk: {
-        var fn_arena = std.heap.ArenaAllocator.init(mod.gpa);
-        errdefer fn_arena.deinit();
-        const fn_zir = try scope.arena().create(Module.Fn.ZIR);
-        fn_zir.* = .{
-            .body = .{
-                .instructions = fn_inst.positionals.body.instructions,
-            },
-            .arena = fn_arena.state,
-        };
-        break :blk fn_zir;
-    };
     const new_func = try scope.arena().create(Module.Fn);
     new_func.* = .{
-        .analysis = .{ .queued = fn_zir },
+        .state = if (fn_inst.kw_args.is_inline) .inline_only else .queued,
+        .zir = fn_inst.positionals.body,
+        .body = undefined,
         .owner_decl = scope.decl().?,
     };
     return mod.constInst(scope, fn_inst.base.src, .{
 @@ -1312,17 +1391,17 @@ fn analyzeInstSwitchBr(mod: *Module, scope: *Scope, inst: *zir.Inst.SwitchBr) In
             const item = try mod.resolveConstValue(scope, casted);
             if (target_val.eql(item)) {
-                try analyzeBody(mod, scope, case.body);
+                try analyzeBody(mod, scope.cast(Scope.Block).?, case.body);
                 return mod.constNoReturn(scope, inst.base.src);
             }
         }
-        try analyzeBody(mod, scope, inst.positionals.else_body);
+        try analyzeBody(mod, scope.cast(Scope.Block).?, inst.positionals.else_body);
         return mod.constNoReturn(scope, inst.base.src);
     }
     if (inst.positionals.cases.len == 0) {
         // no cases just analyze else_branch
-        try analyzeBody(mod, scope, inst.positionals.else_body);
+        try analyzeBody(mod, scope.cast(Scope.Block).?, inst.positionals.else_body);
         return mod.constNoReturn(scope, inst.base.src);
     }
 @@ -1331,10 +1410,12 @@ fn analyzeInstSwitchBr(mod: *Module, scope: *Scope, inst: *zir.Inst.SwitchBr) In
     var case_block: Scope.Block = .{
         .parent = parent_block,
+        .inst_table = parent_block.inst_table,
         .func = parent_block.func,
         .decl = parent_block.decl,
         .instructions = .{},
         .arena = parent_block.arena,
+        .inlining = parent_block.inlining,
         .is_comptime = parent_block.is_comptime,
     };
     defer case_block.instructions.deinit(mod.gpa);
 @@ -1347,7 +1428,7 @@ fn analyzeInstSwitchBr(mod: *Module, scope: *Scope, inst: *zir.Inst.SwitchBr) In
         const casted = try mod.coerce(scope, target.ty, resolved);
         const item = try mod.resolveConstValue(scope, casted);
-        try analyzeBody(mod, &case_block.base, case.body);
+        try analyzeBody(mod, &case_block, case.body);
         cases[i] = .{
             .item = item,
 @@ -1356,7 +1437,7 @@ fn analyzeInstSwitchBr(mod: *Module, scope: *Scope, inst: *zir.Inst.SwitchBr) In
     }
     case_block.instructions.items.len = 0;
-    try analyzeBody(mod, &case_block.base, inst.positionals.else_body);
+    try analyzeBody(mod, &case_block, inst.positionals.else_body);
     const else_body: ir.Body = .{
         .instructions = try parent_block.arena.dupe(*Inst, case_block.instructions.items),
 @@ -1509,7 +1590,7 @@ fn analyzeInstImport(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerErr
             return mod.fail(scope, inst.base.src, "unable to find '{s}'", .{operand});
         },
         else => {
-            // TODO user friendly error to string
+            // TODO: make sure this gets retried and not cached
             return mod.fail(scope, inst.base.src, "unable to open '{s}': {s}", .{ operand, @errorName(err) });
         },
     };
 @@ -1674,24 +1755,26 @@ fn analyzeInstComptimeOp(mod: *Module, scope: *Scope, res_type: Type, inst: *zir
     }
     const is_int = res_type.isInt() or res_type.zigTypeTag() == .ComptimeInt;
-    const value = try switch (inst.base.tag) {
+    const value = switch (inst.base.tag) {
         .add => blk: {
             const val = if (is_int)
-                Module.intAdd(scope.arena(), lhs_val, rhs_val)
+                try Module.intAdd(scope.arena(), lhs_val, rhs_val)
             else
-                mod.floatAdd(scope, res_type, inst.base.src, lhs_val, rhs_val);
+                try mod.floatAdd(scope, res_type, inst.base.src, lhs_val, rhs_val);
             break :blk val;
         },
         .sub => blk: {
             const val = if (is_int)
-                Module.intSub(scope.arena(), lhs_val, rhs_val)
+                try Module.intSub(scope.arena(), lhs_val, rhs_val)
             else
-                mod.floatSub(scope, res_type, inst.base.src, lhs_val, rhs_val);
+                try mod.floatSub(scope, res_type, inst.base.src, lhs_val, rhs_val);
             break :blk val;
         },
         else => return mod.fail(scope, inst.base.src, "TODO Implement arithmetic operand '{s}'", .{@tagName(inst.base.tag)}),
     };
+    log.debug("{s}({}, {}) result: {}", .{ @tagName(inst.base.tag), lhs_val, rhs_val, value });
     return mod.constInst(scope, inst.base.src, .{
         .ty = res_type,
         .val = value,
 @@ -1860,35 +1943,39 @@ fn analyzeInstCondBr(mod: *Module, scope: *Scope, inst: *zir.Inst.CondBr) InnerE
     const uncasted_cond = try resolveInst(mod, scope, inst.positionals.condition);
     const cond = try mod.coerce(scope, Type.initTag(.bool), uncasted_cond);
+    const parent_block = scope.cast(Scope.Block).?;
     if (try mod.resolveDefinedValue(scope, cond)) |cond_val| {
         const body = if (cond_val.toBool()) &inst.positionals.then_body else &inst.positionals.else_body;
-        try analyzeBody(mod, scope, body.*);
+        try analyzeBody(mod, parent_block, body.*);
         return mod.constNoReturn(scope, inst.base.src);
     }
-    const parent_block = try mod.requireRuntimeBlock(scope, inst.base.src);
     var true_block: Scope.Block = .{
         .parent = parent_block,
+        .inst_table = parent_block.inst_table,
         .func = parent_block.func,
         .decl = parent_block.decl,
         .instructions = .{},
         .arena = parent_block.arena,
+        .inlining = parent_block.inlining,
         .is_comptime = parent_block.is_comptime,
     };
     defer true_block.instructions.deinit(mod.gpa);
-    try analyzeBody(mod, &true_block.base, inst.positionals.then_body);
+    try analyzeBody(mod, &true_block, inst.positionals.then_body);
     var false_block: Scope.Block = .{
         .parent = parent_block,
+        .inst_table = parent_block.inst_table,
         .func = parent_block.func,
         .decl = parent_block.decl,
         .instructions = .{},
         .arena = parent_block.arena,
+        .inlining = parent_block.inlining,
         .is_comptime = parent_block.is_comptime,
     };
     defer false_block.instructions.deinit(mod.gpa);
-    try analyzeBody(mod, &false_block.base, inst.positionals.else_body);
+    try analyzeBody(mod, &false_block, inst.positionals.else_body);
     const then_body: ir.Body = .{ .instructions = try scope.arena().dupe(*Inst, true_block.instructions.items) };
     const else_body: ir.Body = .{ .instructions = try scope.arena().dupe(*Inst, false_block.instructions.items) };
 @@ -1912,12 +1999,26 @@ fn analyzeInstUnreachable(
 fn analyzeInstRet(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const operand = try resolveInst(mod, scope, inst.positionals.operand);
-    const b = try mod.requireRuntimeBlock(scope, inst.base.src);
+    const b = try mod.requireFunctionBlock(scope, inst.base.src);
+    if (b.inlining) |inlining| {
+        // We are inlining a function call; rewrite the `ret` as a `break`.
+        try inlining.merges.results.append(mod.gpa, operand);
+        return mod.addBr(b, inst.base.src, inlining.merges.block_inst, operand);
+    }
     return mod.addUnOp(b, inst.base.src, Type.initTag(.noreturn), .ret, operand);
 }
 fn analyzeInstRetVoid(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
-    const b = try mod.requireRuntimeBlock(scope, inst.base.src);
+    const b = try mod.requireFunctionBlock(scope, inst.base.src);
+    if (b.inlining) |inlining| {
+        // We are inlining a function call; rewrite the `retvoid` as a `breakvoid`.
+        const void_inst = try mod.constVoid(scope, inst.base.src);
+        try inlining.merges.results.append(mod.gpa, void_inst);
+        return mod.addBr(b, inst.base.src, inlining.merges.block_inst, void_inst);
+    }
     if (b.func) |func| {
         // Need to emit a compile error if returning void is not allowed.
         const void_inst = try mod.constVoid(scope, inst.base.src);
 @@ -1949,9 +2050,9 @@ fn analyzeBreak(
     while (opt_block) |block| {
         if (block.label) |*label| {
             if (label.zir_block == zir_block) {
-                try label.results.append(mod.gpa, operand);
+                try label.merges.results.append(mod.gpa, operand);
-                const b = try mod.requireRuntimeBlock(scope, src);
+                const b = try mod.requireFunctionBlock(scope, src);
-                return mod.addBr(b, src, label.block_inst, operand);
+                return mod.addBr(b, src, label.merges.block_inst, operand);
             }
         }
         opt_block = block.parent;

test/stage2/test.zig+147-2

...	@@ -27,7 +27,6 @@ const wasi = std.zig.CrossTarget{	...	@@ -27,7 +27,6 @@ const wasi = std.zig.CrossTarget{
27	};	27	};
28		28
29	pub fn addCases(ctx: *TestContext) !void {	29	pub fn addCases(ctx: *TestContext) !void {
30	try @import("zir.zig").addCases(ctx);
31	try @import("cbe.zig").addCases(ctx);	30	try @import("cbe.zig").addCases(ctx);
32	try @import("spu-ii.zig").addCases(ctx);	31	try @import("spu-ii.zig").addCases(ctx);
33	try @import("arm.zig").addCases(ctx);	32	try @import("arm.zig").addCases(ctx);
...	@@ -318,7 +317,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -318,7 +317,7 @@ pub fn addCases(ctx: *TestContext) !void {
318	}	317	}
319		318
320	{	319	{
321	var case = ctx.exe("adding numbers at runtime", linux_x64);	320	var case = ctx.exe("adding numbers at runtime and comptime", linux_x64);
322	case.addCompareOutput(	321	case.addCompareOutput(
323	\\export fn _start() noreturn {	322	\\export fn _start() noreturn {
324	\\ add(3, 4);	323	\\ add(3, 4);
...	@@ -342,6 +341,54 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -342,6 +341,54 @@ pub fn addCases(ctx: *TestContext) !void {
342	,	341	,
343	"",	342	"",
344	);	343	);
		344	// comptime function call
		345	case.addCompareOutput(
		346	\\export fn _start() noreturn {
		347	\\ exit();
		348	\\}
		349	\\
		350	\\fn add(a: u32, b: u32) u32 {
		351	\\ return a + b;
		352	\\}
		353	\\
		354	\\const x = add(3, 4);
		355	\\
		356	\\fn exit() noreturn {
		357	\\ asm volatile ("syscall"
		358	\\ :
		359	\\ : [number] "{rax}" (231),
		360	\\ [arg1] "{rdi}" (x - 7)
		361	\\ : "rcx", "r11", "memory"
		362	\\ );
		363	\\ unreachable;
		364	\\}
		365	,
		366	"",
		367	);
		368	// Inline function call
		369	case.addCompareOutput(
		370	\\export fn _start() noreturn {
		371	\\ var x: usize = 3;
		372	\\ const y = add(1, 2, x);
		373	\\ exit(y - 6);
		374	\\}
		375	\\
		376	\\inline fn add(a: usize, b: usize, c: usize) usize {
		377	\\ return a + b + c;
		378	\\}
		379	\\
		380	\\fn exit(code: usize) noreturn {
		381	\\ asm volatile ("syscall"
		382	\\ :
		383	\\ : [number] "{rax}" (231),
		384	\\ [arg1] "{rdi}" (code)
		385	\\ : "rcx", "r11", "memory"
		386	\\ );
		387	\\ unreachable;
		388	\\}
		389	,
		390	"",
		391	);
345	}	392	}
346		393
347	{	394	{
...	@@ -1331,4 +1378,102 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -1331,4 +1378,102 @@ pub fn addCases(ctx: *TestContext) !void {
1331	\\}	1378	\\}
1332	, &[_][]const u8{":2:9: error: variable of type '@Type(.Null)' must be const or comptime"});	1379	, &[_][]const u8{":2:9: error: variable of type '@Type(.Null)' must be const or comptime"});
1333	}	1380	}
		1381
		1382	{
		1383	var case = ctx.exe("compile error in inline fn call fixed", linux_x64);
		1384	case.addError(
		1385	\\export fn _start() noreturn {
		1386	\\ var x: usize = 3;
		1387	\\ const y = add(10, 2, x);
		1388	\\ exit(y - 6);
		1389	\\}
		1390	\\
		1391	\\inline fn add(a: usize, b: usize, c: usize) usize {
		1392	\\ if (a == 10) @compileError("bad");
		1393	\\ return a + b + c;
		1394	\\}
		1395	\\
		1396	\\fn exit(code: usize) noreturn {
		1397	\\ asm volatile ("syscall"
		1398	\\ :
		1399	\\ : [number] "{rax}" (231),
		1400	\\ [arg1] "{rdi}" (code)
		1401	\\ : "rcx", "r11", "memory"
		1402	\\ );
		1403	\\ unreachable;
		1404	\\}
		1405	, &[_][]const u8{":8:18: error: bad"});
		1406
		1407	case.addCompareOutput(
		1408	\\export fn _start() noreturn {
		1409	\\ var x: usize = 3;
		1410	\\ const y = add(1, 2, x);
		1411	\\ exit(y - 6);
		1412	\\}
		1413	\\
		1414	\\inline fn add(a: usize, b: usize, c: usize) usize {
		1415	\\ if (a == 10) @compileError("bad");
		1416	\\ return a + b + c;
		1417	\\}
		1418	\\
		1419	\\fn exit(code: usize) noreturn {
		1420	\\ asm volatile ("syscall"
		1421	\\ :
		1422	\\ : [number] "{rax}" (231),
		1423	\\ [arg1] "{rdi}" (code)
		1424	\\ : "rcx", "r11", "memory"
		1425	\\ );
		1426	\\ unreachable;
		1427	\\}
		1428	,
		1429	"",
		1430	);
		1431	}
		1432	{
		1433	var case = ctx.exe("recursive inline function", linux_x64);
		1434	case.addCompareOutput(
		1435	\\export fn _start() noreturn {
		1436	\\ const y = fibonacci(7);
		1437	\\ exit(y - 21);
		1438	\\}
		1439	\\
		1440	\\inline fn fibonacci(n: usize) usize {
		1441	\\ if (n <= 2) return n;
		1442	\\ return fibonacci(n - 2) + fibonacci(n - 1);
		1443	\\}
		1444	\\
		1445	\\fn exit(code: usize) noreturn {
		1446	\\ asm volatile ("syscall"
		1447	\\ :
		1448	\\ : [number] "{rax}" (231),
		1449	\\ [arg1] "{rdi}" (code)
		1450	\\ : "rcx", "r11", "memory"
		1451	\\ );
		1452	\\ unreachable;
		1453	\\}
		1454	,
		1455	"",
		1456	);
		1457	case.addError(
		1458	\\export fn _start() noreturn {
		1459	\\ const y = fibonacci(999);
		1460	\\ exit(y - 21);
		1461	\\}
		1462	\\
		1463	\\inline fn fibonacci(n: usize) usize {
		1464	\\ if (n <= 2) return n;
		1465	\\ return fibonacci(n - 2) + fibonacci(n - 1);
		1466	\\}
		1467	\\
		1468	\\fn exit(code: usize) noreturn {
		1469	\\ asm volatile ("syscall"
		1470	\\ :
		1471	\\ : [number] "{rax}" (231),
		1472	\\ [arg1] "{rdi}" (code)
		1473	\\ : "rcx", "r11", "memory"
		1474	\\ );
		1475	\\ unreachable;
		1476	\\}
		1477	, &[_][]const u8{":8:10: error: evaluation exceeded 1000 backwards branches"});
		1478	}
1334	}	1479	}

test/stage2/zir.zig deleted-316

...	@@ -1,316 +0,0 @@
1	const std = @import("std");
2	const TestContext = @import("../../src/test.zig").TestContext;
3	// self-hosted does not yet support PE executable files / COFF object files
4	// or mach-o files. So we do the ZIR transform test cases cross compiling for
5	// x86_64-linux.
6	const linux_x64 = std.zig.CrossTarget{
7	.cpu_arch = .x86_64,
8	.os_tag = .linux,
9	};
10
11	pub fn addCases(ctx: *TestContext) !void {
12	ctx.transformZIR("referencing decls which appear later in the file", linux_x64,
13	\\@void = primitive(void)
14	\\@fnty = fntype([], @void, cc=C)
15	\\
16	\\@9 = str("entry")
17	\\@11 = export(@9, "entry")
18	\\
19	\\@entry = fn(@fnty, {
20	\\ %11 = returnvoid()
21	\\})
22	,
23	\\@void = primitive(void)
24	\\@fnty = fntype([], @void, cc=C)
25	\\@9 = declref("9__anon_0")
26	\\@9__anon_0 = str("entry")
27	\\@unnamed$4 = str("entry")
28	\\@unnamed$5 = export(@unnamed$4, "entry")
29	\\@11 = primitive(void_value)
30	\\@unnamed$7 = fntype([], @void, cc=C)
31	\\@entry = fn(@unnamed$7, {
32	\\ %0 = returnvoid() ; deaths=0b1000000000000000
33	\\})
34	\\
35	);
36	ctx.transformZIR("elemptr, add, cmp, condbr, return, breakpoint", linux_x64,
37	\\@void = primitive(void)
38	\\@usize = primitive(usize)
39	\\@fnty = fntype([], @void, cc=C)
40	\\@0 = int(0)
41	\\@1 = int(1)
42	\\@2 = int(2)
43	\\@3 = int(3)
44	\\
45	\\@entry = fn(@fnty, {
46	\\ %a = str("\x32\x08\x01\x0a")
47	\\ %a_ref = ref(%a)
48	\\ %eptr0 = elemptr(%a_ref, @0)
49	\\ %eptr1 = elemptr(%a_ref, @1)
50	\\ %eptr2 = elemptr(%a_ref, @2)
51	\\ %eptr3 = elemptr(%a_ref, @3)
52	\\ %v0 = deref(%eptr0)
53	\\ %v1 = deref(%eptr1)
54	\\ %v2 = deref(%eptr2)
55	\\ %v3 = deref(%eptr3)
56	\\ %x0 = add(%v0, %v1)
57	\\ %x1 = add(%v2, %v3)
58	\\ %result = add(%x0, %x1)
59	\\
60	\\ %expected = int(69)
61	\\ %ok = cmp_eq(%result, %expected)
62	\\ %10 = condbr(%ok, {
63	\\ %11 = returnvoid()
64	\\ }, {
65	\\ %12 = breakpoint()
66	\\ })
67	\\})
68	\\
69	\\@9 = str("entry")
70	\\@11 = export(@9, "entry")
71	,
72	\\@void = primitive(void)
73	\\@fnty = fntype([], @void, cc=C)
74	\\@0 = int(0)
75	\\@1 = int(1)
76	\\@2 = int(2)
77	\\@3 = int(3)
78	\\@unnamed$6 = fntype([], @void, cc=C)
79	\\@entry = fn(@unnamed$6, {
80	\\ %0 = returnvoid() ; deaths=0b1000000000000000
81	\\})
82	\\@entry__anon_1 = str("2\x08\x01\n")
83	\\@9 = declref("9__anon_0")
84	\\@9__anon_0 = str("entry")
85	\\@unnamed$11 = str("entry")
86	\\@unnamed$12 = export(@unnamed$11, "entry")
87	\\@11 = primitive(void_value)
88	\\
89	);
90
91	{
92	var case = ctx.objZIR("reference cycle with compile error in the cycle", linux_x64);
93	case.addTransform(
94	\\@void = primitive(void)
95	\\@fnty = fntype([], @void, cc=C)
96	\\
97	\\@9 = str("entry")
98	\\@11 = export(@9, "entry")
99	\\
100	\\@entry = fn(@fnty, {
101	\\ %0 = call(@a, [])
102	\\ %1 = returnvoid()
103	\\})
104	\\
105	\\@a = fn(@fnty, {
106	\\ %0 = call(@b, [])
107	\\ %1 = returnvoid()
108	\\})
109	\\
110	\\@b = fn(@fnty, {
111	\\ %0 = call(@a, [])
112	\\ %1 = returnvoid()
113	\\})
114	,
115	\\@void = primitive(void)
116	\\@fnty = fntype([], @void, cc=C)
117	\\@9 = declref("9__anon_0")
118	\\@9__anon_0 = str("entry")
119	\\@unnamed$4 = str("entry")
120	\\@unnamed$5 = export(@unnamed$4, "entry")
121	\\@11 = primitive(void_value)
122	\\@unnamed$7 = fntype([], @void, cc=C)
123	\\@entry = fn(@unnamed$7, {
124	\\ %0 = call(@a, [], modifier=auto) ; deaths=0b1000000000000001
125	\\ %1 = returnvoid() ; deaths=0b1000000000000000
126	\\})
127	\\@unnamed$9 = fntype([], @void, cc=C)
128	\\@a = fn(@unnamed$9, {
129	\\ %0 = call(@b, [], modifier=auto) ; deaths=0b1000000000000001
130	\\ %1 = returnvoid() ; deaths=0b1000000000000000
131	\\})
132	\\@unnamed$11 = fntype([], @void, cc=C)
133	\\@b = fn(@unnamed$11, {
134	\\ %0 = call(@a, [], modifier=auto) ; deaths=0b1000000000000001
135	\\ %1 = returnvoid() ; deaths=0b1000000000000000
136	\\})
137	\\
138	);
139	// Now we introduce a compile error
140	case.addError(
141	\\@void = primitive(void)
142	\\@fnty = fntype([], @void, cc=C)
143	\\
144	\\@9 = str("entry")
145	\\@11 = export(@9, "entry")
146	\\
147	\\@entry = fn(@fnty, {
148	\\ %0 = call(@a, [])
149	\\ %1 = returnvoid()
150	\\})
151	\\
152	\\@a = fn(@fnty, {
153	\\ %0 = call(@c, [])
154	\\ %1 = returnvoid()
155	\\})
156	\\
157	\\@b = str("message")
158	\\
159	\\@c = fn(@fnty, {
160	\\ %9 = compileerror(@b)
161	\\ %0 = call(@a, [])
162	\\ %1 = returnvoid()
163	\\})
164	,
165	&[_][]const u8{
166	":20:21: error: message",
167	},
168	);
169	// Now we remove the call to `a`. `a` and `b` form a cycle, but no entry points are
170	// referencing either of them. This tests that the cycle is detected, and the error
171	// goes away.
172	case.addTransform(
173	\\@void = primitive(void)
174	\\@fnty = fntype([], @void, cc=C)
175	\\
176	\\@9 = str("entry")
177	\\@11 = export(@9, "entry")
178	\\
179	\\@entry = fn(@fnty, {
180	\\ %0 = returnvoid()
181	\\})
182	\\
183	\\@a = fn(@fnty, {
184	\\ %0 = call(@c, [])
185	\\ %1 = returnvoid()
186	\\})
187	\\
188	\\@b = str("message")
189	\\
190	\\@c = fn(@fnty, {
191	\\ %9 = compileerror(@b)
192	\\ %0 = call(@a, [])
193	\\ %1 = returnvoid()
194	\\})
195	,
196	\\@void = primitive(void)
197	\\@fnty = fntype([], @void, cc=C)
198	\\@9 = declref("9__anon_3")
199	\\@9__anon_3 = str("entry")
200	\\@unnamed$4 = str("entry")
201	\\@unnamed$5 = export(@unnamed$4, "entry")
202	\\@11 = primitive(void_value)
203	\\@unnamed$7 = fntype([], @void, cc=C)
204	\\@entry = fn(@unnamed$7, {
205	\\ %0 = returnvoid() ; deaths=0b1000000000000000
206	\\})
207	\\
208	);
209	}
210
211	if (std.Target.current.os.tag != .linux or
212	std.Target.current.cpu.arch != .x86_64)
213	{
214	// TODO implement self-hosted PE (.exe file) linking
215	// TODO implement more ZIR so we don't depend on x86_64-linux
216	return;
217	}
218
219	ctx.compareOutputZIR("hello world ZIR",
220	\\@noreturn = primitive(noreturn)
221	\\@void = primitive(void)
222	\\@usize = primitive(usize)
223	\\@0 = int(0)
224	\\@1 = int(1)
225	\\@2 = int(2)
226	\\@3 = int(3)
227	\\
228	\\@msg = str("Hello, world!\n")
229	\\
230	\\@start_fnty = fntype([], @noreturn, cc=Naked)
231	\\@start = fn(@start_fnty, {
232	\\ %SYS_exit_group = int(231)
233	\\ %exit_code = as(@usize, @0)
234	\\
235	\\ %syscall = str("syscall")
236	\\ %sysoutreg = str("={rax}")
237	\\ %rax = str("{rax}")
238	\\ %rdi = str("{rdi}")
239	\\ %rcx = str("rcx")
240	\\ %rdx = str("{rdx}")
241	\\ %rsi = str("{rsi}")
242	\\ %r11 = str("r11")
243	\\ %memory = str("memory")
244	\\
245	\\ %SYS_write = as(@usize, @1)
246	\\ %STDOUT_FILENO = as(@usize, @1)
247	\\
248	\\ %msg_addr = ptrtoint(@msg)
249	\\
250	\\ %len_name = str("len")
251	\\ %msg_len_ptr = fieldptr(@msg, %len_name)
252	\\ %msg_len = deref(%msg_len_ptr)
253	\\ %rc_write = asm(%syscall, @usize,
254	\\ volatile=1,
255	\\ output=%sysoutreg,
256	\\ inputs=[%rax, %rdi, %rsi, %rdx],
257	\\ clobbers=[%rcx, %r11, %memory],
258	\\ args=[%SYS_write, %STDOUT_FILENO, %msg_addr, %msg_len])
259	\\
260	\\ %rc_exit = asm(%syscall, @usize,
261	\\ volatile=1,
262	\\ output=%sysoutreg,
263	\\ inputs=[%rax, %rdi],
264	\\ clobbers=[%rcx, %r11, %memory],
265	\\ args=[%SYS_exit_group, %exit_code])
266	\\
267	\\ %99 = unreachable()
268	\\});
269	\\
270	\\@9 = str("_start")
271	\\@11 = export(@9, "start")
272	,
273	\\Hello, world!
274	\\
275	);
276
277	ctx.compareOutputZIR("function call with no args no return value",
278	\\@noreturn = primitive(noreturn)
279	\\@void = primitive(void)
280	\\@usize = primitive(usize)
281	\\@0 = int(0)
282	\\@1 = int(1)
283	\\@2 = int(2)
284	\\@3 = int(3)
285	\\
286	\\@exit0_fnty = fntype([], @noreturn)
287	\\@exit0 = fn(@exit0_fnty, {
288	\\ %SYS_exit_group = int(231)
289	\\ %exit_code = as(@usize, @0)
290	\\
291	\\ %syscall = str("syscall")
292	\\ %sysoutreg = str("={rax}")
293	\\ %rax = str("{rax}")
294	\\ %rdi = str("{rdi}")
295	\\ %rcx = str("rcx")
296	\\ %r11 = str("r11")
297	\\ %memory = str("memory")
298	\\
299	\\ %rc = asm(%syscall, @usize,
300	\\ volatile=1,
301	\\ output=%sysoutreg,
302	\\ inputs=[%rax, %rdi],
303	\\ clobbers=[%rcx, %r11, %memory],
304	\\ args=[%SYS_exit_group, %exit_code])
305	\\
306	\\ %99 = unreachable()
307	\\});
308	\\
309	\\@start_fnty = fntype([], @noreturn, cc=Naked)
310	\\@start = fn(@start_fnty, {
311	\\ %0 = call(@exit0, [])
312	\\})
313	\\@9 = str("_start")
314	\\@11 = export(@9, "start")
315	, "");
316	}

author	Andrew Kelley <andrew@ziglang.org> 2021-01-02 22:01:51-08:00
committer	GitHub <noreply@github.com> 2021-01-02 22:01:51-08:00
log	d8f3f14532c4b5d65377efaef015c3855137dccf
tree	d0927df77323d64bff52501b50ef8543a077d4d8
parent	3d151fbfc8db71f87ee84dd33c49910584708a04
parent	654832253a7857e78aab85e28ed09fb16b632dd2
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #7647 from ziglang/stage2-comptime-fn-call