ARM Cross-Compiler

Aus Lowlevel
Wechseln zu: Navigation, Suche


Löschhinweis:

Dieser Artikel wurde zum Löschen vorgeschlagen.

Bereits im Artikel Cross-Compiler vorhanden --Mtgxyz - Diskussion 17:53, 29. Jan. 2016 (CET)

Wer ein Betriebssystem (oder generell Applikationen) für auf ARM-Prozessoren basierenden Architekturen erstellen will, aber selber nicht auf einer solchen entwickelt, muss sich einen Cross-Compiler erstellen bzw. verwenden. In diesem Artikel wird erklärt, wie ein Cross-Compiler unter Linux für die ARM-Architektur erstellt wird.


Vorbereitungen

Die Erstellung eines Cross-Compilers für ARM-Architekturen erfolgt anfangs analog zu der Erstellung eines Cross-Compilers für x86-64 Prozessoren: Es müssen die binutils und der gcc in ihrer jeweils aktuellen Version (Stand: 06. August 2012) heruntergeladen werden. Sollen mehr Sprachen als C unterstützt werden, so müssen die entsprechenden Pakete unter [1] heruntergeladen werden.

HINWEIS ab gcc-4.7 hat sich das Target geändert, es heißt nun nicht mehr

arm-unknown-linux-gnu

sondern

arm-unknown-linux-gnueabi

Siehe dazu auch [2].

Es werden nun ein paar Variablen erstellt:

$ export PREFIX=/usr/cross/arm
$ export TARGET=arm-unknown-linux-gnueabi

Der Pfad unter PREFIX kann geändert werden, wenn die Cross-Tools an anderer Stelle kompiliert werden sollen.

binutils bauen

Sofern nicht schon geschehen, sollte man jetzt das binutils-Paket entpacken, in diesem Beispiel werden die binutils nach /usr/src/cross-arm-binutils entpackt. Nun sollte ein separates Verzeichnis erstellt werden, in welchem die binutils gebaut werden, in unserem Beispiel ist das /usr/src/binutils-arm. Nun wechselt man in eben dieses Verzeichnis und ruft configure wie folgt auf:

$ ../cross-arm-binutils/configure --target=$TARGET --prefix=$PREFIX

Nach erfolgreichem configure können die binutils nun gebaut werden mittels:

$ make -j4 all
$ make install

Hinweis: Da wir schon 2012 haben und die Mehrheit aller PCs mindestens einen Dualcore-Prozessor verbaut hat, kann man den Buildvorgang beschleunigen, indem man die Option -jX make übergibt, wobei X für die Anzahl von Threads pro Core steht, bei einem Dualcore-Prozessor also pro Core zwei Threads.

gcc bauen

Nun geht's an den gcc: Hier gilt auch wieder, sofern nicht schon geschehen, den gcc zu entpacken, in diesem Beispiel nach /usr/src/cross-arm-gcc. Nun sollte, genau wie bei den binutils, ein separates Verzeichnis erstellt werden, in welchem der gcc gebaut wird, in unserem Beispiel ist das /usr/src/gcc-arm. Nun wechselt man in eben dieses Verzeichnis und setzt erst den neuen Pfad zu den ARM-binutils:

$ export PATH=$PATH:$PREFIX/bin

Dann ruft man configure wie folgt auf:

$ ../cross-arm-gcc/gcc-4.7.1/configure --target=$TARGET 
              --prefix=$PREFIX --enable-languages=c --without-headers

Nach erfolgreichem configure kann der gcc mittels

$ make -j4 all-gcc
$ make install-gcc

gebaut und installiert werden.

LibGCC bauen

Für bestimmte Operationen, z.B. Stack Unwinding, Ganzzahl- und Fließkommaarithmetik und andere Unterstützungsfunktionen benötigt man zusätzlich die LibGCC. Diese kann man zusätzlich erstellen:

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

Fehler beim configure

Eventuell kann es sein, dass configure mit der Fehlermeldung abbricht, dass die Libraries GMP und/oder MPFR sowie MCP nicht installiert seien. Diese müssen dann per Paketverwaltung oder von Hand installiert werden. Hier kann GMP und hier MPFR und hier MCP heruntergeladen werden, falls selbige nicht über die Paketverwaltung der Distribution erhältlich sind. Gebaut werden beide mit dem in Linux bekannten Dreisatz ./configure, make, make install.

Fertig!

Wenn alles geklappt hat, wurde nun ein Cross-Compiler für ARM-Architekturen erstellt. Die Tools befinden sich (im Beispiel dieses Artikels) unter /usr/cross/arm.


Siehe auch

Weblinks