Cross compiling/de

Vorwort

Dies ist eine kurze Einführung für Neulinge. Die folgenden Abschnitte beschreiben, wie man ein System für cross compile einrichtet, das bedeutet, arbeiten unter Linux und erzeugen von Win32 executables (oder freebsd oder darwin, oder ...). FreePascal ist ein Compiler und konvertiert hauptsächlich Quellcode in binaries (Maschinensprache). Diese binaries enthalten auch Informationen darüber, wie das Betriebssystem das executable startet. Daher sind diese binaries Plattform-spezifisch. FreePascal selbst benötigt nicht viel Installation. Es kann binaries für viele Plattformen erzeugen. Der Compiler muss nur dazu angewiesen werden. Aber der Compiler ist nur ein Teil. Es gibt auch noch den Assembler und den Linker. Und diese Werkzeuge sind nicht in der Lage, cross code zu erzeugen. Daher müssen wir spezielle Linker 'ld' und Assembler 'as' für jede Zielplattform erzeugen. Dies sind die binutils. Nach Erstellung der cross tools, werden alle FPC Pascal Units cross compiled. Zum Beispiel, dann gibt es eine system.ppu Datei für jede Zielplattform. Dann wird ihre FPC Konfigurationsdatei eingerichtet, so dass cross compilation so einfach wird, dass sie alle langweiligen Details vergessen können. Das selbe wird für die LCL getan - die Lazarus Component Library. Und danach können sie Pascal Programme für Win32 cross kompilieren. Entweder starten sie sie mit Wine oder sie kopieren sie auf einen Windows Computer und testen sie dort.

Grundsätzliche Schritte

Es gibt einige übliche Schritte, die beteiligt sind in crosscompiling, die sie in jedem Fall tun müssen:

1. Bereits einen FreePascal Compiler haben für die Plattform, von der sie kompilieren wollen.
2. Sie müssen den FreePascal Quellcode haben.
3. You need to either build from source or obtain binaries of the cross-binutils that run on the platform you are on and are designed to build programs for your desired target platform.
4. Manchmal werden sie einige Dateien von der Zielplattform benötigen, zu der sie kompilieren.

Von Linux

Zu Linux

Zur Klarstellung: Dies ist für die Kompilierung von Linux(x86_64) zu Linux(i386).

Chances are that your 64 bit linux distrubution is already capable of compiling 32 bit programs but due to the way the fpc build process is designed there are a couple of things you might have to do.

• Zuerst prüfen Sie, ob Sie bereits die Dateien i386-linux-ld und i386-linux-as haben:

 bash $ which i386-linux-ld

 bash $ which i386-linux-as

Wenn sie diese Dateien haben springen sie zum "Kompilieren" Abschnitt.

Ich hatte diese Dateien nicht und so erstellte ich ein paar Skripte:

#!/bin/bash
# name this file /usr/bin/i386-linux-ld
ld -A elf32-i386 $@

#!/bin/bash
# name this file /usr/bin/i386-linux-as
as --32 $@

• Machen sie sie ausführbar:

bash $ chmod +x /usr/bin/i386-linux-as
bash $ chmod +x /usr/bin/i386-linux-ld

• Kompilieren sie FPC:

bash $ cd /usr/share/fpcsrc/<version>
bash $ make all CPU_TARGET=i386

dann:

bash $ su -c "make install CPU_TARGET=i386"

Das ist alles. Bearbeiten sie ihre /etc/fpc.cfg Datei falls erforderlich.

Zu Windows

Cross compiling for Windows under Linux

Wenn sie Version 2.1.1 oder höher des FPC Compilers verwenden können sie einfach tippen:

bash $ make all OS_TARGET=win32 CPU_TARGET=i386

und dann

bash $ su -c "make crossinstall OS_TARGET=win32 CPU_TARGET=i386"

Anmerkung: Um für Win64 zu erstellen lautet das make Kommando: make all OS_TARGET=win64 CPU_TARGET=x86_64

Der Grund für diese Einfachheit ist der in dieser Version von FPC enthaltene interne Linker.

Ein gutes Tutorial zum Thema ist im deutschen Lazarusforum zu finden.

Zu Darwin oder macOS

Vorbemerkung: der Autor des Orignaltexts warnt, einige Dinge vielleicht nicht ganz originalgetreu wiedergegeben zu haben, da er seine Erfahrungen erst zu späterem Zeitpunkt protokolliert hat. Bitte ergänzen/korrigieren Sie also diese Anleitung (möglichst auch den Originaltext) bei Bedarf!

• Zuallererst benötigen Sie die binutils für die Plattform, für die Sie kompilieren wollen: laden Sie die odcctools herunter (benutzen Sie die CVS Version!) und folgen Sie deren Installationsanleitung.
• Sie müssen sich ein "Fake-root"-Verzeichnis wie: $HOME/darwinroot anlegen und zumindest die Verzeichnisse /System, /Frameworks und /usr von Ihrem Apple- oder Darwin-Rechner dorthin kopieren (möglicherweise noch weitere?) .
• Danach erstellen Sie einen weiteren Ordner $HOME/darwinroot/cross und legen darin praktischerweise symbolische Verküpfungen (symlinks) auf die odcctools an. Symlinks müssen Sie ferner für powerpc-apple-darwin-* der odcc tools anlegen (oder umbenennen). So wird beispielsweise "powerpc-apple-darwin-ld" zu "powerpc-darwin-ld"; nach demselben Schema bearbeiten Sie *-ar und *-as.
• Jetzt ist alles bereit zum Crosscompilieren von fpc! Sie brauchen dazu die FPC Quelldateien sowie ein in deren Verzeichnis geöffnetes Terminal. Darin tippen Sie (sofern Ihre Symlinks in $HOME/darwinroot/cross liegen):

$PATH=$PATH:$HOME/darwinroot/cross

Tippen Sie (unter Vorbehalt, siehe Vorbemerkung):

make all TARGET_OS=darwin TARGET_CPU=powerpc OPT="-Xd -Fl/$HOME/darwinroot/usr/lib"

wenn das Übersetzen damit erfolgreich war ist, installieren Sie es mit:

make install TARGET_OS=darwin TARGET_CPU=powerpc PREFIX=/cross/fpc

Zuletzt kopieren oder verlinken Sie die Datei ./compiler/ppccross irgendwohin, wo Sie sie leicht wieder aufrufen können, denn es ist Ihr neuer Compiler zum Übersetzen von PowerPC-Binaries.

• Konfigurieren Sie Ihre /etc/fpc.cfg, indem Sie einen Abschnitt wie diesen hinzufügen:

#IFDEF powerpc
-Fu/cross/fpc/lib/fpc/$fpcversion/units/$fpctarget/
-Fu/cross/fpc/lib/fpc/$fpcversion/units/$fpctarget/rtl
-Fu/cross/fpc/lib/fpc/$fpcversion/units/$fpctarget/*
-k-systemroot $HOME/darwin/cross
#ENDIF

Weil Sie bei jeder Crosskompilierung sowohl ppccross als auch die oben beschriebenen Symlinks auf powerpc-darwin-* brauchen, sollten diese in Ihrem Suchpfad (PATH) zu finden sein. Dann genügt ein einfaches

ppccross someprogie.pas

und Sie erhalten das Binary für den PowerPC!

Von Windows

Zu Linux

Marco vd Voort schrieb einige crossnotes. Wenn jemand Zeit hat, dann kann er sie diesem Wiki hinzufügen.

Free Pascal 3.x

Mit fpc 3.x funktioniert die nachfolgend beschriebene Vorgehensweise. Es werden aktuelle binutils und die Quellen von Free Pascal benötigt. Lade also folgende Files herunter:

• Aktuelle binutils. Du brauchst binutils-xxx-mingw32-src.tar.xz.
• Script zum Compilieren der binutils
• fpc sources (fpc-x.x.x.source.zip)

Binutils erstellen, am Beispiel von Fedora 20 x86_64:

• Lade das oben genannte mkbinutils Script nach /root und mache es ausführbar.
• Ändere folgende Variable:
  • VER="2.25.1" (an die jeweilige Version der binutils anpassen)
  • CC="i686-w64-wingw32-gcc"
  • TARGETS="i386-linux x86_64-linux"
• Entpacke die gedownloadeden binutils ebenfalls nach /root
• Stelle sicher, dass folgende Pakete installiert sind (yum install ...):
  • glibc.i686, glibc.x86_64
  • glibc-devel.i686, glibc-devel.x86_64
  • gcc.x86_64
  • mingw32-binutils.x86_64
  • mingw32-gcc.x86_64
  • mingw32-gmp
  • mingw32-mpfr
• Erstelle diesen Symlink: /usr/bin/i386-pc-mingw32-ar -> /usr/bin/i686-w64-mingw32-ar
• Compiliere binutils: ./mkbinutils
• Die erstellten Crosscompiler liegen am Ende in /tmp/binutils.

Unter Windows lassen sich nun mit fpc die Quellen compilieren:

• fpc liege unter c:\fpc\x.x.x
• Kopiere die heruntergeladenen Sources nach c:\fpc\x.x.x\source
• Aus den erstellten binutils, kopiere folgende Tools nach c:\fpc\x.x.x\bin\i386-win32:
  • x86_64-linux-ar.exe
  • x86_64-linux-as.exe
  • x86_64-linux-ld.exe
  • x86_64-linux-nm.exe
  • x86_64-linux-objcopy.exe
  • x86_64-linux-objdump.exe
  • x86_64-linux-strip.exe
  • i386-linux-ar.exe
  • i386-linux-as.exe
  • i386-linux-ld.exe
  • i386-linux-nm.exe
  • i386-linux-objcopy.exe
  • i386-linux-objdump.exe
  • i386-linux-strip.exe
• Erstelle c:\fpc\x.x.x\lib\i386-linux und c:\fpc\x.x.x\lib\x86_64-linux und kopiere aus der Fedora-Installation folgende Dateien:
  • crtbegin.o
  • crtbeginS.o
  • crtbeginT.o
  • crtend.o
  • crtendS.o
  • crti.o
  • crtn.o
  • ld-linux.so.2 bzw. ld-linux-x86-64.so.2
  • libc.so.6 (und nochmals als libc.so)
  • libdl.so
  • libgcc.a
  • libpthread.so
• Manche liegen unter Linux nur als Verweis auf eine konkrete Version; dann sollte die referenzierte Version kopiert und entsprechend umbenannt werden. In der x86_64-Variante wird ld-linux-x86-64.so.2 zusätzlich als ld-linux.so.2 benötigt.
• In einer cmd, wechsle nach c:\fpc\x.x.x\source und führe folgende Befehle aus:
  • PATH=c:\fpc\x.x.x\bin\i386-win32;%PATH%
  • make clean
  • make OS_TARGET=linux CPU_TARGET=x86_64 LIBDIR=c:\fpc\x.x.x\lib all
  • make OS_TARGET=linux CPU_TARGET=x86_64 install INSTALL_PREFIX=c:\fpc\x.x.x OPT="-XPx86_64-linux- "
  • make OS_TARGET=linux CPU_TARGET=i386 LIBDIR=c:\fpc\x.x.x\lib all
  • make OS_TARGET=linux CPU_TARGET=i386 install INSTALL_PREFIX=c:\fpc\x.x.x OPT="-XPi386-linux- "
• Die fürs Cross-Compilieren benötigten Files sollten sich anschliessend in c:\fpc\x.x.x\units und c:\fpc\x.x.x\fpmkinst befinden.
• Hinweis: Die aufgelisteten Bibliotheken sind für console-Anwendungen ausreichend. Für GUI-Anwendungen werden zusätzliche Bibliotheken benötigt. Die Logs während des Compilierens sollten ausreichend sein, um herauszufinden, welche das sind.

Von Darwin (macOS) i386

Von i386 zu PowerPC

• Cross binutils

Prüfen Sie zuerst, ob Sie bereits die Dateien powerpc-darwin-ld und powerpc-darwin-as besitzen:

 $ which powerpc-darwin-ld
 $ which powerpc-darwin-as

Wenn ja, überspringen Sie die Erzeugung der Symlinks und fahren Sie fort mit "FPC übersetzen".

Tatsächlich können Sie die "normalen" Binutils verwenden, weil sie "universal Binaries" sind. Aus diesem Grund reichen einfache Symlinks aus:

 $ sudo ln -s /usr/bin/as /usr/bin/powerpc-darwin-as
 $ sudo ln -s /usr/bin/ld /usr/bin/powerpc-darwin-ld

Die Symlinks können auch in jedem anderen Ordner abgelegt sein, so lange sich dieser in Ihrem $PATH befindet (z. B. /sw/bin, wenn man mittels fink installiert).

• FPC übersetzen:

 $ cd fpc/compiler
 $ make cycle CPU_TARGET=powerpc

Das erzeugt den powerpc Compiler (fpc/compiler/ppcppc) und die Units der rtl.

Um powerpc Binaries zu erzeugen, braucht man keinen Cross-compiler. Powerpc fpc und ppcppc laufen mittels Rosetta problemlos auf IntelMacs.

Benötigt werden weitere Tests und Dokumentation für die parallele Installation beider Compiler und ihre Verwendung.

Fehlen Units, überprüfen Sie Ihre config Dateien $HOME/.fpc.cfg, /etc/fpc.cfg oder /sw/etc/fpc.cfg Je nachdem, wo Ihre Units abgespeichert sind, kann es sein, dass Sie folgendes ergänzen müssen:

-Fu/usr/local/lib/fpc/lib/fpc/$fpcversion/units/$fpctarget/
-Fu/usr/local/lib/fpc/lib/fpc/$fpcversion/units/$fpctarget/rtl
-Fu/usr/local/lib/fpc/lib/fpc/$fpcversion/units/$fpctarget/*

Erinnerung: Universal Binaries erzeugt man mittels lipo aus den individuellen (i386 und powerpc) Binaries.

Zu Windows, Linux und andere Plattformen

Der Paketmanager fink hat Pakete für das den 64-bit compiler fpc und Crosscompiler für Windows, Linux, FreeBSD mit mehreren CPUs.

Ein Beispiel für die Installation eines Crosscompilers ist:

$ fink install fpc-cross-i386-win32

oder

$ fink install fpc-cross-arm-linux

Programme übersetzt man dann mit diesen Kommandos:

 fpc -Pi386 -Twin32 FILENAME
 fpc -Parm -Tlinux FILENAME

Die derzeitige Liste an Crosscompiler mit fpc 3.0.4 ist:

fpc-cross-arm-gba
fpc-cross-arm-linux
fpc-cross-arm-nds
fpc-cross-arm-wince
fpc-cross-arm-armv4t-embedded
fpc-cross-arm-armv7m-embedded
fpc-cross-i386-darwin
fpc-cross-i386-freebsd
fpc-cross-i386-go32v2
fpc-cross-i386-linux
fpc-cross-i386-nativent
fpc-cross-i386-netbsd
fpc-cross-i386-solaris
fpc-cross-i386-win32
fpc-cross-i386-wince
fpc-cross-jvm-android
fpc-cross-jvm-java
fpc-cross-m68k-linux
fpc-cross-mipsel-linux
fpc-cross-powerpc-linux
fpc-cross-sparc-linux
fpc-cross-x86-64-dragonfly
fpc-cross-x86-64-freebsd
fpc-cross-x86-64-linux
fpc-cross-x86-64-win64

Für andere Plattformen (Prozessoren und Systeme) muss man den Crosscompiler selbst erstellen. Das Schema ist immer das gleiche: Als erstes braucht man die entsprechenden binutils (Siehe Binutils) . Danach kann man den Crosscompiler und die Laufzeitbibliothek (run time library) erstellen. Mehr Details, wie man das erstellt, sind aus den Fink Paketbeschreibungen der obigen Crosscompiler ersichtlich.

Cross compile FAQ

Automatisches Tool (FPCUdeluxe)

Wen das zu kompliziert ist, kann folgendes Tool nehmen:

• fpcupdeluxe (deutsch)
• fpcupdeluxe (englisch)

Es läuft auf allen gängigen Plattformen und erzeugt Cross-Compiler für die meisten gängigen Plattformen.

Warum cross compilieren?

Damit können sie ein Programm für ein anderes Betriebssystem/CPU entwickeln. Dieses kann per cross-compiling für ein anderes Betriebssystem oder eine andere CPU ohne Neustart oder Wechsel des Computers kompiliert werden.

Warum Linux zu Windows und nicht in der anderen Richtung?

Der Hauptgrund dafür ist, dass die Erzeugung von Unix binaries auf einer fremden Plattform (ein anderes Unix oder sogar Linux eingeschlossen) komplizierter ist. Statisches Linking ist bereits kompliziert, shared Linking noch um ein vielfaches schwieriger.

Sie würden die verwendeten Bibliotheken der Zielplattformen benötigen (gtk, glib,libc etc), und eine Menge zusätzlicher Konfiguration für ld. (library paths, dynlinker path, usw.)

Für statisches Linking wurde dies bereits teilweise erledigt. Es ist allerdings sehr kompliziert, da es die manuelle Nachbearbeitung der linker Dateien sowie der linker Befehlszeile erfordert. Ein tiefes Verständnis der Funktionsweise von Unix binaries ist dabei absolute Vorraussetzung.

Ich möchte mehr Informationen über die Erstellung von Freepascal. Wo kann ich diese finden?

Eine allgemeine FAQ (englischsprachig) im PDF-Format über die Erstellung und Konfiguration von FPC: http://www.stack.nl/~marcov/buildfaq.pdf.

From the Free Pascal wiki, page "Cross compiling/de", as it stood on 2021-07-19 after a change by Dbannon, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's Licensing page. If you have concerns about this material, message the admin.