1517 lines · plain
1# This CMake module is responsible for interpreting the user defined LLVM_2# options and executing the appropriate CMake commands to realize the users'3# selections.4 5# This is commonly needed so make sure it's defined before we include anything6# else.7string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)8 9include(CheckCompilerVersion)10include(CheckProblematicConfigurations)11include(HandleLLVMStdlib)12include(CheckCCompilerFlag)13include(CheckCSourceCompiles)14include(CheckCXXCompilerFlag)15include(CheckCXXSourceCompiles)16include(CheckSymbolExists)17include(CMakeDependentOption)18include(LLVMProcessSources)19 20if(CMAKE_LINKER MATCHES ".*lld" OR (LLVM_USE_LINKER STREQUAL "lld" OR LLVM_ENABLE_LLD))21 set(LINKER_IS_LLD TRUE)22else()23 set(LINKER_IS_LLD FALSE)24endif()25 26if(CMAKE_LINKER MATCHES "lld-link" OR (MSVC AND (LLVM_USE_LINKER STREQUAL "lld" OR LLVM_ENABLE_LLD)))27 set(LINKER_IS_LLD_LINK TRUE)28else()29 set(LINKER_IS_LLD_LINK FALSE)30endif()31 32set(LLVM_ENABLE_LTO OFF CACHE STRING "Build LLVM with LTO. May be specified as Thin or Full to use a particular kind of LTO")33string(TOUPPER "${LLVM_ENABLE_LTO}" uppercase_LLVM_ENABLE_LTO)34 35option(LLVM_ENABLE_FATLTO "Build LLVM with -ffat-lto-objects." OFF)36 37# Ninja Job Pool support38# The following only works with the Ninja generator in CMake >= 3.0.39set(LLVM_PARALLEL_COMPILE_JOBS "" CACHE STRING40 "Define the maximum number of concurrent compilation jobs (Ninja only).")41if(LLVM_RAM_PER_COMPILE_JOB OR LLVM_RAM_PER_LINK_JOB OR LLVM_RAM_PER_TABLEGEN_JOB)42 cmake_host_system_information(RESULT available_physical_memory QUERY AVAILABLE_PHYSICAL_MEMORY)43 cmake_host_system_information(RESULT number_of_logical_cores QUERY NUMBER_OF_LOGICAL_CORES)44endif()45if(LLVM_RAM_PER_COMPILE_JOB)46 math(EXPR jobs_with_sufficient_memory "${available_physical_memory} / ${LLVM_RAM_PER_COMPILE_JOB}" OUTPUT_FORMAT DECIMAL)47 if (jobs_with_sufficient_memory LESS 1)48 set(jobs_with_sufficient_memory 1)49 endif()50 if (jobs_with_sufficient_memory LESS number_of_logical_cores)51 set(LLVM_PARALLEL_COMPILE_JOBS "${jobs_with_sufficient_memory}")52 else()53 set(LLVM_PARALLEL_COMPILE_JOBS "${number_of_logical_cores}")54 endif()55endif()56if(LLVM_PARALLEL_COMPILE_JOBS)57 if(NOT CMAKE_GENERATOR MATCHES "Ninja")58 message(WARNING "Job pooling is only available with Ninja generators.")59 else()60 set_property(GLOBAL APPEND PROPERTY JOB_POOLS compile_job_pool=${LLVM_PARALLEL_COMPILE_JOBS})61 set(CMAKE_JOB_POOL_COMPILE compile_job_pool)62 endif()63endif()64 65set(LLVM_PARALLEL_LINK_JOBS "" CACHE STRING66 "Define the maximum number of concurrent link jobs (Ninja only).")67if(LLVM_RAM_PER_LINK_JOB)68 math(EXPR jobs_with_sufficient_memory "${available_physical_memory} / ${LLVM_RAM_PER_LINK_JOB}" OUTPUT_FORMAT DECIMAL)69 if (jobs_with_sufficient_memory LESS 1)70 set(jobs_with_sufficient_memory 1)71 endif()72 if (jobs_with_sufficient_memory LESS number_of_logical_cores)73 set(LLVM_PARALLEL_LINK_JOBS "${jobs_with_sufficient_memory}")74 else()75 set(LLVM_PARALLEL_LINK_JOBS "${number_of_logical_cores}")76 endif()77endif()78if(CMAKE_GENERATOR MATCHES "Ninja")79 if(NOT LLVM_PARALLEL_LINK_JOBS AND uppercase_LLVM_ENABLE_LTO STREQUAL "THIN")80 message(STATUS "ThinLTO provides its own parallel linking - limiting parallel link jobs to 2.")81 set(LLVM_PARALLEL_LINK_JOBS "2")82 endif()83 if(LLVM_PARALLEL_LINK_JOBS)84 set_property(GLOBAL APPEND PROPERTY JOB_POOLS link_job_pool=${LLVM_PARALLEL_LINK_JOBS})85 set(CMAKE_JOB_POOL_LINK link_job_pool)86 endif()87elseif(LLVM_PARALLEL_LINK_JOBS)88 message(WARNING "Job pooling is only available with Ninja generators.")89endif()90 91set(LLVM_PARALLEL_TABLEGEN_JOBS "" CACHE STRING92 "Define the maximum number of concurrent tablegen jobs (Ninja only).")93if(LLVM_RAM_PER_TABLEGEN_JOB)94 math(EXPR jobs_with_sufficient_memory "${available_physical_memory} / ${LLVM_RAM_PER_TABLEGEN_JOB}" OUTPUT_FORMAT DECIMAL)95 if (jobs_with_sufficient_memory LESS 1)96 set(jobs_with_sufficient_memory 1)97 endif()98 if (jobs_with_sufficient_memory LESS number_of_logical_cores)99 set(LLVM_PARALLEL_TABLEGEN_JOBS "${jobs_with_sufficient_memory}")100 else()101 set(LLVM_PARALLEL_TABLEGEN_JOBS "${number_of_logical_cores}")102 endif()103endif()104if(LLVM_PARALLEL_TABLEGEN_JOBS)105 if(NOT CMAKE_GENERATOR MATCHES "Ninja")106 message(WARNING "Job pooling is only available with Ninja generators.")107 else()108 set_property(GLOBAL APPEND PROPERTY JOB_POOLS tablegen_job_pool=${LLVM_PARALLEL_TABLEGEN_JOBS})109 # Job pool for tablegen is set on the add_custom_command110 endif()111endif()112 113if( LLVM_ENABLE_ASSERTIONS )114 # MSVC doesn't like _DEBUG on release builds. See PR 4379.115 if( NOT MSVC )116 add_compile_definitions(_DEBUG)117 endif()118 # On non-Debug builds cmake automatically defines NDEBUG, so we119 # explicitly undefine it:120 if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )121 add_compile_options($<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-UNDEBUG>)122 if (MSVC)123 # Also remove /D NDEBUG to avoid MSVC warnings about conflicting defines.124 foreach (flags_var_to_scrub125 CMAKE_CXX_FLAGS_RELEASE126 CMAKE_CXX_FLAGS_RELWITHDEBINFO127 CMAKE_CXX_FLAGS_MINSIZEREL128 CMAKE_C_FLAGS_RELEASE129 CMAKE_C_FLAGS_RELWITHDEBINFO130 CMAKE_C_FLAGS_MINSIZEREL)131 string (REGEX REPLACE "(^| )[/-]D *NDEBUG($| )" " "132 "${flags_var_to_scrub}" "${${flags_var_to_scrub}}")133 endforeach()134 endif()135 endif()136 # Enable assertions in libstdc++.137 add_compile_definitions(_GLIBCXX_ASSERTIONS)138 # Cautiously enable the extensive hardening mode in libc++.139 if((DEFINED LIBCXX_HARDENING_MODE) AND140 (NOT LIBCXX_HARDENING_MODE STREQUAL "extensive"))141 message(WARNING "LLVM_ENABLE_ASSERTIONS implies LIBCXX_HARDENING_MODE \"extensive\" but is overriden from command line with value \"${LIBCXX_HARDENING_MODE}\".")142 else()143 set(LIBCXX_HARDENING_MODE "extensive")144 endif()145endif()146 147if(LLVM_ENABLE_EXPENSIVE_CHECKS)148 # When LLVM_ENABLE_EXPENSIVE_CHECKS is ON, LLVM will intercept errors149 # using assert(). An explicit check is performed here.150 if (NOT LLVM_ENABLE_ASSERTIONS)151 message(FATAL_ERROR "LLVM_ENABLE_EXPENSIVE_CHECKS requires LLVM_ENABLE_ASSERTIONS \"ON\".")152 endif()153 add_compile_definitions(EXPENSIVE_CHECKS)154 155 # In libstdc++ 9 and earlier, std::min_element is not constexpr when156 # _GLIBCXX_DEBUG is enabled.157 CHECK_CXX_SOURCE_COMPILES("158 #define _GLIBCXX_DEBUG159 #include <algorithm>160 int main(int argc, char** argv) {161 static constexpr int data[] = {0, 1};162 constexpr const int* min_elt = std::min_element(&data[0], &data[2]);163 return 0;164 }" CXX_SUPPORTS_GLIBCXX_DEBUG)165 if(CXX_SUPPORTS_GLIBCXX_DEBUG)166 add_compile_definitions(_GLIBCXX_DEBUG)167 else()168 add_compile_definitions(_GLIBCXX_ASSERTIONS)169 endif()170endif()171 172CHECK_CXX_SOURCE_COMPILES("173#include <iosfwd>174#if !defined(__GLIBCXX__)175#error Not libstdc++176#endif177int main() { return 0; }178" LLVM_USES_LIBSTDCXX)179 180CHECK_CXX_SOURCE_COMPILES("181#include <string>182#if _GLIBCXX_USE_CXX11_ABI == 0183#error _GLIBCXX_USE_CXX11_ABI not active184#endif185int main() { return 0; }186" LLVM_DEFAULT_TO_GLIBCXX_USE_CXX11_ABI)187 188option(GLIBCXX_USE_CXX11_ABI "Use new libstdc++ CXX11 ABI" ${LLVM_DEFAULT_TO_GLIBCXX_USE_CXX11_ABI})189 190if (LLVM_USES_LIBSTDCXX)191 if (GLIBCXX_USE_CXX11_ABI)192 add_compile_definitions(_GLIBCXX_USE_CXX11_ABI=1)193 else()194 add_compile_definitions(_GLIBCXX_USE_CXX11_ABI=0)195 endif()196endif()197 198string(TOUPPER "${LLVM_ABI_BREAKING_CHECKS}" uppercase_LLVM_ABI_BREAKING_CHECKS)199 200if( uppercase_LLVM_ABI_BREAKING_CHECKS STREQUAL "WITH_ASSERTS" )201 if( LLVM_ENABLE_ASSERTIONS )202 set( LLVM_ENABLE_ABI_BREAKING_CHECKS 1 )203 endif()204elseif( uppercase_LLVM_ABI_BREAKING_CHECKS STREQUAL "FORCE_ON" )205 set( LLVM_ENABLE_ABI_BREAKING_CHECKS 1 )206elseif( uppercase_LLVM_ABI_BREAKING_CHECKS STREQUAL "FORCE_OFF" )207 # We don't need to do anything special to turn off ABI breaking checks.208elseif( NOT DEFINED LLVM_ABI_BREAKING_CHECKS )209 # Treat LLVM_ABI_BREAKING_CHECKS like "FORCE_OFF" when it has not been210 # defined.211else()212 message(FATAL_ERROR "Unknown value for LLVM_ABI_BREAKING_CHECKS: \"${LLVM_ABI_BREAKING_CHECKS}\"!")213endif()214 215string(TOUPPER "${LLVM_ENABLE_DEBUGLOC_COVERAGE_TRACKING}" uppercase_LLVM_ENABLE_DEBUGLOC_COVERAGE_TRACKING)216 217if( uppercase_LLVM_ENABLE_DEBUGLOC_COVERAGE_TRACKING STREQUAL "COVERAGE" )218 set( LLVM_ENABLE_DEBUGLOC_TRACKING_COVERAGE 1 )219elseif( uppercase_LLVM_ENABLE_DEBUGLOC_COVERAGE_TRACKING STREQUAL "COVERAGE_AND_ORIGIN" )220 set( LLVM_ENABLE_DEBUGLOC_TRACKING_COVERAGE 1 )221 set( LLVM_ENABLE_DEBUGLOC_TRACKING_ORIGIN 1 )222elseif( uppercase_LLVM_ENABLE_DEBUGLOC_COVERAGE_TRACKING STREQUAL "DISABLED" OR NOT DEFINED LLVM_ENABLE_DEBUGLOC_COVERAGE_TRACKING )223 # The DISABLED setting is default.224 set( LLVM_ENABLE_DEBUGLOC_TRACKING_COVERAGE 0 )225else()226 message(FATAL_ERROR "Unknown value for LLVM_ENABLE_DEBUGLOC_COVERAGE_TRACKING: \"${LLVM_ENABLE_DEBUGLOC_COVERAGE_TRACKING}\"!")227endif()228# LLVM_ENABLE_DEBUGLOC_TRACKING_COVERAGE (non-cached) is expected to be229# 1 or 0 here, assuming referenced in #cmakedefine01.230 231if( LLVM_REVERSE_ITERATION )232 set( LLVM_ENABLE_REVERSE_ITERATION 1 )233endif()234 235if(WIN32 OR CYGWIN)236 set(LLVM_HAVE_LINK_VERSION_SCRIPT 0)237 if(CYGWIN)238 set(LLVM_ON_WIN32 0)239 set(LLVM_ON_UNIX 1)240 else()241 set(LLVM_ON_WIN32 1)242 set(LLVM_ON_UNIX 0)243 endif()244elseif(FUCHSIA OR UNIX)245 set(LLVM_ON_WIN32 0)246 set(LLVM_ON_UNIX 1)247 if(APPLE OR "${CMAKE_SYSTEM_NAME}" MATCHES "AIX")248 set(LLVM_HAVE_LINK_VERSION_SCRIPT 0)249 else()250 set(LLVM_HAVE_LINK_VERSION_SCRIPT 1)251 endif()252elseif(CMAKE_SYSTEM_NAME STREQUAL "Generic")253 set(LLVM_ON_WIN32 0)254 set(LLVM_ON_UNIX 0)255 set(LLVM_HAVE_LINK_VERSION_SCRIPT 0)256else()257 MESSAGE(SEND_ERROR "Unable to determine platform")258endif()259 260if (CMAKE_SYSTEM_NAME MATCHES "OS390")261 set(LLVM_HAVE_LINK_VERSION_SCRIPT 0)262endif()263 264set(EXEEXT ${CMAKE_EXECUTABLE_SUFFIX})265set(LTDL_SHLIB_EXT ${CMAKE_SHARED_LIBRARY_SUFFIX})266 267# We use *.dylib rather than *.so on darwin, but we stick with *.so on AIX.268if("${CMAKE_SYSTEM_NAME}" MATCHES "AIX")269 set(LLVM_PLUGIN_EXT ${CMAKE_SHARED_MODULE_SUFFIX})270else()271 set(LLVM_PLUGIN_EXT ${CMAKE_SHARED_LIBRARY_SUFFIX})272endif()273 274if(APPLE)275 # Darwin-specific linker flags for loadable modules.276 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,-flat_namespace -Wl,-undefined -Wl,dynamic_lookup")277endif()278 279if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")280 # RHEL7 has ar and ranlib being non-deterministic by default. The D flag forces determinism,281 # however only GNU version of ar and ranlib (2.27) have this option.282 # RHEL DTS7 is also affected by this, which uses GNU binutils 2.28283 execute_process(COMMAND ${CMAKE_AR} rD t.a284 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}285 RESULT_VARIABLE AR_RESULT286 OUTPUT_QUIET287 ERROR_QUIET288 )289 if(${AR_RESULT} EQUAL 0)290 execute_process(COMMAND ${CMAKE_RANLIB} -D t.a291 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}292 RESULT_VARIABLE RANLIB_RESULT293 OUTPUT_QUIET294 ERROR_QUIET295 )296 if(${RANLIB_RESULT} EQUAL 0)297 set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> Dqc <TARGET> <LINK_FLAGS> <OBJECTS>"298 CACHE STRING "archive create command")299 set(CMAKE_C_ARCHIVE_APPEND "<CMAKE_AR> Dq <TARGET> <LINK_FLAGS> <OBJECTS>")300 set(CMAKE_C_ARCHIVE_FINISH "<CMAKE_RANLIB> -D <TARGET>" CACHE STRING "ranlib command")301 302 set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> Dqc <TARGET> <LINK_FLAGS> <OBJECTS>"303 CACHE STRING "archive create command")304 set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> Dq <TARGET> <LINK_FLAGS> <OBJECTS>")305 set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -D <TARGET>" CACHE STRING "ranlib command")306 endif()307 file(REMOVE ${CMAKE_BINARY_DIR}/t.a)308 endif()309endif()310 311if("${CMAKE_SYSTEM_NAME}" MATCHES "AIX")312 # -fPIC does not enable the large code model for GCC on AIX but does for XL.313 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")314 append("-mcmodel=large" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)315 append("-Wl,-bglink=large"316 CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)317 elseif(CMAKE_CXX_COMPILER_ID MATCHES "XL")318 # XL generates a small number of relocations not of the large model, -bbigtoc is needed.319 append("-Wl,-bbigtoc"320 CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)321 # The default behaviour on AIX processes dynamic initialization of non-local variables with322 # static storage duration even for archive members that are otherwise unreferenced.323 # Since `--whole-archive` is not used by the LLVM build to keep such initializations for Linux,324 # we can limit the processing for archive members to only those that are otherwise referenced.325 append("-bcdtors:mbr"326 CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)327 endif()328 if(BUILD_SHARED_LIBS)329 # See rpath handling in AddLLVM.cmake330 # FIXME: Remove this warning if this rpath is no longer hardcoded.331 message(WARNING "Build and install environment path info may be exposed; binaries will also be unrelocatable.")332 endif()333endif()334 335# Pass -Wl,-z,defs. This makes sure all symbols are defined. Otherwise a DSO336# build might work on ELF but fail on MachO/COFF.337if(NOT (CMAKE_SYSTEM_NAME MATCHES "Darwin|FreeBSD|OpenBSD|DragonFly|AIX|OS390|Emscripten" OR338 WIN32 OR CYGWIN) AND339 NOT LLVM_USE_SANITIZER)340 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,defs")341endif()342 343# Pass -Wl,-z,nodelete. This makes sure our shared libraries are not unloaded344# by dlclose(). We need that since the CLI API relies on cross-references345# between global objects which became horribly broken when one of the libraries346# is unloaded.347if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")348 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,nodelete")349 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,-z,nodelete")350endif()351 352 353function(append value)354 foreach(variable ${ARGN})355 set(${variable} "${${variable}} ${value}" PARENT_SCOPE)356 endforeach(variable)357endfunction()358 359function(prepend value)360 foreach(variable ${ARGN})361 set(${variable} "${value} ${${variable}}" PARENT_SCOPE)362 endforeach(variable)363endfunction()364 365function(append_if condition value)366 if (${condition})367 foreach(variable ${ARGN})368 set(${variable} "${${variable}} ${value}" PARENT_SCOPE)369 endforeach(variable)370 endif()371endfunction()372 373macro(add_flag_if_supported flag name)374 check_c_compiler_flag("-Werror ${flag}" "C_SUPPORTS_${name}")375 append_if("C_SUPPORTS_${name}" "${flag}" CMAKE_C_FLAGS)376 check_cxx_compiler_flag("-Werror ${flag}" "CXX_SUPPORTS_${name}")377 append_if("CXX_SUPPORTS_${name}" "${flag}" CMAKE_CXX_FLAGS)378endmacro()379 380function(add_flag_or_print_warning flag name)381 check_c_compiler_flag("-Werror ${flag}" "C_SUPPORTS_${name}")382 check_cxx_compiler_flag("-Werror ${flag}" "CXX_SUPPORTS_${name}")383 if (C_SUPPORTS_${name} AND CXX_SUPPORTS_${name})384 message(STATUS "Building with ${flag}")385 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" PARENT_SCOPE)386 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" PARENT_SCOPE)387 set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${flag}" PARENT_SCOPE)388 else()389 message(WARNING "${flag} is not supported.")390 endif()391endfunction()392 393function(has_msvc_incremental_no_flag flags incr_no_flag_on)394 set(${incr_no_flag_on} OFF PARENT_SCOPE)395 string(FIND "${flags}" "/INCREMENTAL" idx REVERSE)396 if (${idx} GREATER -1)397 string(SUBSTRING "${flags}" ${idx} 15 no_flag)398 if (${no_flag} MATCHES "/INCREMENTAL:NO")399 set(${incr_no_flag_on} ON PARENT_SCOPE)400 endif()401 endif()402endfunction()403 404if( LLVM_ENABLE_LLD )405 if ( LLVM_USE_LINKER )406 message(FATAL_ERROR "LLVM_ENABLE_LLD and LLVM_USE_LINKER can't be set at the same time")407 endif()408 409 # In case of MSVC cmake always invokes the linker directly, so the linker410 # should be specified by CMAKE_LINKER cmake variable instead of by -fuse-ld411 # compiler option.412 if ( MSVC )413 if(NOT CMAKE_LINKER MATCHES "lld-link")414 get_filename_component(CXX_COMPILER_DIR ${CMAKE_CXX_COMPILER} DIRECTORY)415 get_filename_component(C_COMPILER_DIR ${CMAKE_C_COMPILER} DIRECTORY)416 find_program(LLD_LINK NAMES "lld-link" "lld-link.exe" HINTS ${CXX_COMPILER_DIR} ${C_COMPILER_DIR} DOC "lld linker")417 if(NOT LLD_LINK)418 message(FATAL_ERROR419 "LLVM_ENABLE_LLD set, but cannot find lld-link. "420 "Consider setting CMAKE_LINKER to lld-link path.")421 endif()422 set(CMAKE_LINKER ${LLD_LINK})423 endif()424 else()425 set(LLVM_USE_LINKER "lld")426 endif()427endif()428 429if( LLVM_USE_LINKER )430 append("-fuse-ld=${LLVM_USE_LINKER}"431 CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)432 check_cxx_source_compiles("int main() { return 0; }" CXX_SUPPORTS_CUSTOM_LINKER)433 if ( NOT CXX_SUPPORTS_CUSTOM_LINKER )434 message(FATAL_ERROR "Host compiler does not support '-fuse-ld=${LLVM_USE_LINKER}'. "435 "Please make sure that '${LLVM_USE_LINKER}' is installed and "436 "that your host compiler can compile a simple program when "437 "given the option '-fuse-ld=${LLVM_USE_LINKER}'.")438 endif()439endif()440 441if( LLVM_ENABLE_PIC )442 if( XCODE )443 # Xcode has -mdynamic-no-pic on by default, which overrides -fPIC. I don't444 # know how to disable this, so just force ENABLE_PIC off for now.445 message(WARNING "-fPIC not supported with Xcode.")446 elseif( WIN32 OR CYGWIN)447 # On Windows all code is PIC. MinGW warns if -fPIC is used.448 else()449 add_flag_or_print_warning("-fPIC" FPIC)450 # Enable interprocedural optimizations for non-inline functions which would451 # otherwise be disabled due to GCC -fPIC's default.452 # Note: GCC<10.3 has a bug on SystemZ.453 # Note: Default on AIX is "no semantic interposition".454 # Note: Clang allows IPO for -fPIC so this optimization is less effective.455 # Clang 13 has a bug related to -fsanitize-coverage456 # -fno-semantic-interposition (https://reviews.llvm.org/D117183).457 if ((NOT ("${CMAKE_SYSTEM_NAME}" MATCHES "AIX"))458 AND ((CMAKE_COMPILER_IS_GNUCXX AND459 NOT (LLVM_NATIVE_ARCH STREQUAL "SystemZ"460 AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.3))461 OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"462 AND CMAKE_CXX_COMPILER_VERSION GREATER_EQUAL 14)))463 add_flag_if_supported("-fno-semantic-interposition" FNO_SEMANTIC_INTERPOSITION)464 endif()465 endif()466 # GCC for MIPS can miscompile LLVM due to PR37701.467 if(CMAKE_COMPILER_IS_GNUCXX AND LLVM_NATIVE_ARCH STREQUAL "Mips" AND468 NOT Uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")469 append("-fno-shrink-wrap" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)470 endif()471 # gcc with -O3 -fPIC generates TLS sequences that violate the spec on472 # Solaris/sparcv9, causing executables created with the system linker473 # to SEGV (GCC PR target/96607).474 # clang with -O3 -fPIC generates code that SEGVs.475 # Both can be worked around by compiling with -O instead.476 if("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS" AND LLVM_NATIVE_ARCH STREQUAL "Sparc")477 llvm_replace_compiler_option(CMAKE_CXX_FLAGS_RELEASE "-O[23]" "-O")478 llvm_replace_compiler_option(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O[23]" "-O")479 endif()480endif()481 482if((NOT ("${CMAKE_SYSTEM_NAME}" MATCHES "AIX")) AND483 (NOT (WIN32 OR CYGWIN) OR ((MINGW OR CYGWIN) AND CMAKE_CXX_COMPILER_ID MATCHES "Clang")))484 # GCC for MinGW does nothing about -fvisibility-inlines-hidden, but warns485 # about use of the attributes. As long as we don't use the attributes (to486 # override the default) we shouldn't set the command line options either.487 # GCC on AIX warns if -fvisibility-inlines-hidden is used and Clang on AIX doesn't currently support visibility.488 check_cxx_compiler_flag("-fvisibility-inlines-hidden" SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG)489 append_if(SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG "-fvisibility-inlines-hidden" CMAKE_CXX_FLAGS)490endif()491 492if(CMAKE_SIZEOF_VOID_P EQUAL 8 AND MINGW)493 add_compile_definitions(_FILE_OFFSET_BITS=64)494endif()495 496if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32 )497 # TODO: support other platforms and toolchains.498 if( LLVM_BUILD_32_BITS )499 message(STATUS "Building 32 bits executables and libraries.")500 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32")501 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32")502 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -m32")503 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -m32")504 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -m32")505 506 # FIXME: CMAKE_SIZEOF_VOID_P is still 8507 add_compile_definitions(_LARGEFILE_SOURCE)508 add_compile_definitions(_FILE_OFFSET_BITS=64)509 endif( LLVM_BUILD_32_BITS )510endif( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32 )511 512# If building on a GNU specific 32-bit system, make sure off_t is 64 bits513# so that off_t can stored offset > 2GB.514# Android until version N (API 24) doesn't support it.515if (ANDROID AND (ANDROID_NATIVE_API_LEVEL LESS 24))516 set(LLVM_FORCE_SMALLFILE_FOR_ANDROID TRUE)517endif()518if( CMAKE_SIZEOF_VOID_P EQUAL 4 AND NOT LLVM_FORCE_SMALLFILE_FOR_ANDROID)519 # FIXME: It isn't handled in LLVM_BUILD_32_BITS.520 add_compile_definitions(_LARGEFILE_SOURCE)521 add_compile_definitions(_FILE_OFFSET_BITS=64)522endif()523 524if( XCODE )525 # For Xcode enable several build settings that correspond to526 # many warnings that are on by default in Clang but are527 # not enabled for historical reasons. For versions of Xcode528 # that do not support these options they will simply529 # be ignored.530 set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_RETURN_TYPE "YES")531 set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_MISSING_NEWLINE "YES")532 set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_VALUE "YES")533 set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_VARIABLE "YES")534 set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_SIGN_COMPARE "YES")535 set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_FUNCTION "YES")536 set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED "YES")537 set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS "YES")538 set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNINITIALIZED_AUTOS "YES")539 set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_BOOL_CONVERSION "YES")540 set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_EMPTY_BODY "YES")541 set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_ENUM_CONVERSION "YES")542 set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_INT_CONVERSION "YES")543 set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_CONSTANT_CONVERSION "YES")544 set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_NON_VIRTUAL_DESTRUCTOR "YES")545endif()546 547# On Win32 using MS tools, provide an option to set the number of parallel jobs548# to use.549if( MSVC_IDE )550 set(LLVM_COMPILER_JOBS "0" CACHE STRING551 "Number of parallel compiler jobs. 0 means use all processors. Default is 0.")552 if( NOT LLVM_COMPILER_JOBS STREQUAL "1" )553 if( LLVM_COMPILER_JOBS STREQUAL "0" )554 add_compile_options(/MP)555 else()556 message(STATUS "Number of parallel compiler jobs set to " ${LLVM_COMPILER_JOBS})557 add_compile_options(/MP${LLVM_COMPILER_JOBS})558 endif()559 else()560 message(STATUS "Parallel compilation disabled")561 endif()562endif()563 564# set stack reserved size to ~10MB565if(MSVC)566 # CMake previously automatically set this value for MSVC builds, but the567 # behavior was changed in CMake 2.8.11 (Issue 12437) to use the MSVC default568 # value (1 MB) which is not enough for us in tasks such as parsing recursive569 # C++ templates in Clang.570 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_CXX_LINKER_WRAPPER_FLAG}/STACK:10000000")571elseif(MINGW OR CYGWIN)572 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,16777216")573 574 # Pass -mbig-obj to mingw gas to avoid COFF 2**16 section limit.575 if (NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang")576 append("-Wa,-mbig-obj" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)577 endif()578endif()579 580option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)581 582if( MSVC )583 584 # Add definitions that make MSVC much less annoying.585 add_compile_definitions(586 # For some reason MS wants to deprecate a bunch of standard functions...587 _CRT_SECURE_NO_DEPRECATE588 _CRT_SECURE_NO_WARNINGS589 _CRT_NONSTDC_NO_DEPRECATE590 _CRT_NONSTDC_NO_WARNINGS591 _SCL_SECURE_NO_DEPRECATE592 _SCL_SECURE_NO_WARNINGS593 )594 595 # Tell MSVC to use the Unicode version of the Win32 APIs instead of ANSI.596 add_compile_definitions(597 UNICODE598 _UNICODE599 )600 601 if (LLVM_WINSYSROOT)602 if (NOT CLANG_CL)603 message(ERROR "LLVM_WINSYSROOT requires clang-cl")604 endif()605 append("/winsysroot${LLVM_WINSYSROOT}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)606 if (LINKER_IS_LLD_LINK)607 append("/winsysroot:${LLVM_WINSYSROOT}"608 CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS609 CMAKE_SHARED_LINKER_FLAGS)610 endif()611 endif()612 613 if (LLVM_ENABLE_WERROR)614 append("/WX" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)615 endif (LLVM_ENABLE_WERROR)616 617 append("/Zc:inline" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)618 619 if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")620 # Enable standards-conforming preprocessor.621 # https://learn.microsoft.com/en-us/cpp/build/reference/zc-preprocessor622 append("/Zc:preprocessor" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)623 endif ()624 625 # Some projects use the __cplusplus preprocessor macro to check support for626 # a particular version of the C++ standard. When this option is not specified627 # explicitly, macro's value is "199711L" that implies C++98 Standard.628 # https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/629 append("/Zc:__cplusplus" CMAKE_CXX_FLAGS)630 631 # Allow users to request PDBs in release mode. CMake offeres the632 # RelWithDebInfo configuration, but it uses different optimization settings633 # (/Ob1 vs /Ob2 or -O2 vs -O3). LLVM provides this flag so that users can get634 # PDBs without changing codegen.635 option(LLVM_ENABLE_PDB OFF)636 if (LLVM_ENABLE_PDB AND uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")637 append("/Zi" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)638 # /DEBUG disables linker GC and ICF, but we want those in Release mode.639 append("/DEBUG /OPT:REF /OPT:ICF"640 CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS641 CMAKE_SHARED_LINKER_FLAGS)642 endif()643 644 # Get all linker flags in upper case form so we can search them.645 string(CONCAT all_linker_flags_uppercase646 ${CMAKE_EXE_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} " "647 ${CMAKE_EXE_LINKER_FLAGS} " "648 ${CMAKE_MODULE_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} " "649 ${CMAKE_MODULE_LINKER_FLAGS} " "650 ${CMAKE_SHARED_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} " "651 ${CMAKE_SHARED_LINKER_FLAGS})652 string(TOUPPER "${all_linker_flags_uppercase}" all_linker_flags_uppercase)653 654 if (CLANG_CL AND LINKER_IS_LLD)655 # If we are using clang-cl with lld-link and /debug is present in any of the656 # linker flag variables, pass -gcodeview-ghash to the compiler to speed up657 # linking. This flag is orthogonal from /Zi, /Z7, and other flags that658 # enable debug info emission, and only has an effect if those are also in659 # use.660 string(FIND "${all_linker_flags_uppercase}" "/DEBUG" linker_flag_idx)661 if (${linker_flag_idx} GREATER -1)662 add_flag_if_supported("-gcodeview-ghash" GCODEVIEW_GHASH)663 endif()664 endif()665 666 # "Generate Intrinsic Functions".667 append("/Oi" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)668 669 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT LLVM_ENABLE_LTO)670 # clang-cl and cl by default produce non-deterministic binaries because671 # link.exe /incremental requires a timestamp in the .obj file. clang-cl672 # has the flag /Brepro to force deterministic binaries. We want to pass that673 # whenever you're building with clang unless you're passing /incremental674 # or using LTO (/Brepro with LTO would result in a warning about the flag675 # being unused, because we're not generating object files).676 # This checks CMAKE_CXX_COMPILER_ID in addition to check_cxx_compiler_flag()677 # because cl.exe does not emit an error on flags it doesn't understand,678 # letting check_cxx_compiler_flag() claim it understands all flags.679 680 # Check if /INCREMENTAL is passed to the linker and complain that it681 # won't work with /Brepro.682 has_msvc_incremental_no_flag("${CMAKE_EXE_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${CMAKE_EXE_LINKER_FLAGS}" NO_INCR_EXE)683 has_msvc_incremental_no_flag("${CMAKE_MODULE_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${CMAKE_MODULE_LINKER_FLAGS}" NO_INCR_MODULE)684 has_msvc_incremental_no_flag("${CMAKE_SHARED_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${CMAKE_SHARED_LINKER_FLAGS}" NO_INCR_SHARED)685 if (NO_INCR_EXE AND NO_INCR_MODULE AND NO_INCR_SHARED)686 append("/Brepro" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)687 else()688 message(WARNING "/Brepro not compatible with /INCREMENTAL linking - builds will be non-deterministic")689 endif()690 endif()691 # By default MSVC has a 2^16 limit on the number of sections in an object file,692 # but in many objects files need more than that. This flag is to increase the693 # number of sections.694 append("/bigobj" CMAKE_CXX_FLAGS)695 696 # Enable standards conformance mode.697 # This ensures handling of various C/C++ constructs is more similar to other compilers.698 append("/permissive-" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)699endif( MSVC )700 701# Warnings-as-errors handling for GCC-compatible compilers:702if ( LLVM_COMPILER_IS_GCC_COMPATIBLE )703 append_if(LLVM_ENABLE_WERROR "-Werror" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)704 append_if(LLVM_ENABLE_WERROR "-Wno-error" CMAKE_REQUIRED_FLAGS)705endif( LLVM_COMPILER_IS_GCC_COMPATIBLE )706 707# Specific default warnings-as-errors for compilers accepting GCC-compatible warning flags:708if ( LLVM_COMPILER_IS_GCC_COMPATIBLE OR CMAKE_CXX_COMPILER_ID MATCHES "XL" )709 append("-Werror=date-time" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)710endif( LLVM_COMPILER_IS_GCC_COMPATIBLE OR CMAKE_CXX_COMPILER_ID MATCHES "XL" )711 712if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")713 append("-Werror=unguarded-availability-new" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)714endif()715 716if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND LLVM_ENABLE_LTO)717 # LLVM data structures like llvm::User and llvm::MDNode rely on718 # the value of object storage persisting beyond the lifetime of the719 # object (#24952). This is not standard compliant and causes a runtime720 # crash if LLVM is built with GCC and LTO enabled (#57740). Until721 # these bugs are fixed, we need to disable dead store eliminations722 # based on object lifetime.723 append("-fno-lifetime-dse" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)724endif ()725 726# Modules enablement for GCC-compatible compilers:727if ( LLVM_COMPILER_IS_GCC_COMPATIBLE AND LLVM_ENABLE_MODULES )728 set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})729 set(module_flags "-fmodules -fmodules-cache-path=${PROJECT_BINARY_DIR}/module.cache")730 if ("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")731 # On Darwin -fmodules does not imply -fcxx-modules.732 set(module_flags "${module_flags} -fcxx-modules")733 endif()734 if (LLVM_ENABLE_LOCAL_SUBMODULE_VISIBILITY)735 set(module_flags "${module_flags} -Xclang -fmodules-local-submodule-visibility")736 endif()737 if (LLVM_ENABLE_MODULE_DEBUGGING AND738 ((uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") OR739 (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")))740 set(module_flags "${module_flags} -gmodules")741 endif()742 append("${module_flags}" CMAKE_CXX_FLAGS)743endif( LLVM_COMPILER_IS_GCC_COMPATIBLE AND LLVM_ENABLE_MODULES )744 745if (MSVC)746 if (NOT CLANG_CL)747 set(msvc_warning_flags748 # Disabled warnings.749 -wd4141 # Suppress ''modifier' : used more than once' (because of __forceinline combined with inline)750 -wd4146 # Suppress 'unary minus operator applied to unsigned type, result still unsigned'751 -wd4244 # Suppress ''argument' : conversion from 'type1' to 'type2', possible loss of data'752 -wd4267 # Suppress ''var' : conversion from 'size_t' to 'type', possible loss of data'753 -wd4291 # Suppress ''declaration' : no matching operator delete found; memory will not be freed if initialization throws an exception'754 -wd4351 # Suppress 'new behavior: elements of array 'array' will be default initialized'755 -wd4456 # Suppress 'declaration of 'var' hides local variable'756 -wd4457 # Suppress 'declaration of 'var' hides function parameter'757 -wd4458 # Suppress 'declaration of 'var' hides class member'758 -wd4459 # Suppress 'declaration of 'var' hides global declaration'759 -wd4503 # Suppress ''identifier' : decorated name length exceeded, name was truncated'760 -wd4624 # Suppress ''derived class' : destructor could not be generated because a base class destructor is inaccessible'761 -wd4722 # Suppress 'function' : destructor never returns, potential memory leak762 -wd4100 # Suppress 'unreferenced formal parameter'763 -wd4127 # Suppress 'conditional expression is constant'764 -wd4512 # Suppress 'assignment operator could not be generated'765 -wd4505 # Suppress 'unreferenced local function has been removed'766 -wd4610 # Suppress '<class> can never be instantiated'767 -wd4510 # Suppress 'default constructor could not be generated'768 -wd4702 # Suppress 'unreachable code'769 -wd4245 # Suppress ''conversion' : conversion from 'type1' to 'type2', signed/unsigned mismatch'770 -wd4706 # Suppress 'assignment within conditional expression'771 -wd4310 # Suppress 'cast truncates constant value'772 -wd4701 # Suppress 'potentially uninitialized local variable'773 -wd4703 # Suppress 'potentially uninitialized local pointer variable'774 -wd4389 # Suppress 'signed/unsigned mismatch'775 -wd4611 # Suppress 'interaction between '_setjmp' and C++ object destruction is non-portable'776 -wd4805 # Suppress 'unsafe mix of type <type> and type <type> in operation'777 -wd4204 # Suppress 'nonstandard extension used : non-constant aggregate initializer'778 -wd4577 # Suppress 'noexcept used with no exception handling mode specified; termination on exception is not guaranteed'779 -wd4091 # Suppress 'typedef: ignored on left of '' when no variable is declared'780 # C4592 is disabled because of false positives in Visual Studio 2015781 # Update 1. Re-evaluate the usefulness of this diagnostic with Update 2.782 -wd4592 # Suppress ''var': symbol will be dynamically initialized (implementation limitation)783 -wd4319 # Suppress ''operator' : zero extending 'type' to 'type' of greater size'784 # C4709 is disabled because of a bug with Visual Studio 2017 as of785 # v15.8.8. Re-evaluate the usefulness of this diagnostic when the bug786 # is fixed.787 -wd4709 # Suppress comma operator within array index expression788 789 # We'd like this warning to be enabled, but it triggers from code in790 # WinBase.h that we don't have control over.791 -wd5105 # Suppress macro expansion producing 'defined' has undefined behavior792 793 # Ideally, we'd like this warning to be enabled, but even MSVC 2019 doesn't794 # support the 'aligned' attribute in the way that clang sources requires (for795 # any code that uses the LLVM_ALIGNAS macro), so this is must be disabled to796 # avoid unwanted alignment warnings.797 -wd4324 # Suppress 'structure was padded due to __declspec(align())'798 # This is triggered for every variable that is a template type of a class even 799 # if there private when the class is dllexport'ed800 -wd4251 # Suppress 'needs to have dll-interface to be used by clients'801 # We only putting dll export on classes with out of line members so this 802 # warning gets triggered a lot for bases we haven't exported'803 -wd4275 # non dll-interface class used as base for dll-interface class804 805 # Promoted warnings.806 -w14062 # Promote 'enumerator in switch of enum is not handled' to level 1 warning.807 808 # Promoted warnings to errors.809 -we4238 # Promote 'nonstandard extension used : class rvalue used as lvalue' to error.810 )811 endif(NOT CLANG_CL)812 813 # Enable warnings814 if (LLVM_ENABLE_WARNINGS)815 # Put /W4 in front of all the -we flags. cl.exe doesn't care, but for816 # clang-cl having /W4 after the -we flags will re-enable the warnings817 # disabled by -we.818 set(msvc_warning_flags "/W4 ${msvc_warning_flags}")819 # CMake appends /W3 by default, and having /W3 followed by /W4 will result in820 # cl : Command line warning D9025 : overriding '/W3' with '/W4'. Since this is821 # a command line warning and not a compiler warning, it cannot be suppressed except822 # by fixing the command line.823 string(REGEX REPLACE " /W[0-4]" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")824 string(REGEX REPLACE " /W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")825 826 if (LLVM_ENABLE_PEDANTIC)827 # No MSVC equivalent available828 endif (LLVM_ENABLE_PEDANTIC)829 endif (LLVM_ENABLE_WARNINGS)830 831 foreach(flag ${msvc_warning_flags})832 append("${flag}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)833 endforeach(flag)834endif (MSVC)835 836if (LLVM_ENABLE_WARNINGS AND (LLVM_COMPILER_IS_GCC_COMPATIBLE OR CLANG_CL))837 838 # Don't add -Wall for clang-cl, because it maps -Wall to -Weverything for839 # MSVC compatibility. /W4 is added above instead.840 if (NOT CLANG_CL)841 append("-Wall" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)842 endif()843 844 append("-Wextra -Wno-unused-parameter -Wwrite-strings" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)845 append("-Wcast-qual" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)846 847 # Turn off missing field initializer warnings for gcc to avoid noise from848 # false positives with empty {}. Turn them on otherwise (they're off by849 # default for clang).850 if (CMAKE_COMPILER_IS_GNUCXX)851 append("-Wno-missing-field-initializers" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)852 else()853 append("-Wmissing-field-initializers" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)854 endif()855 856 if (LLVM_ENABLE_PEDANTIC AND LLVM_COMPILER_IS_GCC_COMPATIBLE)857 append("-pedantic" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)858 append("-Wno-long-long" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)859 860 # GCC warns about redundant toplevel semicolons (enabled by -pedantic861 # above), while Clang doesn't. Enable the corresponding Clang option to862 # pick up on these even in builds with Clang.863 add_flag_if_supported("-Wc++98-compat-extra-semi" CXX98_COMPAT_EXTRA_SEMI_FLAG)864 endif()865 866 append("-Wimplicit-fallthrough" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)867 868 set(CXX_SUPPORTS_COVERED_SWITCH_DEFAULT_FLAG 0)869 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")870 set(CXX_SUPPORTS_COVERED_SWITCH_DEFAULT_FLAG 1)871 append("-Wcovered-switch-default" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)872 endif()873 append_if(USE_NO_UNINITIALIZED "-Wno-uninitialized" CMAKE_CXX_FLAGS)874 append_if(USE_NO_MAYBE_UNINITIALIZED "-Wno-maybe-uninitialized" CMAKE_CXX_FLAGS)875 876 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")877 # Disable -Wnonnull for GCC warning as it is emitting a lot of false positives.878 append("-Wno-nonnull" CMAKE_CXX_FLAGS)879 880 # Disable -Wclass-memaccess, a C++-only warning from GCC 8 that fires on881 # LLVM's ADT classes.882 if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)883 append("-Wno-class-memaccess" CMAKE_CXX_FLAGS)884 endif()885 886 # Disable -Wdangling-reference, a C++-only warning from GCC 13 that seems887 # to produce a large number of false positives.888 if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 13.1)889 append("-Wno-dangling-reference" CMAKE_CXX_FLAGS)890 endif()891 892 # Disable -Wredundant-move and -Wpessimizing-move on GCC>=9. GCC wants to893 # remove std::move in code like894 # "A foo(ConvertibleToA a) { return std::move(a); }",895 # but this code does not compile (or uses the copy896 # constructor instead) on clang<=3.8. Clang also has a -Wredundant-move and897 # -Wpessimizing-move, but they only fire when the types match exactly, so we898 # can keep them here.899 if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 9.1)900 append("-Wno-redundant-move" CMAKE_CXX_FLAGS)901 append("-Wno-pessimizing-move" CMAKE_CXX_FLAGS)902 endif()903 904 # Disable -Warray-bounds on GCC; this warning exists since a very long time,905 # but since GCC 11, it produces a lot of very noisy, seemingly false positive906 # warnings (potentially originating in libstdc++).907 append("-Wno-array-bounds" CMAKE_CXX_FLAGS)908 909 # Disable -Wstringop-overread on GCC; this warning produces a number of very910 # noisy diagnostics when -Warray-bounds is disabled above; this option exists911 # since GCC 11.912 if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 11.1)913 append("-Wno-stringop-overread" CMAKE_CXX_FLAGS)914 endif()915 endif()916 917 # The LLVM libraries have no stable C++ API, so -Wnoexcept-type is not useful.918 append("-Wno-noexcept-type" CMAKE_CXX_FLAGS)919 920 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")921 append("-Wnon-virtual-dtor" CMAKE_CXX_FLAGS)922 endif()923 append("-Wdelete-non-virtual-dtor" CMAKE_CXX_FLAGS)924 925 # Enable -Wsuggest-override if it's available, and only if it doesn't926 # suggest adding 'override' to functions that are already marked 'final'927 # (which means it is disabled for GCC < 9.2).928 check_cxx_compiler_flag("-Wsuggest-override" CXX_SUPPORTS_SUGGEST_OVERRIDE_FLAG)929 if (CXX_SUPPORTS_SUGGEST_OVERRIDE_FLAG)930 set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})931 set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror=suggest-override")932 CHECK_CXX_SOURCE_COMPILES("class base {public: virtual void anchor();};933 class derived : base {public: void anchor() final;};934 int main() { return 0; }"935 CXX_WSUGGEST_OVERRIDE_ALLOWS_ONLY_FINAL)936 set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})937 append_if(CXX_WSUGGEST_OVERRIDE_ALLOWS_ONLY_FINAL "-Wsuggest-override" CMAKE_CXX_FLAGS)938 endif()939 940 # Check if -Wcomment is OK with an // comment ending with '\' if the next941 # line is also a // comment.942 set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})943 set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror -Wcomment")944 CHECK_C_SOURCE_COMPILES("// \\\\\\n//\\nint main(void) {return 0;}"945 C_WCOMMENT_ALLOWS_LINE_WRAP)946 set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})947 if (NOT C_WCOMMENT_ALLOWS_LINE_WRAP)948 append("-Wno-comment" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)949 endif()950 951 # Enable -Wstring-conversion to catch misuse of string literals.952 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")953 append("-Wstring-conversion" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)954 955 # Disable -Wno-pass-failed flag, which reports failure to perform956 # optimizations suggested by pragmas. This warning is not relevant for LLVM957 # projects and may be injected by pragmas in libstdc++.958 # FIXME: Reconsider this choice if warnings from STL headers can be reliably959 # avoided (https://github.com/llvm/llvm-project/issues/157666).960 # This option has been available since Clang 3.5, and we do require a newer961 # version.962 append("-Wno-pass-failed" CMAKE_CXX_FLAGS)963 endif()964 965 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")966 # Disable the misleading indentation warning with GCC; GCC can967 # produce noisy notes about this getting disabled in large files.968 # See e.g. https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89549969 append("-Wno-misleading-indentation" CMAKE_CXX_FLAGS)970 else()971 # Prevent bugs that can happen with llvm's brace style.972 add_flag_if_supported("-Wmisleading-indentation" MISLEADING_INDENTATION_FLAG)973 endif()974 975 # Enable -Wctad-maybe-unsupported to catch unintended use of CTAD.976 add_flag_if_supported("-Wctad-maybe-unsupported" CTAD_MAYBE_UNSPPORTED_FLAG)977endif (LLVM_ENABLE_WARNINGS AND (LLVM_COMPILER_IS_GCC_COMPATIBLE OR CLANG_CL))978 979if (LLVM_COMPILER_IS_GCC_COMPATIBLE AND NOT LLVM_ENABLE_WARNINGS)980 append("-w" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)981endif()982 983macro(append_common_sanitizer_flags)984 if (NOT MSVC OR CLANG_CL)985 # Append -fno-omit-frame-pointer and turn on debug info to get better986 # stack traces.987 append("-fno-omit-frame-pointer" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)988 if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND989 NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO" AND990 CMAKE_CXX_COMPILER_ID MATCHES "Clang")991 append("-gline-tables-only" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)992 endif()993 # Use -O1 even in debug mode, otherwise sanitizers slowdown is too large.994 if (uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND LLVM_OPTIMIZE_SANITIZED_BUILDS)995 append("-O1" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)996 endif()997 else()998 # Always ask the linker to produce symbols with asan.999 append("/Z7" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1000 append("/debug" CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1001 # Not compatible with /INCREMENTAL link.1002 foreach (flags_opt_to_scrub1003 CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1004 string (REGEX REPLACE "(^| )/INCREMENTAL($| )" " /INCREMENTAL:NO "1005 "${flags_opt_to_scrub}" "${${flags_opt_to_scrub}}")1006 endforeach()1007 if (LLVM_HOST_TRIPLE MATCHES "i[2-6]86-.*")1008 # Keep frame pointers around.1009 append("/Oy-" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1010 endif()1011 endif()1012endmacro()1013 1014# Turn on sanitizers if necessary.1015if(LLVM_USE_SANITIZER)1016 if (LLVM_ON_UNIX)1017 if (LLVM_USE_SANITIZER STREQUAL "Address")1018 append_common_sanitizer_flags()1019 append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1020 elseif (LLVM_USE_SANITIZER STREQUAL "HWAddress")1021 append_common_sanitizer_flags()1022 append("-fsanitize=hwaddress" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1023 elseif (LLVM_USE_SANITIZER MATCHES "Memory(WithOrigins)?")1024 append_common_sanitizer_flags()1025 append("-fsanitize=memory" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1026 if(LLVM_USE_SANITIZER STREQUAL "MemoryWithOrigins")1027 append("-fsanitize-memory-track-origins" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1028 endif()1029 elseif (LLVM_USE_SANITIZER STREQUAL "Undefined")1030 append_common_sanitizer_flags()1031 append("${LLVM_UBSAN_FLAGS}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1032 elseif (LLVM_USE_SANITIZER STREQUAL "Thread")1033 append_common_sanitizer_flags()1034 append("-fsanitize=thread" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1035 elseif (LLVM_USE_SANITIZER STREQUAL "DataFlow")1036 append("-fsanitize=dataflow" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1037 elseif (LLVM_USE_SANITIZER STREQUAL "Address;Undefined" OR1038 LLVM_USE_SANITIZER STREQUAL "Undefined;Address")1039 append_common_sanitizer_flags()1040 append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1041 append("${LLVM_UBSAN_FLAGS}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1042 elseif (LLVM_USE_SANITIZER STREQUAL "Leaks")1043 append_common_sanitizer_flags()1044 append("-fsanitize=leak" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1045 else()1046 message(FATAL_ERROR "Unsupported value of LLVM_USE_SANITIZER: ${LLVM_USE_SANITIZER}")1047 endif()1048 elseif(MINGW)1049 if (LLVM_USE_SANITIZER STREQUAL "Address")1050 append_common_sanitizer_flags()1051 append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1052 elseif (LLVM_USE_SANITIZER STREQUAL "Undefined")1053 append_common_sanitizer_flags()1054 append("${LLVM_UBSAN_FLAGS}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1055 elseif (LLVM_USE_SANITIZER STREQUAL "Address;Undefined" OR1056 LLVM_USE_SANITIZER STREQUAL "Undefined;Address")1057 append_common_sanitizer_flags()1058 append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1059 append("${LLVM_UBSAN_FLAGS}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1060 else()1061 message(FATAL_ERROR "This sanitizer not yet supported in a MinGW environment: ${LLVM_USE_SANITIZER}")1062 endif()1063 elseif(MSVC)1064 if (NOT LLVM_USE_SANITIZER MATCHES "^(Address|Undefined|Address;Undefined|Undefined;Address)$")1065 message(FATAL_ERROR "This sanitizer not yet supported in the MSVC environment: ${LLVM_USE_SANITIZER}")1066 endif()1067 append_common_sanitizer_flags()1068 if (LINKER_IS_LLD_LINK)1069 if (LLVM_HOST_TRIPLE MATCHES "i[2-6]86-.*")1070 set(arch "i386")1071 else()1072 set(arch "x86_64")1073 endif()1074 # Prepare ASAN runtime if needed1075 if (LLVM_USE_SANITIZER MATCHES ".*Address.*")1076 # lld string tail merging interacts badly with ASAN on Windows, turn it off here1077 # See https://github.com/llvm/llvm-project/issues/620781078 append("/opt:nolldtailmerge" CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1079 # Static and dynamic C runtimes all load ASAN as a DLL1080 # See https://devblogs.microsoft.com/cppblog/msvc-address-sanitizer-one-dll-for-all-runtime-configurations/1081 append("clang_rt.asan_dynamic-${arch}.lib" CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1082 if (${CMAKE_MSVC_RUNTIME_LIBRARY} MATCHES "^(MultiThreaded|MultiThreadedDebug)$")1083 append("/wholearchive:clang_rt.asan_static_runtime_thunk-${arch}.lib"1084 CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1085 else()1086 append("/wholearchive:clang_rt.asan_dynamic_runtime_thunk-${arch}.lib"1087 CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1088 endif()1089 endif()1090 endif()1091 if (LLVM_USE_SANITIZER MATCHES ".*Address.*")1092 if (NOT CLANG_CL)1093 append("/fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1094 # Not compatible with /RTC flags.1095 foreach (flags_opt_to_scrub1096 CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} CMAKE_C_FLAGS_${uppercase_CMAKE_BUILD_TYPE})1097 string (REGEX REPLACE "(^| )/RTC[1csu]*($| )" " "1098 "${flags_opt_to_scrub}" "${${flags_opt_to_scrub}}")1099 endforeach()1100 else()1101 append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1102 endif()1103 endif()1104 if (LLVM_USE_SANITIZER MATCHES ".*Undefined.*")1105 if (NOT CLANG_CL)1106 message(FATAL_ERROR "This sanitizer is only supported by clang-cl: Undefined")1107 endif()1108 append(${LLVM_UBSAN_FLAGS} CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1109 endif()1110 else()1111 message(FATAL_ERROR "LLVM_USE_SANITIZER is not supported on this platform.")1112 endif()1113 if (LLVM_USE_SANITIZE_COVERAGE)1114 append("-fsanitize=fuzzer-no-link" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1115 endif()1116 if (LLVM_USE_SANITIZER MATCHES ".*Undefined.*")1117 set(IGNORELIST_FILE "${PROJECT_SOURCE_DIR}/utils/sanitizers/ubsan_ignorelist.txt")1118 if (EXISTS "${IGNORELIST_FILE}")1119 # Use this option name version since -fsanitize-ignorelist is only1120 # accepted with clang 13.0 or newer.1121 append("-fsanitize-blacklist=${IGNORELIST_FILE}"1122 CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1123 endif()1124 endif()1125endif()1126 1127# Turn on -gsplit-dwarf if requested in debug builds.1128if (LLVM_USE_SPLIT_DWARF AND1129 ((uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") OR1130 (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")))1131 # Limit to clang and gcc so far. Add compilers supporting this option.1132 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR1133 CMAKE_CXX_COMPILER_ID STREQUAL "GNU")1134 add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-gsplit-dwarf>)1135 include(CheckLinkerFlag)1136 check_linker_flag(CXX "-Wl,--gdb-index" LINKER_SUPPORTS_GDB_INDEX)1137 append_if(LINKER_SUPPORTS_GDB_INDEX "-Wl,--gdb-index"1138 CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1139 endif()1140endif()1141 1142add_compile_definitions(__STDC_CONSTANT_MACROS)1143add_compile_definitions(__STDC_FORMAT_MACROS)1144add_compile_definitions(__STDC_LIMIT_MACROS)1145 1146# clang and gcc don't default-print colored diagnostics when invoked from Ninja.1147if (UNIX AND1148 CMAKE_GENERATOR MATCHES "Ninja" AND1149 (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR1150 (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND1151 NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9))))1152 append("-fdiagnostics-color" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1153endif()1154 1155# lld doesn't print colored diagnostics when invoked from Ninja1156if (UNIX AND CMAKE_GENERATOR MATCHES "Ninja" AND NOT "${LLVM_RUNTIMES_TARGET}" MATCHES "^nvptx64")1157 include(CheckLinkerFlag)1158 check_linker_flag(CXX "-Wl,--color-diagnostics" LINKER_SUPPORTS_COLOR_DIAGNOSTICS)1159 append_if(LINKER_SUPPORTS_COLOR_DIAGNOSTICS "-Wl,--color-diagnostics"1160 CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1161endif()1162 1163# Add flags for add_dead_strip().1164# FIXME: With MSVS, consider compiling with /Gy and linking with /OPT:REF?1165# But MinSizeRel seems to add that automatically, so maybe disable these1166# flags instead if LLVM_NO_DEAD_STRIP is set.1167if(NOT CYGWIN AND NOT MSVC)1168 if(NOT "${CMAKE_SYSTEM_NAME}" MATCHES "Darwin" AND1169 NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")1170 if (CMAKE_CXX_COMPILER_ID MATCHES "XL")1171 append("-qfuncsect" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1172 else()1173 append("-ffunction-sections" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1174 endif()1175 append("-fdata-sections" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1176 endif()1177elseif(MSVC)1178 if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )1179 append("/Gw" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1180 endif()1181endif()1182 1183if(MSVC)1184 # Remove flags here, for exceptions and RTTI.1185 # Each target property or source property should be responsible to control1186 # them.1187 # CL.EXE complains to override flags like "/GR /GR-".1188 string(REGEX REPLACE "(^| ) */EH[-cs]+ *( |$)" "\\1 \\2" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")1189 string(REGEX REPLACE "(^| ) */GR-? *( |$)" "\\1 \\2" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")1190endif()1191 1192# Provide public options to globally control RTTI and EH1193option(LLVM_ENABLE_EH "Enable Exception handling" OFF)1194option(LLVM_ENABLE_RTTI "Enable run time type information" OFF)1195if(LLVM_ENABLE_EH AND NOT LLVM_ENABLE_RTTI)1196 message(FATAL_ERROR "Exception handling requires RTTI. You must set LLVM_ENABLE_RTTI to ON")1197endif()1198 1199set(LLVM_BUILD_INSTRUMENTED OFF CACHE STRING "Build LLVM and tools with PGO instrumentation. May be specified as IR, Frontend, CSIR, CSSPGO")1200set(LLVM_VP_COUNTERS_PER_SITE "1.5" CACHE STRING "Value profile counters to use per site for IR PGO with Clang")1201mark_as_advanced(LLVM_BUILD_INSTRUMENTED LLVM_VP_COUNTERS_PER_SITE)1202string(TOUPPER "${LLVM_BUILD_INSTRUMENTED}" uppercase_LLVM_BUILD_INSTRUMENTED)1203 1204if (LLVM_BUILD_INSTRUMENTED)1205 if (uppercase_LLVM_BUILD_INSTRUMENTED STREQUAL "IR")1206 append("-fprofile-generate=\"${LLVM_PROFILE_DATA_DIR}\""1207 CMAKE_CXX_FLAGS1208 CMAKE_C_FLAGS)1209 if(NOT LINKER_IS_LLD_LINK)1210 append("-fprofile-generate=\"${LLVM_PROFILE_DATA_DIR}\""1211 CMAKE_EXE_LINKER_FLAGS1212 CMAKE_SHARED_LINKER_FLAGS)1213 endif()1214 # Set this to avoid running out of the value profile node section1215 # under clang in dynamic linking mode.1216 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND1217 CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 11 AND1218 LLVM_LINK_LLVM_DYLIB)1219 append("-Xclang -mllvm -Xclang -vp-counters-per-site=${LLVM_VP_COUNTERS_PER_SITE}"1220 CMAKE_CXX_FLAGS1221 CMAKE_C_FLAGS)1222 endif()1223 elseif(uppercase_LLVM_BUILD_INSTRUMENTED STREQUAL "CSIR")1224 append("-fcs-profile-generate=\"${LLVM_CSPROFILE_DATA_DIR}\""1225 CMAKE_CXX_FLAGS1226 CMAKE_C_FLAGS)1227 if(NOT LINKER_IS_LLD_LINK)1228 append("-fcs-profile-generate=\"${LLVM_CSPROFILE_DATA_DIR}\""1229 CMAKE_EXE_LINKER_FLAGS1230 CMAKE_SHARED_LINKER_FLAGS)1231 endif()1232 elseif(uppercase_LLVM_BUILD_INSTRUMENTED STREQUAL "CSSPGO")1233 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")1234 append("-fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -fno-optimize-sibling-calls -fpseudo-probe-for-profiling -fdebug-info-for-profiling"1235 CMAKE_CXX_FLAGS1236 CMAKE_C_FLAGS)1237 if(NOT LINKER_IS_LLD_LINK)1238 append("-fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -fno-optimize-sibling-calls -fpseudo-probe-for-profiling -fdebug-info-for-profiling"1239 CMAKE_EXE_LINKER_FLAGS1240 CMAKE_SHARED_LINKER_FLAGS)1241 endif()1242 else()1243 message(FATAL_ERROR "LLVM_BUILD_INSTRUMENTED=CSSPGO can only be specified when compiling with clang")1244 endif()1245 else()1246 append("-fprofile-instr-generate=\"${LLVM_PROFILE_FILE_PATTERN}\""1247 CMAKE_CXX_FLAGS1248 CMAKE_C_FLAGS)1249 if(NOT LINKER_IS_LLD_LINK)1250 append("-fprofile-instr-generate=\"${LLVM_PROFILE_FILE_PATTERN}\""1251 CMAKE_EXE_LINKER_FLAGS1252 CMAKE_SHARED_LINKER_FLAGS)1253 endif()1254 endif()1255endif()1256 1257# When using clang-cl with an instrumentation-based tool, add clang's library1258# resource directory to the library search path. Because cmake invokes the1259# linker directly, it isn't sufficient to pass -fsanitize=* to the linker.1260if (CLANG_CL AND (LLVM_BUILD_INSTRUMENTED OR LLVM_USE_SANITIZER))1261 execute_process(1262 COMMAND ${CMAKE_CXX_COMPILER} /clang:-print-libgcc-file-name /clang:--rtlib=compiler-rt1263 OUTPUT_VARIABLE clang_compiler_rt_file1264 ERROR_VARIABLE clang_cl_stderr1265 OUTPUT_STRIP_TRAILING_WHITESPACE1266 ERROR_STRIP_TRAILING_WHITESPACE1267 RESULT_VARIABLE clang_cl_exit_code)1268 if (NOT "${clang_cl_exit_code}" STREQUAL "0")1269 message(FATAL_ERROR1270 "Unable to invoke clang-cl to find resource dir: ${clang_cl_stderr}")1271 endif()1272 file(TO_CMAKE_PATH "${clang_compiler_rt_file}" clang_compiler_rt_file)1273 get_filename_component(clang_runtime_dir "${clang_compiler_rt_file}" DIRECTORY)1274 prepend("${CMAKE_CXX_LINKER_WRAPPER_FLAG}/libpath:\"${clang_runtime_dir}\""1275 CMAKE_EXE_LINKER_FLAGS1276 CMAKE_MODULE_LINKER_FLAGS1277 CMAKE_SHARED_LINKER_FLAGS)1278endif()1279 1280if(LLVM_PROFDATA_FILE AND EXISTS ${LLVM_PROFDATA_FILE})1281 if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" )1282 append("-fprofile-instr-use=\"${LLVM_PROFDATA_FILE}\""1283 CMAKE_CXX_FLAGS1284 CMAKE_C_FLAGS)1285 if(NOT LINKER_IS_LLD_LINK)1286 append("-fprofile-instr-use=\"${LLVM_PROFDATA_FILE}\""1287 CMAKE_EXE_LINKER_FLAGS1288 CMAKE_SHARED_LINKER_FLAGS)1289 endif()1290 else()1291 message(FATAL_ERROR "LLVM_PROFDATA_FILE can only be specified when compiling with clang")1292 endif()1293elseif(LLVM_PROFDATA_FILE)1294 message(WARNING "LLVM_PROFDATA_FILE specified, but ${LLVM_PROFDATA_FILE} not found")1295endif()1296 1297if(LLVM_SPROFDATA_FILE AND EXISTS ${LLVM_SPROFDATA_FILE})1298 if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" )1299 append("-fpseudo-probe-for-profiling -fprofile-sample-use=\"${LLVM_SPROFDATA_FILE}\""1300 CMAKE_CXX_FLAGS1301 CMAKE_C_FLAGS)1302 if(NOT LINKER_IS_LLD_LINK)1303 append("-fpseudo-probe-for-profiling -fprofile-sample-use=\"${LLVM_SPROFDATA_FILE}\""1304 CMAKE_EXE_LINKER_FLAGS1305 CMAKE_SHARED_LINKER_FLAGS)1306 endif()1307 else()1308 message(FATAL_ERROR "LLVM_SPROFDATA_FILE can only be specified when compiling with clang")1309 endif()1310endif()1311 1312option(LLVM_BUILD_INSTRUMENTED_COVERAGE "Build LLVM and tools with Code Coverage instrumentation" Off)1313option(LLVM_INDIVIDUAL_TEST_COVERAGE "Emit individual coverage file for each test case." OFF)1314mark_as_advanced(LLVM_BUILD_INSTRUMENTED_COVERAGE)1315append_if(LLVM_BUILD_INSTRUMENTED_COVERAGE "-fprofile-instr-generate=\"${LLVM_PROFILE_FILE_PATTERN}\" -fcoverage-mapping"1316 CMAKE_CXX_FLAGS1317 CMAKE_C_FLAGS1318 CMAKE_EXE_LINKER_FLAGS1319 CMAKE_SHARED_LINKER_FLAGS)1320 1321if (LLVM_BUILD_INSTRUMENTED AND LLVM_BUILD_INSTRUMENTED_COVERAGE)1322 message(FATAL_ERROR "LLVM_BUILD_INSTRUMENTED and LLVM_BUILD_INSTRUMENTED_COVERAGE cannot both be specified")1323endif()1324 1325set(LLVM_THINLTO_CACHE_PATH "${PROJECT_BINARY_DIR}/lto.cache" CACHE STRING "Set ThinLTO cache path. This can be used when building LLVM from several different directiories.")1326 1327if(LLVM_ENABLE_LTO AND LLVM_ON_WIN32 AND NOT LINKER_IS_LLD_LINK AND NOT MINGW)1328 message(FATAL_ERROR "When compiling for Windows, LLVM_ENABLE_LTO requires using lld as the linker (point CMAKE_LINKER at lld-link.exe)")1329endif()1330if(uppercase_LLVM_ENABLE_LTO STREQUAL "THIN")1331 append("-flto=thin" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)1332 if(NOT LINKER_IS_LLD_LINK)1333 append("-flto=thin" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1334 endif()1335 # If the linker supports it, enable the lto cache. This improves initial build1336 # time a little since we re-link a lot of the same objects, and significantly1337 # improves incremental build time.1338 # FIXME: We should move all this logic into the clang driver.1339 if(APPLE)1340 append("-Wl,-cache_path_lto,${LLVM_THINLTO_CACHE_PATH}"1341 CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1342 elseif("${CMAKE_SYSTEM_NAME}" MATCHES "AIX")1343 append("-bplugin_opt:-legacy-thinlto-cache-dir=${LLVM_THINLTO_CACHE_PATH}"1344 CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1345 elseif((UNIX OR MINGW) AND LLVM_USE_LINKER STREQUAL "lld")1346 append("-Wl,--thinlto-cache-dir=${LLVM_THINLTO_CACHE_PATH}"1347 CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1348 elseif(LLVM_USE_LINKER STREQUAL "gold")1349 append("-Wl,--plugin-opt,cache-dir=${LLVM_THINLTO_CACHE_PATH}"1350 CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1351 elseif(LINKER_IS_LLD_LINK)1352 append("/lldltocache:${LLVM_THINLTO_CACHE_PATH}"1353 CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1354 endif()1355elseif(uppercase_LLVM_ENABLE_LTO STREQUAL "FULL")1356 append("-flto=full" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)1357 if(NOT LINKER_IS_LLD_LINK)1358 append("-flto=full" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1359 endif()1360elseif(LLVM_ENABLE_LTO)1361 append("-flto" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)1362 if(NOT LINKER_IS_LLD_LINK)1363 append("-flto" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)1364 endif()1365endif()1366 1367if(LLVM_ENABLE_FATLTO AND ((UNIX AND NOT APPLE) OR FUCHSIA))1368 append("-ffat-lto-objects" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1369 if(NOT LINKER_IS_LLD_LINK)1370 append("-ffat-lto-objects" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS)1371 endif()1372endif()1373 1374# Set an AIX default for LLVM_EXPORT_SYMBOLS_FOR_PLUGINS based on whether we are1375# doing dynamic linking (see below).1376set(LLVM_EXPORT_SYMBOLS_FOR_PLUGINS_AIX_default OFF)1377if (NOT (BUILD_SHARED_LIBS OR LLVM_LINK_LLVM_DYLIB))1378 set(LLVM_EXPORT_SYMBOLS_FOR_PLUGINS_AIX_default ON)1379endif()1380 1381# This option makes utils/extract_symbols.py be used to determine the list of1382# symbols to export from LLVM tools. This is necessary when on AIX or when using1383# MSVC if you want to allow plugins. On AIX we don't show this option, and we1384# enable it by default except when the LLVM libraries are set up for dynamic1385# linking (due to incompatibility). With MSVC, note that the plugin has to1386# explicitly link against (exactly one) tool so we can't unilaterally turn on1387# LLVM_ENABLE_PLUGINS when it's enabled.1388if("${CMAKE_SYSTEM_NAME}" MATCHES "AIX")1389 set(LLVM_EXPORT_SYMBOLS_FOR_PLUGINS_OPTION OFF)1390else()1391 set(LLVM_EXPORT_SYMBOLS_FOR_PLUGINS_OPTION ON)1392endif()1393CMAKE_DEPENDENT_OPTION(LLVM_EXPORT_SYMBOLS_FOR_PLUGINS1394 "Export symbols from LLVM tools so that plugins can import them" OFF1395 "LLVM_EXPORT_SYMBOLS_FOR_PLUGINS_OPTION" ${LLVM_EXPORT_SYMBOLS_FOR_PLUGINS_AIX_default})1396if(BUILD_SHARED_LIBS AND LLVM_EXPORT_SYMBOLS_FOR_PLUGINS)1397 message(FATAL_ERROR "BUILD_SHARED_LIBS not compatible with LLVM_EXPORT_SYMBOLS_FOR_PLUGINS")1398endif()1399if(LLVM_LINK_LLVM_DYLIB AND LLVM_EXPORT_SYMBOLS_FOR_PLUGINS)1400 message(FATAL_ERROR "LLVM_LINK_LLVM_DYLIB not compatible with LLVM_EXPORT_SYMBOLS_FOR_PLUGINS")1401endif()1402 1403# By default we should enable LLVM_ENABLE_IDE only for multi-configuration1404# generators. This option disables optional build system features that make IDEs1405# less usable.1406set(LLVM_ENABLE_IDE_default OFF)1407if (CMAKE_CONFIGURATION_TYPES)1408 set(LLVM_ENABLE_IDE_default ON)1409endif()1410option(LLVM_ENABLE_IDE1411 "Disable optional build system features that cause problems for IDE generators"1412 ${LLVM_ENABLE_IDE_default})1413if (CMAKE_CONFIGURATION_TYPES AND NOT LLVM_ENABLE_IDE)1414 message(WARNING "Disabling LLVM_ENABLE_IDE on multi-configuration generators is not recommended.")1415endif()1416 1417function(get_compile_definitions)1418 get_directory_property(top_dir_definitions DIRECTORY ${CMAKE_SOURCE_DIR} COMPILE_DEFINITIONS)1419 foreach(definition ${top_dir_definitions})1420 if(DEFINED result)1421 string(APPEND result " -D${definition}")1422 else()1423 set(result "-D${definition}")1424 endif()1425 endforeach()1426 set(LLVM_DEFINITIONS "${result}" PARENT_SCOPE)1427endfunction()1428get_compile_definitions()1429 1430option(LLVM_FORCE_ENABLE_STATS "Enable statistics collection for builds that wouldn't normally enable it" OFF)1431 1432check_symbol_exists(os_signpost_interval_begin "os/signpost.h" macos_signposts_available)1433if(macos_signposts_available)1434 check_cxx_source_compiles(1435 "#include <os/signpost.h>1436 int main() { os_signpost_interval_begin(nullptr, 0, \"\", \"\"); return 0; }"1437 macos_signposts_usable)1438 if(macos_signposts_usable)1439 set(LLVM_ENABLE_SUPPORT_XCODE_SIGNPOSTS "WITH_ASSERTS" CACHE STRING1440 "Enable support for Xcode signposts. Can be WITH_ASSERTS, FORCE_ON, FORCE_OFF")1441 string(TOUPPER "${LLVM_ENABLE_SUPPORT_XCODE_SIGNPOSTS}"1442 uppercase_LLVM_ENABLE_SUPPORT_XCODE_SIGNPOSTS)1443 if( uppercase_LLVM_ENABLE_SUPPORT_XCODE_SIGNPOSTS STREQUAL "WITH_ASSERTS" )1444 if( LLVM_ENABLE_ASSERTIONS )1445 set( LLVM_SUPPORT_XCODE_SIGNPOSTS 1 )1446 endif()1447 elseif( uppercase_LLVM_ENABLE_SUPPORT_XCODE_SIGNPOSTS STREQUAL "FORCE_ON" )1448 set( LLVM_SUPPORT_XCODE_SIGNPOSTS 1 )1449 elseif( uppercase_LLVM_ENABLE_SUPPORT_XCODE_SIGNPOSTS STREQUAL "FORCE_OFF" )1450 # We don't need to do anything special to turn off signposts.1451 elseif( NOT DEFINED LLVM_ENABLE_SUPPORT_XCODE_SIGNPOSTS )1452 # Treat LLVM_ENABLE_SUPPORT_XCODE_SIGNPOSTS like "FORCE_OFF" when it has not been1453 # defined.1454 else()1455 message(FATAL_ERROR "Unknown value for LLVM_ENABLE_SUPPORT_XCODE_SIGNPOSTS:"1456 " \"${LLVM_ENABLE_SUPPORT_XCODE_SIGNPOSTS}\"!")1457 endif()1458 endif()1459endif()1460 1461set(LLVM_SOURCE_PREFIX "" CACHE STRING "Use prefix for sources")1462 1463option(LLVM_USE_RELATIVE_PATHS_IN_DEBUG_INFO "Use relative paths in debug info" OFF)1464 1465if(LLVM_USE_RELATIVE_PATHS_IN_DEBUG_INFO)1466 check_c_compiler_flag("-fdebug-prefix-map=foo=bar" SUPPORTS_FDEBUG_PREFIX_MAP)1467 if(LLVM_ENABLE_PROJECTS_USED)1468 get_filename_component(source_root "${LLVM_MAIN_SRC_DIR}/.." ABSOLUTE)1469 else()1470 set(source_root "${LLVM_MAIN_SRC_DIR}")1471 endif()1472 file(RELATIVE_PATH relative_root "${CMAKE_BINARY_DIR}" "${source_root}")1473 append_if(SUPPORTS_FDEBUG_PREFIX_MAP "-fdebug-prefix-map=${CMAKE_BINARY_DIR}=${relative_root}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1474 append_if(SUPPORTS_FDEBUG_PREFIX_MAP "-fdebug-prefix-map=${source_root}/=${LLVM_SOURCE_PREFIX}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1475 if (LLVM_COMPILER_IS_GCC_COMPATIBLE)1476 append("-no-canonical-prefixes" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1477 endif()1478endif()1479 1480option(LLVM_USE_RELATIVE_PATHS_IN_FILES "Use relative paths in sources and debug info" OFF)1481 1482if(LLVM_USE_RELATIVE_PATHS_IN_FILES)1483 check_c_compiler_flag("-ffile-prefix-map=foo=bar" SUPPORTS_FFILE_PREFIX_MAP)1484 if(LLVM_ENABLE_PROJECTS_USED)1485 get_filename_component(source_root "${LLVM_MAIN_SRC_DIR}/.." ABSOLUTE)1486 else()1487 set(source_root "${LLVM_MAIN_SRC_DIR}")1488 endif()1489 file(RELATIVE_PATH relative_root "${CMAKE_BINARY_DIR}" "${source_root}")1490 append_if(SUPPORTS_FFILE_PREFIX_MAP "-ffile-prefix-map=${CMAKE_BINARY_DIR}=${relative_root}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1491 append_if(SUPPORTS_FFILE_PREFIX_MAP "-ffile-prefix-map=${source_root}/=${LLVM_SOURCE_PREFIX}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1492 if (LLVM_COMPILER_IS_GCC_COMPATIBLE)1493 append("-no-canonical-prefixes" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)1494 endif()1495endif()1496 1497set(LLVM_THIRD_PARTY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../third-party CACHE STRING1498 "Directory containing third party software used by LLVM (e.g. googletest)")1499 1500set(LLVM_UNITTEST_LINK_FLAGS "" CACHE STRING1501 "Additional linker flags for unit tests")1502 1503if(LLVM_ENABLE_LLVM_LIBC)1504 check_library_exists(llvmlibc printf "" HAVE_LLVM_LIBC)1505 if(NOT HAVE_LLVM_LIBC)1506 message(WARNING "Unable to link against LLVM libc. LLVM will be built without linking against the LLVM libc overlay.")1507 endif()1508endif()1509 1510check_symbol_exists(flock "sys/file.h" HAVE_FLOCK)1511set(LLVM_ENABLE_ONDISK_CAS_default OFF)1512if(HAVE_FLOCK OR LLVM_ON_WIN32)1513 # LLVM OnDisk CAS currently requires flock on Unix.1514 set(LLVM_ENABLE_ONDISK_CAS_default ON)1515endif()1516option(LLVM_ENABLE_ONDISK_CAS "Build OnDiskCAS." ${LLVM_ENABLE_ONDISK_CAS_default})1517