Cross compiling/es

│ Deutsch (de) │ English (en) │ español (es) │ français (fr) │ magyar (hu) │ português (pt) │ русский (ru) │ 中文（中国大陆） (zh_CN) │ 中文（臺灣） (zh_TW) │

Introducción

Esta es una breve introducción para los nuevos en esta temática. Las siguientes secciones describen cómo configurar un sistema para realizar compilación cruzada ( - e.g. trabajar bajo linux y generar ejecutables Win32 desde el mismo (o esto mismo para FreeBSD o Darwin, etc.). En este caso la plataforma usada para la compilación a menudo se refiere como "host" o anfitrión (Linux en el ejemplo anterior), mientras que la plataforma para la que queremos crear los binaros ejecutables es el "target" u objetivo. FreePascal es un compilador y básicamente convierte el código fuente en binario (lenguaje máquina). Estos binarios además contienen información sobre cómo los inicia el sistema operativo. Además, los binarios referencian a las APIs aportadas por un sistema operativo en particular, siendo esta la razón por la que es necesaria una implementación diferente de la Run Time Library (RTL) para cada sistema operativo. Por tanto, tales binarios son específicos de cada plataforma. FreePascal por sí mismo no necesita demasiados ajustes. Puede crear binarios para muchas plataformas. Simplemente indíqueselo.

"Host" y "Target" en la misma CPU

FPC se ha diseñado de manera que el compilador distribuido pueda generar código de máquina para determinada CPU (debido a que diferentes CPUs necesitan diferentes códigos de máquina) y sepa de los requerimientos específicos para todas las plataformas soportadas (Sistemas Operativos) disponibles en una CPU en particular. Esto significa que se puede realizar compilación cruzada (cross-compilation) con un mismo compilador usado para compilación nativa siempre que te mantengas en la misma CPU.

"Host" y "Target" en diferentes CPUs

Si se necesita crear binarios para una CPU diferente entonces necesitará un compilador "cruzado" especial, p.e. un compilador ejecutándose en la plataforma host, pero que sea capaz de crear código de máquina para una CPU distinta (en el caso de FPC, tal compilador-cruzado debería ser nuevamente capaz de establecer como objetivo final _target_ todas las plataformas disponibles en la CPU que deseemos). Este compilador cruzado se ubica por lo general en el mismo directorio que el compilador nativo. Tal compilador cruzado podría ser compilado por usted, o puede usar uno ya construido provisto por el equipo FPC (usualmente plataformas que en su mayoría se usan en dispositivos portables tales como arm-linux o arm-wince, debido a que no se usan por lo general como plataformas host). El binario FPC puede entonces elegir el compilador correcto (tanto el compilador nativo como el compilador cruzado) para la CPU objetivo usando el parámetro -P.

Targets soportados

Revise el artículo sobre sistemas operativos soportados de Target para la lista completa.

Ensamblador y enlazador

El compilador es sólo una parte. También necesitamos el ensamblador y el enlazador. FPC provee un ensamblador interno y/o enlazador para ciertas plataformas, pero otras plataformas necesitan herramientas externas. Por lo general estas herramientas no son capaces de crear binarios para distintas plataformas. Es por lo que tenemos que utilizar un enlazador especial '-ld' y un ensamblador '-as' para cada plataforma objetivo. Estas son las utilidades binarias (binutils). VerBinutils

Unidades para objetivos (target)

Después de crear (o tener/instalar) las utilidades cruzadas, se necesita el FPC RTL y otras unidades compiladas para la plataforma objetivo escogida. Por ejemplo, cada plataforma objetivo necesita un archivo system.ppu diferente (unidad System), etc. Estas unidades pueden ser tanto compiladas utilizando tu compilador configurado para compilar conforme a la plataforma objetivo, o puede usar de forma potencial las unidades oficialmente compiladas (y distribuidas) con la misma versión de FPC (si están disponibles en formato usable bajo la plataforma host en particular).

No valdrá que no necesite un nuevo compilador cruzado para cada combinación entre CPU y sistema operativo, pero realmente necesita las Unidades FPC. Por ejemplo, en una configuración de host para Linux que compile hacia Windows y Raspberri Pi, el directorio /usr/lib/fpc/3.2.2/units puede contener los siguientes directorios:

arm-linux i386-linux i386-win32 x86_64-linux x86_64-win64

Cada directorio de estos contendrá un directorio para cada una de las unidades FPC, cada una con archivos .o y .ppu.

Configuración

Entonces hay que adaptar el archivo de configuración de FPC, de manera que la compilación cruzada resulte fácil y nos podamos olvidar de todos los aburridos detalles. Lo mismo hay que hacer para el LCL - la Librería de Componentes de Lazarus (en caso de utilizar Lazarus) - Y después de esto ya se puede realizar compilación cruzada para las (distintas)plataformas objetivo. Los binarios resultantes deben a continuación ser copiados a una máquina corriendo la plataforma objetivo, o copiarlas a un sistema virtualizado/emulado (e.g. Wine para binarios Win32 bajo Linux, etc.).

Pasos básicos

Hay unos cuantos pasos comunes relacionados con la compilación cruzada que hay que realizar en todos los casos:

• Tener un compilador de FreePascal para la plataforma desde la que se desea compilar.
• Tener el código fuente de FreePascal (excepto para el caso especial de tener todo preparado por alguien previamente).
• Necesita además construir a partir del código fuente u obtener las utilidades binarias cruzadas (cross-binutils) que corran en la plataforma actual y estén diseñadas para construir programas para la plataforma objetivo deseada.
• Algunas veces necesitarás algunos archivos objetivo para el que se está compilando.

Desde Linux

Desde Linux x64 a Linux i386

Para las ocasiones en que la distribución de Linux de 64 bits sea capaz de compilar programas de 32 bits pero debido al modo en el que el proceso de construcción de FPC fue diseñado existen unas cuantas cosas que se deben hacer.

• Primero compruebe si ya tiene los archivos i386-linux-ld y i386-linux-as:

$ which i386-linux-ld

$ which i386-linux-as

• Si ya tiene estos archivos salte a la cabecera "Compilar FPC". En caso contrario ambos se pueden crear utilizando los siguientes script:

#!/bin/bash

# Create /usr/bin/i386-linux-ld
cat >/usr/bin/i386-linux-ld << EOF
#!/bin/bash
ld -A elf32-i386 $@
EOF
chmod +x /usr/bin/i386-linux-ld

# Create /usr/bin/i386-linux-as
cat >/usr/bin/i386-linux-as << EOF
#!/bin/bash
as --32 $@
EOF
chmod +x /usr/bin/i386-linux-as

• Compilar FPC:

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

• Entonces:

sudo make crossinstall CPU_TARGET=i386

• Esto es. Edita tu fichero /etc/fpc.cfg file según necesites.

Desde Linux a ARM Linux

Puedes encontrar información sobre como hacer la configuración para un objetivo ARM Linux (e.g. Zaurus) en Setup Cross Compile For ARM.

Desde Linux hacia Windows

La información sobre compilación cruzada con Lazarus se puede encontrar en Cross compiling for Windows under Linux

Desde Linux a Darwin o Mac OS X

Warning

El software de 32 bits sólo puede compilarse hasta MacOS 10.14 (Mojave). Apple removió el soporte de 32 bits desde MacOS 10.15 (Catalina) en 2019 - ese sistema operativo y futuras versiones no compilarán o ejecutarán ningún software bajo 32 bits.

Por favor echa un vistazo a aquí.

Desde Windows

Desde Windows a Linux

Esto es menos trivial, hay algo de información en el buildfaq

ver también fpcup para descripciones sobre las binutils que funcionan y que librerías/ficheros copiar.

Tal como las Build FAQ (Preguntas Frecuentes) explican, necesitarás librerías (ficheros .so) para el sistema objetivo, e.g. desde /lib y /userTal/lib (pero pueden ser más ubicaciones). En algunos sistemas, algunos ficheros .so son actualmente scripts; verifícalos con

grep -i "ld script" *

Remueva los archivos .so y cópielos encima (o symlink) de los archivos .so.x que debería tener .so para que el enlazador los encuentre.

Desde Windows a GO32v2

Puedes encontrar información detallada en Cross-compilation from Win32 to GO32v2.

Desde Windows a WinCE

arm-wince Describe como configurar un compilador cruzado para ARM CPU
i386-wince Describe como configurar compilación para i386 CPU (sin compilación cruzada)

Nota: Los instaladores de Lazarus tienen un instalador que añade Windows a WinCE cross compilation options automatically

Desde Win32 a Win64

Si estás compilando la rama 2.1.1 o superior de FPC puedes hacer:

$ make all OS_TARGET=win64 CPU_TARGET=x86_64

y entonces:

$ make crossinstall OS_TARGET=win64 CPU_TARGET=x86_64

Desde win64 a win32

Instala el fichero lazarus-1.6.0-fpc-3.0.0-cross-i386-win32-win64.exe y a continuación configura las opciones de proyecto a:

• Target OS : Win32
• Target CPU : i386

¡ Errando al establecer la CPU (Por defecto) conduce a una plataforma win32-x86_64 incorrecta !

Desde Darwin (Mac OS X) i386

Warning

El software de 32 bits sólo puede compilarse hasta MacOS 10.14 (Mojave). Apple removió el soporte de 32 bits desde MacOS 10.15 (Catalina) en 2019 - ese sistema operativo y futuras versiones no compilarán o ejecutarán ningún software bajo 32 bits.

Desde Darwin i386 hacia powerpc

El instalador FPC oficial para Mac OS X/i386 incluye un compilador cruzado PowerPC y todas las unidades necesarias para compilar programas PowerPC (use ppcppc en vez de ppc386 para compilar sus programas). Las instrucciones abajo descritas son necesarias si quiere compilar e instalar una nueva versión desde svn.

• Compilar FPC:

$ cd fpc
$ make all CPU_TARGET=powerpc -j 2

Esto crea el compilador cruzado powerpc (fpc/compiler/ppcrosspcc) y todas las unidades. Puede instalarlos usando los siguientes comandos:

$ sudo make FPC=`pwd`/compiler/ppc386 install CPU_TARGET=powerpc CROSSINSTALL=1
$ INSTALLED_VERSION=`./compiler/ppc386 -iV`
$ sudo mv /usr/local/lib/fpc/$INSTALLED_VERSION/ppcrossppc /usr/local/lib/fpc/$INSTALLED_VERSION/ppcppc

Recordatorio: Los binarios universales se crean desde los binarios individuales (i386 y powerpc) usando lipo.

Desde Darwin i386 hacia x86_64

El instalador FPC para Mac OS X/i386 incluye un compilador x86_64 y todas las unidades necesarias para compilar programas x86_64 (use ppcx64 en vez de ppc386 para compilar sus programas o use fpc -x86_64). Las instrucciones abajo son sólo necesarias si quiere compilar e instalar una nueva versión desde el svn.

• Compilar FPC:

$ cd fpc
$ make all CPU_TARGET=x86_64

Esto crea el compilador cruzado x86_64 (fpc/compiler/ppcrossx64) y todas las unidades. Puede instalarlas usando los siguientes comandos:

$ sudo make crossinstall CPU_TARGET=x86_64
$ sudo mv /usr/local/lib/fpc/2.7.1/ppcrossx64 /usr/local/lib/fpc/2.7.1/ppcx64

Si quiere crear este compilador recientemente instalado la versión por defecto (no es recomendada, y terminará con su habilidad de construir versiones nuevas de FPC 2.7.1 sin especificar explícitamente la ruta a la versión oficial más reciente de FPC), también ejecute el siguiente comando:

$ sudo ln -sf /usr/local/lib/fpc/2.7.1/ppcx64 /usr/local/bin/ppcx64

Asumiendo que todos los componentes LCL que usa su proyecto sean soportados por | Cocoa widgetset, puede compilar un proyecto Lazarus desde la línea de comandos, usando un comando como este (ruta completa al compilador se ve necesaria):

$ lazbuild -B project1.lpr --ws=cocoa --cpu=x86_64 --os=darwin --compiler=/usr/local/bin/ppcx64

Se puede revisar si el ejecutable es de 64 bits usando el comando "file":

$ file ./project1
$ ./project1: Mach-O 64-bit executable x86_64

Alternativamente, puede ajustar su proyecto para compilar en 64 bits usando la interfaz gráfica de Lazarus:

a.) Elija en el menú Project/Project Options
b.) En Compiler Options/Compiler Commands escriba en el campo de Compiler Command lo siguiente: "/usr/local/bin/ppcx64"
c.) Para Compiler Options/Config And Target abra "Target CPU family" y escoja "x86_64"
d.) Para Compiler Options/Additions And Overrides guarde  "LCLWidgetType := cocoa" en el LPI

Note que un computador con OSX de 64 bits puede ejecutar bien sobre 32 bits. Sin embargo, si quiere crear un binario universal que ejecute en Intel de 32 bits como tambén en modo de 64 bits en un computador de 64 bits de Intel puede usar el comando "lipo". Esto podría permitir al computador de 64 bits acceder a más memoria y en teoría podría desarrollares un poco mejor (e.g. distintas optimizaciones del compilador, más registros aunque con punteros más grandes). Asumiendo que tenga separados los ejecutables de 32 bits ("project32") y de 64 bits ("project64") con Lazarus.

$ lipo -create project32 project64 -o projectUniversal

Desde Darwin hacia Windows, Linux y otros

El administrador de paquetes fink tiene paquetes para compilación cruzada hacia windows, linux, freebsd principalmente para Macs basados en Intel, como también para algunos Macs basados en PowerPC Macs.

$ fink install fpc-cross-i386-win32

or

$ fink install fpc-cross-arm-linux

instalando los compiladores cruzados.

Para compilar use estos comandos:

fpc -Twin32 FILENAME
fpc -Parm -Tlinux FILENAME

La lista actual con fpc 2.6.4 es:

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-solaris
fpc-cross-i386-win32
fpc-cross-i386-wince
fpc-cross-powerpc-darwin
fpc-cross-powerpc-linux
fpc-cross-sparc-linux
fpc-cross-x86-64-darwin
fpc-cross-x86-64-freebsd
fpc-cross-x86-64-linux
fpc-cross-x86-64-win64

Para otras plataformas (procesadores y sistemas) tiene que hacer la configuración por sí mismo. Es básicamente siempre el mismo esquema: Primero, necesita el binutils correspondiente, el compilador cruzado y la biblioteca de tiempo de ejecución RTL. Más detalles del procedimiento de construcción se puede aprender desde los archivos de descripción del paquete fink o de los compiladores cruzados de arriba.

From FreeBSD

FreeBSD to SPARC

Warning: This section appears to date from around 2005 and may not be relevant anymore. Updates are welcome.

I managed to crosscompile from x86 to Sparc Solaris 9. However the result doesn't work very well, but here is my cmdline:

in compiler/ execute:

gmake cycle CPU_TARGET=sparc OS_TARGET=solaris CROSSBINUTILPREFIX=solaris-sparc- CROSSOPT='-Xd -Fl~/src/sollib'

~/src/sollib is a directory that contains:

• a set of .o's from /usr/local/gcc-3.3-32bit/lib/gcc-lib/sparc-sun-solaris/3.3
• libgcc.a from /usr/local/gcc-3.3-32bit/lib/gcc-lib/sparc-sun-solaris/3.3
• a set of lib*.so from /usr/lib: libaio.so libmd5.so libc.so libelf.so librt.so libdl.so libm.so

Problem is illustrated by the following binary.

 Free Pascal Compiler version 2.1.1 [2006/03/17] for sparc
 Copyright (c) 1993-2005 by Florian Klaempfl
 Target OS: Solaris for SPARC
 Compiling system.pp
 system.pp(15,1) Fatal: Syntax error, "BEGIN" expected but "identifier UNIT" found

I suspect wrong .o's are taken.

General Unix/Linux notes

Option -XLA is used to rename library dependencies specified in pascal units. Format is -XLAold=new, to modify ld link option -l<old> to -l<new>.

Option -XR<sysroot> (recent trunk) that can be used to specify the target system root. It's used for:

• adding a prefix to the default added library paths; in the past you used to specify -Xd and these paths manually. E.g. for i386-linux instead of passing /lib, /usr/lib, and /usr/X11R6/lib to ld, it will pass <sysroot>/lib, <sysroot>/usr/lib, and <sysroot>/usr/X11R6/lib to ld.
• detecting the C library (linux specific): glibc or uclibc. E.g. for uclibc detection '<sysroot>/lib/ld-uClibc.so.0' is tried.

Cross compiling the LCL

Since 0.9.31 the LCL is a normal Lazarus package and the IDE will automatically cross compile all needed packages, when you change the target platform of your project.

If something goes wrong, here are some hints that might help to find out why:

Test cross compiler

Test if you have installed the cross compiled fpc correctly:

Create a hello world program test.pas:

program test;
begin
  writeln('DATE ',{$i %DATE%});
  writeln('FPCTARGET ',{$i %FPCTARGET%});
  writeln('FPCTARGETCPU ',{$i %FPCTARGETCPU%});
  writeln('FPCTARGETOS ',{$i %FPCTARGETOS%});
  writeln('FPCVERSION ',{$i %FPCVERSION%});
end.

And compile it with your source/original platform. Example for x86 Windows:

fpc -Twin32 -Pi386 test.pas

Then test source compiler:

test

Replace win32 and i386 with your targets. Example for target Windows 64 bit:

fpc -Twin64 -Px86_64 test.pas

Then test cross compiler:

test

The program fpc is a wrapper that searches the right compiler (e.g. ppcrossx64) for the target and executes it.

If this does not work, your cross compiler was not installed correctly. When this works you can cross compile the LCL.

Cross compiling the LCL in Lazarus 0.9.30 and below

If you are sure your cross compiler works, you can do the actual cross compile.

Perform the following steps in the Lazarus IDE to do an LCL cross compile: In older IDEs:

• Set in Tools -> Options -> Environment -> Files the Compiler path to the path to fpc. Normally this is already done.
• Then open Tools -> Configure Build Lazarus.
• Set Target OS (e.g. to Win64) and Target CPU (e.g. to x86_64)
• Click the Build button.

Command line

Apart from the IDE, the command line also allows you to build a cross compiled LCL.

  Nota: Since 0.9.31 you should use lazbuild to cross compile Lazarus packages. See lazbuild -h for a list of options.

An example: you would cross compile a Windows 64 cross compiler using: First thoroughly clean any 64 bit leftovers. This does not touch your 32 bit environment:

make distclean LCL_PLATFORM=win32 CPU_TARGET=x86_64 OS_TARGET=win64

Then build LCL and its required dependencies. We're using LCL_PLATFORM as that presumably corresponds to the widgetset, which is still Windows 32 even on Windows 64 (the widgetsets are the same).

make packager/registration lazutils lcl LCL_PLATFORM=win32 CPU_TARGET=x86_64 OS_TARGET=win64

As in the previous section, the LCL for your normal OS is untouched.

Cross compiling LCL applications

You first need to cross compile the LCL. See above.

Cross compiling applications means: compiling plus linking. When you have cross compiled the LCL the compilation part is easy. Just set in the compiler options of the IDE the Target OS and Target CPU. The tricky part is the linking. If you cross compile a project you may see something like this:

/usr/local/bin/arm-linux-ld: cannot find -lX11

This means you have to install the graphical libraries of the target system. This has nothing to do with FPC/Lazarus, but with cross compiling a library. Some distributions provides pre compiled packages for this. For example Microsoft provides cross compiled libraries for WinCE for Windows. Under Linux you can install Wine to cross compile from Linux to Windows. Some Linux distributions provide 64bit libraries for 32bit systems.

Preguntas Frecuentes sobre compilación cruzada

Por qué compilar en cruzado?

Para que pueda desarrollar un programa para un S.O./CPU y compilarlo para otro S.O./CPU sin necesidad de reiniciar o cambiar de computador.

Por qué no compilar en cruzado?

En muchos casos, querrá probar el programa resultante en la plataforma nativa. Compilar la aplicación en esa plataforma puede ser más fácil de configurar.

Por qué compilar desde Unix a Windows y no al revés?

Ver Cross compiling for Win32 under Linux

Necesito más información sobre como construir FreePascal. ¿Donde la encuentro?

Hay un archivo en formato PDF sobre las FAQ generales sobre como construir y configurar FPC: buildfaq

Errores como que el compilador "/usr/bin/fpc" no soporta arm-linux

Aparte de otras causas, este error puede ocurrir si ha editado fpc.cfg con opciones incorrectas para el compilador cruzado (e.g. especificando todos los parámetros en una línea en vez de línea por línea).

Ver además

• crossnotes Notas sobre compilación cruzada.
• Cross compiling for Windows under Linux