Difference between revisions of "Building LDC from source"

From D Wiki
Jump to: navigation, search
m (Adapted cmake cmdline for build with llvm-8.0.0 instead of 6.0.1-3)
m (Update minimum LLVM version to 15)
 
(22 intermediate revisions by 4 users not shown)
Line 1: Line 1:
This page shows you how to build and install [[LDC]] on most Posix-like systems such as linux, macOS, BSD, or Android. For building LDC on Windows, please see [[Building and hacking LDC on Windows using MSVC|its dedicated page]].
+
This page shows you how to build and install [[LDC]] on most Posix-like systems such as linux, macOS, BSD, or Android. For building LDC on '''Windows''', please see [[Building and hacking LDC on Windows using MSVC|its dedicated page]].
  
 
== Advice ==
 
== Advice ==
Line 8: Line 8:
 
* Git (for fetching the source code, if not using a tarball)
 
* Git (for fetching the source code, if not using a tarball)
 
* a C++ toolchain (GCC, Clang, …)
 
* a C++ toolchain (GCC, Clang, …)
* a D compiler (currently LDC and DMD are supported)
+
* a D compiler (LDC/DMD/GDC)
** If you don't have a D compiler installed: LDC 0.17 is the last version that does not need a D compiler to be built. Thus for bootstrapping, you can first build 0.17, and then use that to build newer compiler versions. Our testing infrastructure explicitly tests that new LDC versions can be built with 0.17. The git branch is called <tt>ltsmaster</tt> or [https://github.com/ldc-developers/ldc/releases you can get the source for the latest 0.17 release].
+
** If there's no suitable prebuilt D compiler for your platform: LDC 0.17 is the last version that does not need a D compiler to be built. Thus for bootstrapping, you can first build 0.17, and then use that to build newer compiler versions. Our testing infrastructure explicitly tests that new LDC versions can be built with 0.17 (on 64-bit systems). The git branch is called <tt>ltsmaster</tt> or [https://github.com/ldc-developers/ldc/releases/tag/v0.17.6 you can get the source for the latest 0.17 release]. Note that it doesn't support the latest LLVM versions.
* CMake 2.8+
+
* CMake 3.8+
* Ninja or Make (Ninja is recommended as it supports parallel builds)
+
* [https://github.com/ninja-build/ninja/releases Ninja] or Make (Ninja is highly recommended as it builds in parallel by default and doesn't suffer from concurrency issues wrt. CMake custom commands)
* LLVM 3.9+
+
* Python
* For 0.17 ltsmaster, you need libconfig++ and its header files
+
* libcurl for Phobos' <tt>std.net.curl</tt> (e.g., <tt>libcurl4</tt> on recent Ubuntu)
** Get the <tt>libconfig-devel</tt> or <tt>libconfig-dev</tt> package for some Linux distributions. On OSX, <tt>sudo port install libconfig-hr</tt>); on Android with the Termux app, <tt>apt install libconfig-dev</tt>
+
* zlib-dev (e.g., <tt>zlib1g-dev</tt> on Ubuntu)
* libcurl-dev for building the Phobos standard library and tests (various versions available, e.g. libcurl4-gnutls-dev on Ubuntu)
+
* For 0.17 ltsmaster:
* libedit-dev
+
** libconfig++: get the <tt>libconfig-devel</tt> or <tt>libconfig-dev</tt> package for some Linux distributions. On OSX, <tt>sudo port install libconfig-hr</tt>; on Android with the Termux app, <tt>apt install libconfig-dev</tt>.
* zlib-dev (e.g. zlib1g-dev on Ubuntu)
+
** libcurl-dev (e.g., <tt>libcurl4-gnutls-dev</tt> on Ubuntu)
 +
* For the tests: gdb, unzip, zip and tzdata
 +
** For BSD: bash and GNU make
 +
 
 +
On Ubuntu 18.04, this amounts to:
 +
 
 +
<syntaxhighlight lang=bash>
 +
apt-get install git-core g++ ldc cmake ninja-build zlib1g-dev libcurl4 \
 +
                gdb unzip zip tzdata # only required for the tests
 +
</syntaxhighlight>
  
 
=== LLVM ===
 
=== LLVM ===
  
Many Linux distributions already provide recent binary LLVM packages, sometimes in the form of user-curated package repositories (PPA, …). If a recent LLVM package is available, you might prefer to use it, as LLVM is a rather big project to build. Only the Android target requires building [https://github.com/ldc-developers/llvm/releases our lightly tweaked version of LLVM], which is what we'll use here. There are also pre-built binary tarballs of our tweaked LLVM at that link, but they don't always work in other build environments, so we lay out the steps below in case you can't use them.
+
The minimum supported LLVM version as of August 2024 is 15.0. Many Linux distributions already provide recent LLVM dev packages, sometimes in the form of user-curated package repositories (PPA, …). If a recent LLVM package is available, you might prefer to use it, as LLVM is a rather big project to build, e.g., via <code>apt-get install llvm-dev libclang-common-<matching LLVM version>-dev</code> (the LLVM compiler-rt libraries aka <tt>libclang-common-*-dev</tt> are optional but recommended). Only the Android target requires building [https://github.com/ldc-developers/llvm-project/releases our lightly tweaked version of LLVM], which is what we'll use here. There are also pre-built binary tarballs of our tweaked LLVM at that link, but they don't always work in other build environments, so we lay out the steps below in case you can't use them.
  
==== Building LLVM manually ====
+
==== Building LLVM from source ====
  
We try to keep LDC up-to-date with LLVM trunk, but the latest official release is recommended for the least amount of trouble (with LLVM trunk, you will have to recompile LLVM often). Download a [https://github.com/ldc-developers/llvm/releases lightly tweaked source tarball], extract the archive, configure and build:
+
<syntaxhighlight lang=bash>
 +
# Non-Apple platforms: install binutils-dev package required to generate the ld.gold LTO linker plugin
 +
apt-get install binutils-dev
  
<syntaxhighlight lang=bash>
+
# Download & extract source tarball of our lightly tweaked LLVM
curl -L -O https://github.com/ldc-developers/llvm/releases/download/ldc-v8.0.0/llvm-8.0.0.src.tar.xz
+
curl -OL https://github.com/ldc-developers/llvm-project/releases/download/ldc-v10.0.1/llvm-10.0.1.src.tar.xz
tar xf llvm-8.0.0.src.tar.xz
+
tar -xf llvm-10.0.1.src.tar.xz
cd llvm-8.0.0.src
 
mkdir build && cd build
 
  
# remove `-G Ninja` to use Make instead
+
# Generate Ninja build files; remove `-G Ninja` to use Make instead
cmake -G Ninja .. \
+
mkdir build-llvm && cd build-llvm # using a fresh new build dir is highly recommended whenever re-invoking CMake
 +
cmake -G Ninja ../llvm-10.0.1.src \
 
   -DCMAKE_BUILD_TYPE=Release \
 
   -DCMAKE_BUILD_TYPE=Release \
   -DLLVM_TARGETS_TO_BUILD="AArch64;ARM;Mips;MSP430;NVPTX;PowerPC;X86" \
+
  -DCMAKE_INSTALL_PREFIX=$PWD/../install-llvm \
   -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD="RISCV;WebAssembly" \
+
  -DLLVM_BINUTILS_INCDIR=/usr/include \ # non-Apple only: location of binutils-dev's plugin.h
   -DCOMPILER_RT_INCLUDE_TESTS=OFF
+
   -DLLVM_TARGETS_TO_BUILD='AArch64;ARM;Mips;MSP430;NVPTX;PowerPC;RISCV;WebAssembly;X86' \ # defaults to `all` if not specified
ninja
+
   -DCOMPILER_RT_INCLUDE_TESTS=OFF \
 +
   -DLLVM_INCLUDE_TESTS=OFF
  
cd ../..
+
# Build and install (to directory specified as CMAKE_INSTALL_PREFIX above)
 +
ninja install # or `make -j$(nproc) install`
 +
cd ..
 
</syntaxhighlight>
 
</syntaxhighlight>
  
If you are planning to work on LDC itself, you might want to install a debug build of LLVM instead by using <tt>-DCMAKE_BUILD_TYPE=Debug</tt>. Warning: This leads to a ''heavy'' slowdown!
+
Check out the [http://llvm.org/docs/CMake.html#llvm-specific-variables LLVM CMake page] for more CMake variables.
You can alternatively choose to use <tt>-DCMAKE_BUILD_TYPE=RelWithDebInfo</tt>. This results in less heavy build but with adequate debug info.
 
  
It is recommended that you install LLVM, with <tt>ninja install</tt>. To specify a path for the installation, use the <tt>CMAKE_INSTALL_PREFIX</tt> variable.
+
If you are planning to work on LDC itself, we recommend <tt>-DCMAKE_BUILD_TYPE=RelWithDebInfo</tt> for the (huge!) LLVM debuginfos and <tt>-DLLVM_ENABLE_ASSERTIONS=ON</tt>. LLVM's assertions mode also controls LDC's assertions (in both C++ and D parts of LDC). A debug build of LLVM (<tt>-DCMAKE_BUILD_TYPE=Debug</tt>) leads to a ''heavy'' slowdown of LDC's compilation speed. LLVM's <tt>CMAKE_BUILD_TYPE</tt> also controls how the C++ parts of LDC are compiled (LDC inherits the C++ compiler flags used to build LLVM).
  
If you are building natively in Termux for Android, you'll want to add <tt>-DLLVM_DEFAULT_TARGET_TRIPLE=armv7-none-linux-android</tt>, because CMake cannot detect the Android platform yet.
+
If you are building natively in Termux for Android, you'll want to specify a proper default triple like <tt>-DLLVM_DEFAULT_TARGET_TRIPLE=armv7a-unknown-linux-androideabi</tt>.
  
== LDC ==
+
== Building LDC from source ==
  
Now that you're ready to build and install LDC from source, clone the [https://github.com/ldc-developers/ldc LDC GitHub repository] or get [https://github.com/ldc-developers/ldc/releases one of our official source releases]:
+
Now that you're ready to build LDC from source, clone the [https://github.com/ldc-developers/ldc LDC GitHub repository] or get [https://github.com/ldc-developers/ldc/releases one of our official source releases]:
<pre>$ git clone --recursive https://github.com/ldc-developers/ldc.git</pre>
 
  
If you're behind a company firewall and cloning of the submodules fails, first configure git to use a different protocol, ex https:
+
git clone --recursive https://github.com/ldc-developers/ldc.git
<pre>$ git config --global url."https://github".insteadOf git://github</pre>
 
  
If you already have the git repo, don’t forget to make sure your submodules are up to date by running <tt>git submodule update --init</tt>.
+
If you already have the git repo, don't forget to make sure your submodules are up to date by running <tt>git submodule update --init</tt>.
  
Run the following commands to configure and build ldc and its runtime libraries (see the list of useful CMake switches below):
+
Run the following commands to configure and build LDC and its default libraries:
  
 
<syntaxhighlight lang=bash>
 
<syntaxhighlight lang=bash>
cd ldc
+
# Generate Ninja build files
 +
mkdir build-ldc && cd build-ldc # using a fresh new build dir is highly recommended whenever re-invoking CMake
 +
cmake -G Ninja ../ldc \
 +
  -DCMAKE_BUILD_TYPE=Release \
 +
  -DCMAKE_INSTALL_PREFIX=$PWD/../install-ldc \
 +
  -DLLVM_ROOT_DIR=$PWD/../install-llvm \                  # not needed if using a distro LLVM package
 +
  -DD_COMPILER=$PWD/../ldc2-1.17.0-linux-x86_64/bin/ldmd2 # not needed if host D compiler (ldmd2/dmd/gdmd) is found in PATH or if building 0.17 ltsmaster
  
# Make a working directory for the build (name/path arbitrary).
+
# Build; use -j<N> to limit parallelism if running out of memory. The binaries end up in bin/.
mkdir build && cd build
 
 
 
# If host D compiler is not on path, explicitly specify dmd/ldmd2
 
# (not required for ltsmaster/0.17.x).
 
export DMD=/path/to/your/dmd2/bin/dmd
 
 
 
# Run CMake, giving path to top-level source directory. (Remove
 
# -G Ninja to use default generator, i.e. make.)
 
cmake -G Ninja -DLLVM_CONFIG=../../llvm-8.0.0.src/build/bin/llvm-config ..
 
 
 
# Build and install LDC. Use -j<n> to limit parallelism if running out of memory.
 
 
ninja
 
ninja
sudo ninja install
+
# Optional: install LDC to the CMAKE_INSTALL_PREFIX directory above
 +
ninja install
 
</syntaxhighlight>
 
</syntaxhighlight>
The last step is optional; instead of installing it to the system, you can also choose to run LDC from the <tt>bin/</tt> directory in your CMake working tree.  If you're using an LLVM already installed in your system instead of the tweaked version we just compiled, you don't need to specify <tt>-DLLVM_CONFIG=..</tt>, because our CMake config should pick it up automatically.
 
If it doesn't, set the <tt>LLVM_ROOT_DIR</tt> variable to the location where you installed it. That should be the location you set the <tt>CMAKE_INSTALL_PREFIX</tt> in the CMake command-line
 
when configuring LLVM (see above).
 
 
You can specify install location for LDC too. Set again the <tt>CMAKE_INSTALL_PREFIX</tt> accordingly.
 
 
If you don't need the experimental JIT functionality, you can use -DLDC_DYNAMIC_COMPILE=False in the CMake cmdline as it seems to have caused problems.
 
 
If you're planning to work on LDC, you can set <tt>-DCMAKE_BUILD_TYPE=RelWithDebInfo</tt> here too.
 
 
''Note'': When you issue <tt>ninja install</tt>, that installs LDC on your system and puts the binary e.g. in <tt>/local/bin/ldc</tt>. When you issue <tt>ninja</tt>, that generates a ldc2 binary in <tt>build/bin</tt>. You can config CMake with <tt>-DCMAKE_BUILD_TYPE=Release</tt> and issue <tt>ninja install</tt> to install LDC once. Then, you can delete the <tt>build</tt> directory,
 
and repeat the steps above but now use <tt>-DCMAKE_BUILD_TYPE=RelWithDebInfo</tt>. That way, while working on LDC, with <tt>ninja</tt>, you'll be getting a debug binary in <tt>build/bin</tt>
 
but have a release version in your system.
 
 
If you want to target Android and are building ldc 1.4 or later, add <tt>-DLDC_TARGET_PRESET=Android-arm</tt> to the CMake config.
 
 
If cross-compiling the runtime libraries, you'll need to specify the C cross-compiler before running CMake
 
  
<pre>$ export CC=/home/david/android-ndk-r17b/toolchains/llvm/prebuilt/linux-x86_64/bin/clang</pre>
+
'''Note''': On recent Mac systems, you may likely need an additional <tt>-DD_COMPILER_FLAGS="-gcc=/usr/bin/cc"</tt> in case CMake fails with linker errors. See https://github.com/ldc-developers/ldc/issues/3901.
  
and pass any C, D, or linker flags you need to CMake:
+
If you are planning to work on LDC, we recommend <tt>-DCMAKE_BUILD_TYPE=RelWithDebInfo</tt>.
  
<pre>-DRT_CFLAGS="-target armv7-none-linux-gnueabihf -Os" -DD_FLAGS="-w;-mtriple=armv7-none-linux-gnueabihf" -DLD_FLAGS="-target armv7-none-linux-gnueabihf -fpie -pie"</pre>
+
'''Note''': When installing LDC, existing Phobos/druntime includes (*.d and *.di files) aren't removed, only overwritten. This can cause conflicts when installing a new LDC version into an older LDC installation directory, e.g., when a <tt>std/datetime.d</tt> module is replaced by a <tt>std/datetime/*.d</tt> package. Cleaning up the installation dir or using a new one is recommended.
  
=== Useful CMake variables ===
+
=== More useful CMake variables ===
  
* '''LIB_SUFFIX''': Some Linux distributions, such as Fedora, expect 64 bit libraries in <tt>/usr/lib64</tt> instead of <tt>/usr/lib</tt>. In this case, the installation directory can be adjusted using <tt>-DLIB_SUFFIX=64</tt>.
+
{| class="wikitable"
* '''CMAKE_INSTALL_PREFIX''': The installation prefix, <tt>/usr/local</tt> by default (e.g. <tt>-DCMAKE_INSTALL_PREFIX=/opt/ldc</tt>).
+
|-
* '''INCLUDE_INSTALL_DIR''': The location the D modules for druntime and Phobos are installed to.
+
! LLVM_ROOT_DIR or<br>LLVM_CONFIG
* '''RUNTIME_DIR''', '''PHOBOS2_DIR''': By default, druntime and Phobos are expected in <tt>runtime/</tt> as git submodules. Should circumstances require it, these paths can be changed by setting the variables accordingly.
+
| Allows you to specify the LLVM instance to use. LLVM_CONFIG specifies the path and name of the <tt>llvm-config</tt> binary to use. By default, it is assumed to be <tt>${LLVM_ROOT_DIR}/bin/llvm-config</tt>, otherwise it is searched for on default system paths.
* '''LLVM_ROOT_DIR''' and '''LLVM_CONFIG''': Allows you to specify the LLVM instance to use. LLVM_CONFIG specifies the path and name of the <tt>llvm-config</tt> binary to use. By default, it is assumed to be <tt>${LLVM_ROOT_DIR}/bin/llvm-config</tt>, otherwise it is searched for on default system paths. EDIT: https://github.com/ldc-developers/ldc/issues/1928#issuecomment-268421779 suggests we should just use `ccmake -DLLVM_ROOT_DIR=$homebrew_D/ ..` on ubuntu 14.04 even if /usr/bin/llvm-config-3.8 is available
+
|-
* '''LIBCONFIG_LIBRARY''' and '''LIBCONFIG_INCLUDE_DIR''': Only for 0.17 ltsmaster, these variables can be used to specify the location of the libconfig++ library files and the path to the corresponding header files. NOTE: on error Could NOT find LibConfig (missing: LIBCONFIG_INCLUDE_DIR LIBCONFIG_LIBRARY) and using brew, use for eg: CMAKE_PREFIX_PATH=`brew --prefix` cmake .. [see https://github.com/ldc-developers/ldc/issues/952] or use `sudo apt-get install libconfig++`
+
! BUILD_LTO_LIBS
* '''D_COMPILER''': path to prebuilt D compiler, needed for anything newer than 0.17 ltsmaster
+
| Set this to <tt>ON</tt> to build an additional LTO-able set of Phobos and druntime (to be selected via <tt>-defaultlib=phobos2-ldc-lto,druntime-ldc-lto</tt>).
* '''BUILD_LTO_LIBS''': Set this to <tt>'ON'</tt> to build phobos and druntime with LTO. Available on MacOS and Linux starting with LDC 1.9.0. Include <tt>D_FLAGS='-w;-flto=thin'</tt> to enable ThinLTO (so pass <tt>-DBUILD_LTO_LIBS=ON -DD_FLAGS='-w;-flto=thin'</tt> to cmake). In LDC 1.12.0 ThinLTO will be included automatically, so the <tt>D_FLAGS</tt> variable won't be necessary. LDC 1.12.0 will also support Win64 ([https://github.com/ldc-developers/ldc/pull/2774 PR 2774]).
+
|-
 +
! LDC_INSTALL_LTOPLUGIN
 +
| Set this to <tt>ON</tt> to include the LLVM <tt>ld.gold</tt> LTO linker plugin in the LDC installation, if found.
 +
|-
 +
! LDC_INSTALL_LLVM_RUNTIME_LIBS
 +
| Set this to <tt>ON</tt> to include the LLVM compiler-rt libraries in the LDC installation, if found.
 +
|-
 +
! MULTILIB
 +
| Set this to <tt>ON</tt> to build the 32-bit libraries too. You'll need a multilib C toolchain, e.g., <tt>apt-get install g++-multilib</tt>.
 +
|-
 +
! BUILD_SHARED_LIBS
 +
| Build only shared libraries (<tt>ON</tt>), only static libraries (<tt>OFF</tt>), or both (<tt>BOTH</tt>). Defaults to <tt>BOTH</tt> if shared libraries are supported on your platform, and <tt>OFF</tt> if they aren't.
 +
|-
 +
! LIB_SUFFIX
 +
| Some Linux distributions, such as Fedora, expect 64 bit libraries in <tt>/usr/lib64</tt> instead of <tt>/usr/lib</tt>. In this case, the installation directory can be adjusted using <tt>-DLIB_SUFFIX=64</tt>.
 +
|-
 +
! INCLUDE_INSTALL_DIR
 +
| The location the D modules for druntime and Phobos are installed to. Defaults to <tt>${CMAKE_INSTALL_PREFIX}/include/d</tt>.
 +
|-
 +
! LDC_WITH_LLD
 +
| Set this to <tt>OFF</tt> to disable the LLD linker integration even if the LLD headers are found, e.g., when getting errors about conflicting command-line options when running LDC.
 +
|-
 +
! LDC_DYNAMIC_COMPILE
 +
| Set this to <tt>OFF</tt> (before v1.21: <tt>False</tt>) to disable support for dynamic compilation aka JIT. Try this when getting strange CMake errors.
 +
|-
 +
! LIBCONFIG_LIBRARY and LIBCONFIG_INCLUDE_DIR
 +
| '''Only for 0.17 ltsmaster''', these variables can be used to specify the location of the libconfig++ library files and the path to the corresponding header files. NOTE: on error <tt>Could NOT find LibConfig (missing: LIBCONFIG_INCLUDE_DIR LIBCONFIG_LIBRARY)</tt> and using brew, use for eg: <tt>CMAKE_PREFIX_PATH=`brew --prefix` cmake …</tt> [see https://github.com/ldc-developers/ldc/issues/952].
 +
|-
 +
|}
  
 
NOTE: see https://github.com/Linuxbrew/homebrew-core/blob/master/Formula/ldc.rb for brew's install
 
NOTE: see https://github.com/Linuxbrew/homebrew-core/blob/master/Formula/ldc.rb for brew's install

Latest revision as of 07:53, 26 July 2024

This page shows you how to build and install LDC on most Posix-like systems such as linux, macOS, BSD, or Android. For building LDC on Windows, please see its dedicated page.

Advice

It is hard for us to keep these wiki pages up-to-date. If you run into trouble, have a look at the build scripts for our Continuous Integration platforms: the Azure Pipelines scripts for Ubuntu Linux and macOS and Windows are always up-to-date with the latest build setup.

Prerequisites

  • Git (for fetching the source code, if not using a tarball)
  • a C++ toolchain (GCC, Clang, …)
  • a D compiler (LDC/DMD/GDC)
    • If there's no suitable prebuilt D compiler for your platform: LDC 0.17 is the last version that does not need a D compiler to be built. Thus for bootstrapping, you can first build 0.17, and then use that to build newer compiler versions. Our testing infrastructure explicitly tests that new LDC versions can be built with 0.17 (on 64-bit systems). The git branch is called ltsmaster or you can get the source for the latest 0.17 release. Note that it doesn't support the latest LLVM versions.
  • CMake 3.8+
  • Ninja or Make (Ninja is highly recommended as it builds in parallel by default and doesn't suffer from concurrency issues wrt. CMake custom commands)
  • Python
  • libcurl for Phobos' std.net.curl (e.g., libcurl4 on recent Ubuntu)
  • zlib-dev (e.g., zlib1g-dev on Ubuntu)
  • For 0.17 ltsmaster:
    • libconfig++: get the libconfig-devel or libconfig-dev package for some Linux distributions. On OSX, sudo port install libconfig-hr; on Android with the Termux app, apt install libconfig-dev.
    • libcurl-dev (e.g., libcurl4-gnutls-dev on Ubuntu)
  • For the tests: gdb, unzip, zip and tzdata
    • For BSD: bash and GNU make

On Ubuntu 18.04, this amounts to:

apt-get install git-core g++ ldc cmake ninja-build zlib1g-dev libcurl4 \
                gdb unzip zip tzdata # only required for the tests

LLVM

The minimum supported LLVM version as of August 2024 is 15.0. Many Linux distributions already provide recent LLVM dev packages, sometimes in the form of user-curated package repositories (PPA, …). If a recent LLVM package is available, you might prefer to use it, as LLVM is a rather big project to build, e.g., via apt-get install llvm-dev libclang-common-<matching LLVM version>-dev (the LLVM compiler-rt libraries aka libclang-common-*-dev are optional but recommended). Only the Android target requires building our lightly tweaked version of LLVM, which is what we'll use here. There are also pre-built binary tarballs of our tweaked LLVM at that link, but they don't always work in other build environments, so we lay out the steps below in case you can't use them.

Building LLVM from source

# Non-Apple platforms: install binutils-dev package required to generate the ld.gold LTO linker plugin
apt-get install binutils-dev

# Download & extract source tarball of our lightly tweaked LLVM
curl -OL https://github.com/ldc-developers/llvm-project/releases/download/ldc-v10.0.1/llvm-10.0.1.src.tar.xz
tar -xf llvm-10.0.1.src.tar.xz

# Generate Ninja build files; remove `-G Ninja` to use Make instead
mkdir build-llvm && cd build-llvm # using a fresh new build dir is highly recommended whenever re-invoking CMake
cmake -G Ninja ../llvm-10.0.1.src \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_INSTALL_PREFIX=$PWD/../install-llvm \
  -DLLVM_BINUTILS_INCDIR=/usr/include \ # non-Apple only: location of binutils-dev's plugin.h
  -DLLVM_TARGETS_TO_BUILD='AArch64;ARM;Mips;MSP430;NVPTX;PowerPC;RISCV;WebAssembly;X86' \ # defaults to `all` if not specified
  -DCOMPILER_RT_INCLUDE_TESTS=OFF \
  -DLLVM_INCLUDE_TESTS=OFF

# Build and install (to directory specified as CMAKE_INSTALL_PREFIX above)
ninja install # or `make -j$(nproc) install`
cd ..

Check out the LLVM CMake page for more CMake variables.

If you are planning to work on LDC itself, we recommend -DCMAKE_BUILD_TYPE=RelWithDebInfo for the (huge!) LLVM debuginfos and -DLLVM_ENABLE_ASSERTIONS=ON. LLVM's assertions mode also controls LDC's assertions (in both C++ and D parts of LDC). A debug build of LLVM (-DCMAKE_BUILD_TYPE=Debug) leads to a heavy slowdown of LDC's compilation speed. LLVM's CMAKE_BUILD_TYPE also controls how the C++ parts of LDC are compiled (LDC inherits the C++ compiler flags used to build LLVM).

If you are building natively in Termux for Android, you'll want to specify a proper default triple like -DLLVM_DEFAULT_TARGET_TRIPLE=armv7a-unknown-linux-androideabi.

Building LDC from source

Now that you're ready to build LDC from source, clone the LDC GitHub repository or get one of our official source releases:

git clone --recursive https://github.com/ldc-developers/ldc.git

If you already have the git repo, don't forget to make sure your submodules are up to date by running git submodule update --init.

Run the following commands to configure and build LDC and its default libraries:

# Generate Ninja build files
mkdir build-ldc && cd build-ldc # using a fresh new build dir is highly recommended whenever re-invoking CMake
cmake -G Ninja ../ldc \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_INSTALL_PREFIX=$PWD/../install-ldc \
  -DLLVM_ROOT_DIR=$PWD/../install-llvm \                  # not needed if using a distro LLVM package
  -DD_COMPILER=$PWD/../ldc2-1.17.0-linux-x86_64/bin/ldmd2 # not needed if host D compiler (ldmd2/dmd/gdmd) is found in PATH or if building 0.17 ltsmaster

# Build; use -j<N> to limit parallelism if running out of memory. The binaries end up in bin/.
ninja
# Optional: install LDC to the CMAKE_INSTALL_PREFIX directory above
ninja install

Note: On recent Mac systems, you may likely need an additional -DD_COMPILER_FLAGS="-gcc=/usr/bin/cc" in case CMake fails with linker errors. See https://github.com/ldc-developers/ldc/issues/3901.

If you are planning to work on LDC, we recommend -DCMAKE_BUILD_TYPE=RelWithDebInfo.

Note: When installing LDC, existing Phobos/druntime includes (*.d and *.di files) aren't removed, only overwritten. This can cause conflicts when installing a new LDC version into an older LDC installation directory, e.g., when a std/datetime.d module is replaced by a std/datetime/*.d package. Cleaning up the installation dir or using a new one is recommended.

More useful CMake variables

LLVM_ROOT_DIR or
LLVM_CONFIG
Allows you to specify the LLVM instance to use. LLVM_CONFIG specifies the path and name of the llvm-config binary to use. By default, it is assumed to be ${LLVM_ROOT_DIR}/bin/llvm-config, otherwise it is searched for on default system paths.
BUILD_LTO_LIBS Set this to ON to build an additional LTO-able set of Phobos and druntime (to be selected via -defaultlib=phobos2-ldc-lto,druntime-ldc-lto).
LDC_INSTALL_LTOPLUGIN Set this to ON to include the LLVM ld.gold LTO linker plugin in the LDC installation, if found.
LDC_INSTALL_LLVM_RUNTIME_LIBS Set this to ON to include the LLVM compiler-rt libraries in the LDC installation, if found.
MULTILIB Set this to ON to build the 32-bit libraries too. You'll need a multilib C toolchain, e.g., apt-get install g++-multilib.
BUILD_SHARED_LIBS Build only shared libraries (ON), only static libraries (OFF), or both (BOTH). Defaults to BOTH if shared libraries are supported on your platform, and OFF if they aren't.
LIB_SUFFIX Some Linux distributions, such as Fedora, expect 64 bit libraries in /usr/lib64 instead of /usr/lib. In this case, the installation directory can be adjusted using -DLIB_SUFFIX=64.
INCLUDE_INSTALL_DIR The location the D modules for druntime and Phobos are installed to. Defaults to ${CMAKE_INSTALL_PREFIX}/include/d.
LDC_WITH_LLD Set this to OFF to disable the LLD linker integration even if the LLD headers are found, e.g., when getting errors about conflicting command-line options when running LDC.
LDC_DYNAMIC_COMPILE Set this to OFF (before v1.21: False) to disable support for dynamic compilation aka JIT. Try this when getting strange CMake errors.
LIBCONFIG_LIBRARY and LIBCONFIG_INCLUDE_DIR Only for 0.17 ltsmaster, these variables can be used to specify the location of the libconfig++ library files and the path to the corresponding header files. NOTE: on error Could NOT find LibConfig (missing: LIBCONFIG_INCLUDE_DIR LIBCONFIG_LIBRARY) and using brew, use for eg: CMAKE_PREFIX_PATH=`brew --prefix` cmake … [see https://github.com/ldc-developers/ldc/issues/952].

NOTE: see https://github.com/Linuxbrew/homebrew-core/blob/master/Formula/ldc.rb for brew's install

Tips

The Makefiles generated by CMake respect the DESTDIR variable for the install target. It is prepended to all the file installation targets. This can be useful for building packages:

$ make install DESTDIR=<your root directory>