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