zig 0.12

Author: markfirmware

build.sh

@@ -1,12 +1,13 @@
 #!/bin/bash
 set -e
 
-echo zig version $(./zig/zig version)
-touch symbols.txt
-./zig/zig build
-llvm-objdump-6.0 --source -disassemble-all -section-headers -t  zig-cache/bin/main > main.asm
-grep '^00000000.*:$' main.asm | sed 's/^00000000//' > symbols.txt
-./zig/zig build
+echo zig version $(zig version)
+#touch symbols.txt
+zig build
+echo missing llvm-objdump-6.0
+#llvm-objdump-14 --source -disassemble-all -section-headers -t  zig-out/bin/main > main.asm
+#grep '^00000000.*:$' main.asm | sed 's/^00000000//' > symbols.txt
+#zig build
 
 #ARCH=thumbv6m
 #SOURCE=$(ls mission0*.zig)
@@ -16,4 +17,5 @@ grep '^00000000.*:$' main.asm | sed 's/^00000000//' > symbols.txt
 #grep 'q[0-9].*#' asm.$ARCH | egrep -v '#(-|)(16|32|48|64|80|96|112|128)'
 #set -e
 
-ls -l zig-cache/bin/main.img symbols.txt
+# ls -l zig-out/bin/main.img symbols.txt
+ls -l zig-out/bin/main.img

build.zig

@@ -1,17 +1,16 @@
+// qemu working, real working, emit asm, symbol table, readme
+
 pub fn build(b: *std.build.Builder) !void {
     const display_option = b.option(bool, "display", "graphics display for qemu") orelse false;
-    const build_exe = b.addExecutable("main", "main.zig");
-    _ = buildExeDetails: {
-        build_exe.emit_asm = .emit;
-        build_exe.install();
-        build_exe.setBuildMode(b.standardReleaseOptions());
+    const build_exe = b.addExecutable(.{ .name = "main", .optimize = b.standardOptimizeOption(.{}), .root_source_file = .{ .path = "main.zig" }, .target = model.target });
+    _ = build_exe_details: {
+        //        build_exe.emit_asm = .emit;
         build_exe.setLinkerScriptPath(std.build.FileSource.relative("linker_script.ld"));
-        build_exe.setTarget(model.target);
         build_exe.link_function_sections = true;
-        break :buildExeDetails 0;
+        break :build_exe_details 0;
     };
-    const format_source = b.addFmt(&[_][]const u8{ "build.zig", "main.zig" });
-    const install_raw = b.addInstallRaw(build_exe, "main.img", std.build.InstallRawStep.CreateOptions{});
+    const format_source = b.addFmt(.{ .paths = &[_][]const u8{ "build.zig", "main.zig" } });
+    const install_raw = b.addInstallArtifact(build_exe, .{ .dest_sub_path = "main.img" });
     const make_hex_file = addCustomStep(b, MakeHexFileStep{ .input_name = "zig-out/bin/main.img", .output_name = "main.hex" });
     const run_qemu = b.addSystemCommand(&[_][]const u8{
         "qemu-system-arm",
@@ -25,27 +24,27 @@ pub fn build(b: *std.build.Builder) !void {
         if (display_option) "gtk" else "none",
     });
 
-    _ = declareDependencies: {
+    _ = declare_dependencies: {
         build_exe.step.dependOn(&format_source.step);
         install_raw.step.dependOn(&build_exe.step);
         make_hex_file.step.dependOn(&install_raw.step);
         run_qemu.step.dependOn(&install_raw.step);
-        break :declareDependencies 0;
+        break :declare_dependencies 0;
     };
 
-    _ = declareCommandLineSteps: {
-        b.step("make-hex", "make hex file to copy to device").dependOn(&make_hex_file.step);
+    _ = declare_command_line_steps: {
+        b.step("hex", "make hex file to copy to device").dependOn(&make_hex_file.step);
         b.step("qemu", "run in qemu").dependOn(&run_qemu.step);
         b.default_step.dependOn(&build_exe.step);
-        break :declareCommandLineSteps 0;
+        break :declare_command_line_steps 0;
     };
 }
 
 const MakeHexFileStep = struct {
     step: std.build.Step = undefined,
     input_name: []const u8,
     output_name: []const u8,
-    pub fn make(step: *std.build.Step) anyerror!void {
+    pub fn make(step: *std.build.Step, _: *std.Progress.Node) anyerror!void {
         const self = @fieldParentPtr(MakeHexFileStep, "step", step);
         const cwd = fs.cwd();
         const image = try cwd.openFile(self.input_name, fs.File.OpenFlags{});
@@ -61,9 +60,12 @@ const MakeHexFileStep = struct {
             }
             while (offset < n) {
                 if (offset % 0x10000 == 0) {
-                    try writeHexRecord(hex, 0, 0x04, &[_]u8{ @truncate(u8, offset >> 24), @truncate(u8, offset >> 16) });
+                    var two: [2]u8 = undefined;
+                    two[0] = @truncate(offset >> 24);
+                    two[1] = @truncate(offset >> 16);
+                    try writeHexRecord(hex, 0, 0x04, &two);
                 }
-                const i = std.math.min(hex_record_len, n - offset);
+                const i = @min(hex_record_len, n - offset);
                 try writeHexRecord(hex, offset % 0x10000, 0x00, read_buf[offset .. offset + i]);
                 offset += i;
             }
@@ -73,11 +75,11 @@ const MakeHexFileStep = struct {
     fn writeHexRecord(file: fs.File, offset: usize, code: u8, bytes: []u8) !void {
         var record_buf: [1 + 2 + 1 + hex_record_len + 1]u8 = undefined;
         var record: []u8 = record_buf[0 .. 1 + 2 + 1 + bytes.len + 1];
-        record[0] = @truncate(u8, bytes.len);
-        record[1] = @truncate(u8, offset >> 8);
-        record[2] = @truncate(u8, offset >> 0);
+        record[0] = @truncate(bytes.len);
+        record[1] = @truncate(offset >> 8);
+        record[2] = @truncate(offset >> 0);
         record[3] = code;
-        for (bytes) |b, i| {
+        for (0.., bytes) |i, b| {
             record[4 + i] = b;
         }
         var checksum: u8 = 0;
@@ -94,7 +96,13 @@ const MakeHexFileStep = struct {
 pub fn addCustomStep(self: *std.build.Builder, customStep: anytype) *@TypeOf(customStep) {
     var allocated = self.allocator.create(@TypeOf(customStep)) catch unreachable;
     allocated.* = customStep;
-    allocated.*.step = std.build.Step.init(.custom, @typeName(@TypeOf(customStep)), self.allocator, @TypeOf(customStep).make);
+    var options: std.build.Step.StepOptions = undefined;
+    options.id = .custom;
+    options.name = @typeName(@TypeOf(customStep));
+    options.owner = self;
+    options.makeFn = @TypeOf(customStep).make;
+    options.max_rss = 100 * 1024 * 1024;
+    allocated.*.step = std.build.Step.init(options);
     return allocated;
 }
 

main.zig

@@ -1,12 +1,21 @@
-export var vector_table linksection(".vector_table") = packed struct {
+export var vector_table linksection(".vector_table") = extern struct {
     initial_sp: u32 = model.memory.ram.stack_bottom,
     reset: EntryPoint = reset,
     system_exceptions: [14]EntryPoint = [1]EntryPoint{exception} ** 14,
     interrupts: [model.number_of_peripherals]EntryPoint = [1]EntryPoint{exception} ** model.number_of_peripherals,
-    const EntryPoint = fn () callconv(.C) noreturn;
+    const EntryPoint = *const fn () callconv(.C) noreturn;
 }{};
 
 fn reset() callconv(.C) noreturn {
+    model.memory.ram.prepare();
+    Uart.prepare();
+    log("https://github.com/markfirmware/zig-vector-table is running on a microbit!", .{});
+    while (true) {
+        Uart.update();
+    }
+}
+
+fn reset2() callconv(.C) noreturn {
     model.memory.ram.prepare();
     Uart.prepare();
     Timers[0].prepare();
@@ -46,8 +55,9 @@ fn exception() callconv(.C) noreturn {
     panicf("arm exception ipsr.isr_number {}", .{isr_number});
 }
 
-pub fn panic(message: []const u8, trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, trace: ?*std.builtin.StackTrace, status_code: ?usize) noreturn {
     _ = trace;
+    _ = status_code;
     panicf("panic(): {s}", .{message});
 }
 
@@ -70,7 +80,7 @@ const Ficr = struct {
     pub fn isQemu() bool {
         return deviceId() == 0x1234567800000003;
     }
-    pub const contents = @intToPtr(*[64]u32, 0x10000000);
+    pub const contents = @as(*[64]u32, @ptrFromInt(0x10000000));
 };
 
 const Gpio = struct {
@@ -94,19 +104,19 @@ const Gpio = struct {
 };
 
 const Peripheral = struct {
-    fn at(base: u32) type {
+    fn at(comptime base: u32) type {
         assert(base == 0xe000e000 or base == 0x50000000 or base & 0xfffe0fff == 0x40000000);
         return struct {
             const peripheral_id = base >> 12 & 0x1f;
             fn mmio(address: u32, comptime T: type) *align(4) volatile T {
-                return @intToPtr(*align(4) volatile T, address);
+                return @as(*align(4) volatile T, @ptrFromInt(address));
             }
             fn event(offset: u32) Event {
                 var e: Event = undefined;
                 e.address = base + offset;
                 return e;
             }
-            fn typedRegister(offset: u32, comptime the_layout: type) type {
+            fn typedRegister(comptime offset: u32, comptime the_layout: type) type {
                 return struct {
                     pub const layout = the_layout;
                     pub noinline fn read() layout {
@@ -117,7 +127,7 @@ const Peripheral = struct {
                     }
                 };
             }
-            fn register(offset: u32) type {
+            fn register(comptime offset: u32) type {
                 return typedRegister(offset, u32);
             }
             fn registerGroup(offsets: RegisterGroup) type {
@@ -277,19 +287,19 @@ pub const Pins = packed struct {
     }
     pub fn mask(self: Pins) u32 {
         assert(@sizeOf(Pins) == 4);
-        return @bitCast(u32, self);
+        return @bitCast(self);
     }
     pub fn maskUnion(self: Pins, other: Pins) Pins {
-        return @bitCast(Pins, self.mask() | other.mask());
+        return @bitCast(self.mask() | other.mask());
     }
     pub fn outRead(self: Pins) u32 {
-        return (@bitCast(u32, Gpio.registers.out.read()) & self.mask()) >> self.bitPosition(0);
+        return (@as(u32, @bitCast(Gpio.registers.out.read())) & self.mask()) >> self.bitPosition(0);
     }
     fn bitPosition(self: Pins, i: u32) u5 {
-        return @truncate(u5, @ctz(self.mask()) + i);
+        return @truncate(@ctz(self.mask()) + i);
     }
     pub fn read(self: Pins) u32 {
-        return (@bitCast(u32, Gpio.registers.in.read()) & self.mask()) >> self.bitPosition(0);
+        return (@as(u32, @bitCast(Gpio.registers.in.read())) & self.mask()) >> self.bitPosition(0);
     }
     pub fn set(self: Pins) void {
         Gpio.registers.out.set(self);
@@ -300,7 +310,7 @@ pub const Pins = packed struct {
     pub fn write(self: Pins, x: u32) void {
         var new = Gpio.registers.out.read().mask() & ~self.mask();
         new |= (x << self.bitPosition(0)) & self.mask();
-        Gpio.registers.out.write(@bitCast(Pins, new));
+        Gpio.registers.out.write(@bitCast(new));
     }
     pub fn writeWholeMask(self: Pins) void {
         Gpio.registers.out.write(self);
@@ -420,7 +430,7 @@ pub const TimeKeeper = struct {
 
 pub const Timers = [_]@TypeOf(Timer(0x40008000)){ Timer(0x40008000), Timer(0x40009000), Timer(0x4000a000) };
 
-fn Timer(base: u32) type {
+fn Timer(comptime base: u32) type {
     return struct {
         const max_width = if (base == 0x40008000) @as(u32, 32) else 16;
         const p = Peripheral.at(base);
@@ -505,7 +515,7 @@ const Uart = struct {
     var tx_queue: [3]u8 = undefined;
     var tx_queue_read: usize = undefined;
     var tx_queue_write: usize = undefined;
-    var updater: ?fn () void = undefined;
+    var updater: ?*fn () void = null;
     pub fn drainTx() void {
         while (tx_queue_read != tx_queue_write) {
             loadTxd();
@@ -531,9 +541,7 @@ const Uart = struct {
             registers.txd.write(tx_queue[tx_queue_read]);
             tx_queue_read = (tx_queue_read + 1) % tx_queue.len;
             tx_busy = true;
-            if (updater) |an_updater| {
-                an_updater();
-            }
+            updater.?();
         }
     }
     pub fn log(comptime fmt: []const u8, args: anytype) void {
@@ -567,7 +575,7 @@ const Uart = struct {
     }
     pub fn readByte() u8 {
         events.rx_ready.clearEvent();
-        return @truncate(u8, registers.rxd.read());
+        return @truncate(registers.rxd.read());
     }
 };
 

system_model.zig

@@ -14,12 +14,12 @@ pub const memory = struct {
         extern var _ram_data_initial_values: u8;
         pub fn prepare() void {
             const ram_bss = asSlice(&_ram_bss_start, &_ram_data_end);
-            std.mem.set(u8, ram_bss, 0);
+            @memset(ram_bss, 0);
             const ram_data = asSlice(&_ram_data_start, &_ram_data_end);
-            std.mem.copy(u8, ram_data, @ptrCast([*]u8, &_ram_data_initial_values)[0..ram_data.len]);
+            @memcpy(ram_data, @as([*]u8, @ptrCast(&_ram_data_initial_values))[0..ram_data.len]);
         }
         fn asSlice(start_ptr: *u8, end_ptr: *u8) []u8 {
-            return @ptrCast([*]u8, start_ptr)[0 .. @ptrToInt(end_ptr) - @ptrToInt(start_ptr)];
+            return @as([*]u8, @ptrCast(start_ptr))[0 .. @as(usize, @intFromPtr(end_ptr)) - @as(usize, @intFromPtr(start_ptr))];
         }
     };
 };