| ======================== |
| Building LLVM with CMake |
| ======================== |
| |
| .. contents:: |
| :local: |
| |
| Introduction |
| ============ |
| |
| `CMake <http://www.cmake.org/>`_ is a cross-platform build-generator tool. CMake |
| does not build the project, it generates the files needed by your build tool |
| (GNU make, Visual Studio, etc) for building LLVM. |
| |
| If you are really anxious about getting a functional LLVM build, go to the |
| `Quick start`_ section. If you are a CMake novice, start on `Basic CMake usage`_ |
| and then go back to the `Quick start`_ once you know what you are doing. The |
| `Options and variables`_ section is a reference for customizing your build. If |
| you already have experience with CMake, this is the recommended starting point. |
| |
| .. _Quick start: |
| |
| Quick start |
| =========== |
| |
| We use here the command-line, non-interactive CMake interface. |
| |
| #. `Download <http://www.cmake.org/cmake/resources/software.html>`_ and install |
| CMake. Version 2.8.8 is the minimum required. |
| |
| #. Open a shell. Your development tools must be reachable from this shell |
| through the PATH environment variable. |
| |
| #. Create a directory for containing the build. It is not supported to build |
| LLVM on the source directory. cd to this directory: |
| |
| .. code-block:: console |
| |
| $ mkdir mybuilddir |
| $ cd mybuilddir |
| |
| #. Execute this command on the shell replacing `path/to/llvm/source/root` with |
| the path to the root of your LLVM source tree: |
| |
| .. code-block:: console |
| |
| $ cmake path/to/llvm/source/root |
| |
| CMake will detect your development environment, perform a series of test and |
| generate the files required for building LLVM. CMake will use default values |
| for all build parameters. See the `Options and variables`_ section for |
| fine-tuning your build |
| |
| This can fail if CMake can't detect your toolset, or if it thinks that the |
| environment is not sane enough. On this case make sure that the toolset that |
| you intend to use is the only one reachable from the shell and that the shell |
| itself is the correct one for you development environment. CMake will refuse |
| to build MinGW makefiles if you have a POSIX shell reachable through the PATH |
| environment variable, for instance. You can force CMake to use a given build |
| tool, see the `Usage`_ section. |
| |
| #. After CMake has finished running, proceed to use IDE project files or start |
| the build from the build directory: |
| |
| .. code-block:: console |
| |
| $ cmake --build . |
| |
| The ``--build`` option tells ``cmake`` to invoke the underlying build |
| tool (``make``, ``ninja``, ``xcodebuild``, ``msbuild``, etc). |
| |
| The underlying build tool can be invoked directly either of course, but |
| the ``--build`` option is portable. |
| |
| #. After LLVM has finished building, install it from the build directory: |
| |
| .. code-block:: console |
| |
| $ cmake --build . --target install |
| |
| The ``--target`` option with ``install`` parameter in addition to |
| the ``--build`` option tells ``cmake`` to build the ``install`` target. |
| |
| It is possible to set a different install prefix at installation time |
| by invoking the ``cmake_install.cmake`` script generated in the |
| build directory: |
| |
| .. code-block:: console |
| |
| $ cmake -DCMAKE_INSTALL_PREFIX=/tmp/llvm -P cmake_install.cmake |
| |
| .. _Basic CMake usage: |
| .. _Usage: |
| |
| Basic CMake usage |
| ================= |
| |
| This section explains basic aspects of CMake, mostly for explaining those |
| options which you may need on your day-to-day usage. |
| |
| CMake comes with extensive documentation in the form of html files and on the |
| cmake executable itself. Execute ``cmake --help`` for further help options. |
| |
| CMake requires to know for which build tool it shall generate files (GNU make, |
| Visual Studio, Xcode, etc). If not specified on the command line, it tries to |
| guess it based on you environment. Once identified the build tool, CMake uses |
| the corresponding *Generator* for creating files for your build tool. You can |
| explicitly specify the generator with the command line option ``-G "Name of the |
| generator"``. For knowing the available generators on your platform, execute |
| |
| .. code-block:: console |
| |
| $ cmake --help |
| |
| This will list the generator's names at the end of the help text. Generator's |
| names are case-sensitive. Example: |
| |
| .. code-block:: console |
| |
| $ cmake -G "Visual Studio 11" path/to/llvm/source/root |
| |
| For a given development platform there can be more than one adequate |
| generator. If you use Visual Studio "NMake Makefiles" is a generator you can use |
| for building with NMake. By default, CMake chooses the more specific generator |
| supported by your development environment. If you want an alternative generator, |
| you must tell this to CMake with the ``-G`` option. |
| |
| .. todo:: |
| |
| Explain variables and cache. Move explanation here from #options section. |
| |
| .. _Options and variables: |
| |
| Options and variables |
| ===================== |
| |
| Variables customize how the build will be generated. Options are boolean |
| variables, with possible values ON/OFF. Options and variables are defined on the |
| CMake command line like this: |
| |
| .. code-block:: console |
| |
| $ cmake -DVARIABLE=value path/to/llvm/source |
| |
| You can set a variable after the initial CMake invocation for changing its |
| value. You can also undefine a variable: |
| |
| .. code-block:: console |
| |
| $ cmake -UVARIABLE path/to/llvm/source |
| |
| Variables are stored on the CMake cache. This is a file named ``CMakeCache.txt`` |
| on the root of the build directory. Do not hand-edit it. |
| |
| Variables are listed here appending its type after a colon. It is correct to |
| write the variable and the type on the CMake command line: |
| |
| .. code-block:: console |
| |
| $ cmake -DVARIABLE:TYPE=value path/to/llvm/source |
| |
| Frequently-used CMake variables |
| ------------------------------- |
| |
| Here are some of the CMake variables that are used often, along with a |
| brief explanation and LLVM-specific notes. For full documentation, check the |
| CMake docs or execute ``cmake --help-variable VARIABLE_NAME``. |
| |
| **CMAKE_BUILD_TYPE**:STRING |
| Sets the build type for ``make`` based generators. Possible values are |
| Release, Debug, RelWithDebInfo and MinSizeRel. On systems like Visual Studio |
| the user sets the build type with the IDE settings. |
| |
| **CMAKE_INSTALL_PREFIX**:PATH |
| Path where LLVM will be installed if "make install" is invoked or the |
| "INSTALL" target is built. |
| |
| **LLVM_LIBDIR_SUFFIX**:STRING |
| Extra suffix to append to the directory where libraries are to be |
| installed. On a 64-bit architecture, one could use ``-DLLVM_LIBDIR_SUFFIX=64`` |
| to install libraries to ``/usr/lib64``. |
| |
| **CMAKE_C_FLAGS**:STRING |
| Extra flags to use when compiling C source files. |
| |
| **CMAKE_CXX_FLAGS**:STRING |
| Extra flags to use when compiling C++ source files. |
| |
| **BUILD_SHARED_LIBS**:BOOL |
| Flag indicating if shared libraries will be built. Its default value is |
| OFF. Shared libraries are not supported on Windows and not recommended on the |
| other OSes. |
| |
| .. _LLVM-specific variables: |
| |
| LLVM-specific variables |
| ----------------------- |
| |
| **LLVM_TARGETS_TO_BUILD**:STRING |
| Semicolon-separated list of targets to build, or *all* for building all |
| targets. Case-sensitive. Defaults to *all*. Example: |
| ``-DLLVM_TARGETS_TO_BUILD="X86;PowerPC"``. |
| |
| **LLVM_BUILD_TOOLS**:BOOL |
| Build LLVM tools. Defaults to ON. Targets for building each tool are generated |
| in any case. You can build an tool separately by invoking its target. For |
| example, you can build *llvm-as* with a makefile-based system executing *make |
| llvm-as* on the root of your build directory. |
| |
| **LLVM_INCLUDE_TOOLS**:BOOL |
| Generate build targets for the LLVM tools. Defaults to ON. You can use that |
| option for disabling the generation of build targets for the LLVM tools. |
| |
| **LLVM_BUILD_EXAMPLES**:BOOL |
| Build LLVM examples. Defaults to OFF. Targets for building each example are |
| generated in any case. See documentation for *LLVM_BUILD_TOOLS* above for more |
| details. |
| |
| **LLVM_INCLUDE_EXAMPLES**:BOOL |
| Generate build targets for the LLVM examples. Defaults to ON. You can use that |
| option for disabling the generation of build targets for the LLVM examples. |
| |
| **LLVM_BUILD_TESTS**:BOOL |
| Build LLVM unit tests. Defaults to OFF. Targets for building each unit test |
| are generated in any case. You can build a specific unit test with the target |
| *UnitTestNameTests* (where at this time *UnitTestName* can be ADT, Analysis, |
| ExecutionEngine, JIT, Support, Transform, VMCore; see the subdirectories of |
| *unittests* for an updated list.) It is possible to build all unit tests with |
| the target *UnitTests*. |
| |
| **LLVM_INCLUDE_TESTS**:BOOL |
| Generate build targets for the LLVM unit tests. Defaults to ON. You can use |
| that option for disabling the generation of build targets for the LLVM unit |
| tests. |
| |
| **LLVM_APPEND_VC_REV**:BOOL |
| Append version control revision info (svn revision number or Git revision id) |
| to LLVM version string (stored in the PACKAGE_VERSION macro). For this to work |
| cmake must be invoked before the build. Defaults to OFF. |
| |
| **LLVM_ENABLE_THREADS**:BOOL |
| Build with threads support, if available. Defaults to ON. |
| |
| **LLVM_ENABLE_CXX1Y**:BOOL |
| Build in C++1y mode, if available. Defaults to OFF. |
| |
| **LLVM_ENABLE_ASSERTIONS**:BOOL |
| Enables code assertions. Defaults to ON if and only if ``CMAKE_BUILD_TYPE`` |
| is *Debug*. |
| |
| **LLVM_ENABLE_EH**:BOOL |
| Build LLVM with exception handling support. This is necessary if you wish to |
| link against LLVM libraries and make use of C++ exceptions in your own code |
| that need to propagate through LLVM code. Defaults to OFF. |
| |
| **LLVM_ENABLE_PIC**:BOOL |
| Add the ``-fPIC`` flag for the compiler command-line, if the compiler supports |
| this flag. Some systems, like Windows, do not need this flag. Defaults to ON. |
| |
| **LLVM_ENABLE_RTTI**:BOOL |
| Build LLVM with run time type information. Defaults to OFF. |
| |
| **LLVM_ENABLE_WARNINGS**:BOOL |
| Enable all compiler warnings. Defaults to ON. |
| |
| **LLVM_ENABLE_PEDANTIC**:BOOL |
| Enable pedantic mode. This disables compiler specific extensions, if |
| possible. Defaults to ON. |
| |
| **LLVM_ENABLE_WERROR**:BOOL |
| Stop and fail build, if a compiler warning is triggered. Defaults to OFF. |
| |
| **LLVM_ABI_BREAKING_CHECKS**:STRING |
| Used to decide if LLVM should be built with ABI breaking checks or |
| not. Allowed values are `WITH_ASSERTS` (default), `FORCE_ON` and |
| `FORCE_OFF`. `WITH_ASSERTS` turns on ABI breaking checks in an |
| assertion enabled build. `FORCE_ON` (`FORCE_OFF`) turns them on |
| (off) irrespective of whether normal (`NDEBUG` based) assertions are |
| enabled or not. A version of LLVM built with ABI breaking checks |
| is not ABI compatible with a version built without it. |
| |
| **LLVM_BUILD_32_BITS**:BOOL |
| Build 32-bits executables and libraries on 64-bits systems. This option is |
| available only on some 64-bits unix systems. Defaults to OFF. |
| |
| **LLVM_TARGET_ARCH**:STRING |
| LLVM target to use for native code generation. This is required for JIT |
| generation. It defaults to "host", meaning that it shall pick the architecture |
| of the machine where LLVM is being built. If you are cross-compiling, set it |
| to the target architecture name. |
| |
| **LLVM_TABLEGEN**:STRING |
| Full path to a native TableGen executable (usually named ``tblgen``). This is |
| intended for cross-compiling: if the user sets this variable, no native |
| TableGen will be created. |
| |
| **LLVM_LIT_ARGS**:STRING |
| Arguments given to lit. ``make check`` and ``make clang-test`` are affected. |
| By default, ``'-sv --no-progress-bar'`` on Visual C++ and Xcode, ``'-sv'`` on |
| others. |
| |
| **LLVM_LIT_TOOLS_DIR**:PATH |
| The path to GnuWin32 tools for tests. Valid on Windows host. Defaults to "", |
| then Lit seeks tools according to %PATH%. Lit can find tools(eg. grep, sort, |
| &c) on LLVM_LIT_TOOLS_DIR at first, without specifying GnuWin32 to %PATH%. |
| |
| **LLVM_ENABLE_FFI**:BOOL |
| Indicates whether LLVM Interpreter will be linked with Foreign Function |
| Interface library. If the library or its headers are installed on a custom |
| location, you can set the variables FFI_INCLUDE_DIR and |
| FFI_LIBRARY_DIR. Defaults to OFF. |
| |
| **LLVM_EXTERNAL_{CLANG,LLD,POLLY}_SOURCE_DIR**:PATH |
| Path to ``{Clang,lld,Polly}``\'s source directory. Defaults to |
| ``tools/{clang,lld,polly}``. ``{Clang,lld,Polly}`` will not be built when it |
| is empty or it does not point to a valid path. |
| |
| **LLVM_USE_OPROFILE**:BOOL |
| Enable building OProfile JIT support. Defaults to OFF |
| |
| **LLVM_USE_INTEL_JITEVENTS**:BOOL |
| Enable building support for Intel JIT Events API. Defaults to OFF |
| |
| **LLVM_ENABLE_ZLIB**:BOOL |
| Build with zlib to support compression/uncompression in LLVM tools. |
| Defaults to ON. |
| |
| **LLVM_USE_SANITIZER**:STRING |
| Define the sanitizer used to build LLVM binaries and tests. Possible values |
| are ``Address``, ``Memory``, ``MemoryWithOrigins``, ``Undefined``, ``Thread``, |
| and ``Address;Undefined``. Defaults to empty string. |
| |
| **LLVM_PARALLEL_COMPILE_JOBS**:STRING |
| Define the maximum number of concurrent compilation jobs. |
| |
| **LLVM_PARALLEL_LINK_JOBS**:STRING |
| Define the maximum number of concurrent link jobs. |
| |
| **LLVM_BUILD_DOCS**:BOOL |
| Enables all enabled documentation targets (i.e. Doxgyen and Sphinx targets) to |
| be built as part of the normal build. If the ``install`` target is run then |
| this also enables all built documentation targets to be installed. Defaults to |
| OFF. |
| |
| **LLVM_ENABLE_DOXYGEN**:BOOL |
| Enables the generation of browsable HTML documentation using doxygen. |
| Defaults to OFF. |
| |
| **LLVM_ENABLE_DOXYGEN_QT_HELP**:BOOL |
| Enables the generation of a Qt Compressed Help file. Defaults to OFF. |
| This affects the make target ``doxygen-llvm``. When enabled, apart from |
| the normal HTML output generated by doxygen, this will produce a QCH file |
| named ``org.llvm.qch``. You can then load this file into Qt Creator. |
| This option is only useful in combination with ``-DLLVM_ENABLE_DOXYGEN=ON``; |
| otherwise this has no effect. |
| |
| **LLVM_DOXYGEN_QCH_FILENAME**:STRING |
| The filename of the Qt Compressed Help file that will be generated when |
| ``-DLLVM_ENABLE_DOXYGEN=ON`` and |
| ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON`` are given. Defaults to |
| ``org.llvm.qch``. |
| This option is only useful in combination with |
| ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``; |
| otherwise this has no effect. |
| |
| **LLVM_DOXYGEN_QHP_NAMESPACE**:STRING |
| Namespace under which the intermediate Qt Help Project file lives. See `Qt |
| Help Project`_ |
| for more information. Defaults to "org.llvm". This option is only useful in |
| combination with ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``; otherwise |
| this has no effect. |
| |
| **LLVM_DOXYGEN_QHP_CUST_FILTER_NAME**:STRING |
| See `Qt Help Project`_ for |
| more information. Defaults to the CMake variable ``${PACKAGE_STRING}`` which |
| is a combination of the package name and version string. This filter can then |
| be used in Qt Creator to select only documentation from LLVM when browsing |
| through all the help files that you might have loaded. This option is only |
| useful in combination with ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``; |
| otherwise this has no effect. |
| |
| .. _Qt Help Project: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-filters |
| |
| **LLVM_DOXYGEN_QHELPGENERATOR_PATH**:STRING |
| The path to the ``qhelpgenerator`` executable. Defaults to whatever CMake's |
| ``find_program()`` can find. This option is only useful in combination with |
| ``-DLLVM_ENABLE_DOXYGEN_QT_HELP=ON``; otherwise this has no |
| effect. |
| |
| **LLVM_DOXYGEN_SVG**:BOOL |
| Uses .svg files instead of .png files for graphs in the Doxygen output. |
| Defaults to OFF. |
| |
| **LLVM_ENABLE_SPHINX**:BOOL |
| If enabled CMake will search for the ``sphinx-build`` executable and will make |
| the ``SPHINX_OUTPUT_HTML`` and ``SPHINX_OUTPUT_MAN`` CMake options available. |
| Defaults to OFF. |
| |
| **SPHINX_EXECUTABLE**:STRING |
| The path to the ``sphinx-build`` executable detected by CMake. |
| |
| **SPHINX_OUTPUT_HTML**:BOOL |
| If enabled (and ``LLVM_ENABLE_SPHINX`` is enabled) then the targets for |
| building the documentation as html are added (but not built by default unless |
| ``LLVM_BUILD_DOCS`` is enabled). There is a target for each project in the |
| source tree that uses sphinx (e.g. ``docs-llvm-html``, ``docs-clang-html`` |
| and ``docs-lld-html``). Defaults to ON. |
| |
| **SPHINX_OUTPUT_MAN**:BOOL |
| If enabled (and ``LLVM_ENABLE_SPHINX`` is enabled) the targets for building |
| the man pages are added (but not built by default unless ``LLVM_BUILD_DOCS`` |
| is enabled). Currently the only target added is ``docs-llvm-man``. Defaults |
| to ON. |
| |
| **SPHINX_WARNINGS_AS_ERRORS**:BOOL |
| If enabled then sphinx documentation warnings will be treated as |
| errors. Defaults to ON. |
| |
| Executing the test suite |
| ======================== |
| |
| Testing is performed when the *check* target is built. For instance, if you are |
| using makefiles, execute this command while on the top level of your build |
| directory: |
| |
| .. code-block:: console |
| |
| $ make check |
| |
| On Visual Studio, you may run tests to build the project "check". |
| |
| Cross compiling |
| =============== |
| |
| See `this wiki page <http://www.vtk.org/Wiki/CMake_Cross_Compiling>`_ for |
| generic instructions on how to cross-compile with CMake. It goes into detailed |
| explanations and may seem daunting, but it is not. On the wiki page there are |
| several examples including toolchain files. Go directly to `this section |
| <http://www.vtk.org/Wiki/CMake_Cross_Compiling#Information_how_to_set_up_various_cross_compiling_toolchains>`_ |
| for a quick solution. |
| |
| Also see the `LLVM-specific variables`_ section for variables used when |
| cross-compiling. |
| |
| Embedding LLVM in your project |
| ============================== |
| |
| From LLVM 3.5 onwards both the CMake and autoconf/Makefile build systems export |
| LLVM libraries as importable CMake targets. This means that clients of LLVM can |
| now reliably use CMake to develop their own LLVM based projects against an |
| installed version of LLVM regardless of how it was built. |
| |
| Here is a simple example of CMakeLists.txt file that imports the LLVM libraries |
| and uses them to build a simple application ``simple-tool``. |
| |
| .. code-block:: cmake |
| |
| cmake_minimum_required(VERSION 2.8.8) |
| project(SimpleProject) |
| |
| find_package(LLVM REQUIRED CONFIG) |
| |
| message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}") |
| message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}") |
| |
| # Set your project compile flags. |
| # E.g. if using the C++ header files |
| # you will need to enable C++11 support |
| # for your compiler. |
| |
| include_directories(${LLVM_INCLUDE_DIRS}) |
| add_definitions(${LLVM_DEFINITIONS}) |
| |
| # Now build our tools |
| add_executable(simple-tool tool.cpp) |
| |
| # Find the libraries that correspond to the LLVM components |
| # that we wish to use |
| llvm_map_components_to_libnames(llvm_libs support core irreader) |
| |
| # Link against LLVM libraries |
| target_link_libraries(simple-tool ${llvm_libs}) |
| |
| The ``find_package(...)`` directive when used in CONFIG mode (as in the above |
| example) will look for the ``LLVMConfig.cmake`` file in various locations (see |
| cmake manual for details). It creates a ``LLVM_DIR`` cache entry to save the |
| directory where ``LLVMConfig.cmake`` is found or allows the user to specify the |
| directory (e.g. by passing ``-DLLVM_DIR=/usr/share/llvm/cmake`` to |
| the ``cmake`` command or by setting it directly in ``ccmake`` or ``cmake-gui``). |
| |
| This file is available in two different locations. |
| |
| * ``<INSTALL_PREFIX>/share/llvm/cmake/LLVMConfig.cmake`` where |
| ``<INSTALL_PREFIX>`` is the install prefix of an installed version of LLVM. |
| On Linux typically this is ``/usr/share/llvm/cmake/LLVMConfig.cmake``. |
| |
| * ``<LLVM_BUILD_ROOT>/share/llvm/cmake/LLVMConfig.cmake`` where |
| ``<LLVM_BUILD_ROOT>`` is the root of the LLVM build tree. **Note this only |
| available when building LLVM with CMake** |
| |
| If LLVM is installed in your operating system's normal installation prefix (e.g. |
| on Linux this is usually ``/usr/``) ``find_package(LLVM ...)`` will |
| automatically find LLVM if it is installed correctly. If LLVM is not installed |
| or you wish to build directly against the LLVM build tree you can use |
| ``LLVM_DIR`` as previously mentioned. |
| |
| The ``LLVMConfig.cmake`` file sets various useful variables. Notable variables |
| include |
| |
| ``LLVM_CMAKE_DIR`` |
| The path to the LLVM CMake directory (i.e. the directory containing |
| LLVMConfig.cmake). |
| |
| ``LLVM_DEFINITIONS`` |
| A list of preprocessor defines that should be used when building against LLVM. |
| |
| ``LLVM_ENABLE_ASSERTIONS`` |
| This is set to ON if LLVM was built with assertions, otherwise OFF. |
| |
| ``LLVM_ENABLE_EH`` |
| This is set to ON if LLVM was built with exception handling (EH) enabled, |
| otherwise OFF. |
| |
| ``LLVM_ENABLE_RTTI`` |
| This is set to ON if LLVM was built with run time type information (RTTI), |
| otherwise OFF. |
| |
| ``LLVM_INCLUDE_DIRS`` |
| A list of include paths to directories containing LLVM header files. |
| |
| ``LLVM_PACKAGE_VERSION`` |
| The LLVM version. This string can be used with CMake conditionals. E.g. ``if |
| (${LLVM_PACKAGE_VERSION} VERSION_LESS "3.5")``. |
| |
| ``LLVM_TOOLS_BINARY_DIR`` |
| The path to the directory containing the LLVM tools (e.g. ``llvm-as``). |
| |
| Notice that in the above example we link ``simple-tool`` against several LLVM |
| libraries. The list of libraries is determined by using the |
| ``llvm_map_components_to_libnames()`` CMake function. For a list of available |
| components look at the output of running ``llvm-config --components``. |
| |
| Note that for LLVM < 3.5 ``llvm_map_components_to_libraries()`` was |
| used instead of ``llvm_map_components_to_libnames()``. This is now deprecated |
| and will be removed in a future version of LLVM. |
| |
| .. _cmake-out-of-source-pass: |
| |
| Developing LLVM passes out of source |
| ------------------------------------ |
| |
| It is possible to develop LLVM passes out of LLVM's source tree (i.e. against an |
| installed or built LLVM). An example of a project layout is provided below. |
| |
| .. code-block:: none |
| |
| <project dir>/ |
| | |
| CMakeLists.txt |
| <pass name>/ |
| | |
| CMakeLists.txt |
| Pass.cpp |
| ... |
| |
| Contents of ``<project dir>/CMakeLists.txt``: |
| |
| .. code-block:: cmake |
| |
| find_package(LLVM REQUIRED CONFIG) |
| |
| add_definitions(${LLVM_DEFINITIONS}) |
| include_directories(${LLVM_INCLUDE_DIRS}) |
| |
| add_subdirectory(<pass name>) |
| |
| Contents of ``<project dir>/<pass name>/CMakeLists.txt``: |
| |
| .. code-block:: cmake |
| |
| add_library(LLVMPassname MODULE Pass.cpp) |
| |
| Note if you intend for this pass to be merged into the LLVM source tree at some |
| point in the future it might make more sense to use LLVM's internal |
| add_llvm_loadable_module function instead by... |
| |
| |
| Adding the following to ``<project dir>/CMakeLists.txt`` (after |
| ``find_package(LLVM ...)``) |
| |
| .. code-block:: cmake |
| |
| list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}") |
| include(AddLLVM) |
| |
| And then changing ``<project dir>/<pass name>/CMakeLists.txt`` to |
| |
| .. code-block:: cmake |
| |
| add_llvm_loadable_module(LLVMPassname |
| Pass.cpp |
| ) |
| |
| When you are done developing your pass, you may wish to integrate it |
| into LLVM source tree. You can achieve it in two easy steps: |
| |
| #. Copying ``<pass name>`` folder into ``<LLVM root>/lib/Transform`` directory. |
| |
| #. Adding ``add_subdirectory(<pass name>)`` line into |
| ``<LLVM root>/lib/Transform/CMakeLists.txt``. |
| |
| Compiler/Platform-specific topics |
| ================================= |
| |
| Notes for specific compilers and/or platforms. |
| |
| Microsoft Visual C++ |
| -------------------- |
| |
| **LLVM_COMPILER_JOBS**:STRING |
| Specifies the maximum number of parallell compiler jobs to use per project |
| when building with msbuild or Visual Studio. Only supported for the Visual |
| Studio 2010 CMake generator. 0 means use all processors. Default is 0. |