Cross-compiling Servo to ARM

While Servo supports Android for a while now, it turned out cross compiling to ARM devices requires some additional work. Now that most of these patches have landed, it is possible to build for ARM with just some minor tweaks.

UPDATE: This tutorial has also been posted here: http://browser.sed.hu/blog/20150717/cross-compiling-servo-arm. Please visit that site if you wish to leave comments.

UPDATE 2: Most of the patches have landed, post updated.

UPDATE 3: The linker issue is now fixed (but, unfortunately there is an issue with the latest Skia).

UPDATE 4: Looks like the Skia issue was fixed, but another appeared in libexpat. Fortunately, there is a clean workaround for that.

Last update: 2015, Nov 2

For reference, in this post I’m going to use Servo at commit 73b52c0, which requires Rust version 2d0cbf3e3e25e092bd9e4c94d08e446b680869f0. You will need the Rust standart library of this particular version, compiled to ARM. The required version is stored in the file rust-snapshot-hash.

Unfortunately, you will probably have to build that yourself too, as ARM libs are not distributed with Rust yet. The first part of the on-board building guide describes how to do it. UPDATE: Now you should also be able to compile it by simply setting the appropriate configure flags.

You will also need the ARM system libraries, but you can copy them either from the system running on your board or from a downloaded distribution installer, eg. a Raspbian image.

Setting up a rootfs

First, I’m going to set up an Ubuntu 14.04 rootfs to build in a clean environment. You can safely skip this step (just don’t forget to change the paths later).

sudo apt-get install debootstrap
sudo debootstrap --arch=amd64 trusty rootfs-trusty
sudo mount -o bind /dev  rootfs-trusty/dev
sudo mount -o bind /proc rootfs-trusty/proc
sudo mount -o bind /sys  rootfs-trusty/sys
sudo chroot rootfs-trusty /bin/bash

Then, add a new user inside the roots (again, you can skip this):

useradd -m servobuild -s /bin/bash
passwd servobuild
usermod -aG sudo servobuild
su - servobuild

Prerequisites

All right, let’s install the ARM compiler. There are many kinds of toolchains (eg. optimized for a certain board, like the Raspberry Pi), but the default one is fine for me:

sudo apt-get update
sudo apt-get install g++-arm-linux-gnueabihf

Install the Servo dependencies (copied from the README):

sudo apt-get install curl freeglut3-dev \
    libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
    gperf g++ cmake python-virtualenv \
    libssl-dev libbz2-dev libosmesa6-dev libxmu6 libxmu-dev

Note: if python-virtualenv is not found, install it like this:

sudo apt-get install python-setuptools
curl -O https://pypi.python.org/packages/source/v/virtualenv/virtualenv-13.0.3.tar.gz
tar xzf virtualenv-13.0.3.tar.gz && cd virtualenv-13.0.3
sudo python setup.py install

Oh, and we will also need git:

sudo apt-get install git

Finally, download Servo, but leave it alone for now:

git clone https://github.com/servo/servo

Updating dependencies

UPDATE: Most dependencies work correctly now

+ See the steps anyway

I’ve just pushed some ARM patches to Servo and its dependencies, which have not landed yet. Fortunately, we can use custom versions of these repos without messing up the main Servo (Cargo) directory, so we can apply these changes already.

I’m going to store these git repositories in servo_repos:

mkdir servo_repos && cd servo_repos

and download each dependency which have an unlanded patch and apply it.

UPDATE:: These patches have already landed, you can get them by mach cargo-update (see later), or manually:

git clone https://github.com/servo/glutin.git && cd glutin && \
curl -LO https://github.com/servo/glutin/pull/32.diff && \
git apply 32.diff && \
cd ..

git clone https://github.com/servo/libexpat.git && cd libexpat && \
curl -LO https://github.com/servo/libexpat/pull/6.diff && \
git apply 6.diff && \
cd ..

git clone https://github.com/servo/mozjs.git && cd mozjs && \
curl -LO https://github.com/servo/mozjs/pull/48.diff && \
git apply 48.diff && \
cd ..

git clone https://github.com/servo/rust-mozjs.git && cd rust-mozjs && \
curl -LO https://github.com/servo/rust-mozjs/pull/167.diff && \
git apply 167.diff && \
cd ..

git clone https://github.com/servo/rust-png.git && cd rust-png && \
curl -LO https://github.com/servo/rust-png/pull/77.diff && \
git apply 77.diff && \
cd ..

git clone https://github.com/servo/libfontconfig.git && cd libfontconfig && \
curl -LO https://github.com/servo/libfontconfig/pull/11.diff && \
git apply 11.diff && \
cd ..

Now we have to create a Cargo config file for Servo to tell the location of these repos:

cd ~/servo
mkdir .cargo

cat << 'EOF' > .cargo/config
paths = [
    "/home/servobuild/servo_repos/glutin",
    "/home/servobuild/servo_repos/other-deps",
    ...
]
EOF

This will solve the problem of unlanded patches. Now, some dependencies have ARM cross compile patches already, but Servo doesn’t use the latest version of these. To update them, we have to initialize the build system first:

git submodule init
git submodule update
./mach bootstrap-rust
./mach bootstrap-cargo

which will download Rust and Cargo used by Servo, and creates the directory structure to where we will copy the Rust libraries in the next section.

Alternatively, you can just run ./mach build, which also does this for you, but the build itself will fail at this point.

Now that we have set up the build system, we can get the updated dependencies like this:

./mach cargo-update -p azure           && \
./mach cargo-update -p fontconfig-sys  && \
./mach cargo-update -p freetype-sys    && \
./mach cargo-update -p mozjs_sys       && \
./mach cargo-update -p js              && \
./mach cargo-update -p png-sys         && \
./mach cargo-update -p skia            && \
./mach cargo-update -p stb_image

You can also specify a target Git hash for each package with the --precise flag. At the time of writing,

./mach cargo-update -p azure --precise 0ee76c98d92b0ff180f8b4474c4f4b7c80b67ecf
./mach cargo-update -p fontconfig-sys --precise b01ee3e2f8523a6566b8e5d406a2176ccb574060
./mach cargo-update -p freetype-sys --precise 23b2ebba10639716c8f9e37945ee37dacc68b195
./mach cargo-update -p mozjs_sys --precise 290ae28abec5a3f2bdc7ed8508ce02f86ac2c3e4
./mach cargo-update -p js --precise 5da854e637fcfeefe4aebda0b66fc2406ea7dc63
./mach cargo-update -p png-sys --precise a3569ca11ea54e5d6152ee80d7d39b2799700dbf
./mach cargo-update -p skia --precise 0e2cc56c36ca08371777e11be018d93d2a877881
./mach cargo-update -p stb_image --precise ddb122381df6249f7916c3cdadd9f42396d36602

can also be used for getting the latest versions.

What you still have to do, is setting up the build system:

git submodule init
git submodule update
./mach bootstrap-rust
./mach bootstrap-cargo

Installing libraries

We will need to install the Rust standart libraries for ARM if we want to cross compile programs written in Rust. Let’s exit from the rootfs for a minute:

exit    # log out from 'servobuild'
exit    # log out from the rootfs

and copy your ARM Rust libraries to the correct location:

cp -R path/to/your/rustc/lib/rustlib/arm-unknown-linux-gnueabihf rootfs-trusty/home/servobuild/servo/.servo/rust/2d0cbf3e3e25e092bd9e4c94d08e446b680869f0/rustc-1.2.0-dev-x86_64-unknown-linux-gnu/rustc/lib/rustlib/

Note: Your target directory might have a different Rust hash/version.

Note: In case you’ve skipped the preface, you have to build the Rust standard libraries of the version used by Servo for ARM

If you skip this step, you will get std-related errors when compiling Rust code

We will also need to install the ARM system libraries if we don’t want to get linker errors later:

sudo cp -R path/to/your/lib/arm-linux-gnueabihf rootfs-trusty/lib/
sudo cp -R path/to/your/usr/lib/arm-linux-gnueabihf rootfs-trusty/usr/lib/

If you are not working in a rootfs, just remove the rootfs-trusty part of the commands.

We’re done with the libraries, let’s go back into the rootfs:

sudo chroot rootfs-trusty /bin/bash
su - servobuild
cd servo

There are two ‘missing header’ errors, for OpenSSL and Zlib. Apparently this is a packaging issue on certain distros. Anyway, you can fix it like this:

sudo mkdir -p /usr/include/arm-linux-gnueabihf/
sudo ln -s /usr/include/x86_64-linux-gnu/openssl /usr/include/arm-linux-gnueabihf/
sudo ln -s /usr/include/x86_64-linux-gnu/zconf.h /usr/include/arm-linux-gnueabihf/

Building!

Finally! If you’ve followed the previous steps correctly, running

PKG_CONFIG_ALLOW_CROSS=1 \
PKG_CONFIG_PATH=/usr/lib/arm-linux-gnueabihf/pkgconfig \
EXPAT_NO_PKG_CONFIG=1 \
CC=arm-linux-gnueabihf-gcc \
CXX=arm-linux-gnueabihf-g++ \
CPP="arm-linux-gnueabihf-gcc -E" \
LD=arm-linux-gnueabihf-ld \
AR=arm-linux-gnueabihf-ar \
RANLIB=arm-linux-gnueabihf-ranlib \
./mach build --target=arm-unknown-linux-gnueabihf --dev

should build servo correctly, and you can find it at ./target/arm-unknown-linux-gnueabihf/debug/servo. Congratulations!

+ Show the old linker errors

Issues

Servo still has some visual (X11 and OpenGL) problems on embedded Linux, whether you build on board or cross compile.