Rust on Dreamcast: Difference between revisions
| Line 13: | Line 13: | ||
==Building a cross-compiling libgccjit.so for rustc_codegen_gcc== | ==Building a cross-compiling libgccjit.so for rustc_codegen_gcc== | ||
First, we must compile | First, we must compile <code>libgccjit.so</code>, the cross-compiling shared library, for your system. This entails building another copy of GCC once more in its own directory under <code>/opt/toolchains/dc/rust</code>. | ||
Using <code>git</code>, clone the rust-for-dreamcast repository to /opt/toolchains/dc/rust: | Using <code>git</code>, clone the rust-for-dreamcast repository to /opt/toolchains/dc/rust: | ||
| Line 27: | Line 27: | ||
Make any desired changes to the configuration, and then compile the SH4 toolchain: | Make any desired changes to the configuration, and then compile the SH4 toolchain: | ||
make build-sh4 | make build-sh4 | ||
When this command is completed successfully, a | When this command is completed successfully, a <code>libgccjit.so</code> will be installed to <code>/opt/toolchains/dc/rust/sh-elf/lib/libgccjit.so</code>. | ||
==Building rustc_codegen_gcc== | ==Building rustc_codegen_gcc== | ||
Revision as of 04:15, 3 February 2024
Preliminary support exists for developing for the Dreamcast using the Rust programming language. This is a bit of a challenge, however, as the official Rust compiler is based on the LLVM toolchain infrastructure, which does not support the Dreamcast's CPU SuperH architecture. Dreamcast programming is instead done with GCC, the GNU Compiler Collection. There exists two solutions to this problem:
- rustc_codegen_gcc: A libgccjit codegen backend for rustc (preferred method)
- gccrs: a Rust frontend for GCC
rustc_codegen_gcc
GCC includes a component called libgccjit which provides an API for an embeddable just-in-time code generator using GCC, useful for creating programs like interpreters. However, this component can also be used to generate code ahead of time as well. rustc_codegen_gcc is a project which interfaces the official Rust compiler with the libgccjit API to generate machine code from Rust using the GCC backend. With this, we can compile Rust programs for Dreamcast using familiar compiler tools such as rustc and cargo! The familiar borrow checker still works, and one can write #![no_std] crates with full libcore support. An experimental crate binding with KallistiOS provides liballoc functionality such as a heap and familiar collections like Vec, String, etc. as well.
We will build rustc_codegen_gcc support for the Dreamcast in the instructions below. Before we begin, though:
- You must already have a KallistiOS development environment set up. This means you have created a cross-compiling toolchain for SH4 and you have built KallistiOS with it. See Getting Started with Dreamcast development for more information.
- For the purposes of this guide, we will assume you are using the standard paths for Dreamcast tools; i.e. your environment is set up in
/opt/toolchains/dc.
- For the purposes of this guide, we will assume you are using the standard paths for Dreamcast tools; i.e. your environment is set up in
- You must already have a relatively up-to-date Rust installation, either using your operating system's package manager or rustup.
Building a cross-compiling libgccjit.so for rustc_codegen_gcc
First, we must compile libgccjit.so, the cross-compiling shared library, for your system. This entails building another copy of GCC once more in its own directory under /opt/toolchains/dc/rust.
Using git, clone the rust-for-dreamcast repository to /opt/toolchains/dc/rust:
git clone https://github.com/darcagn/rust-for-dreamcast /opt/toolchains/dc/rust
Enter your KallistiOS's dc-chain directory:
cd /opt/toolchains/dc/kos/utils/dc-chain
Clear out any existing build files:
make clean-keep-archives
Copy the necessary toolchain patches to your dc-chain setup:
cp /opt/toolchains/dc/rust/toolchain/*.diff patches/
Copy the rustc_codegen_gcc configuration file into place:
cp /opt/toolchains/dc/rust/toolchain/config.mk.rustc_codegen_gcc.sample config.mk
Make any desired changes to the configuration, and then compile the SH4 toolchain:
make build-sh4
When this command is completed successfully, a libgccjit.so will be installed to /opt/toolchains/dc/rust/sh-elf/lib/libgccjit.so.
Building rustc_codegen_gcc
- copy wrappers to /opt/toolchains/dc/bin (or add /opt/toolchains/dc/rust/wrappers to $PATH?)
- clone rustc_codegen_gcc repo to /opt/toolchains/dc/rust/rustc_codegen_gcc
- save /opt/toolchains/dc/rust/sh-elf/lib to gcc_path file
- copy sh-elf.json to /opt/toolchains/dc/rust/rustc_codegen_gcc
- patch out duplicate symbols in src/context.rs
- add SH4 precision mode to src/base.rs
- patch build_system/src/config.rs to alter default linker call
- patch build_sysroot/Cargo.toml to remove std and test from being pulled in
- y.sh clean
- y.sh prepare --cross
- y.sh build
Creating a new project using Cargo
- create an empty staticlib crate with target in .cargo/config
- add kos-rs crate from /opt/toolchains/dc/rust/kos-rs path
Compiling individual modules into object files with rustc
gccrs
gccrs implements a Rust compiler frontend for GCC. This essentially means implementing a new Rust compiler from the ground up using the GCC toolchain infrastructure. This project is in early stages and is targeting the Rust 1.49 revision from December 2020. As of this writing (February 2024), it is not yet able to compile Rust's libcore, so many basic language features are unimplemented or not functional. Additionally, Rust standard tooling like cargo is not available, nor is borrow checking implemented. It is possible to use this compiler by compiling either GCC 14.0.1-dev or GCCRS git repo.