From d8049872c9a98a6dd761b5c0949ea06a7fdfa6a7 Mon Sep 17 00:00:00 2001 From: fubark Date: Sun, 25 Aug 2024 23:19:51 -0400 Subject: [PATCH] Fix value template expansion. --- src/bc_gen.zig | 23 +++++++++++++++------ src/cte.zig | 56 +++++++++++++++++++++++++++++++++----------------- src/ir.zig | 8 ++++++-- src/sym.zig | 5 +++++ 4 files changed, 65 insertions(+), 27 deletions(-) diff --git a/src/bc_gen.zig b/src/bc_gen.zig index b0c351b50..645c1675e 100644 --- a/src/bc_gen.zig +++ b/src/bc_gen.zig @@ -257,7 +257,10 @@ pub fn prepareFunc(c: *cy.Compiler, opt_group: ?rt.FuncGroupId, func: *cy.Func) if (opt_group) |group| { _ = try addGroupFunc(c, group, func, rtFunc); } else { - _ = try completeFunc(c, func, rtFunc); + const id = try reserveFunc(c, func); + if (c.vm.funcSyms.buf[id].type == .null) { + completeFunc(c, id, func, rtFunc); + } } }, .userFunc => { @@ -291,10 +294,12 @@ fn reserveFunc(c: *cy.Compiler, func: *cy.Func) !u32 { return res.value_ptr.func.id; } -fn completeFunc(c: *cy.Compiler, func: *cy.Func, sym: rt.FuncSymbol) !u32 { - const id = try reserveFunc(c, func); +fn completeFunc(c: *cy.Compiler, id: u32, func: *cy.Func, sym: rt.FuncSymbol) void { + log.tracev("complete func gen: {s} {}", .{func.name(), id}); + if (c.vm.funcSyms.buf[id].type != .null) { + std.debug.panic("Func already completed: {s} {}", .{func.name(), id}); + } c.vm.funcSyms.buf[id] = sym; - return id; } fn genChunk(c: *Chunk) !void { @@ -553,6 +558,11 @@ pub fn funcBlock(c: *Chunk, idx: usize, node: *ast.Node) !void { const data = c.ir.getStmtData(idx, .funcBlock); const func = data.func; + // Skip if marked as skip (usually for one-off compile-time functions) + if (data.skip) { + return; + } + // Skip if func has already been generated by compile-time. const id = try reserveFunc(c.compiler, func); if (c.vm.funcSyms.buf[id].type != .null) { @@ -570,7 +580,7 @@ pub fn funcBlock(c: *Chunk, idx: usize, node: *ast.Node) !void { const stackSize = c.getMaxUsedRegisters(); const rt_func = rt.FuncSymbol.initFunc(funcPc, @intCast(stackSize), func.numParams, func.funcSigId, func.reqCallTypeCheck, func.isMethod()); - c.vm.funcSyms.buf[id] = rt_func; + completeFunc(c.compiler, id, func, rt_func); try popFuncBlockCommon(c, func); } @@ -3320,7 +3330,8 @@ fn genLambda(c: *Chunk, idx: usize, cstr: Cstr, node: *ast.Node) !GenValue { const stackSize = c.getMaxUsedRegisters(); const rt_func = rt.FuncSymbol.initFunc(funcPc, @intCast(stackSize), func.numParams, func.funcSigId, func.reqCallTypeCheck, func.isMethod()); - const rt_id = try completeFunc(c.compiler, func, rt_func); + const rt_id = try reserveFunc(c.compiler, func); + completeFunc(c.compiler, rt_id, func, rt_func); try popFuncBlockCommon(c, func); c.patchJumpToCurPc(skipJump); diff --git a/src/cte.zig b/src/cte.zig index 8e1fb036e..5887d8183 100644 --- a/src/cte.zig +++ b/src/cte.zig @@ -149,7 +149,7 @@ pub fn expandCtFuncTemplateOnCallArgs(c: *cy.Chunk, template: *cy.sym.Template, try pushNodeValuesCstr(c, args, template, valueStart, node); const arg_vals = c.valueStack.items[valueStart..]; - return expandCtFuncTemplate(c, template, arg_vals); + return expandValueTemplate(c, template, arg_vals); } pub fn expandFuncTemplateOnCallArgs(c: *cy.Chunk, template: *cy.Func, args: []const *ast.Node, node: *ast.Node) !*cy.Func { @@ -252,22 +252,33 @@ fn compileFuncDeep(c: *cy.Chunk, func: *cy.Func, queued: *std.AutoHashMapUnmanag src_chunk.buf = &c.compiler.buf; // TODO: defer restore bc state. try bcgen.prepareFunc(src_chunk.compiler, null, func); - try bcgen.funcBlock(src_chunk, loc, loc_n); - - // Analyze IR for func deps. - var visitor = try src_chunk.ir.visitStmt(c.alloc, @intCast(loc)); - defer visitor.deinit(); - while (try visitor.next()) |entry| { - if (entry.is_stmt) { - continue; - } - const code = src_chunk.ir.getExprCode(entry.loc); - switch (code) { - .call_sym => { - const data = src_chunk.ir.getExprData(entry.loc, .call_sym); - try compileFuncDeep(c, data.func, queued); - }, - else => {}, + switch (func.type) { + .hostFunc => { + // Nop. Already setup from `prepareFunc`. + }, + .userFunc => { + try bcgen.funcBlock(src_chunk, loc, loc_n); + + // Analyze IR for func deps. + var visitor = try src_chunk.ir.visitStmt(c.alloc, @intCast(loc)); + defer visitor.deinit(); + while (try visitor.next()) |entry| { + if (entry.is_stmt) { + continue; + } + const code = src_chunk.ir.getExprCode(entry.loc); + switch (code) { + .call_sym => { + const data = src_chunk.ir.getExprData(entry.loc, .call_sym); + try compileFuncDeep(c, data.func, queued); + }, + else => {}, + } + } + func.data = .{ .userFunc = .{ .loc = @intCast(loc) }}; + }, + else => { + return error.Unexpected; } } func.emitted_deps = true; @@ -292,7 +303,7 @@ pub fn callFunc(c: *cy.Chunk, func: *cy.Func, args: []const cy.Value) !CtValue { }; } -pub fn expandCtFuncTemplate(c: *cy.Chunk, template: *cy.sym.Template, args: []const cy.Value) !CtValue { +pub fn expandValueTemplate(c: *cy.Chunk, template: *cy.sym.Template, args: []const cy.Value) !CtValue { // Ensure variant type. const res = try template.variant_cache.getOrPutContext(c.alloc, args, .{ .sema = c.sema }); if (!res.found_existing) { @@ -328,7 +339,14 @@ pub fn expandCtFuncTemplate(c: *cy.Chunk, template: *cy.sym.Template, args: []co // Generate ct func. Can assume not a `@host` func. const func = try c.createFunc(.userFunc, @ptrCast(template), @ptrCast(template.decl.child_decl), false); - defer c.vm.alloc.destroy(func); + defer { + // Remove references to the func and invalidate the sema func block. + _ = c.compiler.genSymMap.remove(@ptrCast(func)); + const src_chunk = func.chunk(); + const data = src_chunk.ir.getStmtDataPtr(func.data.userFunc.loc, .funcBlock); + data.skip = true; + c.vm.alloc.destroy(func); + } const func_sig = c.sema.getFuncSig(sig); func.funcSigId = sig; func.retType = func_sig.getRetType(); diff --git a/src/ir.zig b/src/ir.zig index 827083423..2f6c36b7e 100644 --- a/src/ir.zig +++ b/src/ir.zig @@ -351,6 +351,10 @@ pub const FuncBlock = struct { // For methods only. parentType: cy.TypeId, + + /// Mark a func block to skip generation. + /// Useful for removing temporary compile-time functions. + skip: bool = false, }; pub const PushBlock = struct { @@ -795,7 +799,7 @@ pub const Buffer = struct { } pub fn pushEmptyExpr(self: *Buffer, comptime code: ExprCode, alloc: std.mem.Allocator, expr_t: ExprType, node_id: *ast.Node) !u32 { - log.tracev("irPushExpr: {}", .{code}); + log.tracev("irPushExpr: {} at {}", .{code, self.buf.items.len}); const start = self.buf.items.len; try self.buf.resize(alloc, self.buf.items.len + 1 + 8 + 4 + @sizeOf(ExprData(code))); self.buf.items[start] = @intFromEnum(code); @@ -908,7 +912,7 @@ pub const Buffer = struct { } pub fn pushEmptyStmt2(self: *Buffer, alloc: std.mem.Allocator, comptime code: StmtCode, node: *ast.Node, comptime appendToParent_: bool) !u32 { - log.tracev("irPushStmt: {}", .{code}); + log.tracev("irPushStmt: {} at {}", .{code, self.buf.items.len}); const start: u32 = @intCast(self.buf.items.len); try self.buf.resize(alloc, self.buf.items.len + 1 + 8 + 4 + @sizeOf(StmtData(code))); self.buf.items[start] = @intFromEnum(code); diff --git a/src/sym.zig b/src/sym.zig index 661537b54..3549275df 100644 --- a/src/sym.zig +++ b/src/sym.zig @@ -1063,6 +1063,11 @@ pub const Func = struct { vtable_idx: u32, }, template: *FuncTemplate, + userFunc: struct { + /// Currently used to invalidate the IR func block when removing temporary functions. + /// See `cte.expandValueTemplate`. + loc: u32, + }, }, variant: ?*Variant, reqCallTypeCheck: bool,