Difference between revisions of "Building and hacking LDC on Windows using MSVC"

From D Wiki
Jump to: navigation, search
(Update for VS 2015, libconfig 1.5 (on GitHub now too), dmd-testsuite...)
m (Running the druntime/Phobos unit tests and druntime standalone tests)
 
(115 intermediate revisions by 3 users not shown)
Line 1: Line 1:
LDC on Windows is work in progress. This page documents how to compile LDC2 on Windows x64. It also provides hints on druntime and phobos.
+
Windows MSVC x86/x64 are first class targets for LDC. This page documents how to build, test and hack LDC2 on Windows.
 +
 
 +
== LDC binaries ==
 +
 
 +
If you just want to download the very latest LDC binaries, head over to the [https://github.com/ldc-developers/ldc/releases/tag/CI GitHub CI release].
 +
 
 +
== 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 [http://wiki.dlang.org/LDC_contributor%27s_guide#Continuous_Integration Continuous Integration] platforms: the Azure Pipelines scripts for [https://github.com/ldc-developers/ldc/blob/master/.azure-pipelines/posix.yml Ubuntu Linux and macOS] and [https://github.com/ldc-developers/ldc/blob/master/.azure-pipelines/windows.yml Windows] are always up-to-date with the latest build setup.
  
 
== Building LDC ==
 
== Building LDC ==
Line 5: Line 12:
 
=== Required software ===
 
=== Required software ===
  
* Windows x64, of course!
+
* Windows, of course!
* Visual Studio (e.g. [https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx VS Community 2015])
+
* [https://www.visualstudio.com/downloads/ Visual Studio or stand-alone Build Tools] ≥ 2017. Make sure to install the Visual C++ toolchain.
* [http://git-scm.com/download/win git 1.8+] (I use [https://code.google.com/r/chen2008cj-gitclone/source/browse/PortableGit-1.8.1.2-preview20130201.7z PortableGit])
+
* A [https://github.com/ldc-developers/ldc/releases/ D compiler] (the <tt>ltsmaster</tt> git branch does not need a D compiler to build). DMD as host compiler isn't supported on Windows, make sure to use LDC.
* [http://python.org/download/ Python 2.7.x or Python 3.3.x] (I use [http://portablepython.com/wiki/Download/ Portable Python])
+
* A recent [https://git-scm.com/download/win git] installation
* [http://www.cmake.org/download/ CMake 2.8+]
+
* [https://www.python.org/downloads/ Python] (I use [https://github.com/winpython/winpython/releases Winpython])
* [https://github.com/martine/ninja/releases Ninja], a neat little and fast build system
+
* [https://github.com/Kitware/CMake/releases CMake &ge; 3.8]
* [http://wiki.dlang.org/Curl_on_Windows Curl library] (just use a precompiled one)
+
* [https://github.com/ninja-build/ninja/releases Ninja], a neat little and fast build system
** Put curl.lib in a LIB/LIBPATH directory (e.g., <tt>C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\lib\amd64</tt>)...
+
* For running the testsuite: GNU make ([https://dl.dropboxusercontent.com/s/4y36f5ydgrk4p5g/make-4.2.1.7z?dl=0 prebuilt v4.2.1])
** ... and curl.dll in a PATH directory (e.g., <tt>C:\LDC\LDC-x64\bin</tt>).
 
  
=== Shell script ===
+
=== Shell environment ===
  
 
I use a little batch file to set up my LDC build environment. It's located in the root of my LDC environment: <tt>C:\LDC\shell.cmd</tt>.
 
I use a little batch file to set up my LDC build environment. It's located in the root of my LDC environment: <tt>C:\LDC\shell.cmd</tt>.
It sets up the <tt>PATH</tt> environment variable (I've installed the portable tools into <tt>C:\LDC\Tools</tt>) and then spawns a new <tt>VS 2015 x64 Native Tools Command Prompt</tt> with a below-normal process priority, so that my system stays responsive while building.
+
It sets up the <tt>PATH</tt> environment variable (I've installed the portable tools into <tt>C:\LDC\Tools</tt>) and then spawns a new <tt>x64 Native Tools Command Prompt for VS 2019</tt> with a below-normal process priority, so that my system stays responsive while building.
 
I use a shortcut on my desktop to this batch file. Please adjust it to your needs (and note that <tt>%~dp0</tt> is the directory containing the script, i.e., <tt>C:\LDC\</tt>).
 
I use a shortcut on my desktop to this batch file. Please adjust it to your needs (and note that <tt>%~dp0</tt> is the directory containing the script, i.e., <tt>C:\LDC\</tt>).
  
 
<pre>
 
<pre>
 
@echo off
 
@echo off
set PATH=%~dp0LDC-x64\bin;%~dp0LLVM-x64\bin;%~dp0Tools\Ninja 1.6.0;%~dp0Tools\make-3.81\bin;%~dp0Tools\PortableGit-1.8.1.2-preview20130201\bin;%~dp0Tools\cmake-3.3.0-win32-x86\bin;%~dp0Tools\Portable Python 2.7.5.1\App;%PATH%
+
set PATH=%~dp0LDC-x64\bin;%~dp0LLVM-x64\bin;%~dp0Tools\Ninja 1.10.2;%~dp0Tools\make-4.2.1;C:\Program Files\Git\usr\bin;C:\Program Files\Git\bin;%~dp0Tools\cmake-3.19.4-win64-x64\bin;%~dp0Tools\Winpython64-3.7.4.0Zero\python-3.7.4.amd64;%PATH%
 +
:: set D host compiler
 +
set DMD=%~dp0ldc2-1.24.0-windows-multilib\bin\ldmd2.exe
 +
:: set a few environment variables for dmd-testsuite
 +
set OS=windows
 +
set MODEL=64
 
if not exist "%TERM%" set TERM=msys
 
if not exist "%TERM%" set TERM=msys
start /belownormal %comspec% /k "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
+
start /belownormal cmd.exe /k "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\Tools\VsDevCmd.bat" -arch=x64
 
</pre>
 
</pre>
  
=== Environment check ===
+
Use <tt>-arch=x86</tt> in the last line and <tt>set MODEL=32</tt> if you want to build a 32-bit LDC.
  
 
Open a shell by executing the batch file.
 
Open a shell by executing the batch file.
  
* Running <tt>cl</tt> should display the banner from the MS compiler.
+
* Running <code>cl</code> should display the banner from the MS compiler.
* Running <tt>git --version</tt> should display the banner from git.
+
* Running <code>link /version</code> should display the banner from the MS linker.
* Running <tt>python --version</tt> should display the banner from python.
+
* Running <code>git --version</code> should display the banner from git.
* Running <tt>cmake --version</tt> should display the banner from cmake.
+
* Running <code>python --version</code> should display the banner from Python.
* Running <tt>ninja --version</tt> should display the ninja version.
+
* Running <code>cmake --version</code> should display the banner from CMake.
 +
* Running <code>ninja --version</code> should display the Ninja version.
 +
* For the tests:
 +
** Running <code>make --version</code> should display the banner from GNU make.
 +
** Starting a bash shell via <code>bash</code> and then invoking <code>link /version</code> should still display the MS linker banner. If it doesn't, make sure that git's <tt>usr\bin</tt> directory is listed before its <tt>bin</tt> directory in <tt>PATH</tt>.
  
=== Build LLVM ===
+
=== Building LLVM ===
  
To build LLVM from the command line, just execute the following steps (from <tt>C:\LDC</tt>):
+
Building LLVM takes quite a while, so you may want to download a prebuilt version from [https://github.com/ldc-developers/llvm-project/releases here]. We use these prebuilt packages for CI and the official release packages. Just extract the archive into <tt>C:\LDC\LLVM-x64</tt> and then skip this section. In case you encounter errors wrt. unsupported command-line options or linking errors when building LDC, you probably use a different MSVC/clang toolchain version and will need to build LLVM yourself.
  
 
<ul>
 
<ul>
<li>Get the source: <tt>git clone http://llvm.org/git/llvm.git llvm</tt></li>
+
<li>Download an LLVM source tarball (<tt>llvm-x.y.z.src.tar.xz</tt>). We maintain an [https://github.com/ldc-developers/llvm-project/releases LLVM fork] with minimal modifications; [http://releases.llvm.org/download.html vanilla LLVM] can be used as well.</li>
<li>Create a build directory: <tt>md build-llvm-x64</tt></li>
+
<li>Extract it into <tt>C:\LDC</tt> (e.g., with [http://www.7-zip.org/ 7-Zip]), so that you end up with the source tree in e.g. <tt>C:\LDC\llvm-11.0.1.src</tt>.</li>
<li>Change into it: <tt>cd build-llvm-x64</tt></li>
+
<li><code>cd C:\LDC</code></li>
 +
<li>Create a build directory: <code>md build-llvm-x64</code></li>
 +
<li>Change into it: <code>cd build-llvm-x64</code></li>
 
<li><p>Use a command like this (in one line) to create the Ninja build files:</p>
 
<li><p>Use a command like this (in one line) to create the Ninja build files:</p>
<pre>cmake -G Ninja -DCMAKE_INSTALL_PREFIX=&quot;C:\LDC\LLVM-x64&quot; -DCMAKE_BUILD_TYPE=&quot;RelWithDebInfo&quot;
+
<pre>cmake -G Ninja ..\llvm-11.0.1.src
       -DPYTHON_EXECUTABLE=&quot;C:\LDC\Tools\Portable Python 2.7.5.1\App\python.exe&quot;
+
      -DCMAKE_INSTALL_PREFIX=&quot;C:\LDC\LLVM-x64&quot;
       -DLLVM_TARGETS_TO_BUILD=&quot;X86&quot; -DLLVM_INCLUDE_TESTS=OFF -DLLVM_INCLUDE_EXAMPLES=OFF -DLLVM_ENABLE_ASSERTIONS=ON -DLLVM_APPEND_VC_REV=ON ..\llvm</pre></li>
+
      -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_USE_CRT_RELWITHDEBINFO=MT
<li>Build LLVM: <tt>ninja</tt></li>
+
       -DLLVM_ENABLE_ASSERTIONS=ON
<li>Install it: <tt>ninja install</tt></li>
+
       -DLLVM_TARGETS_TO_BUILD=AArch64;ARM;Mips;MSP430;NVPTX;PowerPC;RISCV;WebAssembly;X86
 +
      -DLLVM_DEFAULT_TARGET_TRIPLE=x86_64-pc-windows-msvc
 +
      -DCOMPILER_RT_INCLUDE_TESTS=OFF
 +
      -DLLVM_INCLUDE_TESTS=OFF</pre>
 +
<p>Use <code>-DCMAKE_BUILD_TYPE=Debug</code> to build a debug version (and probably use <code>-DLLVM_USE_CRT_DEBUG=MTd</code> then). The [http://llvm.org/docs/CMake.html#llvm-specific-variables LLVM page on CMake] documents other variables you can change. For a 32-bit build, use <code>-DLLVM_DEFAULT_TARGET_TRIPLE=i686-pc-windows-msvc</code>.</p></li>
 +
<li>Build LLVM: <code>ninja</code></li>
 +
<li>Install it (to <tt>C:\LDC\LLVM-x64</tt>): <code>ninja install</code></li>
 +
<li>Note that you'll need to keep the <tt>C:\LDC\build-llvm-x64</tt> directory in order to keep the LLVM debuginfos (.pdb files) available.</li>
 
</ul>
 
</ul>
  
The [http://llvm.org/docs/CMake.html#id10 LLVM page on CMake] documents other variables you can change. The most common is to add more targets. E.g. to build a target for ARM you change the targets to build to <tt>-DLLVM_TARGETS_TO_BUILD=&quot;X86;ARM&quot;</tt>.
+
=== Building LDC ===
  
=== Build libconfig ===
+
<ul>
 +
<li><code>cd C:\LDC</code></li>
 +
<li><code>git clone --recursive https://github.com/ldc-developers/ldc.git</code></li>
 +
<li><code>md build-ldc-x64</code></li>
 +
<li><code>cd build-ldc-x64</code></li>
 +
<li><p>Use a command like this (in one line) to create the Ninja build files:</p>
 +
<pre>cmake -G Ninja ..\ldc
 +
      -DCMAKE_INSTALL_PREFIX=&quot;C:\LDC\LDC-x64&quot;
 +
      -DCMAKE_BUILD_TYPE=RelWithDebInfo
 +
      -DLLVM_ROOT_DIR=&quot;C:/LDC/LLVM-x64&quot;</pre>
 +
<p>You can specify the D host compiler explicitly by adding <code>-DD_COMPILER=c:\path\to\ldmd2.exe</code>.</p>
 +
</li>
 +
<li>Build LDC and the default libraries: <code>ninja</code>. The binaries end up in <tt>C:\LDC\build-ldc-x64\bin</tt>.</li>
 +
<li>If you want to install it (to <tt>C:\LDC\LDC-x64</tt>): <code>ninja install</code></li>
 +
</ul>
  
Simple build instructions for libconfig are missing. You can do the following:
+
== Tests ==
  
* <tt>cd C:\LDC</tt>
+
For troubleshooting, be sure to examine the file <tt>C:\LDC\build-ldc-x64\Testing\Temporary\LastTest.log</tt> after a <tt>ctest</tt> invocation.
* <tt>git clone https://github.com/hyperrealm/libconfig.git libconfig</tt>
 
* Open the libconfig.sln solution with Visual Studio
 
* Create a solution configuration for 'x64 Debug'
 
* Change the configuration type of project <tt>libconfig</tt> to 'Static library'.
 
* Build the project <tt>libconfig</tt>
 
  
Alternatively you can use a custom <tt>CMakeLists.txt</tt>:
+
=== Running the LDC D unit tests ===
  
* <tt>cd C:\LDC</tt>
+
* <code>cd C:\LDC\build-ldc-x64</code>
* <tt>git clone https://github.com/hyperrealm/libconfig.git libconfig</tt>
+
* <code>ctest --output-on-failure -R ldc2-unittest</code>
* Download CMakeLists.txt from [https://gist.github.com/redstar/d5694a6301c40ceb0720 this gist] to <tt>C:\LDC\libconfig</tt>.
 
* Create a build directory: <tt>md build-libconfig-x64</tt>
 
* <tt>cd build-libconfig-x64</tt>
 
* <tt>cmake ..\libconfig</tt>
 
* Build the library: <tt>msbuild ALL_BUILD.vcxproj</tt>
 
  
=== Build LDC ===
+
=== Running the LIT (LLVM Integrated Tester) tests ===
  
<ul>
+
You'll need to have [https://pypi.python.org/pypi/lit lit] installed for Python:
<li><tt>cd C:\LDC</tt></li>
+
* Upgrade [https://pip.pypa.io/ pip]: <code>python -m pip install -U pip</code>
<li><tt>git clone --recursive git://github.com/ldc-developers/ldc.git ldc</tt></li>
+
* Install lit: <code>python -m pip install lit</code>
<li><tt>md build-ldc-x64</tt></li>
+
* Make sure it works: <code>python -c "import lit.main; lit.main.main();" --version .</code>
<li><tt>cd build-ldc-x64</tt></li>
+
To run the tests from your build dir you can do:
<li><p>Use a command like this (in one line):</p>
+
* <code>cd C:\LDC\build-ldc-x64</code>
<pre>cmake -G &quot;Visual Studio 14 Win64&quot; -DCMAKE_INSTALL_PREFIX=&quot;C:\LDC\LDC-x64&quot; -DCMAKE_BUILD_TYPE=&quot;RelWithDebInfo&quot;
+
* <code>ctest -V -R lit-tests</code>
      -DLLVM_ROOT_DIR=&quot;C:/LDC/LLVM-x64&quot; -DLIBCONFIG_INCLUDE_DIR=&quot;C:/LDC/libconfig/lib&quot;
+
or you can go to the tests folder inside your build dir, and run the runlit.py script:
      -DLIBCONFIG_LIBRARY=&quot;C:/LDC/libconfig/x64/Debug/libconfig.lib&quot; ..\ldc</pre>
+
* <code>cd C:\LDC\build-ldc-x64\tests</code>
<p>This assumes that you have a static compiled version of <tt>libconfig.lib</tt>. If you use the DLL version then you need to add <tt>-DLIBCONFIG_DLL=ON</tt>.</p></li>
+
* <code>python runlit.py -v .</code>
<li>Build LDC and the runtimes: <tt>ninja</tt></li>
+
The second way is convenient for running individual tests:
<li>If you want to install it: <tt>ninja install</tt></li>
+
* <code>python runlit.py -v codegen/align.d</code>
</ul>
 
  
=== Running the runtime unit tests ===
+
=== Running the druntime/Phobos unit tests and druntime integration tests ===
  
* <tt>cd C:\LDC\build-ldc-x64</tt>
+
* Make sure the 64/32-bit <tt>libcurl.dll</tt> (bundled with LDC) can be found in a PATH directory. Verify by running <code>where libcurl.dll</code>.
* Build the unit tests: <tt>ninja druntime-ldc-unittest druntime-ldc-unittest-debug phobos2-ldc-unittest phobos2-ldc-unittest-debug</tt>
+
* <code>cd C:\LDC\build-ldc-x64</code>
* Run the tests, excluding the dmd-testsuite ones: <tt>ctest -E dmd-testsuite</tt>
+
* Build the unit tests: <code>ninja all-test-runners</code>
 
+
* Run the tests, excluding LDC unit tests, LIT tests and dmd-testsuite: <code>ctest --output-on-failure -E &quot;dmd-testsuite|lit-tests|ldc2-unittest&quot;</code>
For troubleshooting be sure to examine the file <tt>C:\LDC\build-ldc-x64\Testing\Temporary\LastTest.log</tt>.
 
  
 
=== Running the dmd-testsuite tests ===
 
=== Running the dmd-testsuite tests ===
  
dmd-testsuite requires a minimalistic GNU environment. bash, grep etc. are shipped with git. Additionally, we need GNU make and reasonably recent GNU diffutils:
+
* If you haven't already, set the <tt>OS</tt> and <tt>MODEL</tt> environment variables:
 
+
** <code>set OS=windows</code> (since v1.17, previously <code>win{32,64}</code>)
* Download [http://gnuwin32.sourceforge.net/packages/make.htm GNU make for Windows]: [http://gnuwin32.sourceforge.net/downlinks/make-bin-zip.php binary] + [http://gnuwin32.sourceforge.net/downlinks/make-dep-zip.php dependencies]
+
** <code>set MODEL={32,64}</code>
* Download [http://gnuwin32.sourceforge.net/packages/diffutils.htm GNU diffutils for Windows]: [http://gnuwin32.sourceforge.net/downlinks/diffutils-bin-zip.php binaries] (same dependencies as make)
+
* <code>cd C:\LDC\build-ldc-x64</code>
* Extract all 3 ZIP archives into a common root folder, e.g., <tt>C:\LDC\Tools\make</tt>
+
* <code>ctest -V -R dmd-testsuite</code>
* Edit your shell batch script and add the bin subdirectory to your PATH, e.g., <tt>set PATH=%~dp0Tools\make\bin;%PATH%</tt>
+
** Debug only: <code>ctest -V -R "build-run-dmd-testsuite|dmd-testsuite-debug"</code>
** Make sure that directory preceeds the git bin directory in the PATH environment variable, so that the newer <tt>diff.exe</tt> from <tt>C:\LDC\Tools\make\bin</tt> is preferred.
+
** Release only: <code>ctest -V -R dmd-testsuite -E -debug</code>
* Spawn a new shell and make sure <tt>make --version</tt> prints its banner.
 
 
 
Now that we have extended our LDC build environment, we're able to run the dmd-testsuite tests. I prefer to run them manually, outside of ctest.
 
  
* <tt>cd C:\LDC\ldc\tests\d2\dmd-testsuite</tt>
+
== Developing/debugging LDC/LLVM with Visual Studio ==
* If you want to reset the results, delete the folder: <tt>rmdir /S C:\LDC\build-ldc-x64\dmd-testsuite(-debug)</tt>
 
* Get the command line from <tt>C:\LDC\build-ldc-x64\tests\d2\CTestTestfile.cmake</tt> (e.g., <tt>"make" "-k" "-C" "C:/LDC/ldc/tests/d2/dmd-testsuite" "RESULTS_DIR=C:/LDC/build-ldc-x64/dmd-testsuite-debug" ... "quick"</tt>)
 
** You may want to redirect stdout and stderr to a log file by appending something like <tt>&nbsp;&gt; C:\LDC\build-ldc-x64\dmd-testsuite.log 2&gt;&amp;1</tt>
 
* Start the tests.
 
* Run the tests a second time without resetting the results to get a list of the failures and disabled tests.
 
  
=== Developing/debugging with Visual Studio ===
+
Be sure to use Rainer's great [http://rainers.github.io/visuald/visuald/StartPage.html Visual D] plugin for VS.
  
* <tt>cd C:\LDC</tt>
+
* <code>cd C:\LDC</code>
* <tt>md vs-ldc-x64</tt>
+
* <code>md vs-ldc-x64</code>
* <tt>cd vs-ldc-x64</tt>
+
* <code>cd vs-ldc-x64</code>
* Use the cmake command from the Build LDC section, but use the VS generator instead of Ninja this time: <tt>cmake -G "Visual Studio 14 Win64" ...</tt>
+
* Use the CMake command from the Build LDC section, but use the VS generator instead of Ninja this time: <code>cmake -G "Visual Studio 15 Win64" ...</code>
* This creates the VS solution <tt>C:\LDC\vs-ldc-x64\ldc.sln</tt>.
 
  
 +
This creates the VS 2017 solution <tt>C:\LDC\vs-ldc-x64\ldc.sln</tt>.
 
A Visual Studio solution for LLVM can be created the same way.
 
A Visual Studio solution for LLVM can be created the same way.
  
=== Known bugs/limitations ===
+
I don't recommend building LDC/LLVM with VS directly; I only use VS for development/debugging and build in the shell with Ninja.
 
 
* Structured Exception Handling is only available for LLVM 3.7 head. Support in <tt>ldc.eh2</tt> has still alpha quality and is known to crash your application under certain circumstances. LLVM is getting [http://llvm.org/docs/ExceptionHandling.html#c-exception-handling-using-the-windows-runtime native support for MSVCRT exceptions], so we'll have to wait for that.
 
* At the time of this writing, LDC master is based on D 2.066, and branch <tt>merge-2.067</tt> provides important fixes for MSVC.
 
** Even more cutting edge, right now anyway, is [https://github.com/kinke/ldc my win64 branch], providing further important fixes (not just for LDC, but all submodules too).
 
* You'll most likely notice [https://github.com/ldc-developers/ldc/issues/988 issue 988]. :P
 
* You'll probably also encounter issues like [https://github.com/ldc-developers/ldc/issues/930 #930].
 
* Visual Studio 2015 is greatly encouraged due to improved C99 support; see [https://github.com/ldc-developers/druntime/pull/29 PR29].
 
 
 
== Example ==
 
 
 
The simple D program <tt>hello.d</tt>
 
 
 
<source lang="d">import std.stdio;
 
 
 
int main()
 
{
 
    writefln("Hello LDC2");
 
    return 0;
 
}</source>
 
can be compiled and linked with the commands:
 
 
 
<pre>
 
ldc2 -c hello.d
 
link hello2.obj phobos-ldc.lib shell32.lib
 
</pre>
 
 
 
or simply with: <tt>ldc2 hello.d</tt>
 
 
 
The resulting <tt>hello.exe</tt> produces the expected output.
 
 
 
  
  

Latest revision as of 04:47, 8 February 2021

Windows MSVC x86/x64 are first class targets for LDC. This page documents how to build, test and hack LDC2 on Windows.

LDC binaries

If you just want to download the very latest LDC binaries, head over to the GitHub CI release.

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.

Building LDC

Required software

Shell environment

I use a little batch file to set up my LDC build environment. It's located in the root of my LDC environment: C:\LDC\shell.cmd. It sets up the PATH environment variable (I've installed the portable tools into C:\LDC\Tools) and then spawns a new x64 Native Tools Command Prompt for VS 2019 with a below-normal process priority, so that my system stays responsive while building. I use a shortcut on my desktop to this batch file. Please adjust it to your needs (and note that %~dp0 is the directory containing the script, i.e., C:\LDC\).

@echo off
set PATH=%~dp0LDC-x64\bin;%~dp0LLVM-x64\bin;%~dp0Tools\Ninja 1.10.2;%~dp0Tools\make-4.2.1;C:\Program Files\Git\usr\bin;C:\Program Files\Git\bin;%~dp0Tools\cmake-3.19.4-win64-x64\bin;%~dp0Tools\Winpython64-3.7.4.0Zero\python-3.7.4.amd64;%PATH%
:: set D host compiler
set DMD=%~dp0ldc2-1.24.0-windows-multilib\bin\ldmd2.exe
:: set a few environment variables for dmd-testsuite
set OS=windows
set MODEL=64
if not exist "%TERM%" set TERM=msys
start /belownormal cmd.exe /k "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\Tools\VsDevCmd.bat" -arch=x64

Use -arch=x86 in the last line and set MODEL=32 if you want to build a 32-bit LDC.

Open a shell by executing the batch file.

  • Running cl should display the banner from the MS compiler.
  • Running link /version should display the banner from the MS linker.
  • Running git --version should display the banner from git.
  • Running python --version should display the banner from Python.
  • Running cmake --version should display the banner from CMake.
  • Running ninja --version should display the Ninja version.
  • For the tests:
    • Running make --version should display the banner from GNU make.
    • Starting a bash shell via bash and then invoking link /version should still display the MS linker banner. If it doesn't, make sure that git's usr\bin directory is listed before its bin directory in PATH.

Building LLVM

Building LLVM takes quite a while, so you may want to download a prebuilt version from here. We use these prebuilt packages for CI and the official release packages. Just extract the archive into C:\LDC\LLVM-x64 and then skip this section. In case you encounter errors wrt. unsupported command-line options or linking errors when building LDC, you probably use a different MSVC/clang toolchain version and will need to build LLVM yourself.

  • Download an LLVM source tarball (llvm-x.y.z.src.tar.xz). We maintain an LLVM fork with minimal modifications; vanilla LLVM can be used as well.
  • Extract it into C:\LDC (e.g., with 7-Zip), so that you end up with the source tree in e.g. C:\LDC\llvm-11.0.1.src.
  • cd C:\LDC
  • Create a build directory: md build-llvm-x64
  • Change into it: cd build-llvm-x64
  • Use a command like this (in one line) to create the Ninja build files:

    cmake -G Ninja ..\llvm-11.0.1.src
          -DCMAKE_INSTALL_PREFIX="C:\LDC\LLVM-x64"
          -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_USE_CRT_RELWITHDEBINFO=MT
          -DLLVM_ENABLE_ASSERTIONS=ON
          -DLLVM_TARGETS_TO_BUILD=AArch64;ARM;Mips;MSP430;NVPTX;PowerPC;RISCV;WebAssembly;X86
          -DLLVM_DEFAULT_TARGET_TRIPLE=x86_64-pc-windows-msvc
          -DCOMPILER_RT_INCLUDE_TESTS=OFF
          -DLLVM_INCLUDE_TESTS=OFF

    Use -DCMAKE_BUILD_TYPE=Debug to build a debug version (and probably use -DLLVM_USE_CRT_DEBUG=MTd then). The LLVM page on CMake documents other variables you can change. For a 32-bit build, use -DLLVM_DEFAULT_TARGET_TRIPLE=i686-pc-windows-msvc.

  • Build LLVM: ninja
  • Install it (to C:\LDC\LLVM-x64): ninja install
  • Note that you'll need to keep the C:\LDC\build-llvm-x64 directory in order to keep the LLVM debuginfos (.pdb files) available.

Building LDC

  • cd C:\LDC
  • git clone --recursive https://github.com/ldc-developers/ldc.git
  • md build-ldc-x64
  • cd build-ldc-x64
  • Use a command like this (in one line) to create the Ninja build files:

    cmake -G Ninja ..\ldc
          -DCMAKE_INSTALL_PREFIX="C:\LDC\LDC-x64"
          -DCMAKE_BUILD_TYPE=RelWithDebInfo
          -DLLVM_ROOT_DIR="C:/LDC/LLVM-x64"

    You can specify the D host compiler explicitly by adding -DD_COMPILER=c:\path\to\ldmd2.exe.

  • Build LDC and the default libraries: ninja. The binaries end up in C:\LDC\build-ldc-x64\bin.
  • If you want to install it (to C:\LDC\LDC-x64): ninja install

Tests

For troubleshooting, be sure to examine the file C:\LDC\build-ldc-x64\Testing\Temporary\LastTest.log after a ctest invocation.

Running the LDC D unit tests

  • cd C:\LDC\build-ldc-x64
  • ctest --output-on-failure -R ldc2-unittest

Running the LIT (LLVM Integrated Tester) tests

You'll need to have lit installed for Python:

  • Upgrade pip: python -m pip install -U pip
  • Install lit: python -m pip install lit
  • Make sure it works: python -c "import lit.main; lit.main.main();" --version .

To run the tests from your build dir you can do:

  • cd C:\LDC\build-ldc-x64
  • ctest -V -R lit-tests

or you can go to the tests folder inside your build dir, and run the runlit.py script:

  • cd C:\LDC\build-ldc-x64\tests
  • python runlit.py -v .

The second way is convenient for running individual tests:

  • python runlit.py -v codegen/align.d

Running the druntime/Phobos unit tests and druntime integration tests

  • Make sure the 64/32-bit libcurl.dll (bundled with LDC) can be found in a PATH directory. Verify by running where libcurl.dll.
  • cd C:\LDC\build-ldc-x64
  • Build the unit tests: ninja all-test-runners
  • Run the tests, excluding LDC unit tests, LIT tests and dmd-testsuite: ctest --output-on-failure -E "dmd-testsuite|lit-tests|ldc2-unittest"

Running the dmd-testsuite tests

  • If you haven't already, set the OS and MODEL environment variables:
    • set OS=windows (since v1.17, previously win{32,64})
    • set MODEL={32,64}
  • cd C:\LDC\build-ldc-x64
  • ctest -V -R dmd-testsuite
    • Debug only: ctest -V -R "build-run-dmd-testsuite|dmd-testsuite-debug"
    • Release only: ctest -V -R dmd-testsuite -E -debug

Developing/debugging LDC/LLVM with Visual Studio

Be sure to use Rainer's great Visual D plugin for VS.

  • cd C:\LDC
  • md vs-ldc-x64
  • cd vs-ldc-x64
  • Use the CMake command from the Build LDC section, but use the VS generator instead of Ninja this time: cmake -G "Visual Studio 15 Win64" ...

This creates the VS 2017 solution C:\LDC\vs-ldc-x64\ldc.sln. A Visual Studio solution for LLVM can be created the same way.

I don't recommend building LDC/LLVM with VS directly; I only use VS for development/debugging and build in the shell with Ninja.



Windows MSVC