Imbus/pluto
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Start using the zig build system

Browse source 
Start using zig build system
This commit is contained in:
Sam Tebbs 2019-04-30 10:43:40 +01:00 • committed by SamTebbs33
parent def383249e
commit 47f68ceb9c
5 changed files with 145 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

139
build.zig
View file

@ -1,43 +1,124 @@
// Zig version: 0.4.0
const Builder = @import("std").build.Builder;
const Step = @import("std").build.Step;
const builtin = @import("builtin");
const Array = @import("std").ArrayList;
const std = @import("std");
const ArrayList = std.ArrayList;
const warn = std.debug.warn;
const mem = std.mem;
const src_files = [][]const u8{"kernel/kmain"};
fn concat(allocator: *std.mem.Allocator, str: []const u8, str2: []const u8) !std.Buffer {
var b = try std.Buffer.init(allocator, str);
try b.append(str2);
return b;
}
pub fn build(b: *Builder) void {
const kernel_out_dir = "bin/kernel";
const kernel_src = "src/kernel/";
const debug = b.option(bool, "debug", "build with debug symbols / make qemu wait for a debug connection") orelse false;
var build_path = b.option([]const u8, "build-path", "path to build to") orelse "bin";
var src_path = b.option([]const u8, "source-path", "path to source") orelse "src";
var target = b.option([]const u8, "target", "target to build/run for") orelse "x86";
const builtin_target = if (mem.eql(u8, target, "x86")) builtin.Arch.i386 else unreachable;
var kernel = b.addExecutable("pluto.elf", kernel_src ++ "kmain.zig");
//kernel.addAssemblyFile(kernel_src ++ "start.s");
const iso_path = concat(b.allocator, build_path, "/pluto.iso") catch unreachable;
kernel.setOutputDir(kernel_out_dir);
kernel.setBuildMode(b.standardReleaseOptions());
kernel.setTarget(builtin.Arch.i386, builtin.Os.freestanding, builtin.Abi.gnu);
kernel.setLinkerScriptPath("link.ld");
var objects_steps = buildObjects(b, builtin_target, build_path, src_path);
var link_step = buildLink(b, builtin_target, build_path);
const iso_step = buildISO(b, build_path, iso_path.toSlice());
const run_objcopy = b.addSystemCommand([][]const u8 {
"objcopy", "-O", "binary", "-S", kernel.getOutputPath(), kernel_out_dir ++ "/pluto.bin",
for (objects_steps.toSlice()) |step| b.default_step.dependOn(step);
b.default_step.dependOn(link_step);
for (iso_step.toSlice()) |step| b.default_step.dependOn(step);
buildRun(b, builtin_target, build_path, iso_path.toSlice(), debug);
buildDebug(b);
buildTest(b, src_path);
}
fn buildTest(b: *Builder, src_path: []const u8) void {
const step = b.step("test", "Run all tests");
const src_path2 = concat(b.allocator, src_path, "/") catch unreachable;
for (src_files) |file| {
var file_src = concat(b.allocator, src_path2.toSlice(), file) catch unreachable;
file_src.append(".zig") catch unreachable;
const tst = b.addTest(file_src.toSlice());
step.dependOn(&tst.step);
}
}
fn buildDebug(b: *Builder) void {
const step = b.step("debug", "Debug with gdb");
const cmd = b.addSystemCommand([][]const u8{
"gdb",
"-ex",
"symbol-file bin/iso/boot/pluto.elf",
"-ex",
"target remote localhost:1234",
});
run_objcopy.step.dependOn(&kernel.step);
step.dependOn(&cmd.step);
}
b.default_step.dependOn(&run_objcopy.step);
fn buildRun(b: *Builder, target: builtin.Arch, build_path: []const u8, iso_path: []const u8, debug: bool) void {
const step = b.step("run", "Run with qemu");
const qemu = if (target == builtin.Arch.i386) "qemu-system-i386" else unreachable;
var qemu_flags = ArrayList([]const u8).init(b.allocator);
qemu_flags.appendSlice([][]const u8{
qemu,
"-cdrom",
iso_path,
"-boot",
"d",
"-serial",
"stdio",
}) catch unreachable;
if (debug)
qemu_flags.appendSlice([][]const u8{
"-s",
"-S",
}) catch unreachable;
const cmd = b.addSystemCommand(qemu_flags.toSlice());
step.dependOn(&cmd.step);
}
const run_qemu = b.addSystemCommand([][]const u8 {
"qemu-system-i386",
"-display", "curses",
"-kernel", kernel.getOutputPath(),
});
fn buildISO(b: *Builder, build_path: []const u8, iso_path: []const u8) ArrayList(*Step) {
const grub_build_path = concat(b.allocator, build_path, "/iso/boot/") catch unreachable;
const iso_dir_path = concat(b.allocator, build_path, "/iso") catch unreachable;
const grub_cmd = b.addSystemCommand([][]const u8{ "cp", "-r", "grub", grub_build_path.toSlice() });
const iso_cmd = b.addSystemCommand([][]const u8{ "grub-mkrescue", "-o", iso_path, iso_dir_path.toSlice() });
var steps = ArrayList(*Step).init(b.allocator);
steps.append(&grub_cmd.step) catch unreachable;
steps.append(&iso_cmd.step) catch unreachable;
return steps;
}
const run_qemu_debug = b.addSystemCommand([][]const u8 {
"qemu-system-i386",
"-display", "curses",
"-kernel", kernel.getOutputPath(),
"-s", "-S",
});
fn buildLink(b: *Builder, target: builtin.Arch, build_path: []const u8) *Step {
const exec = b.addExecutable("pluto.elf", null);
const elf_path = concat(b.allocator, build_path, "/iso/boot") catch unreachable;
exec.setOutputDir(elf_path.toSlice());
exec.setLinkerScriptPath("link.ld");
exec.setTarget(target, builtin.Os.freestanding, builtin.Abi.gnu);
for (src_files) |file| {
var file_obj = concat(b.allocator, build_path, "/") catch unreachable;
file_obj.append(file) catch unreachable;
file_obj.append(".o") catch unreachable;
exec.addObjectFile(file_obj.toSlice());
}
return &exec.step;
}
run_qemu.step.dependOn(&kernel.step);
//run_qemu_debug.step.dependOn(&kernel.step);
b.default_step.dependOn(&run_qemu.step);
}
fn buildObjects(b: *Builder, target: builtin.Arch, build_path: []const u8, src_path: []const u8) ArrayList(*Step) {
var objects = ArrayList(*Step).init(b.allocator);
const src_path2 = concat(b.allocator, src_path, "/") catch unreachable;
for (src_files) |file| {
var file_src = concat(b.allocator, src_path2.toSlice(), file) catch unreachable;
file_src.append(".zig") catch unreachable;
const obj = b.addObject(file, file_src.toSlice());
obj.setOutputDir(build_path);
obj.setTarget(target, builtin.Os.freestanding, builtin.Abi.gnu);
objects.append(&obj.step) catch unreachable;
}
return objects;
}