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

9From Linux
- 9.1From Linux x64 to Linux i386
10From Windows
11From macOS (Darwin)
12From FreeBSD
15Cross compiling the LCL
17Cross compile FAQ

Foreword

Build the IMCROSS cross-compiling toolset (Linux-hosted, targeting OS X). It doesn't create binaries that run on Intel Mac OS X 10.5, though, but they will run on PowerPC Mac OS X 10.5 or Intel. How to cross compile from Linux for Mac. There are a lot of examples of cross compiling a go binary for usage on a linux and/or windows machine, but I can't find any info regarding the reverse. I have a linux machine that needs to build a go binary for use on a Mac.

Note: Before going any further, consider Why not to cross compile? below

This is a short introduction for newbies. The following sections describe how to setup a system to cross compile, that means creating binaries (executables) for a platform different from the one used for compilation - e.g. working under Linux and creating Win32 executables (or those for FreeBSD or Darwin, etc.). In this case, the platform used for compilation is usually referred to as 'host' (Linux in the example above) and the platform where you want to run your created binaries is your 'target'.

Free Pascal is a compiler and basically converts source into binaries (machine language). These binaries also contain information on how the operating system starts the executables. Moreover, the binaries refer to the APIs provided by the particular operating system, that's why a different implementation of our Run-Time Library is necessary for different operating systems. Therefore these binaries are platform specific. Free Pascal itself does not need much setup. It can create binaries for many platforms. Just tell it to do so.

Host and target on the same CPU

FPC is designed so that the distributed compiler can create machine code for a certain CPU (because different CPUs need different machine code) and it knows specific requirements for all supported platforms (operating systems) available on that particular CPU. This means that you can perform cross-compilation with the same compiler used for native compilation as long as you stick to the same CPU.

Host and target on different CPUs

If you need to create binaries for a different CPU, you need a special cross-compiler, i.e. compiler running on the host platform, but able to create machine code for a different CPU (in the case of FPC, such a cross-compiler would be again able to target all supported platforms available on the _target_ CPU). This cross-compiler is then usually stored in the same directory as the native compiler. Such a cross-compiler may be either compiled by yourself, or you can use a ready made distributed cross-compiler provided for some platforms directly by the FPC team (usually platforms mostly used in portable devices like arm-linux or arm-wince, because these are usually not used as host platforms). FPC binary can then select the right compiler (either the native compiler or the cross-compiler) for the target CPU selected using the -P parameter.

Supported targets

See the Supported target operating systems article for the full list.

Assembler and linker

The compiler is only one part. We also need the assembler and the linker. FPC provides an internal assembler and/or linker for some platforms, but other platforms need external tools. Usually these tools are not able to create binaries for different platforms. That's why we have to use different special linker 'ld' and assembler 'as' for every target platform. These are the binutils.

See Binutils.

Units for target

After creating (or having/installing) the cross tools, one needs FPC RTL and other units compiled for the chosen target platform. For example, every target platform needs a different file system.ppu (System unit), etc. These units may be either compiled using your compiler set up for compilation to the target platform, or you may potentially use officially distributed units compiled (and distributed) with exactly the same FPC version (if available in format usable under the particular host platform).

Configuration

Then your FPC config file will be setup, so that cross compilation becomes so easy, that you can forget all the boring details. The same will be done for the LCL - the Lazarus Component Library (if using Lazarus). And after this you can cross compile Pascal programs for the (different) target platform. The resulting binaries may then be copied to a machine running the target platform, or run under an emulator (e.g. Wine for Win32 binaries under Linux, etc.).

Basic Steps

There are a few common steps involved in cross compiling that you must do in every case:

Have already a Free Pascal compiler for the platform you wish to compile from.
You need to have the Free Pascal source code (except for the special case of having everything prepared by someone else).
You need to either build from source or obtain binaries of the cross-binutils (See Binutils) that run on the platform you are on and are designed to build programs for your desired target platform.
Sometimes you will need some files from the target you are compiling to.

From Linux

From Linux x64 to Linux i386

Burn iso for mac. Chances are that your 64 bit Linux distribution 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.

Install libc6-dev-i386 package

On multiarch Debian/Ubuntu you need to install the package libc6-dev-i386

Ubuntu issues

On Ubuntu 20.04 x64, some people have errors like these:

It was solved like this:

Get cross-libs from fpcupdeluxe: https://github.com/LongDirtyAnimAlf/fpcupdeluxe/releases/tag/crosslibs_v1.2
Copy from there files 'libglib*' and 'libgio*' to '/lib/i386-linux-gnu'.
In fpc.cfg, change line

Create ld and as files

Check if you already have the files i386-linux-ld and i386-linux-as by doing the following commands:

If you get nothing, it means you need to create them. If you have these files skip to the Compile FPC (see below).

Those are executables files. /usr/bin/i386-linux-ld must contain:

/usr/bin/i386-linux-as must contain:

Both can be created using following commands:

Compile FPC

If for some reason you need to recompile, add the word clean after make (sudo make clean all..). Then:

That's it. Edit your /etc/fpc.cfg file if needed. Note that with 3.0.4 at least, the above crossinstall puts the files in /usr/local/lib/fpc/3.0.4/units/i386-linux and the rest of the FPC systems assumes /usr/lib/.. Easily fixed with a symlink but much nicer to do -

Note that if you see messages about failing to find files such as crtn.o and predicted failures to link, its probably because your Linux distro likes to keep its 32bit gcc libraries in /usr/lib32. Check if the missing files are in fact, in /usr/lib32 and, if so, make a small change to your (eg) /etc/fpc.cfg file, around line #177 there is a section that looks like this -

Make it look like this, one additional line -

From Linux to ARM Linux

Information about targeting Linux running on ARM (e.g. Zaurus) may be found in Setup Cross Compile For ARM.

From Linux to Windows

Information on cross-compilation with Lazarus can be found in Cross compiling for Win32 under Linux

From Linux to macOS

Please see Cross compiling macOS on Linux.

From Windows

From Windows to Linux

This is less trivial, there is some info in the buildfaq

See also fpcup for descriptions on which binutils work and what libraries/files to copy.

As the Build FAQ explains, you will need libs (.so files)

Cross Compile On Linux For Mac