building again wip; starting on dainboot.

.gitignore

@@ -4,6 +4,6 @@
 *.efi
 dainkrnl.riscv64
 dainkrnl.arm64
-zig-cache
+.zig-cache
 zig-out
 target/disk

common/dbuild.zig

@@ -1,11 +1,10 @@
 const std = @import("std");
-const build = std.build;
 
 const dcommon = @import("dcommon.zig");
 const Arch = dcommon.Arch;
 const Board = dcommon.Board;
 
-pub fn getBoard(b: *build.Builder) !Board {
+pub fn getBoard(b: *std.Build) !Board {
     return b.option(Board, "board", "Target board.") orelse
         error.UnknownBoard;
 }
@@ -17,7 +16,7 @@ pub fn getArch(board: Board) Arch {
     };
 }
 
-pub fn crossTargetFor(board: Board) std.zig.CrossTarget {
+pub fn queryFor(board: Board) std.Target.Query {
     switch (board) {
         .qemu_arm64, .rockpro64 => {
             var features = std.Target.Cpu.Feature.Set.empty;
@@ -26,7 +25,7 @@ pub fn crossTargetFor(board: Board) std.zig.CrossTarget {
             // function.  Can't seem to find a register setting (like in SCTLR_EL1
             // or something) that stops this happening.  Reproduced on both
             // QEMU and rockpro64 so giving up for now.
-            features.addFeature(@enumToInt(std.Target.aarch64.Feature.strict_align));
+            features.addFeature(@intFromEnum(std.Target.aarch64.Feature.strict_align));
 
             return .{
                 .cpu_arch = .aarch64,
@@ -49,21 +48,21 @@ pub fn efiTagFor(cpu_arch: std.Target.Cpu.Arch) []const u8 {
     };
 }
 
-pub fn addBuildOptions(b: *build.Builder, exe: *build.CompileStep, board: Board) !void {
+pub fn addBuildOptions(b: *std.Build, exe: *std.Build.Step.Compile, 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);
+    exe.root_module.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 {
+fn getVersion(b: *std.Build) ![]u8 {
     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{
+    const git_describe_untrimmed = b.runAllowFail(&[_][]const u8{
         "git", "-C", b.build_root.path orelse ".", "describe", "--match", "*.*.*", "--tags",
     }, &code, .Ignore) catch {
         return version_string;
@@ -86,7 +85,7 @@ fn getVersion(b: *build.Builder) ![]u8 {
             const commit_height = it.next() orelse unreachable;
             const commit_id = it.next() orelse unreachable;
 
-            const ancestor_ver = try std.builtin.Version.parse(tagged_ancestor);
+            const ancestor_ver = try std.SemanticVersion.parse(tagged_ancestor);
             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,7 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-pub const version = std.builtin.Version{ .major = 0, .minor = 0, .patch = 2 };
+pub const version = std.SemanticVersion{ .major = 0, .minor = 0, .patch = 2 };
 
 pub const Arch = enum {
     arm64,

common/ddtb.zig

@@ -63,7 +63,7 @@ pub fn searchForUart(dtb: []const u8) Error!Uart {
                 } else if (std.mem.eql(u8, prop.name, "compatible")) {
                     state.compatible = prop.value;
                 } else if (std.mem.eql(u8, prop.name, "reg-shift")) {
-                    state.reg_shift = @truncate(u4, readU32(prop.value));
+                    state.reg_shift = @as(u4, @truncate(readU32(prop.value)));
                 }
             },
             .BeginNode => in_node = false,
@@ -95,14 +95,16 @@ pub fn searchForUart(dtb: []const u8) Error!Uart {
 }
 
 fn readU32(value: []const u8) u32 {
-    return std.mem.bigToNative(u32, @ptrCast(*const u32, @alignCast(@alignOf(u32), value.ptr)).*);
+    // align to: @alignOf(u32)
+    return std.mem.bigToNative(u32, @as(*const u32, @ptrCast(@alignCast(value.ptr))).*);
 }
 
 fn firstReg(address_cells: u32, value: []const u8) !u64 {
     if (value.len % @sizeOf(u32) != 0) {
         return error.BadStructure;
     }
-    var big_endian_cells: []const u32 = @ptrCast([*]const u32, @alignCast(@alignOf(u32), value.ptr))[0 .. value.len / @sizeOf(u32)];
+    // align to: @alignOf(u32)
+    const big_endian_cells: []const u32 = @as([*]const u32, @ptrCast(@alignCast(value.ptr)))[0 .. value.len / @sizeOf(u32)];
     if (address_cells == 1) {
         return std.mem.bigToNative(u32, big_endian_cells[0]);
     } else if (address_cells == 2) {

dainboot/build.zig

@@ -1,61 +1,58 @@
 const std = @import("std");
-const Build = std.Build;
 
 const dbuild = @import("src/common/dbuild.zig");
 const dcommon = @import("src/common/dcommon.zig");
 
-pub fn build(b: *Build) !void {
+pub fn build(b: *std.Build) !void {
     const board = try dbuild.getBoard(b);
-    var target = dbuild.crossTargetFor(board);
-    target.os_tag = .uefi;
+    var targetQuery = dbuild.queryFor(board);
+    targetQuery.os_tag = .uefi;
+    const resolvedTarget = b.resolveTargetQuery(targetQuery);
 
-    if (target.cpu_arch.? == .riscv64) {
-        try buildRiscv64(b, board, target);
+    if (resolvedTarget.query.cpu_arch.? == .riscv64) {
+        try buildRiscv64(b, board, resolvedTarget);
         return;
     }
 
     const exe = b.addExecutable(.{
-        .name = bootName(b, board, target),
-        .root_source_file = .{ .path = "src/dainboot.zig" },
-        .target = target,
+        .name = bootName(b, board, resolvedTarget),
+        .root_source_file = b.path("src/dainboot.zig"),
+        .target = resolvedTarget,
         .optimize = b.standardOptimizeOption(.{}),
     });
     try dbuild.addBuildOptions(b, exe, board);
     const dtb = b.addModule("dtb", .{
-        .source_file = .{ .path = "../dtb/src/dtb.zig" },
+        .root_source_file = b.path("../dtb/src/dtb.zig"),
     });
-    exe.addModule("dtb", dtb);
+    exe.root_module.addImport("dtb", dtb);
 
     b.installArtifact(exe);
 
     b.default_step.dependOn(&exe.step);
 }
 
-fn buildRiscv64(b: *Build, board: dcommon.Board, target: std.zig.CrossTarget) !void {
+fn buildRiscv64(b: *std.Build, board: dcommon.Board, resolvedTarget: std.Build.ResolvedTarget) !void {
     const optimize = b.standardOptimizeOption(.{});
 
     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,
-        },
+        .source_file = b.path("src/crt0-efi-riscv64.S"),
+        .target = resolvedTarget, // .os_tag = .freestanding
         .optimize = optimize,
     });
 
     const obj = b.addObject(.{
-        .name = bootName(b, board, target),
-        .root_source_file = .{ .path = "src/dainboot.zig" },
-        .target = target,
+        .name = bootName(b, board, resolvedTarget),
+        .root_source_file = b.path("src/dainboot.zig"),
+        .target = resolvedTarget,
         .optimize = optimize,
     });
     try dbuild.addBuildOptions(b, obj, board);
 
     const dtb = b.addModule("dtb", .{
-        .source_file = .{ .path = "../dtb/src/dtb.zig" },
+        .root_source_file = b.path("../dtb/src/dtb.zig"),
     });
-    obj.addModule("dtb", dtb);
+    obj.root_module.addImport("dtb", dtb);
 
     const combined = b.addSystemCommand(&.{
         "ld.lld",
@@ -99,13 +96,13 @@ fn buildRiscv64(b: *Build, board: dcommon.Board, target: std.zig.CrossTarget) !v
         ".reloc",
         "--output-target=binary",
         "combined.o",
-        b.fmt("zig-out/bin/{s}.efi", .{bootName(b, board, target)}),
+        b.fmt("zig-out/bin/{s}.efi", .{bootName(b, board, resolvedTarget)}),
     });
     efi.step.dependOn(&combined.step);
 
     b.default_step.dependOn(&efi.step);
 }
 
-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) });
+fn bootName(b: *std.Build, board: dcommon.Board, resolvedTarget: std.Build.ResolvedTarget) []const u8 {
+    return b.fmt("BOOT{s}.{s}", .{ dbuild.efiTagFor(resolvedTarget.query.cpu_arch.?), @tagName(board) });
 }