Archiv/GNU ARM-Toolchain

Artikel für fortgeschrittene Anwender

Dieser Artikel erfordert mehr Erfahrung im Umgang mit Linux und ist daher nur für fortgeschrittene Benutzer gedacht.

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:

  1. Installation von Programmen

  2. Ein Terminal öffnen

  3. Einen Editor öffnen

  4. Archive entpacken

  5. Ein Programm starten

  6. Pakete aus dem Quellcode erstellen

  7. Ein einzelnes Paket installieren

Inhaltsverzeichnis
  1. Methode 1 - Manuelle Installation
    1. Vorbereitungen
    2. Binutils
    3. GCC - Teil 1
    4. Newlib
    5. GCC - Teil 2
    6. GDB und Insight
  2. Methode 2 - Installation per Skript
    1. Vorbereitungen
    2. Kompilieren
    3. Feinarbeiten
  3. Methode 3 - Installation per PPA
  4. Bekannte Probleme
    1. x86_64 Host-Architektur und Insight
    2. ARM-Simulator als Target
  5. Methode 4 - Nachbau der Yagarto-Toolchain
  6. 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.

Paketliste zum Kopieren:

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

Paketliste zum Kopieren:

sudo apt-get install libncurses4 

Oder mit apturl die Pakete 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.bz2
tar -xvf binutils-2.19.tar.bz2
tar -xvf newlib-1.16.0.tar.gz 
tar -xvf gdb-6.8.tar.bz2
tar -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-werror
make 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:

1
2
 # 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 all
sudo 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-gcc
sudo 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-werror
make all
sudo 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-werror
make all
sudo 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

Paketliste zum Kopieren:

sudo apt-get install subversion 

Oder mit apturl die Pakete 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-embedded
sudo 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.

Methode 4 - Nachbau der Yagarto-Toolchain

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.