docs/CMake.rst

   1 ========================
   2 Building LLVM with CMake
   3 ========================
   4
   5 .. contents::
   6    :local:
   7
   8 Introduction
   9 ============
  10
  11 `CMake <http://www.cmake.org/>`_ is a cross-platform build-generator tool. CMake
  12 does not build the project, it generates the files needed by your build tool
  13 (GNU make, Visual Studio, etc) for building LLVM.
  14
  15 If you are really anxious about getting a functional LLVM build, go to the
  16 `Quick start`_ section. If you are a CMake novice, start on `Basic CMake usage`_
  17 and then go back to the `Quick start`_ once you know what you are doing. The
  18 `Options and variables`_ section is a reference for customizing your build. If
  19 you already have experience with CMake, this is the recommended starting point.
  20
  21 .. _Quick start:
  22
  23 Quick start
  24 ===========
  25
  26 We use here the command-line, non-interactive CMake interface.
  27
  28 #. `Download <http://www.cmake.org/cmake/resources/software.html>`_ and install
  29    CMake. Version 2.8 is the minimum required.
  30
  31 #. Open a shell. Your development tools must be reachable from this shell
  32    through the PATH environment variable.
  33
  34 #. Create a directory for containing the build. It is not supported to build
  35    LLVM on the source directory. cd to this directory:
  36
  37    .. code-block:: console
  38
  39      $ mkdir mybuilddir
  40      $ cd mybuilddir
  41
  42 #. Execute this command on the shell replacing `path/to/llvm/source/root` with
  43    the path to the root of your LLVM source tree:
  44
  45    .. code-block:: console
  46
  47      $ cmake path/to/llvm/source/root
  48
  49    CMake will detect your development environment, perform a series of test and
  50    generate the files required for building LLVM. CMake will use default values
  51    for all build parameters. See the `Options and variables`_ section for
  52    fine-tuning your build
  53
  54    This can fail if CMake can't detect your toolset, or if it thinks that the
  55    environment is not sane enough. On this case make sure that the toolset that
  56    you intend to use is the only one reachable from the shell and that the shell
  57    itself is the correct one for you development environment. CMake will refuse
  58    to build MinGW makefiles if you have a POSIX shell reachable through the PATH
  59    environment variable, for instance. You can force CMake to use a given build
  60    tool, see the `Usage`_ section.
  61
  62 .. _Basic CMake usage:
  63 .. _Usage:
  64
  65 Basic CMake usage
  66 =================
  67
  68 This section explains basic aspects of CMake, mostly for explaining those
  69 options which you may need on your day-to-day usage.
  70
  71 CMake comes with extensive documentation in the form of html files and on the
  72 cmake executable itself. Execute ``cmake --help`` for further help options.
  73
  74 CMake requires to know for which build tool it shall generate files (GNU make,
  75 Visual Studio, Xcode, etc). If not specified on the command line, it tries to
  76 guess it based on you environment. Once identified the build tool, CMake uses
  77 the corresponding *Generator* for creating files for your build tool. You can
  78 explicitly specify the generator with the command line option ``-G "Name of the
  79 generator"``. For knowing the available generators on your platform, execute
  80
  81 .. code-block:: console
  82
  83   $ cmake --help
  84
  85 This will list the generator's names at the end of the help text. Generator's
  86 names are case-sensitive. Example:
  87
  88 .. code-block:: console
  89
  90   $ cmake -G "Visual Studio 11" path/to/llvm/source/root
  91
  92 For a given development platform there can be more than one adequate
  93 generator. If you use Visual Studio "NMake Makefiles" is a generator you can use
  94 for building with NMake. By default, CMake chooses the more specific generator
  95 supported by your development environment. If you want an alternative generator,
  96 you must tell this to CMake with the ``-G`` option.
  97
  98 .. todo::
  99
 100   Explain variables and cache. Move explanation here from #options section.
 101
 102 .. _Options and variables:
 103
 104 Options and variables
 105 =====================
 106
 107 Variables customize how the build will be generated. Options are boolean
 108 variables, with possible values ON/OFF. Options and variables are defined on the
 109 CMake command line like this:
 110
 111 .. code-block:: console
 112
 113   $ cmake -DVARIABLE=value path/to/llvm/source
 114
 115 You can set a variable after the initial CMake invocation for changing its
 116 value. You can also undefine a variable:
 117
 118 .. code-block:: console
 119
 120   $ cmake -UVARIABLE path/to/llvm/source
 121
 122 Variables are stored on the CMake cache. This is a file named ``CMakeCache.txt``
 123 on the root of the build directory. Do not hand-edit it.
 124
 125 Variables are listed here appending its type after a colon. It is correct to
 126 write the variable and the type on the CMake command line:
 127
 128 .. code-block:: console
 129
 130   $ cmake -DVARIABLE:TYPE=value path/to/llvm/source
 131
 132 Frequently-used CMake variables
 133 -------------------------------
 134
 135 Here are some of the CMake variables that are used often, along with a
 136 brief explanation and LLVM-specific notes. For full documentation, check the
 137 CMake docs or execute ``cmake --help-variable VARIABLE_NAME``.
 138
 139 **CMAKE_BUILD_TYPE**:STRING
 140   Sets the build type for ``make`` based generators. Possible values are
 141   Release, Debug, RelWithDebInfo and MinSizeRel. On systems like Visual Studio
 142   the user sets the build type with the IDE settings.
 143
 144 **CMAKE_INSTALL_PREFIX**:PATH
 145   Path where LLVM will be installed if "make install" is invoked or the
 146   "INSTALL" target is built.
 147
 148 **LLVM_LIBDIR_SUFFIX**:STRING
 149   Extra suffix to append to the directory where libraries are to be
 150   installed. On a 64-bit architecture, one could use ``-DLLVM_LIBDIR_SUFFIX=64``
 151   to install libraries to ``/usr/lib64``.
 152
 153 **CMAKE_C_FLAGS**:STRING
 154   Extra flags to use when compiling C source files.
 155
 156 **CMAKE_CXX_FLAGS**:STRING
 157   Extra flags to use when compiling C++ source files.
 158
 159 **BUILD_SHARED_LIBS**:BOOL
 160   Flag indicating if shared libraries will be built. Its default value is
 161   OFF. Shared libraries are not supported on Windows and not recommended on the
 162   other OSes.
 163
 164 .. _LLVM-specific variables:
 165
 166 LLVM-specific variables
 167 -----------------------
 168
 169 **LLVM_TARGETS_TO_BUILD**:STRING
 170   Semicolon-separated list of targets to build, or *all* for building all
 171   targets. Case-sensitive. Defaults to *all*. Example:
 172   ``-DLLVM_TARGETS_TO_BUILD="X86;PowerPC"``.
 173
 174 **LLVM_BUILD_TOOLS**:BOOL
 175   Build LLVM tools. Defaults to ON. Targets for building each tool are generated
 176   in any case. You can build an tool separately by invoking its target. For
 177   example, you can build *llvm-as* with a makefile-based system executing *make
 178   llvm-as* on the root of your build directory.
 179
 180 **LLVM_INCLUDE_TOOLS**:BOOL
 181   Generate build targets for the LLVM tools. Defaults to ON. You can use that
 182   option for disabling the generation of build targets for the LLVM tools.
 183
 184 **LLVM_BUILD_EXAMPLES**:BOOL
 185   Build LLVM examples. Defaults to OFF. Targets for building each example are
 186   generated in any case. See documentation for *LLVM_BUILD_TOOLS* above for more
 187   details.
 188
 189 **LLVM_INCLUDE_EXAMPLES**:BOOL
 190   Generate build targets for the LLVM examples. Defaults to ON. You can use that
 191   option for disabling the generation of build targets for the LLVM examples.
 192
 193 **LLVM_BUILD_TESTS**:BOOL
 194   Build LLVM unit tests. Defaults to OFF. Targets for building each unit test
 195   are generated in any case. You can build a specific unit test with the target
 196   *UnitTestNameTests* (where at this time *UnitTestName* can be ADT, Analysis,
 197   ExecutionEngine, JIT, Support, Transform, VMCore; see the subdirectories of
 198   *unittests* for an updated list.) It is possible to build all unit tests with
 199   the target *UnitTests*.
 200
 201 **LLVM_INCLUDE_TESTS**:BOOL
 202   Generate build targets for the LLVM unit tests. Defaults to ON. You can use
 203   that option for disabling the generation of build targets for the LLVM unit
 204   tests.
 205
 206 **LLVM_APPEND_VC_REV**:BOOL
 207   Append version control revision info (svn revision number or Git revision id)
 208   to LLVM version string (stored in the PACKAGE_VERSION macro). For this to work
 209   cmake must be invoked before the build. Defaults to OFF.
 210
 211 **LLVM_ENABLE_THREADS**:BOOL
 212   Build with threads support, if available. Defaults to ON.
 213
 214 **LLVM_ENABLE_CXX1Y**:BOOL
 215   Build in C++1y mode, if available. Defaults to OFF.
 216
 217 **LLVM_ENABLE_ASSERTIONS**:BOOL
 218   Enables code assertions. Defaults to ON if and only if ``CMAKE_BUILD_TYPE``
 219   is *Debug*.
 220
 221 **LLVM_ENABLE_EH**:BOOL
 222   Build LLVM with exception handling support. This is necessary if you wish to
 223   link against LLVM libraries and make use of C++ exceptions in your own code
 224   that need to propagate through LLVM code. Defaults to OFF.
 225
 226 **LLVM_ENABLE_PIC**:BOOL
 227   Add the ``-fPIC`` flag for the compiler command-line, if the compiler supports
 228   this flag. Some systems, like Windows, do not need this flag. Defaults to ON.
 229
 230 **LLVM_ENABLE_RTTI**:BOOL
 231   Build LLVM with run time type information. Defaults to OFF.
 232
 233 **LLVM_ENABLE_WARNINGS**:BOOL
 234   Enable all compiler warnings. Defaults to ON.
 235
 236 **LLVM_ENABLE_PEDANTIC**:BOOL
 237   Enable pedantic mode. This disables compiler specific extensions, if
 238   possible. Defaults to ON.
 239
 240 **LLVM_ENABLE_WERROR**:BOOL
 241   Stop and fail build, if a compiler warning is triggered. Defaults to OFF.
 242
 243 **LLVM_BUILD_32_BITS**:BOOL
 244   Build 32-bits executables and libraries on 64-bits systems. This option is
 245   available only on some 64-bits unix systems. Defaults to OFF.
 246
 247 **LLVM_TARGET_ARCH**:STRING
 248   LLVM target to use for native code generation. This is required for JIT
 249   generation. It defaults to "host", meaning that it shall pick the architecture
 250   of the machine where LLVM is being built. If you are cross-compiling, set it
 251   to the target architecture name.
 252
 253 **LLVM_TABLEGEN**:STRING
 254   Full path to a native TableGen executable (usually named ``tblgen``). This is
 255   intended for cross-compiling: if the user sets this variable, no native
 256   TableGen will be created.
 257
 258 **LLVM_LIT_ARGS**:STRING
 259   Arguments given to lit.  ``make check`` and ``make clang-test`` are affected.
 260   By default, ``'-sv --no-progress-bar'`` on Visual C++ and Xcode, ``'-sv'`` on
 261   others.
 262
 263 **LLVM_LIT_TOOLS_DIR**:PATH
 264   The path to GnuWin32 tools for tests. Valid on Windows host.  Defaults to "",
 265   then Lit seeks tools according to %PATH%.  Lit can find tools(eg. grep, sort,
 266   &c) on LLVM_LIT_TOOLS_DIR at first, without specifying GnuWin32 to %PATH%.
 267
 268 **LLVM_ENABLE_FFI**:BOOL
 269   Indicates whether LLVM Interpreter will be linked with Foreign Function
 270   Interface library. If the library or its headers are installed on a custom
 271   location, you can set the variables FFI_INCLUDE_DIR and
 272   FFI_LIBRARY_DIR. Defaults to OFF.
 273
 274 **LLVM_EXTERNAL_{CLANG,LLD,POLLY}_SOURCE_DIR**:PATH
 275   Path to ``{Clang,lld,Polly}``\'s source directory. Defaults to
 276   ``tools/{clang,lld,polly}``. ``{Clang,lld,Polly}`` will not be built when it
 277   is empty or it does not point to a valid path.
 278
 279 **LLVM_USE_OPROFILE**:BOOL
 280   Enable building OProfile JIT support. Defaults to OFF
 281
 282 **LLVM_USE_INTEL_JITEVENTS**:BOOL
 283   Enable building support for Intel JIT Events API. Defaults to OFF
 284
 285 **LLVM_ENABLE_ZLIB**:BOOL
 286   Build with zlib to support compression/uncompression in LLVM tools.
 287   Defaults to ON.
 288
 289 **LLVM_USE_SANITIZER**:STRING
 290   Define the sanitizer used to build LLVM binaries and tests. Possible values
 291   are ``Address``, ``Memory``, ``MemoryWithOrigins`` and ``Undefined``.
 292   Defaults to empty string.
 293
 294 **LLVM_PARALLEL_COMPILE_JOBS**:STRING
 295   Define the maximum number of concurrent compilation jobs.
 296
 297 **LLVM_PARALLEL_LINK_JOBS**:STRING
 298   Define the maximum number of concurrent link jobs.
 299
 300 **LLVM_BUILD_DOCS**:BOOL
 301   Enables all enabled documentation targets (i.e. Doxgyen and Sphinx targets) to
 302   be built as part of the normal build. If the ``install`` target is run then
 303   this also enables all built documentation targets to be installed. Defaults to
 304   OFF.
 305
 306 **LLVM_ENABLE_DOXYGEN**:BOOL
 307   Enables the generation of browsable HTML documentation using doxygen.
 308   Defaults to OFF.
 309
 310 **LLVM_ENABLE_DOXYGEN_QT_HELP**:BOOL
 311   Enables the generation of a Qt Compressed Help file. Defaults to OFF.
 312   This affects the make target ``doxygen-llvm``. When enabled, apart from
 313   the normal HTML output generated by doxygen, this will produce a QCH file
 314   named ``org.llvm.qch``. You can then load this file into Qt Creator.
 315   This option is only useful in combination with ``-DLLVM_ENABLE_DOXYGEN=ON``;
 316   otherwise this has no effect.
 317
 318 **LLVM_DOXYGEN_QCH_FILENAME**:STRING
 319   The filename of the Qt Compressed Help file that will be generated when
 320   ``-DLLVM_ENABLE_DOXYGEN=ON`` and
 321   ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON`` are given. Defaults to
 322   ``org.llvm.qch``.
 323   This option is only useful in combination with
 324   ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``;
 325   otherwise this has no effect.
 326
 327 **LLVM_DOXYGEN_QHP_NAMESPACE**:STRING
 328   Namespace under which the intermediate Qt Help Project file lives. See `Qt
 329   Help Project`_
 330   for more information. Defaults to "org.llvm". This option is only useful in
 331   combination with ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``; otherwise
 332   this has no effect.
 333
 334 **LLVM_DOXYGEN_QHP_CUST_FILTER_NAME**:STRING
 335   See `Qt Help Project`_ for
 336   more information. Defaults to the CMake variable ``${PACKAGE_STRING}`` which
 337   is a combination of the package name and version string. This filter can then
 338   be used in Qt Creator to select only documentation from LLVM when browsing
 339   through all the help files that you might have loaded. This option is only
 340   useful in combination with ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``;
 341   otherwise this has no effect.
 342
 343 .. _Qt Help Project: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-filters
 344
 345 **LLVM_DOXYGEN_QHELPGENERATOR_PATH**:STRING
 346   The path to the ``qhelpgenerator`` executable. Defaults to whatever CMake's
 347   ``find_program()`` can find. This option is only useful in combination with
 348   ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``; otherwise this has no
 349   effect.
 350
 351 **LLVM_ENABLE_SPHINX**:BOOL
 352   If enabled CMake will search for the ``sphinx-build`` executable and will make
 353   the ``SPHINX_OUTPUT_HTML`` and ``SPHINX_OUTPUT_MAN`` CMake options available.
 354   Defaults to OFF.
 355
 356 **SPHINX_EXECUTABLE**:STRING
 357   The path to the ``sphinx-build`` executable detected by CMake.
 358
 359 **SPHINX_OUTPUT_HTML**:BOOL
 360   If enabled (and ``LLVM_ENABLE_SPHINX`` is enabled) then the targets for
 361   building the documentation as html are added (but not built by default unless
 362   ``LLVM_BUILD_DOCS`` is enabled). There is a target for each project in the
 363   source tree that uses sphinx (e.g.  ``docs-llvm-html``, ``docs-clang-html``
 364   and ``docs-lld-html``). Defaults to ON.
 365
 366 **SPHINX_OUTPUT_MAN**:BOOL
 367   If enabled (and ``LLVM_ENABLE_SPHINX`` is enabled) the targets for building
 368   the man pages are added (but not built by default unless ``LLVM_BUILD_DOCS``
 369   is enabled). Currently the only target added is ``docs-llvm-man``. Defaults
 370   to ON.
 371
 372 **SPHINX_WARNINGS_AS_ERRORS**:BOOL
 373   If enabled then sphinx documentation warnings will be treated as
 374   errors. Defaults to ON.
 375
 376 Executing the test suite
 377 ========================
 378
 379 Testing is performed when the *check* target is built. For instance, if you are
 380 using makefiles, execute this command while on the top level of your build
 381 directory:
 382
 383 .. code-block:: console
 384
 385   $ make check
 386
 387 On Visual Studio, you may run tests to build the project "check".
 388
 389 Cross compiling
 390 ===============
 391
 392 See `this wiki page <http://www.vtk.org/Wiki/CMake_Cross_Compiling>`_ for
 393 generic instructions on how to cross-compile with CMake. It goes into detailed
 394 explanations and may seem daunting, but it is not. On the wiki page there are
 395 several examples including toolchain files. Go directly to `this section
 396 <http://www.vtk.org/Wiki/CMake_Cross_Compiling#Information_how_to_set_up_various_cross_compiling_toolchains>`_
 397 for a quick solution.
 398
 399 Also see the `LLVM-specific variables`_ section for variables used when
 400 cross-compiling.
 401
 402 Embedding LLVM in your project
 403 ==============================
 404
 405 From LLVM 3.5 onwards both the CMake and autoconf/Makefile build systems export
 406 LLVM libraries as importable CMake targets. This means that clients of LLVM can
 407 now reliably use CMake to develop their own LLVM based projects against an
 408 installed version of LLVM regardless of how it was built.
 409
 410 Here is a simple example of CMakeLists.txt file that imports the LLVM libraries
 411 and uses them to build a simple application ``simple-tool``.
 412
 413 .. code-block:: cmake
 414
 415   cmake_minimum_required(VERSION 2.8.8)
 416   project(SimpleProject)
 417
 418   find_package(LLVM REQUIRED CONFIG)
 419
 420   message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 421   message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 422
 423   # Set your project compile flags.
 424   # E.g. if using the C++ header files
 425   # you will need to enable C++11 support
 426   # for your compiler.
 427
 428   include_directories(${LLVM_INCLUDE_DIRS})
 429   add_definitions(${LLVM_DEFINITIONS})
 430
 431   # Now build our tools
 432   add_excutable(simple-tool tool.cpp)
 433
 434   # Find the libraries that correspond to the LLVM components
 435   # that we wish to use
 436   llvm_map_components_to_libnames(llvm_libs support core irreader)
 437
 438   # Link against LLVM libraries
 439   target_link_libraries(simple-tool ${llvm_libs})
 440
 441 The ``find_package(...)`` directive when used in CONFIG mode (as in the above
 442 example) will look for the ``LLVMConfig.cmake`` file in various locations (see
 443 cmake manual for details).  It creates a ``LLVM_DIR`` cache entry to save the
 444 directory where ``LLVMConfig.cmake`` is found or allows the user to specify the
 445 directory (e.g. by passing ``-DLLVM_DIR=/usr/share/llvm/cmake`` to
 446 the ``cmake`` command or by setting it directly in ``ccmake`` or ``cmake-gui``).
 447
 448 This file is available in two different locations.
 449
 450 * ``<INSTALL_PREFIX>/share/llvm/cmake/LLVMConfig.cmake`` where
 451   ``<INSTALL_PREFIX>`` is the install prefix of an installed version of LLVM.
 452   On Linux typically this is ``/usr/share/llvm/cmake/LLVMConfig.cmake``.
 453
 454 * ``<LLVM_BUILD_ROOT>/share/llvm/cmake/LLVMConfig.cmake`` where
 455   ``<LLVM_BUILD_ROOT>`` is the root of the LLVM build tree. **Note this only
 456   available when building LLVM with CMake**
 457
 458 If LLVM is installed in your operating system's normal installation prefix (e.g.
 459 on Linux this is usually ``/usr/``) ``find_package(LLVM ...)`` will
 460 automatically find LLVM if it is installed correctly. If LLVM is not installed
 461 or you wish to build directly against the LLVM build tree you can use
 462 ``LLVM_DIR`` as previously mentioned.
 463
 464 The ``LLVMConfig.cmake`` file sets various useful variables. Notable variables
 465 include
 466
 467 ``LLVM_CMAKE_DIR``
 468   The path to the LLVM CMake directory (i.e. the directory containing
 469   LLVMConfig.cmake).
 470
 471 ``LLVM_DEFINITIONS``
 472   A list of preprocessor defines that should be used when building against LLVM.
 473
 474 ``LLVM_ENABLE_ASSERTIONS``
 475   This is set to ON if LLVM was built with assertions, otherwise OFF.
 476
 477 ``LLVM_ENABLE_EH``
 478   This is set to ON if LLVM was built with exception handling (EH) enabled,
 479   otherwise OFF.
 480
 481 ``LLVM_ENABLE_RTTI``
 482   This is set to ON if LLVM was built with run time type information (RTTI),
 483   otherwise OFF.
 484
 485 ``LLVM_INCLUDE_DIRS``
 486   A list of include paths to directories containing LLVM header files.
 487
 488 ``LLVM_PACKAGE_VERSION``
 489   The LLVM version. This string can be used with CMake conditionals. E.g. ``if
 490   (${LLVM_PACKAGE_VERSION} VERSION_LESS "3.5")``.
 491
 492 ``LLVM_TOOLS_BINARY_DIR``
 493   The path to the directory containing the LLVM tools (e.g. ``llvm-as``).
 494
 495 Notice that in the above example we link ``simple-tool`` against several LLVM
 496 libraries. The list of libraries is determined by using the
 497 ``llvm_map_components_to_libnames()`` CMake function. For a list of available
 498 components look at the output of running ``llvm-config --components``.
 499
 500 Note that for LLVM < 3.5 ``llvm_map_components_to_libraries()`` was
 501 used instead of ``llvm_map_components_to_libnames()``. This is now deprecated
 502 and will be removed in a future version of LLVM.
 503
 504 .. _cmake-out-of-source-pass:
 505
 506 Developing LLVM passes out of source
 507 ------------------------------------
 508
 509 It is possible to develop LLVM passes out of LLVM's source tree (i.e. against an
 510 installed or built LLVM). An example of a project layout is provided below.
 511
 512 .. code-block:: none
 513
 514   <project dir>/
 515       |
 516       CMakeLists.txt
 517       <pass name>/
 518           |
 519           CMakeLists.txt
 520           Pass.cpp
 521           ...
 522
 523 Contents of ``<project dir>/CMakeLists.txt``:
 524
 525 .. code-block:: cmake
 526
 527   find_package(LLVM REQUIRED CONFIG)
 528
 529   add_definitions(${LLVM_DEFINITIONS})
 530   include_directories(${LLVM_INCLUDE_DIRS})
 531
 532   add_subdirectory(<pass name>)
 533
 534 Contents of ``<project dir>/<pass name>/CMakeLists.txt``:
 535
 536 .. code-block:: cmake
 537
 538   add_library(LLVMPassname MODULE Pass.cpp)
 539
 540 Note if you intend for this pass to be merged into the LLVM source tree at some
 541 point in the future it might make more sense to use LLVM's internal
 542 add_llvm_loadable_module function instead by...
 543
 544
 545 Adding the following to ``<project dir>/CMakeLists.txt`` (after
 546 ``find_package(LLVM ...)``)
 547
 548 .. code-block:: cmake
 549
 550   list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
 551   include(AddLLVM)
 552
 553 And then changing ``<project dir>/<pass name>/CMakeLists.txt`` to
 554
 555 .. code-block:: cmake
 556
 557   add_llvm_loadable_module(LLVMPassname
 558     Pass.cpp
 559     )
 560
 561 When you are done developing your pass, you may wish to integrate it
 562 into LLVM source tree. You can achieve it in two easy steps:
 563
 564 #. Copying ``<pass name>`` folder into ``<LLVM root>/lib/Transform`` directory.
 565
 566 #. Adding ``add_subdirectory(<pass name>)`` line into
 567    ``<LLVM root>/lib/Transform/CMakeLists.txt``.
 568
 569 Compiler/Platform-specific topics
 570 =================================
 571
 572 Notes for specific compilers and/or platforms.
 573
 574 Microsoft Visual C++
 575 --------------------
 576
 577 **LLVM_COMPILER_JOBS**:STRING
 578   Specifies the maximum number of parallell compiler jobs to use per project
 579   when building with msbuild or Visual Studio. Only supported for the Visual
 580   Studio 2010 CMake generator. 0 means use all processors. Default is 0.