dainboot: building

Working? No idea.

Makefile

@@ -37,6 +37,8 @@ QEMU_ARGS := \
 # qemu-system-riscv64: FDT: Failed to create subnode /fw-cfg@10100000: FDT_ERR_EXISTS
 QEMU_DTB_ARGS :=
 EFI_BOOTLOADER_NAME := BOOTRISCV64
+else
+$(error ARCH must be set to arm64 or riscv64)
 endif
 
 QEMU_ACCEL := tcg

common/dbuild.zig

@@ -1,7 +1,9 @@
 const std = @import("std");
 const build = std.build;
 
-usingnamespace @import("dcommon.zig");
+const dcommon = @import("dcommon.zig");
+const Arch = dcommon.Arch;
+const Board = dcommon.Board;
 
 pub fn getBoard(b: *build.Builder) !Board {
     return b.option(Board, "board", "Target board.") orelse
@@ -47,15 +49,18 @@ pub fn efiTagFor(cpu_arch: std.Target.Cpu.Arch) []const u8 {
     };
 }
 
-pub fn addBuildOptions(b: *build.Builder, exe: *build.LibExeObjStep, board: Board) !void {
-    exe.addBuildOption([:0]const u8, "version", try b.allocator.dupeZ(u8, try getVersion(b)));
-    exe.addBuildOption([:0]const u8, "board", try b.allocator.dupeZ(u8, @tagName(board)));
+pub fn addBuildOptions(b: *build.Builder, exe: *build.CompileStep, board: Board) !void {
+    const options = b.addOptions();
+    options.addOption([]const u8, "version", try b.allocator.dupe(u8, try getVersion(b)));
+    options.addOption([]const u8, "board", try b.allocator.dupe(u8, @tagName(board)));
+    exe.addOptions("build_options", options);
 }
 
 // adapted from Zig's own build.zig:
 // https://github.com/ziglang/zig/blob/a021c7b1b2428ecda85e79e281d43fa1c92f8c94/build.zig#L140-L188
 fn getVersion(b: *build.Builder) ![]u8 {
-    const version_string = b.fmt("{d}.{d}.{d}", .{ daintree_version.major, daintree_version.minor, daintree_version.patch });
+    const version = dcommon.version;
+    const version_string = b.fmt("{d}.{d}.{d}", .{ version.major, version.minor, version.patch });
 
     var code: u8 = undefined;
     const git_describe_untrimmed = b.execAllowFail(&[_][]const u8{
@@ -76,14 +81,14 @@ fn getVersion(b: *build.Builder) ![]u8 {
         },
         2 => {
             // Untagged development build (e.g. 0.7.0-684-gbbe2cca1a).
-            var it = std.mem.split(git_describe, "-");
+            var it = std.mem.split(u8, git_describe, "-");
             const tagged_ancestor = it.next() orelse unreachable;
             const commit_height = it.next() orelse unreachable;
             const commit_id = it.next() orelse unreachable;
 
             const ancestor_ver = try std.builtin.Version.parse(tagged_ancestor);
-            if (daintree_version.order(ancestor_ver) != .gt) {
-                std.debug.print("Daintree version '{}' must be greater than tagged ancestor '{}'\n", .{ daintree_version, ancestor_ver });
+            if (version.order(ancestor_ver) != .gt) {
+                std.debug.print("Daintree version '{}' must be greater than tagged ancestor '{}'\n", .{ version, ancestor_ver });
                 std.process.exit(1);
             }
 

common/dcommon.zig

@@ -1,13 +1,14 @@
 const std = @import("std");
+const builtin = @import("builtin");
 
-pub const daintree_version = std.builtin.Version{ .major = 0, .minor = 0, .patch = 2 };
+pub const version = std.builtin.Version{ .major = 0, .minor = 0, .patch = 2 };
 
 pub const Arch = enum {
     arm64,
     riscv64,
 };
 
-pub const daintree_arch: Arch = switch (std.builtin.target.cpu.arch) {
+pub const daintree_arch: Arch = switch (builtin.target.cpu.arch) {
     .aarch64 => .arm64,
     .riscv64 => .riscv64,
     else => @panic("unsupported arch"),

common/ddtb.zig

@@ -30,8 +30,8 @@ pub fn searchForUart(dtb: []const u8) Error!Uart {
     var address_cells: ?u32 = null;
     var size_cells: ?u32 = null;
 
-    var ev = try traverser.next();
-    while (ev != .End) : (ev = try traverser.next()) {
+    var ev = try traverser.event();
+    while (ev != .End) : (ev = try traverser.event()) {
         if (!in_node) {
             switch (ev) {
                 .BeginNode => |name| {

dainboot/build.zig

@@ -1,10 +1,10 @@
 const std = @import("std");
-const Builder = std.build.Builder;
+const Build = std.Build;
 
 const dbuild = @import("src/common/dbuild.zig");
 const dcommon = @import("src/common/dcommon.zig");
 
-pub fn build(b: *Builder) !void {
+pub fn build(b: *Build) !void {
     const board = try dbuild.getBoard(b);
     var target = dbuild.crossTargetFor(board);
     target.os_tag = .uefi;
@@ -14,29 +14,45 @@ pub fn build(b: *Builder) !void {
         return;
     }
 
-    const exe = b.addExecutable(bootName(b, board, target), "src/dainboot.zig");
-    exe.setTarget(target);
-    exe.setBuildMode(b.standardReleaseOptions());
+    const exe = b.addExecutable(.{
+        .name = bootName(b, board, target),
+        .root_source_file = .{ .path = "src/dainboot.zig" },
+        .target = target,
+        .optimize = b.standardOptimizeOption(.{}),
+    });
     try dbuild.addBuildOptions(b, exe, board);
-    exe.addPackagePath("dtb", "../dtb/src/dtb.zig");
+    b.addModule(.{
+        .name = "dtb",
+        .source_file = .{ .path = "../dtb/src/dtb.zig" },
+    });
+    exe.addModule("dtb", b.modules.get("dtb").?);
+
     exe.install();
 
     b.default_step.dependOn(&exe.step);
 }
 
-fn buildRiscv64(b: *Builder, board: dcommon.Board, target: std.zig.CrossTarget) !void {
-    const crt0 = b.addAssemble("crt0-efi-riscv64", "src/crt0-efi-riscv64.S");
-    crt0.setTarget(std.zig.CrossTarget{
-        .cpu_arch = target.cpu_arch,
-        .os_tag = .freestanding,
+fn buildRiscv64(b: *Build, board: dcommon.Board, target: std.zig.CrossTarget) !void {
+    const crt0 = b.addAssembly(.{
+        .name = "crt0-efi-riscv64",
+        .source_file = .{ .path = "src/crt0-efi-riscv64.S" },
+        .target = .{
+            .cpu_arch = target.cpu_arch,
+            .os_tag = .freestanding,
+        },
+        .optimize = b.standardOptimizeOption(.{}),
     });
-    crt0.setBuildMode(b.standardReleaseOptions());
 
-    const obj = b.addObject(bootName(b, board, target), "src/dainboot.zig");
-    obj.setTarget(target);
-    obj.setBuildMode(b.standardReleaseOptions());
+    const obj = b.addObject(.{
+        .name = bootName(b, board, target),
+        .root_source_file = .{ .path = "src/dainboot.zig" },
+        .target = target,
+        .optimize = b.standardOptimizeOption(.{}),
+    });
     try dbuild.addBuildOptions(b, obj, board);
-    obj.addPackagePath("dtb", "../dtb/src/dtb.zig");
+
+    const dtb_pkg = b.dependency("dtb", .{});
+    obj.addModule("dtb", dtb_pkg.module("dbt"));
 
     const combined = b.addSystemCommand(&.{
         "ld.lld",
@@ -87,6 +103,6 @@ fn buildRiscv64(b: *Builder, board: dcommon.Board, target: std.zig.CrossTarget)
     b.default_step.dependOn(&efi.step);
 }
 
-fn bootName(b: *Builder, board: dcommon.Board, target: std.zig.CrossTarget) []const u8 {
+fn bootName(b: *Build, board: dcommon.Board, target: std.zig.CrossTarget) []const u8 {
     return b.fmt("BOOT{s}.{s}", .{ dbuild.efiTagFor(target.cpu_arch.?), @tagName(board) });
 }

dainboot/build.zig.zon

@@ -0,0 +1,4 @@
+.{
+    .name = "dainboot",
+    .version = "0.0.0",
+}

dainboot/src/arch.zig

@@ -1,3 +1,6 @@
 const dcommon = @import("common/dcommon.zig");
 
-pub usingnamespace @import(@tagName(dcommon.daintree_arch) ++ ".zig");
+pub usingnamespace switch (dcommon.daintree_arch) {
+    .arm64 => @import("arm64.zig"),
+    .riscv64 => @import("riscv64.zig"),
+};