mirror of
https://git.planet-casio.com/Lephenixnoir/sh-elf-gcc.git
synced 2024-12-28 20:43:39 +01:00
26affe51cf
The main change is making the scripts a two-stage process where we first build GCC, leave the user to install the libc, and then come back to install libstdc++-v3. * Detect whether we are in the first or second stage * Don't clean files after first stage install, and even then only do it if :clean is specified * Update README except for the manual install tutorial * Patch the source using a backported GCC 12.1 commit to make the configure script for libstdc++-v3 skip checking for dlopen, which is impossible is our not-really-hosted setup Details: * Proper .gitignore
113 lines
6.8 KiB
Markdown
113 lines
6.8 KiB
Markdown
# SuperH toolchain: `sh-elf-gcc`
|
|
|
|
This repository provides scripts to automatically compile and install an SH3/SH4-compatible [GCC cross-compiler](https://gcc.gnu.org/). GCC is a collection of compilers most commonly used for C/C++.
|
|
|
|
The following three methods can be used to install the compiler with different levels of automation.
|
|
|
|
Note that this repository should usually be built twice: first to build the compiler, and then after the libc is installed to build the C++ library.
|
|
|
|
## Method 1: Using GiteaPC
|
|
|
|
The most common way to install this compiler is for the fxSDK, and it can be automated with [GiteaPC](/Lephenixnoir/GiteaPC):
|
|
|
|
```bash
|
|
% giteapc install Lephenixnoir/sh-elf-gcc
|
|
```
|
|
|
|
This installs GCC (and binutils if missing) in the fxSDK's SuperH system root. Note that at first it will *not* install the C++ standard library libstdc++, because it requires the C standard library which is not available at this stage. After you install [fxlibc](/Vhex-Kernel-Core/fxlibc/) you should run GiteaPC's install command again, and this time the scripts will build libstdc++. The GiteaPC tutorial has more detailed instructions about this two-stage process.
|
|
|
|
A `:any` configuration is provided in case you already have another version of GCC installed in the fxSDK sysroot and want to keep using it (ie. skip a version upgrade). This will mark this repository as installed, so other repositories depending on it can build, without actually compiling binutils.
|
|
|
|
```bash
|
|
% giteapc install Lephenixnoir/sh-elf-gcc:any
|
|
```
|
|
|
|
A `:clean` configuration is also provided if you want to clean up the source and build files automatically after the second pass. This frees up some disk space.
|
|
|
|
```bash
|
|
% giteapc install Lephenixnoir/sh-elf-gcc:clean
|
|
```
|
|
|
|
## Method 2: Manually running the scripts
|
|
|
|
Make sure to previously install:
|
|
|
|
* [fxSDK](https://gitea.planet-casio.com/Lephenixnoir/fxsdk) ≥ 2.8.1 (provides the sysroot)
|
|
* [binutils for SuperH](https://gitea.planet-casio.com/Lephenixnoir/sh-elf-binutils)
|
|
* Most of the [requirements for GCC](https://gcc.gnu.org/install/prerequisites.html) are checked in the binutils `configure.sh`
|
|
|
|
Follow the same procedure as for binutils; preferably use the same `PREFIX`.
|
|
|
|
```bash
|
|
% make -f giteapc.make configure build install PREFIX="$HOME/.local"
|
|
```
|
|
|
|
## Method 3: Fully manually
|
|
|
|
TODO: Manual install tutorial and link to the Planète Casio one
|
|
|
|
TODO: The stuff below about libstdc++ is outdated, we can now build the entire thing
|
|
|
|
**Notes on building libstdc++-v3**
|
|
|
|
These are experimental notes on attempts at building the C++ standard library implementation bundled with GCC, `libstdc++-v3`. For the official manual, see [libstdc++ info manual, Chapter 2: Setup](https://gcc.gnu.org/onlinedocs/libstdc++/manual/setup.html) (gcc.gnu.org).
|
|
|
|
So far, I was only able to build the **free-standing subset** which has basically nothing in it, see [Freestanding and hosted implementations](https://en.cppreference.com/w/cpp/freestanding) (cppreference.com). As a rule of thumb only features that look like extensions of the language are supported in there (RTTI, exceptions, coroutines, etc.) and everything that looks like a library (STL containers, I/O tools, filesystem) you can forget about. This subset does not include familiar features but it is needed nonetheless for C++ programs to work at all.
|
|
|
|
So how do we go around doing that?
|
|
|
|
First configure GCC as usual (follow `configure.sh`), but use a separate build folder. Since this is experimental the files are likely to stay here longer while debugging and you don't want them gone during a GCC upgrade. There are a couple of additional flags to care about, mainly described [here](https://gcc.gnu.org/onlinedocs/libstdc++/manual/configure.html).
|
|
|
|
```
|
|
% export PREFIX="$(pwd)"
|
|
% mkdir build-libstdc++
|
|
% cd build-libstdc++
|
|
% ../gcc-11.1.0/configure --prefix="$PREFIX" --target=sh3eb-elf --with-multilib-list=m3,m4-nofpu --enable-languages=c,c++ --without-headers --with-newlib --program-prefix=sh-elf- --enable-libssp --enable-lto --enable-clocale=generic --enable-libstdcxx-allocator --disable-threads --disable-hosted-libstdcxx --disable-libstdcxx-verbose --enable-cxx-flags="-ffreestanding -fno-exceptions"
|
|
```
|
|
|
|
* `--enable-clocale=generic`: We want minimal locales and this is certainly the minimalistic option.
|
|
* `--enable-libstdcxx-allocator`: `=malloc` might be an option too.
|
|
* `--disable-threads`: Obvious.
|
|
* `--disable-hosted-libstdcxx`: This builds only the free-standing subset of the library. If you're adventurous, remove it.
|
|
* `--disable-libstdcxx-verbose`: We don't have a systematic standard error stream anyway.
|
|
* `--enable-cxx-flags="-ffreestanding -fno-exceptions"`: Everything should be free-standing since we don't use a standard runtime.
|
|
|
|
Currently I don't know of a way to completely disable exceptions in a way that linking with libstdc++ does not include all the stack unwinding and RTTI code for exceptions, but it sure starts with `-fno-exceptions` so it can't hurt to have that.
|
|
|
|
Now build and install that GCC and the libgcc.
|
|
|
|
```
|
|
% make -j$(nproc) all-gcc all-target-libgcc
|
|
% make -j$(nproc) install-strip-gcc install-strip-target-libgcc
|
|
```
|
|
|
|
Next step is to install [OpenLibm](https://gitea.planet-casio.com/Lephenixnoir/OpenLibm) and [fxlibc](https://gitea.planet-casio.com/Vhex-Kernel-Core/fxlibc/) since we're certainly not going to build the C++ standard library without the C standard library.
|
|
|
|
For some reason OpenLibm installs its headers in the `include/openlibm` subfolder, but then includes them as if they were in `include`, so we have to add a path. Normally either the projet provides that path, or gint does it through its CMake find module. Here we can symlink to the `sh3eb-elf/sys-include` folder in this repo's root folder (or `include` but it's already symlinked to the compiler's install folder and we don't really want to override that).
|
|
|
|
```
|
|
% SRC="$(sh-elf-gcc -print-file-name=include/openlibm)"
|
|
% DST="../sh3eb-elf/sys-include"
|
|
% mkdir -p "$DST"
|
|
% for x in "$SRC"/*.h; do ln -s "$x" "$DST/${x#$SRC/}"; done
|
|
```
|
|
|
|
Also `<stdint.h>` has issues because GCC only redirects to its default `"stdint-gcc.h"` when free-standing, which conftest programs are not, so we have to provide some version of `<stdint.h>`.
|
|
|
|
```
|
|
% echo '#include "stdint-gcc.h"' > ../sh3eb-elf/sys-include/stdint.h
|
|
```
|
|
|
|
After this, come back to the build folder, run the build command for libstdc++-v3, and hope it works out. I recommend not using `-j` as it makes error messages and logs more linear, and the library builds very fast anyway.
|
|
|
|
```
|
|
% make all-target-libstdc++-v3
|
|
```
|
|
|
|
If it fails, check out `sh3eb-elf/libstdc++-v3/config.log` for configure errors, or other log files if you make it past the configuration step. `config.log` has many details on programs that failed to compile; not all failures to build are fatal for the configuration step, but some are.
|
|
|
|
If it succeeds, install.
|
|
|
|
```
|
|
% make install-strip-target-libstdc++-v3
|
|
```
|