llvm/CMakeLists.txt

   1 # See docs/CMake.html for instructions about how to build LLVM with CMake.
   2
   3 cmake_minimum_required(VERSION 3.4.3)
   4
   5 if ("${CMAKE_VERSION}" VERSION_LESS "3.13.4")
   6   message(WARNING
   7     "Your CMake version is ${CMAKE_VERSION}. Starting with LLVM 12.0.0, the "
   8     "minimum version of CMake required to build LLVM will become 3.13.4, and "
   9     "using an older CMake will become an error. Please upgrade your CMake to "
  10     "at least 3.13.4 now to avoid issues in the future!")
  11 endif()
  12
  13 if(POLICY CMP0068)
  14   cmake_policy(SET CMP0068 NEW)
  15   set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON)
  16 endif()
  17
  18 if(POLICY CMP0075)
  19   cmake_policy(SET CMP0075 NEW)
  20 endif()
  21
  22 if(POLICY CMP0077)
  23   cmake_policy(SET CMP0077 NEW)
  24 endif()
  25
  26 if(NOT DEFINED LLVM_VERSION_MAJOR)
  27   set(LLVM_VERSION_MAJOR 11)
  28 endif()
  29 if(NOT DEFINED LLVM_VERSION_MINOR)
  30   set(LLVM_VERSION_MINOR 0)
  31 endif()
  32 if(NOT DEFINED LLVM_VERSION_PATCH)
  33   set(LLVM_VERSION_PATCH 0)
  34 endif()
  35 if(NOT DEFINED LLVM_VERSION_SUFFIX)
  36   set(LLVM_VERSION_SUFFIX git)
  37 endif()
  38
  39 if (NOT PACKAGE_VERSION)
  40   set(PACKAGE_VERSION
  41     "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}${LLVM_VERSION_SUFFIX}")
  42 endif()
  43
  44 if ((CMAKE_GENERATOR MATCHES "Visual Studio") AND (CMAKE_GENERATOR_TOOLSET STREQUAL ""))
  45   message(WARNING "Visual Studio generators use the x86 host compiler by "
  46                   "default, even for 64-bit targets. This can result in linker "
  47                   "instability and out of memory errors. To use the 64-bit "
  48                   "host compiler, pass -Thost=x64 on the CMake command line.")
  49 endif()
  50
  51 if (CMAKE_GENERATOR STREQUAL "Xcode" AND NOT CMAKE_OSX_ARCHITECTURES)
  52   # Some CMake features like object libraries get confused if you don't
  53   # explicitly specify an architecture setting with the Xcode generator.
  54   set(CMAKE_OSX_ARCHITECTURES "x86_64")
  55 endif()
  56
  57 project(LLVM
  58   VERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}
  59   LANGUAGES C CXX ASM)
  60
  61 set(CMAKE_CXX_STANDARD 14 CACHE STRING "C++ standard to conform to")
  62 set(CMAKE_CXX_STANDARD_REQUIRED YES)
  63 set(CMAKE_CXX_EXTENSIONS NO)
  64
  65 if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
  66   message(STATUS "No build type selected, default to Debug")
  67   set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Build type (default Debug)" FORCE)
  68 endif()
  69
  70 # Side-by-side subprojects layout: automatically set the
  71 # LLVM_EXTERNAL_${project}_SOURCE_DIR using LLVM_ALL_PROJECTS
  72 # This allows an easy way of setting up a build directory for llvm and another
  73 # one for llvm+clang+... using the same sources.
  74 set(LLVM_ALL_PROJECTS "clang;clang-tools-extra;compiler-rt;debuginfo-tests;libc;libclc;libcxx;libcxxabi;libunwind;lld;lldb;mlir;openmp;parallel-libs;polly;pstl")
  75 # The flang project is not yet part of "all" projects (see C++ requirements)
  76 set(LLVM_EXTRA_PROJECTS "flang")
  77 # List of all known projects in the mono repo
  78 set(LLVM_KNOWN_PROJECTS "${LLVM_ALL_PROJECTS};${LLVM_EXTRA_PROJECTS}")
  79 set(LLVM_ENABLE_PROJECTS "" CACHE STRING
  80         "Semicolon-separated list of projects to build (${LLVM_KNOWN_PROJECTS}), or \"all\".")
  81 if( LLVM_ENABLE_PROJECTS STREQUAL "all" )
  82   set( LLVM_ENABLE_PROJECTS ${LLVM_ALL_PROJECTS})
  83 endif()
  84
  85 # LLVM_ENABLE_PROJECTS_USED is `ON` if the user has ever used the
  86 # `LLVM_ENABLE_PROJECTS` CMake cache variable.  This exists for
  87 # several reasons:
  88 #
  89 # * As an indicator that the `LLVM_ENABLE_PROJECTS` list is now the single
  90 # source of truth for which projects to build. This means we will ignore user
  91 # supplied `LLVM_TOOL_<project>_BUILD` CMake cache variables and overwrite
  92 # them.
  93 #
  94 # * The case where the user previously had `LLVM_ENABLE_PROJECTS` set to a
  95 # non-empty list but now the user wishes to disable building all other projects
  96 # by setting `LLVM_ENABLE_PROJECTS` to an empty string. In that case we still
  97 # need to set the `LLVM_TOOL_${upper_proj}_BUILD` variables so that we disable
  98 # building all the projects that were previously enabled.
  99 set(LLVM_ENABLE_PROJECTS_USED OFF CACHE BOOL "")
 100 mark_as_advanced(LLVM_ENABLE_PROJECTS_USED)
 101
 102 if (LLVM_ENABLE_PROJECTS_USED OR NOT LLVM_ENABLE_PROJECTS STREQUAL "")
 103   set(LLVM_ENABLE_PROJECTS_USED ON CACHE BOOL "" FORCE)
 104   foreach(proj ${LLVM_KNOWN_PROJECTS} ${LLVM_EXTERNAL_PROJECTS})
 105     string(TOUPPER "${proj}" upper_proj)
 106     string(REGEX REPLACE "-" "_" upper_proj ${upper_proj})
 107     if ("${proj}" IN_LIST LLVM_ENABLE_PROJECTS)
 108       message(STATUS "${proj} project is enabled")
 109       set(SHOULD_ENABLE_PROJECT TRUE)
 110       set(PROJ_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../${proj}")
 111       if(NOT EXISTS "${PROJ_DIR}" OR NOT IS_DIRECTORY "${PROJ_DIR}")
 112         message(FATAL_ERROR "LLVM_ENABLE_PROJECTS requests ${proj} but directory not found: ${PROJ_DIR}")
 113       endif()
 114       if( LLVM_EXTERNAL_${upper_proj}_SOURCE_DIR STREQUAL "" )
 115         set(LLVM_EXTERNAL_${upper_proj}_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../${proj}" CACHE PATH "" FORCE)
 116       else()
 117         set(LLVM_EXTERNAL_${upper_proj}_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../${proj}" CACHE PATH "")
 118       endif()
 119     elseif ("${proj}" IN_LIST LLVM_EXTERNAL_PROJECTS)
 120       message(STATUS "${proj} project is enabled")
 121       set(SHOULD_ENABLE_PROJECT TRUE)
 122     else()
 123       message(STATUS "${proj} project is disabled")
 124       set(SHOULD_ENABLE_PROJECT FALSE)
 125     endif()
 126     # Force `LLVM_TOOL_${upper_proj}_BUILD` variables to have values that
 127     # corresponds with `LLVM_ENABLE_PROJECTS`. This prevents the user setting
 128     # `LLVM_TOOL_${upper_proj}_BUILD` variables externally. At some point
 129     # we should deprecate allowing users to set these variables by turning them
 130     # into normal CMake variables rather than cache variables.
 131     set(LLVM_TOOL_${upper_proj}_BUILD
 132       ${SHOULD_ENABLE_PROJECT}
 133       CACHE
 134       BOOL "Whether to build ${upper_proj} as part of LLVM" FORCE
 135     )
 136   endforeach()
 137 endif()
 138 unset(SHOULD_ENABLE_PROJECT)
 139
 140 # Build llvm with ccache if the package is present
 141 set(LLVM_CCACHE_BUILD OFF CACHE BOOL "Set to ON for a ccache enabled build")
 142 if(LLVM_CCACHE_BUILD)
 143   find_program(CCACHE_PROGRAM ccache)
 144   if(CCACHE_PROGRAM)
 145       set(LLVM_CCACHE_MAXSIZE "" CACHE STRING "Size of ccache")
 146       set(LLVM_CCACHE_DIR "" CACHE STRING "Directory to keep ccached data")
 147       set(LLVM_CCACHE_PARAMS "CCACHE_CPP2=yes CCACHE_HASHDIR=yes"
 148           CACHE STRING "Parameters to pass through to ccache")
 149
 150       set(CCACHE_PROGRAM "${LLVM_CCACHE_PARAMS} ${CCACHE_PROGRAM}")
 151       if (LLVM_CCACHE_MAXSIZE)
 152         set(CCACHE_PROGRAM "CCACHE_MAXSIZE=${LLVM_CCACHE_MAXSIZE} ${CCACHE_PROGRAM}")
 153       endif()
 154       if (LLVM_CCACHE_DIR)
 155         set(CCACHE_PROGRAM "CCACHE_DIR=${LLVM_CCACHE_DIR} ${CCACHE_PROGRAM}")
 156       endif()
 157       set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_PROGRAM})
 158   else()
 159     message(FATAL_ERROR "Unable to find the program ccache. Set LLVM_CCACHE_BUILD to OFF")
 160   endif()
 161 endif()
 162
 163 option(LLVM_DEPENDENCY_DEBUGGING "Dependency debugging mode to verify correctly expressed library dependencies (Darwin only)" OFF)
 164
 165 # Some features of the LLVM build may be disallowed when dependency debugging is
 166 # enabled. In particular you cannot use ccache because we want to force compile
 167 # operations to always happen.
 168 if(LLVM_DEPENDENCY_DEBUGGING)
 169   if(NOT CMAKE_HOST_APPLE)
 170     message(FATAL_ERROR "Dependency debugging is only currently supported on Darwin hosts.")
 171   endif()
 172   if(LLVM_CCACHE_BUILD)
 173     message(FATAL_ERROR "Cannot enable dependency debugging while using ccache.")
 174   endif()
 175 endif()
 176
 177 option(LLVM_ENABLE_DAGISEL_COV "Debug: Prints tablegen patterns that were used for selecting" OFF)
 178 option(LLVM_ENABLE_GISEL_COV "Enable collection of GlobalISel rule coverage" OFF)
 179 if(LLVM_ENABLE_GISEL_COV)
 180   set(LLVM_GISEL_COV_PREFIX "${CMAKE_BINARY_DIR}/gisel-coverage-" CACHE STRING "Provide a filename prefix to collect the GlobalISel rule coverage")
 181 endif()
 182
 183 # Add path for custom modules
 184 set(CMAKE_MODULE_PATH
 185   ${CMAKE_MODULE_PATH}
 186   "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
 187   "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules"
 188   )
 189
 190 # Generate a CompilationDatabase (compile_commands.json file) for our build,
 191 # for use by clang_complete, YouCompleteMe, etc.
 192 set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
 193
 194 option(LLVM_INSTALL_BINUTILS_SYMLINKS
 195   "Install symlinks from the binutils tool names to the corresponding LLVM tools." OFF)
 196
 197 option(LLVM_INSTALL_CCTOOLS_SYMLINKS
 198   "Install symlinks from the cctools tool names to the corresponding LLVM tools." OFF)
 199
 200 option(LLVM_INSTALL_UTILS "Include utility binaries in the 'install' target." OFF)
 201
 202 option(LLVM_INSTALL_TOOLCHAIN_ONLY "Only include toolchain files in the 'install' target." OFF)
 203
 204 # Unfortunatly Clang is too eager to search directories for module maps, which can cause the
 205 # installed version of the maps to be found when building LLVM from source. Therefore we turn off
 206 # the installation by default. See llvm.org/PR31905.
 207 option(LLVM_INSTALL_MODULEMAPS "Install the modulemap files in the 'install' target." OFF)
 208
 209 option(LLVM_USE_FOLDERS "Enable solution folders in Visual Studio. Disable for Express versions." ON)
 210 if ( LLVM_USE_FOLDERS )
 211   set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 212 endif()
 213
 214 include(VersionFromVCS)
 215
 216 option(LLVM_APPEND_VC_REV
 217   "Embed the version control system revision in LLVM" ON)
 218
 219 set(PACKAGE_NAME LLVM)
 220 set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
 221 set(PACKAGE_BUGREPORT "https://bugs.llvm.org/")
 222
 223 set(BUG_REPORT_URL "${PACKAGE_BUGREPORT}" CACHE STRING
 224   "Default URL where bug reports are to be submitted.")
 225
 226 # Configure CPack.
 227 set(CPACK_PACKAGE_INSTALL_DIRECTORY "LLVM")
 228 set(CPACK_PACKAGE_VENDOR "LLVM")
 229 set(CPACK_PACKAGE_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
 230 set(CPACK_PACKAGE_VERSION_MINOR ${LLVM_VERSION_MINOR})
 231 set(CPACK_PACKAGE_VERSION_PATCH ${LLVM_VERSION_PATCH})
 232 set(CPACK_PACKAGE_VERSION ${PACKAGE_VERSION})
 233 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.TXT")
 234 set(CPACK_NSIS_COMPRESSOR "/SOLID lzma \r\n SetCompressorDictSize 32")
 235 if(WIN32 AND NOT UNIX)
 236   set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "LLVM")
 237   set(CPACK_PACKAGE_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\cmake\\\\nsis_logo.bmp")
 238   set(CPACK_NSIS_MUI_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\cmake\\\\nsis_icon.ico")
 239   set(CPACK_NSIS_MUI_UNIICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\cmake\\\\nsis_icon.ico")
 240   set(CPACK_NSIS_MODIFY_PATH "ON")
 241   set(CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL "ON")
 242   if( CMAKE_CL_64 )
 243     set(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES64")
 244   endif()
 245 endif()
 246 include(CPack)
 247
 248 # Sanity check our source directory to make sure that we are not trying to
 249 # generate an in-source build (unless on MSVC_IDE, where it is ok), and to make
 250 # sure that we don't have any stray generated files lying around in the tree
 251 # (which would end up getting picked up by header search, instead of the correct
 252 # versions).
 253 if( CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE )
 254   message(FATAL_ERROR "In-source builds are not allowed.
 255 Please create a directory and run cmake from there, passing the path
 256 to this source directory as the last argument.
 257 This process created the file `CMakeCache.txt' and the directory `CMakeFiles'.
 258 Please delete them.")
 259 endif()
 260
 261 string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 262
 263 if (CMAKE_BUILD_TYPE AND
 264     NOT uppercase_CMAKE_BUILD_TYPE MATCHES "^(DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL)$")
 265   message(FATAL_ERROR "Invalid value for CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
 266 endif()
 267
 268 set(LLVM_LIBDIR_SUFFIX "" CACHE STRING "Define suffix of library directory name (32/64)" )
 269
 270 set(LLVM_TOOLS_INSTALL_DIR "bin" CACHE STRING "Path for binary subdirectory (defaults to 'bin')")
 271 mark_as_advanced(LLVM_TOOLS_INSTALL_DIR)
 272
 273 set(LLVM_UTILS_INSTALL_DIR "${LLVM_TOOLS_INSTALL_DIR}" CACHE STRING
 274     "Path to install LLVM utilities (enabled by LLVM_INSTALL_UTILS=ON) (defaults to LLVM_TOOLS_INSTALL_DIR)")
 275 mark_as_advanced(LLVM_UTILS_INSTALL_DIR)
 276
 277 # They are used as destination of target generators.
 278 set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)
 279 set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
 280 if(WIN32 OR CYGWIN)
 281   # DLL platform -- put DLLs into bin.
 282   set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
 283 else()
 284   set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
 285 endif()
 286
 287 # Each of them corresponds to llvm-config's.
 288 set(LLVM_TOOLS_BINARY_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR}) # --bindir
 289 set(LLVM_LIBRARY_DIR      ${LLVM_LIBRARY_OUTPUT_INTDIR}) # --libdir
 290 set(LLVM_MAIN_SRC_DIR     ${CMAKE_CURRENT_SOURCE_DIR}  ) # --src-root
 291 set(LLVM_MAIN_INCLUDE_DIR ${LLVM_MAIN_SRC_DIR}/include ) # --includedir
 292 set(LLVM_BINARY_DIR       ${CMAKE_CURRENT_BINARY_DIR}  ) # --prefix
 293
 294 # Note: LLVM_CMAKE_PATH does not include generated files
 295 set(LLVM_CMAKE_PATH ${LLVM_MAIN_SRC_DIR}/cmake/modules)
 296 set(LLVM_EXAMPLES_BINARY_DIR ${LLVM_BINARY_DIR}/examples)
 297 set(LLVM_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/include)
 298
 299 # List of all targets to be built by default:
 300 set(LLVM_ALL_TARGETS
 301   AArch64
 302   AMDGPU
 303   ARM
 304   AVR
 305   BPF
 306   Hexagon
 307   Lanai
 308   Mips
 309   MSP430
 310   NVPTX
 311   PowerPC
 312   RISCV
 313   Sparc
 314   SystemZ
 315   WebAssembly
 316   X86
 317   XCore
 318   )
 319
 320 # List of targets with JIT support:
 321 set(LLVM_TARGETS_WITH_JIT X86 PowerPC AArch64 ARM Mips SystemZ)
 322
 323 set(LLVM_TARGETS_TO_BUILD "all"
 324     CACHE STRING "Semicolon-separated list of targets to build, or \"all\".")
 325
 326 set(LLVM_EXPERIMENTAL_TARGETS_TO_BUILD ""
 327   CACHE STRING "Semicolon-separated list of experimental targets to build.")
 328
 329 option(BUILD_SHARED_LIBS
 330   "Build all libraries as shared libraries instead of static" OFF)
 331
 332 option(LLVM_ENABLE_BACKTRACES "Enable embedding backtraces on crash." ON)
 333 if(LLVM_ENABLE_BACKTRACES)
 334   set(ENABLE_BACKTRACES 1)
 335 endif()
 336
 337 option(LLVM_ENABLE_UNWIND_TABLES "Emit unwind tables for the libraries" ON)
 338
 339 option(LLVM_ENABLE_CRASH_OVERRIDES "Enable crash overrides." ON)
 340 if(LLVM_ENABLE_CRASH_OVERRIDES)
 341   set(ENABLE_CRASH_OVERRIDES 1)
 342 endif()
 343
 344 option(LLVM_ENABLE_CRASH_DUMPS "Turn on memory dumps on crashes. Currently only implemented on Windows." OFF)
 345
 346 option(LLVM_ENABLE_FFI "Use libffi to call external functions from the interpreter" OFF)
 347 set(FFI_LIBRARY_DIR "" CACHE PATH "Additional directory, where CMake should search for libffi.so")
 348 set(FFI_INCLUDE_DIR "" CACHE PATH "Additional directory, where CMake should search for ffi.h or ffi/ffi.h")
 349
 350 set(LLVM_TARGET_ARCH "host"
 351   CACHE STRING "Set target to use for LLVM JIT or use \"host\" for automatic detection.")
 352
 353 option(LLVM_ENABLE_TERMINFO "Use terminfo database if available." ON)
 354
 355 set(LLVM_ENABLE_LIBXML2 "ON" CACHE STRING "Use libxml2 if available. Can be ON, OFF, or FORCE_ON")
 356
 357 option(LLVM_ENABLE_LIBEDIT "Use libedit if available." ON)
 358
 359 option(LLVM_ENABLE_LIBPFM "Use libpfm for performance counters if available." ON)
 360
 361 option(LLVM_ENABLE_THREADS "Use threads if available." ON)
 362
 363 set(LLVM_ENABLE_ZLIB "ON" CACHE STRING "Use zlib for compression/decompression if available. Can be ON, OFF, or FORCE_ON")
 364
 365 set(LLVM_Z3_INSTALL_DIR "" CACHE STRING "Install directory of the Z3 solver.")
 366
 367 find_package(Z3 4.7.1)
 368
 369 if (LLVM_Z3_INSTALL_DIR)
 370   if (NOT Z3_FOUND)
 371     message(FATAL_ERROR "Z3 >= 4.7.1 has not been found in LLVM_Z3_INSTALL_DIR: ${LLVM_Z3_INSTALL_DIR}.")
 372   endif()
 373 endif()
 374
 375 set(LLVM_ENABLE_Z3_SOLVER_DEFAULT "${Z3_FOUND}")
 376
 377 option(LLVM_ENABLE_Z3_SOLVER
 378   "Enable Support for the Z3 constraint solver in LLVM."
 379   ${LLVM_ENABLE_Z3_SOLVER_DEFAULT}
 380 )
 381
 382 if (LLVM_ENABLE_Z3_SOLVER)
 383   if (NOT Z3_FOUND)
 384     message(FATAL_ERROR "LLVM_ENABLE_Z3_SOLVER cannot be enabled when Z3 is not available.")
 385   endif()
 386
 387   set(LLVM_WITH_Z3 1)
 388 endif()
 389
 390 if( LLVM_TARGETS_TO_BUILD STREQUAL "all" )
 391   set( LLVM_TARGETS_TO_BUILD ${LLVM_ALL_TARGETS} )
 392 endif()
 393
 394 set(LLVM_TARGETS_TO_BUILD
 395    ${LLVM_TARGETS_TO_BUILD}
 396    ${LLVM_EXPERIMENTAL_TARGETS_TO_BUILD})
 397 list(REMOVE_DUPLICATES LLVM_TARGETS_TO_BUILD)
 398
 399 option(LLVM_ENABLE_PIC "Build Position-Independent Code" ON)
 400 option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)
 401 option(LLVM_ENABLE_MODULES "Compile with C++ modules enabled." OFF)
 402 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 403   option(LLVM_ENABLE_MODULE_DEBUGGING "Compile with -gmodules." ON)
 404 else()
 405   option(LLVM_ENABLE_MODULE_DEBUGGING "Compile with -gmodules." OFF)
 406 endif()
 407 option(LLVM_ENABLE_LOCAL_SUBMODULE_VISIBILITY "Compile with -fmodules-local-submodule-visibility." ON)
 408 option(LLVM_ENABLE_LIBCXX "Use libc++ if available." OFF)
 409 option(LLVM_STATIC_LINK_CXX_STDLIB "Statically link the standard library." OFF)
 410 option(LLVM_ENABLE_LLD "Use lld as C and C++ linker." OFF)
 411 option(LLVM_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
 412 option(LLVM_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
 413
 414 option(LLVM_ENABLE_DUMP "Enable dump functions even when assertions are disabled" OFF)
 415
 416 if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
 417   option(LLVM_ENABLE_ASSERTIONS "Enable assertions" OFF)
 418 else()
 419   option(LLVM_ENABLE_ASSERTIONS "Enable assertions" ON)
 420 endif()
 421
 422 option(LLVM_ENABLE_EXPENSIVE_CHECKS "Enable expensive checks" OFF)
 423
 424 # While adding scalable vector support to LLVM, we temporarily want to
 425 # allow an implicit conversion of TypeSize to uint64_t, and to allow
 426 # code to get the fixed number of elements from a possibly scalable vector.
 427 # This CMake flag enables a more strict mode where it asserts that the type
 428 # is not a scalable vector type.
 429 #
 430 # Enabling this flag makes it easier to find cases where the compiler makes
 431 # assumptions on the size being 'fixed size', when building tests for
 432 # SVE/SVE2 or other scalable vector architectures.
 433 option(LLVM_ENABLE_STRICT_FIXED_SIZE_VECTORS
 434        "Enable assertions that type is not scalable in implicit conversion from TypeSize to uint64_t and calls to getNumElements" OFF)
 435
 436 set(LLVM_ABI_BREAKING_CHECKS "WITH_ASSERTS" CACHE STRING
 437   "Enable abi-breaking checks.  Can be WITH_ASSERTS, FORCE_ON or FORCE_OFF.")
 438
 439 option(LLVM_FORCE_USE_OLD_TOOLCHAIN
 440        "Set to ON to force using an old, unsupported host toolchain." OFF)
 441
 442 option(LLVM_TEMPORARILY_ALLOW_OLD_TOOLCHAIN
 443        "Set to ON to only warn when using a toolchain which is about to be deprecated, instead of emitting an error." OFF)
 444
 445 option(LLVM_USE_INTEL_JITEVENTS
 446   "Use Intel JIT API to inform Intel(R) VTune(TM) Amplifier XE 2011 about JIT code"
 447   OFF)
 448
 449 if( LLVM_USE_INTEL_JITEVENTS )
 450   # Verify we are on a supported platform
 451   if( NOT CMAKE_SYSTEM_NAME MATCHES "Windows" AND NOT CMAKE_SYSTEM_NAME MATCHES "Linux" )
 452     message(FATAL_ERROR
 453       "Intel JIT API support is available on Linux and Windows only.")
 454   endif()
 455 endif( LLVM_USE_INTEL_JITEVENTS )
 456
 457 option(LLVM_USE_OPROFILE
 458   "Use opagent JIT interface to inform OProfile about JIT code" OFF)
 459
 460 option(LLVM_EXTERNALIZE_DEBUGINFO
 461   "Generate dSYM files and strip executables and libraries (Darwin Only)" OFF)
 462
 463 set(LLVM_CODESIGNING_IDENTITY "" CACHE STRING
 464   "Sign executables and dylibs with the given identity or skip if empty (Darwin Only)")
 465
 466 # If enabled, verify we are on a platform that supports oprofile.
 467 if( LLVM_USE_OPROFILE )
 468   if( NOT CMAKE_SYSTEM_NAME MATCHES "Linux" )
 469     message(FATAL_ERROR "OProfile support is available on Linux only.")
 470   endif( NOT CMAKE_SYSTEM_NAME MATCHES "Linux" )
 471 endif( LLVM_USE_OPROFILE )
 472
 473 option(LLVM_USE_PERF
 474   "Use perf JIT interface to inform perf about JIT code" OFF)
 475
 476 # If enabled, verify we are on a platform that supports perf.
 477 if( LLVM_USE_PERF )
 478   if( NOT CMAKE_SYSTEM_NAME MATCHES "Linux" )
 479     message(FATAL_ERROR "perf support is available on Linux only.")
 480   endif( NOT CMAKE_SYSTEM_NAME MATCHES "Linux" )
 481 endif( LLVM_USE_PERF )
 482
 483 set(LLVM_USE_SANITIZER "" CACHE STRING
 484   "Define the sanitizer used to build binaries and tests.")
 485 option(LLVM_OPTIMIZE_SANITIZED_BUILDS "Pass -O1 on debug sanitizer builds" ON)
 486 set(LLVM_LIB_FUZZING_ENGINE "" CACHE PATH
 487   "Path to fuzzing library for linking with fuzz targets")
 488
 489 option(LLVM_USE_SPLIT_DWARF
 490   "Use -gsplit-dwarf when compiling llvm." OFF)
 491
 492 # Define an option controlling whether we should build for 32-bit on 64-bit
 493 # platforms, where supported.
 494 if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT (WIN32 OR ${CMAKE_SYSTEM_NAME} MATCHES "AIX"))
 495   # TODO: support other platforms and toolchains.
 496   option(LLVM_BUILD_32_BITS "Build 32 bits executables and libraries." OFF)
 497 endif()
 498
 499 # Define the default arguments to use with 'lit', and an option for the user to
 500 # override.
 501 set(LIT_ARGS_DEFAULT "-sv")
 502 if (MSVC_IDE OR XCODE)
 503   set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
 504 endif()
 505 set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
 506
 507 # On Win32 hosts, provide an option to specify the path to the GnuWin32 tools.
 508 if( WIN32 AND NOT CYGWIN )
 509   set(LLVM_LIT_TOOLS_DIR "" CACHE PATH "Path to GnuWin32 tools")
 510 endif()
 511
 512 # Define options to control the inclusion and default build behavior for
 513 # components which may not strictly be necessary (tools, examples, and tests).
 514 #
 515 # This is primarily to support building smaller or faster project files.
 516 option(LLVM_INCLUDE_TOOLS "Generate build targets for the LLVM tools." ON)
 517 option(LLVM_BUILD_TOOLS
 518   "Build the LLVM tools. If OFF, just generate build targets." ON)
 519
 520 option(LLVM_INCLUDE_UTILS "Generate build targets for the LLVM utils." ON)
 521 option(LLVM_BUILD_UTILS
 522   "Build LLVM utility binaries. If OFF, just generate build targets." ON)
 523
 524 option(LLVM_INCLUDE_RUNTIMES "Generate build targets for the LLVM runtimes." ON)
 525 option(LLVM_BUILD_RUNTIMES
 526   "Build the LLVM runtimes. If OFF, just generate build targets." ON)
 527
 528 option(LLVM_BUILD_RUNTIME
 529   "Build the LLVM runtime libraries." ON)
 530 option(LLVM_BUILD_EXAMPLES
 531   "Build the LLVM example programs. If OFF, just generate build targets." OFF)
 532 option(LLVM_INCLUDE_EXAMPLES "Generate build targets for the LLVM examples" ON)
 533
 534 if(LLVM_BUILD_EXAMPLES)
 535   add_definitions(-DBUILD_EXAMPLES)
 536 endif(LLVM_BUILD_EXAMPLES)
 537
 538 option(LLVM_BUILD_TESTS
 539   "Build LLVM unit tests. If OFF, just generate build targets." OFF)
 540 option(LLVM_INCLUDE_TESTS "Generate build targets for the LLVM unit tests." ON)
 541 option(LLVM_INCLUDE_GO_TESTS "Include the Go bindings tests in test build targets." ON)
 542
 543 option(LLVM_BUILD_BENCHMARKS "Add LLVM benchmark targets to the list of default
 544 targets. If OFF, benchmarks still could be built using Benchmarks target." OFF)
 545 option(LLVM_INCLUDE_BENCHMARKS "Generate benchmark targets. If OFF, benchmarks can't be built." ON)
 546
 547 option (LLVM_BUILD_DOCS "Build the llvm documentation." OFF)
 548 option (LLVM_INCLUDE_DOCS "Generate build targets for llvm documentation." ON)
 549 option (LLVM_ENABLE_DOXYGEN "Use doxygen to generate llvm API documentation." OFF)
 550 option (LLVM_ENABLE_SPHINX "Use Sphinx to generate llvm documentation." OFF)
 551 option (LLVM_ENABLE_OCAMLDOC "Build OCaml bindings documentation." ON)
 552 option (LLVM_ENABLE_BINDINGS "Build bindings." ON)
 553
 554 set(LLVM_INSTALL_DOXYGEN_HTML_DIR "share/doc/llvm/doxygen-html"
 555     CACHE STRING "Doxygen-generated HTML documentation install directory")
 556 set(LLVM_INSTALL_OCAMLDOC_HTML_DIR "share/doc/llvm/ocaml-html"
 557     CACHE STRING "OCamldoc-generated HTML documentation install directory")
 558
 559 option (LLVM_BUILD_EXTERNAL_COMPILER_RT
 560   "Build compiler-rt as an external project." OFF)
 561
 562 option (LLVM_VERSION_PRINTER_SHOW_HOST_TARGET_INFO
 563   "Show target and host info when tools are invoked with --version." ON)
 564
 565 # You can configure which libraries from LLVM you want to include in the
 566 # shared library by setting LLVM_DYLIB_COMPONENTS to a semi-colon delimited
 567 # list of LLVM components. All component names handled by llvm-config are valid.
 568 if(NOT DEFINED LLVM_DYLIB_COMPONENTS)
 569   set(LLVM_DYLIB_COMPONENTS "all" CACHE STRING
 570     "Semicolon-separated list of components to include in libLLVM, or \"all\".")
 571 endif()
 572
 573 if(MSVC)
 574   option(LLVM_BUILD_LLVM_C_DYLIB "Build LLVM-C.dll (Windows only)" ON)
 575   # Set this variable to OFF here so it can't be set with a command-line
 576   # argument.
 577   set (LLVM_LINK_LLVM_DYLIB OFF)
 578   if (BUILD_SHARED_LIBS)
 579     message(FATAL_ERROR "BUILD_SHARED_LIBS options is not supported on Windows.")
 580   endif()
 581 else()
 582   option(LLVM_LINK_LLVM_DYLIB "Link tools against the libllvm dynamic library" OFF)
 583   option(LLVM_BUILD_LLVM_C_DYLIB "Build libllvm-c re-export library (Darwin only)" OFF)
 584   set(LLVM_BUILD_LLVM_DYLIB_default OFF)
 585   if(LLVM_LINK_LLVM_DYLIB OR LLVM_BUILD_LLVM_C_DYLIB)
 586     set(LLVM_BUILD_LLVM_DYLIB_default ON)
 587   endif()
 588   option(LLVM_BUILD_LLVM_DYLIB "Build libllvm dynamic library" ${LLVM_BUILD_LLVM_DYLIB_default})
 589 endif()
 590
 591 if (LLVM_LINK_LLVM_DYLIB AND BUILD_SHARED_LIBS)
 592   message(FATAL_ERROR "Cannot enable BUILD_SHARED_LIBS with LLVM_LINK_LLVM_DYLIB.  We recommend disabling BUILD_SHARED_LIBS.")
 593 endif()
 594
 595 option(LLVM_OPTIMIZED_TABLEGEN "Force TableGen to be built with optimization" OFF)
 596 if(CMAKE_CROSSCOMPILING OR (LLVM_OPTIMIZED_TABLEGEN AND (LLVM_ENABLE_ASSERTIONS OR CMAKE_CONFIGURATION_TYPES)))
 597   set(LLVM_USE_HOST_TOOLS ON)
 598 endif()
 599
 600 if (MSVC_IDE)
 601   option(LLVM_ADD_NATIVE_VISUALIZERS_TO_SOLUTION "Configure project to use Visual Studio native visualizers" TRUE)
 602 endif()
 603
 604 if (LLVM_BUILD_INSTRUMENTED OR LLVM_BUILD_INSTRUMENTED_COVERAGE OR
 605     LLVM_ENABLE_IR_PGO)
 606   if(NOT LLVM_PROFILE_MERGE_POOL_SIZE)
 607     # A pool size of 1-2 is probably sufficient on a SSD. 3-4 should be fine
 608     # for spining disks. Anything higher may only help on slower mediums.
 609     set(LLVM_PROFILE_MERGE_POOL_SIZE "4")
 610   endif()
 611   if(NOT LLVM_PROFILE_FILE_PATTERN)
 612     if(NOT LLVM_PROFILE_DATA_DIR)
 613       file(TO_NATIVE_PATH "${LLVM_BINARY_DIR}/profiles" LLVM_PROFILE_DATA_DIR)
 614     endif()
 615     file(TO_NATIVE_PATH "${LLVM_PROFILE_DATA_DIR}/%${LLVM_PROFILE_MERGE_POOL_SIZE}m.profraw" LLVM_PROFILE_FILE_PATTERN)
 616   endif()
 617   if(NOT LLVM_CSPROFILE_FILE_PATTERN)
 618     if(NOT LLVM_CSPROFILE_DATA_DIR)
 619       file(TO_NATIVE_PATH "${LLVM_BINARY_DIR}/csprofiles" LLVM_CSPROFILE_DATA_DIR)
 620     endif()
 621     file(TO_NATIVE_PATH "${LLVM_CSPROFILE_DATA_DIR}/%${LLVM_PROFILE_MERGE_POOL_SIZE}m.profraw" LLVM_CSPROFILE_FILE_PATTERN)
 622   endif()
 623 endif()
 624
 625 if (LLVM_BUILD_STATIC)
 626   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
 627 endif()
 628
 629 # Use libtool instead of ar if you are both on an Apple host, and targeting Apple.
 630 if(CMAKE_HOST_APPLE AND APPLE)
 631   include(UseLibtool)
 632 endif()
 633
 634 # Override the default target with an environment variable named by LLVM_TARGET_TRIPLE_ENV.
 635 set(LLVM_TARGET_TRIPLE_ENV CACHE STRING "The name of environment variable to override default target. Disabled by blank.")
 636 mark_as_advanced(LLVM_TARGET_TRIPLE_ENV)
 637
 638 set(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR OFF CACHE BOOL
 639   "Enable per-target runtimes directory")
 640
 641 set(LLVM_PROFDATA_FILE "" CACHE FILEPATH
 642   "Profiling data file to use when compiling in order to improve runtime performance.")
 643
 644 # All options referred to from HandleLLVMOptions have to be specified
 645 # BEFORE this include, otherwise options will not be correctly set on
 646 # first cmake run
 647 include(config-ix)
 648
 649 string(REPLACE "Native" ${LLVM_NATIVE_ARCH}
 650   LLVM_TARGETS_TO_BUILD "${LLVM_TARGETS_TO_BUILD}")
 651 list(REMOVE_DUPLICATES LLVM_TARGETS_TO_BUILD)
 652
 653 # By default, we target the host, but this can be overridden at CMake
 654 # invocation time.
 655 set(LLVM_DEFAULT_TARGET_TRIPLE "${LLVM_HOST_TRIPLE}" CACHE STRING
 656   "Default target for which LLVM will generate code." )
 657 set(TARGET_TRIPLE "${LLVM_DEFAULT_TARGET_TRIPLE}")
 658 message(STATUS "LLVM host triple: ${LLVM_HOST_TRIPLE}")
 659 message(STATUS "LLVM default target triple: ${LLVM_DEFAULT_TARGET_TRIPLE}")
 660
 661 if(WIN32 OR CYGWIN)
 662   if(BUILD_SHARED_LIBS OR LLVM_BUILD_LLVM_DYLIB)
 663     set(LLVM_ENABLE_PLUGINS_default ON)
 664   else()
 665     set(LLVM_ENABLE_PLUGINS_default OFF)
 666   endif()
 667 else()
 668   set(LLVM_ENABLE_PLUGINS_default ${LLVM_ENABLE_PIC})
 669 endif()
 670 option(LLVM_ENABLE_PLUGINS "Enable plugin support" ${LLVM_ENABLE_PLUGINS_default})
 671
 672 include(HandleLLVMOptions)
 673
 674 if(CMAKE_VERSION VERSION_LESS 3.12)
 675   include(FindPythonInterp)
 676   if( NOT PYTHONINTERP_FOUND )
 677     message(FATAL_ERROR
 678   "Unable to find Python interpreter, required for builds and testing.
 679
 680   Please install Python or specify the PYTHON_EXECUTABLE CMake variable.")
 681   endif()
 682
 683   if( ${PYTHON_VERSION_STRING} VERSION_LESS 2.7 )
 684     message(FATAL_ERROR "Python 2.7 or newer is required")
 685   endif()
 686
 687   add_executable(Python3::Interpreter IMPORTED)
 688   set_target_properties(Python3::Interpreter PROPERTIES
 689     IMPORTED_LOCATION ${PYTHON_EXECUTABLE})
 690   set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE})
 691 else()
 692   find_package(Python3 COMPONENTS Interpreter)
 693   if(NOT Python3_Interpreter_FOUND)
 694     message(WARNING "Python3 not found, using python2 as a fallback")
 695     find_package(Python2 COMPONENTS Interpreter REQUIRED)
 696     if(Python2_VERSION VERSION_LESS 2.7)
 697       message(SEND_ERROR "Python 2.7 or newer is required")
 698     endif()
 699
 700     # Treat python2 as python3
 701     add_executable(Python3::Interpreter IMPORTED)
 702     set_target_properties(Python3::Interpreter PROPERTIES
 703       IMPORTED_LOCATION ${Python2_EXECUTABLE})
 704     set(Python3_EXECUTABLE ${Python2_EXECUTABLE})
 705   endif()
 706 endif()
 707
 708 ######
 709 # LLVMBuild Integration
 710 #
 711 # We use llvm-build to generate all the data required by the CMake based
 712 # build system in one swoop:
 713 #
 714 #  - We generate a file (a CMake fragment) in the object root which contains
 715 #    all the definitions that are required by CMake.
 716 #
 717 #  - We generate the library table used by llvm-config.
 718 #
 719 #  - We generate the dependencies for the CMake fragment, so that we will
 720 #    automatically reconfigure ourselves.
 721
 722 set(LLVMBUILDTOOL "${LLVM_MAIN_SRC_DIR}/utils/llvm-build/llvm-build")
 723 set(LLVMCONFIGLIBRARYDEPENDENCIESINC
 724   "${LLVM_BINARY_DIR}/tools/llvm-config/LibraryDependencies.inc")
 725 set(LLVMBUILDCMAKEFRAG
 726   "${LLVM_BINARY_DIR}/LLVMBuild.cmake")
 727
 728 # Create the list of optional components that are enabled
 729 if (LLVM_USE_INTEL_JITEVENTS)
 730   set(LLVMOPTIONALCOMPONENTS IntelJITEvents)
 731 endif (LLVM_USE_INTEL_JITEVENTS)
 732 if (LLVM_USE_OPROFILE)
 733   set(LLVMOPTIONALCOMPONENTS ${LLVMOPTIONALCOMPONENTS} OProfileJIT)
 734 endif (LLVM_USE_OPROFILE)
 735 if (LLVM_USE_PERF)
 736   set(LLVMOPTIONALCOMPONENTS ${LLVMOPTIONALCOMPONENTS} PerfJITEvents)
 737 endif (LLVM_USE_PERF)
 738
 739 message(STATUS "Constructing LLVMBuild project information")
 740 execute_process(
 741   COMMAND "${Python3_EXECUTABLE}" -B ${LLVMBUILDTOOL}
 742             --native-target "${LLVM_NATIVE_ARCH}"
 743             --enable-targets "${LLVM_TARGETS_TO_BUILD}"
 744             --enable-optional-components "${LLVMOPTIONALCOMPONENTS}"
 745             --write-library-table ${LLVMCONFIGLIBRARYDEPENDENCIESINC}
 746             --write-cmake-fragment ${LLVMBUILDCMAKEFRAG}
 747             OUTPUT_VARIABLE LLVMBUILDOUTPUT
 748             ERROR_VARIABLE LLVMBUILDERRORS
 749             OUTPUT_STRIP_TRAILING_WHITESPACE
 750             ERROR_STRIP_TRAILING_WHITESPACE
 751   RESULT_VARIABLE LLVMBUILDRESULT)
 752
 753 # On Win32, CMake doesn't properly handle piping the default output/error
 754 # streams into the GUI console. So, we explicitly catch and report them.
 755 if( NOT "${LLVMBUILDOUTPUT}" STREQUAL "")
 756   message(STATUS "llvm-build output: ${LLVMBUILDOUTPUT}")
 757 endif()
 758 if( NOT "${LLVMBUILDRESULT}" STREQUAL "0" )
 759   message(FATAL_ERROR
 760     "Unexpected failure executing llvm-build: ${LLVMBUILDERRORS}")
 761 endif()
 762
 763 # Include the generated CMake fragment. This will define properties from the
 764 # LLVMBuild files in a format which is easy to consume from CMake, and will add
 765 # the dependencies so that CMake will reconfigure properly when the LLVMBuild
 766 # files change.
 767 include(${LLVMBUILDCMAKEFRAG})
 768
 769 ######
 770
 771 # Configure all of the various header file fragments LLVM uses which depend on
 772 # configuration variables.
 773 set(LLVM_ENUM_TARGETS "")
 774 set(LLVM_ENUM_ASM_PRINTERS "")
 775 set(LLVM_ENUM_ASM_PARSERS "")
 776 set(LLVM_ENUM_DISASSEMBLERS "")
 777 foreach(t ${LLVM_TARGETS_TO_BUILD})
 778   set( td ${LLVM_MAIN_SRC_DIR}/lib/Target/${t} )
 779
 780   list(FIND LLVM_ALL_TARGETS ${t} idx)
 781   list(FIND LLVM_EXPERIMENTAL_TARGETS_TO_BUILD ${t} idy)
 782   # At this point, LLVMBUILDTOOL already checked all the targets passed in
 783   # LLVM_TARGETS_TO_BUILD and LLVM_EXPERIMENTAL_TARGETS_TO_BUILD, so
 784   # this test just makes sure that any experimental targets were passed via
 785   # LLVM_EXPERIMENTAL_TARGETS_TO_BUILD, not LLVM_TARGETS_TO_BUILD.
 786   if( idx LESS 0 AND idy LESS 0 )
 787     message(FATAL_ERROR "The target `${t}' is experimental and must be passed "
 788       "via LLVM_EXPERIMENTAL_TARGETS_TO_BUILD.")
 789   else()
 790     set(LLVM_ENUM_TARGETS "${LLVM_ENUM_TARGETS}LLVM_TARGET(${t})\n")
 791   endif()
 792
 793   file(GLOB asmp_file "${td}/*AsmPrinter.cpp")
 794   if( asmp_file )
 795     set(LLVM_ENUM_ASM_PRINTERS
 796       "${LLVM_ENUM_ASM_PRINTERS}LLVM_ASM_PRINTER(${t})\n")
 797   endif()
 798   if( EXISTS ${td}/AsmParser/CMakeLists.txt )
 799     set(LLVM_ENUM_ASM_PARSERS
 800       "${LLVM_ENUM_ASM_PARSERS}LLVM_ASM_PARSER(${t})\n")
 801   endif()
 802   if( EXISTS ${td}/Disassembler/CMakeLists.txt )
 803     set(LLVM_ENUM_DISASSEMBLERS
 804       "${LLVM_ENUM_DISASSEMBLERS}LLVM_DISASSEMBLER(${t})\n")
 805   endif()
 806 endforeach(t)
 807
 808 # Produce the target definition files, which provide a way for clients to easily
 809 # include various classes of targets.
 810 configure_file(
 811   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Config/AsmPrinters.def.in
 812   ${LLVM_INCLUDE_DIR}/llvm/Config/AsmPrinters.def
 813   )
 814 configure_file(
 815   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Config/AsmParsers.def.in
 816   ${LLVM_INCLUDE_DIR}/llvm/Config/AsmParsers.def
 817   )
 818 configure_file(
 819   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Config/Disassemblers.def.in
 820   ${LLVM_INCLUDE_DIR}/llvm/Config/Disassemblers.def
 821   )
 822 configure_file(
 823   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Config/Targets.def.in
 824   ${LLVM_INCLUDE_DIR}/llvm/Config/Targets.def
 825   )
 826
 827 # Configure the three LLVM configuration header files.
 828 configure_file(
 829   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Config/config.h.cmake
 830   ${LLVM_INCLUDE_DIR}/llvm/Config/config.h)
 831 configure_file(
 832   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Config/llvm-config.h.cmake
 833   ${LLVM_INCLUDE_DIR}/llvm/Config/llvm-config.h)
 834 configure_file(
 835   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Config/abi-breaking.h.cmake
 836   ${LLVM_INCLUDE_DIR}/llvm/Config/abi-breaking.h)
 837
 838 # Add target for generating source rpm package.
 839 set(LLVM_SRPM_USER_BINARY_SPECFILE ${CMAKE_CURRENT_SOURCE_DIR}/llvm.spec.in
 840     CACHE FILEPATH ".spec file to use for srpm generation")
 841 set(LLVM_SRPM_BINARY_SPECFILE ${CMAKE_CURRENT_BINARY_DIR}/llvm.spec)
 842 set(LLVM_SRPM_DIR "${CMAKE_CURRENT_BINARY_DIR}/srpm")
 843
 844 get_source_info(${CMAKE_CURRENT_SOURCE_DIR} revision repository)
 845 string(LENGTH "${revision}" revision_length)
 846 set(LLVM_RPM_SPEC_REVISION "${revision}")
 847
 848 configure_file(
 849   ${LLVM_SRPM_USER_BINARY_SPECFILE}
 850   ${LLVM_SRPM_BINARY_SPECFILE} @ONLY)
 851
 852 add_custom_target(srpm
 853   COMMAND cpack -G TGZ --config CPackSourceConfig.cmake -B ${LLVM_SRPM_DIR}/SOURCES
 854   COMMAND rpmbuild -bs --define '_topdir ${LLVM_SRPM_DIR}' ${LLVM_SRPM_BINARY_SPECFILE})
 855 set_target_properties(srpm PROPERTIES FOLDER "Misc")
 856
 857
 858 # They are not referenced. See set_output_directory().
 859 set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/bin )
 860 set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
 861 set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
 862
 863 if(APPLE AND DARWIN_LTO_LIBRARY)
 864   set(CMAKE_EXE_LINKER_FLAGS
 865     "${CMAKE_EXE_LINKER_FLAGS} -Wl,-lto_library -Wl,${DARWIN_LTO_LIBRARY}")
 866   set(CMAKE_SHARED_LINKER_FLAGS
 867     "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-lto_library -Wl,${DARWIN_LTO_LIBRARY}")
 868   set(CMAKE_MODULE_LINKER_FLAGS
 869     "${CMAKE_MODULE_LINKER_FLAGS} -Wl,-lto_library -Wl,${DARWIN_LTO_LIBRARY}")
 870 endif()
 871
 872 # Build with _XOPEN_SOURCE on AIX, as stray macros in _ALL_SOURCE mode tend to
 873 # break things. In this case we need to enable the large-file API as well.
 874 if (UNIX AND ${CMAKE_SYSTEM_NAME} MATCHES "AIX")
 875           add_definitions("-D_XOPEN_SOURCE=700")
 876           add_definitions("-D_LARGE_FILE_API")
 877
 878   # CMake versions less than 3.16 set default linker flags to include -brtl, as
 879   # well as setting -G when building libraries, so clear them out. Note we only
 880   # try to clear the form that CMake will set as part of its initial
 881   # configuration, it is still possible the user may force it as part of a
 882   # compound option.
 883   if(CMAKE_VERSION VERSION_LESS 3.16)
 884     string(REGEX REPLACE "(^|[ \t]+)-Wl,-brtl([ \t]+|$)" "" CMAKE_EXE_LINKER_FLAGS  "${CMAKE_EXE_LINKER_FLAGS}")
 885     string(REGEX REPLACE "(^|[ \t]+)-Wl,-brtl([ \t]+|$)" "" CMAKE_SHARED_LINKER_FLAGS  "${CMAKE_SHARED_LINKER_FLAGS}")
 886     string(REGEX REPLACE "(^|[ \t]+)-Wl,-brtl([ \t]+|$)" "" CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS}")
 887     string(REGEX REPLACE "(^|[ \t]+)(-Wl,)?-G([ \t]+|$)" "" CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS
 888       "${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS}")
 889     string(REGEX REPLACE "(^|[ \t]+)(-Wl,)?-G([ \t]+|$)" "" CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS
 890       "${CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS}")
 891     string(REGEX REPLACE "(^|[ \t]+)(-Wl,)?-G([ \t]+|$)" "" CMAKE_SHARED_LIBRARY_CREATE_ASM_FLAGS
 892       "${CMAKE_SHARED_LIBRARY_CREATE_ASM_FLAGS}")
 893   endif()
 894
 895   # Modules should be built with -G, so we can use runtime linking with
 896   # plugins.
 897   string(APPEND CMAKE_MODULE_LINKER_FLAGS " -G")
 898
 899   # Also set the correct flags for building shared libraries.
 900   string(APPEND CMAKE_SHARED_LINKER_FLAGS " -shared")
 901 endif()
 902
 903 # Build with _FILE_OFFSET_BITS=64 on Solaris to match g++ >= 9.
 904 if (UNIX AND ${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
 905           add_definitions("-D_FILE_OFFSET_BITS=64")
 906 endif()
 907
 908 # Work around a broken bfd ld behavior. When linking a binary with a
 909 # foo.so library, it will try to find any library that foo.so uses and
 910 # check its symbols. This is wasteful (the check was done when foo.so
 911 # was created) and can fail since it is not the dynamic linker and
 912 # doesn't know how to handle search paths correctly.
 913 if (UNIX AND NOT APPLE AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "SunOS|AIX")
 914   set(CMAKE_EXE_LINKER_FLAGS
 915       "${CMAKE_EXE_LINKER_FLAGS} -Wl,-allow-shlib-undefined")
 916 endif()
 917
 918 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 919
 920 include_directories( ${LLVM_INCLUDE_DIR} ${LLVM_MAIN_INCLUDE_DIR})
 921
 922 # when crosscompiling import the executable targets from a file
 923 if(LLVM_USE_HOST_TOOLS)
 924   include(CrossCompile)
 925   llvm_create_cross_target(LLVM NATIVE "" Release)
 926 endif(LLVM_USE_HOST_TOOLS)
 927 if(LLVM_TARGET_IS_CROSSCOMPILE_HOST)
 928 # Dummy use to avoid CMake Warning: Manually-specified variables were not used
 929 # (this is a variable that CrossCompile sets on recursive invocations)
 930 endif()
 931
 932 if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)")
 933   # On FreeBSD, /usr/local/* is not used by default. In order to build LLVM
 934   # with libxml2, iconv.h, etc., we must add /usr/local paths.
 935   include_directories(SYSTEM "/usr/local/include")
 936   link_directories("/usr/local/lib")
 937 endif(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)")
 938
 939 if( ${CMAKE_SYSTEM_NAME} MATCHES SunOS )
 940    # special hack for Solaris to handle crazy system sys/regset.h
 941    include_directories("${LLVM_MAIN_INCLUDE_DIR}/llvm/Support/Solaris")
 942 endif( ${CMAKE_SYSTEM_NAME} MATCHES SunOS )
 943
 944 # Make sure we don't get -rdynamic in every binary. For those that need it,
 945 # use export_executable_symbols(target).
 946 set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "")
 947
 948 include(AddLLVM)
 949 include(TableGen)
 950
 951 if( MINGW AND NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" )
 952   # People report that -O3 is unreliable on MinGW. The traditional
 953   # build also uses -O2 for that reason:
 954   llvm_replace_compiler_option(CMAKE_CXX_FLAGS_RELEASE "-O3" "-O2")
 955 endif()
 956
 957 # Put this before tblgen. Else we have a circular dependence.
 958 add_subdirectory(lib/Demangle)
 959 add_subdirectory(lib/Support)
 960 add_subdirectory(lib/TableGen)
 961
 962 add_subdirectory(utils/TableGen)
 963
 964 add_subdirectory(include/llvm)
 965
 966 add_subdirectory(lib)
 967
 968 if( LLVM_INCLUDE_UTILS )
 969   add_subdirectory(utils/FileCheck)
 970   add_subdirectory(utils/PerfectShuffle)
 971   add_subdirectory(utils/count)
 972   add_subdirectory(utils/not)
 973   add_subdirectory(utils/yaml-bench)
 974 else()
 975   if ( LLVM_INCLUDE_TESTS )
 976     message(FATAL_ERROR "Including tests when not building utils will not work.
 977     Either set LLVM_INCLUDE_UTILS to On, or set LLVM_INCLUDE_TESTS to Off.")
 978   endif()
 979 endif()
 980
 981 # Use LLVM_ADD_NATIVE_VISUALIZERS_TO_SOLUTION instead of LLVM_INCLUDE_UTILS because it is not really a util
 982 if (LLVM_ADD_NATIVE_VISUALIZERS_TO_SOLUTION)
 983   add_subdirectory(utils/LLVMVisualizers)
 984 endif()
 985
 986 foreach( binding ${LLVM_BINDINGS_LIST} )
 987   if( EXISTS "${LLVM_MAIN_SRC_DIR}/bindings/${binding}/CMakeLists.txt" )
 988     add_subdirectory(bindings/${binding})
 989   endif()
 990 endforeach()
 991
 992 add_subdirectory(projects)
 993
 994 if( LLVM_INCLUDE_TOOLS )
 995   add_subdirectory(tools)
 996 endif()
 997
 998 if( LLVM_INCLUDE_RUNTIMES )
 999   add_subdirectory(runtimes)
1000 endif()
1001
1002 if( LLVM_INCLUDE_EXAMPLES )
1003   add_subdirectory(examples)
1004 endif()
1005
1006 if( LLVM_INCLUDE_TESTS )
1007   if(EXISTS ${LLVM_MAIN_SRC_DIR}/projects/test-suite AND TARGET clang)
1008     include(LLVMExternalProjectUtils)
1009     llvm_ExternalProject_Add(test-suite ${LLVM_MAIN_SRC_DIR}/projects/test-suite
1010       USE_TOOLCHAIN
1011       EXCLUDE_FROM_ALL
1012       NO_INSTALL
1013       ALWAYS_CLEAN)
1014   endif()
1015   add_subdirectory(utils/lit)
1016   add_subdirectory(test)
1017   add_subdirectory(unittests)
1018   if( LLVM_INCLUDE_UTILS )
1019     add_subdirectory(utils/unittest)
1020   endif()
1021
1022   if (WIN32)
1023     # This utility is used to prevent crashing tests from calling Dr. Watson on
1024     # Windows.
1025     add_subdirectory(utils/KillTheDoctor)
1026   endif()
1027
1028   # Add a global check rule now that all subdirectories have been traversed
1029   # and we know the total set of lit testsuites.
1030   get_property(LLVM_LIT_TESTSUITES GLOBAL PROPERTY LLVM_LIT_TESTSUITES)
1031   get_property(LLVM_LIT_PARAMS GLOBAL PROPERTY LLVM_LIT_PARAMS)
1032   get_property(LLVM_LIT_DEPENDS GLOBAL PROPERTY LLVM_LIT_DEPENDS)
1033   get_property(LLVM_LIT_EXTRA_ARGS GLOBAL PROPERTY LLVM_LIT_EXTRA_ARGS)
1034   get_property(LLVM_ADDITIONAL_TEST_TARGETS
1035                GLOBAL PROPERTY LLVM_ADDITIONAL_TEST_TARGETS)
1036   get_property(LLVM_ADDITIONAL_TEST_DEPENDS
1037                GLOBAL PROPERTY LLVM_ADDITIONAL_TEST_DEPENDS)
1038   add_lit_target(check-all
1039     "Running all regression tests"
1040     ${LLVM_LIT_TESTSUITES}
1041     PARAMS ${LLVM_LIT_PARAMS}
1042     DEPENDS ${LLVM_LIT_DEPENDS} ${LLVM_ADDITIONAL_TEST_TARGETS}
1043     ARGS ${LLVM_LIT_EXTRA_ARGS}
1044     )
1045   if(TARGET check-runtimes)
1046     add_dependencies(check-all check-runtimes)
1047   endif()
1048   add_custom_target(test-depends
1049                     DEPENDS ${LLVM_LIT_DEPENDS} ${LLVM_ADDITIONAL_TEST_DEPENDS})
1050   set_target_properties(test-depends PROPERTIES FOLDER "Tests")
1051 endif()
1052
1053 if (LLVM_INCLUDE_DOCS)
1054   add_subdirectory(docs)
1055 endif()
1056
1057 add_subdirectory(cmake/modules)
1058
1059 # Do this last so that all lit targets have already been created.
1060 if (LLVM_INCLUDE_UTILS)
1061   add_subdirectory(utils/llvm-lit)
1062 endif()
1063
1064 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
1065   install(DIRECTORY include/llvm include/llvm-c
1066     DESTINATION include
1067     COMPONENT llvm-headers
1068     FILES_MATCHING
1069     PATTERN "*.def"
1070     PATTERN "*.h"
1071     PATTERN "*.td"
1072     PATTERN "*.inc"
1073     PATTERN "LICENSE.TXT"
1074     PATTERN ".svn" EXCLUDE
1075     )
1076
1077   install(DIRECTORY ${LLVM_INCLUDE_DIR}/llvm ${LLVM_INCLUDE_DIR}/llvm-c
1078     DESTINATION include
1079     COMPONENT llvm-headers
1080     FILES_MATCHING
1081     PATTERN "*.def"
1082     PATTERN "*.h"
1083     PATTERN "*.gen"
1084     PATTERN "*.inc"
1085     # Exclude include/llvm/CMakeFiles/intrinsics_gen.dir, matched by "*.def"
1086     PATTERN "CMakeFiles" EXCLUDE
1087     PATTERN "config.h" EXCLUDE
1088     PATTERN ".svn" EXCLUDE
1089     )
1090
1091   if (LLVM_INSTALL_MODULEMAPS)
1092     install(DIRECTORY include/llvm include/llvm-c
1093             DESTINATION include
1094             COMPONENT llvm-headers
1095             FILES_MATCHING
1096             PATTERN "module.modulemap"
1097             )
1098     install(FILES include/llvm/module.install.modulemap
1099             DESTINATION include/llvm
1100             COMPONENT llvm-headers
1101             RENAME "module.extern.modulemap"
1102             )
1103   endif(LLVM_INSTALL_MODULEMAPS)
1104
1105   # Installing the headers needs to depend on generating any public
1106   # tablegen'd headers.
1107   add_custom_target(llvm-headers DEPENDS intrinsics_gen)
1108   set_target_properties(llvm-headers PROPERTIES FOLDER "Misc")
1109
1110   if (NOT LLVM_ENABLE_IDE)
1111     add_llvm_install_targets(install-llvm-headers
1112                              DEPENDS llvm-headers
1113                              COMPONENT llvm-headers)
1114   endif()
1115
1116   # Custom target to install all libraries.
1117   add_custom_target(llvm-libraries)
1118   set_target_properties(llvm-libraries PROPERTIES FOLDER "Misc")
1119
1120   if (NOT LLVM_ENABLE_IDE)
1121     add_llvm_install_targets(install-llvm-libraries
1122                              DEPENDS llvm-libraries
1123                              COMPONENT llvm-libraries)
1124   endif()
1125
1126   get_property(LLVM_LIBS GLOBAL PROPERTY LLVM_LIBS)
1127   if(LLVM_LIBS)
1128     list(REMOVE_DUPLICATES LLVM_LIBS)
1129     foreach(lib ${LLVM_LIBS})
1130       add_dependencies(llvm-libraries ${lib})
1131       if (NOT LLVM_ENABLE_IDE)
1132         add_dependencies(install-llvm-libraries install-${lib})
1133         add_dependencies(install-llvm-libraries-stripped install-${lib}-stripped)
1134       endif()
1135     endforeach()
1136   endif()
1137 endif()
1138
1139 # This must be at the end of the LLVM root CMakeLists file because it must run
1140 # after all targets are created.
1141 include(LLVMDistributionSupport)
1142 llvm_distribution_add_targets()
1143 process_llvm_pass_plugins(GEN_CONFIG)
1144
1145 # This allows us to deploy the Universal CRT DLLs by passing -DCMAKE_INSTALL_UCRT_LIBRARIES=ON to CMake
1146 if (MSVC AND CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows" AND CMAKE_INSTALL_UCRT_LIBRARIES)
1147   include(InstallRequiredSystemLibraries)
1148 endif()
1149
1150 if (LLVM_INCLUDE_BENCHMARKS)
1151   # Override benchmark defaults so that when the library itself is updated these
1152   # modifications are not lost.
1153   set(BENCHMARK_ENABLE_TESTING OFF CACHE BOOL "Disable benchmark testing" FORCE)
1154   set(BENCHMARK_ENABLE_EXCEPTIONS OFF CACHE BOOL "Disable benchmark exceptions" FORCE)
1155   set(BENCHMARK_ENABLE_INSTALL OFF CACHE BOOL "Don't install benchmark" FORCE)
1156   set(BENCHMARK_DOWNLOAD_DEPENDENCIES OFF CACHE BOOL "Don't download dependencies" FORCE)
1157   set(BENCHMARK_ENABLE_GTEST_TESTS OFF CACHE BOOL "Disable Google Test in benchmark" FORCE)
1158   # Since LLVM requires C++11 it is safe to assume that std::regex is available.
1159   set(HAVE_STD_REGEX ON CACHE BOOL "OK" FORCE)
1160
1161   add_subdirectory(utils/benchmark)
1162   add_subdirectory(benchmarks)
1163 endif()
1164
1165 if (LLVM_INCLUDE_UTILS AND LLVM_INCLUDE_TOOLS)
1166   add_subdirectory(utils/llvm-locstats)
1167 endif()