sylveos

build.zig (6811B)

---

 const std = @import("std");
 const builtin = @import("builtin");
 
 fn pi_zero_target(b: *std.Build) std.Build.ResolvedTarget {
     var cpu_features = std.Target.arm.cpu.arm1176jzf_s.features;
     cpu_features.addFeatureSet(std.Target.arm.featureSet(&[_]std.Target.arm.Feature{.strict_align}));
     cpu_features.removeFeatureSet(std.Target.arm.featureSet(&[_]std.Target.arm.Feature{.vfp2}));
 
     const query: std.Target.Query = .{
         .cpu_arch = .arm,
         .cpu_model = .{ .explicit = &std.Target.arm.cpu.arm1176jzf_s },
         .cpu_features_add = cpu_features,
         .os_tag = .freestanding,
         .abi = .eabi,
     };
 
     return b.resolveTargetQuery(query);
 }
 
 fn pi_module_opts(target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, path: ?std.Build.LazyPath) std.Build.Module.CreateOptions {
     return .{
         .root_source_file = path,
         .target = target,
         .optimize = optimize,
         .link_libc = false,
         .omit_frame_pointer = true,
         .single_threaded = true,
         .no_builtin = true,
         .pic = true,
     };
 }
 
 const BinaryMode = enum {
     Bootloader,
     Standalone,
     Bootable,
 };
 
 fn build_pi(
     b: *std.Build,
     target: std.Build.ResolvedTarget,
     optimize: std.builtin.OptimizeMode,
     name: []const u8,
     program_path: std.Build.LazyPath,
     default_mode: ?BinaryMode,
 ) !*std.Build.Module {
     const mode = default_mode orelse b.option(BinaryMode, "mode", "specify binary output mode") orelse .Bootable;
 
     const shared = b.createModule(pi_module_opts(target, optimize, b.path("shared/root.zig")));
 
     const pi = b.createModule(pi_module_opts(target, optimize, b.path("pi/root.zig")));
     pi.addImport("shared", shared);
     pi.addIncludePath(b.path("include/"));
     pi.addCSourceFile(.{ .file = b.path("include/emmc.c") });
     pi.addCSourceFile(.{ .file = b.path("include/pi-sd.c") });
 
     const program = b.createModule(pi_module_opts(target, optimize, program_path));
     program.addImport("shared", shared);
     program.addImport("pi", pi);
 
     // TODO; boot/root.zig could probably just read some config flag we pass down
     const boot_stub_path = switch (mode) {
         .Bootable => b.path("boot/bootable.zig"),
         .Bootloader => b.path("boot/bootloader.zig"),
         .Standalone => b.path("boot/standalone.zig"),
     };
     const boot_stub = b.createModule(pi_module_opts(target, optimize, boot_stub_path));
     boot_stub.addImport("shared", shared);
 
     const root = b.createModule(pi_module_opts(target, optimize, b.path("boot/root.zig")));
     root.addImport("shared", shared);
     root.addImport("boot", boot_stub);
     root.addImport("pi", pi);
 
     root.addImport("program", program);
 
     const exe_name = try std.fmt.allocPrint(b.allocator, "{s}.elf", .{name});
     defer b.allocator.free(exe_name);
 
     const exe = b.addExecutable(.{
         .name = exe_name,
         .linkage = .static,
         .root_module = root,
         .use_lld = true,
         .use_llvm = true,
     });
     exe.link_function_sections = true;
     exe.link_data_sections = true;
     exe.link_gc_sections = true;
     exe.lto = .full;
 
     exe.setLinkerScript(b.path("pi/linker.ld"));
     b.installArtifact(exe);
 
     const obj_copy = b.addObjCopy(exe.getEmittedBin(), .{
         .format = .bin,
     });
     obj_copy.step.dependOn(&exe.step);
 
     const bin_name = try std.fmt.allocPrint(b.allocator, "{s}.bin", .{name});
     defer b.allocator.free(bin_name);
 
     const install_bin = b.addInstallBinFile(obj_copy.getOutput(), bin_name);
     b.getInstallStep().dependOn(&install_bin.step);
 
     return program;
 }
 
 fn build_sylveos_vm(
     b: *std.Build,
     target: std.Build.ResolvedTarget,
     optimize: std.builtin.OptimizeMode,
 ) !*std.Build.Step.ObjCopy {
     const shared = b.createModule(pi_module_opts(target, optimize, b.path("shared/root.zig")));
     const pi = b.createModule(pi_module_opts(target, optimize, b.path("pi/root.zig")));
     pi.addImport("shared", shared);
     pi.addIncludePath(b.path("include/"));
     pi.addCSourceFile(.{ .file = b.path("include/emmc.c") });
     pi.addCSourceFile(.{ .file = b.path("include/pi-sd.c") });
 
     const root = b.createModule(pi_module_opts(target, optimize, b.path("sylveos/root.zig")));
     root.addImport("shared", shared);
     root.addImport("pi", pi);
 
     const exe = b.addExecutable(.{
         .name = "sylveos.elf",
         .linkage = .static,
         .root_module = root,
         .use_lld = true,
         .use_llvm = true,
     });
     exe.link_function_sections = true;
     exe.link_data_sections = true;
     exe.link_gc_sections = true;
     exe.lto = .full;
 
     exe.setLinkerScript(b.path("sylveos/linker.ld"));
     b.installArtifact(exe);
 
     const obj_copy = b.addObjCopy(exe.getEmittedBin(), .{
         .format = .bin,
     });
     obj_copy.step.dependOn(&exe.step);
 
     const install_bin = b.addInstallBinFile(obj_copy.getOutput(), "sylveos.bin");
     b.getInstallStep().dependOn(&install_bin.step);
 
     return obj_copy;
 }
 
 fn build_program(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, program: []const u8, mode: ?BinaryMode) !void {
     const program_name = try std.fmt.allocPrint(b.allocator, "programs/{s}.zig", .{program});
     defer b.allocator.free(program_name);
 
     _ = try build_pi(b, target, optimize, program, b.path(program_name), mode);
 }
 
 fn build_all_programs(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode) !void {
     const path = try b.path("programs").getPath3(b, null).toString(b.allocator);
     defer b.allocator.free(path);
 
     var dir = try std.fs.openDirAbsolute(path, .{ .access_sub_paths = false, .iterate = true });
     defer dir.close();
 
     var iter = dir.iterate();
     while (try iter.next()) |entry| {
         if (entry.kind != .file) continue;
         if (!std.mem.endsWith(u8, entry.name, ".zig")) continue;
         const name = entry.name[0..(entry.name.len - 4)];
 
         try build_program(b, target, optimize, name, .Bootable);
     }
 }
 
 pub fn build(b: *std.Build) !void {
     const pi_target = pi_zero_target(b);
     const optimize = b.standardOptimizeOption(.{ .preferred_optimize_mode = .ReleaseSafe });
 
     const program = b.option([]const u8, "program", "specify pi program") orelse {
         try build_all_programs(b, pi_target, optimize);
         _ = try build_pi(b, pi_target, optimize, "sylveos", b.path("sylveos/root.zig"), .Bootable);
 
         return;
     };
 
     if (std.mem.eql(u8, program, "sylveos-boot")) {
         _ = try build_pi(b, pi_target, optimize, "sylveos-boot", b.path("sylveos/boot.zig"), null);
     } else if (std.mem.eql(u8, program, "sylveos")) {
         _ = try build_sylveos_vm(b, pi_target, optimize);
     } else {
         try build_program(b, pi_target, optimize, program, null);
     }
 }