# Build RISC-V Toolchain

This doc lists the common config settings to build the RISC-V toolchain. It
generally involves two parts of the toolchain: GCC to build the headers and
libraries, and LLVM to build the compiler, linker, and utility tools.

## Prerequisites

Your host machine needs to have the following packages installed, which are
already part of the Shodan prerequisite pacakges

* CMake (>= 3.13.4)
* Ninja
* Clang

The source code of the toolchain is at

* [riscv-gnu-toolchain](https://github.com/riscv/riscv-gnu-toolchain): Checkout
the latest release tag, and checkout the submodule `riscv-binutils` at the master
branch at git://sourceware.org/git/binutils-gdb.git
* [llvm-project](https://github.com/llvm/llvm-project): Checkout the latest green
commit

## Build RISC-V Linux toolchain (64-bit)

### Build GCC

```bash
$ mkdir -p <GCC_BUILD_PATH>
$ cd <GCC_BUILD_PATH>
$ <GCC_SRC_PATH>/configure \
  --srcdir=<GCC_SRC_PATH> \
  --prefix=<TOOLCHAIN_OUT_DIR> \
  --with-arch=rv64gc \
  --with-abi=lp64d \
  --with-cmodel=medany
$ make -C <GCC_BUILD_PATH> linux
```

Notice Linux requires the full general CPU extension support, i.e., rv64imafdc,
and the ABI also needs to support hard double-float modules. For 32-bit Linux,
build the toolchain with the flags of `--with-arch=rv32gc --with-abi=ilp32d`.

### Build LLVM

```bash
$ cmake -B <LLVM_BUILD_PATH> \
    -DCMAKE_INSTALL_PREFIX=<TOOLCHAIN_OUT_DIR> \
    -DCMAKE_C_COMPILER=clang  -DCMAKE_CXX_COMPILER=clang++ \
    -DCMAKE_BUILD_TYPE=Release \
    -DLLVM_TARGETS_TO_BUILD="RISCV" \
    -DLLVM_ENABLE_PROJECTS="clang"  \
    -DLLVM_DEFAULT_TARGET_TRIPLE="riscv64-unknown-linux-gnu" \
    -DLLVM_INSTALL_TOOLCHAIN_ONLY=On \
    -DDEFAULT_SYSROOT=../sysroot \
    -G Ninja \
    <LLVM_SRC_PATH>/llvm
$ cmake --build  <LLVM_BUILD_PATH> --target install
```

For 32-bit, change the LLVM target triple to `riscv32-unknown-linux-gnu`.

## Build RISC-V bare-metal toolchain (32-bit)

### Build 32-bit GCC

```bash
$ mkdir -p <GCC_BUILD_PATH>
$ cd <GCC_BUILD_PATH>
$ <GCC_SRC_PATH>/configure \
  --srcdir=<GCC_SRC_PATH> \
  --prefix=<TOOLCHAIN_OUT_DIR> \
  --with-arch=rv32i2p0mf2p0 \
  --with-abi=ilp32 \
  --with-cmodel=medany
$ make -C <GCC_BUILD_PATH> newlib
```

Notice for bare-metal newlib there's no hard constraints on CPU feature and ABI
support. However, LLVM for bare-metal only supports soft-float modules, so the
GCC ABI setting needs to match that. Also, the ISA version needs to be specified,
since binuils ISA supports 20191213 spec and LLVM is at v2.2 spec

### Build 32-bit LLVM

```bash
$ cmake -B <LLVM_BUILD_PATH> \
    -DCMAKE_INSTALL_PREFIX=<TOOLCHAIN_OUT_DIR> \
    -DCMAKE_C_COMPILER=clang  -DCMAKE_CXX_COMPILER=clang++ \
    -DCMAKE_BUILD_TYPE=Release \
    -DLLVM_TARGETS_TO_BUILD="RISCV" \
    -DLLVM_ENABLE_PROJECTS="clang"  \
    -DLLVM_DEFAULT_TARGET_TRIPLE="riscv32-unknown-elf" \
    -DLLVM_INSTALL_TOOLCHAIN_ONLY=On \
    -DDEFAULT_SYSROOT=../riscv32-unknown-elf \
    -G Ninja \
    <LLVM_SRC_PATH>/llvm
$ cmake --build  <LLVM_BUILD_PATH> --target install
```

#### Build compiler-rt

This should not be necessary for the Shodan usage, but in case the compiler-rt
builtins is required in the project (instead of using libgcc), it can be built
with the additional commands:

```bash
$ export PATH=<TOOLCHAIN_OUT_DIR>/bin:${PATH}
$ cmake -B <LLVM_BUILD_PATH>/compiler-rt \
  -DCMAKE_INSTALL_PREFIX=$PREFIX \
  -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY \
  -DCMAKE_AR=<TOOLCHAIN_OUT_DIR>/bin/llvm-ar \
  -DCMAKE_NM=<TOOLCHAIN_OUT_DIR>/bin/llvm-nm \
  -DCMAKE_RANLIB=<TOOLCHAIN_OUT_DIR>/bin/llvm-ranlib \
  -DCMAKE_C_FLAGS="-march=rv32i2p0mf2p0v1p0" \
  -DCMAKE_ASM_FLAGS="-march=rv32i2p0mf2p0v1p0" \
  -DCMAKE_C_COMPILER=<TOOLCHAIN_OUT_DIR>/bin/clang \
  -DCMAKE_C_COMPILER_TARGET=riscv32-unknown-elf \
  -DCMAKE_ASM_COMPILER_TARGET=riscv32-unknown-elf \
  -DCOMPILER_RT_OS_DIR="clang/14.0.0/lib" \
  -DCMAKE_EXE_LINKER_FLAGS="-fuse-ld=lld" \
  -DCOMPILER_RT_BUILD_BUILTINS=ON \
  -DCOMPILER_RT_BUILD_SANITIZERS=OFF \
  -DCOMPILER_RT_BUILD_XRAY=OFF \
  -DCOMPILER_RT_BUILD_LIBFUZZER=OFF \
  -DCOMPILER_RT_BUILD_MEMPROF=OFF \
  -DCOMPILER_RT_BUILD_PROFILE=OFF \
  -DCOMPILER_RT_BAREMETAL_BUILD=ON \
  -DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON \
  -DLLVM_CONFIG_PATH=<LLVM_BUILD_PATH>/bin/llvm-config \
  -DCMAKE_C_FLAGS="-march=rv32i2p0mf2p0v1p0 -mno-relax" \
  -DCMAKE_ASM_FLAGS="-march=rv32i2p0mf2p0v1p0 -mno-relax" \
  -G "Ninja" <LLVM_SRC_PATH>/compiler-rt
$ cmake --build <LLVM_BUILD_PATH>/compiler-rt --target install
```

### Build newlib

Even with compiler_rt to replace libgcc, we still need to build libc, libm, and
libgloss as the toolchain prebuilts. They can also be built with clang
The source code is at <https://github.com/riscv/riscv-newlib>

***NOTE: The GCC utility tools needs to be built first.***

```bash
$ mkdir -p <NEWLIB_BUILD_PATH>
$ cd <NEWLIB_BUILD_PATH>
$ <NEWLIB_SRC_PATH>/configure \
  --target=riscv32-unknown-elf \
  --prefix=<TOOLCHAIN_OUT_DIR> \
  --enable-newlib-io-long-double \
  --enable-newlib-io-long-long \
  --enable-newlib-io-c99-formats \
  --enable-newlib-register-fini \
  CC_FOR_TARGET=clang \
  CXX_FOR_TARGET=clang++ \
  CFLAGS_FOR_TARGET="-march=rv32i2p0mf2p0v1p0 -O2 -D_POSIX_MODE -mno-relax" \
  CXXFLAGS_FOR_TARGET="-march=rv32i2p0mf2p0v1p0 -O2 -D_POSIX_MODE -mno-relax"
$ make -j32
$ make install
```

The newlib nano spec needs to be built separatedly and then merged with newlib.
GNU top-level Makefile lists the flags to build nano and the merging script.

## Test toolchain

Run

```bash
<TOOLCHAIN_OUT_DIR>/bin/<arch>-<os>-<abi>-gcc -v
```

to see the supported ABIs, architectures, library paths, etc.

Try to compile a simple c code (copied from CMake's package content, e.g.,
`/usr/share/cmake-3.18/Modules/CMakeTestCCompiler.cmake`)

```c
#ifdef __cplusplus
# error "The CMAKE_C_COMPILER is set to a C++ compiler"
#endif
#if defined(__CLASSIC_C__)
int main(argc, argv)
  int argc;
  char* argv[];
#else
int main(int argc, char* argv[])
#endif
{ (void)argv; return argc-1;}
```

To build (32-bit bare-metal example)

```bash
$<TOOLCHAIN_OUT_DIR>/bin/clang -c testCCompiler.c -O --target=riscv32
$<TOOLCHAIN_OUT_DIR>/bin/riscv32-unknown-elf-gcc testCCompiler.o -o testCCompiler -march=rv32gc -mabi=ilp32
```

You can also use `readelf` to inspect the object file before building the binary
to see if the architecture and ABI match.