stage2: add extern functions

and improve the C backend enough to support Hello World (almost)

7 files changed, 452 insertions, 163 deletions

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 26beeccd9e..39dd97c3a2 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -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;
diff --git a/src/Module.zig b/src/Module.zig
index c0b7011f43..dbb845116a 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -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);
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 589e2f17e0..8d706f8735 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -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");
+            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,
+            }
+        },
+        .Pointer => {
+            if (t.isSlice()) {
+                return ctx.fail(ctx.decl.src(), "TODO: C backend: implement slices", .{});
             } else {
-                return ctx.fail(ctx.decl.src(), "TODO implement int type {}", .{T});
+                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 type {}", .{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 renderValue(ctx: *Context, writer: std.ArrayList(u8).Writer, T: Type, val: Value) !void {
-    switch (T.zigTypeTag()) {
+fn renderValue(
+    ctx: *Context,
+    writer: Writer,
+    t: Type,
+    val: Value,
+) error{ OutOfMemory, AnalysisFail }!void {
+    switch (t.zigTypeTag()) {
         .Int => {
-            if (T.isSignedInt())
-                return writer.print("{}", .{val.toSignedInt()});
-            return writer.print("{}", .{val.toUnsignedInt()});
+            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 implement value {}", .{e}),
+        else => |e| return ctx.fail(ctx.decl.src(), "TODO: C backend: implement value {s}", .{
+            @tagName(e),
+        }),
     }
 }
 
-fn renderFunctionSignature(ctx: *Context, header: *C.Header, writer: std.ArrayList(u8).Writer, decl: *Decl) !void {
+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];
diff --git a/src/link/C.zig b/src/link/C.zig
index 325f2ee048..62a350826e 100644
--- a/src/link/C.zig
+++ b/src/link/C.zig
@@ -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});
         }
     }
 
diff --git a/src/link/cbe.h b/src/link/cbe.h
index c3f889c6f1..cd37ba2f2e 100644
--- a/src/link/cbe.h
+++ b/src/link/cbe.h
@@ -23,3 +23,7 @@
 #define zig_unreachable()
 #endif
 
+#include <stdint.h>
+#define int128_t __int128
+#define uint128_t unsigned __int128
+
diff --git a/src/type.zig b/src/type.zig
index f3ca23014d..f08408738a 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -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,
diff --git a/src/value.zig b/src/value.zig
index 4271ae66f4..53c4b2d540 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -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,