AdaOrbit 738ba7e0c8 clean up toolchain documentation

2026-04-17 19:34:58 +02:00

7.1 KiB

Raw Blame History

AdaCasio

Building and developing Ada applications for the Casio fx-CG50

The Casio fx-CG50 (from here on only called CG50) uses the SuperH architecture. Specifically a custom SH4-A chip. To be able to develope Add-ons, we first need to compile gcc with Ada and SuperH support.

Note

You need a working ada compiler to compile ada. If you don't have gnat available in your repo, you can compile a stage1 gcc compiler. For my own sanity sake, I'll just assume that you already have gnat installed on your system.

Building a GNAT cross compiler

We start by downloading the binutils and gcc source code.

wget -O binutils.tar.gz "https://ftp.gnu.org/gnu/binutils/binutils-2.46.0.tar.gz"
wget -O gcc.tar.gz "https://ftp.gnu.org/gnu/gcc/gcc-15.2.0/gcc-15.2.0.tar.gz"
tar -xf binutils.tar.gz
tar -xf gcc.tar.gz

Prepare the build environment to configure the tools.

mkdir build-binutils build-gcc sysroot

sysroot is where gcc and binutils is going to be installed at. The build-* directories are where the tools are going to be build at. But before we do that we first have to configure them.

Configuring binutils

cd build-binutils
../binutils-*/configure                 \
  --prefix="$(pwd)/../sysroot"          \
  --target="sh3eb-elf"                  \
  --with-multilib-list="m3,m4-nofpu"    \
  --program-prefix="sh-elf-"            \
  --enable-libssp                       \
  --enable-lto

You might ask yourself now why we chose these flags. Here I have tried to lay out why we use some of these flags.

Flag	Meaning
--prefix	The install path. In our case it's `sysroot`
--target	What our target architecture is. The CG50 uses SuperH
--with-multilib-list	which CPUs we target.
--program-prefix	prefix of the binuitls tools
--enable-libssp	No Idea
--enable-lto	Link Time Optimization. Glue code faster together

Compiling binutils

We now compile binutils with our custom configuration using

make -j$(nproc)
make install-strip

We will now configure and install gcc using the same steps but with different flags.

Configuring GCC

We will first compile a working C cross compiler without a libc and add it later on to compile gcc with C++ and Ada support.

cd ../build-gcc
../gcc-*/configure                        \
  --prefix="$(pwd)/../sysroot"            \
  --target="sh3eb-elf"                    \
  --with-multilib-list="m3,m4-nofpu"      \
  --enable-languages="c,c++,ada"          \
  --without-libada                        \
  --without-headers                       \
  --program-prefix="sh-elf-"              \
  --enable-libssp                         \
  --enable-lto                            \
  --enable-clocale="generic"              \
  --enable-libstdcxx-allocator            \
  --disable-threads                       \
  --disable-libstdcxx-verbose             \
  --enable-cxx-flags="-fno-exceptions"

The most important flags are described here.

Flags	Effect
--target="sh3eb-elf"	Compile Code to sh3
--enable-languages="ada"	Add support for the Ada language
--without-libada	We will be adding our own runtime as there is none for casiowin

Many of the other flags are for enabling C++ support, however, with gcc15 I wasn't able to add C++ support and with gcc14 there where too many nuances to get Ada to work. For now these extra flags stay here for future use.

Compiling GCC (Step 1)

We now compile gcc the same way we did binutils.

make -j$(nproc) all-gcc all-target-libgcc
make install-strip-gcc install-strip-target-libgcc # TODO: may need to add Ada stuff?

We now have successfully cross compiled gcc. However we still need to add a libc and compile gnat. For that we will have to install the required headers into the correct coresponding direcotry

cd ..
export PATH="$PATH:$(pwd)/sysroot/bin"
PREFIX="$(sh-elf-gcc --print-file-name=.)"

The PREFIX directory is where gcc is going to look for all the system headers.

Adding libc

We will now install a libc implementation that works on the CG50. For that we will use libfxcg

git clone https://github.com/Jonimoose/libfxcg.git
cd libfxcg/libc

replace all the sh3eb- with sh-elf

make
cp lib/* ../sysroot/lib/
cp -r include/* ../sysroot/lib/gcc/sh3eb-elf/15.2.0/include/

Note

There is also the libc from gint and vhex but those target also other calculators that I don't have access to. For my own sanity sake I'll just stick with libfxcg

Installing gnattools

We do not necsairaly need to build gnattools in order to compile ada, but it was helpfull during development to debug and figure out how to integrate our custom gcc compiler to gprbuild.

Go back to build-gcc and run

make -C gcc cross-gnattools
make install-strip

gnat is now installed in our sysroot!

Compiling GCC (Part 2)

Warning

Building gcc with c++ does not work!!! These instrucitons are here for future use!!!

Build now the c++ support with

make -j$(nproc) all-target-libstdc++-v3
make install-strip-target-libstdc++-v3

packaging the binary

We will need to build mkg3a, a tool to package binaries to a format that CasioWin can use.

git clone https://gitlab.com/taricorp/mkg3a.git
mkdir build
cd build
cmake ..
make
make install/local # do not want to install it to the system but to

The tools are now in the current diredtory, however they are not in our PATH yet. Add them by either adding

Adding our custom compiler to GPRBuild

We need to tell the build system (in our case GPRbuild) that it has to use our custom gcc. We do this in the following way.

package Compiler is 
   for Driver ("Ada") use "/path/to/gcc";
end Compiler;

We also have to tell the linker to use our custom linker.

package Linker is
   for Driver use "/path/to/gcc";
end Linker;

You now have access to an ada cross compiler for the sh3 achitecture!

The next steps are now to build your first application!!!

Good luck and happy hacking!

Sources used:

7.1 KiB Raw Blame History