Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
En pratique : Comment construire un compilateur croisé AmigaOS 4 (Binutils 2.23.2 & GCC 8.3.0) sur MSYS2
(Article écrit par Roman Kargin et extrait d'OS4Coding.net - novembre 2018)
|
|
Note : traduction par David Brunet.
L'avantage d'avoir un compilateur croisé à jour pour AmigaOS 4 n'a probablement pas besoin d'être expliqué,
car tout évolue, et même sur AmigaOS 4 nous avons dû évoluer, même par petits pas. Si le fait de disposer d'un
compilateur croisé a de très bonnes raisons d'être (la vitesse et la possibilité d'utiliser toute une gamme
d'outils utiles comme cmakes, autoconf et les langages de script), le fait d'avoir un compilateur croisé
à jour a encore plus de raisons d'être : la possibilité d'utiliser C++XX jusqu'à C++17, la gestion
des fils d'exécution dans C++XX, les corrections de bogues (et les nouveaux bogues, bien sûr :)) et tous les trucs
fantaisistes qui viennent avec le nouveau GCC. Certains projets à code source ouvert ne peuvent même plus être
compilés avec les anciens compilateurs (comme la série GCC 4.x).
Alors que certains projets peuvent être modifiés pour une compatibilité ascendante, d'autres utilisent de
nouvelles fonctionnalités qui sont impossibles à réécrire dans un délai raisonnable. Il est donc toujours
préférable d'avoir une version actualisée. Pour ceux qui sont curieux de savoir ce qu'il y a de nouveau
dans GCC 8.2, voici une brève liste des changements : gcc.gnu.org/gcc-8/changes.html.
L'homme qui permet d'avoir GCC sur AmigaOS 4 est Sebastian "sba1" Bauer, qui maintient le projet Adtools
sur github.com/sba1/adtools, dont le but est de fournir
un certain nombre d'outils qui peuvent être utilisés pour développer des applications pour les systèmes
AmigaOS et assimilés. Mais pour l'instant, seule la version pour AmigaOS 4 est maintenue et en relatif
bon état, ce qui est assez prévisible car tout maintenir seul pour chaque plate-forme est un cauchemar.
Alors... chapeau bas à Sebastian !
Avant, j'utilisais des compilateurs croisés sur Cygwin/Windows et sur Linux, mais cette fois, je dispose d'un
ordinateur portable HP/iCore 3 GHz avec Windows 10 (que j'utilise pour une émulation rapide de WinUAE/OS4_FE
classic, pour pouvoir faire des tests non seulement sur AmigaOne X5000 et mon vieux et fidèle Pegasos II,
mais aussi sur une configuration Classic, même si elle est émulée). Et dernièrement, j'ai eu besoin
d'avoir quelque chose de frais pour le travail de compilation croisée, et j'avais deux choix : soit à nouveau
Cygwin, soit autre chose :). J'ai longuement testé Cygwin, et bien qu'il fasse tout ce qu'il faut une fois
que vous avez installé tout ce dont vous avez besoin, je n'aime toujours pas la façon dont il maintient les
dépendances et je veux juste quelque chose de plus léger, différent et nouveau. J'ai donc choisi
MSYS2.
Comme indiqué sur le site de MSYS2 :
"Le noyau est une réécriture indépendante de MSYS, basée sur un Cygwin moderne (couche de compatibilité
POSIX) et MinGW-w64, dans le but d'une meilleure interopérabilité avec les logiciels natifs Windows. Il
fournit un interpréteur de commandes bash, Autotools, des systèmes de contrôle de révision et d'autres
éléments similaires pour construire des applications Windows natives à l'aide des chaînes d'outils MinGW-w64.
Il dispose d'un système de gestion des paquets, nommé Pacman, afin de faciliter leur installation. Il
apporte de nombreuses fonctionnalités puissantes, telles que la résolution des dépendances et les mises
à niveau complètes et simples du système, ainsi que la création directe de paquets."
Donc, si vous êtes intéressé, vous pouvez suivre les instructions du site de MSYS2 pour le télécharger et l'installer.
Préparez-vous à compiler
Pour compiler un compilateur croisé, vous aurez d'abord besoin d'un compilateur natif :). Donc vous installez
tout ce à quoi vous pouvez penser : GCC, make, Autotools, cmake, git, subversion, flex, bison, python, perl,
etc. Tout cela peut être fait via l'utilitaire Pacman en l'exécutant sur la console MSYS2, donc c'est un
peu comme apt-get, yum ou quelque chose de ce genre.
Tout d'abord, lorsque vous exécutez pour la première fois msys32.exe ou msys64.exe (selon ce que vous voulez
utiliser, les versions 32 bits ou x64), vous exécutez "pacman" pour mettre à jour tout ce que vous avez
déjà après l'installation initiale de MSYS2 :
Et vous répétez ces étapes jusqu'à ce que tout soit mis à jour.
Ensuite, nous avons besoin d'installer tous ces trucs de développement dont j'ai parlé avant, et
cela peut être fait facilement par exemple en tapant cette ligne :
|
# pacman -S --need base-devel mingw-w64-i686-toolchain mingw-w64-x86_64-toolchain python git subversion mercurial mingw-w64-i686-cmake mingw-w64-x86_64-cmake
|
Toutes les dépendances nécessaires (comme bison, flex, etc.) seront installées automatiquement. Mais si
quelque chose vous manque plus tard, vous pouvez toujours l'installer séparément via le même outil Pacman.
Préparez-vous pour le compilateur croisé
Voici maintenant la partie la plus intéressante : la compilation de notre compilateur croisé AmigaOS 4.
Mais d'abord, assurez-vous que vous avez configuré quelques paramètres supplémentaires pour GIT,
qui sont nécessaires, car sans eux, certaines des commandes suivantes (les commandes de base)
refuseront de fonctionner. Les voici :
git config --global user.email "vous@exemple.com"
git config --global user.name "Votre nom"
|
Donc, tout ce dont vous avez besoin est de suivre les étapes de la
page Adtools de Sebastian Bauer, c'est-à-dire :
$ cd /
$ mkdir /amiga
$ cd /amiga
$ git clone https://github.com/sba1/adtools
$ cd adtools
$ git submodule init
$ git submodule update
$ gild/bin/gild clone
$ gild/bin/gild checkout binutils 2.23.2
$ gild/bin/gild checkout gcc 8
|
A cette étape, nous avons téléchargé tout ce dont nous avons besoin du dépôt Adtools, et ce dont
nous avons besoin ensuite, c'est de le construire.
Pour ma part, je le construis aussi avec la gestion d'objc et obj-c++. Ce n'est pas que ce soit
nécessaire pour nous, mais parfois certaines choses le veulent, alors pourquoi pas. Sebastian Bauer,
bien sûr, ne peut pas tout gérer seul, et donc la gestion d'objc et d'obj-c++ sera "telle quelle".
Mais j'ai vu sur le dépôt d'Adtools que Jonathan Schleifer a été capable de le construire,
et de le tester par github.com/ObjFW/ObjFW où tout
compile bien et tous les tests sont passés, donc au moins ça fonctionne déjà sous une certaine forme.
Pour l'activer, j'ai dû faire une modification dans le fichier "/amiga/adtools/gccbuild/features.mk",
en changeant ceci :
...par cela :
--enable-languages=c,c++,objc,obj-c++
|
Nous n'avons besoin de rien d'autre.
Vous pouvez également voir dans ce même fichier "features.mk", qu'il y a maintenant l'argument
"--enable-threads=amigaos". Il s'agit d'une nouvelle fonctionnalité ajoutée par Sebastian Bauer
il y a quelques mois, pour faire fonctionner le traitement en fils d'exécution ("threading") de C++XX.
Oui, il s'agit bien de ce traitement en fils d'exécution dont nous parlons depuis dix années ou plus. :)
Il y a ici une nouvelle option "-athread=", où vous pouvez choisir entre trois options : native (donc
implémentation native d'AmigaOS 4, sans dépendre de pthreads du tout), single (comme c'était le cas avant
pour nous) et pthread (cette option ne fonctionne pas actuellement, elle le fera probablement à un moment
donné, mais pas tout de suite).
C'est parti
Maintenant, avant de lancer "make" et pour éviter des problèmes dans le processus, nous allons d'abord
corriger quelques problèmes cosmétiques issus de MSYS2.
1. Vous n'aurez certainement pas installé Lha, qui est utilisé pour décompresser les données de
l'archive SDK (qui sera téléchargée automatiquement depuis le site de Hyperion), alors faites-le :
cd /amiga
git clone https://github.com/fragglet/lhasa
cd lhaasa
./autogen.sh
make
make install
|
2. MSYS2 n'a pas besoin de "-ldl" et donc n'a pas cette option. Mais le processus de construction en
a besoin, donc nous allons construire un adaptateur ("wrapper") qui a été écrit spécialement pour (pour
plus d'informations, allez sur la page GitHub) :
cd /amiga
git clone https://github.com/dlfcn-win32/dlfcn-win32.git
cd dlfcn-win32/
./configure
make
make install
ln -s /mingw/lib/libdl.a /mingw32/lib/libdl.a
ln -s /mingw/lib/libdl.a /mingw64/lib/libdl.a
|
3. MSYS2 (et en général mingw) a quelques problèmes avec les chemins absolus. Par exemple,
"/usr" est en réalité "d:/msys64/usr" (ou l'endroit où vous avez installé MSYS2). Il s'agit d'un mélange de
chemin utilisé dans Windows 32 et dans Unix. Donc parfois, certains fichiers d'inclusion, ou applications,
qui utilisent certaines fonctions que d'autres n'utilisent pas, veulent utiliser de "vrais" chemins (avec
la partie Windows 32 au début). Donc, pour corriger les problèmes qui peuvent survenir inhérent à cela,
nous devons changer ceci dans "/amiga/adtools/gcc-build/Makefile" :
REAL_SRC_DIR=$(realpath $(SRC_DIR))
|
...par cela :
REAL_SRC_DIR=d:/msys64$(realpath $(SRC_DIR))
|
Gardez à l'esprit que c'est dans "d:/msys64" où nous installons MSYS2, donc le chemin peut être différent
pour vous, bien sûr.
Il y aura également des problèmes avec la directive "@include" dans les fichiers "*.texi", donc nous
devons taper ceci :
cp /amiga/adtools/gcc/repo/gcc/doc/include/* /amiga/adtools/gcc/repo/gcc/doc/
cp /amiga/adtools/native-build/gcc-cross-build-8.2.0/gcc/gcc-vers.texi /amiga/adtools/gcc/repo/gcc/doc/
|
Cela devrait être suffisant (du moins cela l'a été pour moi). Si, par la suite, vous voyez une erreur
dans un fichier ".texi", disant que le fichier "@include" est introuvable, remplacez-le simplement par
le chemin complet, ou copiez le fichier nécessaire dans ce répertoire.
Enfin, exécutez la ligne magique pour construire et installer notre compilateur croisé AmigaOS 4 :
# make -C native-build gcc-cross CROSS_PREFIX=/usr/local/amiga
|
Cela va prendre un certain temps, donc vous devriez ajouter l'argument "-j2" ou "-j3" pour réaliser une construction
parallèle et accélérer les choses. Mais une fois cela fait, il suffit de taper notre ligne magique
"export PATH=/usr/local/amiga/bin:$PATH" pour que le système sache où trouver les binaires du compilateur
AmigaOS 4 (et je vous conseille aussi d'ajouter cette ligne au fichier "/home/user/.bashrc", ainsi vous n'aurez plus
à vous en soucier).
Voilà, c'est fait !
Un peu de code de test maintenant :
#include <stdio.h>
void main()
{
printf("gcc 8.2.0\n");
}
$ ppc-amigaos-gcc test.c -o test
|
A présent, on va passer à quelque chose d'un peu plus compliqué, c'est-à-dire C++11 et le traitement en fils d'exécution
via l'implémentation native de Sebastian Bauer :
#include <iostream>
#include <thread>
//Cette fonction sera appelée depuis un fil d'exécution
void call_from_thread() {
std::cout << "only 1200, only hardcore" << std::endl;
}
int main() {
//Lancement d'un fil d'exécution
std::thread t1(call_from_thread);
//Joint le fil d'exécution avec le fil d'exécution principal
t1.join();
return 0;
}
$ ppc-amigaos-g++ -athread=native test2.c -o test2
|
Épilogue
Voilà, c'est tout, j'espère que ce tutoriel aidera quelqu'un. Si l'un de nos actuels développeurs
(ou même un nouveau ?) le trouve utile, cela voudra dire que j'ai écrit cela pour quelque chose. :)
|
