RX toolchain 2026-11-08 (x86-64 Linux and Windows)

Prebuilt RX toolchain for x86-64 Linux and, new in this release, x86-64 Windows. Both are made by the CI:

Archive	Built by	Runs on
rx-toolchain-x86_64-linux.tar.xz	scripts/dist-toolchain.sh on Ubuntu 22.04	glibc 2.34 or later; checked on Ubuntu 22.04 and Debian 12
rx-toolchain-x86_64-windows.zip	scripts/dist-toolchain-windows.sh (host x86_64-pc-windows-msvc)	Windows x86-64; nothing to install for the programs themselves

Changes since toolchain-2026-11-05

Compiler and linker

rust a0454a4 (was 03738d3) and llvm-project 9119acc (was ada4a46).

• DFPU code (#115, #116, #117):
  • A f64 loaded into or stored from a DR register uses one dmov.d instead of two mov.l and two dmov.l.
  • The FPU and DFPU now handle the ueq / one compares and f32::min / max, f64::min / max in instructions.
  • The register allocator uses DR0-DR3 instead of DR0-DR1, so there are fewer spills (one benchmark function went from 144 to 99 instructions at -O2).
  • Compatibility: code from this compiler uses DR2 / DR3, and only this release's rx-rt saves them in interrupt entries. Update rx-rt together with the toolchain.
• Linker relaxation fixes (llvm-project#32):
  • with --no-relax, lld still honours the alignment of objects built with +relax;
  • 16-bit immediates for high addresses such as 0xffff8000 now link;
  • the assembler no longer picks a 3-bit .s branch across code the linker may shorten.
• rlib metadata as RX objects (#124): rustc writes an rx-none-elf rlib's lib.rmeta as an RX ELF object, with the code objects' e_flags. The rustc build now fetches the object crate from CDEF-inc/object.

New: the Windows toolchain (#118)

• It has the same contents as the Linux archive: rustc, cargo, rust-lld / ld.lld, the LLVM tools (also as rx-elf-*), LLDB and qemu-system-rx.
• LLVM, rustc and LLDB are built with Visual Studio's C++ tools, with the MSVC runtime linked statically. qemu-system-rx is built with MSYS2's MinGW, and its DLLs sit beside it in bin/.
• Build scripts still need the MSVC linker (Visual Studio Build Tools), as with any MSVC Rust.

rx-rust (the crates that go with this toolchain)

• New boards: the EK-RX74N and EK-RX74M (RXv3e) run the instruction, codegen, Rust and rt tests (#119, #120, #132).

• New crates:

  • rx74n-pac and its generator sfrx-pac (#121);
  • rx74n-hal:
    • GPIO, DelayNs and the RSCI12 UART (#122);
    • PLL 480 / 600 MHz (#123);
    • SPI on RSPIA0, PWM on GPTW8, ADC16H (#129-#131);
    • I2C on RI3C0 (#134).

  Both crates work on the RX74M too.

• rx72m-hal: SPI on RSPI2, ADC on S12AD, PWM on MTU6 (#125, #126, #128).

• rx-rt: interrupt entries save DR0-DR3 (#117).

• Fix: the HALs' busy waits had been optimized away, because core::hint::spin_loop is a no-op on RX (#133).

Contents

Each archive contains:

• the stage1 rustc with the rx-none-elf target, plus the library sources for -Zbuild-std;
• rust-lld, the RX port of lld and the target's default linker (also as bin/ld.lld);
• lldb, which debugs RX programs over the GDB remote protocol (no Python scripting);
• cargo;
• the LLVM binary tools, also under the rx-elf-* names: llvm-objcopy, llvm-objdump, llvm-nm, llvm-size, llvm-readelf, llvm-ar, llvm-strip, llvm-strings and llvm-addr2line;
• qemu-system-rx with the RXv2 / RXv3 / RXv3e CPU models and its shared libraries.

VERSIONS in each archive lists the commits; the Linux one also says which glibc it needs. The Linux VERSIONS is also attached here.

Requirements and use

• Rust programs need neither GNU binutils nor GCC, so the archives have neither.
• Build scripts need a host C compiler (build-essential on Linux, the MSVC tools on Windows).

Linux:

tar -xJf rx-toolchain-x86_64-linux.tar.xz
T=$PWD/rx-toolchain-x86_64-linux
RUSTC=$T/bin/rustc RUSTC_BOOTSTRAP=1 PATH=$T/bin:$PATH $T/bin/cargo build

Windows (PowerShell):

tar -xf rx-toolchain-x86_64-windows.zip
$T = "$PWD\rx-toolchain-x86_64-windows"
$env:RUSTC = "$T\bin\rustc.exe"; $env:RUSTC_BOOTSTRAP = 1; $env:PATH = "$T\bin;$env:PATH"
cargo build

Smaller code: add -C target-feature=+relax. FPU / DFPU for floats: add -C target-feature=+flush-denormals (see the README).

The tag is on the rx-rust commit that the toolchain goes with (crates/rx-rt, the HALs). Earlier releases:

• toolchain-2026-11-05 (glibc 2.34, LLDB target descriptions);
• toolchain-2026-11-03.3 (linker relaxation);
• toolchain-2026-11-03.2 (LLDB).

Sources

Component	Source
rx-rust	https://github.com/CDEF-inc/rx-rust/tree/939d1b9294a8552022861f1c3081df643e0b098f
rust	https://github.com/CDEF-inc/rust/tree/a0454a408060674e0dbdc1e45cd7786d3161308e
llvm-project	https://github.com/CDEF-inc/llvm-project/tree/9119accd73773335f392d88f64fd20d7a9232e99 (rustc's LLVM, lld, the LLVM tools and LLDB)
object	https://github.com/CDEF-inc/object/tree/rx/0.39 (a rustc dependency)
qemu	https://github.com/CDEF-inc/qemu/tree/ec286b3c27f5be1d681246e2902db45c15b85f62 (QEMU 11.1.2)

Each component keeps its own license: QEMU is GPL, libxml2 (linked into LLDB) is MIT, and the Rust and LLVM forks are under their projects' licenses.

Tested

• QEMU: the CI run on this commit (run 42440662431) passes scripts/run-all-tests.sh in four shards, including the LLDB session.

• Linux archive: scripts/check-dist.sh passes in ubuntu:22.04 and debian:12 containers. It builds and runs qemu-demo with the archive's tools.

• Windows archive: the Windows run on this commit passes scripts/check-dist.sh on the zip.

• Boards: these runs used toolchains built locally from the same rust and llvm-project commits, not these archives:

  • EK-RX74M, 2026-11-08: all 73 tests (insns, rom, codegen, rust, rt);
  • EK-RX74M, after #133 and #134: the RX74N rt group, including hw-i2c-rx74n;
  • AP-RX72M-0A, after #133: the RX72M rt group (34 ELFs).

  The full RX72M suite (insns, codegen) was last run for toolchain-2026-11-03.3.

SHA-256:

• rx-toolchain-x86_64-linux.tar.xz: d784ccb85b197eacafeec2e5042af605b5e6e7e663ad92e9de1beba63cb42150
• rx-toolchain-x86_64-windows.zip: 4aae6b435e5579e1244f3fb3caeace1243ee0f9d227f78885711157c60453030

RX toolchain 2026-11-05 (x86-64 Linux, glibc 2.34+)

Prebuilt RX toolchain for x86-64 Linux, made with scripts/dist-toolchain.sh by the CI on Ubuntu 22.04. Its binaries need glibc 2.34 or later (VERSIONS); it is checked on Ubuntu 22.04 and Debian 12.

Changes since toolchain-2026-11-03.3

The compiler, lld and the LLVM tools are the same sources as in toolchain-2026-11-03.3 (rust 03738d3, llvm-project ada4a46). What changed is how the archive is built, plus LLDB and rx-rt:

• Runs on older systems (#90, #110).
  • The archive is now built by the CI on Ubuntu 22.04, so it needs glibc 2.34 instead of 2.39.
  • qemu-system-rx brings its shared libraries (glib, pixman, ...) in lib/: no QEMU packages to install.
  • The CI checks the archive on its own in ubuntu:22.04 and debian:12 containers.
• LLDB reads the target description (#82, #113).
  • LLDB is now built with libxml2 (linked statically, so no new runtime dependency).
  • It uses the GDB server's target.xml and memory map.
  • On the RX72M bridge, register read psw / fpsw show the flag fields (IPL, PM, U, I, O, S, Z, C; FPSW's DN, RM, ...).
• rx-rt: interrupt entries with the RXv3 register bank (#106, #107).
  • rx_rt::interrupt!(n, handler, bank = b) saves the registers with save #b / rstr #b instead of pushing them.
  • The existing interrupt!(n, handler) is unchanged.
• rx72m-hal:
  • the UART receive path is checked on the board: echo, 4096 bytes, break → framing error (#112);
  • new examples/serial-echo.
• Development: the CI builds the toolchain and runs all tests on GitHub Actions (#89, #111), and run-all-tests.sh runs the tests in parallel (#108).

Contents

rx-toolchain-x86_64-linux.tar.xz contains:

• the stage1 rustc with the rx-none-elf target, plus the library sources for -Zbuild-std=core;
• rust-lld, the RX port of lld and the target's default linker. It is in lib/rustlib/x86_64-unknown-linux-gnu/bin, and bin/ld.lld links to it;
• lldb (with lib/liblldb.so), which debugs RX programs over the GDB remote protocol. It has no Python scripting;
• cargo;
• the LLVM binary tools, also under the rx-elf-* names: llvm-objcopy, llvm-objdump, llvm-nm, llvm-size, llvm-readelf, llvm-ar, llvm-strip, llvm-strings and llvm-addr2line;
• qemu-system-rx with the RXv2 / RXv3 / RXv3e CPU models and its shared libraries.

VERSIONS in the archive lists the commits and the glibc it needs.

Requirements

• Rust programs need neither GNU binutils nor GCC, so the archive has neither. To mix in C built by GCC, or to link with GNU ld, install binutils / GCC for rx-elf yourself.
• Build scripts need a host C compiler (build-essential).

tar -xJf rx-toolchain-x86_64-linux.tar.xz
T=$PWD/rx-toolchain-x86_64-linux
RUSTC=$T/bin/rustc RUSTC_BOOTSTRAP=1 PATH=$T/bin:$PATH $T/bin/cargo build
# smaller code:
RUSTFLAGS='-C target-feature=+relax' RUSTC=$T/bin/rustc RUSTC_BOOTSTRAP=1 PATH=$T/bin:$PATH $T/bin/cargo build

Debugging with LLDB

On QEMU's gdbstub:

rx-elf-objcopy -O binary target/rx-none-elf/debug/APP rom.bin
qemu-system-rx -M gdbsim-r5f562n8 -bios rom.bin -display none -S -gdb tcp:127.0.0.1:1234 &
lldb target/rx-none-elf/debug/APP -o 'gdb-remote 1234'

What works:

• breakpoints by Rust function name or by line;
• backtraces from the compiler's CFI;
• arguments, locals and structs;
• finish with the return value (aggregates too), thread return, next, step, up;
• registers (with flag fields where the server describes them), disassembly of every RX instruction set, watchpoints and globals.

Limits:

• LLDB has no Rust plugin, so types show their C names (unsigned int, ...);
• expressions cannot call functions.

On an RX72M board: scripts/hw-lldb.sh in rx-rust connects this LLDB to the server through a bridge.

• The setup is an E2 Lite plus e2 studio's e2-server-gdb on Windows.
• The bridge does not support watchpoints or the DFPU registers.
• See docs/NOTES-lldb.md.

The tag is on the rx-rust commit that the toolchain goes with (crates/rx-rt). Earlier releases:

• toolchain-2026-11-03.3 (linker relaxation);
• toolchain-2026-11-03.2 (LLDB);
• toolchain-2026-11-03.1 (LLVM tools instead of binutils);
• toolchain-2026-11-03.

Sources

Component	Source
rx-rust	https://github.com/CDEF-inc/rx-rust/tree/d1aee9909f0ff74d5064941f7560c53ccffb02a0
rust	https://github.com/CDEF-inc/rust/tree/03738d3cb6cc6e89aa5c928f5f6c9c730c05f658
llvm-project	https://github.com/CDEF-inc/llvm-project/tree/ada4a4635679c6a452292469500f29715010be22 (rustc's LLVM, lld, the LLVM tools and LLDB)
libxml2	2.13.9 from download.gnome.org (linked into LLDB)
qemu	https://github.com/CDEF-inc/qemu/tree/ec286b3c27f5be1d681246e2902db45c15b85f62 (QEMU 11.1.2)

Each component keeps its own license: QEMU is GPL, libxml2 is MIT, and the Rust and LLVM forks are under their projects' licenses.

Tested

• QEMU: the CI run on this commit (run 41945241218) passes scripts/run-all-tests.sh (331 / 331, in four shards), including the LLDB session.
• The archive itself: scripts/check-dist.sh passes in ubuntu:22.04 and debian:12 containers with no QEMU packages. It builds and runs qemu-demo (release and dev) with the archive's tools.
• RX72M board:
  • The full scripts/hw-run.sh suite was not run for this release; the last full run is the one listed for toolchain-2026-11-03.3.
  • On the board, only these were checked:
    • examples/serial-echo, with the debugger attached;
    • LLDB's PSW / FPSW flag fields through scripts/hw-lldb.sh.

SHA-256 of rx-toolchain-x86_64-linux.tar.xz: 2e88f7f7d6eca387b91e512b78034c1b343a833755123d477cfdecc1c7285c08

RX toolchain 2026-11-03.3 (x86-64 Linux, linker relaxation)

Prebuilt RX toolchain for x86-64 Linux, made with scripts/dist-toolchain.sh. It runs on glibc 2.39 or later (it was built on Ubuntu 24.04).

Changes since toolchain-2026-11-03.2

• Linker relaxation (#96). Opt in with -C target-feature=+relax (#104, #105):
  • the assembler marks the code with GNU-compatible R_RX_RH_RELAX hints;
  • lld shortens bsr.a / bra.a to bsr.w / bra.w / bra.b and mov.l #sym to the smallest immediate, and deletes alignment padding that is not needed;
  • in the test programs, code is 3–11 % smaller;
  • it is off by default; -C link-arg=--no-relax keeps the objects' alignment but does not shorten.
• Branch sizing (#96, part A; #103). The assembler sizes a branch inside a function from the real distance, so more branches take the short forms, even without +relax.
• LLDB:
  • aggregate return values and thread return follow the RX ABI (#84, #102);
  • an expression that calls a function now gives an error instead of crashing LLDB (#79, #100).
• The README covers floating point and what works (#94, #97).

The QEMU in the archive is unchanged.

Contents

rx-toolchain-x86_64-linux.tar.xz contains:

• the stage1 rustc with the rx-none-elf target, plus the library sources for -Zbuild-std=core;
• rust-lld, the RX port of lld and the target's default linker. It is in lib/rustlib/x86_64-unknown-linux-gnu/bin, and bin/ld.lld links to it;
• lldb (with lib/liblldb.so), which debugs RX programs over the GDB remote protocol. It has no Python scripting;
• cargo;
• the LLVM binary tools: llvm-objcopy, llvm-objdump, llvm-nm, llvm-size, llvm-readelf, llvm-ar, llvm-strip, llvm-strings and llvm-addr2line, also under the rx-elf-* names;
• qemu-system-rx with the RXv2 / RXv3 / RXv3e CPU models.

Requirements

Rust programs need neither GNU binutils nor GCC, so the archive has neither. To mix in C built by GCC, or to link with GNU ld, install binutils / GCC for rx-elf yourself.

qemu-system-rx needs QEMU's shared libraries; apt-get install qemu-system-misc brings them. Build scripts need a host C compiler (build-essential).

tar -xJf rx-toolchain-x86_64-linux.tar.xz
T=$PWD/rx-toolchain-x86_64-linux
RUSTC=$T/bin/rustc RUSTC_BOOTSTRAP=1 PATH=$T/bin:$PATH $T/bin/cargo build
# smaller code:
RUSTFLAGS='-C target-feature=+relax' RUSTC=$T/bin/rustc RUSTC_BOOTSTRAP=1 PATH=$T/bin:$PATH $T/bin/cargo build

Debugging with LLDB

On QEMU's gdbstub:

rx-elf-objcopy -O binary target/rx-none-elf/debug/APP rom.bin
qemu-system-rx -M gdbsim-r5f562n8 -bios rom.bin -display none -S -gdb tcp:127.0.0.1:1234 &
lldb target/rx-none-elf/debug/APP -o 'gdb-remote 1234'

What works:

• breakpoints by Rust function name or by line;
• backtraces from the compiler's CFI;
• arguments, locals and structs;
• finish with the return value (aggregates too), thread return, next, step, up;
• registers, disassembly of every RX instruction set, watchpoints and globals.

Limits:

• LLDB has no Rust plugin, so types show their C names (unsigned int, ...);
• expressions cannot call functions.

On an RX72M board, scripts/hw-lldb.sh in rx-rust connects this LLDB to the server through a bridge. The setup is E2 Lite plus e2 studio's e2-server-gdb on Windows. The bridge does not support watchpoints or the DFPU registers. See docs/NOTES-lldb.md.

The tag is on the rx-rust commit that the toolchain goes with (crates/rx-rt). Earlier releases:

• toolchain-2026-11-03.2 (LLDB);
• toolchain-2026-11-03.1 (LLVM tools instead of binutils);
• toolchain-2026-11-03.

Sources

Component	Source
rx-rust	https://github.com/CDEF-inc/rx-rust/tree/019938c670bec81f04350a374901d270e5385c43
rust	https://github.com/CDEF-inc/rust/tree/03738d3cb6cc6e89aa5c928f5f6c9c730c05f658
llvm-project	https://github.com/CDEF-inc/llvm-project/tree/ada4a4635679c6a452292469500f29715010be22 (rustc's LLVM, lld, the LLVM tools and LLDB)
qemu	https://github.com/CDEF-inc/qemu/tree/ec286b3c27f5be1d681246e2902db45c15b85f62 (QEMU 11.1.2)

Each component keeps its own license: QEMU is GPL, and the Rust and LLVM forks are under their projects' licenses.

Tested

• QEMU: scripts/run-all-tests.sh passes 321 / 321 on these sources. That includes the +relax variants of the Rust programs and the LLDB session.
• RX72M board: scripts/hw-run.sh passes 65 / 65 programs (178,310 checks), including the +relax variants. That run used rx-rust #104, which is before the three relaxation fixes in #105.
• The archive itself: extracted on its own, with PATH set to its bin plus /usr/bin:/bin:
  • it builds test/rust/lldb-demo;
  • it runs the program on its qemu-system-rx;
  • its lldb stops in scale, gives the backtrace down to _rx_reset, gets 9 from finish, then runs next and reads the global result = 28.

SHA-256 of rx-toolchain-x86_64-linux.tar.xz: e89a9f7d1963ca398629e669fe9ba65b8316e9efc855c27edb2963a9ae3a03e9

RX toolchain 2026-11-03.2 (x86-64 Linux, with LLDB)

Prebuilt RX toolchain for x86-64 Linux, made with scripts/dist-toolchain.sh. It runs on glibc 2.39 or later (it was built on Ubuntu 24.04).

This is toolchain-2026-11-03.1 plus LLDB with RX support (#76, #77). The compiler, lld and QEMU are unchanged. rx-rt now has CFI on _rx_reset, so that a debugger's backtrace ends there.

rx-toolchain-x86_64-linux.tar.xz contains:

• the stage1 rustc with the rx-none-elf target, plus the library sources for -Zbuild-std=core;
• rust-lld, the RX port of lld and the target's default linker. It is in lib/rustlib/x86_64-unknown-linux-gnu/bin, and bin/ld.lld links to it;
• lldb (with lib/liblldb.so), which debugs RX programs over the GDB remote protocol. It has no Python scripting;
• cargo;
• the LLVM binary tools: llvm-objcopy, llvm-objdump, llvm-nm, llvm-size, llvm-readelf, llvm-ar, llvm-strip, llvm-strings and llvm-addr2line, also under the rx-elf-* names;
• qemu-system-rx with the RXv2 / RXv3 / RXv3e CPU models.

No GNU binutils and no GCC: Rust programs need neither. To mix in C built by GCC, or to link with GNU ld, install binutils / GCC for rx-elf yourself.

qemu-system-rx needs QEMU's shared libraries; apt-get install qemu-system-misc brings them. Build scripts need a host C compiler (build-essential).

tar -xJf rx-toolchain-x86_64-linux.tar.xz
T=$PWD/rx-toolchain-x86_64-linux
RUSTC=$T/bin/rustc RUSTC_BOOTSTRAP=1 PATH=$T/bin:$PATH $T/bin/cargo build

Debugging with LLDB

On QEMU's gdbstub:

rx-elf-objcopy -O binary target/rx-none-elf/debug/APP rom.bin
qemu-system-rx -M gdbsim-r5f562n8 -bios rom.bin -display none -S -gdb tcp:127.0.0.1:1234 &
lldb target/rx-none-elf/debug/APP -o 'gdb-remote 1234'

What works:

• breakpoints by Rust function name or by line;
• backtraces from the compiler's CFI;
• arguments, locals and structs;
• finish with the return value, next, step, up;
• registers, disassembly of every RX instruction set, watchpoints, globals.

Limits:

• LLDB has no Rust plugin, so types show their C names (unsigned int, ...);
• expressions cannot call functions.

On an RX72M board (E2 Lite + e2 studio's e2-server-gdb on Windows), scripts/hw-lldb.sh in rx-rust connects this LLDB to the server through a bridge. It does not work with watchpoints or the DFPU registers. See docs/NOTES-lldb.md.

The tag is on the rx-rust commit the toolchain goes with (crates/rx-rt). Earlier changes: toolchain-2026-11-03.1 (LLVM tools instead of binutils) and toolchain-2026-11-03.

Sources

Component	Source
rx-rust	https://github.com/CDEF-inc/rx-rust/tree/56686efa63b7e107f027b3800f699f6d5a8b6d37
rust	https://github.com/CDEF-inc/rust/tree/6c5a1a856749a868cd198a0f7d4cfb8289dcb048
llvm-project	https://github.com/CDEF-inc/llvm-project/tree/6f6407e9e194c08260f40e5005d94bfec8885f15 (rustc's LLVM, lld, the LLVM tools and LLDB)
qemu	https://github.com/CDEF-inc/qemu/tree/ec286b3c27f5be1d681246e2902db45c15b85f62 (QEMU 11.1.2)

The sources for each component are at the links above. Each component keeps its own license: QEMU is GPL; the Rust and LLVM forks are under their projects' licenses.

Tested

• QEMU: scripts/run-all-tests.sh passes 281 / 281 on rx-rust #77, which has the same sources as this build except for one documentation line. That includes the LLDB session on QEMU and the LLDB lit test.
• RX72M board: the LLDB session works through the bridge. The board tests ran with toolchain-2026-11-03's compiler, which is unchanged.
• The archive itself: extracted on its own, with PATH set to its bin plus /usr/bin:/bin:
  • it builds test/rust/lldb-demo;
  • it runs the program on its qemu-system-rx;
  • its lldb stops at a breakpoint in scale, gives the backtrace down to _rx_reset, gets 9 from finish, then next and the global result = 28.

SHA-256 of rx-toolchain-x86_64-linux.tar.xz: 269b130faaabe200421e120aaa84c517a0db86e6ae6d827b879f728789b1f89d

RX toolchain 2026-11-03.1 (x86-64 Linux, no binutils)

Prebuilt RX toolchain for x86-64 Linux, made with scripts/dist-toolchain.sh. It runs on glibc 2.39 or later (it was built on Ubuntu 24.04).

This is toolchain-2026-11-03 with the LLVM binary tools in place of GNU binutils (#75). The compiler, lld and QEMU are the same builds from the same commits.

rx-toolchain-x86_64-linux.tar.xz contains:

• the stage1 rustc with the rx-none-elf target, plus the library sources for -Zbuild-std=core;
• rust-lld, the RX port of lld and the target's default linker, in lib/rustlib/x86_64-unknown-linux-gnu/bin. bin/ld.lld links to it;
• cargo;
• the LLVM binary tools:
  • llvm-objcopy, llvm-objdump (with the RX disassembler), llvm-nm, llvm-size, llvm-readelf / llvm-readobj, llvm-ar, llvm-strip, llvm-strings, llvm-addr2line / llvm-symbolizer;
  • the same tools under the rx-elf-* names, as links;
• qemu-system-rx with the RXv2 / RXv3 / RXv3e CPU models.

No GNU binutils

Rust programs do not need GNU binutils: rustc links with rust-lld, and asm! / global_asm! use LLVM's assembler. The rx-elf-objcopy, rx-elf-nm and similar names still work, but they now run the LLVM tools.

Not included any more: rx-elf-as, rx-elf-ld and GCC. To link with GNU ld (-C linker=rx-elf-ld) or to mix in C built by GCC, install binutils / GCC for rx-elf yourself.

qemu-system-rx needs QEMU's shared libraries; apt-get install qemu-system-misc brings them. Build scripts need a host C compiler (build-essential).

tar -xJf rx-toolchain-x86_64-linux.tar.xz
T=$PWD/rx-toolchain-x86_64-linux
RUSTC=$T/bin/rustc RUSTC_BOOTSTRAP=1 PATH=$T/bin:$PATH $T/bin/cargo build --release
rx-elf-objcopy -O binary target/rx-none-elf/release/APP rom.bin   # with $T/bin on PATH

The tag is on the rx-rust commit the toolchain goes with (crates/rx-rt). For the changes since toolchain-2026-10-29, see toolchain-2026-11-03.

Sources

Component	Source
rx-rust	https://github.com/CDEF-inc/rx-rust/tree/f0a780aae484b32a6444d7097549ada23ccba298
rust	https://github.com/CDEF-inc/rust/tree/92128dab160106f887dcccaa9e9d12a7c0145468
llvm-project	https://github.com/CDEF-inc/llvm-project/tree/b293c07e8384674414b90dd043e5761eeee70945 (also the LLVM tools)
qemu	https://github.com/CDEF-inc/qemu/tree/ec286b3c27f5be1d681246e2902db45c15b85f62 (QEMU 11.1.2)

The sources for each component are at the links above. Each component keeps its own license: QEMU is GPL; the Rust and LLVM forks are under their projects' licenses.

Tested

The archive was extracted on its own and run with PATH set to its bin plus /usr/bin:/bin:

• test/rust/qemu-demo builds and links with rust-lld;
• rx-elf-objcopy -O binary gives a 512 KB ROM image byte-identical to GNU objcopy's;
• rx-elf-nm lists the same symbols as GNU nm;
• size, readelf, objdump -d and strip work;
• the ROM image runs on the bundled qemu-system-rx: checks=8 failures=0.

The compiler and lld are the builds in toolchain-2026-11-03. That release's results apply to them: 279 / 279 QEMU tests, and 57 / 57 on the RX72M board.

SHA-256 of rx-toolchain-x86_64-linux.tar.xz: 967c847c78c4a2ddaff1e3ffaba0e490702e95e9310c8c821b5e4660ceb84003

RX toolchain 2026-11-03 (x86-64 Linux)

Prebuilt RX toolchain for x86-64 Linux, made with scripts/dist-toolchain.sh. It runs on glibc 2.39 or later (it was built on Ubuntu 24.04).

rx-toolchain-x86_64-linux.tar.xz contains:

• the stage1 rustc with the rx-none-elf target, plus the library sources for -Zbuild-std=core;
• rust-lld, the RX port of lld and the target's default linker, in lib/rustlib/x86_64-unknown-linux-gnu/bin. The same lld is also in bin/ as ld.lld, for linking C directly;
• cargo;
• the rx-elf binutils 2.43;
• qemu-system-rx with the RXv2 / RXv3 / RXv3e CPU models.

qemu-system-rx needs QEMU's shared libraries; apt-get install qemu-system-misc brings them. Build scripts need a host C compiler (build-essential).

tar -xJf rx-toolchain-x86_64-linux.tar.xz
T=$PWD/rx-toolchain-x86_64-linux
RUSTC=$T/bin/rustc RUSTC_BOOTSTRAP=1 PATH=$T/bin:$PATH $T/bin/cargo build --release

The tag is on the rx-rust commit the toolchain goes with (crates/rx-rt).

Changes since toolchain-2026-10-29

• Linker:
  • lld now supports RX and is the default linker (#73, #74). It links as GNU ld does: same relocations, e_flags and layout.
  • A Rust-only program no longer needs the rx-elf binutils.
  • -C linker=rx-elf-ld selects GNU ld.
  • GNU ld and lld can read a linker script differently. docs/NOTES-lld.md describes the case that rx72m-rom.ld hit.
• FPU / DFPU (opt-in, #71):
  • With -C target-feature=+flush-denormals, ordinary f32 code uses the FPU, and on RXv3 f64 code uses the DFPU. This covers arithmetic, compares and as.
  • NaNs and infinities follow IEEE; only denormals become ±0.
  • The default stays soft-float.
• More FPU / DFPU code generation (#65, #66):
  • FPU memory operands and the RXv2 3-operand forms;
  • f64 values kept in DFPU registers;
  • DFPU conversions.
• alloc: builds and is tested with a user-provided global allocator (#69).
• Code generation:
  • frame pointer, dynamic alloca and variadic function definitions (#68);
  • jump tables for switch (#63);
  • emul / emulu for multiply-high and division by constants (#62);
  • pushm / rtsd prologues and epilogues (#44).
• Debugging:
  • CFI for prologues and epilogues (#45, #64) and for rx-rt's interrupt entry (#46);
  • a DWARF producer string that e² studio's GDB accepts (#47).
• Tests: the mulh, frame and jt codegen tests now also run on the RX72M (#67).

Sources

Component	Source
rx-rust	https://github.com/CDEF-inc/rx-rust/tree/9fd801611221b15fc64cbbd712b1394e02d79dd0
rust	https://github.com/CDEF-inc/rust/tree/92128dab160106f887dcccaa9e9d12a7c0145468
llvm-project	https://github.com/CDEF-inc/llvm-project/tree/b293c07e8384674414b90dd043e5761eeee70945
qemu	https://github.com/CDEF-inc/qemu/tree/ec286b3c27f5be1d681246e2902db45c15b85f62 (QEMU 11.1.2)
binutils	GNU Binutils 2.43, unmodified, built by scripts/build-gnu.sh

The sources for each component are at the links above. Each component keeps its own license: binutils and QEMU are GPL; the Rust and LLVM forks are under their projects' licenses.

Tested

• QEMU: scripts/run-all-tests.sh passes 279 / 279 tests on the rx62n, rxv2, rxv3 and rxv3e models, linked with lld, plus a GNU ld loop.
• RX72M board: all 57 board tests pass on an AP-RX72M-0A.
• The archive itself: extracted on its own, it builds test/rust/qemu-demo, links it with rust-lld and runs it on its qemu-system-rx. The build also works with the rx-elf binutils hidden.

SHA-256 of rx-toolchain-x86_64-linux.tar.xz: 567c8894f5c33c7366d536802493fc9f0181711cd4146bd94da71f5a5f6f0926

RX toolchain 2026-10-29 (x86-64 Linux)

Prebuilt RX toolchain for x86-64 Linux, made with scripts/dist-toolchain.sh (#40). It runs on glibc 2.39 or later (it was built on Ubuntu 24.04).

rx-toolchain-x86_64-linux.tar.xz contains:

• the stage1 rustc with the rx-none-elf target, plus the library sources for -Zbuild-std=core
• cargo
• the rx-elf binutils 2.43
• qemu-system-rx with the RXv2 / RXv3 / RXv3e CPU models

qemu-system-rx needs QEMU's shared libraries; apt-get install qemu-system-misc brings them. Build scripts need a host C compiler (build-essential).

tar -xJf rx-toolchain-x86_64-linux.tar.xz
T=$PWD/rx-toolchain-x86_64-linux
RUSTC=$T/bin/rustc RUSTC_BOOTSTRAP=1 PATH=$T/bin:$PATH $T/bin/cargo build --release

The tag is on the rx-rust commit the toolchain goes with (crates/rx-rt).

Sources

Component	Source
rx-rust	https://github.com/CDEF-inc/rx-rust/tree/5403df931c37c1e7ce7ccfd30a94d29b2daa7995
rust	https://github.com/CDEF-inc/rust/tree/534e54e3cbae580764d6a61dde297de3ece60c78
llvm-project	https://github.com/CDEF-inc/llvm-project/tree/417e313d5d952de8918f99c23c7a275e5e029e05
qemu	https://github.com/CDEF-inc/qemu/tree/ec286b3c27f5be1d681246e2902db45c15b85f62 (QEMU 11.1.2)
binutils	GNU Binutils 2.43, unmodified, built by scripts/build-gnu.sh

The sources for each component are at the links above. Each component keeps its own license: binutils and QEMU are GPL; the Rust and LLVM forks are under their projects' licenses.

SHA-256 of rx-toolchain-x86_64-linux.tar.xz: 47bc12988c0a732c874fd6fd5df12005243bd7e6df3f8f71e227aed1271dfb83