It is well known that compiling a large software like Chromium can take a lot of resources. Most riscv64 linux distros are directly building chromium on real riscv64 hardware or QEMU user-mode emulator. Packagers need to be very patient because of the poor performance of the RISC-V chips/emulators at the current stage. Building chromium in qemu-user on 5950X can take at least 2.6 days to complete, and building it on slow hardwares like unmatched boards can take a lot longer than that. The 64 core SG2042 server brought some excitement but later it was proven that some quirks or even system instability can be encountered when building chromium on it.

So the most reasonable way to build and develop (or hack on) chromium for RISC-V appears to be cross compilation. But as everyone knows, cross-compilation in general can be hard, let alone compiling such a large project like chromium. In the following post, I will walk you through the procedures about cross compiling mainline chromium for riscv64 from the absolute scratch, staying as close to upstream as possible.

Environment Preparation

For the purpose of this post, I assume you are cross compiling chromium from x86_64 to riscv64. It might also be possible to do the cross-compilation on arm64 but I never tried.

The cross-compilation will be done in a Debian bookworm environment. Don’t worry if you are using other distros. We will setup a systemd container so it will work if you are using a systemd powered Linux distro. If not, then you can try to do it in a docker/podman container.

Creating the Container

Install debootstrap and create a base container:

Then enter the container:

You should be greeted with a root shell.

Installing Dependencies

First, let’s install some really basic stuff:

Creating a non-root User

Building as root is bad, let’s create a non-root user and give it sudo privillege.

Then switch to the porter account and go home:

Don’t forget to set up your git config:

Install depot_tools

depot_tools are the official tools for Chromium development. Most importantly, it includes gclient which manages hundreds of git repos. We will use it to fetch Chromium source code.

Then permanently add it to PATH by adding the following line to your .bashrc:

Source the .bashrc to apply the change:

Fetch the Sources

First, create a directory for the sources and cd into it. I will use ~/Workspaces/chromium:

Then fetch the Chromium source code using the fetch command from depot_tools:

Mind the --nohooks argument because some dependencies are not yet installed.

This step can take quite a lot time depending on your network condition. While downloading, do something else and relax!

After it finishes, install additional dependencies:

Then we can run the hooks(which download toolchains and sysroots and do some other stuff):

Then cd into src, the Chromium source repo.

Build the Toolchains

Chromium uses its own LLVM(and Rust) toolchain. The LLVM toolchain is built with RISC-V target enabled but most components missing. Most importantly, compiler-rt is missing. Building compiler-rt requires a Debian sysroot, as upstream doesn’t maintain Debian sysroot for riscv64, they cannot enable those components for riscv64, thus blocking riscv64 from being officially supported.

Debian only supports riscv64 in sid at the time of writing, while other architectures are using Debian bulleye sysroots. So it is unlikely that a riscv64 sysroot patch will be accepted by upstream, at least before trixie is released with riscv64 support.

So in order to build a LLVM toolchain with sufficient riscv64 support, we need to build a Debian sysroot first.

Debian Sysroot

Debian sysroots are placed in build/linux, and following the convention we should name our sysroot debian_sid_riscv64-sysroot.

Let’s create a Debian sysroot via debootstrap. This is the most simple way to go.

Some of the packages might be unnecessary but the above command should work.

You might encounter some errors about configuring packages, that doesn’t affect our usage and we can ignore them.

Then we need to modify the sysroot because chromium expect to find pkgconfigs in <sysroot>/usr/lib/pkgconfig:

And we need to remove usr/bin/python* because otherwise when building the LLVM toolchain it attempts to execute the python binary from the sysroot.

LLVM Toolchain

It’s possible to use other LLVM toolchains or even gcc(more patches are needed, of course). Note that for cross language LTO to work you’ll need the Rust toolchain to be built against matching LLVM. Such toolchains are also available for download on kernel.org: https://mirrors.edge.kernel.org/pub/tools/llvm/rust/. This blog post aims to stay close to upstream so we will use Chromium’s LLVM toolchain.

tools/clang/scripts/build.py builds Chromium’s LLVM toolchain. It includes fuchsia and Android support which requires NDK to be present. To avoid the need of setting up NDK and save build time, we will disable Android and fuchsia support when building the toolchain.

Apply the following patch that adds riscv64 support and disables some unnecessary parts for the purpose of this blog post.

LLVM build script expects another sysroot to be installed. We can create a symlink to make it happy:

Then start building LLVM toolchain:

Rust Toolchain

Chromium’s prebuilt rust toolchain already includes support for riscv64 target. So usually we don’t need to do anything.

But in case you want to build an older version of Chromium, you need to be aware of the following two issues:

• On riscv64gc linux, split-debuginfo =“unpacked” caused error: A dwo section may not contain relocations fixed by me in rust#120518 riscv only supports split_debuginfo=off for now and available since rust 1.78.0
• Cross-language LTO is broken for riscv64 lp64d fixed by me in rust#123612 Set target-abi module flag for RISC-V targets and available since rust 1.79.0

Patch the Sources

Before building Chromium, we need to apply some RISC-V specific patches.

Chromium

The riscv64 patch for sandbox: https://chromium-review.googlesource.com/c/chromium/src/+/4935120

Apply this patch by running:

And to make Chromium recognize our riscv64 sysroot, apply the following patch:

In order to build Linux installer (deb and rpm packages), apply the following patch:

And apply the following patches to fix build:

Upstream CL Link: https://chromium-review.googlesource.com/c/chromium/src/+/5850670

A workaround for partition allocator:

It will be fixed in https://chromium-review.googlesource.com/c/chromium/src/+/5839530 .

ffmpeg

Chromium doesn’t use ffmpeg’s build system. It stores generated files like config.h for every architecture/platform combination. So this means that we need to build the generated files for riscv64.

First, let’s apply this patch to Chromium:

Then let’s build ffmpeg for riscv64:

After building, you should see:

To do that, first cd into third_party/ffmpeg, then patch:

and run copy_config.sh:

Then you should see some generated files are copied to chromium/config for riscv64:

We are not done yet. We need to update Chromium’s ffmpeg build recipe for riscv64.

generate_gn.py updates ffmpeg_generated.gni by scanning all the build dirs of ffmpeg for every architecture/platform combination.

Previously we generated the build dir for riscv64: build.riscv64.linux. Then the generated ffmpeg_generated.gni only comes with riscv64 linux support.

In order to support other architecture/platform combinations, build them before running generate_gn.py.

Some executables for the build architecture also need ffmpeg, so we also need to build ffmpeg for our build architecture(x86_64):

SwiftShader

SwiftShader supports riscv64, but compiling with the default LLVM 10 results in compiler errors. So let’s apply a patch for switching to LLVM 16:

cd into third_party/swiftshader and apply the following patch:

V8

RISC-V support is already in upstream V8, but it appears that V8 development doesn’t take riscv64 into consideration and it’s up to the RISC-V team to fix breakages afterwards. This often results in not buildable V8 releases for riscv64. So we usually need to backport some V8 patches or update V8 to a new version.

At Chromium commit 790c25b96b62748e965b7b5df8112b09ed179b35, there’s no problem about compiling and running v8 for riscv64.

But you might run into some compiler errors when building other revisions.

Configure

Please read https://www.chromium.org/developers/gn-build-configuration/ to learn more about gn build configuration.

To do a release build, run

For the purpose of simplifying this blog post, here I added treat_warnings_as_errors=false. If this flag is not added, you will need to apply more patches to make Chromium compile. And use_debug_fission is set to false to workaround -gsplit-dwarf is unsupported with RISC-V linker relaxation (-mrelax).

Build

If you are building mainline instead of commit 790c25b96b62748e965b7b5df8112b09ed179b35, then fix any build errors that arise and rerun it until success.

Run & Debug

First, strip Chromium, it’s too large if not stripped.

Then we can use the following simple script to create a tarball of Chromium:

Now you can transfer chromium-dist.tar.zst to real riscv64 board to test the freshly built Chromium!

Here’s a screenshot of the freshly built mainline Chromium running on Arch Linux RISC-V:

Upstream Your Patch

If you have developed a patch for making Chromium better on riscv64. Don’t forget to upstream your patch.

In general, Chromium usually will accept small/medium changes that has negligible cost, but adding a large amount of code or new abstraction for a currently unsupported architecture like RISC-V won’t be accepted.

See https://chromium.googlesource.com/chromium/src/+/main/docs/contributing.md for more details on how to upstream your patch.

Electron for RISC-V

Electron has an infrastructure for applying patches to Chromium, and the riscv fork of electron uses it to apply riscv64 patches.

So it’s very likely that you can find riscv64 patches for some old versions of Chromium there.

Thanks

Finally, thanks Revy for inspiring me to write this blog post and helping me to improve it.