Artikel für fortgeschrittene Anwender
Dieser Artikel erfordert mehr Erfahrung im Umgang mitLinux und ist daher nur für fortgeschrittene Benutzergedacht.
Archivierte Anleitung
Dieser Artikel wurde archiviert. Das bedeutet, dass er nicht mehr auf Richtigkeit überprüft oder anderweitig gepflegt wird. Der Inhalt wurde für keine aktuell unterstützte Ubuntu-Version getestet. Wenn du Gründe für eine Wiederherstellung siehst, melde dich bitte in der Diskussion zum Artikel. Bis dahin bleibt die Seite für weitere Änderungen gesperrt.
Zum Verständnis dieses Artikels sind folgende Seiten hilfreich:
⚓︎ Installation von Programmen
⚓︎ Ein Terminal öffnen
⚓︎ Einen Editor öffnen
⚓︎ Archive entpacken
⚓︎ Ein Programm starten
⚓︎ Pakete aus dem Quellcode erstellen
⚓︎ Ein einzelnes Paket installieren
Inhaltsverzeichnis
- Methode 1 - Manuelle Installation
- Vorbereitungen
- Binutils
- GCC - Teil 1
- Newlib
- GCC - Teil 2
- GDB und Insight
- Methode 2 - Installation per Skript
- Vorbereitungen
- Kompilieren
- Feinarbeiten
- Methode 3 - Installation per PPA
- Bekannte Probleme
- x86_64 Host-Architektur und Insight
- ARM-Simulator als Target
- Methode 4 - Nachbau der Yagarto-Toolchain
- Links
Die GNU ARM-Toolchain ist eine Sammlung von Cross-Compilern und Debuggern zum Übersetzen von Programmen für ARM-basierte Mikrocontroller. Sie wird gewöhnlich unter Zuhilfenahme der Cygwin-Umgebung 🇬🇧 auf Windows-Systemen verwendet, wofür es beispielsweise bei GNUarm.com 🇬🇧 eine fertig konfigurierte Installationsroutine gibt. Da alle verwendeten Werkzeuge jedoch aus der Unix/Linux-Welt stammen, können diese ebenso gut unter Ubuntu und anderen Linux-Distributionen verwendet werden. Hierfür ist leider etwas mehr Zeit und Aufwand erforderlich.
Methode 1 - Manuelle Installation¶
Der Erfolg der Installation hängt unter Umständen essentiell von den einzelnen Versionen ab. Diese Anleitung wurde mit den folgenden Versionen getestet: GCC 4.3.2, Binutils 2.19, Newlib 1.16, GDB 6.8, Insight 6.8. Für andere Programm-Versionen ist die Vorgehensweise im Prinzip die gleiche, es kann aber zu Fehlern kommen.
Vorbereitungen¶
Zum Kompilieren der Toolchain müssen die üblichen Pakete mit Compilern, Entwicklungswerkzeugen sowie die Quelltexte einiger Bibliotheken installiert [1] werden.
build-essential
libgmp3-dev
libmpfr-dev
libx11-6
libx11-dev
texinfo
flex
bison
libmpc-dev
libncurses5
libncurses5-dbg
libncurses5-dev
libncursesw5
libncursesw5-dbg
libncursesw5-dev
zlibc
Befehl zum Installieren der Pakete:
sudo apt-get install build-essential libgmp3-dev libmpfr-dev libx11-6 libx11-dev texinfo flex bison libmpc-dev libncurses5 libncurses5-dbg libncurses5-dev libncursesw5 libncursesw5-dbg libncursesw5-dev zlibc
Oder mit apturl installieren, Link: apt://build-essential,libgmp3-dev,libmpfr-dev,libx11-6,libx11-dev,texinfo,flex,bison,libmpc-dev,libncurses5,libncurses5-dbg,libncurses5-dev,libncursesw5,libncursesw5-dbg,libncursesw5-dev,zlibc
Für Ubuntu 8.04 muss möglicherweise das Paket libncurses4 noch installiert werden. Im Test war es installiert, die Funktion ohne dieses Paket wurde nicht getestet. Ab Ubuntu 8.10 gibt es das Paket nicht mehr.
libncurses4
Befehl zum Installieren der Pakete:
sudo apt-get install libncurses4
Oder mit apturl installieren, Link: apt://libncurses4
Die Toolchain besteht aus dem Compiler GCC 🇬🇧, den GNU Binutils 🇬🇧, der Standardbibliothek Newlib 🇬🇧 sowie dem Debugger GDB 🇬🇧 und dessen grafischer Oberfläche Insight 🇬🇧. Alle Werkzeuge sind als Quelltext-Pakete verfügbar und können von den angegebenen Seiten oder von der GNUARM-Homepage 🇬🇧 heruntergeladen werden. Die vorliegende Anleitung bezieht sich auf die Original-Pakete von den entsprechenden Projektseiten.
Nach dem Herunterladen der Archive diese entpacken [4]:
tar -xvf gcc-4.3.2.tar.bz2tar -xvf binutils-2.19.tar.bz2tar -xvf newlib-1.16.0.tar.gz tar -xvf gdb-6.8.tar.bz2tar -xvf insight-6.8.tar.bz2
Anschließend Scratch-Verzeichnisse für den Build anlegen:
mkdir build-gcc build-binutils build-newlib build-gdb build-insight
Hinweis:
Die Installation der Toolchain erfolgt in das Verzeichnis /opt/gnuarm/. Sofern die Toolchain an anderer Stelle abgelegt werden soll, muss dieses Verzeichnis in allen folgenden Schritten entsprechend abgeändert werden.
Binutils¶
Zuerst werden die Binutils kompiliert. Um die Binutils compilieren zu können, sollte man die Binutils werden mit der Option --disable-werror konfiguriert. Diese Option verhindert, dass bestimmte Compiler-Warnungen als Fehler behandelt werden.
Verhindern, dass Warnungen als Fehler behandelt werden¶
Binutils compilieren mit folgenden Befehlen:
cd build-binutils../binutils-2.19/configure --target=arm-elf --prefix=/opt/gnuarm --enable-interwork --enable-multilib --enable-target-optspace --with-float=soft --disable-werrormake all
Weiter für beide Alternativen:
Hinweis:
Möglicherweise bricht der Befehl make all mit einer Fehlermeldung ab, die besagt, dass das Kommando "makeinfo" nicht gefunden wurde. In diesem Fall muss die Datei Makefile von Hand editiert werden und die Zeile MAKEINFO = /irgend/ein/pfad/missing makeinfo durch ein simples MAKEINFO = makeinfo ersetzt werden. Hierfür muss aber manuell sichergestellt werden, dass das Programm makeinfo - enthalten im Paket '''texinfo''' - auch installiert ist!|}}
Nun können die fertigen Binaries installiert werden. Dies muss mit Root-Rechten erfolgen:
sudo make install
Wenn die Binutils installiert wurden, müssen sämtliche Dateien im Verzeichnis /opt/gnuarm/bin nach /usr/local/bin verlinkt werden. Alternativ können Experten auch das Verzeichnis /opt/gnuarm/bin zu ihrer PATH-Variablen hinzufügen.
sudo ln -s /opt/gnuarm/bin/* /usr/local/bin
GCC - Teil 1¶
Das Bauen des GCC-Cross-Compilers erfordert etwas mehr Aufwand. Zunächst wird ein einfacher Compiler ohne Standardbibliotheken erstellt. Mit diesem wird anschließend Newlib übersetzt. Erst dann kann GCC vollständig installiert werden.
Wichtig: Um später auch Projekte mit gemischtem Thumb-Code und ARM-Code übersetzen zu können ("Thumb-Interworking"), muss der GCC-Quellcode gepatcht werden - vgl. Menüpunkt Support auf gnuarm.com 🇬🇧. Hierfür die Datei t-arm-elf ⮷ von gnuarm.com 🇬🇧 herunterladen und die vorhandene Datei im Quelltext-Verzeichnis gcc-4.3.2/gcc/config/arm/ mit der neu heruntergeladenen ersetzen. Dies funktionierte im Test für GCC 4.2.0 und GCC 4.3.2 problemlos, für andere Versionen muss besagte Datei gegebenenfalls manuell angepasst werden. Wer sichergehen will, sollte die Inhalte evtl. kurz von Hand abgleichen.
Zunächst also eine GCC-Version ohne Standardbibliotheken erstellen:
cd ../build-gcc../gcc-4.3.2/configure --target=arm-elf --prefix=/opt/gnuarm --enable-interwork --enable-multilib --enable-languages="c,c++" --enable-target-optspace --with-float=soft --with-newlib --with-headers=../newlib-1.16.0/newlib/libc/include/ --disable-nls sudo make all-gcc install-gcc
Hinweis:
Bei GCC kann es unter Umständen in Verbindung mit Newlib zu einer Fehlermeldung configure: error: Link tests are not allowed after GCC_NO_EXECUTABLES beim Konfigurieren der zlib kommen. Dagegen helfen unter Umständen die Optionen --with-system-zlib und --disable-shared bei configure. Getestet mit GCC 4.5.1.
Möglicherweise tritt auch hier der Makeinfo-Bug auf - vgl. Hinweis im Abschnitt Binutils.
Hinweis:
Eine Anmerkungen hierzu: Wer lieber deutschsprachige GCC-Fehlermeldungen mag, kann die Option --disable-nls auch weglassen. Sollte man allerdings die Entwicklungsumgebung Eclipse verwenden wollen, muss GCC englischsprachige Fehlermeldungen erzeugen. Ansonsten kommt der Parser von Eclipse nicht mehr mit der Ausgabe von GCC klar.
Zum Schluss wieder, wie bereits im Abschnitt Binutils beschrieben, die neu hinzugekommenen Dateien im Verzeichnis /opt/gnuarm/bin nach /usr/local/bin verlinken, sofern man das Verzeichnis /opt/gnuarm/bin nicht bereits der PATH-Variablen hinzugefügt hat:
sudo ln -s /opt/gnuarm/bin/* /usr/local/bin
Newlib¶
Mit dem neuen GCC-Cross-Compiler aus dem vorigen Abschnitt kann nun Newlib übersetzt werden. Zunächst mit dem üblichen Spiel:
cd ../build-newlib../newlib-1.16.0/configure --target=arm-elf --prefix=/opt/gnuarm --enable-interwork --enable-multilib --enable-target-optspace --with-float=soft
'Sofern die Reentrancy-Unterstützung von Newlib benötigt wird, muss nun die Datei Makefile im Scratch-Verzeichnis manuell editiert und der Option CFLAGS_FOR_TARGET im Abschnitt all: die Option -DREENTRANT_SYSCALLS_PROVIDED hinzugefügt werden. Die gesamte Zeile sollte nun ungefähr so aussehen:
12 | # Build libraries optimizing for space, not speed CFLAGS_FOR_TARGET = -g -Os -DREENTRANT_SYSCALLS_PROVIDED |
Zum Thema Reentrancy vgl. diesen Artikel von Bill Gatliff 🇬🇧.
Weiter dann auf die übliche Weise:
make allsudo make install
Auch hier kann theoretisch der Makeinfo-Bug auftreten (vgl. Hinweis im Abschnitt Binutils).
GCC - Teil 2¶
Wenn Newlib fertig installiert ist, kann der GCC-Cross-Compiler fertiggestellt werden:
cd ../build-gccsudo make all install
GDB und Insight¶
Es fehlen noch GDB und Insight. Eigentlich keine große Sache mehr. Wenn allgemein ein Fehler à la "cc1: warnings being treated as errors" auftreten, ist beim Konfigurieren die Option --disable-werror notwendig.
cd ../build-gdb../gdb-6.8/configure --target=arm-elf --prefix=/opt/gnuarm --enable-interwork --enable-multilib --enable-target-optspace --disable-werrormake allsudo make install
Zum Schluss noch Insight:
cd ../build-insight../insight-6.8/configure --target=arm-elf --prefix=/opt/gnuarm --enable-interwork --enable-multilib --enable-target-optspace --disable-werrormake allsudo make install
Auf den Makeinfo-Bug wurde bereits mehrfach hingewiesen (vgl. Hinweis im Abschnitt Binutils).
Zum Schluss nicht vergessen, wieder die neu hinzugekommenen Binaries zu verlinken:
sudo ln -s /opt/gnuarm/bin/* /usr/local/bin
Hinweis:
Möglicherweise müssen für Insight noch bestimmte Tcl/Tk-Pakete nachinstalliert werden. Für Insight ist das nicht getestet worden, weil es aber zur offiziellen Toolchain gehört, ist es der Vollständigkeit halber hier mit aufgelistet.
Methode 2 - Installation per Skript¶
Waipot Ngamsaad hat im Forum von mcuprogramming.com 🇬🇧, einem Blog über Microcontroller, ein Shell-Skript veröffentlicht 🇬🇧, dass die Erstellung der GNU ARM-Toolchain weitestgehend automatisiert. Das Skript wurde mittlerweile unter der GPL v3 lizenziert und ist bei Google Code frei verfügbar 🇬🇧.
Hinweis:
Wer Reentrancy-Unterstützung oder Thumb-Interworking benötigt, der sollte die manuelle Methode bevorzugen, da Änderungen am Quellcode gemacht werden müssen.
Vorbereitungen¶
Download des Skriptes¶
Um das Skript aus dem SVN-Repository von Google Code herunterzuladen, muss man zunächst Subversion installieren [1]:
subversion
Befehl zum Installieren der Pakete:
sudo apt-get install subversion
Oder mit apturl installieren, Link: apt://subversion
Das Auschecken aus dem Repository erfolgt nun über folgenden Terminal-Befehl [2]:
svn checkout http://hobbycode.googlecode.com/svn/trunk/gnu-arm-installer gnu-arm-installer
Download der GNU ARM Quellen¶
Die aktuell vom Skript für den Bau der Toolchain verwendeten Quellen findet man inkl. Download-Links in der ReadMe.txt 🇬🇧 des Skript-Paketes. Diese muss man in das Verzeichnis src abspeichern, nicht aber entpacken.
Alternativ kann man auch, falls bei gnuarm.com 🇬🇧 verfügbar, eine neuere Toolchain ausprobieren. Dabei muss man allerdings die Variablen GCC_SRC, GCC_VERSION, BINUTILS_SRC=, BINUTILS_VERSION, NEWLIB_SRC, NEWLIB_VERSION, INSIGHT_SRC und INSIGHT_VERSION in der Datei gnu-arm-installer.sh entsprechend anpassen [3].
Installation der Abhängigkeiten¶
Bevor man mit dem Kompilieren beginnen kann, müssen die oben angegebenen nötigen Abhängigkeiten installiert [1] werden.
Kompilieren¶
Das Kompilieren der Toolchain ist nun keine große Kunst mehr, nimmt aber je nach Rechnerleistung ein bis zwei Stunden Zeit in Anspruch. Durch folgenden Terminal-Befehl [2] wird der Prozess angestoßen:
sh gnu-arm-installer.sh
Hinweis:
Während des Kompilierens sollte man es vermeiden, die PATH-Variable zu ändern, da das Skript diese, während es seine Aufgabe erledigt, temporär verändert.
Die fertige Toolchain befindet sich dann im Verzeichnis install.
Feinarbeiten¶
Toolchain verschieben¶
Wem eine Toolchain im Heimat-Verzeichnis zuwider ist, der kann die erstellte Toolchain z.B. nach /opt verschieben. Dazu öffnet man ein Terminal [2] und wendet folgenden Befehl im Verzeichnis des Skriptes an:
sudo cp -R install /opt/gnuarm
PATH-Variable anpassen¶
Damit man von jedem beliebigen Verzeichnis auf die Toolchain zugreifen kann, muss die PATH-Variable entsprechend angepasst werden. Temporär geschieht das durch den im Terminal [2] ausgeführten Befehl:
export PATH=$PATH:/opt/gnuarm/bin/
Dabei muss es sich immer um einen absoluten Pfad zu den Toolchain-Binärdateien handeln. Relative Pfadangaben würden nicht akzeptiert.
Damit die Änderung der PATH-Variable auch nach einem Neustart durchgeführt wird, fügt man den obigen Befehl mit Hilfe eines Editors [3] in die Datei ~/.bashrc ein.
Methode 3 - Installation per PPA¶
Hinweis:
Das PPA installiert arm-none-eabi-gcc, nicht arm-elf-gcc wie im Rest des Tutorials. Das Target arm-elf wird ab GCC 4.8 nicht mehr unterstützt.In der Bedienung unterscheiden sich arm-none-eabi-gcc und arm-elf-gcc nicht.
Auf Launchpad pflegen ARM-Mitarbeiter ein PPA, dass regelmäßig aktualisiert wird.
Zur Installation wird erst das Repository zum System hinzugefügt:
sudo add-apt-repository ppa:terry.guo/gcc-arm-embeddedsudo apt-get update
Anschließend kann die Toolchain installiert werden:
sudo apt-get install gcc-arm-none-eabi
Bekannte Probleme¶
x86_64 Host-Architektur und Insight¶
Insight lässt sich unter einem x86_64 Ubuntu zwar für arm-elf erfolgreich kompilieren, funktioniert allerdings nur kaum bis gar nicht. Die Ursache des Problems ist bisher nicht bekannt. Der eigentliche Debugger gdb funktioniert dagegen. Anwender haben berichtet, dass eine für ein x86-Host-System kompilierte Toolchain auch unter einem x86_64-Host-System funktioniert. Zum Erstellen einer solchen Toolchain kann man sich einer virtuellen 32-Bit-Umgebung, wie z.B. VirtualBox, bedienen.
ARM-Simulator als Target¶
Berichten 🇩🇪 zufolge kann es beim Debuggen mit Insight zu einer Fehlermeldung kommen, die man nicht vollends lesen kann, wenn man als Target "Simulator" ausgewählt hat. Abhilfe schafft das Abwählen von "Download Program" in den Target-Einstellungen. Ebenso sollte man dort bei "Command to issue after attaching:" den Befehl load eintragen.
Eine der verbreiteten Toolchains aus der Windows-Welt ist diejenige von Yagarto 🇬🇧. Wenn ein Projekt sowohl auf Linux als auch auf Windows-Systemen übersetzt werden soll, bietet es sich an, diese Toolchain für Ubuntu nachzubauen, um eine Toolchain zu haben, die auf beiden Systemen weitestgehend identisch ist.
Aus den entsprechenden Build-Skripten und Patches 🇬🇧 lassen sich leicht die dazu notwendigen Schritte extrahieren.
Wenn es beim Bauen der Toolchain zu Compiler-Fehlern kommt, sind möglicherweise für die Konfiguration zusätzliche Optionen notwendig oder es müssen Bibliotheken nachinstalliert werden. So musste im Test auf Precise beispielsweise GCC 4.7.2 mit der Option --with-system-zlib konfiguriert werden. Für Binutils und Newlib waren keine Änderungen gegenüber den Build-Skripten notwendig.
Links¶
gnuarm.com 🇬🇧 - ARM-Toolchain für Windows mit Hinweisen zum selbst Compilieren
alphapogo.de 🇩🇪 - ein weiteres etwas älteres Tutorial auf Deutsch
Yagarto 🇬🇧 - verbreitetes "Yet another GNU ARM" Toolchain
GNUArm Toolchain unter Ubuntu 8.10 🇩🇪 - Deutsches Tutorial zur Skript-Methode
Diese Revision wurde am 6. September 2015 12:45 von aasche erstellt.
Die folgenden Schlagworte wurden dem Artikel zugewiesen: Programmierung
