Skip to content
zw3rkPublic

About

rvrt — Rosetta-style RISC-V (RV64GC/RV32GC) to AArch64 Linux user-mode binary translator

Resources

Stars

0 stars

Watchers

0 watching

Forks

Repository files navigation

rvrt

RISC-V Linux user-mode translation to AArch64 Linux, running standalone and explicitly inside hyper-linux on macOS Apple Silicon.

Status: RV64 runtime development is active; the full product is incomplete. The native ELF inspector and static-musl AArch64 Linux runtime are separate products. The runtime has an RV64 interpreter, a direct arithmetic AArch64 JIT with explicit interpreter fallback, checked sparse memory, SoftFloat semantics, static/PIE/dynamic ELF loading, guest TLS and explicit Linux ABI conversion. Selected static and dynamic musl/glibc, dlopen and libm workloads run on Linux and through the opt-in hyper-linux companion. Exact artifact identities, acceptance results and current failures live in the implementation ledger.

Guest instructions execute under a managed-family token. Threads can park outside that token for admitted blocking I/O and normal futex operations. Signal support includes guest masks, alternate stacks, edited signal contexts, synchronous faults and selected external-signal/restart paths. These are qualified slices; complete pthread, signal and application acceptance remains open. The current canonical-source checkpoint still times out on the named hyper-linux glibc/basic pthread case at its original bound.

A focused RV64 parent-cap fixture passes the QEMU Linux-user reference and Linux runtime under interp and JIT. It checks process-directed SIGTERM from a guest child to its parent, including SI_USER sender identity, one handler delivery, rt_sigreturn, and exact child wait status. The corrected fixture uses the RISC-V three-word rt_sigaction layout. Run make test-native-term-parent-oracle for QEMU, or make test-native-term-parent-linux ENGINE=interp|jit on Linux. The -hl target also passes on the bounded production companion profile recorded in the plan. This fixture does not qualify general external-signal or process compatibility.

Restricted fork/wait and same-PID self-exec are implemented. The internal canonical-source runtime preserves source-service ownership across fork and repeated exec, and passes focused multiworker exec and shared clear-TID cases on both hosts and engines. Waitable CLONE_VM/vfork now supports parked sibling workers and concurrent shared clones, with hook-safe waits and private reader ownership per worker. Cold private-file clear-TID has atomic COW replay and late exec-failure coherence checks. Nested vfork and waitable process clones preserve each upstream completion owner; pending-upstream CLONE_THREAD remains unsupported. Complete process, signal and application acceptance remains open. The ordinary product now offers explicit --source-mode=canonical, selecting the paired source-service, memory, file, fork, exec and cleanup path. The unlinked-file fork/private-COW fixture passes on Linux and the qualified hyper-linux companion in both engines. Ordinary mode remains the default; the broader internal checkpoints above do not qualify this public mode. Pre-fork canonical workers sharing one address space now admit private regular-file mmap, with detached source preparation and current-state placement checks. Focused occupied-hint and NOREPLACE cases pass both engines on Linux and hyper-linux. Post-fork worker admission and canonical second-worker O_TRUNC remain unsupported; held stale-description recovery is not qualified.

Persistent-cache components now include a versioned whole-record SHA-256, owned non-executable reader, atomic record writer, bounded JIT emission and checked guest-relative relocation. The serialized pipeline matches fresh JIT emission at changed guest layouts. Opt-in startup caching validates and executes direct 32-bit startup code from a static RV64 main or pinned PT_INTERP image. It checks exact-FD authority and current guest source before W^X publication. Caching defaults off. One block is the default; --cache-blocks=2 can include its checked ecall fallthrough. Explicit configuration survives guest exec. Fork discards transient code and reprepares eligible child candidates from an owned immutable image; child hits are currently qualified on Linux. Selected mixed 16/32-bit integer prefixes have bounded persistent-cache coverage; compressed memory, FP and control flow remain interpreted. --pretranslate stores or validates the same record without guest execution. General block/DSO discovery, dynamic-image cross-load-bias hits and full host lifecycle coverage remain open. Two-placement PIE cache publication has focused coverage. Configured initial RV64 ELF dispatch and bounded native AArch64-to-RV64 exec now work through the companion. Native script exec with an RV64 interpreter is also qualified. Initial host script selection, broader exec/fork propagation, full application/process qualification and RV32 remain required. Final profiles are RV64GC/LP64D and RV32GC/ILP32D, with the explicit exclusions in the plan. This is not a universal Linux compatibility claim. The plan contains the copy-ready full-completion Goal prompt.

Current guest syscall coverage includes private anonymous mmap, munmap, mprotect, brk and single-VMA mremap; openat, close, dup/dup3, fcntl's descriptor and append/nonblocking operations, read/write/writev, pread64/pwrite64, lseek, fstat, newfstatat, faccessat, fchmod, readlinkat, unlinkat, ftruncate and TIOCGWINSZ; private regular-file mmap; mkdirat/getdents64, pipe2/ppoll, unnamed Unix socketpairs/IPv4 UDP/TCP, listen/accept/accept4 and basic socket options, vectored Unix stream sendmsg/recvmsg with socket/anonymous-pipe SCM_RIGHTS, clocks, single-worker RV64 nanosleep, entropy and virtual uname/identity; cooperative self-signals, rt_sigaction/rt_sigprocmask/rt_sigpending, sigaltstack, rt_sigreturn and an initial external standard-signal/read-interruption path; the selected thread-profile clone, exit, exit_group, per-worker gettid and set_tid_address bookkeeping and riscv_flush_icache. Anonymous MAP_SHARED has a distinct VMA kind and supports nonprivate futexes, including the qualified Linux guest-fork cases. File-backed MAP_SHARED, advanced mapping flags and multi-VMA fixed moves remain unfinished and fail deliberately. riscv_hwprobe reports the implemented virtual RV64 profile, with one online CPU0, checked pair/cpuset conversion and WHICH_CPUS selection. Unknown keys return key=-1/value0. Hardware IDs and time-CSR frequency are zero; this profile has no usable time CSR. Other unsupported syscall numbers return ENOSYS. make test-linux-hwprobe checks native ABI codecs; make test-hwprobe-linux and make test-hwprobe-hl run the real guest fixture after building it with a matching RV64 toolchain. HWPROBE_CASE=qemu-compatible selects the independent QEMU subset; the full oracle run preserves documented QEMU ABI differences. --version lists the implemented ISA extensions and versions. Guest execution serializes guest instructions under a family token. Anonymous pages use guarded, family-owned packed backing; anonymous MAP_SHARED is implemented, while file-backed MAP_SHARED remains unsupported. File mappings retain the open inode, preserve private COW through partial-page truncation, and fault on full pages beyond EOF. In JIT mode, direct blocks retain and validate their source bytes through checked executable reads before running when file mappings exist. Source changes and guest fetch faults fall back to the interpreter at the current PC; internal refresh failures stop execution. Ordinary transfers stage at most 64KiB per call and may return short results. Admitted owned-pipe write/writev requests stage the complete Linux-capped logical request and can return positive-prefix progress; managed FIFO writes remain capped at 4KiB. Unknown ioctl requests return ENOTTY; unsupported fcntl operations return EOPNOTSUPP. Process record locks remain unsupported. Blocking stream/error ordering and concurrent I/O lifetimes remain R5 work. These are deliberate early limits, not the final support contract. The current syscall/support matrix records the implemented commands, error policy and remaining limits. make test-aot-cache-rebase checks actual warm cached-code publication at a different guest PIE address on Linux and hyper-linux, including AUIPC and recovery PCs. It is a bounded component check, separate from full application and DSO compatibility.

Guest descriptors use their own lowest-free-number table. Startup imports inheritable native entry descriptors0..1023, excluding the exact image and optional diagnostic roles. Stdio originals are consumed after relocation; private opens cannot turn originally closed slots into guest descriptors. Inherited dup aliases preserve kernel file offsets. Runtime handles stay private. The path walker expands ordinary symlinks but rejects native procfs and descriptor namespaces with EOPNOTSUPP, including symlink aliases. O_PATH works only when the host preserves its semantics. The qualified companion supports directory O_PATH through an exact search-only native capability in legacy and rooted modes. Older hosts may decline O_PATH and require readable directories for traversal. make test-native-opath-directory checks Linux and both companion modes, including permission revocation and descriptor flags. These limits must be removed or replaced by a guest view before final filesystem compatibility is claimed.

make test-r4-memory-linux ENGINE=interp and make test-r4-memory-hl ENGINE=jit exercise real mapping fixtures; make test-r4-memory-oracle compares QEMU Linux-user behavior. make test-linux-memory checks VMA ownership natively; make test-linux-memory-alloc checks allocation-failure rollback under ASan/UBSan. Select a working native sanitizer compiler with HOST_CC when needed. Sysroot provisioning uses make sysroot-rv64-musl or make sysroot-rv64-glibc with matching RV_CC/RV_CXX compiler commands. The sysroot-rv32-musl and sysroot-rv32-glibc targets require matching RV32 ILP32D compilers and validate ELF32 libraries in a separate sysroot. These provisioning targets do not establish RV32 runtime execution support. make rv32-linux-target-libs-smoke builds the pinned-backend RV32 musl/libgcc bootstrap and runs an ABI-checked static C division fixture under configured RV32_QEMU. Set RV32_BACKEND_CC_PATH and RV32_BACKEND_BINUTILS_PATH to the realized backend inputs. The corrected C path passes; C++ and glibc provisioning remain separate incomplete checkpoints. QEMU10.1 is the observed local reference; the final pinned reference-tool matrix remains outstanding. make rv32-linux-target-libs-dynamic-c-smoke provisions a separate dynamic musl PIE fixture with pthread TLS, using static libgcc helpers and the exact staged loader/sysroot under QEMU. This provisioning lane passes on QEMU10.1; rvrt execution remains a later RV32 checkpoint. make rv32-linux-target-libs-cxx-smoke builds the independent C++17 string/vector/exception fixture; its latest bounded build expired during compilation, before installation or execution. These targets do not imply RV32 execution by rvrt. The separate rv32GlibcTargetLibrariesFor path is an experimental, target-libraries-only glibc route. It uses the pinned RV64 GCC 15.2/binutils 2.44 backend with explicit RV32GC/ILP32D flags and the accepted RV32 static libgcc archive; it keeps the backend's truthful RV64 -dumpmachine and does not build an RV32 GCC frontend. Its refreshed static and dynamic C dry-runs each resolve to five derivations and do not include a GCC frontend. The bootstrap compiler derivation built and passed its RV32 ELF/ABI checks. The first glibc build used one Nix build core, configured successfully, then ended with status 125 after 1193.135 seconds while compiling NPTL objects. No glibc sysroot or C smoke was produced, and no QEMU run occurred. Treat this path as incomplete until both smokes build and execute against the resulting sysroot. On macOS, the default provisioning recipe queries compilers inside Lima. For a cross compiler running directly on macOS, set SYSROOT_PROVISION='python3 test/provision_sysroot.py' on the Make command. make rv32-linux-target-libs-export stages the accepted static/dynamic RV32 C and C++ smoke ELFs, four full composed musl sysroot tar archives, and four lib-only runtime roots under _build/rv32-target-libs-export. The archives preserve the full Linux sysroots, including header names that collide by case on case-insensitive host filesystems. It reruns each exact ELF under QEMU with its staged runtime root before publishing, writes source/store/ABI provenance and SHA-256 file hashes, and refuses to replace an existing export directory. The manifest names each full sysroot archive and its separate runtime root; extract an archive on a case-sensitive filesystem when compiling against the complete sysroot. Set RV32_EXPORT_DIR=_build/<new-name> to choose another destination. Run make rv32-linux-target-libs-export-dry-run first to inspect the locked bundle graph without realizing it or running QEMU. Both targets require RV32_BACKEND_CC_PATH and RV32_BACKEND_BINUTILS_PATH to name the selected RV64 Nix store outputs, and RV32_BACKEND_PREFIX to name their RV64 tool prefix; these inputs are validated and recorded in the export provenance. make test-rv32-export-oracle RV32_EXPORT_DIR=_build/rv32-target-libs-export-v3 revalidates the published manifest, full-file hashes and modes, locked nixpkgs revision, and backend profile before replaying the four already-published ELF files with Linux QEMU against their matching runtime roots. This is a run-only check; it does not invoke Nix or rebuild the export. Each QEMU case keeps a 15-second bound, and the replay log records the manifest/tree and per-profile ELF/sysroot archive hashes. Dynamic musl/glibc TLS and external-DSO dlopen/TLS/libm fixtures pass on both hosts/engines with canonical /lib RUNPATH and provisioned sysroots. This does not establish full application or process compatibility. make test-r4-file-mmap-linux and its -hl counterpart exercise retained image identity, COW, truncation/regrowth and precise beyond-EOF faults. Native make test-file-backing and make test-linux-metadata check backing ownership and pathname metadata. make test-dlopen-musl and make test-dlopen-glibc build and run the external-DSO fixtures with matching RV_CC and sysroot. make test-r4-file-linux and make test-r4-file-hl run real file fixtures; make test-r4-file-errors-linux and its -hl counterpart check Linux error ordering and partial copies. QEMU's eager buffer checks differ from the kernel; make test-r4-file-errors-qemu-subset reports that divergence explicitly and runs a separately named compatible subset. Native Linux probes supply the independent expectations for those differing cases. make test-loader-dynamic checks PIE placement, interpreter loading, guest auxv and malformed inputs natively. make test-linux-directory-linux and its -hl counterpart check shared directory cursors, seek cookies, EOF and output faults. make test-linux-poll checks event conversion and deadlines; make test-r4-abi-linux and -hl exercise real RISC-V pipe/poll/time/entropy syscalls against QEMU expectations. make test-linux-sleep checks raw time64 request validation, monotonic and saturating deadlines, interruption and remainder copyout. The raw RV64 fixture uses make test-nanosleep-oracle for seven QEMU-compatible cases and make test-nanosleep-linux ENGINE=interp or make test-nanosleep-hl ENGINE=jit for the selected runtime engine. The additional NANOSLEEP_CASES=partial runtime case checks a valid eight-byte remainder prefix followed by EFAULT at a page boundary. Its expectation comes from pinned Linux 6.18 RISC-V usercopy. QEMU 10.1 checks the whole destination first and leaves the prefix untouched; the strict partial-copy probe records that difference and is excluded from the seven-case QEMU oracle target. Caught SA_RESTART still returns EINTR. Multiworker nanosleep, clock_nanosleep (115), and full stop/continue restart behavior remain unsupported or unqualified. make test-linux-socket-linux and -hl check descriptor/address codecs and protocol-specific receive faults; the real ABI fixture also covers socketpair and loopback UDP. make test-socket-app LIBC=musl ENGINE=interp and the glibc/JIT variants run compiled Unix/UDP/TCP workloads using provisioned sysroots and fixtures built with make test-socket-app-fixture. Named Unix endpoints and regular/directory descriptor passing and broader ancillary message codecs remain in progress. make test-linux-message-linux and -hl check the bounded Unix stream message/rights codecs; regular/directory rights currently fail deliberately with EOPNOTSUPP. Pinned static/dynamic BusyBox workloads have separate builtins, direct and process targets. Direct applets have focused coverage; current hyper-linux shell startup and process acceptance remain incomplete. See the implementation plan for exact artifacts and retained failures. These targets inherit their launch environment by default. For comparable diagnostics, set BUSYBOX_GUEST_ENV=fixed (or test/test_busybox.py --guest-env fixed) to give the workload only PATH=/bin:/usr/bin, LC_ALL=C, LANG=C, and HOME=/. Lima's transport retains its host environment. make test-busybox-env-command checks the local and remote environment boundary without starting a VM.

For poll/signal ABI checks, POLL_SIGNAL_LINK_MODE=static selects a separately validated static-musl fixture; the default remains dynamic. Use POLL_SIGNAL_CASE=mask-restore or sibling-ppoll with the existing test-poll-signal-{oracle,linux,hl} targets. Static selected cases have paired coverage; dynamic startup timeouts remain recorded in the plan.

make test-family-unit-linux runs the managed page/token foundation on Linux or Lima, including packed objects, owner death and committed slot recovery. make test-family-object-smoke-hl HL_BIN=../hyper-linux-rvrt-host/_build/hl checks single-process shared objects against the isolated host companion. make test-family-managed-linux checks guarded CPU-memory helpers, aliases, atomic reservations, two-slot stores and remote same-value invalidation; make test-family-managed-smoke-hl checks the same single-process helpers. make test-family-mm test-mm-view checks canonical anonymous MM roots and transactional local reconciliation, including native-process updates, redo crashes, allocation rollback and retained copyout. Their -sanitize and -linux variants run ASan/UBSan and static AArch64 Linux components. These components have separate runtime admission checks described below. make test-mm-protect test-mm-protect-sanitize checks canonical permission transactions, partial-prefix errors, no-op identities and peer copyout. make test-mm-protect-linux test-mm-protect-oracle-linux runs the component and an independent real-kernel prefix oracle on AArch64 Linux. make test-guest-memory-canonical test-guest-memory-canonical-sanitize checks internal session ownership, guarded refresh admission, OOM retry and teardown without refreshing; test-guest-memory-canonical-linux runs it on AArch64 Linux. The ordinary runtime keeps its existing memory path; the internal source runtime selects the canonical constructor. make test-mm-runtime-binding test-mm-runtime-binding-sanitize checks the canonical memory-syscall adapter and atomic file replacement; the -linux and -hl targets run the same AArch64 component on Linux and Hyper-Linux. make test-guest-memory-canonical-exec test-guest-memory-canonical-exec-sanitize checks the internal same-PID exec foundation, with corresponding -linux and -hl targets. These component and exec checks do not open the public source profile. The internal source runtime now admits selected guest threads with exact canonical MM membership and has focused fork/exec acceptance, including live sibling exec. Public source routing remains gated; component checks do not establish full R5 support. make test-mm-fork test-mm-fork-sanitize checks the canonical fork memory component: exact private state with fresh keys, shared aliases, and file-origin registration before a delayed child attaches. Its -linux and -hl targets run the same AArch64 component on both hosts. Public source routing remains gated. make test-mm-join test-mm-join-sanitize checks shared-MM child ownership, current-root reconciliation and owner-selective retirement; its -linux and -hl variants execute identical AArch64 component bytes. make test-guest-memory-canonical-threads test-guest-memory-canonical-threads-sanitize checks split local attachment, guarded admission, refresh, retirement and cleanup-only ownership. Its -linux and -hl targets run the same AArch64 component on both hosts. make test-canonical-thread-edges-linux test-canonical-thread-edges-hl checks cancellation before the first guest turn and a fatal worker fault with bounded group teardown. Set CANONICAL_THREAD_RUNTIME to the absolute path of the frozen internal runtime when replaying it; the -oracle target checks the independent Linux-user QEMU outcomes. make test-file-exec-truncate-linux test-file-exec-truncate-hl checks the same warmed executable-file mapping through the interpreter and JIT on both hosts. Set FILE_EXEC_TRUNCATE_RUNTIME=/absolute/path/to/frozen-runtime to name the exact existing runtime for a replay; Make then uses that artifact instead of its default runtime path. make test-native-file-exec-truncate-linux is the independent AArch64 Linux kernel oracle. The strict test-file-exec-truncate-oracle QEMU comparison currently returns fixture exit 19 after the post-truncate call returns instead of faulting; it remains RED, with no expected-failure exemption. make test-file-jit-linux test-file-jit-hl checks two real native executions of file-backed arithmetic around a file write and instruction-cache flush. test-anonymous-jit-linux/-hl/-oracle checks the corresponding guest-store case; its Linux-user QEMU oracle passes. test-file-jit-boundary-linux/-hl warms a two-instruction native block across a page boundary, truncates the second page, then checks the SIGBUS PC, address and earlier committed register value. Its post-truncate execution may use precise interpreter fallback. These targets use FILE_JIT_RUNTIME to select a frozen internal runtime. test-jit-progress checks the interval-counter parser and rejects unrelated JIT work as evidence of mapped-code execution. The strict test-file-jit-oracle and test-file-jit-boundary-oracle comparisons remain RED on QEMU10.1: it executes stale code after these file mutations. Their expected results remain unchanged; an independent oracle failure is reported separately from rvrt's Linux and hyper-linux results. make test-mm-unmap test-mm-unmap-sanitize checks transactional interval removal, retained aliases and pending copyout. test-mm-unmap-linux and test-mm-unmap-oracle-linux run the component and an independent Linux syscall oracle; invalid bounds remove no prefix and hole-only success keeps identity. make test-mm-map test-mm-map-sanitize checks internal anonymous mapping transactions, fixed replacement zeroing, retained aliases, NOREPLACE and allocation failure. test-mm-map-linux test-mm-map-oracle-linux runs the component and independent kernel expectations on AArch64 Linux. make test-mm-brk test-mm-brk-sanitize checks internal heap transactions and metadata-only peer refresh; test-mm-brk-linux test-mm-brk-oracle-linux runs the component and raw Linux kernel expectations. make test-brk-hole ENGINE=interp checks the actual RV64 guest shrink regression through both hosts and the raw kernel oracle; repeat with ENGINE=jit. make test-mprotect-limit ENGINE=interp checks the actual RV64 guest syscall at the supported VA limit through Linux, explicit hyper-linux invocation and QEMU; repeat with ENGINE=jit. A later hole preserves an earlier protected prefix, while arithmetic wrap changes nothing. The fresh source runtime passes; the older installed package 3f8eeefb fails this new regression. make test-private-paths-linux checks private inode denial without dropping process record locks. make test-family-leave-linux checks cleanup after file unlock and before another local thread enters. make test-guest-memory-linux and make test-guest-memory-hl check runtime startup adoption, private-inode protection and cleanup, including worker handoff and an idle detach racing a sibling leave. Each admitted guest worker holds its own family guard. Reads park the worker and release the guard around native I/O, then reacquire it before completing or discarding owned copyout. Other potentially blocking calls with multiple live workers still return EOPNOTSUPP. make test-linux-file-workers-linux and -hl check per-call callbacks, retained descriptor leases and rebased copyout using real native workers; this component test is separate from guest-runtime acceptance. make test-native-signal-stop-linux and -hl check the private stop carrier and reader cancellation boundary. make test-clone-blocked-read-linux CLONE_BLOCKED_READ_CASE=group-exit and -hl check guest teardown; readiness provides scheduling opportunity without proving kernel-blocked entry. make test-linux-file-writes and its -linux/-hl variants check retained staged write/writev data through descriptor reuse with native workers. make test-clone-pipe-write-oracle checks seven pipe-write/readiness cases against QEMU. Its -linux/-hl variants select CLONE_PIPE_WRITE_CASE=all or named cases: sigpipe, group-exit, atomic, partial, readiness, large-write, and large-writev. The latter two require one syscall to write 131073 unaligned bytes, verified through EOF. Native SIGPIPE masking is scoped to the owned-pipe write and restores the prior bit before returning. make test-linux-futex-linux and -hl check actual queued namespace/mask filtering, retained mappings and clear-tid wake. make test-futex-signal-linux and -hl check saved guest syscall state and timed/untimed restart behavior with external USR1 delivery; make test-futex-signal-oracle uses QEMU. make test-clone-requeue-linux and -hl check normal/compare/same-key requeue against independent QEMU expectations, with optional CLONE_QUANTUM=N. make test-clone-rv64-oracle runs the finite raw-clone fixtures under QEMU; make test-clone-rv64-linux ENGINE=interp CLONE_QUANTUM=1 and make test-clone-rv64-hl ENGINE=jit CLONE_QUANTUM=256 run the same fixtures through rvrt. --quantum N sets a positive retired-instruction budget; the current default is64, selected from measured handoff costs in the pthread workload. Use --quantum 1 to stress instruction-by-instruction scheduling. A bounded allowance preserves constrained LR/SC progress. make test-clone-signal-read-oracle checks the cross-worker read/signal fixtures with Linux-user QEMU; test-clone-signal-read-linux and -hl run them through rvrt, with CLONE_SIGNAL_READ_CASE=interrupt|restart|process|all. test-native-signal-wake-linux and -hl check coalesced native notifications, independent target selection and ordinary read completion after notifications. Shared guest memory, futexes, full pthread compatibility, extended signal behavior and process lifecycle remain required implementation work. make test-threads-oracle LIBC=musl and make test-signals-oracle LIBC=musl run the named pthread and signal fixtures against Linux-user QEMU; repeat with LIBC=glibc. Build them with the corresponding test-threads-fixture and test-signals-fixture targets in the matching toolchain shell. Their -linux and -hl targets are required acceptance lanes; cooperative delivery and the named external signal/read/wait cases pass, while wider signal, pthread and process cases still expose unfinished R5 behavior. THREAD_FIXTURE, THREAD_SYSROOT, SIGNAL_FIXTURE and SIGNAL_SYSROOT select previously provisioned, hash-verified artifacts. make test-fork-wait-oracle checks the raw fork, wait-status, pipe-EOF, three-generation and retired-helper fixtures against QEMU; make test-fork-wait-linux ENGINE=interp and ENGINE=jit run the same cases through rvrt. The Linux fork path supports clone(SIGCHLD) from initial and helper workers, including with live siblings and after helpers retire, plus restricted wait4. It preserves private/shared memory, inherited descriptors and signal-handler frames. Check the latter with make test-r5-fork-signal-linux ENGINE=interp and its JIT/oracle variants. make test-r5-fork-tid-linux ENGINE=interp and its JIT variant cover selected parent/child TID flags, best-effort pointer faults and mm-owned clear-tid. make test-fork-tid-native-linux independently checks generic Linux behavior; the pinned QEMU parent-TID discrepancy remains a strict oracle failure. make test-r5-fork-multi-linux FORK_MULTI_CASE=leader-idle ENGINE=interp and FORK_MULTI_CASE=leader-read exercise live peers; repeat with ENGINE=jit. make test-r5-fork-poll-lease-linux ENGINE=interp and its JIT variant require EOF while the fork child remains alive after dropping copied poll leases. The -native and -oracle targets provide independent reference behavior. make test-r5-fork-nonleader-chain-linux ENGINE=interp and its JIT variant check real libc fork from a helper, post-fork pthread creation, a nested fork, nonzero child statuses and the same sequence after exec. Its -native and -oracle targets check the fixture independently; -cancel-linux requires exactly three actual owner-cleanup cancellation-state checks. make test-exec-launch checks the real exec owners' activation order and exact descriptor-flag rollback after native exec and injected activation failures; test-exec-launch-sanitize and test-exec-launch-linux check that same unit under sanitizers and on AArch64 Linux. Set EXEC_ROLLBACK_MULTI_DIAGNOSTIC=1 on the existing test-r5-exec-rollback-multi-linux or -suspended-linux targets to exercise the private diagnostic channel as well as blocked siblings and FD aliases. make test-r5-fork-rollback-hook-linux ENGINE=interp and its JIT variant inject one native-fork failure after snapshot preparation, verify the original parent/peer state, then require a successful retry and nested child execution. Wider process failure behavior, complete libc process behavior, full exec qualification and orphan lifecycle remain required work. Hyper-linux fork targets still fail behind the companion's process gate. make test-signal-context-linux ENGINE=interp and its -hl/JIT variants check a raw handler-edited PC, every GPR/FPR and FCSR against the independent test-signal-context-oracle. test-signal-frame and test-linux-signal exercise wire layout, masks, pending order, nested altstacks and invalid-frame handling; their -linux/-hl variants run the same AArch64 unit artifacts. make test-trap-signal-linux ENGINE=interp and its -hl/JIT variants check illegal instructions, breakpoints, mapping/permission faults and atomic alignment. test-trap-signal-oracle labels QEMU's different misalignment siginfo expectation. test-linux-trap-signal checks the Linux mapping directly. make test-native-signals-hl NATIVE_SIGNAL_CASE=ppoll-ignore checks the native AArch64 boundary under the companion's explicit RVRT policy; x8, ppoll and sender select the other probes. The external sender canary now passes under the opt-in companion policy. That host-boundary result does not by itself qualify guest signal-frame, restart, or multi-thread behavior.

nix develop -c make check
nix develop -c make fixtures
./_build/rvrt inspect _build/hello-rv64

make help lists targets. The inspector is a native host executable (Mach-O on macOS, ELF on Linux). A host C11 compiler, Make and Python 3 can also run make check. LLVM's Clang and LLD build the optional real RISC-V ELF fixtures. nix build packages the native inspector and runs make check-inspector (the 20 parser tests). The package source includes only inspector inputs and the shared Make dependency catalog; it does not compile runtime code. make check retains the broader native runtime/component aggregate. make test-fixtures also inspects the LLVM-built RV32/RV64 executables.

On macOS, nix develop .#toolchain-rv64-musl-clang -c make toolchain-check cross-compiles the existing dynamic and static RV64GC/LP64D C and C++17 toolchain probes with host-native Clang/LLD. The shell uses target CRT, musl, GCC runtime and libstdc++ files from the locked x86_64-linux RV64 musl package closure as data; it never executes that closure's Linux GCC or binutils. The existing toolchain-rv64-musl GCC shell is unchanged. This checks fixture compilation and ELF metadata, not RV64 runtime execution. The thread, hwprobe, signal, exec, process and C++ fixture builders honor RV_CC_EXECUTION: auto keeps each builder's existing placement; host or lima selects the compiler's actual execution platform. The optional Clang shell sets host. Guest execution remains separate from compiler placement.

The Clang/LLD inputs use Apache-2.0 WITH LLVM-exception (and the LLVM/NCSA license notices), musl uses MIT, and GCC-derived target headers/runtime files are covered by the GNU GPL v3-or-later and applicable GCC runtime exceptions. The toolchain shell keeps these inputs as Nix references, so their locked nixpkgs license metadata remains available alongside the compiler tools.

Build the separate runtime with nix develop -c make runtime-linux fixtures. nix build .#rvrt-linux-aarch64 packages that static-PIE runtime and its Apache-2.0, SoftFloat and Mbed TLS license/provenance files. The separate nix build .#softfloat-aarch64 output provides its reusable target archive; ordinary runtime source changes reuse it. Both packages use the pinned flake toolchain and the root Make rules. The runtime has no hyper-linux build or link dependency.

For a manual runtime link against a previously built target archive, use make SOFTFLOAT_PREBUILT=1 SOFTFLOAT_AARCH64=/path/to/libsoftfloat.a runtime-linux. The prebuilt mode requires that file to exist and omits the vendor archive build rule. The default SOFTFLOAT_PREBUILT=0 continues to build SoftFloat from the vendored sources.

An optional Clang-built package is available with nix build .#rvrt-linux-aarch64-clang. It installs the same bin/rvrt-linux-aarch64 static-musl AArch64 PIE and license files, and uses the flake-pinned Clang, LLD, musl headers/libraries and GCC target runtime libraries. On AArch64 Linux, run the installed artifact directly with ./result/bin/rvrt-linux-aarch64 --engine=interp -- TARGET_PATH GUEST_ARGV0; for an explicit output path, use nix build --no-link --print-out-paths .#rvrt-linux-aarch64-clang and append /bin/rvrt-linux-aarch64 to the returned store path. The existing rvrt-linux-aarch64 package remains the default GCC output. Its latest current-source bounded Nix compile stopped at the 600-second limit before verification or installation, so that GCC package revision remains unqualified; the Clang package is a separate build result.

For build diagnostics, add BUILD_TIMING=1 to report live start/end records and elapsed nanoseconds for runtime and target SoftFloat build phases. For a resumable runtime build, use make runtime-linux RUNTIME_OBJECT_BUILD=1 BUILD_DIR=_build/runtime-objects-dev. It retains completed objects, tracks headers and compiler flags, and publishes the executable after static-PIE verification. The ordinary build remains the default; use a distinct build directory for the optional object mode. For direct cross builds, set A64_CC and A64_AR to the AArch64 Linux musl compiler and target archiver; the native host archiver does not build this ELF archive. On AArch64 Linux, run:

./_build/rvrt-linux-aarch64 --engine=interp -- _build/hello-rv64 chosen-argv0
./_build/rvrt-linux-aarch64 --engine=jit --stats -- _build/hello-rv64 chosen-argv0

Use --source-mode=canonical for the finite source-family profile:

./_build/rvrt-linux-aarch64 --source-mode=canonical --engine=jit -- TARGET_PATH GUEST_ARGV0
hl --rvrt-runtime ./_build/rvrt-linux-aarch64 --rvrt-engine jit --rvrt-arg --source-mode=canonical -- TARGET_PATH GUEST_ARGV0

This requires the companion's owned lifetime-socket fork support. The option does not select a filesystem trust policy; --file-identity and --family-authority retain their separate contracts. Check the public fork fixture with make test-fork-file-canonical-linux ENGINE=interp and make test-fork-file-canonical-hl ENGINE=jit, setting FORK_FILE_CANONICAL_RUNTIME and HL_BIN to the desired built artifacts. The focused worker mapping cases use make test-r5-canonical-mmap-gate-plain-linux-interp or make test-r5-canonical-mmap-gate-plain-hl-jit. Set RVRT_RUNTIME, CANONICAL_MMAP_GATE_FIXTURE, CANONICAL_MMAP_GATE_SYSROOT and HL_BIN when reusing pinned artifacts. The separate -held- targets build or require a test-hook runtime; the resample case currently fails at refused worker O_TRUNC.

--trace-syscalls prints guest syscall inputs and returned results to stderr without instruction tracing. --trace retains both instruction and syscall logging. Both flags are off by default; exit and context-restoring syscalls may have an input line without a returned-result line.

To exercise the initial executable-cache path on native Linux ext4/tmpfs, build make runtime-linux test-aot-cache-runtime-fixtures, create a private directory, and run the same command twice:

cache_dir="$(mktemp -d)"
./_build/rvrt-linux-aarch64 --engine=jit --stats --cache-dir "$cache_dir" -- _build/aot-cache-entry-rv64 chosen-argv0

The cold run reports cache=stored reason=cold; the warm run reports cache=hit reason=executed only after cached code actually runs. Unsupported filesystems, ACLs, unsafe permissions, stale/corrupt records and failed cache operations preserve normal guest execution. Cache paths use the translator's filesystem view. The initial auto policy certifies local ext4/tmpfs only. APFS requires the explicit trusted-host policy --cache-authority=hyper-linux-apfs-acl-v1 and a qualified hyper-linux ACL companion; older passthrough hosts do not qualify. A record digest cannot establish trust in attacker-modified generated code. See the host contract for the authority boundary.

make test-aot-cache-runtime-linux checks cold/warm execution, corruption and native file-size-limit fallback. make test-aot-cache-runtime-hl HL_BIN=/path/to/qualified/hl checks the same runtime through the qualified host. These commands require the existing AArch64 cross toolchain and, on macOS, the configured Lima VM.

--cache-blocks=2 extends the default entry record with the direct prefix at the sequential return PC of its terminating ecall, when eligible. Each block has separate recovery metadata and a cache-block offset=... executed=... diagnostic under --stats; an executed hit requires that exact published block to run. make test-aot-multiblock HL_BIN=/path/to/qualified/hl checks both blocks, explicit pretranslation, changed layouts, disabled caching and precise fallback after execute permission is removed, with Linux-user QEMU expectations. --cache-blocks=3 through --cache-blocks=16 opt into bounded discovery within the selected initial image entry's executable segment. It follows checked direct branches, jumps and ecall continuations, including cycles and targets before entry; control-flow instructions still run in the interpreter. An adjacent emitted AUIPC with nonzero destination followed by a legal matching JALR, C.JR or C.JALR also prepares its PC-relative callee and, for linked calls, the continuation at the original instruction length, including when the pair crosses the instruction quantum. Supported 16-bit RV64C integer operations are expanded only when the existing direct-JIT classifier accepts their 32-bit equivalent; the original encoding, guest PC, and 2-byte length remain attached to the instruction. Discovery can therefore cache mixed 2-byte and 4-byte direct blocks. Compressed memory, floating-point, and control-flow instructions still use the interpreter, as do unsupported operations. Discovery visits at most128 roots and emits at most the requested number of blocks. Static binaries select their main entry; dynamic binaries select the pinned PT_INTERP entry, with both images bound into identity. This is not full DSO or arbitrary-code discovery. make test-aot-discover test-aot-discover-sanitize checks the bounded discovery component, including fault classification and records larger than8KiB. make test-aot-pcrel-linux test-aot-pcrel-hl checks an indirect call across the 32-instruction quantum, with an independent Linux-user QEMU result. Cold, warm, pretranslated and disabled-cache runs use the same runtime/fixture; warm runs must execute the cached callee and return continuation. make test-aot-pcrel-compressed-linux test-aot-pcrel-compressed-hl repeats these checks with an AUIPC/C.JALR pair after31 compressed instructions; the linked continuation is two bytes after C.JALR. Native discovery tests also cover unlinked C.JR, final-parcel bounds, and rejected producer/consumer pairs. make test-aot-mixed-width-linux test-aot-mixed-width-hl checks a static PIE with mixed 2-byte/4-byte source instructions through QEMU and both hosts. It checks cold/warm execution, non-executing pretranslation and validation, and disabled-cache behavior. make test-aot-mixed-width-rebase-linux test-aot-mixed-width-rebase-hl checks cached execution at a second PIE bias and rejects changed source. The cache record remains format v2 and stores the original source encodings and lengths; emitter identity v3 separates code generated with mixed-width decoding from older emitter output. Bounded fetches never read an incomplete final instruction parcel outside the selected image segment. make test-aot-cfg-dynamic-linux test-aot-cfg-dynamic-hl checks interpreted control flow through a cached ELF interpreter and an actual AT_ENTRY handoff.

make test-aot-dynamic HL_BIN=/path/to/qualified/hl checks startup caching of a purpose-built PT_INTERP entry, then transfer to the main image through AT_ENTRY. Dynamic records bind both immutable image snapshots, so changing either input selects a new key. Code offsets and relocations use the interpreter's own load bias. The test mutates and restores owned fixture inodes, runs host lanes serially, and compares loader/main output with Linux-user QEMU. General DSO discovery and libc-loader cache coverage remain open.

make test-aot-exec HL_BIN=/path/to/qualified/hl checks that guest exec preserves its PID and cache configuration, then executes the new target's prewarmed entry. Relative cache paths are copied as absolute spellings at launch, so guest chdir cannot retarget them. Every open rechecks authority. make test-aot-fork-linux checks parent and child hits independently: the parent executes both prefixes while the child resumes at the second. Disabled cache and Linux-user QEMU controls preserve process behavior. The normal HL native-fork gate remains closed.

make test-fsize-inherited compares guest-visible inherited file-size limits with QEMU, then checks both engines on Linux and hyper-linux. The Linux cases keep the original hard limit, vary only a child soft limit, and verify cache refusal or a warm HIT without changing the guest-visible pair. Ordinary guest prlimit64 currently supports only a read of RLIMIT_FSIZE for self.

make test-fsize-hard0-linux checks inherited soft/hard limits of0/0: hello, the guest limit query and the bounded clone/exec rejection policy on both engines. The same ordinary runtime also passes these cases through make test-fsize-hard0-hl HL_BIN=/path/to/qualified/hl; this named test selects --family-authority=hyper-linux-apfs-acl-v1. Runtime AUTO still declines APFS. The policy is separate from cache authority and file identity. Its CLI checks are test-family-authority-cli-linux and test-family-authority-cli-hl. This checkpoint uses one worker without the source service. The allocation crash window, full HL wait capacity, source-service attachment and full thread/process support remain open. Its -oracle companion checks independent QEMU expectations; test-fsize-hard0 includes both hosts. The internal source runtime also passes the Linux cases with retained service cleanup. The executable-cache suite checks hard-zero cold fallback and warm executed hits. See the support matrix for these temporary limits and exact artifact ledger.

Use the same runtime to prepare the startup translation without executing guest instructions:

./_build/rvrt-linux-aarch64 --pretranslate --cache-dir "$cache_dir" -- _build/aot-cache-entry-rv64 chosen-argv0

It reports pretranslation=stored reason=cold or pretranslation=validated reason=cache. The next ordinary JIT run uses that record. The default covers one direct 32-bit RV64 startup entry block: the static main or pinned PT_INTERP image. Unsupported direct prefixes, including compressed-only entries, deliberately decline while ordinary execution remains available. Dynamic identity binds both main and interpreter snapshots. Unavailable storage or unsupported input returns1, invalid options return2, and an internal invariant failure returns125. Successful pretranslation returns0. It selects JIT emission by default and accepts --stats; explicit interpreter, trace, step-limit and progress options are rejected. make test-pretranslate checks both hosts, including later cached execution. Add --cache-blocks=2 to pretranslate the same eligible pair described above. Supply PRETRANSLATE_INTERP_FIXTURE and PRETRANSLATE_SYSROOT to include a provisioned valid dynamic image with an unsupported direct prefix, such as a compressed entry. Its expected decline is reason=emit. Broader block/DSO discovery and cache propagation remain open.

Runtime diagnostics follow current guest stderr. Closing or replacing guest2 closes or redirects default logging without an implicit retained pipe endpoint. For complete cleanup/total timings, explicitly dedicate a separate descriptor:

./_build/rvrt-linux-aarch64 --stats --diagnostic-fd 9 -- _build/hello-rv64 chosen-argv0 9>rvrt.log

The runtime consumes native9 as a private channel; guest9 is not imported. The channel also survives guest exec/fork. Default --stats prints kind=execution before descriptor teardown with cleanup-total-excluded; the explicit channel prints kind=final after cleanup. Both routes preserve instruction counts and completed inclusive measurements.

--stats enables monotonic per-phase wall timers and instruction counts. Linux measurements use a direct clock syscall so cached host vDSO timestamps do not collapse short phases to zero. make test-measure-clock-linux and its -hl counterpart report empty-pair overhead without imposing a speed threshold. Phase times are inclusive: memory and file I/O nest inside execution and must not be summed as independent costs. Clock failures, backward samples and overflow are reported. Disabled instrumentation reads no clocks. Observation adds overhead, especially where clock reads require host syscalls; compare bounded workloads with and without observation before interpreting timings. Cache preparation reports aot_prepare plus nested authority, identity, emission, read, verification, relocation and write phases. The read/write phases include their internal authority checks. Cached RX publication uses publish. These measurements do not establish a speed benefit; warm loading still emits fresh code to validate saved text.

--stats-sample N enables observation with one timed call in every N per phase. calls counts completed calls, samples counts successful timed calls, and ns is their raw duration sum. Unsampled time is never silently estimated. Use different periods to check sampling bias; inclusive phases still overlap.

--progress-sample N adds worker-local progress records every N attempted instructions, plus worker, futex, I/O and join lifecycle markers. Each interval reports instruction and yield deltas with the guest TID and PC. Scheduler and guard timings sample one call in 128; native futex sleep is timed on every call. The reported nanoseconds are raw sampled sums, with clock validity and failure counts. They are not estimates of all calls or disjoint total costs. This diagnostic is off by default and preserves syscall errno; output and clock reads can affect scheduling. When combined with --stats or --stats-sample, each emitted progress interval also prints a cumulative timing snapshot. Timing headers identify kind=snapshot, kind=execution or kind=final. Snapshot rows contain process-wide completed measurements only; open worker stamps and the still-open total timer are omitted. Phase counters stay cumulative and raw, without extrapolation. Use make test-progress for its focused checks.

--sysroot PATH prefixes absolute guest PT_INTERP and openat paths. The target path is opened literally in the runtime's filesystem view (or supplied through --image-fd); relative interpreter paths use cwd. The guest dynamic linker owns relocations and guest TLS. Relative file paths use native cwd or a guest directory descriptor. Absolute symlink targets restart at native /, preserving prefix-only filesystem behavior. Sysroot prefixing is not confinement.

--expect-image SHA256_HEX:DECIMAL_SIZE checks the exact initial image bytes before guest entry. The configured Hyper-Linux launcher computes this value from the pinned RV64 target and inserts it into the runtime command. Forwarded --rvrt-arg --expect-image or --rvrt-arg --expect-image=... is rejected because it conflicts with the host's checked target identity; a literal --rvrt-arg -- is rejected as an invalid forwarded value. This is a consistency check over the captured image, not an authenticity claim. Initial host launch cases remain under qualification.

On macOS Apple Silicon, invoke the same runtime through the isolated companion's explicit RVRT policy. This supplies a pinned target descriptor, coherent shared backing and owner identity required by managed memory:

../hyper-linux-rvrt-exec-dispatch/_build/rvrt-exec-script-v4/hl --rvrt-runtime ./_build/rvrt-linux-aarch64 --rvrt-engine jit _build/hello-rv64
# An explicit guest argv0 uses the existing separator form:
../hyper-linux-rvrt-exec-dispatch/_build/rvrt-exec-script-v4/hl --rvrt-runtime ./_build/rvrt-linux-aarch64 -- _build/hello-rv64 chosen-argv0

Set HL_BIN to the qualified companion binary for -hl Make targets until the companion changes are integrated. make test-rvrt-launch checks ordinary RV64 ELF selection, explicit argv0, negative startup cases and both descriptor- zero layers. The configured translator leaves native A64/x64/A32 initial ELF routes unchanged. A configured native AArch64 Linux process can also exec an RV64 ELF with the same PID. This admission requires one live worker, no previous native fork relay and the supported stdio/regular descriptor table; closed standard descriptors remain closed. A native script exec can select a pinned RV64 interpreter, preserve the original script AT_EXECFN and pass one opaque optional shebang argument. A conflicting forwarded --execfn returns EINVAL before teardown. Native runtime masks, pending USR1 and ignored USR2 survive, while caught handlers reset. Initial host script selection, broader descriptor/worker states and full fork/sysroot propagation remain open. make test-rvrt-native-exec-hl ENGINE=jit and ENGINE=interp check actual exec, empty argv, PID/auxv, signal state, closed descriptors and pre-reset failures. make test-rvrt-native-script-exec-hl focuses on shebang argv, original-script identity and exact selected-runtime errors. make test-rvrt-native-exec-linux runs the same assertions against native AArch64 Linux exec; test-rvrt-native-controls-hl and -linux check native fork and signal controls. For ordinary AArch64 runtime invocation, hl --rvrt-native RUNTIME [RUNTIME_ARGS...] selects the same memory/signal policy while preserving native argv and inherited descriptors. It does not add a foreign target or AT_EXECFD. Host-target descriptor-zero coverage uses the pinned handoff form; runtime image-FD-zero coverage is a separate test.

make test-rvrt-parent-notify-oracle checks the small RV64 parent-signal fixture against Linux-user QEMU. test-rvrt-parent-notify-linux runs the same fixture through the selected RVRT_RUNTIME; test-rvrt-parent-notify-hl checks the isolated fork/exec companion. All require the exact sender, marker, exit status and owned-process cleanup within 15 seconds. The full C sentinel remains test-rvrt-fork-exec-hl; select R6_FORK_EXPECTATION=inherited-stdio or two-generation for descriptor lifetime and repeated-fork coverage. These focused tests do not open the production fork admission gate.

make test-rvrt-wait-progress-oracle checks interrupted raw wait4 on native AArch64 Linux. test-rvrt-wait-progress-hl requires the same continuation PC, full-width signal-frame and resumed registers, exact sender and live child before final reap. Both keep the 15-second case deadline. The controller holds the child's stdin until the parent proves signal delivery and child liveness.

Use repeated --rvrt-arg WORD options to forward runtime flags verbatim, for example --rvrt-arg --stats-sample --rvrt-arg 1024. Runtime --sysroot paths must be visible inside the host filesystem view; host --sysroot is a separate filesystem/environment policy. That companion policy permits runtime pthread workers but keeps Hyper-Linux process clones behind its H2/R5 process-ownership gate. The Linux-host runtime has separate, restricted guest clone(SIGCHLD)/ wait4 support for qualified worker and fork fixtures; this does not establish full POSIX process semantics or open the Hyper-Linux gate.

--file-identity=auto is the runtime default. It admits verified Linux tmpfs file handles for clean read-only file futex keys. With a companion that provides the APFS handle contract, select --file-identity=hyper-linux-apfs-v1 explicitly:

hl --rvrt-runtime ./_build/rvrt-linux-aarch64 --rvrt-arg --file-identity=hyper-linux-apfs-v1 -- _build/hello-rv64 chosen-argv0

The selected policy survives runtime fork and guest exec. The host does not append it automatically. Unrecognized providers still permit ordinary file access and conservative mapping refresh; a clean read-only nonprivate futex requires a proven mapped-file identity and otherwise returns EOPNOTSUPP. Other required filesystem providers remain implementation work.

The target path and guest argv0 are separate arguments. Unhandled guest faults retain diagnostics and exit statuses; installed guest handlers can recover through edited signal contexts. The isolated hyper-linux companion fixes blocked-read signal interruption and passes the unchanged host smoke harness. That change has not yet been integrated into the main sibling checkout. Guest readonly truncation uses logical descriptor metadata and passes on both hosts while preserving the default hyper-linux contract.

Inspection checks ELF identification, program headers, load ranges and interpreter strings. It reports the float ABI and RVC flag without claiming instruction coverage. It does not parse ISA attributes, map segments, resolve an interpreter, or certify that a file can execute. Extended program-header numbering and big-endian inputs are explicitly unsupported.

Read the implementation plan for required deliverables, acceptance checks and progress; it is the sole execution record. RVRT.md retains architecture research and design. The draft host contract defines the proposed integration boundary and the hyper-linux changes needed. AGENTS.md contains repository working rules adapted from the local ../a32rt and ../hyper-linux projects. The requested ../r32rt was not present; ../a32rt is the AArch32 translator used as the reference.

Original work is Apache-2.0, Copyright 2026 Moritz Angermann moritz@zw3rk.com, zw3rk pte. ltd.

About

rvrt — Rosetta-style RISC-V (RV64GC/RV32GC) to AArch64 Linux user-mode binary translator

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages