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 OFF if and only if ``CMAKE_BUILD_TYPE``
 219   is *Release*.
 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 disable compiler specific extensions, is
 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_BUILD_DOCS**:BOOL
 295   Enables all enabled documentation targets (i.e. Doxgyen and Sphinx targets) to
 296   be built as part of the normal build. If the ``install`` target is run then
 297   this also enables all built documentation targets to be installed. Defaults to
 298   OFF.
 299
 300 **LLVM_ENABLE_DOXYGEN**:BOOL
 301   Enables the generation of browsable HTML documentation using doxygen.
 302   Defaults to OFF.
 303
 304 **LLVM_ENABLE_DOXYGEN_QT_HELP**:BOOL
 305   Enables the generation of a Qt Compressed Help file. Defaults to OFF.
 306   This affects the make target ``doxygen-llvm``. When enabled, apart from
 307   the normal HTML output generated by doxygen, this will produce a QCH file
 308   named ``org.llvm.qch``. You can then load this file into Qt Creator.
 309   This option is only useful in combination with ``-DLLVM_ENABLE_DOXYGEN=ON``;
 310   otherwise this has no effect.
 311
 312 **LLVM_DOXYGEN_QCH_FILENAME**:STRING
 313   The filename of the Qt Compressed Help file that will be genrated when
 314   ``-DLLVM_ENABLE_DOXYGEN=ON`` and
 315   ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON`` are given. Defaults to
 316   ``org.llvm.qch``.
 317   This option is only useful in combination with
 318   ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``;
 319   otherwise this has no effect.
 320
 321 **LLVM_DOXYGEN_QHP_NAMESPACE**:STRING
 322   Namespace under which the intermediate Qt Help Project file lives. See `Qt
 323   Help Project`_
 324   for more information. Defaults to "org.llvm". This option is only useful in
 325   combination with ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``; otherwise
 326   this has no effect.
 327
 328 **LLVM_DOXYGEN_QHP_CUST_FILTER_NAME**:STRING
 329   See `Qt Help Project`_ for
 330   more information. Defaults to the CMake variable ``${PACKAGE_STRING}`` which
 331   is a combination of the package name and version string. This filter can then
 332   be used in Qt Creator to select only documentation from LLVM when browsing
 333   through all the help files that you might have loaded. This option is only
 334   useful in combination with ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``;
 335   otherwise this has no effect.
 336
 337 .. _Qt Help Project: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-filters
 338
 339 **LLVM_DOXYGEN_QHELPGENERATOR_PATH**:STRING
 340   The path to the ``qhelpgenerator`` executable. Defaults to whatever CMake's
 341   ``find_program()`` can find. This option is only useful in combination with
 342   ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``; otherwise this has no
 343   effect.
 344
 345 **LLVM_ENABLE_SPHINX**:BOOL
 346   If enabled CMake will search for the ``sphinx-build`` executable and will make
 347   the ``SPHINX_OUTPUT_HTML`` and ``SPHINX_OUTPUT_MAN`` CMake options available.
 348   Defaults to OFF.
 349
 350 **SPHINX_EXECUTABLE**:STRING
 351   The path to the ``sphinx-build`` executable detected by CMake.
 352
 353 **SPHINX_OUTPUT_HTML**:BOOL
 354   If enabled (and ``LLVM_ENABLE_SPHINX`` is enabled) then the targets for
 355   building the documentation as html are added (but not built by default unless
 356   ``LLVM_BUILD_DOCS`` is enabled). There is a target for each project in the
 357   source tree that uses sphinx (e.g.  ``docs-llvm-html``, ``docs-clang-html``
 358   and ``docs-lld-html``). Defaults to ON.
 359
 360 **SPHINX_OUTPUT_MAN**:BOOL
 361   If enabled (and ``LLVM_ENABLE_SPHINX`` is enabled) the targets for building
 362   the man pages are added (but not built by default unless ``LLVM_BUILD_DOCS``
 363   is enabled). Currently the only target added is ``docs-llvm-man``. Defaults
 364   to ON.
 365
 366 **SPHINX_WARNINGS_AS_ERRORS**:BOOL
 367   If enabled then sphinx documentation warnings will be treated as
 368   errors. Defaults to ON.
 369
 370 Executing the test suite
 371 ========================
 372
 373 Testing is performed when the *check* target is built. For instance, if you are
 374 using makefiles, execute this command while on the top level of your build
 375 directory:
 376
 377 .. code-block:: console
 378
 379   $ make check
 380
 381 On Visual Studio, you may run tests to build the project "check".
 382
 383 Cross compiling
 384 ===============
 385
 386 See `this wiki page <http://www.vtk.org/Wiki/CMake_Cross_Compiling>`_ for
 387 generic instructions on how to cross-compile with CMake. It goes into detailed
 388 explanations and may seem daunting, but it is not. On the wiki page there are
 389 several examples including toolchain files. Go directly to `this section
 390 <http://www.vtk.org/Wiki/CMake_Cross_Compiling#Information_how_to_set_up_various_cross_compiling_toolchains>`_
 391 for a quick solution.
 392
 393 Also see the `LLVM-specific variables`_ section for variables used when
 394 cross-compiling.
 395
 396 Embedding LLVM in your project
 397 ==============================
 398
 399 From LLVM 3.5 onwards both the CMake and autoconf/Makefile build systems export
 400 LLVM libraries as importable CMake targets. This means that clients of LLVM can
 401 now reliably use CMake to develop their own LLVM based projects against an
 402 installed version of LLVM regardless of how it was built.
 403
 404 Here is a simple example of CMakeLists.txt file that imports the LLVM libraries
 405 and uses them to build a simple application ``simple-tool``.
 406
 407 .. code-block:: cmake
 408
 409   cmake_minimum_required(VERSION 2.8.8)
 410   project(SimpleProject)
 411
 412   find_package(LLVM REQUIRED CONFIG)
 413
 414   message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 415   message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 416
 417   # Set your project compile flags.
 418   # E.g. if using the C++ header files
 419   # you will need to enable C++11 support
 420   # for your compiler.
 421
 422   include_directories(${LLVM_INCLUDE_DIRS})
 423   add_definitions(${LLVM_DEFINITIONS})
 424
 425   # Now build our tools
 426   add_excutable(simple-tool tool.cpp)
 427
 428   # Find the libraries that correspond to the LLVM components
 429   # that we wish to use
 430   llvm_map_components_to_libnames(llvm_libs support core irreader)
 431
 432   # Link against LLVM libraries
 433   target_link_libraries(simple-tool ${llvm_libs})
 434
 435 The ``find_package(...)`` directive when used in CONFIG mode (as in the above
 436 example) will look for the ``LLVMConfig.cmake`` file in various locations (see
 437 cmake manual for details).  It creates a ``LLVM_DIR`` cache entry to save the
 438 directory where ``LLVMConfig.cmake`` is found or allows the user to specify the
 439 directory (e.g. by passing ``-DLLVM_DIR=/usr/share/llvm/cmake`` to
 440 the ``cmake`` command or by setting it directly in ``ccmake`` or ``cmake-gui``).
 441
 442 This file is available in two different locations.
 443
 444 * ``<INSTALL_PREFIX>/share/llvm/cmake/LLVMConfig.cmake`` where
 445   ``<INSTALL_PREFIX>`` is the install prefix of an installed version of LLVM.
 446   On Linux typically this is ``/usr/share/llvm/cmake/LLVMConfig.cmake``.
 447
 448 * ``<LLVM_BUILD_ROOT>/share/llvm/cmake/LLVMConfig.cmake`` where
 449   ``<LLVM_BUILD_ROOT>`` is the root of the LLVM build tree. **Note this only
 450   available when building LLVM with CMake**
 451
 452 If LLVM is installed in your operating system's normal installation prefix (e.g.
 453 on Linux this is usually ``/usr/``) ``find_package(LLVM ...)`` will
 454 automatically find LLVM if it is installed correctly. If LLVM is not installed
 455 or you wish to build directly against the LLVM build tree you can use
 456 ``LLVM_DIR`` as previously mentioned.
 457
 458 The ``LLVMConfig.cmake`` file sets various useful variables. Notable variables
 459 include
 460
 461 ``LLVM_CMAKE_DIR``
 462   The path to the LLVM CMake directory (i.e. the directory containing
 463   LLVMConfig.cmake).
 464
 465 ``LLVM_DEFINITIONS``
 466   A list of preprocessor defines that should be used when building against LLVM.
 467
 468 ``LLVM_ENABLE_ASSERTIONS``
 469   This is set to ON if LLVM was built with assertions, otherwise OFF.
 470
 471 ``LLVM_ENABLE_EH``
 472   This is set to ON if LLVM was built with exception handling (EH) enabled,
 473   otherwise OFF.
 474
 475 ``LLVM_ENABLE_RTTI``
 476   This is set to ON if LLVM was built with run time type information (RTTI),
 477   otherwise OFF.
 478
 479 ``LLVM_INCLUDE_DIRS``
 480   A list of include paths to directories containing LLVM header files.
 481
 482 ``LLVM_PACKAGE_VERSION``
 483   The LLVM version. This string can be used with CMake conditionals. E.g. ``if
 484   (${LLVM_PACKAGE_VERSION} VERSION_LESS "3.5")``.
 485
 486 ``LLVM_TOOLS_BINARY_DIR``
 487   The path to the directory containing the LLVM tools (e.g. ``llvm-as``).
 488
 489 Notice that in the above example we link ``simple-tool`` against several LLVM
 490 libraries. The list of libraries is determined by using the
 491 ``llvm_map_components_to_libnames()`` CMake function. For a list of available
 492 components look at the output of running ``llvm-config --components``.
 493
 494 Note that for LLVM < 3.5 ``llvm_map_components_to_libraries()`` was
 495 used instead of ``llvm_map_components_to_libnames()``. This is now deprecated
 496 and will be removed in a future version of LLVM.
 497
 498 .. _cmake-out-of-source-pass:
 499
 500 Developing LLVM passes out of source
 501 ------------------------------------
 502
 503 It is possible to develop LLVM passes out of LLVM's source tree (i.e. against an
 504 installed or built LLVM). An example of a project layout is provided below.
 505
 506 .. code-block:: none
 507
 508   <project dir>/
 509       |
 510       CMakeLists.txt
 511       <pass name>/
 512           |
 513           CMakeLists.txt
 514           Pass.cpp
 515           ...
 516
 517 Contents of ``<project dir>/CMakeLists.txt``:
 518
 519 .. code-block:: cmake
 520
 521   find_package(LLVM REQUIRED CONFIG)
 522
 523   add_definitions(${LLVM_DEFINITIONS})
 524   include_directories(${LLVM_INCLUDE_DIRS})
 525
 526   add_subdirectory(<pass name>)
 527
 528 Contents of ``<project dir>/<pass name>/CMakeLists.txt``:
 529
 530 .. code-block:: cmake
 531
 532   add_library(LLVMPassname MODULE Pass.cpp)
 533
 534 Note if you intend for this pass to be merged into the LLVM source tree at some
 535 point in the future it might make more sense to use LLVM's internal
 536 add_llvm_loadable_module function instead by...
 537
 538
 539 Adding the following to ``<project dir>/CMakeLists.txt`` (after
 540 ``find_package(LLVM ...)``)
 541
 542 .. code-block:: cmake
 543
 544   list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
 545   include(AddLLVM)
 546
 547 And then changing ``<project dir>/<pass name>/CMakeLists.txt`` to
 548
 549 .. code-block:: cmake
 550
 551   add_llvm_loadable_module(LLVMPassname
 552     Pass.cpp
 553     )
 554
 555 When you are done developing your pass, you may wish to integrate it
 556 into LLVM source tree. You can achieve it in two easy steps:
 557
 558 #. Copying ``<pass name>`` folder into ``<LLVM root>/lib/Transform`` directory.
 559
 560 #. Adding ``add_subdirectory(<pass name>)`` line into
 561    ``<LLVM root>/lib/Transform/CMakeLists.txt``.
 562
 563 Compiler/Platform-specific topics
 564 =================================
 565
 566 Notes for specific compilers and/or platforms.
 567
 568 Microsoft Visual C++
 569 --------------------
 570
 571 **LLVM_COMPILER_JOBS**:STRING
 572   Specifies the maximum number of parallell compiler jobs to use per project
 573   when building with msbuild or Visual Studio. Only supported for the Visual
 574   Studio 2010 CMake generator. 0 means use all processors. Default is 0.