Tous | Basic Casio | C/C++/ASM | LuaFX | Graphisme | Transferts | Logiciels | Diverses astuces

Calculatrice
Toutes
Graphs 35 à 100
Graph 25
Graphs 75/85/95 (SD)
Graph 100(+)
Classpad 300/330 (+)
Fx-CG 10/20
Fx-CP 400

Retour à la liste des tutoriels
Tutoriel Casio : Compiler sous Linux avec GCC
Tutoriel rédigé le : 2014-07-29 15:21  par Lephenixnoir  Catégorie : C/C++/ASM  Calculatrice : Graphs 75/85/95 (SD)

Discutez de ce tutoriel sur le forum >> Voir le sujet dédié (129 commentaires)

Compiler sous Linux avec GCC

Linux ne va pas sans son puissant compilateur, gcc, et ses opportunités de développer autrement, et avec plus de liberté. Ce tutoriel présente la compilation de gcc pour l'architecture sh3eb-elf, qui est celle de la calculatrice.

Rassurez-vous, cela n'a rien d'une opération militaire.

Planification de l'opération
Étape 1 : Préparation des équipements (les dépendances)
Étape 2 : Analyse du terrain (préparation)
Assaut frontal
Étape 3 : Premiers échanges de tirs (binutils)
Étape 4 : Les chars d'assaut (gcc)
Étape 5 : Nettoyage aérien (libgcc)
Conquête du territoire
Étape 6 : Installation des forces armées (g1a-wrapper)
Étape 7 : Commandement central (projets)
Étape 8 : Réseaux de communication (fichiers g1a)




Étape 1 : Préparation des équipements (installation des dépendances)

On ne va pas simplement installer gcc, mais réellement deux composants : binutils (binary utilities), qui traite du langage assembleur, de l'édition des liens, des formats exécutables, et tout le reste de ce qui touche au code compilé mais pas au langage C, et le compilateur gcc (GNU Compiler Collection) en lui-même. On va configurer les deux pour l'architecture sh3eb-elf, ce qui signifie « pour SH3 » (le processeur), et « au format ELF » (le format des fichiers exécutables).

Pour cette version du tutoriel (11.09.2016), j'ai utilisé gcc-6.1.0 et binutils-2.26. N'hésitez pas à choisir des versions plus récentes. Bien sûr, des versions trop éloignées dans le temps ne seront pas forcément compatibles. La communauté d'OSDev (qui cross-compile souvent gcc) tient à jour un tableau dans lequel elle indique les compilations réussies. Si vous réussissez une nouvelle combinaison, allez leur dire.

La manipulation peut parfois échouer de manière plus ou moins imprévisible (malheureusement il y a beaucoup de facteurs difficiles à calculer...) ; dans ce cas, vous pourrez télécharger d'autres versions et réessayer.

[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]
Compilations réussies par la communauté d'OSDev

Inévitablement, vous allez devoir passer par l'installation des dépendances. J'ai noté leur usage à titre indicatif. Notez que le -dev à la fin du nom de paquet indique que les fichiers installés permettent la compilation de programmes utilisant la bibliothèque, pas juste leur exécution (cela concerne par exemple les fichiers d'en-tête). Les noms de paquets indiqués entre parenthèses sont valables au moment où je rédige cette version du tutoriel (11.09.2016).

- mpfr  (libmpfr-dev)   : flottants à précision variable
- mpc   (libmpc-dev)    : complexes à précision variable
- gmp   (libgmp-dev)    : arithmétique à multi-précision
- png   (libpng12-dev)  : manipulation d'images
- ppl   (libppl-dev)    : polyèdres Parma (optimisation magique)
- g++   (g++)           : compilateur C++
- git   (git)           : gestionnaire de versions

De manière générale, téléchargez la dernière version. Sous Debian et ses dérivés (Ubuntu, Mint, etc.), utilisez apt-get, sinon, ben débrouillez-vous (yaourt, yum, pacman, peu importe, ce n'est pas moi qui vais vous apprendre à vous en servir).




Étape 2 : Analyse du terrain (préparation de l'environnement)

On va compiler tout ça dans un sous-dossier de votre répertoire personnel nommé opt (un classique et bonne habitude). Il faut donc le créer... et s'y rendre. Ouvrez un terminal, vous ne le quitterez pas avant longtemps.


$ mkdir -p ~/opt/sh3eb-elf
$ cd ~/opt/sh3eb-elf

Pour mémoire, sh3eb-elf c'est le nom du cross-compilateur qu'on va compiler.

Ensuite, on va créer deux sous-dossiers pour compiler binutils et gcc. Toute la compilation se fera dans ses dossiers. Si vous voulez recommencer la procédure, supprimez-les, recréez-les, et vous êtes prêt à repartir.


$ mkdir build-binutils build-gcc

Extrayez enfin les deux archives que vous avez téléchargées à l'étape précédente dans le dossier ~/opt/sh3eb-elf. Vous aurez alors deux autres dossiers dont les noms correspondent aux versions que vous avez choisies : binutils-2.26 et gcc-6.1.0 pour moi. Pensez à adapter vos commandes par la suite, si vous n'avez pas utilisé les mêmes ces versions-là.




Étape 3 : Premiers échanges de tirs (compilation de binutils)

La compilation de binutils est classique au possible, un coup de configure et puis make. Notez (et cela reste valable jusqu'à la fin de ce tutoriel) que make possède une option -j (suivi d'un nombre, ne l'utilisez pas sans nombre) vous permettant de configurer le nombre de threads à utiliser, pour aller plus vite.

Comment choisir le nombre de threads pour -j (pour information)


$ cd build-binutils
$ ../binutils-2.26/configure --target=sh3eb-elf --prefix="$HOME/opt/sh3eb-elf/" --disable-nls --disable-werror

Vous aurez reconnu l'option --target, qui indique l'architecture cible (ici la calculatrice, qui est un processeur SuperH-3). Pour ceux qui se posent la question de la compatibilité SH4, vous n'aurez pas de problème avec les SH4 (l'inverse n'aurait pas été vrai). L'option --disable-nls force les diagnostics du compilateur à être en anglais (c'est une bonne habitude à prendre ; par ailleurs, Internet ne connaît que l'anglais) et --disable-werror désactive l'option de compilation -Werror, que vous n'utiliserez jamais.

Ensuite, on compile et on installe avec make :


$ make
$ sudo make install

Si vous avez une erreur à la compilation, vérifiez que vous avez bien toutes les dépendances, et s'il ne vous manque pas des en-têtes que vous pourriez installer. Sinon, recommencez depuis l'étape 1 en changeant de version de binutils et éventuellement de gcc.




Étape 4 : Les chars d'assaut (compilation de gcc)

Maintenant que vous avez installé binutils, les fichiers exécutables sont apparus dans ~/opt/sh3eb-elf/bin. On ne les déplaçera pas, il faut donc ajouter ce dossier au PATH (liste des dossiers où les programmes sont recherchés) si on veut pouvoir les utiliser. La commande suivante vous permet de le faire de manière temporaire (jusqu'à ce que le terminal soit fermé, en fait). Pour que la configuration soit permanente, ajoutez la commande à la fin du fichier ~/.profile.


export PATH=$PATH:$HOME/opt/sh3eb-elf/bin

La suite est dans le même ton que précédemment. On configure, puis on compile. Notez que l'option --enable-languages vous permet de spécifier les différentes compilateurs que vous allez créer. En général, C et C++ suffisent, mais vous pouvez ajouter Ada, Go ou Fortran si vous avez l'intention de les utiliser. En revanche, ça va être long, donc n'en abusez pas.


$ cd ~/opt/sh3eb-elf/build-gcc
$ ../gcc-6.1.0/configure --target=sh3eb-elf --prefix="$HOME/opt/sh3eb-elf" --disable-nls --enable-languages=c,c++ --without-headers

Vous reconnaissez des options similaires à celles de tout à l'heure. Si la configuration échoue à cause de headers manquants, installez-les puis relancez configure. Sinon, vous êtes prêts pour le plus gros morceau de la séance (n'hésitez pas à utiliser l'option -j en spécifiant le nombre de threads) :


$ make all-gcc
$ sudo make install-gcc

Si vous avez des erreurs de compilation que vous ne savez pas résoudre... vous allez devoir reprendre à l'étape 1. Désolé.




Étape 5 : Nettoyage aérien (installation de libgcc)

Dernière grande étape, vous devez compiler libgcc. Vous devez absolument compiler libgcc, et vous devrez toujours l'utiliser pour compiler vos programmes.


$ make all-target-libgcc
$ sudo make install-target-libgcc

Si la compilation échoue, de nouveau... retournez à l'étape 1 (à ce stade c'est plutôt déprimant mais les efforts paient).

Félicitations ! Votre compilateur est installé et prêt à être utilisé. Commencez par tester quelques commandes pour le vérifier...


$ sh3eb-elf-as --version
GNU assembler (GNU Binutils) 2.26.20160125 [...]
~$ sh3eb-elf-gcc --version
sh3eb-elf-gcc (GCC) 6.1.0 [...]
~$ sh3eb-elf-gcc -print-file-name=libgcc.a
/home/lephe/opt/sh3eb-elf/lib/gcc/sh3eb-elf/6.1.0/libgcc.a

Si vous avez quelque chose comme ça, vous êtes prêts à... poursuivre le tuto. Ce n'est pas encore tout à fait suffisant !



Étape 6 : Installation de forces armées (le wrapper)

Certains d'entre vous auront tiqué quand j'ai parlé de format ELF, comme dans sh3eb-elf. La calculatrice ne veut entendre parler que de g1a... mais voilà, le g1a est un format de Casio, gcc ne sait pas du tout comment on en fait. En revanche, nous on sait. On va donc utiliser un wrapper pour créer le fichier g1a à partir du fichier ELF. On va le piquer dans un dépôt git et l'installer dans le dossier qui contient déjà les binaires du compilateur.


$ cd ~/opt/sh3eb-elf
$ git clone "https://Lephenixnoir""@""bitbucket.org/Lephenixnoir/add-in-wrapper.git"
$ cd add-in-wrapper
$ make
$ cp build/g1a-wrapper ~/opt/sh3eb-elf/bin

Vous êtes maintenant prêts à développer des programmes pour la calculatrice ! Voyons ensemble comment s'y prendre...




Étape 7 : Commandement central (environnement de projet)

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. ~/my-awesome-project 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 include contenant les 6 headers de fxlib (dispbios.h, endian.h, filebios.h, fxlib.h, keybios.h, timer.h)
- la bibliothèque libfx.a
- les fichiers addin.ld et crt0.s
- une icône, par exemple icon.bmp
- les sources (dans un dossier src par exemple)

Le code de base est un peu plus simple qu'avec le SDK (toutes les choses bourrines ayant été mises dans crt0.s) :


#include <fxlib.h>

int main(void)
{
    unsigned int key;
    locate(1, 1);
    Print((unsigned char *)"gcc add-in");
    while(1) GetKey(&key);
    return 1;
}

Tous ces fichiers sont prêts à utiliser dans l'archive suivante.
Télécharger le projet d'exemple

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...


$ sh3eb-elf-gcc -m3 -mb -nostdlib -T addin.ld crt0.s addin.c -o addin.elf -I include -lgcc -L . -lfx -O2

- Les options -m3 et -mb indiquent qu'on veut du code pour SH3 (même si on utilise déjà le sh3eb-elf, 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 include indique que certains de nos fichiers d'en-tête sont dans le dossier include
- L'option -nostdlib indique que l'on n'a pas de bibliothèque standard (elle est dans fxlib)
- L'option -O2 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 -c 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 -T addin.ld indique au compilateur que les règles qu'on l'on veut voir respecter lors de l'édition des liens sont dans le fichier addin.ld
- Les options -L . et -lfx indiquent qu'on veut utiliser fxlib, et que le fichier libfx.a se trouve dans le dossier courant
- L'option -lgcc spécifie l'utilisation de libgcc (il faut toujours utiliser libgcc !)
- Bien sûr, -o addin.elf indique le nom du fichier de sortie

Notez que le fichier crt0.s est un autre fichier source qui contient du code indispensable. Pensez à le compiler aussi, ici en même temps que le programme addin.c. 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 sh3eb-elf.




Étape 8 : Réseaux de communication (génération du g1a)

Le format ELF a plein d'avantages, mais on ne veut que du binaire pur. Pour cela, on va utiliser un programme de binutils, objcopy, 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 -O binary). On supprime aussi deux-trois sections au passage (.comment et .bss), n'oubliez pas de le faire sinon vous aurez un fichier énormissime en sortie.


$ sh3eb-elf-objcopy -R .comment -R .bss -O binary addin.elf addin.bin

On n'a plus maintenant qu'à ajouter les informations de l'application add-in pour obtenir un fichier g1a. C'est le boulot du g1a-wrapper. Il y a des options pour pas mal de champs (que vous pouvez obtenir en exécutant g1a-wrapper --help), mais faisons simple et mettons juste une icône :


$ g1a-wrapper addin.bin -o addin.g1a -i icon.bmp


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 P7 de Cakeisalie5
- CasioUsb de Nessotrin



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 !



Fichier joint


Discutez de ce tutoriel sur le forum >> Voir le sujet dédié (129 commentaires)

Publicité et partenaires
Casio Education
Casio éducation

TI-Planet
Casiopeia
Casiopeia
CasioFan, la communauté ClassPad
CasioFan
CodeWalrus
CodeWalrus

Planète Casio v42 © créé par Neuronix et Muelsaco 2004 - 2015 | Il y a 27 connectés | Nous contacter | Qui sommes-nous ? | Licences et remerciements
Rugby Manager | Jeu de basket | Jeu de handball | Jeu de tennis | Nova Raider | Réparation téléphone | Soccer Rush | Tasty Tale

Planète Casio est un site communautaire indépendant, géré bénévolement et n'est donc pas affilié à Casio | Toute reproduction de Planète Casio, même partielle, est interdite
Les fichiers, programmes et autres publications présents sur Planète Casio restent la propriété de leurs auteurs respectifs et peuvent être soumis à des licences ou des copyrights.
CASIO est une marque déposée par CASIO Computer Co., Ltd