feat: init yaz, lz10, lz11 decompressors + darc + make cxi!

* compress: init generic lz decompressor + yaz, lz10 and lz11
  specializations
* horizon/fmt: init audio and archive
* hardware: init cpu
* tools/Compress: init Yaz, Lz10 and Lz11
* tools/Archive: init Darc
* tools/Ncch: init `make cxi`
* build: init MakeFirm

* all: zig fmt, general fixes

Author: GasInfinity

.github/workflows/release-tag.yaml

@@ -18,8 +18,8 @@ jobs:
         with:
           version: 0.15.2 
 
-      - name: Build
-        run: zig build -Drelease
+      - name: Build Release
+        run: zig build release -Doptimize=ReleaseSafe
 
       - name: Package artifacts
         working-directory: zig-out

README.md

@@ -116,12 +116,18 @@ You can (and are encouraged) to look at the `tools` directory as it is a good ex
     - 🟢 Disassemble: Outputs **Z**itrus**P**ica**A**sse**m**bly. Either RAW instructions, ZPSH's or DVL's (.shbin) can be disassembled.
 - 🟢 Firm (tools/Firm): Make / Info / Dump
     - 🟢 Make: Confirmed to build (and boot!) Luma3DS from source, however needs more testing as the firm is not 1:1.
-- 🟡 Ncch (tools/Ncch): Dump (/ Info)
+- 🟡 Ncch (tools/Ncch): Make CXI / Dump / Info
     - 🟢 ExeFS (tools/ExeFs): Make / List / Dump
     - 🟢 RomFS (tools/RomFs): Make / List / Dump
-- 🟡 LZrev (tools/LzRev): Decompression
+- 🟡 Compression (tools/Compress):
+    - 🟡 LZrev (Compress/LzRev): Decompression
+    - 🟡 Yaz0 (Compress/Yaz): Decompression
+    - 🟡 LZ10 (Compress/Lz10): Decompression
+    - 🟡 LZ11 (Compress/Lz11): Decompression
+- 🟡 Archives:
+    - 🟡 Darc (Archive/Darc): List
+    - 🔴 Sarc
 - 🔴 Cro0 / Crr0
-- 🔴 Arc / Bcma / SArc / Etc
 - 🔴 Cia
 
 ## Horizon

build.zig

@@ -1,5 +1,6 @@
 pub const version = "0.0.0-pre1";
 
+pub const MakeFirm = @import("build/MakeFirm.zig");
 pub const Make3dsx = @import("build/Make3dsx.zig");
 pub const MakeSmdh = @import("build/MakeSmdh.zig");
 pub const MakeRomFs = @import("build/MakeRomFs.zig");
@@ -47,8 +48,6 @@ pub const target = struct {
 };
 
 pub fn build(b: *Build) void {
-    const release = b.option(bool, "release", "Perform a release build") orelse false;
-
     const optimize = b.standardOptimizeOption(.{});
     const tools_target = b.standardTargetOptions(.{});
 
@@ -79,10 +78,7 @@ pub fn build(b: *Build) void {
 
     zitrus.addImport("zitrus", zitrus);
 
-    if (release) {
-        buildReleases(b, config, zdap, zigimg, zitrus);
-        return;
-    }
+    makeReleaseStep(b, optimize, config, zdap, zigimg, zitrus);
 
     // XXX: Yes, this is really needed for each target / optimize...
     const zitrus_lib = b.addLibrary(.{
@@ -147,22 +143,32 @@ pub fn build(b: *Build) void {
 }
 
 const release_targets: []const std.Target.Query = &.{
+    // Everyone is welcome to the party!
+    // NOTE: Even if your platform is not included here it may be supported if zig supports it.
     .{ .cpu_arch = .x86, .os_tag = .linux },
     .{ .cpu_arch = .x86, .os_tag = .windows },
+    .{ .cpu_arch = .x86, .os_tag = .netbsd },
     .{ .cpu_arch = .x86_64, .os_tag = .linux },
     .{ .cpu_arch = .x86_64, .os_tag = .windows },
     .{ .cpu_arch = .x86_64, .os_tag = .macos },
     .{ .cpu_arch = .x86_64, .os_tag = .freebsd },
+    .{ .cpu_arch = .x86_64, .os_tag = .netbsd },
+    .{ .cpu_arch = .arm, .os_tag = .linux },
+    .{ .cpu_arch = .arm, .os_tag = .freebsd },
+    .{ .cpu_arch = .arm, .os_tag = .netbsd },
     .{ .cpu_arch = .aarch64, .os_tag = .linux },
     .{ .cpu_arch = .aarch64, .os_tag = .windows },
     .{ .cpu_arch = .aarch64, .os_tag = .macos },
     .{ .cpu_arch = .aarch64, .os_tag = .freebsd },
+    .{ .cpu_arch = .aarch64, .os_tag = .netbsd },
     .{ .cpu_arch = .riscv64, .os_tag = .linux },
 };
 
-fn buildReleases(b: *Build, config: *Build.Step.Options, zdap: *Build.Module, zigimg: *Build.Module, zitrus: *Build.Module) void {
+fn makeReleaseStep(b: *Build, optimize: std.builtin.OptimizeMode, config: *Build.Step.Options, zdap: *Build.Module, zigimg: *Build.Module, zitrus: *Build.Module) void {
+    const release_step = b.step("release", "Perform a release build");
+
     for (release_targets) |release_target| {
-        _, const tools = buildTools(b, config, .ReleaseSafe, b.resolveTargetQuery(release_target), zdap, zigimg, zitrus);
+        _, const tools = buildTools(b, config, optimize, b.resolveTargetQuery(release_target), zdap, zigimg, zitrus);
 
         tools.root_module.strip = true;
 
@@ -174,7 +180,7 @@ fn buildReleases(b: *Build, config: *Build.Step.Options, zdap: *Build.Module, zi
             },
         });
 
-        b.getInstallStep().dependOn(&tools_output.step);
+        release_step.dependOn(&tools_output.step);
     }
 }
 

build/MakeFirm.zig

@@ -0,0 +1,120 @@
+//! A wrapper to simplify making a FIRM with the build system.
+
+pub const Options = struct {
+    pub const CopyMethod = enum { ndma, xdma, memcpy };
+    pub const Section = union(enum) {
+        pub const Binary = struct {
+            path: Build.LazyPath,
+            address: u32,
+            method: CopyMethod,
+        };
+
+        pub const Executable = struct {
+            exe: *Build.Step.Compile,
+            method: CopyMethod,
+        };
+
+        none,
+        binary: Binary,
+        executable: Executable,
+
+        pub fn bin(path: Build.LazyPath, address: u32, method: CopyMethod) Section {
+            return .{ .binary = .{ .path = path, .address = address, .method = method } };
+        }
+
+        pub fn exe(artifact: *Build.Step.Compile, method: CopyMethod) Section {
+            return .{ .executable = .{ .exe = artifact, .method = method } };
+        }
+    };
+
+    name: []const u8,
+    arm9: Section.Executable,
+    arm11: Section.Executable,
+    boot_priority: u32 = 0,
+    extra: [2]Section = .{ .none, .none },
+};
+
+pub const Config = struct {
+    tools_artifact: *Build.Step.Compile,
+};
+
+pub const InstallOptions = struct {
+    pub const default: InstallOptions = .{ .install_dir = .bin, .dest_sub_path = null };
+
+    /// Which installation directory to put the main output file into.
+    install_dir: Build.InstallDir = .bin,
+
+    /// If non-null, adds additional path components relative to bin dir, and
+    /// overrides the basename of the Compile step for installation purposes.
+    dest_sub_path: ?[]const u8 = null,
+};
+
+name: []const u8,
+
+/// The underlying `Build.Step.Run` which makes the FIRM.
+run: *Build.Step.Run,
+
+/// The generated FIRM file by zitrus. You are encouraged to use this
+/// directly.
+out: Build.LazyPath,
+
+pub fn init(zitrus_dep: *Build.Dependency, options: Options) MakeFirm {
+    return initInner(zitrus_dep.builder, .{
+        .tools_artifact = zitrus_dep.artifact("zitrus"),
+    }, options);
+}
+
+/// This is intended to be used by **zitrus** itself,
+/// prefer `init` instead.
+pub fn initInner(b: *Build, config: Config, options: Options) MakeFirm {
+    const make = b.addRunArtifact(config.tools_artifact);
+    make.setName(b.fmt("make firm ({s})", .{options.name}));
+    make.addArgs(&.{ "firm", "make" });
+
+    const Cpu = enum { arm9, arm11 };
+    const entries: []const Options.Section.Executable = &.{ options.arm9, options.arm11 };
+
+    for (entries, std.enums.values(Cpu)) |entry, cpu| {
+        make.addArg("--elf");
+        make.addArtifactArg(entry.exe);
+        make.addArg(@tagName(cpu));
+        make.addArg(@tagName(entry.method));
+    }
+
+    for (&options.extra) |extra| switch (extra) {
+        .none => {},
+        .binary => |bin| {
+            make.addArg("--section");
+            make.addFileArg(bin.path);
+            make.addArg(b.fmt("0x{X:0>8}", .{bin.address}));
+            make.addArg(@tagName(bin.method));
+        },
+        .executable => |exe| {
+            make.addArg("--elf");
+            make.addArtifactArg(exe.exe);
+            make.addArg("raw");
+            make.addArg(@tagName(exe.method));
+        },
+    };
+
+    make.addArg("--output");
+    const out = make.addOutputFileArg(options.name);
+
+    return .{
+        .name = options.name,
+        .run = make,
+        .out = out,
+    };
+}
+
+pub fn install(make: MakeFirm, b: *Build, options: InstallOptions) void {
+    const dest_sub_path = options.dest_sub_path orelse make.name;
+    const install_firm = b.addInstallFileWithDir(make.out, options.install_dir, dest_sub_path);
+
+    b.getInstallStep().dependOn(&install_firm.step);
+}
+
+const MakeFirm = @This();
+
+const std = @import("std");
+const Build = std.Build;

build/ld/arm-3ds.ld

@@ -1,4 +1,5 @@
 /* 
+* Good sources:
 * https://sourceware.org/binutils/docs/ld/Scripts.html
 * https://gabi.xinuos.com/elf/
 **/
@@ -36,7 +37,7 @@ SECTIONS
 	. = ALIGN(0x1000);
 	.text : {
 		KEEP(*(.text.base))
-		ASSERT(SIZEOF(.prm) == 0 || SIZEOF(.prm) > 0 && SIZEOF(.text.base) == 4, "When embedding/using program metadata, the first and only instruction in `_start` must be a branch to a function");
+		ASSERT(SIZEOF(.prm) == 0 || (SIZEOF(.prm) > 0 && SIZEOF(.text.base) == 4), "When embedding/using program metadata, the first and only instruction in `_start` must be a branch to a function");
 		*(.prm)
 
 		*(.text*)

src/compress.zig

@@ -1,5 +1,12 @@
+pub const lz = @import("compress/lz.zig");
+pub const yaz = @import("compress/yaz.zig");
+pub const lz10 = @import("compress/lz10.zig");
+pub const lz11 = @import("compress/lz11.zig");
 pub const lzrev = @import("compress/lzrev.zig");
 
 comptime {
     _ = lzrev;
+    _ = yaz;
+    _ = lz10;
+    _ = lz11;
 }