aboutsummaryrefslogtreecommitdiff
path: root/src/codegen/c.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/codegen/c.zig')
-rw-r--r--src/codegen/c.zig130
1 files changed, 83 insertions, 47 deletions
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index e562ce320e..425663ad9c 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -2,6 +2,7 @@ const std = @import("std");
const link = @import("../link.zig");
const Module = @import("../Module.zig");
+const Compilation = @import("../Compilation.zig");
const Inst = @import("../ir.zig").Inst;
const Value = @import("../value.zig").Value;
@@ -19,7 +20,7 @@ fn map(allocator: *std.mem.Allocator, name: []const u8) ![]const u8 {
return allocator.dupe(u8, name);
}
-fn renderType(ctx: *Context, writer: std.ArrayList(u8).Writer, T: Type) !void {
+fn renderType(ctx: *Context, header: *C.Header, writer: std.ArrayList(u8).Writer, T: Type) !void {
switch (T.zigTypeTag()) {
.NoReturn => {
try writer.writeAll("zig_noreturn void");
@@ -27,16 +28,16 @@ fn renderType(ctx: *Context, writer: std.ArrayList(u8).Writer, T: Type) !void {
.Void => try writer.writeAll("void"),
.Int => {
if (T.tag() == .u8) {
- ctx.file.need_stdint = true;
+ header.need_stdint = true;
try writer.writeAll("uint8_t");
} else if (T.tag() == .usize) {
- ctx.file.need_stddef = true;
+ header.need_stddef = true;
try writer.writeAll("size_t");
} else {
- return ctx.file.fail(ctx.decl.src(), "TODO implement int types", .{});
+ return ctx.fail(ctx.decl.src(), "TODO implement int types", .{});
}
},
- else => |e| return ctx.file.fail(ctx.decl.src(), "TODO implement type {}", .{e}),
+ else => |e| return ctx.fail(ctx.decl.src(), "TODO implement type {}", .{e}),
}
}
@@ -47,13 +48,13 @@ fn renderValue(ctx: *Context, writer: std.ArrayList(u8).Writer, T: Type, val: Va
return writer.print("{}", .{val.toSignedInt()});
return writer.print("{}", .{val.toUnsignedInt()});
},
- else => |e| return ctx.file.fail(ctx.decl.src(), "TODO implement value {}", .{e}),
+ else => |e| return ctx.fail(ctx.decl.src(), "TODO implement value {}", .{e}),
}
}
-fn renderFunctionSignature(ctx: *Context, writer: std.ArrayList(u8).Writer, decl: *Decl) !void {
+fn renderFunctionSignature(ctx: *Context, header: *C.Header, writer: std.ArrayList(u8).Writer, decl: *Decl) !void {
const tv = decl.typed_value.most_recent.typed_value;
- try renderType(ctx, writer, tv.ty.fnReturnType());
+ try renderType(ctx, header, writer, tv.ty.fnReturnType());
// Use the child allocator directly, as we know the name can be freed before
// the rest of the arena.
const name = try map(ctx.arena.child_allocator, mem.spanZ(decl.name));
@@ -68,7 +69,7 @@ fn renderFunctionSignature(ctx: *Context, writer: std.ArrayList(u8).Writer, decl
if (index > 0) {
try writer.writeAll(", ");
}
- try renderType(ctx, writer, tv.ty.fnParamType(index));
+ try renderType(ctx, header, writer, tv.ty.fnParamType(index));
try writer.print(" arg{}", .{index});
}
}
@@ -83,6 +84,34 @@ pub fn generate(file: *C, decl: *Decl) !void {
}
}
+pub fn generateHeader(
+ arena: *std.heap.ArenaAllocator,
+ module: *Module,
+ header: *C.Header,
+ decl: *Decl,
+) error{ AnalysisFail, OutOfMemory }!void {
+ switch (decl.typed_value.most_recent.typed_value.ty.zigTypeTag()) {
+ .Fn => {
+ var inst_map = std.AutoHashMap(*Inst, []u8).init(&arena.allocator);
+ defer inst_map.deinit();
+ var ctx = Context{
+ .decl = decl,
+ .arena = arena,
+ .inst_map = &inst_map,
+ };
+ const writer = header.buf.writer();
+ renderFunctionSignature(&ctx, header, writer, decl) catch |err| {
+ if (err == error.AnalysisFail) {
+ try module.failed_decls.put(module.gpa, decl, ctx.error_msg);
+ }
+ return err;
+ };
+ try writer.writeAll(";\n");
+ },
+ else => {},
+ }
+}
+
fn genArray(file: *C, decl: *Decl) !void {
const tv = decl.typed_value.most_recent.typed_value;
// TODO: prevent inline asm constants from being emitted
@@ -102,12 +131,12 @@ fn genArray(file: *C, decl: *Decl) !void {
}
const Context = struct {
- file: *C,
decl: *Decl,
inst_map: *std.AutoHashMap(*Inst, []u8),
arena: *std.heap.ArenaAllocator,
argdex: usize = 0,
unnamed_index: usize = 0,
+ error_msg: *Compilation.ErrorMsg = undefined,
fn resolveInst(self: *Context, inst: *Inst) ![]u8 {
if (inst.cast(Inst.Constant)) |const_inst| {
@@ -127,6 +156,11 @@ const Context = struct {
return val;
}
+ fn fail(self: *Context, src: usize, comptime format: []const u8, args: anytype) error{ AnalysisFail, OutOfMemory } {
+ self.error_msg = try Compilation.ErrorMsg.create(self.arena.child_allocator, src, format, args);
+ return error.AnalysisFail;
+ }
+
fn deinit(self: *Context) void {
self.* = undefined;
}
@@ -141,14 +175,16 @@ fn genFn(file: *C, decl: *Decl) !void {
var inst_map = std.AutoHashMap(*Inst, []u8).init(&arena.allocator);
defer inst_map.deinit();
var ctx = Context{
- .file = file,
.decl = decl,
.arena = &arena,
.inst_map = &inst_map,
};
- defer ctx.deinit();
+ defer {
+ file.error_msg = ctx.error_msg;
+ ctx.deinit();
+ }
- try renderFunctionSignature(&ctx, writer, decl);
+ try renderFunctionSignature(&ctx, &file.header, writer, decl);
try writer.writeAll(" {");
@@ -158,18 +194,18 @@ fn genFn(file: *C, decl: *Decl) !void {
try writer.writeAll("\n");
for (instructions) |inst| {
if (switch (inst.tag) {
- .assembly => try genAsm(&ctx, inst.castTag(.assembly).?),
- .call => try genCall(&ctx, inst.castTag(.call).?),
- .add => try genBinOp(&ctx, inst.cast(Inst.BinOp).?, "+"),
- .sub => try genBinOp(&ctx, inst.cast(Inst.BinOp).?, "-"),
+ .assembly => try genAsm(&ctx, file, inst.castTag(.assembly).?),
+ .call => try genCall(&ctx, file, inst.castTag(.call).?),
+ .add => try genBinOp(&ctx, file, inst.cast(Inst.BinOp).?, "+"),
+ .sub => try genBinOp(&ctx, file, inst.cast(Inst.BinOp).?, "-"),
.ret => try genRet(&ctx, inst.castTag(.ret).?),
- .retvoid => try genRetVoid(&ctx),
+ .retvoid => try genRetVoid(file),
.arg => try genArg(&ctx),
.dbg_stmt => try genDbgStmt(&ctx, inst.castTag(.dbg_stmt).?),
.breakpoint => try genBreak(&ctx, inst.castTag(.breakpoint).?),
- .unreach => try genUnreach(&ctx, inst.castTag(.unreach).?),
- .intcast => try genIntCast(&ctx, inst.castTag(.intcast).?),
- else => |e| return file.fail(decl.src(), "TODO implement C codegen for {}", .{e}),
+ .unreach => try genUnreach(file, inst.castTag(.unreach).?),
+ .intcast => try genIntCast(&ctx, file, inst.castTag(.intcast).?),
+ else => |e| return ctx.fail(decl.src(), "TODO implement C codegen for {}", .{e}),
}) |name| {
try ctx.inst_map.putNoClobber(inst, name);
}
@@ -185,46 +221,46 @@ fn genArg(ctx: *Context) !?[]u8 {
return name;
}
-fn genRetVoid(ctx: *Context) !?[]u8 {
- try ctx.file.main.writer().print(indentation ++ "return;\n", .{});
+fn genRetVoid(file: *C) !?[]u8 {
+ try file.main.writer().print(indentation ++ "return;\n", .{});
return null;
}
fn genRet(ctx: *Context, inst: *Inst.UnOp) !?[]u8 {
- return ctx.file.fail(ctx.decl.src(), "TODO return", .{});
+ return ctx.fail(ctx.decl.src(), "TODO return", .{});
}
-fn genIntCast(ctx: *Context, inst: *Inst.UnOp) !?[]u8 {
+fn genIntCast(ctx: *Context, file: *C, inst: *Inst.UnOp) !?[]u8 {
if (inst.base.isUnused())
return null;
const op = inst.operand;
- const writer = ctx.file.main.writer();
+ const writer = file.main.writer();
const name = try ctx.name();
const from = try ctx.resolveInst(inst.operand);
try writer.writeAll(indentation ++ "const ");
- try renderType(ctx, writer, inst.base.ty);
+ try renderType(ctx, &file.header, writer, inst.base.ty);
try writer.print(" {} = (", .{name});
- try renderType(ctx, writer, inst.base.ty);
+ try renderType(ctx, &file.header, writer, inst.base.ty);
try writer.print("){};\n", .{from});
return name;
}
-fn genBinOp(ctx: *Context, inst: *Inst.BinOp, comptime operator: []const u8) !?[]u8 {
+fn genBinOp(ctx: *Context, file: *C, inst: *Inst.BinOp, comptime operator: []const u8) !?[]u8 {
if (inst.base.isUnused())
return null;
const lhs = ctx.resolveInst(inst.lhs);
const rhs = ctx.resolveInst(inst.rhs);
- const writer = ctx.file.main.writer();
+ const writer = file.main.writer();
const name = try ctx.name();
try writer.writeAll(indentation ++ "const ");
- try renderType(ctx, writer, inst.base.ty);
+ try renderType(ctx, &file.header, writer, inst.base.ty);
try writer.print(" {} = {} " ++ operator ++ " {};\n", .{ name, lhs, rhs });
return name;
}
-fn genCall(ctx: *Context, inst: *Inst.Call) !?[]u8 {
- const writer = ctx.file.main.writer();
- const header = ctx.file.header.writer();
+fn genCall(ctx: *Context, file: *C, inst: *Inst.Call) !?[]u8 {
+ const writer = file.main.writer();
+ const header = file.header.buf.writer();
try writer.writeAll(indentation);
if (inst.func.castTag(.constant)) |func_inst| {
if (func_inst.val.cast(Value.Payload.Function)) |func_val| {
@@ -235,9 +271,9 @@ fn genCall(ctx: *Context, inst: *Inst.Call) !?[]u8 {
try writer.print("(void)", .{});
}
const tname = mem.spanZ(target.name);
- if (ctx.file.called.get(tname) == null) {
- try ctx.file.called.put(tname, void{});
- try renderFunctionSignature(ctx, header, target);
+ if (file.called.get(tname) == null) {
+ try file.called.put(tname, void{});
+ try renderFunctionSignature(ctx, &file.header, header, target);
try header.writeAll(";\n");
}
try writer.print("{}(", .{tname});
@@ -256,10 +292,10 @@ fn genCall(ctx: *Context, inst: *Inst.Call) !?[]u8 {
}
try writer.writeAll(");\n");
} else {
- return ctx.file.fail(ctx.decl.src(), "TODO non-function call target?", .{});
+ return ctx.fail(ctx.decl.src(), "TODO non-function call target?", .{});
}
} else {
- return ctx.file.fail(ctx.decl.src(), "TODO non-constant call inst?", .{});
+ return ctx.fail(ctx.decl.src(), "TODO non-constant call inst?", .{});
}
return null;
}
@@ -274,20 +310,20 @@ fn genBreak(ctx: *Context, inst: *Inst.NoOp) !?[]u8 {
return null;
}
-fn genUnreach(ctx: *Context, inst: *Inst.NoOp) !?[]u8 {
- try ctx.file.main.writer().writeAll(indentation ++ "zig_unreachable();\n");
+fn genUnreach(file: *C, inst: *Inst.NoOp) !?[]u8 {
+ try file.main.writer().writeAll(indentation ++ "zig_unreachable();\n");
return null;
}
-fn genAsm(ctx: *Context, as: *Inst.Assembly) !?[]u8 {
- const writer = ctx.file.main.writer();
+fn genAsm(ctx: *Context, file: *C, as: *Inst.Assembly) !?[]u8 {
+ const writer = file.main.writer();
try writer.writeAll(indentation);
for (as.inputs) |i, index| {
if (i[0] == '{' and i[i.len - 1] == '}') {
const reg = i[1 .. i.len - 1];
const arg = as.args[index];
try writer.writeAll("register ");
- try renderType(ctx, writer, arg.ty);
+ try renderType(ctx, &file.header, writer, arg.ty);
try writer.print(" {}_constant __asm__(\"{}\") = ", .{ reg, reg });
// TODO merge constant handling into inst_map as well
if (arg.castTag(.constant)) |c| {
@@ -296,17 +332,17 @@ fn genAsm(ctx: *Context, as: *Inst.Assembly) !?[]u8 {
} else {
const gop = try ctx.inst_map.getOrPut(arg);
if (!gop.found_existing) {
- return ctx.file.fail(ctx.decl.src(), "Internal error in C backend: asm argument not found in inst_map", .{});
+ return ctx.fail(ctx.decl.src(), "Internal error in C backend: asm argument not found in inst_map", .{});
}
try writer.print("{};\n ", .{gop.entry.value});
}
} else {
- return ctx.file.fail(ctx.decl.src(), "TODO non-explicit inline asm regs", .{});
+ return ctx.fail(ctx.decl.src(), "TODO non-explicit inline asm regs", .{});
}
}
try writer.print("__asm {} (\"{}\"", .{ if (as.is_volatile) @as([]const u8, "volatile") else "", as.asm_source });
if (as.output) |o| {
- return ctx.file.fail(ctx.decl.src(), "TODO inline asm output", .{});
+ return ctx.fail(ctx.decl.src(), "TODO inline asm output", .{});
}
if (as.inputs.len > 0) {
if (as.output == null) {
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-28 03:28:43 +0000