compilation-gcc: fxSDK 2.9 setup and slightly more expert style
This commit is contained in:
parent
8dced6746c
commit
62aaf1d272
GPG Key ID:
1BBA026E13FC0495
|
|
@ -1,242 +1,122 @@
|
|||
[b]Qui dit Linux implique son puissant compilateur `gcc`, et de nombreux outils permettant de développer plus librement, plus efficacement. Dans ce tutoriel, je vous propose de compiler GCC et sa suite pour développer des programmes pour les calculatrices Casio.[/b]
|
||||
# [Tutoriel] Installation manuelle de GCC (et du fxSDK)
|
||||
|
||||
Pour pouvoir bien suivre, vous devez savoir vous servir d'un terminal et des commandes de base. Ouvrez-en un pour commencer, et essayez de ne pas le fermer par erreur, ça pourrait gêner. Accrochez-vous bien ! :)
|
||||
Parmi les compilateurs C/C++ modernes de premier plan (LLVM, GCC, MSVC...), GCC est le seul à avoir un backend SuperH, ie. capable de générer des add-ins pour les calculatrices CASIO. Dans ce tutoriel, on va voir comment compiler GCC à la main. J'y mentionne également par le symbole :arrow: les étapes supplémentaires nécessaires pour installer le fxSDK tout entier à la main.
|
||||
|
||||
[brown][b]Arch Linux.[/b][/brown] Les paquets [url=https://aur.archlinux.org/packages/sh-elf-binutils-casio]`sh-elf-binutils-casio`[/url] et [url=https://aur.archlinux.org/packages/sh-elf-gcc-casio]`sh-elf-gcc-casio`[/url] sont dispo pour vous. Vous pouvez installer ça et passer directement à l'étape 7. En cas de pépin, me pinger ainsi que [profil]Dark Storm[/profil].
|
||||
Ce tutoriel était initialement utilisé pour toutes les installation de GCC pour la calculatrice, mais il y a maintenant des méthodes automatiques via le dépôt [url=https://gitea.planet-casio.com/Lephenixnoir/sh-elf-gcc]sh-elf-gcc[/url], via [url=https://www.planet-casio.com/Fr/forums/topic16790-1-middlearch-un-depot-communautaire.html]MiddleArch[/url] ou même l'installation complète du fxSDK avec [url=https://www.planet-casio.com/Fr/forums/topic16614-last-giteapc-installer-et-mettre-a-jour-automatiquement-des-projets-gitea.html]GiteaPC[/url]. Le texte ci-dessous est donc destiné à des personnes relativement expérimentées avec le terminal et les processus classiques de compilation, et spécifiquement à ceux qui voudraient tester des configurations inhabituelles. [i]Pour relire l'ancien tutoriel, voir [url=https://gitea.planet-casio.com/Lephenixnoir/Tutoriels/src/commit/8dced6746ce4c4a23ec66b8001da6a0dc9c27e41/Compiler%20sous%20Linux%20avec%20un%20cross-compilateur%20GCC/article.txt]sur la forge Gitea[/url].[/i]
|
||||
|
||||
[brown][b]Windows.[/b][/brown] Vous pouvez suivre ce tutoriel sous Windows 10 en utilisant [url=https://en.wikipedia.org/wiki/Windows_Subsystem_for_Linux]WSL[/url], un composant de Windows 10 qui vous permet de lancer des programmes Linux. KikooDX a [url=https://www.planet-casio.com/Fr/forums/topic13572-last-gint-un-noyau-pour-developper-des-add-ins.html#175912]testé pour vous[/url] déjà. ^^
|
||||
Ce tutoriel est écrit pour Linux mais vous pouvez le suivre sous Windows 10 en utilisant [url=https://en.wikipedia.org/wiki/Windows_Subsystem_for_Linux]WSL[/url] qui vous donnera accès à Ubuntu.
|
||||
|
||||
[b]Sommaire[/b]
|
||||
[brown][b][u]1. Présentation du processus[/u][/b][/brown]
|
||||
|
||||
1. [target=dependances]Installation des dépendances[/target]
|
||||
2. [target=architecture]Considérations sur l'architecture cible[/target]
|
||||
3. [target=environnement]Préparation de l'environnement de compilation[/target]
|
||||
Dans ce tutoriel, on va compiler plusieurs logiciels. Côté compilateur, d'abord [b]binutils[/b], une suite de programmes qui gère l'assembleur, les fichiers objets, les bibliothèques, et l'édition des liens ; puis [b]GCC[/b], le compilateur C/C++ en lui-même.
|
||||
|
||||
4. [target=binutils]Compilation de binutils[/target]
|
||||
5. [target=gcc]Compilation de gcc et de libgcc[/target]
|
||||
6. [target=newlib]Compilation de newlib[/target] (experts)
|
||||
Ensuite on va faire un détour par le fxSDK pour installer la bibliothèque mathématique et la bibliothèque standard C qui sont nécessaires pour avoir accès à la totalité du langage C.
|
||||
|
||||
7. [target=runtime]Choisir un environnement de développement[/target]
|
||||
On reviendra alors vers GCC, puisqu'une fois la lib standard C installée on peut compiler la bibliothèque standard C++, qui est là aussi nécessaire pour avoir accès à la totalité du langage C++.
|
||||
|
||||
Enfin on pourra finir l'installation du fxSDK avec gint et d'autres bibliothèques.
|
||||
|
||||
[label=dependances]
|
||||
[big][brown][b]1. Installation des dépendances[/b][/brown][/big]
|
||||
:arrow: [fxSDK] Commencez par installer le dépôt [url=https://gitea.planet-casio.com/Lephenixnoir/fxsdk]fxsdk[/url], qui fournit la sysroot dans laquelle on va installer le compilateur. C'est un `cmake`/`make` classique.
|
||||
|
||||
Dans ce tutoriel, on va compiler plusieurs programmes : d'abord [b]`binutils`[/b], une suite d'outils qui gère les programmes en assembleur, l'édition des liens, les fichiers exécutables et tout ce qui n'est pas du C ; ensuite le compilateur [b]`gcc`[/b] qui compile le code C en assembleur ; et si vous êtes aventureux, peut-être même une version expérimentale de [b]`newlib`[/b], une bibliothèque standard qui fournit les fonctions fondamentales du C.
|
||||
[brown][b][u]2. Installation des dépendances[u][/b][/brown]
|
||||
|
||||
Le `gcc` qui compile vers la calculatrice produit du code en assembleur SuperH, ce n'est [i]pas[/i] celui de votre système qui compile probablement en assembleur x86_64. Il ne s'appelle [i]pas[/i] `gcc` mais quelque chose de plus long comme `sh-elf-gcc`. Vous devez faire très attention à ne pas confondre les deux ! ;)
|
||||
Nos calculatrices utilisent des processeurs de la famille SuperH, on ne peut donc pas utiliser le même compilateur C que quand on programme pour l'ordinateur. On va utiliser un [i]cross-compilateur[/i] qui ne s'appelera pas `gcc` mais `sh-elf-gcc`, attention à ne pas confondre !
|
||||
|
||||
À l'heure où j'écris cette version du tutoriel (12 Septembre 2019), les dernières versions disponibles sont `binutils-2.32` et `gcc-9.2.0`. N'hésitez pas à prendre des versions plus récentes, tant que vous les prenez proches dans le temps. Attention, la dernière version n'est pas toujours en bas de la liste ! La communauté d'OSDev (qui compile `gcc` à tour de bras) a un tableau où elle indique les combinaisons qui ont marché. Si vous en réusissez une nouvelle, allez leur dire.
|
||||
Téléchargez la dernière version de binutils ([url=https://ftp.gnu.org/gnu/binutils/]téléchargement ici[/url]) ainsi que la dernière version de GCC ([url=https://ftp.gnu.org/gnu/gcc/]téléchargement ici[/url]). En cas d'erreur insondable, vous pourrez toujours tenter d'autres versions plus tard.
|
||||
|
||||
La manipulation peut échouer à cause d'erreurs de compilation imprévisibles et que vous ne saurez souvent pas résoudre ; en général soit il vous manque des dépendances soit vous êtes tombé sur des versions qui ne veulent pas marcher chez vous, vous pouvez alors essayer avec d'autres.
|
||||
[b]Attention :[/b] Si votre GCC système est en version 12.1 ou 12.2 (tapez `gcc -v` pour le déterminer), vous devez prendre GCC 11.1 pour la calculatrice à cause de [url=https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106609]ce bug de GCC pour x86_64[/url].
|
||||
|
||||
[url=ftp://ftp.gnu.org/gnu/binutils/]Téléchargement de binutils[/url]
|
||||
[url=ftp://gcc.gnu.org/pub/gcc/releases/]Téléchargement de gcc[/url]
|
||||
[url=http://wiki.osdev.org/Cross-Compiler_Successful_Builds]Compilations réussies par la communauté d'OSDev[/url]
|
||||
Bien sûr GCC est un logiciel complexe avec pas mal de dépendances. Voici de quoi les installer :
|
||||
|
||||
Bien sûr `gcc` est un logiciel complexe qui s'appuie sur différentes bibliothèques pour faire son boulot : il y a donc un certain nombre de dépendances à installer. Les noms de paquets ci-dessous sont pour Debian et ses dérivés (Ubuntu, Mint, ElementaryOS...), à utiliser avec `apt`. Si vous avez une autre distribution vous saurez vous débrouiller. :)
|
||||
[code]# Pour Debian, Ubuntu, Mint, WSL pour Windows, et autres dérivés de Debian :
|
||||
% sudo apt install libmpfr-dev libmpc-dev libgmp-dev libpng-dev libppl-dev flex g++ git texinfo
|
||||
# Pour Arch Linux, Manjaro, et autres dérivés de Arch :
|
||||
% sudo pacman -S mpfr libmpc gmp libpng ppl flex gcc git texinfo[/code]
|
||||
[list=arrow]
|
||||
[li]MPFR : calcul flottant à précision arbitraire[/li]
|
||||
[li]MPC : calcul complexe à précision arbitraire[/li]
|
||||
[li]GMP : arithmétique entière multi-précision[/li]
|
||||
[li]libPNG : manipulations d'images PNG[/li]
|
||||
[li]PPL : optimisation polyhédrique (optimisation magique)[/li]
|
||||
[li]flex : générateur d'analyseurs lexicaux[/li]
|
||||
[li]g++ : compilateur C++ pour votre système[/li]
|
||||
[li]git : gestionnaire de versions[/li]
|
||||
[li]texinfo : générateur de documentation formatée[/li]
|
||||
[/list]
|
||||
[brown][b][u]3. Préparation de l'environnement de compilation[/u][/b][/brown]
|
||||
|
||||
` mpfr (libmpfr-dev) `: flottants à précision variable
|
||||
` mpc (libmpc-dev) `: complexes à précision variable
|
||||
` gmp (libgmp-dev) `: arithmétique à multi-précision
|
||||
` png (libpng-dev) `: manipulation d'images
|
||||
` ppl (libppl-dev) `: polyèdres Parma (optimisation magique)
|
||||
` flex (flex) `: générateur d'analyseurs lexicaux
|
||||
` g++ (g++) `: compilateur C++
|
||||
` git (git) `: gestionnaire de versions
|
||||
` texinfo (texinfo) `: générateur de documentation formatée
|
||||
Le compilateur et toutes les bibliothèques pour la calculatrice vont être installées dans un même dossier. Si vous utilisez le fxSDK, ce dossier est pré-choisi et la commande `fxsdk path sysroot` vous l'affiche. Sinon vous pouvez aller où vous voulez, mais restez dans votre dossier personnel.
|
||||
|
||||
[code]% export PREFIX="$(fxsdk path sysroot)"
|
||||
# Exemple de dossier hors fxSDK :
|
||||
# export PREFIX="$HOME/opt/sh-elf-2.39-11.1.0"
|
||||
|
||||
[label=architecture]
|
||||
[big][brown][b]2. Considérations sur l'architecture cible[/b][/brown][/big]
|
||||
% mkdir -p $PREFIX[/code]
|
||||
Assurez-vous que `$PREFIX/bin` est dans votre PATH. Extrayez le contenu des archives que vous avez téléchargées dans un dossier temporaire, et créez deux répertoires `build-binutils` et `build-gcc`.
|
||||
|
||||
Les processeurs des calculatrices Casio font partie de la lignée des SuperH, et vous savez peut-être qu'il y en a deux versions en circulation : les vieilles machines d'avant 2012 utilisent des processeurs SuperH-3, et les autres des SuperH-4A. Un certain nombre de membres anciens et respectés utilisent toujours des SH3, donc il est important de pouvoir créer des programmes pour les deux.
|
||||
|
||||
Dans ce tutoriel, on va compiler un GCC qu'on appellera [b]`sh-elf-gcc`[/b] qui sera capable de cibler deux architectures : SuperH-3 et SuperH-4 sans FPU.
|
||||
|
||||
La méthode proposée dans les anciennes versions du tutoriel ne permettait que de cibler une seule architecture à la fois. Les compilateurs s'appelaient alors `sh3eb-elf-gcc` et `sh4eb-nofpu-elf-gcc`. Vous pouvez toujours utiliser le premier, mais cela n'a plus vraiment d'intérêt puis qu'on peut avoir les deux ensemble. Le deuxième n'est pas [i]véritablement[/i] sans FPU et pose des problèmes sérieux : ne l'utilisez pas.
|
||||
|
||||
Passons aux choses sérieuses maintenant !
|
||||
|
||||
|
||||
[label=environnement]
|
||||
[big][brown][b]3. Préparation de l'environnement de compilation[/b][/brown][/big]
|
||||
|
||||
Tout ce qu'on va créer aujourd'hui ira dans un dossier de votre ordinateur. Le compilateur sera installé là, et les bibliothèques pour programmer sur la calculatrice seront là aussi. Je vous conseille vivement de choisir un dossier dans votre répertoire personnel. Pour moi, ce sera dans `$HOME/opt` avec le numéro de version car j'en compile souvent. Vous pouvez choisir ce que vous voulez, par exemple `$HOME/Documents/Casio/gcc` (ça ne changera rien à la suite).
|
||||
|
||||
[code]% export PREFIX="$HOME/opt/sh-elf-2.32-9.2.0"
|
||||
% mkdir -p $PREFIX
|
||||
% cd $PREFIX[/code]
|
||||
Si vous fermez votre terminal au milieu du tutoriel, et en ouvrez un autre ensuite, retapez ces trois commandes, retapez le `export PATH` plus bas, puis reprenez le tutoriel là où vous étiez arrêté.
|
||||
|
||||
Extrayez le contenu des archives que vous avez téléchargées dans ce dossier, et créez deux répertoires `build-binutils` et `build-gcc`. Si par exemple les archives sont au format `.tar.xz` dans le dossier que vous venez de choisir, vous pouvez les extraire avec `tar`. Pour créer les sous-dossiers, utilisez `mkdir` comme d'habitude.
|
||||
|
||||
[code]% tar -xJf binutils-2.31.1.tar.xz
|
||||
% tar -xJf gcc-8.2.0.tar.xz
|
||||
[code]% tar -xJf binutils-2.39.tar.xz
|
||||
% tar -xJf gcc-11.1.0.tar.xz
|
||||
% mkdir build-binutils build-gcc[/code]
|
||||
Après cela, votre dossier doit ressembler ceci quand vous exécutez la commande "`tree -L 1`" :
|
||||
On va ensuite appliquer quelques patchs. On va d'abord toucher un fichier de binutils pour éviter la régénération d'un parser avec bison qui ne marche plus depuis longtemps :
|
||||
|
||||
[code]% tree -L 1
|
||||
.
|
||||
├── binutils-2.32
|
||||
├── binutils-2.32.tar.xz
|
||||
├── build-binutils
|
||||
├── build-gcc
|
||||
├── gcc-9.2.0
|
||||
└── gcc-9.2.0.tar.xz[/code]
|
||||
Le compilateur et tous les outils de sa suite vont arriver dans un sous-dossier `bin`. Pour pouvoir les utiliser sur la ligne de commande, vous devez les ajouter au `PATH`. (Le `PATH` est l'ensemble des dossiers dans lesquels le terminal cherche les commandes.) Utilisez la commande ci-dessous pour modifier temporairement le `PATH`.
|
||||
[code]% touch binutils-2.39/intl/plural.c[/code]
|
||||
Si vous utilisez GCC 11.1 (et sans doute quelques versions d'avant), téléchargez de plus [url=https://gitea.planet-casio.com/Lephenixnoir/sh-elf-gcc/src/branch/master/patches/gcc-11.1.0-libstdc++-v3-skip-dlopen.patch]ce patch[/url] qui désactive des tests de configuration inutilement aggressifs dans la lib C++ et appliquez-le :
|
||||
|
||||
[code]% export PATH="$PATH:$PREFIX/bin"[/code]
|
||||
La modification sera perdue quand le terminal sera fermé. Pour que ce changement soit permanent, il faut ajouter la commande à la fin du fichier `$HOME/.profile`, ou à `$HOME/.bashrc` si vous utilisez WSL sous Windows 10. La commande suivante le fait pour vous. ;)
|
||||
[code]% patch -u -N -p0 < gcc-11.1.0-libstdc++-v3-skip-dlopen.patch[/code]
|
||||
[brown][b][u]4. Compilation de binutils[/u][/b][/brown]
|
||||
|
||||
[code]% echo "export PATH=\"\$PATH:$PREFIX/bin\"" >> $HOME/.profile[/code]
|
||||
La compilation de binutils est un configure/make classique. Les options qu'on utilise sont :
|
||||
|
||||
[label=binutils]
|
||||
[big][brown][b]4. Compilation de binutils[/b][/brown][/big]
|
||||
|
||||
La compilation de `binutils` est très classique : d'abord on configure nos options avec `./configure`, ensuite on compile avec `make`, puis on installe avec `make install`. C'est comme ça pour un nombre incalculable de logiciels.
|
||||
|
||||
Notez (ça marche jusqu'à la fin du tutoriel) que `make` possède une option `-j` pour compiler avec plusieurs processus en même temps, pour aller plus vite. Utilisez toujours `-j` suivi d'un nombre, typiquement votre nombre de coeurs. Pour moi, `-j4`.
|
||||
|
||||
[url=https://programmers.stackexchange.com/questions/156569/how-many-make-threads-to-use]Choisir le bon nombre de threads pour `-j`[/url] (pour ceux que ça intéresse)
|
||||
[list=arrow]
|
||||
[li]`--prefix` pour indiquer le dossier d'installation final.[/li]
|
||||
[li]`--target="sh3eb-elf"` pour spécifier qu'on veut un cross-compilateur pour SuperH.[/li]
|
||||
[li]`--with-multilib-list="m3,m4-nofpu"` indique plus précisément qu'on veut une variante pour SH3 et une pour SH4 sans FPU.[/li]
|
||||
[li]`--program-prefix="sh-elf-"` renomme le compilateur de `sh3eb-elf-gcc` à `sh-elf-gcc` vu qu'on a aussi le SH3.[/li]
|
||||
[/list]
|
||||
Il n'y a pas beaucoup d'autres options intéressantes, mais vous pouvez les voir toutes avec `configure --help`.
|
||||
|
||||
[code]% cd build-binutils
|
||||
% ../binutils-2.32/configure --prefix=$PREFIX --target=sh3eb-elf --with-multilib-list=m3,m4-nofpu --disable-nls --program-prefix=sh-elf-[/code]
|
||||
Ici, l'option `--prefix` indique où on va installer le compilateur. `--target` avec `--with-multilib-list` permet de spécifier à la fois SuperH-3 et SuperH-4 sans FPU comme cibles. Enfin, `--program-prefix` permet de donner un nom personnalisé au compilateur, ici `sh-elf-gcc`. ;)
|
||||
|
||||
(experts) La liste complète des options de compilation est donnée par `configure --help`, en voici quelques-unes suscesptibles de vous intéresser :
|
||||
|
||||
`--disable-nls` pour forcer les diagnostics en anglais
|
||||
`--disable-werror` pour supprimer l'option `-Werror`
|
||||
`--enable-libssp` pour compiler `libssp` (protection de pile)
|
||||
`--enable-lto` pour activer le support des optimisations au linkage (puissant)
|
||||
|
||||
Une fois que tout est configuré, il n'y a plus qu'à compiler et à installer. Normalement ça va assez vite, comptez quelques minutes. Si vous avez une erreur de compilation, vérifiez les dépendances et les en-têtes possiblement manquants. Sinon, changez de version de `binutils` et éventuellement de `gcc`.
|
||||
% ../binutils-2.39/configure --prefix="$PREFIX" --target="sh3eb-elf" --with-multilib-list="m3,m4-nofpu" --program-prefix="sh-elf-"[/code]
|
||||
Une fois que tout est configuré, il n'y a plus qu'à compiler et à installer. Normalement ça va assez vite, comptez quelques minutes.
|
||||
|
||||
[code]% make -j4
|
||||
% make install[/code]
|
||||
Les exécutables de `binutils` ont dû apparaître dans `$PREFIX/bin`. Essayez de taper `$PREFIX/bin/sh-elf-as --version` pour vérifier que ça marche !
|
||||
% make install-strip[/code]
|
||||
Les exécutables de `binutils` ont dû apparaître dans `$PREFIX/bin` Essayez `sh-elf-ld --version` qui doit vous renvoyer la version de binutils (ici 2.39).
|
||||
|
||||
[brown][b][u]5. Compilation de gcc et de libgcc[/u][/b][/brown]
|
||||
|
||||
[label=gcc]
|
||||
[big][brown][b]5. Compilation de gcc et de libgcc[/b][/brown][/big]
|
||||
Ensuite c'est pareil mais pour GCC. En plus des options précédentes, on indique :
|
||||
|
||||
Maintenant, on recommence pareil, mais cette fois on compile un morceau beaucoup plus gros : `gcc`. L'option `--enable-languages` vous permet de choisir les langages que vous voulez pouvoir compiler, notamment C, C++, Ada, Go ou Fortran. Attention au temps de compilation qui va vite monter !
|
||||
[list=arrow]
|
||||
[li]`--enable-languages="c,c++"` qui spécifie les compilateurs qu'on veut. Si vous voulez expérimenter avec d'autres langages notamment Ada, D, Go ou Fortran, c'est là qu'il faut commencer ![/li]
|
||||
[li]`--without-headers` qui indique essentiellement qu'on veut un cross-compilateur.[/li]
|
||||
[li]`--enable-clocale="generic"` qui simplifie le module `<locale>` de la lib C++.[/li]
|
||||
[li]`--enable-libstdcxx-allocator` qui fait de même avec les allocateurs mémoire.[/li]
|
||||
[li]`--disable-threads` qui désactive le threading (qu'on n'a pas).[/li]
|
||||
[li]`--disable-libstdcxx-verbose` qui élimine des logs dans la lib C++.[/li]
|
||||
[li]`--enable-cxx-flags="-fno-exceptions"` qui désactive les exceptions durant la compilation de la lib C++.[/li]
|
||||
[/list]
|
||||
Voyez [url=https://gcc.gnu.org/install/configure.html]le guide de configuration[/url] pour toutes les options utiles.
|
||||
|
||||
[code]% cd $PREFIX/build-gcc
|
||||
% ../gcc-9.2.0/configure --prefix=$PREFIX --target=sh3eb-elf --with-multilib-list=m3,m4-nofpu --enable-languages=c,c++ --without-headers --with-newlib --disable-nls --program-prefix=sh-elf-[/code]
|
||||
(experts) Les options `--disable-werror`, `--enable-libssp` et `--enable-lto` doivent être passées ici aussi si vous les avez passées à `binutils`.
|
||||
[code]% cd "$PREFIX/build-gcc"
|
||||
% ../gcc-11.1.0/configure --prefix="$PREFIX" --target="sh3eb-elf" --with-multilib-list="m3,m4-nofpu" --enable-languages="c,c++" --without-headers --program-prefix="sh-elf-" --enable-clocale="generic" --enable-libstdcxx-allocator --disable-threads --disable-libstdcxx-verbose --enable-cxx-flags="-fno-exceptions[/code]
|
||||
Cette fois la compilation occupera entre 10 et 30 minutes... ou 5/6 heures sur un vieux Raspberry Pi. :E
|
||||
|
||||
Et c'est parti pour compiler ! Comptez entre 10 et 30 minutes (pour `c,c++`) selon la puissance de votre ordinateur, 5 à 6 heures sur un vieux Raspberry Pi ! :E
|
||||
[code]% make -j4 all-gcc all-target-libgcc
|
||||
% make install-strip-gcc install-strip-target-libgcc[/code]
|
||||
Avec ça vous devez pouvoir taper `sh-elf-gcc -v` et la version et les options de compilation. ^^
|
||||
|
||||
[code]% make -j4 all-gcc
|
||||
% make install-gcc[/code]
|
||||
GCC fournit également une bibliothèque appelée `libgcc` qui contient des fonctions indispensables. Tout le code compilé avec `gcc` doit être linké avec `libgcc`. On compile donc cette bibliothèque, ce qui se passe très vite et sans la moindre difficulté.
|
||||
:arrow: [fxSDK] C'est le moment d'installer [url=https://gitea.planet-casio.com/Lephenixnoir/OpenLibm]OpenLibm[/url], avec `make`.
|
||||
:arrow: [fxSDK] Installez aussi la lib C, [url=https://gitea.planet-casio.com/Vhex-Kernel-Core/fxlibc/]fxlibc[/url], un autre `cmake`/`make` classique.
|
||||
|
||||
[code]% make -j4 all-target-libgcc
|
||||
% make install-target-libgcc[/code]
|
||||
Vous pouvez désormais taper `sh-elf-gcc -m3` et `sh-elf-gcc -m4-nofpu` et vous devez avoir juste une erreur fatale indiquant que vous n'avez pas donné de fichier à compiler. Si on prend une autre cible, par exemple avec `sh-elf-gcc -m4`, GCC doit se plaindre que `-m4` n'est pas supporté parce que ne l'a pas demandé.
|
||||
[brown][b][u]6. Compilation de libstdc++[/u][/b][/brown]
|
||||
|
||||
Si tout s'est bien passé, alors vous avez terminé ce tutoriel ! La partie 7 vous guidera vers un SDK pour créer vos add-ins :D
|
||||
On peut maintenant revenir dans le dossier de compilation de GCC et compiler des libs plus évoluées, comme la lib C++. Si vous testez d'autres langages (par exemple D) c'est le moment de compiler les libs qui vont avec (libphobos), ou même de compiler libssl, libiberty, etc. selon vos goûts.
|
||||
|
||||
[label=newlib]
|
||||
[big][brown][b]6. Compilation de newlib (experts)[/b][/brown][/big]
|
||||
[code]% make -j4 all-target-libstdc++-v3
|
||||
% make install-strip-target-libstdc++-v3[/code]
|
||||
Et voilà, la toolchain est complète. Si vous manquez d'espace disque vous pouvez supprimez les archives, dossiers de sources, et dossiers de build de binutils et GCC.
|
||||
|
||||
[profil]Memallox[/profil] a construit un [url=https://www.planet-casio.com/Fr/forums/topic15316-1-Complete-C-standard-library.html]port de newlib (en anglais)[/url] pour supporter une libc avec `gcc`. Pour l'instant c'est au stade expérimental ; vous pouvez sauter cette section jusqu'à ce que ce soit bien étudié. Si vous savez de quoi vous parlez, vous pouvez le compiler maintenant.
|
||||
:arrow: [fxSDK] Installez maintenant [url=https://gitea.planet-casio.com/Lephenixnoir/gint]gint[/url], et les autres libs qui vous plaisent (eg. libprof, zlib, etc).
|
||||
|
||||
Clônez le [url=https://git.planet-casio.com/Memallox/libc]dépôt de Memallox[/url] dans le répertoire de travail ou créez un lien symbolique. Ensuite, configurez de la même façon :
|
||||
|
||||
[code]% git clone https://git.planet-casio.com/Memallox/libc
|
||||
% mkdir build-newlib
|
||||
% cd build-newlib
|
||||
% ../libc/configure --prefix=$PREFIX --target=sh3eb-elf --enable-target-optspace
|
||||
% make -j4
|
||||
% make install[/code]
|
||||
Là aussi les options de configuration `--enable-libssp` et `--enable-lto` peuvent vous intéresser. Ensuite, recompilez `gcc` (avec les mêmes options, en particulier `--without-headers` et `--with-newlib`) :
|
||||
|
||||
[code]% cd build-gcc
|
||||
% ../gcc-9.2.0/configure --prefix=$PREFIX --target=sh3eb-elf --with-multilib-list=m3,m4-nofpu --enable-languages=c,c++ --without-headers --with-newlib --disable-nls --program-prefix=sh-elf-
|
||||
% make -j4 all-gcc
|
||||
% make install-gcc
|
||||
% make -j4 all-target-libgcc
|
||||
% make install-target-libgcc[/code]
|
||||
Je ne suis pas sûr qu'il soit nécessaire de recompiler `libgcc` mais ça ne coûte rien !
|
||||
|
||||
|
||||
[label=runtime]
|
||||
[big][brown][b]7. Choisir un environnement de développement[/b][/brown][/big]
|
||||
|
||||
Maintenant que vous avez le compilateur, vous pouvez écrire des add-ins ! Enfin... presque. Il vous manque encore de quoi écrire à l'écran, récupérer les touches pressées sur le clavier, et convertir vos images. ;)
|
||||
|
||||
Pour ça, vous avez (à l'heure où j'écris cette version du tutoriel), deux choix : utiliser fxlib porté pour GCC, ou bien utiliser [url=https://www.planet-casio.com/Fr/forums/topic13164-1-fxSDK,-un-SDK-alternatif-pour-ecrire-des-add-ins.html]le fxSDK[/url].
|
||||
|
||||
Jusqu'ici le tutoriel pour développer des add-ins avec fxlib était sur cette page, mais je vais le déplacer dans un topic à part. Je l'ai temporairement laissé dans le spoiler ci-dessous.
|
||||
|
||||
Pour le fxSDK, la page du projet détaille son installation et son utilisation. C'est plus facile que GCC donc vous avez déjà quasiment tout fait !
|
||||
|
||||
[spoiler=Ancien tutoriel d'utilisation de fxlib (commence à être très vieux)]
|
||||
[big][brown][b]Installation du `g1a-wrapper`[/b][/brown][/big]
|
||||
|
||||
Votre `binutils` produit des fichiers au format ELF. Il y a encore un peu de travail à faire avant d'obtenir un `g1a`. Le `g1a-wrapper` est un petit programme qui va nous y aider. Clônez-le depuis un dépôt git et installez-le dans le dossier des binaires du compilateur.
|
||||
|
||||
[code]% cd $PREFIX
|
||||
% git clone "https://Lephenixnoir""@""bitbucket.org/Lephenixnoir/add-in-wrapper.git"
|
||||
% cd add-in-wrapper
|
||||
% make
|
||||
% cp build/g1a-wrapper $PREFIX/bin[/code]
|
||||
|
||||
[big][brown][b]Environnement de projet[/b][/brown][/big]
|
||||
|
||||
On va créer un modèle de projet que vous pourrez réutiliser. Tout ça se passe en-dehors de la compilation de gcc, je vous conseille donc de changer de dossier. [i]~/my-awesome-project[/i] pourrait être sympa. Dans tous les cas, vous pouvez fermer le terminal pour l'instant. Si vous avez de l'expérience dans la programmation C, je ne vais pas vous apprendre à organiser un projet... il vous faudra juste quelques fichiers donnés plus bas.
|
||||
|
||||
Voilà par exemple comment on pourrait organiser un projet:
|
||||
- un dossier [i]include[/i] contenant les 6 headers de fxlib ([i]dispbios.h[/i], [i]endian.h[/i], [i]filebios.h[/i], [i]fxlib.h[/i], [i]keybios.h[/i], [i]timer.h[/i])
|
||||
- la bibliothèque [i]libfx.a[/i]
|
||||
- les fichiers [i]addin.ld[/i] et [i]crt0.s[/i]
|
||||
- une icône, par exemple [i]icon.bmp[/i]
|
||||
- les sources (dans un dossier [i]src[/i] par exemple)
|
||||
|
||||
Le code de base est un peu plus simple qu'avec le SDK (toutes les choses bourrines ayant été mises dans [i]crt0.s[/i]) :[/justify]
|
||||
[code]#include <fxlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
unsigned int key;
|
||||
locate(1, 1);
|
||||
Print((unsigned char *)"gcc add-in");
|
||||
while(1) GetKey(&key);
|
||||
return 1;
|
||||
}[/code]
|
||||
[justify]Tous ces fichiers sont prêts à utiliser dans l'archive suivante.
|
||||
[url=http://www.planet-casio.com/files/forums/projet-142401.zip]Télécharger le projet d'exemple[/url]
|
||||
|
||||
Voilà sans plus attendre la commande à utiliser pour compiler ce nouveau projet. Y'a plein d'options, mais rien de bien méchant, vous allez voir...[/justify]
|
||||
[code]$ sh3eb-elf-gcc -m3 -mb -mrenesas -ffreestanding -nostdlib -T addin.ld crt0.s addin.c -o addin.elf -I include -lgcc -L . -lfx -O2[/code]
|
||||
[justify]- Les options [i]-m3[/i] et [i]-mb[/i] indiquent qu'on veut du code pour SH3 (même si on utilise déjà le [i]sh3eb-elf[/i], il y a plusieurs variantes) utilisant le big-endian (cela concerne l'ordre des octets en mémoire dans des variables de plusieurs octets)
|
||||
- L'option [i]-mrenesas[/i] demande à GCC de produire du code compatible avec fxlib
|
||||
- L'option [i]-ffreestanding[/i] signale que le programme compilé tient « tout seul », sans s'appuyer sur un système d'exploitation (gcc fournit alors deux-trois choses en plus)
|
||||
- L'option [i]-I include[/i] indique que certains de nos fichiers d'en-tête sont dans le dossier [i]include[/i]
|
||||
- L'option [i]-nostdlib[/i] indique que l'on n'a pas de bibliothèque standard (elle est dans fxlib)
|
||||
- L'option [i]-O2[/i] active l'optimisation du code (facultatif, mais utile)
|
||||
|
||||
Ça c'est les options de compilation proprement dites. Ici, on compile tout d'un coup et on effectue l'édition des liens (génération du fichier exécutable) dans la foulée, donc les options se mélangent. Si vous avez un gros projet, vous allez compiler les fichiers un par un avec [i]-c[/i] et tout linker ensuite. Les options que j'ai citées pour l'instant sont celles qu'on utilisera à la compilation. Les options suivantes sont spécifiques au linkage :
|
||||
|
||||
- L'option [i]-T addin.ld[/i] indique au compilateur que les règles qu'on l'on veut voir respecter lors de l'édition des liens sont dans le fichier [i]addin.ld[/i]
|
||||
- Les options [i]-L .[/i] et [i]-lfx[/i] indiquent qu'on veut utiliser fxlib, et que le fichier [i]libfx.a[/i] se trouve dans le dossier courant
|
||||
- L'option [i]-lgcc[/i] spécifie l'utilisation de libgcc (il faut toujours utiliser libgcc !)
|
||||
- Bien sûr, [i]-o addin.elf[/i] indique le nom du fichier de sortie
|
||||
|
||||
Notez que le fichier [i]crt0.s[/i] est un autre fichier source qui contient du code indispensable. Pensez à le compiler aussi, ici en même temps que le programme [i]addin.c[/i]. Le fichier de sortie est au format ELF (le format classique sous Linux), ce qu'on avait prévu en compilant un gcc pour l'architecture [i]sh3eb-elf[/i].
|
||||
|
||||
[big][brown][b]Génération du g1a[/b][/brown][/big]
|
||||
|
||||
Le format ELF a plein d'avantages, mais on ne veut que du binaire pur. Pour cela, on va utiliser un programme de binutils, [i]objcopy[/i], qui va nous permettre de changer le format. En deux mots, supprimer l'ELF et ne garder que le binaire pur (ce qui est dit par [i]-O binary[/i]). On supprime aussi deux-trois sections au passage ([i].comment[/i] et [i].bss[/i]), n'oubliez pas de le faire sinon vous aurez un fichier énormissime en sortie.[/justify]
|
||||
[code]$ sh3eb-elf-objcopy -R .comment -R .bss -O binary addin.elf addin.bin[/code]
|
||||
[justify]On n'a plus maintenant qu'à ajouter les informations de l'application add-in pour obtenir un fichier g1a. C'est le boulot du [i]g1a-wrapper[/i]. Il y a des options pour pas mal de champs (que vous pouvez obtenir en exécutant [i]g1a-wrapper --help[/i]), mais faisons simple et mettons juste une icône :[/justify]
|
||||
[code]$ g1a-wrapper addin.bin -o addin.g1a -i icon.bmp[/code]
|
||||
|
||||
[justify]Terminé ! Vous n'avez plus qu'à transférer votre nouvel add-in... pour ça, seul un bon vieux terminal et des programmes en ligne de commande sont désormais dignes de vous. On en a quelques-uns :
|
||||
- Le grand [url=http://www.planet-casio.com/Fr/forums/lecture_sujet?id=14487]P7[/url] de Cakeisalie5
|
||||
- [url=http://www.planet-casio.com/Fr/forums/topic14276-1--CasioUsb-(Outil-multifonction-USB-pour-calculatrice-CASIO).html]CasioUsb[/url] de Nessotrin[/spoiler]
|
||||
|
||||
Merci d'avoir suivi ce tuto ! N'hésitez pas à laisser vos impressions, idées d'amélioration, messages de réussite ou même messages d'erreur dans les commentaires ! :)
|
||||
Et voilà, vous avez un compilateur C/C++ complet voire un SDK complet pour programmer des add-ins. ^^
|
||||
|
|
|
|||
Loading…
Reference in New Issue