granicus.if.org Git - clang/blob - CMakeLists.txt

   1 cmake_minimum_required(VERSION 3.4.3)
   2
   3 # If we are not building as a part of LLVM, build Clang as an
   4 # standalone project, using LLVM as an external library:
   5 if( CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR )
   6   project(Clang)
   7
   8   # Rely on llvm-config.
   9   set(CONFIG_OUTPUT)
  10   find_program(LLVM_CONFIG "llvm-config")
  11   if(LLVM_CONFIG)
  12     message(STATUS "Found LLVM_CONFIG as ${LLVM_CONFIG}")
  13     set(CONFIG_COMMAND ${LLVM_CONFIG}
  14       "--assertion-mode"
  15       "--bindir"
  16       "--libdir"
  17       "--includedir"
  18       "--prefix"
  19       "--src-root"
  20       "--cmakedir")
  21     execute_process(
  22       COMMAND ${CONFIG_COMMAND}
  23       RESULT_VARIABLE HAD_ERROR
  24       OUTPUT_VARIABLE CONFIG_OUTPUT
  25     )
  26     if(NOT HAD_ERROR)
  27       string(REGEX REPLACE
  28         "[ \t]*[\r\n]+[ \t]*" ";"
  29         CONFIG_OUTPUT ${CONFIG_OUTPUT})
  30     else()
  31       string(REPLACE ";" " " CONFIG_COMMAND_STR "${CONFIG_COMMAND}")
  32       message(STATUS "${CONFIG_COMMAND_STR}")
  33       message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}")
  34     endif()
  35   else()
  36     message(FATAL_ERROR "llvm-config not found -- ${LLVM_CONFIG}")
  37   endif()
  38
  39   list(GET CONFIG_OUTPUT 0 ENABLE_ASSERTIONS)
  40   list(GET CONFIG_OUTPUT 1 TOOLS_BINARY_DIR)
  41   list(GET CONFIG_OUTPUT 2 LIBRARY_DIR)
  42   list(GET CONFIG_OUTPUT 3 INCLUDE_DIR)
  43   list(GET CONFIG_OUTPUT 4 LLVM_OBJ_ROOT)
  44   list(GET CONFIG_OUTPUT 5 MAIN_SRC_DIR)
  45   list(GET CONFIG_OUTPUT 6 LLVM_CONFIG_CMAKE_PATH)
  46
  47   if(NOT MSVC_IDE)
  48     set(LLVM_ENABLE_ASSERTIONS ${ENABLE_ASSERTIONS}
  49       CACHE BOOL "Enable assertions")
  50     # Assertions should follow llvm-config's.
  51     mark_as_advanced(LLVM_ENABLE_ASSERTIONS)
  52   endif()
  53
  54   set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin")
  55   set(LLVM_LIBRARY_DIR ${LIBRARY_DIR} CACHE PATH "Path to llvm/lib")
  56   set(LLVM_MAIN_INCLUDE_DIR ${INCLUDE_DIR} CACHE PATH "Path to llvm/include")
  57   set(LLVM_BINARY_DIR ${LLVM_OBJ_ROOT} CACHE PATH "Path to LLVM build tree")
  58   set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree")
  59
  60   # Normalize LLVM_CMAKE_PATH. --cmakedir might contain backslashes.
  61   # CMake assumes slashes as PATH.
  62   file(TO_CMAKE_PATH ${LLVM_CONFIG_CMAKE_PATH} LLVM_CMAKE_PATH)
  63
  64   find_program(LLVM_TABLEGEN_EXE "llvm-tblgen" ${LLVM_TOOLS_BINARY_DIR}
  65     NO_DEFAULT_PATH)
  66
  67   set(LLVMCONFIG_FILE "${LLVM_CMAKE_PATH}/LLVMConfig.cmake")
  68   if(EXISTS ${LLVMCONFIG_FILE})
  69     list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}")
  70     include(${LLVMCONFIG_FILE})
  71   else()
  72     message(FATAL_ERROR "Not found: ${LLVMCONFIG_FILE}")
  73   endif()
  74
  75   # They are used as destination of target generators.
  76   set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)
  77   set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
  78   if(WIN32 OR CYGWIN)
  79     # DLL platform -- put DLLs into bin.
  80     set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
  81   else()
  82     set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
  83   endif()
  84
  85   option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)
  86   option(LLVM_INSTALL_TOOLCHAIN_ONLY
  87     "Only include toolchain files in the 'install' target." OFF)
  88
  89   option(LLVM_FORCE_USE_OLD_HOST_TOOLCHAIN
  90     "Set to ON to force using an old, unsupported host toolchain." OFF)
  91   option(CLANG_ENABLE_BOOTSTRAP "Generate the clang bootstrap target" OFF)
  92
  93   include(AddLLVM)
  94   include(TableGen)
  95   include(HandleLLVMOptions)
  96   include(VersionFromVCS)
  97
  98   set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
  99
 100   if (NOT DEFINED LLVM_INCLUDE_TESTS)
 101     set(LLVM_INCLUDE_TESTS ON)
 102   endif()
 103
 104   include_directories("${LLVM_BINARY_DIR}/include" "${LLVM_MAIN_INCLUDE_DIR}")
 105   link_directories("${LLVM_LIBRARY_DIR}")
 106
 107   set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin )
 108   set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
 109   set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
 110
 111   if(LLVM_INCLUDE_TESTS)
 112     set(Python_ADDITIONAL_VERSIONS 2.7)
 113     include(FindPythonInterp)
 114     if(NOT PYTHONINTERP_FOUND)
 115       message(FATAL_ERROR
 116 "Unable to find Python interpreter, required for builds and testing.
 117
 118 Please install Python or specify the PYTHON_EXECUTABLE CMake variable.")
 119     endif()
 120
 121     if( ${PYTHON_VERSION_STRING} VERSION_LESS 2.7 )
 122       message(FATAL_ERROR "Python 2.7 or newer is required")
 123     endif()
 124
 125     # Check prebuilt llvm/utils.
 126     if(EXISTS ${LLVM_TOOLS_BINARY_DIR}/FileCheck${CMAKE_EXECUTABLE_SUFFIX}
 127         AND EXISTS ${LLVM_TOOLS_BINARY_DIR}/count${CMAKE_EXECUTABLE_SUFFIX}
 128         AND EXISTS ${LLVM_TOOLS_BINARY_DIR}/not${CMAKE_EXECUTABLE_SUFFIX})
 129       set(LLVM_UTILS_PROVIDED ON)
 130     endif()
 131
 132     if(EXISTS ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)
 133       # Note: path not really used, except for checking if lit was found
 134       set(LLVM_LIT ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)
 135       if(NOT LLVM_UTILS_PROVIDED)
 136         add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/FileCheck utils/FileCheck)
 137         add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/count utils/count)
 138         add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/not utils/not)
 139         set(LLVM_UTILS_PROVIDED ON)
 140         set(CLANG_TEST_DEPS FileCheck count not)
 141       endif()
 142       set(UNITTEST_DIR ${LLVM_MAIN_SRC_DIR}/utils/unittest)
 143       if(EXISTS ${UNITTEST_DIR}/googletest/include/gtest/gtest.h
 144           AND NOT EXISTS ${LLVM_LIBRARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}gtest${CMAKE_STATIC_LIBRARY_SUFFIX}
 145           AND EXISTS ${UNITTEST_DIR}/CMakeLists.txt)
 146         add_subdirectory(${UNITTEST_DIR} utils/unittest)
 147       endif()
 148     else()
 149       # Seek installed Lit.
 150       find_program(LLVM_LIT
 151                    NAMES llvm-lit lit.py lit
 152                    PATHS "${LLVM_MAIN_SRC_DIR}/utils/lit"
 153                    DOC "Path to lit.py")
 154     endif()
 155
 156     if(LLVM_LIT)
 157       # Define the default arguments to use with 'lit', and an option for the user
 158       # to override.
 159       set(LIT_ARGS_DEFAULT "-sv")
 160       if (MSVC OR XCODE)
 161         set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
 162       endif()
 163       set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
 164
 165       # On Win32 hosts, provide an option to specify the path to the GnuWin32 tools.
 166       if( WIN32 AND NOT CYGWIN )
 167         set(LLVM_LIT_TOOLS_DIR "" CACHE PATH "Path to GnuWin32 tools")
 168       endif()
 169     else()
 170       set(LLVM_INCLUDE_TESTS OFF)
 171     endif()
 172   endif()
 173
 174   set( CLANG_BUILT_STANDALONE 1 )
 175   set(BACKEND_PACKAGE_STRING "LLVM ${LLVM_PACKAGE_VERSION}")
 176 else()
 177   set(BACKEND_PACKAGE_STRING "${PACKAGE_STRING}")
 178 endif()
 179
 180 # Make sure that our source directory is on the current cmake module path so that
 181 # we can include cmake files from this directory.
 182 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
 183
 184 # Don't look for libxml if we're using MSan, since uninstrumented third party
 185 # code may call MSan interceptors like strlen, leading to false positives.
 186 if(NOT LLVM_USE_SANITIZER MATCHES "Memory.*")
 187   set (LIBXML2_FOUND 0)
 188   find_package(LibXml2 2.5.3 QUIET)
 189   if (LIBXML2_FOUND)
 190     set(CLANG_HAVE_LIBXML 1)
 191   endif()
 192 endif()
 193
 194 include(CheckIncludeFile)
 195 check_include_file(sys/resource.h CLANG_HAVE_RLIMITS)
 196
 197 set(CLANG_RESOURCE_DIR "" CACHE STRING
 198   "Relative directory from the Clang binary to its resource files.")
 199
 200 set(C_INCLUDE_DIRS "" CACHE STRING
 201   "Colon separated list of directories clang will search for headers.")
 202
 203 set(GCC_INSTALL_PREFIX "" CACHE PATH "Directory where gcc is installed." )
 204 set(DEFAULT_SYSROOT "" CACHE PATH
 205   "Default <path> to all compiler invocations for --sysroot=<path>." )
 206
 207 set(ENABLE_LINKER_BUILD_ID OFF CACHE BOOL "pass --build-id to ld")
 208
 209 set(ENABLE_X86_RELAX_RELOCATIONS OFF CACHE BOOL
 210     "enable x86 relax relocations by default")
 211
 212 set(CLANG_DEFAULT_LINKER "" CACHE STRING
 213   "Default linker to use (linker name or absolute path, empty for platform default)")
 214
 215 set(CLANG_DEFAULT_CXX_STDLIB "" CACHE STRING
 216   "Default C++ stdlib to use (\"libstdc++\" or \"libc++\", empty for platform default")
 217 if (NOT(CLANG_DEFAULT_CXX_STDLIB STREQUAL "" OR
 218         CLANG_DEFAULT_CXX_STDLIB STREQUAL "libstdc++" OR
 219         CLANG_DEFAULT_CXX_STDLIB STREQUAL "libc++"))
 220   message(WARNING "Resetting default C++ stdlib to use platform default")
 221   set(CLANG_DEFAULT_CXX_STDLIB "" CACHE STRING
 222     "Default C++ stdlib to use (\"libstdc++\" or \"libc++\", empty for platform default" FORCE)
 223 endif()
 224
 225 set(CLANG_DEFAULT_RTLIB "" CACHE STRING
 226   "Default runtime library to use (\"libgcc\" or \"compiler-rt\", empty for platform default)")
 227 if (NOT(CLANG_DEFAULT_RTLIB STREQUAL "" OR
 228         CLANG_DEFAULT_RTLIB STREQUAL "libgcc" OR
 229         CLANG_DEFAULT_RTLIB STREQUAL "compiler-rt"))
 230   message(WARNING "Resetting default rtlib to use platform default")
 231   set(CLANG_DEFAULT_RTLIB "" CACHE STRING
 232     "Default runtime library to use (\"libgcc\" or \"compiler-rt\", empty for platform default)" FORCE)
 233 endif()
 234
 235 set(CLANG_DEFAULT_OPENMP_RUNTIME "libomp" CACHE STRING
 236   "Default OpenMP runtime used by -fopenmp.")
 237
 238 # OpenMP offloading requires at least sm_30 because we use shuffle instructions
 239 # to generate efficient code for reductions.
 240 set(CLANG_OPENMP_NVPTX_DEFAULT_ARCH "sm_30" CACHE STRING
 241   "Default architecture for OpenMP offloading to Nvidia GPUs.")
 242 string(REGEX MATCH "^sm_([0-9]+)$" MATCHED_ARCH "${CLANG_OPENMP_NVPTX_DEFAULT_ARCH}")
 243 if (NOT DEFINED MATCHED_ARCH OR "${CMAKE_MATCH_1}" LESS 30)
 244   message(WARNING "Resetting default architecture for OpenMP offloading to Nvidia GPUs to sm_30")
 245   set(CLANG_OPENMP_NVPTX_DEFAULT_ARCH "sm_30" CACHE STRING
 246     "Default architecture for OpenMP offloading to Nvidia GPUs." FORCE)
 247 endif()
 248
 249 set(CLANG_VENDOR ${PACKAGE_VENDOR} CACHE STRING
 250   "Vendor-specific text for showing with version information.")
 251
 252 if( CLANG_VENDOR )
 253   add_definitions( -DCLANG_VENDOR="${CLANG_VENDOR} " )
 254 endif()
 255
 256 set(CLANG_REPOSITORY_STRING "" CACHE STRING
 257   "Vendor-specific text for showing the repository the source is taken from.")
 258
 259 if(CLANG_REPOSITORY_STRING)
 260   add_definitions(-DCLANG_REPOSITORY_STRING="${CLANG_REPOSITORY_STRING}")
 261 endif()
 262
 263 set(CLANG_VENDOR_UTI "org.llvm.clang" CACHE STRING
 264   "Vendor-specific uti.")
 265
 266 # The libdir suffix must exactly match whatever LLVM's configuration used.
 267 set(CLANG_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}")
 268
 269 set(CLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 270 set(CLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 271
 272 if( CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE )
 273   message(FATAL_ERROR "In-source builds are not allowed. CMake would overwrite "
 274 "the makefiles distributed with LLVM. Please create a directory and run cmake "
 275 "from there, passing the path to this source directory as the last argument. "
 276 "This process created the file `CMakeCache.txt' and the directory "
 277 "`CMakeFiles'. Please delete them.")
 278 endif()
 279
 280 if( NOT CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR )
 281   file(GLOB_RECURSE
 282     tablegenned_files_on_include_dir
 283     "${CLANG_SOURCE_DIR}/include/clang/*.inc")
 284   if( tablegenned_files_on_include_dir )
 285     message(FATAL_ERROR "Apparently there is a previous in-source build, "
 286 "probably as the result of running `configure' and `make' on "
 287 "${CLANG_SOURCE_DIR}. This may cause problems. The suspicious files are:\n"
 288 "${tablegenned_files_on_include_dir}\nPlease clean the source directory.")
 289   endif()
 290 endif()
 291
 292 # If CLANG_VERSION_* is specified, use it, if not use LLVM_VERSION_*.
 293 if(NOT DEFINED CLANG_VERSION_MAJOR)
 294   set(CLANG_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
 295 endif()
 296 if(NOT DEFINED CLANG_VERSION_MINOR)
 297   set(CLANG_VERSION_MINOR ${LLVM_VERSION_MINOR})
 298 endif()
 299 if(NOT DEFINED CLANG_VERSION_PATCHLEVEL)
 300   set(CLANG_VERSION_PATCHLEVEL ${LLVM_VERSION_PATCH})
 301 endif()
 302 # Unlike PACKAGE_VERSION, CLANG_VERSION does not include LLVM_VERSION_SUFFIX.
 303 set(CLANG_VERSION "${CLANG_VERSION_MAJOR}.${CLANG_VERSION_MINOR}.${CLANG_VERSION_PATCHLEVEL}")
 304 message(STATUS "Clang version: ${CLANG_VERSION}")
 305
 306 # Configure the Version.inc file.
 307 configure_file(
 308   ${CMAKE_CURRENT_SOURCE_DIR}/include/clang/Basic/Version.inc.in
 309   ${CMAKE_CURRENT_BINARY_DIR}/include/clang/Basic/Version.inc)
 310
 311 # Add appropriate flags for GCC
 312 if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
 313   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-common -Woverloaded-virtual")
 314   if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
 315     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing")
 316   endif ()
 317
 318   # Enable -pedantic for Clang even if it's not enabled for LLVM.
 319   if (NOT LLVM_ENABLE_PEDANTIC)
 320     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wno-long-long")
 321   endif ()
 322
 323   check_cxx_compiler_flag("-Werror -Wnested-anon-types" CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG)
 324   if( CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG )
 325     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nested-anon-types" )
 326   endif()
 327 endif ()
 328
 329 # Determine HOST_LINK_VERSION on Darwin.
 330 set(HOST_LINK_VERSION)
 331 if (APPLE)
 332   set(LD_V_OUTPUT)
 333   execute_process(
 334     COMMAND sh -c "${CMAKE_LINKER} -v 2>&1 | head -1"
 335     RESULT_VARIABLE HAD_ERROR
 336     OUTPUT_VARIABLE LD_V_OUTPUT
 337   )
 338   if (NOT HAD_ERROR)
 339     if ("${LD_V_OUTPUT}" MATCHES ".*ld64-([0-9.]+).*")
 340       string(REGEX REPLACE ".*ld64-([0-9.]+).*" "\\1" HOST_LINK_VERSION ${LD_V_OUTPUT})
 341     elseif ("${LD_V_OUTPUT}" MATCHES "[^0-9]*([0-9.]+).*")
 342       string(REGEX REPLACE "[^0-9]*([0-9.]+).*" "\\1" HOST_LINK_VERSION ${LD_V_OUTPUT})
 343     endif()
 344   else()
 345     message(FATAL_ERROR "${CMAKE_LINKER} failed with status ${HAD_ERROR}")
 346   endif()
 347 endif()
 348
 349 include(CMakeParseArguments)
 350 include(AddClang)
 351
 352 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 353
 354 include_directories(BEFORE
 355   ${CMAKE_CURRENT_BINARY_DIR}/include
 356   ${CMAKE_CURRENT_SOURCE_DIR}/include
 357   )
 358
 359 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
 360   install(DIRECTORY include/clang include/clang-c
 361     DESTINATION include
 362     FILES_MATCHING
 363     PATTERN "*.def"
 364     PATTERN "*.h"
 365     PATTERN "config.h" EXCLUDE
 366     PATTERN ".svn" EXCLUDE
 367     )
 368
 369   install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/clang
 370     DESTINATION include
 371     FILES_MATCHING
 372     PATTERN "CMakeFiles" EXCLUDE
 373     PATTERN "*.inc"
 374     PATTERN "*.h"
 375     )
 376
 377   install(PROGRAMS utils/bash-autocomplete.sh
 378     DESTINATION share/clang
 379     )
 380 endif()
 381
 382 add_definitions( -D_GNU_SOURCE )
 383
 384 option(CLANG_BUILD_TOOLS
 385   "Build the Clang tools. If OFF, just generate build targets." ON)
 386
 387 option(CLANG_ENABLE_ARCMT "Build ARCMT." ON)
 388 option(CLANG_ENABLE_STATIC_ANALYZER "Build static analyzer." ON)
 389
 390 option(CLANG_ANALYZER_BUILD_Z3
 391   "Build the static analyzer with the Z3 constraint manager." OFF)
 392
 393 option(CLANG_ENABLE_PROTO_FUZZER "Build Clang protobuf fuzzer." OFF)
 394
 395 if(NOT CLANG_ENABLE_STATIC_ANALYZER AND (CLANG_ENABLE_ARCMT OR CLANG_ANALYZER_BUILD_Z3))
 396   message(FATAL_ERROR "Cannot disable static analyzer while enabling ARCMT or Z3")
 397 endif()
 398
 399 if(CLANG_ANALYZER_BUILD_Z3)
 400   find_package(Z3 4.5)
 401   if(Z3_FOUND)
 402     set(CLANG_ANALYZER_WITH_Z3 1)
 403   else()
 404     message(FATAL_ERROR "Cannot find Z3 header file or shared library")
 405   endif()
 406 endif()
 407
 408 if(CLANG_ENABLE_ARCMT)
 409   set(CLANG_ENABLE_OBJC_REWRITER ON)
 410 endif()
 411
 412 # Clang version information
 413 set(CLANG_EXECUTABLE_VERSION
 414      "${CLANG_VERSION_MAJOR}.${CLANG_VERSION_MINOR}" CACHE STRING
 415     "Version number that will be placed into the clang executable, in the form XX.YY")
 416 set(LIBCLANG_LIBRARY_VERSION
 417      "${CLANG_VERSION_MAJOR}.${CLANG_VERSION_MINOR}" CACHE STRING
 418     "Version number that will be placed into the libclang library , in the form XX.YY")
 419 mark_as_advanced(CLANG_EXECUTABLE_VERSION LIBCLANG_LIBRARY_VERSION)
 420
 421 option(CLANG_INCLUDE_TESTS
 422        "Generate build targets for the Clang unit tests."
 423        ${LLVM_INCLUDE_TESTS})
 424
 425 add_subdirectory(utils/TableGen)
 426
 427 add_subdirectory(include)
 428
 429 # All targets below may depend on all tablegen'd files.
 430 get_property(CLANG_TABLEGEN_TARGETS GLOBAL PROPERTY CLANG_TABLEGEN_TARGETS)
 431 add_custom_target(clang-tablegen-targets DEPENDS ${CLANG_TABLEGEN_TARGETS})
 432 list(APPEND LLVM_COMMON_DEPENDS clang-tablegen-targets)
 433
 434 # Force target to be built as soon as possible. Clang modules builds depend
 435 # header-wise on it as they ship all headers from the umbrella folders. Building
 436 # an entire module might include header, which depends on intrinsics_gen.
 437 if(LLVM_ENABLE_MODULES AND NOT CLANG_BUILT_STANDALONE)
 438   list(APPEND LLVM_COMMON_DEPENDS intrinsics_gen)
 439 endif()
 440
 441 add_subdirectory(lib)
 442 add_subdirectory(tools)
 443 add_subdirectory(runtime)
 444
 445 option(CLANG_BUILD_EXAMPLES "Build CLANG example programs by default." OFF)
 446 add_subdirectory(examples)
 447
 448 if(APPLE)
 449   # this line is needed as a cleanup to ensure that any CMakeCaches with the old
 450   # default value get updated to the new default.
 451   if(CLANG_ORDER_FILE STREQUAL "")
 452     unset(CLANG_ORDER_FILE CACHE)
 453     unset(CLANG_ORDER_FILE)
 454   endif()
 455
 456
 457   set(CLANG_ORDER_FILE ${CMAKE_CURRENT_BINARY_DIR}/clang.order CACHE FILEPATH
 458     "Order file to use when compiling clang in order to improve startup time (Darwin Only - requires ld64).")
 459
 460   if(NOT EXISTS ${CLANG_ORDER_FILE})
 461     string(FIND "${CLANG_ORDER_FILE}" "${CMAKE_CURRENT_BINARY_DIR}" PATH_START)
 462     if(PATH_START EQUAL 0)
 463       file(WRITE ${CLANG_ORDER_FILE} "\n")
 464     else()
 465       message(FATAL_ERROR "Specified order file '${CLANG_ORDER_FILE}' does not exist.")
 466     endif()
 467   endif()
 468 endif()
 469
 470
 471 if( CLANG_INCLUDE_TESTS )
 472   if(EXISTS ${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include/gtest/gtest.h)
 473     add_subdirectory(unittests)
 474     list(APPEND CLANG_TEST_DEPS ClangUnitTests)
 475     list(APPEND CLANG_TEST_PARAMS
 476       clang_unit_site_config=${CMAKE_CURRENT_BINARY_DIR}/test/Unit/lit.site.cfg
 477       )
 478   endif()
 479   add_subdirectory(test)
 480
 481   if(CLANG_BUILT_STANDALONE)
 482     # Add a global check rule now that all subdirectories have been traversed
 483     # and we know the total set of lit testsuites.
 484     get_property(LLVM_LIT_TESTSUITES GLOBAL PROPERTY LLVM_LIT_TESTSUITES)
 485     get_property(LLVM_LIT_PARAMS GLOBAL PROPERTY LLVM_LIT_PARAMS)
 486     get_property(LLVM_LIT_DEPENDS GLOBAL PROPERTY LLVM_LIT_DEPENDS)
 487     get_property(LLVM_LIT_EXTRA_ARGS GLOBAL PROPERTY LLVM_LIT_EXTRA_ARGS)
 488     add_lit_target(check-all
 489       "Running all regression tests"
 490       ${LLVM_LIT_TESTSUITES}
 491       PARAMS ${LLVM_LIT_PARAMS}
 492       DEPENDS ${LLVM_LIT_DEPENDS}
 493       ARGS ${LLVM_LIT_EXTRA_ARGS}
 494       )
 495   endif()
 496   add_subdirectory(utils/perf-training)
 497 endif()
 498
 499 option(CLANG_INCLUDE_DOCS "Generate build targets for the Clang docs."
 500   ${LLVM_INCLUDE_DOCS})
 501 if( CLANG_INCLUDE_DOCS )
 502   add_subdirectory(docs)
 503 endif()
 504
 505 add_subdirectory(cmake/modules)
 506
 507 if(CLANG_STAGE)
 508   message(STATUS "Setting current clang stage to: ${CLANG_STAGE}")
 509 endif()
 510
 511 if (CLANG_ENABLE_BOOTSTRAP)
 512   include(ExternalProject)
 513
 514   add_custom_target(clang-bootstrap-deps DEPENDS clang)
 515
 516   if(NOT CLANG_STAGE)
 517     set(CLANG_STAGE stage1)
 518   endif()
 519
 520   string(REGEX MATCH "stage([0-9]*)" MATCHED_STAGE "${CLANG_STAGE}")
 521   if(MATCHED_STAGE)
 522     if(NOT LLVM_BUILD_INSTRUMENTED)
 523       math(EXPR STAGE_NUM "${CMAKE_MATCH_1} + 1")
 524       set(NEXT_CLANG_STAGE stage${STAGE_NUM})
 525     else()
 526       set(NEXT_CLANG_STAGE stage${CMAKE_MATCH_1})
 527     endif()
 528   else()
 529     set(NEXT_CLANG_STAGE bootstrap)
 530   endif()
 531
 532   if(BOOTSTRAP_LLVM_BUILD_INSTRUMENTED)
 533     set(NEXT_CLANG_STAGE ${NEXT_CLANG_STAGE}-instrumented)
 534   endif()
 535   message(STATUS "Setting next clang stage to: ${NEXT_CLANG_STAGE}")
 536
 537
 538   set(STAMP_DIR ${CMAKE_CURRENT_BINARY_DIR}/${NEXT_CLANG_STAGE}-stamps/)
 539   set(BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${NEXT_CLANG_STAGE}-bins/)
 540
 541   if(BOOTSTRAP_LLVM_ENABLE_LLD)
 542     add_dependencies(clang-bootstrap-deps lld)
 543   endif()
 544
 545   # If the next stage is LTO we need to depend on LTO and possibly lld or LLVMgold
 546   if(BOOTSTRAP_LLVM_ENABLE_LTO OR LLVM_ENABLE_LTO AND NOT LLVM_BUILD_INSTRUMENTED)
 547     if(APPLE)
 548       add_dependencies(clang-bootstrap-deps LTO)
 549       # on Darwin we need to set DARWIN_LTO_LIBRARY so that -flto will work
 550       # using the just-built compiler, and we need to override DYLD_LIBRARY_PATH
 551       # so that the host object file tools will use the just-built libLTO.
 552       # However if System Integrity Protection is enabled the DYLD variables
 553       # will be scrubbed from the environment of any base system commands. This
 554       # includes /bin/sh, which ninja uses when executing build commands. To
 555       # work around the envar being filtered away we pass it in as a CMake
 556       # variable, and have LLVM's CMake append the envar to the archiver calls.
 557       set(LTO_LIBRARY -DDARWIN_LTO_LIBRARY=${LLVM_SHLIB_OUTPUT_INTDIR}/libLTO.dylib
 558         -DDYLD_LIBRARY_PATH=${LLVM_LIBRARY_OUTPUT_INTDIR})
 559     elseif(NOT WIN32)
 560       add_dependencies(clang-bootstrap-deps llvm-ar llvm-ranlib)
 561       if(NOT BOOTSTRAP_LLVM_ENABLE_LLD AND LLVM_BINUTILS_INCDIR)
 562         add_dependencies(clang-bootstrap-deps LLVMgold)
 563       endif()
 564       set(LTO_AR -DCMAKE_AR=${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-ar)
 565       set(LTO_RANLIB -DCMAKE_RANLIB=${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-ranlib)
 566     endif()
 567   endif()
 568
 569   add_custom_target(${NEXT_CLANG_STAGE}-clear
 570     DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${NEXT_CLANG_STAGE}-cleared
 571     )
 572   add_custom_command(
 573     OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${NEXT_CLANG_STAGE}-cleared
 574     DEPENDS clang-bootstrap-deps
 575     COMMAND ${CMAKE_COMMAND} -E remove_directory ${BINARY_DIR}
 576     COMMAND ${CMAKE_COMMAND} -E make_directory ${BINARY_DIR}
 577     COMMAND ${CMAKE_COMMAND} -E remove_directory ${STAMP_DIR}
 578     COMMAND ${CMAKE_COMMAND} -E make_directory ${STAMP_DIR}
 579     COMMENT "Clobberring ${NEXT_CLANG_STAGE} build and stamp directories"
 580     )
 581
 582   if(CMAKE_VERBOSE_MAKEFILE)
 583     set(verbose -DCMAKE_VERBOSE_MAKEFILE=On)
 584   endif()
 585
 586   set(_BOOTSTRAP_DEFAULT_PASSTHROUGH
 587     PACKAGE_VERSION
 588     PACKAGE_VENDOR
 589     LLVM_VERSION_MAJOR
 590     LLVM_VERSION_MINOR
 591     LLVM_VERSION_PATCH
 592     CLANG_VERSION_MAJOR
 593     CLANG_VERSION_MINOR
 594     CLANG_VERSION_PATCHLEVEL
 595     LLVM_VERSION_SUFFIX
 596     LLVM_BINUTILS_INCDIR
 597     CLANG_REPOSITORY_STRING
 598     CMAKE_MAKE_PROGRAM
 599     CMAKE_OSX_ARCHITECTURES)
 600
 601   # We don't need to depend on compiler-rt if we're building instrumented
 602   # because the next stage will use the same compiler used to build this stage.
 603   if(TARGET compiler-rt AND NOT LLVM_BUILD_INSTRUMENTED)
 604     add_dependencies(clang-bootstrap-deps compiler-rt)
 605   endif()
 606
 607   set(C_COMPILER "clang")
 608   set(CXX_COMPILER "clang++")
 609   if(WIN32)
 610     set(C_COMPILER "clang-cl.exe")
 611     set(CXX_COMPILER "clang-cl.exe")
 612   endif()
 613
 614   set(COMPILER_OPTIONS
 615     -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${CXX_COMPILER}
 616     -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${C_COMPILER}
 617     -DCMAKE_ASM_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${C_COMPILER})
 618
 619   if(BOOTSTRAP_LLVM_BUILD_INSTRUMENTED)
 620     add_dependencies(clang-bootstrap-deps llvm-profdata)
 621     set(PGO_OPT -DLLVM_PROFDATA=${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-profdata)
 622   endif()
 623
 624   if(LLVM_BUILD_INSTRUMENTED)
 625     add_dependencies(clang-bootstrap-deps generate-profdata)
 626     set(PGO_OPT -DLLVM_PROFDATA_FILE=${CMAKE_CURRENT_BINARY_DIR}/utils/perf-training/clang.profdata)
 627     # Use the current tools for LTO instead of the instrumented ones
 628     list(APPEND _BOOTSTRAP_DEFAULT_PASSTHROUGH
 629       CMAKE_CXX_COMPILER
 630       CMAKE_C_COMPILER
 631       CMAKE_ASM_COMPILER
 632       CMAKE_AR
 633       CMAKE_RANLIB
 634       DARWIN_LTO_LIBRARY
 635       DYLD_LIBRARY_PATH)
 636
 637     set(COMPILER_OPTIONS)
 638     set(LTO_LIBRARY)
 639     set(LTO_AR)
 640     set(LTO_RANLIB)
 641   endif()
 642
 643   # Find all variables that start with BOOTSTRAP_ and populate a variable with
 644   # them.
 645   get_cmake_property(variableNames VARIABLES)
 646   foreach(variableName ${variableNames})
 647     if(variableName MATCHES "^BOOTSTRAP_")
 648       string(SUBSTRING ${variableName} 10 -1 varName)
 649       string(REPLACE ";" "\;" value "${${variableName}}")
 650       list(APPEND PASSTHROUGH_VARIABLES
 651         -D${varName}=${value})
 652     endif()
 653     if(${variableName} AND variableName MATCHES "LLVM_EXTERNAL_.*_SOURCE_DIR")
 654       list(APPEND PASSTHROUGH_VARIABLES
 655         -D${variableName}=${${variableName}})
 656     endif()
 657   endforeach()
 658
 659   # Populate the passthrough variables
 660   foreach(variableName ${CLANG_BOOTSTRAP_PASSTHROUGH} ${_BOOTSTRAP_DEFAULT_PASSTHROUGH})
 661     if(DEFINED ${variableName})
 662       if("${${variableName}}" STREQUAL "")
 663         set(value "")
 664       else()
 665         string(REPLACE ";" "\;" value ${${variableName}})
 666       endif()
 667       list(APPEND PASSTHROUGH_VARIABLES
 668         -D${variableName}=${value})
 669     endif()
 670   endforeach()
 671
 672   ExternalProject_Add(${NEXT_CLANG_STAGE}
 673     DEPENDS clang-bootstrap-deps
 674     PREFIX ${NEXT_CLANG_STAGE}
 675     SOURCE_DIR ${CMAKE_SOURCE_DIR}
 676     STAMP_DIR ${STAMP_DIR}
 677     BINARY_DIR ${BINARY_DIR}
 678     EXCLUDE_FROM_ALL 1
 679     CMAKE_ARGS
 680                 # We shouldn't need to set this here, but INSTALL_DIR doesn't
 681                 # seem to work, so instead I'm passing this through
 682                 -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
 683                 ${CLANG_BOOTSTRAP_CMAKE_ARGS}
 684                 ${PASSTHROUGH_VARIABLES}
 685                  -DCLANG_STAGE=${NEXT_CLANG_STAGE}
 686                 ${COMPILER_OPTIONS}
 687                 ${LTO_LIBRARY} ${LTO_AR} ${LTO_RANLIB} ${verbose} ${PGO_OPT}
 688     INSTALL_COMMAND ""
 689     STEP_TARGETS configure build
 690     USES_TERMINAL_CONFIGURE 1
 691     USES_TERMINAL_BUILD 1
 692     USES_TERMINAL_INSTALL 1
 693     )
 694
 695   # exclude really-install from main target
 696   set_target_properties(${NEXT_CLANG_STAGE} PROPERTIES _EP_really-install_EXCLUDE_FROM_MAIN On)
 697   ExternalProject_Add_Step(${NEXT_CLANG_STAGE} really-install
 698     COMMAND ${CMAKE_COMMAND} --build <BINARY_DIR> --target install
 699     COMMENT "Performing install step for '${NEXT_CLANG_STAGE}'"
 700     DEPENDEES build
 701     USES_TERMINAL 1
 702   )
 703   ExternalProject_Add_StepTargets(${NEXT_CLANG_STAGE} really-install)
 704   add_custom_target(${NEXT_CLANG_STAGE}-install DEPENDS ${NEXT_CLANG_STAGE}-really-install)
 705
 706   if(NOT CLANG_BOOTSTRAP_TARGETS)
 707     set(CLANG_BOOTSTRAP_TARGETS check-llvm check-clang check-all)
 708   endif()
 709   foreach(target ${CLANG_BOOTSTRAP_TARGETS})
 710     # exclude from main target
 711     set_target_properties(${NEXT_CLANG_STAGE} PROPERTIES _EP_${target}_EXCLUDE_FROM_MAIN On)
 712
 713     ExternalProject_Add_Step(${NEXT_CLANG_STAGE} ${target}
 714       COMMAND ${CMAKE_COMMAND} --build <BINARY_DIR> --target ${target}
 715       COMMENT "Performing ${target} for '${NEXT_CLANG_STAGE}'"
 716       DEPENDEES configure
 717       USES_TERMINAL 1
 718     )
 719
 720     if(target MATCHES "^stage[0-9]*")
 721       add_custom_target(${target} DEPENDS ${NEXT_CLANG_STAGE}-${target})
 722     endif()
 723
 724     ExternalProject_Add_StepTargets(${NEXT_CLANG_STAGE} ${target})
 725   endforeach()
 726 endif()
 727
 728 if (LLVM_ADD_NATIVE_VISUALIZERS_TO_SOLUTION)
 729   add_subdirectory(utils/ClangVisualizers)
 730 endif()
 731
 732 configure_file(
 733   ${CLANG_SOURCE_DIR}/include/clang/Config/config.h.cmake
 734   ${CLANG_BINARY_DIR}/include/clang/Config/config.h)