I found a guide for cross-compiling Rust which basically involves configuring it with a --target option. The target needs to include the cross-compile target and the host target.

$ wget https://static.rust-lang.org/dist/rustc-1.5.0-src.tar.gz
$ tar xf rustc-1.5.0-src.tar.gz 
$ ./configure --target=arm-unknown-linux-gnueabi,x86_64-unknown-linux-gnu --prefix "$(PWD)"/../bin
$ make -j$(nproc) install

This didn't work with my target arm-unknown-linux-gneabi as at some point in the build it started trying to use arm-linux-gneabi-gcc and arm-linux-gneabi-ar, which didn't work as they are called arm-unknown-linux-gneabi-gcc and arm-unknown-linux-gneabi-gcc. I guess this is a problem with the build script, but I couldn't easily work out a fix, so I just created some symlinks with the names it was expecting. This worked well.

$ export LD_LIBRARY_PATH=~/projects/arm-rust-cross-compiler/bin/lib/
$ export PATH=$PATH:~/projects/arm-rust-cross-compiler/bin/bin/
$ bin/bin/rustc --version
rustc 1.5.0-dev

Cargo can also be built from source. I don't think Cargo needs to be cross-compiled as it supports compiling for different targets and I don't actually want to run Cargo on the target machine.

$ git clone https://github.com/rust-lang/cargo
$ cd cargo
$ git submodule update --init
$ python -B src/etc/install-deps.py
$ ./configure --local-rust-root="$PWD"/../bin --prefix "$(PWD)"/../bin
$ make
$ make install

To cross-compile with Cargo, a linker needs to be specified for the target. In my case:

$ cat > ~/.cargo/config << EOF
[target.arm-unknown-linux-gnueabi]
linker = "arm-unknown-linux-gnueabi-gcc-5.2.0"
EOF

Now Cargo can be used to create a new project and build a binary for an ARM target.

$ cargo new --bin hello-rust
$ cd hello
$ cargo build --target=arm-unknown-linux-gnueabi
$ file target/arm-unknown-linux-gnueabi/debug/hello-rust
target/arm-unknown-linux-gnueabi/debug/hello: ELF 32-bit LSB shared object,
ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter
/lib/ld-linux.so.3, for GNU/Linux 4.3.0, not stripped

I was pretty confident at this point, until I tried to run it in my emulator and the program immediately terminated with the message "Illegal instruction". So far, my cross-compiler toolchain and emulator had worked well. Why is now generating illegal instructions?

I eventually found that I wasn't specifying a CPU type and qemu was using the default ARM926 processor on the Versatile board. This can be fixed by adding --cpu arm1176 (which is the CPU on the first generation Raspberry Pi which I am trying to emulate). However, now the Kernel doesn't boot as it was built for an ARM926 processor as specified by versatile_defconfig.

The Linux ARM Versatile config restricts the possible CPU targets to CPUs that can actually fit in the board. Fortunately I found this patch which removes this restriction. Now make ARCH=arm versatile_defconfig && make ARCH=arm menuconfig allows the System Type —> Support ARM V6 processor option to be selected.

Finally, after rebuilding the Kernel and adding the Rust built hello binary to the filesystem, the program can run in the emulator.

qemu-system-arm -M versatilepb -cpu arm1176 -m 128M -kernel zImage -initrd ./rootfs.img.gz -append "root=/dev/ram rdinit=/sbin/init"

hello rust screenshot

Comments

Comment