LDC is an implicit cross-compiler, i.e., if you have an LDC binary, you can cross-compile, and you don't need multiple LDC executables for each host → target combination. This page shows how to set up LDC for cross-compilation and -linking.

The -mtriple command-line option

The fundamental instrument for cross-compilation is LDC's -mtriple command-line option (the corresponding clang switch is -target ). It defines the target for code-generation, incl. architecture and operating system.

Here are some popular triples:

x86_64-linux-gnu : Linux x86_64 with glibc

: Linux x86_64 with glibc x86_64-apple-darwin : macOS

: macOS x86_64-windows-msvc : Windows x64

: Windows x64 i686-linux-musl : Linux x86 with musl

: Linux x86 with musl i686-windows-msvc : Windows x86

: Windows x86 armv6-linux-gnueabihf : Linux ARMv6 with glibc and hard-float ABI

: Linux ARMv6 with glibc and hard-float ABI armv7a-unknown-linux-androideabi : Android ARMv7-A

: Android ARMv7-A aarch64-linux-android : Android AArch64

: Android AArch64 aarch64-linux-gnu : Linux AArch64 with glibc

: Linux AArch64 with glibc arm64-apple-ios12.0 : iOS arm64 ≥ 12.0

: iOS arm64 ≥ 12.0 wasm32-unknown-unknown-webassembly : 32-bit WebAssembly

Run ldc2 -version to check your default/host triple ( Default target ).

Cross-compiling

The supported targets depend on how the LLVM linked against your LDC was built (target architectures enabled in the CMake build command-line). Running ldc2 -version shows the list of enabled/registered LLVM backends.

ldc2 -mtriple=x86_64-windows-msvc -c foo.d : generates a foo.obj COFF object file for Win64

: generates a COFF object file for Win64 ldc2 -mtriple=x86_64-apple-darwin -c foo.d : generates a foo.o Mach-O object file for macOS

: generates a Mach-O object file for macOS ldc2 -mtriple=aarch64-linux-gnu -c foo.d : generates a foo.o ELF object file for Linux AArch64

Generating static libraries

Generating suited static libraries ( -lib ) works for all targets, on all hosts.

ldc2 -mtriple=x86_64-linux-gnu -lib foo.o : generates a libfoo.a archive

: generates a archive ldc2 -mtriple=x86_64-windows-msvc -lib foo.obj : generates a foo.lib library

As long as your LLVM features the backend for your target, you can obviously directly cross-compile and -archive a library:

ldc2 -mtriple=… -lib foo.d

Cross-linking executables and shared libraries

Cross-linking requires more work, as we have these requirements:

Default libraries (e.g., druntime and Phobos) for the target, as (non- betterC ) binaries are linked against these default libraries. C runtime libraries (and startup object files etc.) for the target, as druntime and Phobos don't completely reinvent the wheel and build on top of a C runtime (glibc, musl, Visual C++, Bionic, …). This also applies to -betterC binaries. A cross-linker.

Default libraries

If there's a prebuilt LDC package for your desired target, then the simplest variant is to download it (matching the version of your host LDC) and copy the lib[32,64] subdirectories to your host LDC installation (or wherever you like).

If there's no prebuilt LDC package or you prefer cross-compiling druntime and Phobos yourself, check out Building LDC runtime libraries.

C runtime libraries and cross-linker

Windows targets

The WinSDK and Visual C++ libraries are included in the prebuilt LDC Windows packages since v1.13 (in the mingw subdirectory in the lib directories), so you're already set after copying the lib directories in the previous step.

For Windows targets, LLVM's LLD works nicely as cross-linker on all hosts. Official prebuilt LDC packages feature an integrated LLD and use it by default for Windows targets on non-Windows hosts.

Non-Apple POSIX targets

The preferred way is to install a gcc/clang toolchain for cross-compilation, e.g., the gcc-aarch64-linux-gnu package on Debian/Ubuntu hosts when targeting Linux AArch64, or the NDK for Android targets. These toolchains include the C libraries as well as a cross-linker-driver (e.g., aarch64-linux-gnu-gcc or aarch64-linux-android21-clang ) configured for those libs and startup object files etc.

Tweaking the LDC configuration file

LDC needs information about where to find the target's libraries and which cross-linker to use. While you can specify that information on the command-line, it's tedious and error-prone, so the preferred way is to extend the etc/ldc2.conf configuration file by appending a section for your target triple.

These settings will be used automatically when specifying a matching target triple, so that e.g. ldc2 -mtriple=x86_64-windows-msvc foo.d is enough to generate a foo.exe Win64 executable.

Exemplary sections:

Win64



Assuming the lib directory from the prebuilt LDC windows-x64

package was copied to <LDC root>/lib-win64 . "x86_64-.*-windows-msvc": { switches = [ "-defaultlib=phobos2-ldc,druntime-ldc", "-link-defaultlib-shared=false", ]; lib-dirs = [ "%%ldcbinarypath%%/../lib-win64", ]; }; Linux AArch64



Assuming the lib directory from the prebuilt LDC linux-aarch64

package was copied to <LDC root>/lib-aarch64 and the

cross-gcc executable is found via aarch64-linux-gnu-gcc . "aarch64-.*-linux-gnu": { switches = [ "-defaultlib=phobos2-ldc,druntime-ldc", "-gcc=aarch64-linux-gnu-gcc", ]; lib-dirs = [ "%%ldcbinarypath%%/../lib-aarch64", ]; rpath = "%%ldcbinarypath%%/../lib-aarch64"; }; Android ARMv7-A



Assuming the lib directory from the prebuilt LDC android-armv7a

package was copied to <LDC root>/lib-armv7a and the

Android NDK r21 has been unzipped into /home/me . "armv7a-.*-linux-android": { switches = [ "-defaultlib=phobos2-ldc,druntime-ldc", "-link-defaultlib-shared=false", "-gcc=/home/me/android-ndk-r21/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi21-clang", ]; lib-dirs = [ "%%ldcbinarypath%%/../lib-armv7a", ]; rpath = ""; }; Android AArch64



Assuming the lib directory from the prebuilt LDC android-aarch64

package was copied to <LDC root>/lib-aarch64 and the

Android NDK r21 has been unzipped into /home/me . "aarch64-.*-linux-android": { switches = [ "-defaultlib=phobos2-ldc,druntime-ldc", "-link-defaultlib-shared=false", "-gcc=/home/me/android-ndk-r21/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android21-clang", ]; lib-dirs = [ "%%ldcbinarypath%%/../lib-aarch64", ]; rpath = ""; };

Cross-compiling with dub

Starting with dub v1.18 (or v1.17+ bundled with official LDC v1.18 packages), you can cross-compile entire dub projects incl. their dependencies by simply adding --arch=<LDC triple> in the dub command-line, after setting up your etc/ldc2.conf configuration file as detailed above.

Limitations