zig-p4: pure-Zig ESP32-P4 toolchain

build.zig generates the linker script and drives Zig's own LLD; tools/image.zig
turns the ELF into a flashable image and tools/{rom,serial}.zig speak the mask
ROM loader over the UART. No CMake, ninja, idf.py, esptool, or external linker.

src/soc.zig is a comptime register model over ESP-IDF's own *_reg.h headers;
src/hal/ adds peripheral sequences; src/io/ implements std.Io for the chip;
src/oracle/ diffs this HAL against ESP-IDF's on the die.

1 files changed, 490 insertions, 0 deletions

diff --git a/src/io/unimplemented.zig b/src/io/unimplemented.zig
new file mode 100644
index 0000000..566afac
--- /dev/null
+++ b/src/io/unimplemented.zig
@@ -0,0 +1,490 @@
+//! Every `std.Io.VTable` entry this port does not implement, as a function that panics with its
+//! own name.
+//!
+//! `std.Io.VTable` has 109 entries (`/usr/lib/zig/std/Io.zig:51-255`). A port of it to a chip with
+//! no filesystem, no sockets and no processes implements sixteen of them, and the honest way to
+//! express the other 93 is not a partial struct - the struct has no optional fields - but a complete
+//! one whose unimplemented entries announce themselves the moment they are reached. So this file is
+//! the floor: `p4.zig` starts from `unimplemented.vtable` and overwrites the entries it really has,
+//! and anything it forgot fails with the name of the entry rather than a jump to address zero.
+//!
+//! A stub for an entry `p4.zig` does implement is dead the moment the assignment overwrites the
+//! field, so it costs nothing: a riscv32 `-OReleaseSmall` build emits exactly the 93 that survive.
+//!
+//! The signatures are transcribed from that VTable declaration verbatim, which is why they carry
+//! precision about types nothing here will ever construct: the compiler checks each one against
+//! std, so a Zig release that changes a signature - or adds an entry - is a build error in this
+//! file instead of a silent gap. The parameter names are dropped to `_` because a stub that reads
+//! its arguments would be a lie.
+//!
+//! Note the five `fileMemoryMap*` entries. Their signatures name `Io.File.MemoryMap`, and merely
+//! *defining* a function with that in its type forces the struct to be laid out, which on
+//! riscv32-freestanding needs `std.options.page_size_min` - see `p4.zig`'s "Integrating this".
+
+const std = @import("std");
+const Io = std.Io;
+
+const Alignment = std.mem.Alignment;
+const AnyFuture = Io.AnyFuture;
+const Batch = Io.Batch;
+const CancelProtection = Io.CancelProtection;
+const Cancelable = Io.Cancelable;
+const Clock = Io.Clock;
+const ConcurrentError = Io.ConcurrentError;
+const Dir = Io.Dir;
+const Duration = Io.Duration;
+const File = Io.File;
+const Group = Io.Group;
+const LockedStderr = Io.LockedStderr;
+const Operation = Io.Operation;
+const Queue = Io.Queue;
+const RandomSecureError = Io.RandomSecureError;
+const Terminal = Io.Terminal;
+const Timeout = Io.Timeout;
+const Timestamp = Io.Timestamp;
+const net = Io.net;
+
+/// A `std.Io.VTable` in which nothing is implemented. Every entry panics with its own name.
+pub const vtable: Io.VTable = .{
+    .crashHandler = panics.crashHandler,
+    .async = panics.async,
+    .concurrent = panics.concurrent,
+    .await = panics.await,
+    .cancel = panics.cancel,
+    .groupAsync = panics.groupAsync,
+    .groupConcurrent = panics.groupConcurrent,
+    .groupAwait = panics.groupAwait,
+    .groupCancel = panics.groupCancel,
+    .recancel = panics.recancel,
+    .swapCancelProtection = panics.swapCancelProtection,
+    .checkCancel = panics.checkCancel,
+    .futexWait = panics.futexWait,
+    .futexWaitUncancelable = panics.futexWaitUncancelable,
+    .futexWake = panics.futexWake,
+    .operate = panics.operate,
+    .batchAwaitAsync = panics.batchAwaitAsync,
+    .batchAwaitConcurrent = panics.batchAwaitConcurrent,
+    .batchCancel = panics.batchCancel,
+    .dirCreateDir = panics.dirCreateDir,
+    .dirCreateDirPath = panics.dirCreateDirPath,
+    .dirCreateDirPathOpen = panics.dirCreateDirPathOpen,
+    .dirOpenDir = panics.dirOpenDir,
+    .dirStat = panics.dirStat,
+    .dirStatFile = panics.dirStatFile,
+    .dirAccess = panics.dirAccess,
+    .dirCreateFile = panics.dirCreateFile,
+    .dirCreateFileAtomic = panics.dirCreateFileAtomic,
+    .dirOpenFile = panics.dirOpenFile,
+    .dirClose = panics.dirClose,
+    .dirRead = panics.dirRead,
+    .dirRealPath = panics.dirRealPath,
+    .dirRealPathFile = panics.dirRealPathFile,
+    .dirDeleteFile = panics.dirDeleteFile,
+    .dirDeleteDir = panics.dirDeleteDir,
+    .dirRename = panics.dirRename,
+    .dirRenamePreserve = panics.dirRenamePreserve,
+    .dirSymLink = panics.dirSymLink,
+    .dirReadLink = panics.dirReadLink,
+    .dirSetOwner = panics.dirSetOwner,
+    .dirSetFileOwner = panics.dirSetFileOwner,
+    .dirSetPermissions = panics.dirSetPermissions,
+    .dirSetFilePermissions = panics.dirSetFilePermissions,
+    .dirSetTimestamps = panics.dirSetTimestamps,
+    .dirHardLink = panics.dirHardLink,
+    .fileStat = panics.fileStat,
+    .fileLength = panics.fileLength,
+    .fileClose = panics.fileClose,
+    .fileWritePositional = panics.fileWritePositional,
+    .fileWriteFileStreaming = panics.fileWriteFileStreaming,
+    .fileWriteFilePositional = panics.fileWriteFilePositional,
+    .fileReadPositional = panics.fileReadPositional,
+    .fileSeekBy = panics.fileSeekBy,
+    .fileSeekTo = panics.fileSeekTo,
+    .fileSync = panics.fileSync,
+    .fileIsTty = panics.fileIsTty,
+    .fileEnableAnsiEscapeCodes = panics.fileEnableAnsiEscapeCodes,
+    .fileSupportsAnsiEscapeCodes = panics.fileSupportsAnsiEscapeCodes,
+    .fileSetLength = panics.fileSetLength,
+    .fileSetOwner = panics.fileSetOwner,
+    .fileSetPermissions = panics.fileSetPermissions,
+    .fileSetTimestamps = panics.fileSetTimestamps,
+    .fileLock = panics.fileLock,
+    .fileTryLock = panics.fileTryLock,
+    .fileUnlock = panics.fileUnlock,
+    .fileDowngradeLock = panics.fileDowngradeLock,
+    .fileRealPath = panics.fileRealPath,
+    .fileHardLink = panics.fileHardLink,
+    .fileMemoryMapCreate = panics.fileMemoryMapCreate,
+    .fileMemoryMapDestroy = panics.fileMemoryMapDestroy,
+    .fileMemoryMapSetLength = panics.fileMemoryMapSetLength,
+    .fileMemoryMapRead = panics.fileMemoryMapRead,
+    .fileMemoryMapWrite = panics.fileMemoryMapWrite,
+    .processExecutableOpen = panics.processExecutableOpen,
+    .processExecutablePath = panics.processExecutablePath,
+    .lockStderr = panics.lockStderr,
+    .tryLockStderr = panics.tryLockStderr,
+    .unlockStderr = panics.unlockStderr,
+    .processCurrentPath = panics.processCurrentPath,
+    .processSetCurrentDir = panics.processSetCurrentDir,
+    .processSetCurrentPath = panics.processSetCurrentPath,
+    .processReplace = panics.processReplace,
+    .processReplacePath = panics.processReplacePath,
+    .processSpawn = panics.processSpawn,
+    .processSpawnPath = panics.processSpawnPath,
+    .childWait = panics.childWait,
+    .childKill = panics.childKill,
+    .progressParentFile = panics.progressParentFile,
+    .now = panics.now,
+    .clockResolution = panics.clockResolution,
+    .sleep = panics.sleep,
+    .random = panics.random,
+    .randomSecure = panics.randomSecure,
+    .netListenIp = panics.netListenIp,
+    .netAccept = panics.netAccept,
+    .netBindIp = panics.netBindIp,
+    .netConnectIp = panics.netConnectIp,
+    .netListenUnix = panics.netListenUnix,
+    .netConnectUnix = panics.netConnectUnix,
+    .netSocketCreatePair = panics.netSocketCreatePair,
+    .netSend = panics.netSend,
+    .netRead = panics.netRead,
+    .netWrite = panics.netWrite,
+    .netWriteFile = panics.netWriteFile,
+    .netClose = panics.netClose,
+    .netShutdown = panics.netShutdown,
+    .netInterfaceNameResolve = panics.netInterfaceNameResolve,
+    .netInterfaceName = panics.netInterfaceName,
+    .netLookup = panics.netLookup,
+};
+
+/// One function per entry. Grouped in a namespace so the panic message and the vtable field
+/// cannot drift apart: `panics.dirOpenFile` is the entry named `dirOpenFile`.
+const panics = struct {
+    fn crashHandler(_: ?*anyopaque) void {
+        @panic("io.p4 unimplemented: crashHandler");
+    }
+    fn async(_: ?*anyopaque, _: []u8, _: std.mem.Alignment, _: []const u8, _: std.mem.Alignment, _: *const fn (context: *const anyopaque, result: *anyopaque) void) ?*AnyFuture {
+        @panic("io.p4 unimplemented: async");
+    }
+    fn concurrent(_: ?*anyopaque, _: usize, _: std.mem.Alignment, _: []const u8, _: std.mem.Alignment, _: *const fn (context: *const anyopaque, result: *anyopaque) void) ConcurrentError!*AnyFuture {
+        @panic("io.p4 unimplemented: concurrent");
+    }
+    fn await(_: ?*anyopaque, _: *AnyFuture, _: []u8, _: std.mem.Alignment) void {
+        @panic("io.p4 unimplemented: await");
+    }
+    fn cancel(_: ?*anyopaque, _: *AnyFuture, _: []u8, _: std.mem.Alignment) void {
+        @panic("io.p4 unimplemented: cancel");
+    }
+    fn groupAsync(_: ?*anyopaque, _: *Group, _: []const u8, _: std.mem.Alignment, _: *const fn (context: *const anyopaque) void) void {
+        @panic("io.p4 unimplemented: groupAsync");
+    }
+    fn groupConcurrent(_: ?*anyopaque, _: *Group, _: []const u8, _: std.mem.Alignment, _: *const fn (context: *const anyopaque) void) ConcurrentError!void {
+        @panic("io.p4 unimplemented: groupConcurrent");
+    }
+    fn groupAwait(_: ?*anyopaque, _: *Group, _: *anyopaque) Cancelable!void {
+        @panic("io.p4 unimplemented: groupAwait");
+    }
+    fn groupCancel(_: ?*anyopaque, _: *Group, _: *anyopaque) void {
+        @panic("io.p4 unimplemented: groupCancel");
+    }
+    fn recancel(_: ?*anyopaque) void {
+        @panic("io.p4 unimplemented: recancel");
+    }
+    fn swapCancelProtection(_: ?*anyopaque, _: CancelProtection) CancelProtection {
+        @panic("io.p4 unimplemented: swapCancelProtection");
+    }
+    fn checkCancel(_: ?*anyopaque) Cancelable!void {
+        @panic("io.p4 unimplemented: checkCancel");
+    }
+    fn futexWait(_: ?*anyopaque, _: *const u32, _: u32, _: Timeout) Cancelable!void {
+        @panic("io.p4 unimplemented: futexWait");
+    }
+    fn futexWaitUncancelable(_: ?*anyopaque, _: *const u32, _: u32) void {
+        @panic("io.p4 unimplemented: futexWaitUncancelable");
+    }
+    fn futexWake(_: ?*anyopaque, _: *const u32, _: u32) void {
+        @panic("io.p4 unimplemented: futexWake");
+    }
+    fn operate(_: ?*anyopaque, _: Operation) Cancelable!Operation.Result {
+        @panic("io.p4 unimplemented: operate");
+    }
+    fn batchAwaitAsync(_: ?*anyopaque, _: *Batch) Cancelable!void {
+        @panic("io.p4 unimplemented: batchAwaitAsync");
+    }
+    fn batchAwaitConcurrent(_: ?*anyopaque, _: *Batch, _: Timeout) Batch.AwaitConcurrentError!void {
+        @panic("io.p4 unimplemented: batchAwaitConcurrent");
+    }
+    fn batchCancel(_: ?*anyopaque, _: *Batch) void {
+        @panic("io.p4 unimplemented: batchCancel");
+    }
+    fn dirCreateDir(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.Permissions) Dir.CreateDirError!void {
+        @panic("io.p4 unimplemented: dirCreateDir");
+    }
+    fn dirCreateDirPath(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.Permissions) Dir.CreateDirPathError!Dir.CreatePathStatus {
+        @panic("io.p4 unimplemented: dirCreateDirPath");
+    }
+    fn dirCreateDirPathOpen(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.Permissions, _: Dir.OpenOptions) Dir.CreateDirPathOpenError!Dir {
+        @panic("io.p4 unimplemented: dirCreateDirPathOpen");
+    }
+    fn dirOpenDir(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.OpenOptions) Dir.OpenError!Dir {
+        @panic("io.p4 unimplemented: dirOpenDir");
+    }
+    fn dirStat(_: ?*anyopaque, _: Dir) Dir.StatError!Dir.Stat {
+        @panic("io.p4 unimplemented: dirStat");
+    }
+    fn dirStatFile(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.StatFileOptions) Dir.StatFileError!File.Stat {
+        @panic("io.p4 unimplemented: dirStatFile");
+    }
+    fn dirAccess(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.AccessOptions) Dir.AccessError!void {
+        @panic("io.p4 unimplemented: dirAccess");
+    }
+    fn dirCreateFile(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.CreateFileOptions) File.OpenError!File {
+        @panic("io.p4 unimplemented: dirCreateFile");
+    }
+    fn dirCreateFileAtomic(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.CreateFileAtomicOptions) Dir.CreateFileAtomicError!File.Atomic {
+        @panic("io.p4 unimplemented: dirCreateFileAtomic");
+    }
+    fn dirOpenFile(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.OpenFileOptions) File.OpenError!File {
+        @panic("io.p4 unimplemented: dirOpenFile");
+    }
+    fn dirClose(_: ?*anyopaque, _: []const Dir) void {
+        @panic("io.p4 unimplemented: dirClose");
+    }
+    fn dirRead(_: ?*anyopaque, _: *Dir.Reader, _: []Dir.Entry) Dir.Reader.Error!usize {
+        @panic("io.p4 unimplemented: dirRead");
+    }
+    fn dirRealPath(_: ?*anyopaque, _: Dir, _: []u8) Dir.RealPathError!usize {
+        @panic("io.p4 unimplemented: dirRealPath");
+    }
+    fn dirRealPathFile(_: ?*anyopaque, _: Dir, _: []const u8, _: []u8) Dir.RealPathFileError!usize {
+        @panic("io.p4 unimplemented: dirRealPathFile");
+    }
+    fn dirDeleteFile(_: ?*anyopaque, _: Dir, _: []const u8) Dir.DeleteFileError!void {
+        @panic("io.p4 unimplemented: dirDeleteFile");
+    }
+    fn dirDeleteDir(_: ?*anyopaque, _: Dir, _: []const u8) Dir.DeleteDirError!void {
+        @panic("io.p4 unimplemented: dirDeleteDir");
+    }
+    fn dirRename(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir, _: []const u8) Dir.RenameError!void {
+        @panic("io.p4 unimplemented: dirRename");
+    }
+    fn dirRenamePreserve(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir, _: []const u8) Dir.RenamePreserveError!void {
+        @panic("io.p4 unimplemented: dirRenamePreserve");
+    }
+    fn dirSymLink(_: ?*anyopaque, _: Dir, _: []const u8, _: []const u8, _: Dir.SymLinkFlags) Dir.SymLinkError!void {
+        @panic("io.p4 unimplemented: dirSymLink");
+    }
+    fn dirReadLink(_: ?*anyopaque, _: Dir, _: []const u8, _: []u8) Dir.ReadLinkError!usize {
+        @panic("io.p4 unimplemented: dirReadLink");
+    }
+    fn dirSetOwner(_: ?*anyopaque, _: Dir, _: ?File.Uid, _: ?File.Gid) Dir.SetOwnerError!void {
+        @panic("io.p4 unimplemented: dirSetOwner");
+    }
+    fn dirSetFileOwner(_: ?*anyopaque, _: Dir, _: []const u8, _: ?File.Uid, _: ?File.Gid, _: Dir.SetFileOwnerOptions) Dir.SetFileOwnerError!void {
+        @panic("io.p4 unimplemented: dirSetFileOwner");
+    }
+    fn dirSetPermissions(_: ?*anyopaque, _: Dir, _: Dir.Permissions) Dir.SetPermissionsError!void {
+        @panic("io.p4 unimplemented: dirSetPermissions");
+    }
+    fn dirSetFilePermissions(_: ?*anyopaque, _: Dir, _: []const u8, _: File.Permissions, _: Dir.SetFilePermissionsOptions) Dir.SetFilePermissionsError!void {
+        @panic("io.p4 unimplemented: dirSetFilePermissions");
+    }
+    fn dirSetTimestamps(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir.SetTimestampsOptions) Dir.SetTimestampsError!void {
+        @panic("io.p4 unimplemented: dirSetTimestamps");
+    }
+    fn dirHardLink(_: ?*anyopaque, _: Dir, _: []const u8, _: Dir, _: []const u8, _: Dir.HardLinkOptions) Dir.HardLinkError!void {
+        @panic("io.p4 unimplemented: dirHardLink");
+    }
+    fn fileStat(_: ?*anyopaque, _: File) File.StatError!File.Stat {
+        @panic("io.p4 unimplemented: fileStat");
+    }
+    fn fileLength(_: ?*anyopaque, _: File) File.LengthError!u64 {
+        @panic("io.p4 unimplemented: fileLength");
+    }
+    fn fileClose(_: ?*anyopaque, _: []const File) void {
+        @panic("io.p4 unimplemented: fileClose");
+    }
+    fn fileWritePositional(_: ?*anyopaque, _: File, _: []const u8, _: []const []const u8, _: usize, _: u64) File.WritePositionalError!usize {
+        @panic("io.p4 unimplemented: fileWritePositional");
+    }
+    fn fileWriteFileStreaming(_: ?*anyopaque, _: File, _: []const u8, _: *Io.File.Reader, _: Io.Limit) File.Writer.WriteFileError!usize {
+        @panic("io.p4 unimplemented: fileWriteFileStreaming");
+    }
+    fn fileWriteFilePositional(_: ?*anyopaque, _: File, _: []const u8, _: *Io.File.Reader, _: Io.Limit, _: u64) File.WriteFilePositionalError!usize {
+        @panic("io.p4 unimplemented: fileWriteFilePositional");
+    }
+    fn fileReadPositional(_: ?*anyopaque, _: File, _: []const []u8, _: u64) File.ReadPositionalError!usize {
+        @panic("io.p4 unimplemented: fileReadPositional");
+    }
+    fn fileSeekBy(_: ?*anyopaque, _: File, _: i64) File.SeekError!void {
+        @panic("io.p4 unimplemented: fileSeekBy");
+    }
+    fn fileSeekTo(_: ?*anyopaque, _: File, _: u64) File.SeekError!void {
+        @panic("io.p4 unimplemented: fileSeekTo");
+    }
+    fn fileSync(_: ?*anyopaque, _: File) File.SyncError!void {
+        @panic("io.p4 unimplemented: fileSync");
+    }
+    fn fileIsTty(_: ?*anyopaque, _: File) Cancelable!bool {
+        @panic("io.p4 unimplemented: fileIsTty");
+    }
+    fn fileEnableAnsiEscapeCodes(_: ?*anyopaque, _: File) File.EnableAnsiEscapeCodesError!void {
+        @panic("io.p4 unimplemented: fileEnableAnsiEscapeCodes");
+    }
+    fn fileSupportsAnsiEscapeCodes(_: ?*anyopaque, _: File) Cancelable!bool {
+        @panic("io.p4 unimplemented: fileSupportsAnsiEscapeCodes");
+    }
+    fn fileSetLength(_: ?*anyopaque, _: File, _: u64) File.SetLengthError!void {
+        @panic("io.p4 unimplemented: fileSetLength");
+    }
+    fn fileSetOwner(_: ?*anyopaque, _: File, _: ?File.Uid, _: ?File.Gid) File.SetOwnerError!void {
+        @panic("io.p4 unimplemented: fileSetOwner");
+    }
+    fn fileSetPermissions(_: ?*anyopaque, _: File, _: File.Permissions) File.SetPermissionsError!void {
+        @panic("io.p4 unimplemented: fileSetPermissions");
+    }
+    fn fileSetTimestamps(_: ?*anyopaque, _: File, _: File.SetTimestampsOptions) File.SetTimestampsError!void {
+        @panic("io.p4 unimplemented: fileSetTimestamps");
+    }
+    fn fileLock(_: ?*anyopaque, _: File, _: File.Lock) File.LockError!void {
+        @panic("io.p4 unimplemented: fileLock");
+    }
+    fn fileTryLock(_: ?*anyopaque, _: File, _: File.Lock) File.LockError!bool {
+        @panic("io.p4 unimplemented: fileTryLock");
+    }
+    fn fileUnlock(_: ?*anyopaque, _: File) void {
+        @panic("io.p4 unimplemented: fileUnlock");
+    }
+    fn fileDowngradeLock(_: ?*anyopaque, _: File) File.DowngradeLockError!void {
+        @panic("io.p4 unimplemented: fileDowngradeLock");
+    }
+    fn fileRealPath(_: ?*anyopaque, _: File, _: []u8) File.RealPathError!usize {
+        @panic("io.p4 unimplemented: fileRealPath");
+    }
+    fn fileHardLink(_: ?*anyopaque, _: File, _: Dir, _: []const u8, _: File.HardLinkOptions) File.HardLinkError!void {
+        @panic("io.p4 unimplemented: fileHardLink");
+    }
+    fn fileMemoryMapCreate(_: ?*anyopaque, _: File, _: File.MemoryMap.CreateOptions) File.MemoryMap.CreateError!File.MemoryMap {
+        @panic("io.p4 unimplemented: fileMemoryMapCreate");
+    }
+    fn fileMemoryMapDestroy(_: ?*anyopaque, _: *File.MemoryMap) void {
+        @panic("io.p4 unimplemented: fileMemoryMapDestroy");
+    }
+    fn fileMemoryMapSetLength(_: ?*anyopaque, _: *File.MemoryMap, _: usize) File.MemoryMap.SetLengthError!void {
+        @panic("io.p4 unimplemented: fileMemoryMapSetLength");
+    }
+    fn fileMemoryMapRead(_: ?*anyopaque, _: *File.MemoryMap) File.ReadPositionalError!void {
+        @panic("io.p4 unimplemented: fileMemoryMapRead");
+    }
+    fn fileMemoryMapWrite(_: ?*anyopaque, _: *File.MemoryMap) File.WritePositionalError!void {
+        @panic("io.p4 unimplemented: fileMemoryMapWrite");
+    }
+    fn processExecutableOpen(_: ?*anyopaque, _: Dir.OpenFileOptions) std.process.OpenExecutableError!File {
+        @panic("io.p4 unimplemented: processExecutableOpen");
+    }
+    fn processExecutablePath(_: ?*anyopaque, _: []u8) std.process.ExecutablePathError!usize {
+        @panic("io.p4 unimplemented: processExecutablePath");
+    }
+    fn lockStderr(_: ?*anyopaque, _: ?Terminal.Mode) Cancelable!LockedStderr {
+        @panic("io.p4 unimplemented: lockStderr");
+    }
+    fn tryLockStderr(_: ?*anyopaque, _: ?Terminal.Mode) Cancelable!?LockedStderr {
+        @panic("io.p4 unimplemented: tryLockStderr");
+    }
+    fn unlockStderr(_: ?*anyopaque) void {
+        @panic("io.p4 unimplemented: unlockStderr");
+    }
+    fn processCurrentPath(_: ?*anyopaque, _: []u8) std.process.CurrentPathError!usize {
+        @panic("io.p4 unimplemented: processCurrentPath");
+    }
+    fn processSetCurrentDir(_: ?*anyopaque, _: Dir) std.process.SetCurrentDirError!void {
+        @panic("io.p4 unimplemented: processSetCurrentDir");
+    }
+    fn processSetCurrentPath(_: ?*anyopaque, _: []const u8) std.process.SetCurrentPathError!void {
+        @panic("io.p4 unimplemented: processSetCurrentPath");
+    }
+    fn processReplace(_: ?*anyopaque, _: std.process.ReplaceOptions) std.process.ReplaceError {
+        @panic("io.p4 unimplemented: processReplace");
+    }
+    fn processReplacePath(_: ?*anyopaque, _: Dir, _: std.process.ReplaceOptions) std.process.ReplaceError {
+        @panic("io.p4 unimplemented: processReplacePath");
+    }
+    fn processSpawn(_: ?*anyopaque, _: std.process.SpawnOptions) std.process.SpawnError!std.process.Child {
+        @panic("io.p4 unimplemented: processSpawn");
+    }
+    fn processSpawnPath(_: ?*anyopaque, _: Dir, _: std.process.SpawnOptions) std.process.SpawnError!std.process.Child {
+        @panic("io.p4 unimplemented: processSpawnPath");
+    }
+    fn childWait(_: ?*anyopaque, _: *std.process.Child) std.process.Child.WaitError!std.process.Child.Term {
+        @panic("io.p4 unimplemented: childWait");
+    }
+    fn childKill(_: ?*anyopaque, _: *std.process.Child) void {
+        @panic("io.p4 unimplemented: childKill");
+    }
+    fn progressParentFile(_: ?*anyopaque) std.Progress.ParentFileError!File {
+        @panic("io.p4 unimplemented: progressParentFile");
+    }
+    fn now(_: ?*anyopaque, _: Clock) Timestamp {
+        @panic("io.p4 unimplemented: now");
+    }
+    fn clockResolution(_: ?*anyopaque, _: Clock) Clock.ResolutionError!Duration {
+        @panic("io.p4 unimplemented: clockResolution");
+    }
+    fn sleep(_: ?*anyopaque, _: Timeout) Cancelable!void {
+        @panic("io.p4 unimplemented: sleep");
+    }
+    fn random(_: ?*anyopaque, _: []u8) void {
+        @panic("io.p4 unimplemented: random");
+    }
+    fn randomSecure(_: ?*anyopaque, _: []u8) RandomSecureError!void {
+        @panic("io.p4 unimplemented: randomSecure");
+    }
+    fn netListenIp(_: ?*anyopaque, _: *const net.IpAddress, _: net.IpAddress.ListenOptions) net.IpAddress.ListenError!net.Socket {
+        @panic("io.p4 unimplemented: netListenIp");
+    }
+    fn netAccept(_: ?*anyopaque, _: net.Socket.Handle, _: net.Server.AcceptOptions) net.Server.AcceptError!net.Socket {
+        @panic("io.p4 unimplemented: netAccept");
+    }
+    fn netBindIp(_: ?*anyopaque, _: *const net.IpAddress, _: net.IpAddress.BindOptions) net.IpAddress.BindError!net.Socket {
+        @panic("io.p4 unimplemented: netBindIp");
+    }
+    fn netConnectIp(_: ?*anyopaque, _: *const net.IpAddress, _: net.IpAddress.ConnectOptions) net.IpAddress.ConnectError!net.Socket {
+        @panic("io.p4 unimplemented: netConnectIp");
+    }
+    fn netListenUnix(_: ?*anyopaque, _: *const net.UnixAddress, _: net.UnixAddress.ListenOptions) net.UnixAddress.ListenError!net.Socket.Handle {
+        @panic("io.p4 unimplemented: netListenUnix");
+    }
+    fn netConnectUnix(_: ?*anyopaque, _: *const net.UnixAddress) net.UnixAddress.ConnectError!net.Socket.Handle {
+        @panic("io.p4 unimplemented: netConnectUnix");
+    }
+    fn netSocketCreatePair(_: ?*anyopaque, _: net.Socket.CreatePairOptions) net.Socket.CreatePairError![2]net.Socket {
+        @panic("io.p4 unimplemented: netSocketCreatePair");
+    }
+    fn netSend(_: ?*anyopaque, _: net.Socket.Handle, _: []net.OutgoingMessage, _: net.SendFlags) struct { ?net.Socket.SendError, usize } {
+        @panic("io.p4 unimplemented: netSend");
+    }
+    fn netRead(_: ?*anyopaque, _: net.Socket.Handle, _: [][]u8) net.Stream.Reader.Error!usize {
+        @panic("io.p4 unimplemented: netRead");
+    }
+    fn netWrite(_: ?*anyopaque, _: net.Socket.Handle, _: []const u8, _: []const []const u8, _: usize) net.Stream.Writer.Error!usize {
+        @panic("io.p4 unimplemented: netWrite");
+    }
+    fn netWriteFile(_: ?*anyopaque, _: net.Socket.Handle, _: []const u8, _: *Io.File.Reader, _: Io.Limit) net.Stream.Writer.WriteFileError!usize {
+        @panic("io.p4 unimplemented: netWriteFile");
+    }
+    fn netClose(_: ?*anyopaque, _: []const net.Socket.Handle) void {
+        @panic("io.p4 unimplemented: netClose");
+    }
+    fn netShutdown(_: ?*anyopaque, _: net.Socket.Handle, _: net.ShutdownHow) net.ShutdownError!void {
+        @panic("io.p4 unimplemented: netShutdown");
+    }
+    fn netInterfaceNameResolve(_: ?*anyopaque, _: *const net.Interface.Name) net.Interface.Name.ResolveError!net.Interface {
+        @panic("io.p4 unimplemented: netInterfaceNameResolve");
+    }
+    fn netInterfaceName(_: ?*anyopaque, _: net.Interface) net.Interface.NameError!net.Interface.Name {
+        @panic("io.p4 unimplemented: netInterfaceName");
+    }
+    fn netLookup(_: ?*anyopaque, _: net.HostName, _: *Queue(net.HostName.LookupResult), _: net.HostName.LookupOptions) net.HostName.LookupError!void {
+        @panic("io.p4 unimplemented: netLookup");
+    }
+};