motiejus/zig
1
Fork 0
Code Releases Activity

stage2: add extern functions

Browse Source 
and improve the C backend enough to support Hello World (almost)
This commit is contained in:
Andrew Kelley
2020-12-28 17:15:29 -07:00
parent 2df2f0020f
commit 87c6341b61
7 changed files with 457 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/Compilation.zig
View File

@@ -1431,9 +1431,6 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
var c_comp_progress_node = main_progress_node.start("Compile C Objects", self.c_source_files.len);
defer c_comp_progress_node.end();
var arena = std.heap.ArenaAllocator.init(self.gpa);
defer arena.deinit();
self.work_queue_wait_group.reset();
defer self.work_queue_wait_group.wait();
@@ -1502,7 +1499,7 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
};
if (self.c_header) |*header| {
c_codegen.generateHeader(&arena, module, &header.*, decl) catch |err| switch (err) {
c_codegen.generateHeader(self, module, header, decl) catch |err| switch (err) {
error.OutOfMemory => return error.OutOfMemory,
error.AnalysisFail => {
decl.analysis = .dependency_failure;

97
src/Module.zig
View File

@@ -277,6 +277,8 @@ pub const Decl = struct {
};
/// Fn struct memory is owned by the Decl's TypedValue.Managed arena allocator.
/// 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.
analysis: union(enum) {
@@ -1010,8 +1012,6 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
defer fn_type_scope.instructions.deinit(self.gpa);
decl.is_pub = fn_proto.getVisibToken() != null;
const body_node = fn_proto.getBodyNode() orelse
return self.failTok(&fn_type_scope.base, fn_proto.fn_token, "TODO implement extern functions", .{});
const param_decls = fn_proto.params();
const param_types = try fn_type_scope.arena.alloc(*zir.Inst, param_decls.len);
@@ -1083,6 +1083,36 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
const fn_type = try zir_sema.analyzeBodyValueAsType(self, &block_scope, fn_type_inst, .{
.instructions = fn_type_scope.instructions.items,
});
const body_node = fn_proto.getBodyNode() orelse {
// Extern function.
var type_changed = true;
if (decl.typedValueManaged()) |tvm| {
type_changed = !tvm.typed_value.ty.eql(fn_type);
tvm.deinit(self.gpa);
}
const value_payload = try decl_arena.allocator.create(Value.Payload.ExternFn);
value_payload.* = .{ .decl = decl };
decl_arena_state.* = decl_arena.state;
decl.typed_value = .{
.most_recent = .{
.typed_value = .{
.ty = fn_type,
.val = Value.initPayload(&value_payload.base),
},
.arena = decl_arena_state,
},
};
decl.analysis = .complete;
decl.generation = self.generation;
try self.comp.bin_file.allocateDeclIndexes(decl);
try self.comp.work_queue.writeItem(.{ .codegen_decl = decl });
return type_changed;
};
const new_func = try decl_arena.allocator.create(Fn);
const fn_payload = try decl_arena.allocator.create(Value.Payload.Function);
@@ -1899,7 +1929,13 @@ pub fn resolveDefinedValue(self: *Module, scope: *Scope, base: *Inst) !?Value {
return null;
}
pub fn analyzeExport(self: *Module, scope: *Scope, src: usize, borrowed_symbol_name: []const u8, exported_decl: *Decl) !void {
pub fn analyzeExport(
self: *Module,
scope: *Scope,
src: usize,
borrowed_symbol_name: []const u8,
exported_decl: *Decl,
) !void {
try self.ensureDeclAnalyzed(exported_decl);
const typed_value = exported_decl.typed_value.most_recent.typed_value;
switch (typed_value.ty.zigTypeTag()) {
@@ -2801,16 +2837,47 @@ pub fn coerce(self: *Module, scope: *Scope, dest_type: Type, inst: *Inst) !*Inst
}
}
// *[N]T to []T
if (inst.ty.isSinglePointer() and dest_type.isSlice() and
(!inst.ty.isConstPtr() or dest_type.isConstPtr()))
{
// Coercions where the source is a single pointer to an array.
src_array_ptr: {
if (!inst.ty.isSinglePointer()) break :src_array_ptr;
const array_type = inst.ty.elemType();
if (array_type.zigTypeTag() != .Array) break :src_array_ptr;
const array_elem_type = array_type.elemType();
if (inst.ty.isConstPtr() and !dest_type.isConstPtr()) break :src_array_ptr;
if (inst.ty.isVolatilePtr() and !dest_type.isVolatilePtr()) break :src_array_ptr;
const dst_elem_type = dest_type.elemType();
if (array_type.zigTypeTag() == .Array and
coerceInMemoryAllowed(dst_elem_type, array_type.elemType()) == .ok)
{
return self.coerceArrayPtrToSlice(scope, dest_type, inst);
switch (coerceInMemoryAllowed(dst_elem_type, array_elem_type)) {
.ok => {},
.no_match => break :src_array_ptr,
}
switch (dest_type.ptrSize()) {
.Slice => {
// *[N]T to []T
return self.coerceArrayPtrToSlice(scope, dest_type, inst);
},
.C => {
// *[N]T to [*c]T
return self.coerceArrayPtrToMany(scope, dest_type, inst);
},
.Many => {
// *[N]T to [*]T
// *[N:s]T to [*:s]T
const src_sentinel = array_type.sentinel();
const dst_sentinel = dest_type.sentinel();
if (src_sentinel == null and dst_sentinel == null)
return self.coerceArrayPtrToMany(scope, dest_type, inst);
if (src_sentinel) |src_s| {
if (dst_sentinel) |dst_s| {
if (src_s.eql(dst_s)) {
return self.coerceArrayPtrToMany(scope, dest_type, inst);
}
}
}
},
.One => {},
}
}
@@ -2918,6 +2985,14 @@ fn coerceArrayPtrToSlice(self: *Module, scope: *Scope, dest_type: Type, inst: *I
return self.fail(scope, inst.src, "TODO implement coerceArrayPtrToSlice runtime instruction", .{});
}
fn coerceArrayPtrToMany(self: *Module, scope: *Scope, dest_type: Type, inst: *Inst) !*Inst {
if (inst.value()) |val| {
// The comptime Value representation is compatible with both types.
return self.constInst(scope, inst.src, .{ .ty = dest_type, .val = val });
}
return self.fail(scope, inst.src, "TODO implement coerceArrayPtrToMany runtime instruction", .{});
}
pub fn fail(self: *Module, scope: *Scope, src: usize, comptime format: []const u8, args: anytype) InnerError {
@setCold(true);
const err_msg = try Compilation.ErrorMsg.create(self.gpa, src, format, args);

387
src/codegen/c.zig
View File

@@ -12,7 +12,7 @@ const C = link.File.C;
const Decl = Module.Decl;
const mem = std.mem;
const indentation = " ";
const Writer = std.ArrayList(u8).Writer;
/// Maps a name from Zig source to C. Currently, this will always give the same
/// output for any given input, sometimes resulting in broken identifiers.
@@ -20,43 +20,145 @@ fn map(allocator: *std.mem.Allocator, name: []const u8) ![]const u8 {
return allocator.dupe(u8, name);
}
fn renderType(ctx: *Context, header: *C.Header, writer: std.ArrayList(u8).Writer, T: Type) !void {
switch (T.zigTypeTag()) {
fn renderType(
ctx: *Context,
header: *C.Header,
writer: Writer,
t: Type,
) error{ OutOfMemory, AnalysisFail }!void {
switch (t.zigTypeTag()) {
.NoReturn => {
try writer.writeAll("zig_noreturn void");
},
.Void => try writer.writeAll("void"),
.Bool => try writer.writeAll("bool"),
.Int => {
if (T.tag() == .u8) {
header.need_stdint = true;
try writer.writeAll("uint8_t");
} else if (T.tag() == .u32) {
header.need_stdint = true;
try writer.writeAll("uint32_t");
} else if (T.tag() == .usize) {
header.need_stddef = true;
try writer.writeAll("size_t");
} else {
return ctx.fail(ctx.decl.src(), "TODO implement int type {}", .{T});
switch (t.tag()) {
.u8 => try writer.writeAll("uint8_t"),
.i8 => try writer.writeAll("int8_t"),
.u16 => try writer.writeAll("uint16_t"),
.i16 => try writer.writeAll("int16_t"),
.u32 => try writer.writeAll("uint32_t"),
.i32 => try writer.writeAll("int32_t"),
.u64 => try writer.writeAll("uint64_t"),
.i64 => try writer.writeAll("int64_t"),
.usize => try writer.writeAll("uintptr_t"),
.isize => try writer.writeAll("intptr_t"),
.c_short => try writer.writeAll("short"),
.c_ushort => try writer.writeAll("unsigned short"),
.c_int => try writer.writeAll("int"),
.c_uint => try writer.writeAll("unsigned int"),
.c_long => try writer.writeAll("long"),
.c_ulong => try writer.writeAll("unsigned long"),
.c_longlong => try writer.writeAll("long long"),
.c_ulonglong => try writer.writeAll("unsigned long long"),
.int_signed, .int_unsigned => {
const info = t.intInfo(ctx.target);
const sign_prefix = switch (info.signedness) {
.signed => "i",
.unsigned => "",
};
inline for (.{ 8, 16, 32, 64, 128 }) |nbits| {
if (info.bits <= nbits) {
try writer.print("{s}int{d}_t", .{ sign_prefix, nbits });
break;
}
} else {
return ctx.fail(ctx.decl.src(), "TODO: C backend: implement integer types larger than 128 bits", .{});
}
},
else => unreachable,
}
},
else => |e| return ctx.fail(ctx.decl.src(), "TODO implement type {}", .{e}),
}
}
fn renderValue(ctx: *Context, writer: std.ArrayList(u8).Writer, T: Type, val: Value) !void {
switch (T.zigTypeTag()) {
.Int => {
if (T.isSignedInt())
return writer.print("{}", .{val.toSignedInt()});
return writer.print("{}", .{val.toUnsignedInt()});
.Pointer => {
if (t.isSlice()) {
return ctx.fail(ctx.decl.src(), "TODO: C backend: implement slices", .{});
} else {
if (t.isConstPtr()) {
try writer.writeAll("const ");
}
if (t.isVolatilePtr()) {
try writer.writeAll("volatile ");
}
try renderType(ctx, header, writer, t.elemType());
try writer.writeAll(" *");
}
},
else => |e| return ctx.fail(ctx.decl.src(), "TODO implement value {}", .{e}),
.Array => {
try renderType(ctx, header, writer, t.elemType());
const sentinel_bit = @boolToInt(t.sentinel() != null);
const c_len = t.arrayLen() + sentinel_bit;
try writer.print("[{d}]", .{c_len});
},
else => |e| return ctx.fail(ctx.decl.src(), "TODO: C backend: implement type {s}", .{
@tagName(e),
}),
}
}
fn renderFunctionSignature(ctx: *Context, header: *C.Header, writer: std.ArrayList(u8).Writer, decl: *Decl) !void {
fn renderValue(
ctx: *Context,
writer: Writer,
t: Type,
val: Value,
) error{ OutOfMemory, AnalysisFail }!void {
switch (t.zigTypeTag()) {
.Int => {
if (t.isSignedInt())
return writer.print("{d}", .{val.toSignedInt()});
return writer.print("{d}", .{val.toUnsignedInt()});
},
.Pointer => switch (val.tag()) {
.undef, .zero => try writer.writeAll("0"),
.one => try writer.writeAll("1"),
.decl_ref => {
const decl_ref_payload = val.cast(Value.Payload.DeclRef).?;
try writer.print("&{s}", .{decl_ref_payload.decl.name});
},
.function => {
const payload = val.cast(Value.Payload.Function).?;
try writer.print("{s}", .{payload.func.owner_decl.name});
},
.extern_fn => {
const payload = val.cast(Value.Payload.ExternFn).?;
try writer.print("{s}", .{payload.decl.name});
},
else => |e| return ctx.fail(
ctx.decl.src(),
"TODO: C backend: implement Pointer value {s}",
.{@tagName(e)},
),
},
.Array => {
// TODO first try specific tag representations for more efficiency
// Fall back to inefficient generic implementation.
try writer.writeAll("{");
var index: usize = 0;
const len = t.arrayLen();
const elem_ty = t.elemType();
while (index < len) : (index += 1) {
if (index != 0) try writer.writeAll(",");
const elem_val = try val.elemValue(&ctx.arena.allocator, index);
try renderValue(ctx, writer, elem_ty, elem_val);
}
if (t.sentinel()) |sentinel_val| {
if (index != 0) try writer.writeAll(",");
try renderValue(ctx, writer, elem_ty, sentinel_val);
}
try writer.writeAll("}");
},
else => |e| return ctx.fail(ctx.decl.src(), "TODO: C backend: implement value {s}", .{
@tagName(e),
}),
}
}
fn renderFunctionSignature(
ctx: *Context,
header: *C.Header,
writer: Writer,
decl: *Decl,
) !void {
const tv = decl.typed_value.most_recent.typed_value;
try renderType(ctx, header, writer, tv.ty.fnReturnType());
// Use the child allocator directly, as we know the name can be freed before
@@ -81,27 +183,92 @@ fn renderFunctionSignature(ctx: *Context, header: *C.Header, writer: std.ArrayLi
}
pub fn generate(file: *C, decl: *Decl) !void {
switch (decl.typed_value.most_recent.typed_value.ty.zigTypeTag()) {
.Fn => try genFn(file, decl),
.Array => try genArray(file, decl),
else => |e| return file.fail(decl.src(), "TODO {}", .{e}),
const tv = decl.typed_value.most_recent.typed_value;
var arena = std.heap.ArenaAllocator.init(file.base.allocator);
defer arena.deinit();
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,
.target = file.base.options.target,
};
defer {
file.error_msg = ctx.error_msg;
ctx.deinit();
}
if (tv.val.cast(Value.Payload.Function)) |func_payload| {
const writer = file.main.writer();
try renderFunctionSignature(&ctx, &file.header, writer, decl);
try writer.writeAll(" {");
const func: *Module.Fn = func_payload.func;
const instructions = func.analysis.success.instructions;
if (instructions.len > 0) {
try writer.writeAll("\n");
for (instructions) |inst| {
const indent_size = 4;
const indent_level = 1;
try writer.writeByteNTimes(' ', indent_size * indent_level);
if (switch (inst.tag) {
.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, file, inst.castTag(.ret).?),
.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(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);
}
}
}
try writer.writeAll("}\n\n");
} else if (tv.val.tag() == .extern_fn) {
return; // handled when referenced
} else {
const writer = file.constants.writer();
try writer.writeAll("static ");
// TODO ask the Decl if it is const
// https://github.com/ziglang/zig/issues/7582
try renderType(&ctx, &file.header, writer, tv.ty);
try writer.print(" {s} = ", .{decl.name});
try renderValue(&ctx, writer, tv.ty, tv.val);
try writer.writeAll(";\n");
}
}
pub fn generateHeader(
arena: *std.heap.ArenaAllocator,
comp: *Compilation,
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);
var inst_map = std.AutoHashMap(*Inst, []u8).init(comp.gpa);
defer inst_map.deinit();
var arena = std.heap.ArenaAllocator.init(comp.gpa);
defer arena.deinit();
var ctx = Context{
.decl = decl,
.arena = arena,
.arena = &arena,
.inst_map = &inst_map,
.target = comp.getTarget(),
};
const writer = header.buf.writer();
renderFunctionSignature(&ctx, header, writer, decl) catch |err| {
@@ -116,24 +283,6 @@ pub fn generateHeader(
}
}
fn genArray(file: *C, decl: *Decl) !void {
const tv = decl.typed_value.most_recent.typed_value;
// TODO: prevent inline asm constants from being emitted
const name = try map(file.base.allocator, mem.span(decl.name));
defer file.base.allocator.free(name);
if (tv.val.cast(Value.Payload.Bytes)) |payload|
if (tv.ty.sentinel()) |sentinel|
if (sentinel.toUnsignedInt() == 0)
// TODO: static by default
try file.constants.writer().print("const char *const {} = \"{}\";\n", .{ name, payload.data })
else
return file.fail(decl.src(), "TODO byte arrays with non-zero sentinels", .{})
else
return file.fail(decl.src(), "TODO byte arrays without sentinels", .{})
else
return file.fail(decl.src(), "TODO non-byte arrays", .{});
}
const Context = struct {
decl: *Decl,
inst_map: *std.AutoHashMap(*Inst, []u8),
@@ -141,6 +290,7 @@ const Context = struct {
argdex: usize = 0,
unnamed_index: usize = 0,
error_msg: *Compilation.ErrorMsg = undefined,
target: std.Target,
fn resolveInst(self: *Context, inst: *Inst) ![]u8 {
if (inst.cast(Inst.Constant)) |const_inst| {
@@ -170,55 +320,6 @@ const Context = struct {
}
};
fn genFn(file: *C, decl: *Decl) !void {
const writer = file.main.writer();
const tv = decl.typed_value.most_recent.typed_value;
var arena = std.heap.ArenaAllocator.init(file.base.allocator);
defer arena.deinit();
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,
};
defer {
file.error_msg = ctx.error_msg;
ctx.deinit();
}
try renderFunctionSignature(&ctx, &file.header, writer, decl);
try writer.writeAll(" {");
const func: *Module.Fn = tv.val.cast(Value.Payload.Function).?.func;
const instructions = func.analysis.success.instructions;
if (instructions.len > 0) {
try writer.writeAll("\n");
for (instructions) |inst| {
if (switch (inst.tag) {
.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(file),
.arg => try genArg(&ctx),
.dbg_stmt => try genDbgStmt(&ctx, inst.castTag(.dbg_stmt).?),
.breakpoint => try genBreak(&ctx, inst.castTag(.breakpoint).?),
.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);
}
}
}
try writer.writeAll("}\n\n");
}
fn genArg(ctx: *Context) !?[]u8 {
const name = try std.fmt.allocPrint(&ctx.arena.allocator, "arg{}", .{ctx.argdex});
ctx.argdex += 1;
@@ -226,12 +327,24 @@ fn genArg(ctx: *Context) !?[]u8 {
}
fn genRetVoid(file: *C) !?[]u8 {
try file.main.writer().print(indentation ++ "return;\n", .{});
try file.main.writer().print("return;\n", .{});
return null;
}
fn genRet(ctx: *Context, inst: *Inst.UnOp) !?[]u8 {
return ctx.fail(ctx.decl.src(), "TODO return", .{});
fn genRet(ctx: *Context, file: *C, inst: *Inst.UnOp) !?[]u8 {
const writer = file.main.writer();
try writer.writeAll("return ");
try genValue(ctx, writer, inst.operand);
try writer.writeAll(";\n");
return null;
}
fn genValue(ctx: *Context, writer: Writer, inst: *Inst) !void {
if (inst.value()) |val| {
try renderValue(ctx, writer, inst.ty, val);
return;
}
return ctx.fail(ctx.decl.src(), "TODO: C backend: genValue for non-constant value", .{});
}
fn genIntCast(ctx: *Context, file: *C, inst: *Inst.UnOp) !?[]u8 {
@@ -241,7 +354,7 @@ fn genIntCast(ctx: *Context, file: *C, inst: *Inst.UnOp) !?[]u8 {
const writer = file.main.writer();
const name = try ctx.name();
const from = try ctx.resolveInst(inst.operand);
try writer.writeAll(indentation ++ "const ");
try writer.writeAll("const ");
try renderType(ctx, &file.header, writer, inst.base.ty);
try writer.print(" {} = (", .{name});
try renderType(ctx, &file.header, writer, inst.base.ty);
@@ -256,7 +369,7 @@ fn genBinOp(ctx: *Context, file: *C, inst: *Inst.BinOp, comptime operator: []con
const rhs = ctx.resolveInst(inst.rhs);
const writer = file.main.writer();
const name = try ctx.name();
try writer.writeAll(indentation ++ "const ");
try writer.writeAll("const ");
try renderType(ctx, &file.header, writer, inst.base.ty);
try writer.print(" {} = {} " ++ operator ++ " {};\n", .{ name, lhs, rhs });
return name;
@@ -265,41 +378,42 @@ fn genBinOp(ctx: *Context, file: *C, inst: *Inst.BinOp, comptime operator: []con
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| {
const target = func_val.func.owner_decl;
const target_ty = target.typed_value.most_recent.typed_value.ty;
const ret_ty = target_ty.fnReturnType().tag();
if (target_ty.fnReturnType().hasCodeGenBits() and inst.base.isUnused()) {
try writer.print("(void)", .{});
}
const tname = mem.spanZ(target.name);
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});
if (inst.args.len != 0) {
for (inst.args) |arg, i| {
if (i > 0) {
try writer.writeAll(", ");
}
if (arg.cast(Inst.Constant)) |con| {
try renderValue(ctx, writer, arg.ty, con.val);
} else {
const val = try ctx.resolveInst(arg);
try writer.print("{}", .{val});
}
const fn_decl = if (func_inst.val.cast(Value.Payload.ExternFn)) |extern_fn|
extern_fn.decl
else if (func_inst.val.cast(Value.Payload.Function)) |func_val|
func_val.func.owner_decl
else
unreachable;
const fn_ty = fn_decl.typed_value.most_recent.typed_value.ty;
const ret_ty = fn_ty.fnReturnType().tag();
if (fn_ty.fnReturnType().hasCodeGenBits() and inst.base.isUnused()) {
try writer.print("(void)", .{});
}
const fn_name = mem.spanZ(fn_decl.name);
if (file.called.get(fn_name) == null) {
try file.called.put(fn_name, void{});
try renderFunctionSignature(ctx, &file.header, header, fn_decl);
try header.writeAll(";\n");
}
try writer.print("{s}(", .{fn_name});
if (inst.args.len != 0) {
for (inst.args) |arg, i| {
if (i > 0) {
try writer.writeAll(", ");
}
if (arg.cast(Inst.Constant)) |con| {
try renderValue(ctx, writer, arg.ty, con.val);
} else {
const val = try ctx.resolveInst(arg);
try writer.print("{}", .{val});
}
}
try writer.writeAll(");\n");
} else {
return ctx.fail(ctx.decl.src(), "TODO non-function call target?", .{});
}
try writer.writeAll(");\n");
} else {
return ctx.fail(ctx.decl.src(), "TODO non-constant call inst?", .{});
return ctx.fail(ctx.decl.src(), "TODO: C backend: implement function pointers", .{});
}
return null;
}
@@ -315,13 +429,12 @@ fn genBreak(ctx: *Context, inst: *Inst.NoOp) !?[]u8 {
}
fn genUnreach(file: *C, inst: *Inst.NoOp) !?[]u8 {
try file.main.writer().writeAll(indentation ++ "zig_unreachable();\n");
try file.main.writer().writeAll("zig_unreachable();\n");
return null;
}
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];

16
src/link/C.zig
View File

@@ -15,8 +15,6 @@ pub const base_tag: File.Tag = .c;
pub const Header = struct {
buf: std.ArrayList(u8),
need_stddef: bool = false,
need_stdint: bool = false,
emit_loc: ?Compilation.EmitLoc,
pub fn init(allocator: *Allocator, emit_loc: ?Compilation.EmitLoc) Header {
@@ -31,20 +29,8 @@ pub const Header = struct {
defer tracy.end();
try writer.writeAll(@embedFile("cbe.h"));
var includes = false;
if (self.need_stddef) {
try writer.writeAll("#include <stddef.h>\n");
includes = true;
}
if (self.need_stdint) {
try writer.writeAll("#include <stdint.h>\n");
includes = true;
}
if (includes) {
try writer.writeByte('\n');
}
if (self.buf.items.len > 0) {
try writer.print("{}", .{self.buf.items});
try writer.print("{s}", .{self.buf.items});
}
}

4
src/link/cbe.h
View File

@@ -23,3 +23,7 @@
#define zig_unreachable()
#endif
#include <stdint.h>
#define int128_t __int128
#define uint128_t unsigned __int128

92
src/type.zig
View File

@@ -172,7 +172,15 @@ pub const Type = extern union {
const is_slice_b = isSlice(b);
if (is_slice_a != is_slice_b)
return false;
@panic("TODO implement more pointer Type equality comparison");
const ptr_size_a = ptrSize(a);
const ptr_size_b = ptrSize(b);
if (ptr_size_a != ptr_size_b)
return false;
std.debug.panic("TODO implement more pointer Type equality comparison: {} and {}", .{
a, b,
});
},
.Int => {
// Detect that e.g. u64 != usize, even if the bits match on a particular target.
@@ -1128,6 +1136,88 @@ pub const Type = extern union {
};
}
/// Asserts the `Type` is a pointer.
pub fn ptrSize(self: Type) std.builtin.TypeInfo.Pointer.Size {
return switch (self.tag()) {
.u8,
.i8,
.u16,
.i16,
.u32,
.i32,
.u64,
.i64,
.usize,
.isize,
.c_short,
.c_ushort,
.c_int,
.c_uint,
.c_long,
.c_ulong,
.c_longlong,
.c_ulonglong,
.c_longdouble,
.f16,
.f32,
.f64,
.f128,
.c_void,
.bool,
.void,
.type,
.anyerror,
.comptime_int,
.comptime_float,
.noreturn,
.@"null",
.@"undefined",
.array,
.array_sentinel,
.array_u8,
.array_u8_sentinel_0,
.fn_noreturn_no_args,
.fn_void_no_args,
.fn_naked_noreturn_no_args,
.fn_ccc_void_no_args,
.function,
.int_unsigned,
.int_signed,
.optional,
.optional_single_mut_pointer,
.optional_single_const_pointer,
.enum_literal,
.error_union,
.@"anyframe",
.anyframe_T,
.anyerror_void_error_union,
.error_set,
.error_set_single,
.empty_struct,
=> unreachable,
.const_slice,
.mut_slice,
.const_slice_u8,
=> .Slice,
.many_const_pointer,
.many_mut_pointer,
=> .Many,
.c_const_pointer,
.c_mut_pointer,
=> .C,
.single_const_pointer,
.single_mut_pointer,
.single_const_pointer_to_comptime_int,
=> .One,
.pointer => self.cast(Payload.Pointer).?.size,
};
}
pub fn isSlice(self: Type) bool {
return switch (self.tag()) {
.u8,

24
src/value.zig
View File

@@ -82,6 +82,7 @@ pub const Value = extern union {
int_big_positive,
int_big_negative,
function,
extern_fn,
variable,
ref_val,
decl_ref,
@@ -205,6 +206,7 @@ pub const Value = extern union {
@panic("TODO implement copying of big ints");
},
.function => return self.copyPayloadShallow(allocator, Payload.Function),
.extern_fn => return self.copyPayloadShallow(allocator, Payload.ExternFn),
.variable => return self.copyPayloadShallow(allocator, Payload.Variable),
.ref_val => {
const payload = @fieldParentPtr(Payload.RefVal, "base", self.ptr_otherwise);
@@ -337,6 +339,7 @@ pub const Value = extern union {
.int_big_positive => return out_stream.print("{}", .{val.cast(Payload.IntBigPositive).?.asBigInt()}),
.int_big_negative => return out_stream.print("{}", .{val.cast(Payload.IntBigNegative).?.asBigInt()}),
.function => return out_stream.writeAll("(function)"),
.extern_fn => return out_stream.writeAll("(extern function)"),
.variable => return out_stream.writeAll("(variable)"),
.ref_val => {
const ref_val = val.cast(Payload.RefVal).?;
@@ -468,6 +471,7 @@ pub const Value = extern union {
.int_big_positive,
.int_big_negative,
.function,
.extern_fn,
.variable,
.ref_val,
.decl_ref,
@@ -533,6 +537,7 @@ pub const Value = extern union {
.anyframe_type,
.null_value,
.function,
.extern_fn,
.variable,
.ref_val,
.decl_ref,
@@ -617,6 +622,7 @@ pub const Value = extern union {
.anyframe_type,
.null_value,
.function,
.extern_fn,
.variable,
.ref_val,
.decl_ref,
@@ -701,6 +707,7 @@ pub const Value = extern union {
.anyframe_type,
.null_value,
.function,
.extern_fn,
.variable,
.ref_val,
.decl_ref,
@@ -812,6 +819,7 @@ pub const Value = extern union {
.anyframe_type,
.null_value,
.function,
.extern_fn,
.variable,
.ref_val,
.decl_ref,
@@ -901,6 +909,7 @@ pub const Value = extern union {
.anyframe_type,
.null_value,
.function,
.extern_fn,
.variable,
.ref_val,
.decl_ref,
@@ -1071,6 +1080,7 @@ pub const Value = extern union {
.bool_false,
.null_value,
.function,
.extern_fn,
.variable,
.ref_val,
.decl_ref,
@@ -1150,6 +1160,7 @@ pub const Value = extern union {
.anyframe_type,
.null_value,
.function,
.extern_fn,
.variable,
.ref_val,
.decl_ref,
@@ -1383,6 +1394,10 @@ pub const Value = extern union {
const payload = @fieldParentPtr(Payload.Function, "base", self.ptr_otherwise);
std.hash.autoHash(&hasher, payload.func);
},
.extern_fn => {
const payload = @fieldParentPtr(Payload.ExternFn, "base", self.ptr_otherwise);
std.hash.autoHash(&hasher, payload.decl);
},
.variable => {
const payload = @fieldParentPtr(Payload.Variable, "base", self.ptr_otherwise);
std.hash.autoHash(&hasher, payload.variable);
@@ -1449,6 +1464,7 @@ pub const Value = extern union {
.bool_false,
.null_value,
.function,
.extern_fn,
.variable,
.int_u64,
.int_i64,
@@ -1533,6 +1549,7 @@ pub const Value = extern union {
.bool_false,
.null_value,
.function,
.extern_fn,
.variable,
.int_u64,
.int_i64,
@@ -1634,6 +1651,7 @@ pub const Value = extern union {
.bool_true,
.bool_false,
.function,
.extern_fn,
.variable,
.int_u64,
.int_i64,
@@ -1730,6 +1748,7 @@ pub const Value = extern union {
.bool_true,
.bool_false,
.function,
.extern_fn,
.variable,
.int_u64,
.int_i64,
@@ -1793,6 +1812,11 @@ pub const Value = extern union {
func: *Module.Fn,
};
pub const ExternFn = struct {
base: Payload = Payload{ .tag = .extern_fn },
decl: *Module.Decl,
};
pub const Variable = struct {
base: Payload = Payload{ .tag = .variable },
variable: *Module.Var,