216 lines
7.1 KiB
Markdown
216 lines
7.1 KiB
Markdown
# 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.
|
|
|
|
```bash
|
|
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.
|
|
|
|
```bash
|
|
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
|
|
|
|
```bash
|
|
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
|
|
|
|
```bash
|
|
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.
|
|
|
|
```bash
|
|
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`.
|
|
|
|
```bash
|
|
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
|
|
|
|
```bash
|
|
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](https://github.com/Jonimoose/libfxcg.git)
|
|
|
|
```bash
|
|
git clone https://github.com/Jonimoose/libfxcg.git
|
|
cd libfxcg/libc
|
|
```
|
|
replace all the `sh3eb-` with `sh-elf`
|
|
```bash
|
|
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
|
|
|
|
```bash
|
|
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
|
|
|
|
```bash
|
|
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.
|
|
|
|
```bash
|
|
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.
|
|
|
|
``` ada
|
|
package Compiler is
|
|
for Driver ("Ada") use "/path/to/gcc";
|
|
end Compiler;
|
|
```
|
|
|
|
We also have to tell the linker to use our custom linker.
|
|
|
|
``` ada
|
|
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:
|
|
- https://osdev.wiki/wiki/GNAT_Cross-Compiler
|
|
- https://www.planet-casio.com/Fr/forums/topic12970-1-tutoriel-installation-manuelle-de-gcc-et-du-fxsdk.html
|
|
- https://gcc.gnu.org/install/configure.html
|
|
- https://git.planet-casio.com/Lephenixnoir/fxsdk
|
|
- https://prizm.cemetech.net/Mkg3a/
|
|
- https://docs.adacore.com/gprbuild-docs/html/gprbuild_ug/companion_tools.html#general-compilation-attributes-l1460
|
|
|
|
---
|
|
Copyright (c) 2026 Ada Orbit. All Rights Reserved.
|