# trict-null-sentinel Check the set of common warning flags supported by C and C++ compilers # check_compiler_warning_flags( ) # - variable to store valid C warning flags # - variable to store valid CXX warning flags # This internally calls the check_c_compiler_flag and check_cxx_compiler_flag macros. # To create a portable build system, it is best to not # test for platforms, but to test for features. # # Instead of testing "if Windows then do this", test for # "if the -Wno-invalid-offsetof flag works then use it". # # Typical use of this module is: # # include(CheckCompilerWarningFlags) # check_compiler_warning_flags(C_WARNING_FLAGS CXX_WARNING_FLAGS) # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_WARNING_FLAGS}") # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_WARNING_FLAGS}") include(CheckCXXCompilerFlag) include(CheckCCompilerFlag) include(CheckPIESupported) check_pie_supported() function(check_c_compiler_flags c_flag_var) set(local_c_flags "") set(flag_list "${ARGN}") foreach(flag IN LISTS flag_list) string( REPLACE "=" "_" flag_var ${flag}) check_c_compiler_flag(${flag} C_HAS_WARNING${flag_var}) if(${C_HAS_WARNING${flag_var}}) set(local_c_flags "${local_c_flags} ${flag}") endif() endforeach() set(${c_flag_var} "${local_c_flags}" PARENT_SCOPE) endfunction() function(check_cxx_compiler_flags cxx_flag_var) set(local_cxx_flags "") set(flag_list "${ARGN}") foreach(flag IN LISTS flag_list) string( REPLACE "=" "_" flag_var ${flag}) check_cxx_compiler_flag(${flag} CXX_HAS_WARNING${flag_var}) if(${CXX_HAS_WARNING${flag_var}}) set(local_cxx_flags "${local_cxx_flags} ${flag}") endif() endforeach() set(${cxx_flag_var} "${local_cxx_flags}" PARENT_SCOPE) endfunction() function(check_compiler_warning_flags c_warning_flags_var cxx_warning_flags_var) set(${c_warning_flags_var} "" PARENT_SCOPE) set(${cxx_warning_flags_var} "" PARENT_SCOPE) # Check this list on C compiler only set(c_flags -Wno-uninitialized -Wno-unused-parameter) ## On windows, the most verbose compiler options ## is reporting 1000's of wanings in windows ## header files, for now, limit the number of ## warnings to level 3 if(WIN32) set(VerboseWarningsFlag -W3) ## A better solution would be to use -Wall, ## and then disable warnings one by one ## set(VerboseWarningsFlag -Wall -wd4820 -wd4682) else() ## with Intel compiler, the -Wall compiler options ## is reporting 1000's of remarks of trivial items ## that will only slow day-to-day operations ## specify -w2 to restrict to only warnings and errors if(${CMAKE_C_COMPILER} MATCHES "icc.*$") set(USING_INTEL_ICC_COMPILER TRUE) endif() if(${CMAKE_CXX_COMPILER} MATCHES "icpc.*$") set(USING_INTEL_ICC_COMPILER TRUE) endif() if(USING_INTEL_ICC_COMPILER) # NOTE -w2 is close to gcc's -Wall warning level, -w5 is intels -Wall warning level, and it is too verbose. set(VerboseWarningsFlag -w2 -wd1268 -wd981 -wd383 -wd1418 -wd1419 -wd2259 -wd1572 -wd424) #-wd424 #Needed for Intel compilers with remarki #424: extra ";" ignored #-wd383 #Needed for Intel compilers with remark #383: value copied to temporary, reference to temporary used #-wd981 #Needed for Intel compilers with remark #981: operands are evaluated in unspecified order #-wd1418 #Needed for Intel compilers with remark #1418: external function definition with no prior declaration #-wd1419 #Needed for Intel compilers with remark #1419: external declaration in primary source file #-wd1572 #Needed for Intel compilers with remark #1572: floating-point equality and inequality comparisons are unreliable #-wd2259 #Needed for Intel compilers with remark #2259: non-pointer conversion from "itk::SizeValueType={unsigned long}" to "double" may lose significant bits #-wd1268 #Needed for Intel compilers with warning #1268: support for exported templates is disabled else() set(VerboseWarningsFlag -Wall) endif() endif() # Check this list on both C and C++ compilers set(c_and_cxx_flags ${VerboseWarningsFlag} -Wno-long-double #Needed on APPLE -Wcast-align -Wdisabled-optimization -Wextra -Wformat=2 -Winvalid-pch -Wno-format-nonliteral -Wpointer-arith -Wshadow -Wunused -Wwrite-strings -Wno-strict-overflow) # Check this list on C++ compiler only set(cxx_flags -Wno-deprecated -Wno-invalid-offsetof -Wno-undefined-var-template # suppress invalid warning when explicitly instantiated in another translation unit -Woverloaded-virtual -Wctad-maybe-unsupported -Wstrict-null-sentinel) ##-Wno-c++0x-static-nonintegral-init ## Clang compiler likes to warn about this feature that is technically only in ## c++0x, but works on many compilers, and if it fails, then alternate methods are used check_c_compiler_flags(CMAKE_C_WARNING_FLAGS ${c_flags} ${c_and_cxx_flags}) check_cxx_compiler_flags(CMAKE_CXX_WARNING_FLAGS ${c_and_cxx_flags} ${cxx_flags}) set(${c_warning_flags_var} "${CMAKE_C_WARNING_FLAGS}" PARENT_SCOPE) set(${cxx_warning_flags_var} "${CMAKE_CXX_WARNING_FLAGS}" PARENT_SCOPE) endfunction() # Check for the presence of AVX and figure out the flags to use for it. # Adapted from https://gist.github.com/UnaNancyOwen/263c243ae1e05a2f9d0e function(check_avx_flags avx_flags_var) set(avx_flags_var) include(CheckCXXSourceRuns) set(_safe_cmake_required_flags "${CMAKE_REQUIRED_FLAGS}") set(CMAKE_REQUIRED_FLAGS) # Check AVX if(MSVC) set(CMAKE_REQUIRED_FLAGS "/arch:AVX") # set flags to be used in check_cxx_source_runs below endif() check_cxx_source_runs( " #include int main() { __m256 a, b, c; const float src[8] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f }; float dst[8]; a = _mm256_loadu_ps(src); b = _mm256_loadu_ps(src); c = _mm256_add_ps(a, b); _mm256_storeu_ps(dst, c); for(int i = 0; i < 8; i++){ if(( src[i] + src[i]) != dst[i]){ return -1; } } return 0; }" have_avx_extensions_var) # Check AVX2 if(MSVC) set(CMAKE_REQUIRED_FLAGS "/arch:AVX2") # set flags to be used in check_cxx_source_runs below endif() check_cxx_source_runs( " #include int main() { __m256i a, b, c; const int src[8] = { 1, 2, 3, 4, 5, 6, 7, 8 }; int dst[8]; a = _mm256_loadu_si256( (__m256i*)src); b = _mm256_loadu_si256( (__m256i*)src); c = _mm256_add_epi32( a, b); _mm256_storeu_si256( (__m256i*)dst, c); for(int i = 0; i < 8; i++){ if(( src[i] + src[i]) != dst[i]){ return -1; } } return 0; }" have_avx2_extensions_var) set(CMAKE_REQUIRED_FLAGS "${_safe_cmake_required_flags}") # Set Flags if(have_avx2_extensions_var AND MSVC) set(avx_flags_var "${avx_flags_var} /arch:AVX2") elseif(have_avx_extensions_var AND MSVC) set(avx_flags_var "${avx_flags_var} /arch:AVX") endif() endfunction() # Check for the presence of SSE2. # Adapted from the AVX check and https://github.com/InsightSoftwareConsortium/ITK/blob/master/Modules/ThirdParty/VNL/src/vxl/config/cmake/config/vxl_platform_tests.cxx#L164-L178 function(check_sse2_flags sse2_flags_var) # set flags to be used in check_cxx_source_runs below set(_safe_cmake_required_flags "${CMAKE_REQUIRED_FLAGS}") set(CMAKE_REQUIRED_FLAGS) if(MSVC) set(CMAKE_REQUIRED_FLAGS "/arch:SSE2") elseif(CMAKE_COMPILER_IS_GNUCXX) set(CMAKE_REQUIRED_FLAGS "-msse2") endif() # perform test include(CheckCXXSourceRuns) check_cxx_source_runs( " #include int main() { //try to do some sse2 calculations double d_a[] = { 6.75, 3.42 }; double d_b[] = { 2.3, 9.2 }; double res[2] = {0.0}; __m128d z; z = _mm_mul_pd(_mm_loadu_pd(d_a),_mm_loadu_pd(d_b)); _mm_storeu_pd(res,z); return 0; }" have_sse2_extensions_var) set(CMAKE_REQUIRED_FLAGS "${_safe_cmake_required_flags}") # Set SSE2 Flags set(${sse2_flags_var}) if(have_sse2_extensions_var AND MSVC) set(${sse2_flags_var} "/arch:SSE2") elseif(have_sse2_extensions_var AND CMAKE_COMPILER_IS_GNUCXX) set(${sse2_flags_var} "-msse2") endif() set(${sse2_flags_var} "${${sse2_flags_var}}" PARENT_SCOPE) endfunction() function(check_compiler_optimization_flags c_optimization_flags_var cxx_optimization_flags_var) set(${c_optimization_flags_var} "" PARENT_SCOPE) set(${cxx_optimization_flags_var} "" PARENT_SCOPE) if("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "(x86_64|AMD64)") if(MSVC) check_avx_flags(InstructionSetOptimizationFlags) if("${CMAKE_SIZEOF_VOID_P}" EQUAL "4") list( APPEND InstructionSetOptimizationFlags /arch:SSE /arch:SSE2) endif() elseif(NOT EMSCRIPTEN OR WASI) if(${CMAKE_C_COMPILER} MATCHES "icc.*$") set(USING_INTEL_ICC_COMPILER TRUE) endif() if(${CMAKE_CXX_COMPILER} MATCHES "icpc.*$") set(USING_INTEL_ICC_COMPILER TRUE) endif() if(USING_INTEL_ICC_COMPILER) set(InstructionSetOptimizationFlags "") else() set(InstructionSetOptimizationFlags "") endif() # Check this list on C compiler only set(c_flags "") # Check this list on C++ compiler only set(cxx_flags "") # Check this list on both C and C++ compilers set(InstructionSetOptimizationFlags # https://gcc.gnu.org/onlinedocs/gcc-4.8.0/gcc/i386-and-x86_002d64-Options.html # NOTE the corei7 release date was 2008 #-mtune=native # Tune the code for the computer used compile ITK, but allow running on generic cpu archetectures -mtune=generic # for reproducible results https://github.com/InsightSoftwareConsortium/ITK/issues/1939 -march=corei7 # Use ABI settings to support corei7 (circa 2008 ABI feature sets, core-avx circa 2013) ) endif() set(c_and_cxx_flags ${InstructionSetOptimizationFlags}) endif() check_c_compiler_flags(CMAKE_C_WARNING_FLAGS ${c_and_cxx_flags} ${c_flags}) check_cxx_compiler_flags(CMAKE_CXX_WARNING_FLAGS ${c_and_cxx_flags} ${cxx_flags}) set(${c_optimization_flags_var} "${CMAKE_C_WARNING_FLAGS}" PARENT_SCOPE) set(${cxx_optimization_flags_var} "${CMAKE_CXX_WARNING_FLAGS}" PARENT_SCOPE) endfunction() macro(check_compiler_platform_flags) # On Visual Studio 8 MS deprecated C. This removes all 1.276E1265 security # warnings if(WIN32) if(NOT MINGW) if(NOT ITK_ENABLE_VISUAL_STUDIO_DEPRECATED_C_WARNINGS) add_definitions( -D_CRT_FAR_MAPPINGS_NO_DEPRECATE -D_CRT_IS_WCTYPE_NO_DEPRECATE -D_CRT_MANAGED_FP_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_DEPRECATE_GLOBALS -D_CRT_SETERRORMODE_BEEP_SLEEP_NO_DEPRECATE -D_CRT_TIME_FUNCTIONS_NO_DEPRECATE -D_CRT_VCCLRIT_NO_DEPRECATE -D_SCL_SECURE_NO_DEPRECATE) endif() # With MS compilers on Win64, we need the /bigobj switch, else generated # code results in objects with number of sections exceeding object file # format. # see https://msdn.microsoft.com/en-us/library/ms173499.aspx if(MSVC) set(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} /bigobj") endif() endif() endif() if(WIN32) # Some libraries (e.g. vxl libs) have no dllexport markup, so we can # build full shared libraries only with the GNU toolchain. For non # gnu compilers on windows, only a few libraries are built shared. # This is controlled with ITK_LIBRARY_BUILD_TYPE used in the add_library # call. This allows for plugin type applications to use a dll for # ITKCommon which will contain the static for Modified time. if(CMAKE_COMPILER_IS_GNUCXX) # CMake adds --enable-all-exports on Cygwin (since Cygwin is # supposed to be UNIX-like), but we need to add it explicitly for # a native windows build with the MinGW tools. if(MINGW) set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-shared -Wl,--export-all-symbols -Wl,--enable-auto-import") set(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS "-shared -Wl,--export-all-symbols -Wl,--enable-auto-import") set(CMAKE_EXE_LINKER_FLAGS "-Wl,--enable-auto-import") endif() else() # if CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS is on, then # BUILD_SHARED_LIBS works as it would on other systems if(NOT CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS) if(BUILD_SHARED_LIBS) set(ITK_LIBRARY_BUILD_TYPE "SHARED") else() set(ITK_LIBRARY_BUILD_TYPE "STATIC") endif() # turn off BUILD_SHARED_LIBS as ITK_LIBRARY_BUILD_TYPE # is used on the libraries that have markup. set(BUILD_SHARED_LIBS OFF) endif() endif() endif() #----------------------------------------------------------------------------- #ITK requires special compiler flags on some platforms. if(CMAKE_COMPILER_IS_GNUCXX) if(APPLE) option(ITK_USE_64BITS_APPLE_TRUNCATION_WARNING "Turn on warnings on 64bits to 32bits truncations." OFF) mark_as_advanced(ITK_USE_64BITS_APPLE_TRUNCATION_WARNING) execute_process( COMMAND "${CMAKE_C_COMPILER}" --version OUTPUT_VARIABLE _version ERROR_VARIABLE _version) # -fopenmp breaks compiling the HDF5 library in shared library mode # on the OS X platform -- at least with gcc 4.2 from Xcode. set(compile_flag_lists CMAKE_C_FLAGS CMAKE_CXX_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELWITHDEBINFO) foreach(listname ${compile_flag_lists}) if("${${listname}}" MATCHES ".*-fopenmp.*") string( REPLACE "-fopenmp" "" tmpFlags "${${listname}}") set(${listname} "${tmpFlags}") message("-fopenmp causes incorrect compilation of HDF, removing from ${listname}") endif() endforeach() endif() if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12") set(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -fno-sized-deallocation") endif() check_sse2_flags(ITK_SSE2_CFLAGS_IF_AVAILABLE) set(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} ${ITK_SSE2_CFLAGS_IF_AVAILABLE}") endif() #----------------------------------------------------------------------------- # for the gnu compiler a -D_PTHREADS is needed on sun # for the native compiler a -mt flag is needed on the sun if(CMAKE_SYSTEM MATCHES "SunOS.*") if(CMAKE_COMPILER_IS_GNUCXX) set(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -D_PTHREADS") set(ITK_REQUIRED_LINK_FLAGS "${ITK_REQUIRED_LINK_FLAGS} -lrt") else() set(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -mt") set(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} -mt") endif() # Add flags for the SUN compiler to provide all the methods for std::allocator. # check_cxx_source_compiles("-features=no%anachronisms" SUN_COMPILER) if(SUN_COMPILER) check_cxx_source_compiles("-library=stlport4" SUN_COMPILER_HAS_STL_PORT_4) if(SUN_COMPILER_HAS_STL_PORT_4) set(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -library=stlport4") endif() endif() endif() # mingw thread support if(MINGW) set(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -mthreads") set(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} -mthreads") set(ITK_REQUIRED_LINK_FLAGS "${ITK_REQUIRED_LINK_FLAGS} -mthreads") endif() #----------------------------------------------------------------------------- # Set the compiler-specific flag for disabling optimization. if(MSVC) set(ITK_CXX_DISABLE_OPTIMIZATION_FLAG "/Od") elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "^(GNU|Intel)$" AND NOT MINGW) set(ITK_CXX_DISABLE_OPTIMIZATION_FLAG "-O0") endif() if(DEFINED ITK_CXX_DISABLE_OPTIMIZATION_FLAG) check_cxx_source_compiles(${ITK_CXX_DISABLE_OPTIMIZATION_FLAG} CXX_HAS_DISABLE_OPTIMIZATION_FLAG) endif() endmacro() #End the platform check function if(NOT ITK_C_WARNING_FLAGS OR NOT ITK_CXX_WARNING_FLAGS) # Only check once if not explicitly set on command line #----------------------------------------------------------------------------- #Check the set of warning flags the compiler supports check_compiler_warning_flags(C_WARNING_FLAGS CXX_WARNING_FLAGS) endif() if(NOT ITK_C_WARNING_FLAGS) #Not set on cmake command line option -DITK_C_WARNING_FLAGS:STRING="" set(ITK_C_WARNING_FLAGS ${C_WARNING_FLAGS}) endif() set(ITK_C_WARNING_FLAGS ${ITK_C_WARNING_FLAGS} CACHE STRING "ITK C compiler warning flags. Modify to suit your needs.") if(NOT ITK_CXX_WARNING_FLAGS) #Not set on cmake command line option -DITK_CXX_WARNING_FLAGS:STRING="" set(ITK_CXX_WARNING_FLAGS ${CXX_WARNING_FLAGS}) endif() set(ITK_CXX_WARNING_FLAGS ${ITK_CXX_WARNING_FLAGS} CACHE STRING "ITK CXX compiler warning flags. Modify to suit your needs.") mark_as_advanced(ITK_CXX_WARNING_FLAGS) mark_as_advanced(ITK_C_WARNING_FLAGS) unset(C_WARNING_FLAGS) unset(CXX_WARNING_FLAGS) if(NOT ITK_C_OPTIMIZATION_FLAGS OR NOT ITK_CXX_OPTIMIZATION_FLAGS )# Only check once if not explicitly set on command line #----------------------------------------------------------------------------- #Check the set of warning flags the compiler supports check_compiler_optimization_flags(C_OPTIMIZATION_FLAGS CXX_OPTIMIZATION_FLAGS) endif() if(NOT ITK_C_OPTIMIZATION_FLAGS) #Not set on cmake command line option -DITK_C_OPTIMIZATION_FLAGS:STRING="" set(ITK_C_OPTIMIZATION_FLAGS ${C_OPTIMIZATION_FLAGS} CACHE STRING "ITK C Compiler ABI/Optimization flags, Use '-march=native' to maximize performance, but break portabilitly.") else() set(ITK_C_OPTIMIZATION_FLAGS ${ITK_C_OPTIMIZATION_FLAGS} CACHE STRING "ITK C Compiler ABI/Optimization flags, Use '-march=native' to maximize performance, but break portabilitly.") endif() if(NOT ITK_CXX_OPTIMIZATION_FLAGS) #Not set on cmake command line option -DITK_CXX_OPTIMIZATION_FLAGS:STRING="" set(ITK_CXX_OPTIMIZATION_FLAGS ${CXX_OPTIMIZATION_FLAGS} CACHE STRING "ITK CXX Compiler ABI/Optimization flags, Use '-march=native' to maximize performance, but break portabilitly.") else() set(ITK_CXX_OPTIMIZATION_FLAGS ${ITK_CXX_OPTIMIZATION_FLAGS} CACHE STRING "ITK CXX Compiler ABI/Optimization flags, Use '-march=native' to maximize performance, but break portabilitly.") endif() mark_as_advanced(ITK_CXX_OPTIMIZATION_FLAGS) mark_as_advanced(ITK_C_OPTIMIZATION_FLAGS) unset(C_OPTIMIZATION_FLAGS) unset(CXX_OPTIMIZATION_FLAGS) #----------------------------------------------------------------------------- #Check the set of platform flags the compiler supports check_compiler_platform_flags() # Append ITK warnings to the CMake flags. # We do not set them in ITK_REQUIRED FLAGS because all project which # use ITK don't require these flags . string( REPLACE " " ";" CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ITK_C_OPTIMIZATION_FLAGS} ${ITK_C_WARNING_FLAGS}") list(REMOVE_DUPLICATES CMAKE_C_FLAGS) string( REPLACE ";" " " CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") string( REPLACE " " ";" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ITK_CXX_OPTIMIZATION_FLAGS} ${ITK_CXX_WARNING_FLAGS}") list(REMOVE_DUPLICATES CMAKE_CXX_FLAGS) string( REPLACE ";" " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")