Get esp examples building

Author: tact1m4n3

core/src/failing.zig

@@ -42,19 +42,15 @@ pub const panic = std.debug.FullPanic(struct {
     pub fn panic_fn(message: []const u8, first_trace_address: ?usize) noreturn {
         std.log.err("panic: {s}", .{message});
 
-        var frame_index: usize = 0;
-        if (@errorReturnTrace()) |trace| frame_index = utilities.dump_stack_trace(trace);
+        var error_trace_count: usize = 0;
+        if (@errorReturnTrace()) |trace| error_trace_count = utilities.dump_stack_trace(trace, 0);
 
         var addr_buf: [20]usize = undefined;
         var stacktrace = std.debug.captureCurrentStackTrace(.{
             .first_address = first_trace_address orelse @returnAddress(),
+            .allow_unsafe_unwind = true,
         }, &addr_buf);
-
-        _ = utilities.dump_stack_trace(&stacktrace);
-        //var iter = std.debug.StackIterator.init(first_trace_address orelse @returnAddress(), null);
-        //while (iter.next()) |address| : (frame_index += 1) {
-        //    std.log.err("{d: >3}: 0x{X:0>8}", .{ frame_index, address });
-        //}
+        _ = utilities.dump_stack_trace(&stacktrace, error_trace_count);
 
         // Attach a breakpoint. this might trigger another panic internally, so
         // only do that if requested.

core/src/microzig.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const builtin = @import("builtin");
 const microzig = @import("microzig");
 const app = @import("app");
+const failing = @import("failing.zig");
 
 // Use microzig panic handler if not defined by an application
 pub const panic = if (!@hasDecl(app, "panic")) microzig.panic else app.panic;
@@ -16,7 +17,7 @@ pub const std_options: std.Options = .{
     .logFn = microzig.options.logFn,
 };
 
-pub const std_options_debug_io: std.Io = nop();
+pub const std_options_debug_io: std.Io = failing.io;
 
 // Startup logic:
 comptime {
@@ -95,142 +96,3 @@ export fn microzig_main() noreturn {
     // Main returned, just hang around here a bit.
     microzig.hang();
 }
-
-fn nop() std.Io {
-    return .{
-        .userdata = null,
-        .vtable = &.{
-            .async = async,
-            .concurrent = concurrent,
-            .await = await,
-            .cancel = cancel,
-            .select = select,
-
-            .groupAsync = groupAsync,
-            .groupConcurrent = groupConcurrent,
-            .groupAwait = groupAwait,
-            .groupCancel = groupCancel,
-
-            .recancel = recancel,
-            .swapCancelProtection = swapCancelProtection,
-            .checkCancel = checkCancel,
-
-            .futexWait = futexWait,
-            .futexWaitUncancelable = futexWaitUncancelable,
-            .futexWake = futexWake,
-
-            .dirCreateDir = dirCreateDir,
-            .dirCreateDirPath = dirCreateDirPath,
-            .dirCreateDirPathOpen = dirCreateDirPathOpen,
-            .dirStat = dirStat,
-            .dirStatFile = dirStatFile,
-            .dirAccess = dirAccess,
-            .dirCreateFile = dirCreateFile,
-            .dirCreateFileAtomic = dirCreateFileAtomic,
-            .dirOpenFile = dirOpenFile,
-            .dirOpenDir = dirOpenDir,
-            .dirClose = dirClose,
-            .dirRead = dirRead,
-            .dirRealPath = dirRealPath,
-            .dirRealPathFile = dirRealPathFile,
-            .dirDeleteFile = dirDeleteFile,
-            .dirDeleteDir = dirDeleteDir,
-            .dirRename = dirRename,
-            .dirRenamePreserve = dirRenamePreserve,
-            .dirSymLink = dirSymLink,
-            .dirReadLink = dirReadLink,
-            .dirSetOwner = dirSetOwner,
-            .dirSetFileOwner = dirSetFileOwner,
-            .dirSetPermissions = dirSetPermissions,
-            .dirSetFilePermissions = dirSetFilePermissions,
-            .dirSetTimestamps = dirSetTimestamps,
-            .dirHardLink = dirHardLink,
-
-            .fileStat = fileStat,
-            .fileLength = fileLength,
-            .fileClose = fileClose,
-            .fileWriteStreaming = fileWriteStreaming,
-            .fileWritePositional = fileWritePositional,
-            .fileWriteFileStreaming = fileWriteFileStreaming,
-            .fileWriteFilePositional = fileWriteFilePositional,
-            .fileReadStreaming = fileReadStreaming,
-            .fileReadPositional = fileReadPositional,
-            .fileSeekBy = fileSeekBy,
-            .fileSeekTo = fileSeekTo,
-            .fileSync = fileSync,
-            .fileIsTty = fileIsTty,
-            .fileEnableAnsiEscapeCodes = fileEnableAnsiEscapeCodes,
-            .fileSupportsAnsiEscapeCodes = fileSupportsAnsiEscapeCodes,
-            .fileSetLength = fileSetLength,
-            .fileSetOwner = fileSetOwner,
-            .fileSetPermissions = fileSetPermissions,
-            .fileSetTimestamps = fileSetTimestamps,
-            .fileLock = fileLock,
-            .fileTryLock = fileTryLock,
-            .fileUnlock = fileUnlock,
-            .fileDowngradeLock = fileDowngradeLock,
-            .fileRealPath = fileRealPath,
-            .fileHardLink = fileHardLink,
-
-            .processExecutableOpen = processExecutableOpen,
-            .processExecutablePath = processExecutablePath,
-            .lockStderr = lockStderr,
-            .tryLockStderr = tryLockStderr,
-            .unlockStderr = unlockStderr,
-            .processSetCurrentDir = processSetCurrentDir,
-            .processReplace = processReplace,
-            .processReplacePath = processReplacePath,
-            .processSpawn = processSpawn,
-            .processSpawnPath = processSpawnPath,
-            .childWait = childWait,
-            .childKill = childKill,
-
-            .progressParentFile = progressParentFile,
-
-            .now = now,
-            .sleep = sleep,
-
-            .random = random,
-            .randomSecure = randomSecure,
-
-            .netListenIp = netListenIpUnavailable,
-            .netListenUnix = netListenUnixUnavailable,
-            .netAccept = netAcceptUnavailable,
-            .netBindIp = netBindIpUnavailable,
-            .netConnectIp = netConnectIpUnavailable,
-            .netConnectUnix = netConnectUnixUnavailable,
-            .netClose = netCloseUnavailable,
-            .netShutdown = netShutdownUnavailable,
-            .netRead = netReadUnavailable,
-            .netWrite = netWriteUnavailable,
-            .netWriteFile = netWriteFileUnavailable,
-            .netSend = netSendUnavailable,
-            .netReceive = netReceiveUnavailable,
-            .netInterfaceNameResolve = netInterfaceNameResolveUnavailable,
-            .netInterfaceName = netInterfaceNameUnavailable,
-            .netLookup = netLookupUnavailable,
-        },
-    };
-}
-
-fn async(
-    _: ?*anyopaque,
-    _: []u8,
-    _: std.Alignment,
-    _: []const u8,
-    _: std.Alignment,
-    _: *const fn (context: *const anyopaque, result: *anyopaque) void,
-) ?*std.Io.AnyFuture {
-    return null;
-}
-
-fn concurrent(
-    _: ?*anyopaque,
-    _: usize,
-    _: std.mem.Alignment,
-    _: []const u8,
-    _: std.mem.Alignment,
-    _: *const fn (context: *const anyopaque, result: *anyopaque) void,
-) std.Io.ConcurrentError!*std.Io.AnyFuture {
-    return error.ConcurrencyUnavailable;
-}

core/src/start.zig

@@ -61,11 +61,11 @@ pub fn SliceVector(comptime Slice: type) type {
         @compileError("Slice must have a slice type!");
 
     const item_ptr_attrs: std.builtin.Type.Pointer.Attributes = .{
-        .alignment = @min(type_info.pointer.alignment, @alignOf(type_info.pointer.child)),
-        .address_space = type_info.pointer.address_space,
-        .is_const = type_info.pointer.is_const,
-        .is_volatile = type_info.pointer.is_volatile,
-        .is_allowzero = type_info.pointer.is_allowzero,
+        .@"align" = @min(type_info.pointer.alignment, @alignOf(type_info.pointer.child)),
+        .@"addrspace" = type_info.pointer.address_space,
+        .@"const" = type_info.pointer.is_const,
+        .@"volatile" = type_info.pointer.is_volatile,
+        .@"allowzero" = type_info.pointer.is_allowzero,
     };
 
     return struct {
@@ -479,7 +479,7 @@ test "SliceVector.Iterator.next_chunk" {
     }
 }
 
-pub fn dump_stack_trace(trace: *std.builtin.StackTrace) usize {
+pub fn dump_stack_trace(trace: *std.builtin.StackTrace, start_index: usize) usize {
     const frame_count = @min(trace.index, trace.instruction_addresses.len);
 
     var frame_index: usize = 0;
@@ -489,7 +489,7 @@ pub fn dump_stack_trace(trace: *std.builtin.StackTrace) usize {
         frame_index = (frame_index + 1) % trace.instruction_addresses.len;
     }) {
         const address = trace.instruction_addresses[frame_index];
-        std.log.err("{d: >3}: 0x{X:0>8}", .{ frame_index, address });
+        std.log.err("{d: >3}: 0x{X:0>8}", .{ start_index + frame_index, address });
     }
 
     return frame_count;

core/src/utilities.zig

@@ -14,7 +14,7 @@ pub fn build(b: *std.Build) void {
 
     const targets = [_]TargetDescription{
         .{ .prefix = "esp32_c3", .target = mb.ports.esp.chips.esp32_c3 },
-        .{ .prefix = "esp32_c3_direct_boot", .target = mb.ports.esp.chips.esp32_c3_direct_boot },
+        // .{ .prefix = "esp32_c3_direct_boot", .target = mb.ports.esp.chips.esp32_c3_direct_boot },
         .{ .prefix = "esp32_c3_flashless", .target = mb.ports.esp.chips.esp32_c3_flashless },
     };
 

examples/espressif/esp/build.zig

@@ -49,4 +49,10 @@ SECTIONS
 
   microzig_data_load_start = ORIGIN(DROM) + _irom_size + _drom_size;
   PROVIDE(__global_pointer$ = microzig_data_start + 0x800);
+
+  /DISCARD/ :
+  {
+    *(.eh_frame_hdr)
+    *(.eh_frame)
+  }
 }

port/espressif/esp/ld/esp32_c3/direct_boot_sections.ld

@@ -30,4 +30,10 @@ SECTIONS
   } > DRAM
 
   PROVIDE(__global_pointer$ = microzig_data_start + 0x800);
+
+  /DISCARD/ :
+  {
+    *(.eh_frame_hdr)
+    *(.eh_frame)
+  }
 }

port/espressif/esp/ld/esp32_c3/flashless_sections.ld

@@ -74,4 +74,10 @@ SECTIONS
   } > DRAM
 
   PROVIDE(__global_pointer$ = microzig_data_start + 0x800);
+
+  /DISCARD/ :
+  {
+    *(.eh_frame_hdr)
+    *(.eh_frame)
+  }
 }

port/espressif/esp/ld/esp32_c3/image_boot_sections.ld

@@ -11,8 +11,8 @@ pub fn read_mac() [6]u8 {
     return mac;
 }
 
-pub fn read(comptime what: Item) @Type(.{ .int = .{ .bits = what.bit_length, .signedness = .unsigned } }) {
-    const OutputType = @Type(.{ .int = .{ .bits = what.bit_length, .signedness = .unsigned } });
+pub fn read(comptime what: Item) @Int(.unsigned, what.bit_length) {
+    const OutputType = @Int(.unsigned, what.bit_length);
 
     const block_byte_offsets = [_]u8{ 0x2C, 0x44, 0x5C };
     if (what.block >= block_byte_offsets.len) @compileError("invalid block");