# options and executing the appropriate CMake commands to realize the users'
# selections.
+# This is commonly needed so make sure it's defined before we include anything
+# else.
+string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
+
include(HandleLLVMStdlib)
include(AddLLVMDefinitions)
include(CheckCCompilerFlag)
message(FATAL_ERROR "Host Clang version must be at least 3.1!")
endif()
- # Also test that we aren't using too old of a version of libstdc++ with the
- # Clang compiler. This is tricky as there is no real way to check the
- # version of libstdc++ directly. Instead we test for a known bug in
- # libstdc++4.6 that is fixed in libstdc++4.7.
- if(NOT LLVM_ENABLE_LIBCXX)
+ if (CMAKE_CXX_SIMULATE_ID MATCHES "MSVC")
+ if (CMAKE_CXX_SIMULATE_VERSION VERSION_LESS 18.0)
+ message(FATAL_ERROR "Host Clang must have at least -fms-compatibility-version=18.0")
+ endif()
+ set(CLANG_CL 1)
+ elseif(NOT LLVM_ENABLE_LIBCXX)
+ # Otherwise, test that we aren't using too old of a version of libstdc++
+ # with the Clang compiler. This is tricky as there is no real way to
+ # check the version of libstdc++ directly. Instead we test for a known
+ # bug in libstdc++4.6 that is fixed in libstdc++4.7.
set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
set(OLD_CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
set(CMAKE_REQUIRED_FLAGS "-std=c++0x")
set(CMAKE_REQUIRED_LIBRARIES ${OLD_CMAKE_REQUIRED_LIBRARIES})
endif()
elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
- if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 17.0)
- message(FATAL_ERROR "Host Visual Studio must be at least 2012 (MSVC 17.0)")
+ if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0)
+ message(FATAL_ERROR "Host Visual Studio must be at least 2013")
+ elseif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0.31101)
+ message(WARNING "Host Visual Studio should at least be 2013 Update 4 (MSVC 18.0.31101)"
+ " due to miscompiles from earlier versions")
endif()
endif()
endif()
endif()
endif()
+string(TOUPPER "${LLVM_ABI_BREAKING_CHECKS}" uppercase_LLVM_ABI_BREAKING_CHECKS)
+
+if( uppercase_LLVM_ABI_BREAKING_CHECKS STREQUAL "WITH_ASSERTS" )
+ if( LLVM_ENABLE_ASSERTIONS )
+ set( LLVM_ENABLE_ABI_BREAKING_CHECKS 1 )
+ endif()
+elseif( uppercase_LLVM_ABI_BREAKING_CHECKS STREQUAL "FORCE_ON" )
+ set( LLVM_ENABLE_ABI_BREAKING_CHECKS 1 )
+elseif( uppercase_LLVM_ABI_BREAKING_CHECKS STREQUAL "FORCE_OFF" )
+ # We don't need to do anything special to turn off ABI breaking checks.
+elseif( NOT DEFINED LLVM_ABI_BREAKING_CHECKS )
+ # Treat LLVM_ABI_BREAKING_CHECKS like "FORCE_OFF" when it has not been
+ # defined.
+else()
+ message(FATAL_ERROR "Unknown value for LLVM_ABI_BREAKING_CHECKS: \"${LLVM_ABI_BREAKING_CHECKS}\"!")
+endif()
+
if(WIN32)
set(LLVM_HAVE_LINK_VERSION_SCRIPT 0)
if(CYGWIN)
set(LLVM_ON_WIN32 1)
set(LLVM_ON_UNIX 0)
endif(CYGWIN)
- # Maximum path length is 160 for non-unicode paths
- set(MAXPATHLEN 160)
else(WIN32)
if(UNIX)
set(LLVM_ON_WIN32 0)
else(APPLE)
set(LLVM_HAVE_LINK_VERSION_SCRIPT 1)
endif(APPLE)
- # FIXME: Maximum path length is currently set to 'safe' fixed value
- set(MAXPATHLEN 2024)
else(UNIX)
MESSAGE(SEND_ERROR "Unable to determine platform")
endif(UNIX)
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,-flat_namespace -Wl,-undefined -Wl,suppress")
endif()
+# Pass -Wl,-z,defs. This makes sure all symbols are defined. Otherwise a DSO
+# build might work on ELF but fail on MachO/COFF.
+if(NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin" OR WIN32 OR CYGWIN OR
+ ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" OR
+ ${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD") AND
+ NOT LLVM_USE_SANITIZER)
+ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,defs")
+endif()
+
+
function(append value)
foreach(variable ${ARGN})
set(${variable} "${${variable}} ${value}" PARENT_SCOPE)
message(STATUS "Building with ${flag}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" PARENT_SCOPE)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" PARENT_SCOPE)
+ set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${flag}" PARENT_SCOPE)
else()
message(WARNING "${flag} is not supported.")
endif()
# On Windows all code is PIC. MinGW warns if -fPIC is used.
else()
add_flag_or_print_warning("-fPIC" FPIC)
-
- if( WIN32 OR CYGWIN)
- # MinGW warns if -fvisibility-inlines-hidden is used.
- else()
- check_cxx_compiler_flag("-fvisibility-inlines-hidden" SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG)
- append_if(SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG "-fvisibility-inlines-hidden" CMAKE_CXX_FLAGS)
- endif()
endif()
endif()
+if(NOT WIN32 AND NOT CYGWIN)
+ # MinGW warns if -fvisibility-inlines-hidden is used.
+ check_cxx_compiler_flag("-fvisibility-inlines-hidden" SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG)
+ append_if(SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG "-fvisibility-inlines-hidden" CMAKE_CXX_FLAGS)
+endif()
+
if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32 )
# TODO: support other platforms and toolchains.
if( LLVM_BUILD_32_BITS )
endif()
if( MSVC )
+ if( CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0 )
+ # For MSVC 2013, disable iterator null pointer checking in debug mode,
+ # especially so std::equal(nullptr, nullptr, nullptr) will not assert.
+ add_llvm_definitions("-D_DEBUG_POINTER_IMPL=")
+ endif()
+
include(ChooseMSVCCRT)
if( NOT (${CMAKE_VERSION} VERSION_LESS 2.8.11) )
-D_CRT_NONSTDC_NO_WARNINGS
-D_SCL_SECURE_NO_DEPRECATE
-D_SCL_SECURE_NO_WARNINGS
+ )
+ set(msvc_warning_flags
# Disabled warnings.
+ -wd4141 # Suppress ''modifier' : used more than once' (because of __forceinline combined with inline)
-wd4146 # Suppress 'unary minus operator applied to unsigned type, result still unsigned'
-wd4180 # Suppress 'qualifier applied to function type has no meaning; ignored'
-wd4244 # Suppress ''argument' : conversion from 'type1' to 'type2', possible loss of data'
-wd4624 # Suppress ''derived class' : destructor could not be generated because a base class destructor is inaccessible'
-wd4722 # Suppress 'function' : destructor never returns, potential memory leak
-wd4800 # Suppress ''type' : forcing value to bool 'true' or 'false' (performance warning)'
-
+ -wd4100 # Suppress 'unreferenced formal parameter'
+ -wd4127 # Suppress 'conditional expression is constant'
+ -wd4512 # Suppress 'assignment operator could not be generated'
+ -wd4505 # Suppress 'unreferenced local function has been removed'
+ -wd4610 # Suppress '<class> can never be instantiated'
+ -wd4510 # Suppress 'default constructor could not be generated'
+ -wd4702 # Suppress 'unreachable code'
+ -wd4245 # Suppress 'signed/unsigned mismatch'
+ -wd4706 # Suppress 'assignment within conditional expression'
+ -wd4310 # Suppress 'cast truncates constant value'
+ -wd4701 # Suppress 'potentially uninitialized local variable'
+ -wd4703 # Suppress 'potentially uninitialized local pointer variable'
+ -wd4389 # Suppress 'signed/unsigned mismatch'
+ -wd4611 # Suppress 'interaction between '_setjmp' and C++ object destruction is non-portable'
+ -wd4805 # Suppress 'unsafe mix of type <type> and type <type> in operation'
+ -wd4204 # Suppress 'nonstandard extension used : non-constant aggregate initializer'
+ -wd4577 # Suppress 'noexcept used with no exception handling mode specified; termination on exception is not guaranteed'
+ -wd4091 # Suppress 'typedef: ignored on left of '' when no variable is declared'
+ # C4592 is disabled because of false positives in Visual Studio 2015
+ # Update 1. Re-evaluate the usefulness of this diagnostic with Update 2.
+ -wd4592 # Suppress ''var': symbol will be dynamically initialized (implementation limitation)
+
+ # Ideally, we'd like this warning to be enabled, but MSVC 2013 doesn't
+ # support the 'aligned' attribute in the way that clang sources requires (for
+ # any code that uses the LLVM_ALIGNAS macro), so this is must be disabled to
+ # avoid unwanted alignment warnings.
+ # When we switch to requiring a version of MSVC that supports the 'alignas'
+ # specifier (MSVC 2015?) this warning can be re-enabled.
+ -wd4324 # Suppress 'structure was padded due to __declspec(align())'
+
# Promoted warnings.
-w14062 # Promote 'enumerator in switch of enum is not handled' to level 1 warning.
# Enable warnings
if (LLVM_ENABLE_WARNINGS)
- add_llvm_definitions( /W4 )
+ append("/W4" msvc_warning_flags)
+ # CMake appends /W3 by default, and having /W3 followed by /W4 will result in
+ # cl : Command line warning D9025 : overriding '/W3' with '/W4'. Since this is
+ # a command line warning and not a compiler warning, it cannot be suppressed except
+ # by fixing the command line.
+ string(REGEX REPLACE " /W[0-4]" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+ string(REGEX REPLACE " /W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
if (LLVM_ENABLE_PEDANTIC)
# No MSVC equivalent available
endif (LLVM_ENABLE_PEDANTIC)
endif (LLVM_ENABLE_WARNINGS)
if (LLVM_ENABLE_WERROR)
- add_llvm_definitions( /WX )
+ append("/WX" msvc_warning_flags)
endif (LLVM_ENABLE_WERROR)
+
+ foreach(flag ${msvc_warning_flags})
+ append("${flag}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endforeach(flag)
+
+ append("/Zc:inline" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+
+ # Disable sized deallocation if the flag is supported. MSVC fails to compile
+ # the operator new overload in User otherwise.
+ check_c_compiler_flag("/WX /Zc:sizedDealloc-" SUPPORTS_SIZED_DEALLOC)
+ append_if(SUPPORTS_SIZED_DEALLOC "/Zc:sizedDealloc-" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+
elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
if (LLVM_ENABLE_WARNINGS)
append("-Wall -W -Wno-unused-parameter -Wwrite-strings" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
endif()
endif()
- append_if(LLVM_ENABLE_PEDANTIC "-pedantic -Wno-long-long" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ append_if(LLVM_ENABLE_PEDANTIC "-pedantic" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ append_if(LLVM_ENABLE_PEDANTIC "-Wno-long-long" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
add_flag_if_supported("-Wcovered-switch-default" COVERED_SWITCH_DEFAULT_FLAG)
append_if(USE_NO_UNINITIALIZED "-Wno-uninitialized" CMAKE_CXX_FLAGS)
append_if(USE_NO_MAYBE_UNINITIALIZED "-Wno-maybe-uninitialized" CMAKE_CXX_FLAGS)
endif()
if (LLVM_ENABLE_MODULES)
set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
- set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fmodules -fcxx-modules")
+ set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fmodules")
# Check that we can build code with modules enabled, and that repeatedly
# including <cassert> still manages to respect NDEBUG properly.
CHECK_CXX_SOURCE_COMPILES("#undef NDEBUG
endif( MSVC )
macro(append_common_sanitizer_flags)
- # Append -fno-omit-frame-pointer and turn on debug info to get better
- # stack traces.
- add_flag_if_supported("-fno-omit-frame-pointer" FNO_OMIT_FRAME_POINTER)
- if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND
- NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")
- add_flag_if_supported("-gline-tables-only" GLINE_TABLES_ONLY)
- endif()
- # Use -O1 even in debug mode, otherwise sanitizers slowdown is too large.
- if (uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
- add_flag_if_supported("-O1" O1)
+ if (NOT MSVC)
+ # Append -fno-omit-frame-pointer and turn on debug info to get better
+ # stack traces.
+ add_flag_if_supported("-fno-omit-frame-pointer" FNO_OMIT_FRAME_POINTER)
+ if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND
+ NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")
+ add_flag_if_supported("-gline-tables-only" GLINE_TABLES_ONLY)
+ endif()
+ # Use -O1 even in debug mode, otherwise sanitizers slowdown is too large.
+ if (uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+ add_flag_if_supported("-O1" O1)
+ endif()
+ elseif (CLANG_CL)
+ # Keep frame pointers around.
+ append("/Oy-" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ if (CMAKE_LINKER MATCHES "lld-link.exe")
+ # Use DWARF debug info with LLD.
+ append("-gdwarf" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ # Pass /MANIFEST:NO so that CMake doesn't run mt.exe on our binaries.
+ # Adding manifests with mt.exe breaks LLD's symbol tables. See PR24476.
+ append("/MANIFEST:NO"
+ CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+ else()
+ # Enable codeview otherwise.
+ append("/Z7" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif()
+ # Always ask the linker to produce symbols with asan.
+ append("-debug" CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
endif()
endmacro()
endif()
elseif (LLVM_USE_SANITIZER STREQUAL "Undefined")
append_common_sanitizer_flags()
- append("-fsanitize=undefined -fno-sanitize=vptr,function -fno-sanitize-recover"
+ append("-fsanitize=undefined -fno-sanitize=vptr,function -fno-sanitize-recover=all"
+ CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ elseif (LLVM_USE_SANITIZER STREQUAL "Thread")
+ append_common_sanitizer_flags()
+ append("-fsanitize=thread" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ elseif (LLVM_USE_SANITIZER STREQUAL "Address;Undefined" OR
+ LLVM_USE_SANITIZER STREQUAL "Undefined;Address")
+ append_common_sanitizer_flags()
+ append("-fsanitize=address,undefined -fno-sanitize=vptr,function -fno-sanitize-recover=all"
CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
else()
- message(WARNING "Unsupported value of LLVM_USE_SANITIZER: ${LLVM_USE_SANITIZER}")
+ message(FATAL_ERROR "Unsupported value of LLVM_USE_SANITIZER: ${LLVM_USE_SANITIZER}")
+ endif()
+ elseif(MSVC)
+ if (LLVM_USE_SANITIZER STREQUAL "Address")
+ append_common_sanitizer_flags()
+ append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ else()
+ message(FATAL_ERROR "This sanitizer not yet supported in the MSVC environment: ${LLVM_USE_SANITIZER}")
endif()
else()
- message(WARNING "LLVM_USE_SANITIZER is not supported on this platform.")
+ message(FATAL_ERROR "LLVM_USE_SANITIZER is not supported on this platform.")
+ endif()
+ if (LLVM_USE_SANITIZE_COVERAGE)
+ append("-fsanitize-coverage=edge,indirect-calls,8bit-counters,trace-cmp" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
endif()
endif()
# But MinSizeRel seems to add that automatically, so maybe disable these
# flags instead if LLVM_NO_DEAD_STRIP is set.
if(NOT CYGWIN AND NOT WIN32)
- if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+ if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND
+ NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
check_c_compiler_flag("-Werror -fno-function-sections" C_SUPPORTS_FNO_FUNCTION_SECTIONS)
if (C_SUPPORTS_FNO_FUNCTION_SECTIONS)
# Don't add -ffunction-section if it can be disabled with -fno-function-sections.
message(FATAL_ERROR "Exception handling requires RTTI. You must set LLVM_ENABLE_RTTI to ON")
endif()
+option(LLVM_BUILD_INSTRUMENTED "Build LLVM and tools with PGO instrumentation (experimental)" Off)
+mark_as_advanced(LLVM_BUILD_INSTRUMENTED)
+append_if(LLVM_BUILD_INSTRUMENTED "-fprofile-instr-generate"
+ CMAKE_CXX_FLAGS
+ CMAKE_C_FLAGS
+ CMAKE_EXE_LINKER_FLAGS
+ CMAKE_SHARED_LINKER_FLAGS)
+
# Plugin support
# FIXME: Make this configurable.
if(WIN32 OR CYGWIN)
projects / oota-llvm.git / blobdiff