cmake/CMakeCXXInformation.cmake

   1 # Copied from master branch of CMake (commit SHA 34a49dea) before release of
   2 # this newer version which seems to fix a bug of the one coming with CMake 2.8-12.
   3
   4 #=============================================================================
   5 # Copyright 2004-2011 Kitware, Inc.
   6 #
   7 # Distributed under the OSI-approved BSD License (the "License");
   8 # see accompanying file Copyright.txt for details.
   9 #
  10 # This software is distributed WITHOUT ANY WARRANTY; without even the
  11 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12 # See the License for more information.
  13 #=============================================================================
  14 # (To distribute this file outside of CMake, substitute the full
  15 #  License text for the above reference.)
  16
  17 # This file sets the basic flags for the C++ language in CMake.
  18 # It also loads the available platform file for the system-compiler
  19 # if it exists.
  20 # It also loads a system - compiler - processor (or target hardware)
  21 # specific file, which is mainly useful for crosscompiling and embedded systems.
  22
  23 # some compilers use different extensions (e.g. sdcc uses .rel)
  24 # so set the extension here first so it can be overridden by the compiler specific file
  25 if(UNIX)
  26   set(CMAKE_CXX_OUTPUT_EXTENSION .o)
  27 else()
  28   set(CMAKE_CXX_OUTPUT_EXTENSION .obj)
  29 endif()
  30
  31 set(_INCLUDED_FILE 0)
  32
  33 # Load compiler-specific information.
  34 if(CMAKE_CXX_COMPILER_ID)
  35   include(Compiler/${CMAKE_CXX_COMPILER_ID}-CXX OPTIONAL)
  36 endif()
  37
  38 set(CMAKE_BASE_NAME)
  39 get_filename_component(CMAKE_BASE_NAME "${CMAKE_CXX_COMPILER}" NAME_WE)
  40 # since the gnu compiler has several names force g++
  41 if(CMAKE_COMPILER_IS_GNUCXX)
  42   set(CMAKE_BASE_NAME g++)
  43 endif()
  44
  45
  46 # load a hardware specific file, mostly useful for embedded compilers
  47 if(CMAKE_SYSTEM_PROCESSOR)
  48   if(CMAKE_CXX_COMPILER_ID)
  49     include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
  50   endif()
  51   if (NOT _INCLUDED_FILE)
  52     include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
  53   endif ()
  54 endif()
  55
  56 # load the system- and compiler specific files
  57 if(CMAKE_CXX_COMPILER_ID)
  58   include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
  59 endif()
  60 if (NOT _INCLUDED_FILE)
  61   include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL
  62           RESULT_VARIABLE _INCLUDED_FILE)
  63 endif ()
  64 # We specify the compiler information in the system file for some
  65 # platforms, but this language may not have been enabled when the file
  66 # was first included.  Include it again to get the language info.
  67 # Remove this when all compiler info is removed from system files.
  68 if (NOT _INCLUDED_FILE)
  69   include(Platform/${CMAKE_SYSTEM_NAME} OPTIONAL)
  70 endif ()
  71
  72 if(CMAKE_CXX_SIZEOF_DATA_PTR)
  73   foreach(f ${CMAKE_CXX_ABI_FILES})
  74     include(${f})
  75   endforeach()
  76   unset(CMAKE_CXX_ABI_FILES)
  77 endif()
  78
  79 # This should be included before the _INIT variables are
  80 # used to initialize the cache.  Since the rule variables
  81 # have if blocks on them, users can still define them here.
  82 # But, it should still be after the platform file so changes can
  83 # be made to those values.
  84
  85 if(CMAKE_USER_MAKE_RULES_OVERRIDE)
  86   # Save the full path of the file so try_compile can use it.
  87   include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override)
  88   set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}")
  89 endif()
  90
  91 if(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX)
  92   # Save the full path of the file so try_compile can use it.
  93   include(${CMAKE_USER_MAKE_RULES_OVERRIDE_CXX} RESULT_VARIABLE _override)
  94   set(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX "${_override}")
  95 endif()
  96
  97
  98 # Create a set of shared library variable specific to C++
  99 # For 90% of the systems, these are the same flags as the C versions
 100 # so if these are not set just copy the flags from the c version
 101 if(NOT CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS)
 102   set(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
 103 endif()
 104
 105 if(NOT CMAKE_CXX_COMPILE_OPTIONS_PIC)
 106   set(CMAKE_CXX_COMPILE_OPTIONS_PIC ${CMAKE_C_COMPILE_OPTIONS_PIC})
 107 endif()
 108
 109 if(NOT CMAKE_CXX_COMPILE_OPTIONS_PIE)
 110   set(CMAKE_CXX_COMPILE_OPTIONS_PIE ${CMAKE_C_COMPILE_OPTIONS_PIE})
 111 endif()
 112
 113 if(NOT CMAKE_CXX_COMPILE_OPTIONS_DLL)
 114   set(CMAKE_CXX_COMPILE_OPTIONS_DLL ${CMAKE_C_COMPILE_OPTIONS_DLL})
 115 endif()
 116
 117 if(NOT CMAKE_SHARED_LIBRARY_CXX_FLAGS)
 118   set(CMAKE_SHARED_LIBRARY_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS})
 119 endif()
 120
 121 if(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
 122   set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS})
 123 endif()
 124
 125 if(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG)
 126   set(CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG})
 127 endif()
 128
 129 if(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP)
 130   set(CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG_SEP})
 131 endif()
 132
 133 if(NOT CMAKE_SHARED_LIBRARY_RPATH_LINK_CXX_FLAG)
 134   set(CMAKE_SHARED_LIBRARY_RPATH_LINK_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_C_FLAG})
 135 endif()
 136
 137 if(NOT DEFINED CMAKE_EXE_EXPORTS_CXX_FLAG)
 138   set(CMAKE_EXE_EXPORTS_CXX_FLAG ${CMAKE_EXE_EXPORTS_C_FLAG})
 139 endif()
 140
 141 if(NOT DEFINED CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG)
 142   set(CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG ${CMAKE_SHARED_LIBRARY_SONAME_C_FLAG})
 143 endif()
 144
 145 if(NOT CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG)
 146   set(CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG})
 147 endif()
 148
 149 if(NOT CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG_SEP)
 150   set(CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP})
 151 endif()
 152
 153 if(NOT CMAKE_EXECUTABLE_RPATH_LINK_CXX_FLAG)
 154   set(CMAKE_EXECUTABLE_RPATH_LINK_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_CXX_FLAG})
 155 endif()
 156
 157 if(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_CXX_WITH_RUNTIME_PATH)
 158   set(CMAKE_SHARED_LIBRARY_LINK_CXX_WITH_RUNTIME_PATH ${CMAKE_SHARED_LIBRARY_LINK_C_WITH_RUNTIME_PATH})
 159 endif()
 160
 161 if(NOT CMAKE_INCLUDE_FLAG_CXX)
 162   set(CMAKE_INCLUDE_FLAG_CXX ${CMAKE_INCLUDE_FLAG_C})
 163 endif()
 164
 165 if(NOT CMAKE_INCLUDE_FLAG_SEP_CXX)
 166   set(CMAKE_INCLUDE_FLAG_SEP_CXX ${CMAKE_INCLUDE_FLAG_SEP_C})
 167 endif()
 168
 169 # for most systems a module is the same as a shared library
 170 # so unless the variable CMAKE_MODULE_EXISTS is set just
 171 # copy the values from the LIBRARY variables
 172 if(NOT CMAKE_MODULE_EXISTS)
 173   set(CMAKE_SHARED_MODULE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CXX_FLAGS})
 174   set(CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS})
 175 endif()
 176
 177 # repeat for modules
 178 if(NOT CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS)
 179   set(CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS ${CMAKE_SHARED_MODULE_CREATE_C_FLAGS})
 180 endif()
 181
 182 if(NOT CMAKE_SHARED_MODULE_CXX_FLAGS)
 183   set(CMAKE_SHARED_MODULE_CXX_FLAGS ${CMAKE_SHARED_MODULE_C_FLAGS})
 184 endif()
 185
 186 # Initialize CXX link type selection flags from C versions.
 187 foreach(type SHARED_LIBRARY SHARED_MODULE EXE)
 188   if(NOT CMAKE_${type}_LINK_STATIC_CXX_FLAGS)
 189     set(CMAKE_${type}_LINK_STATIC_CXX_FLAGS
 190       ${CMAKE_${type}_LINK_STATIC_C_FLAGS})
 191   endif()
 192   if(NOT CMAKE_${type}_LINK_DYNAMIC_CXX_FLAGS)
 193     set(CMAKE_${type}_LINK_DYNAMIC_CXX_FLAGS
 194       ${CMAKE_${type}_LINK_DYNAMIC_C_FLAGS})
 195   endif()
 196 endforeach()
 197
 198 # add the flags to the cache based
 199 # on the initial values computed in the platform/*.cmake files
 200 # use _INIT variables so that this only happens the first time
 201 # and you can set these flags in the cmake cache
 202 set(CMAKE_CXX_FLAGS_INIT "$ENV{CXXFLAGS} ${CMAKE_CXX_FLAGS_INIT}")
 203 # avoid just having a space as the initial value for the cache
 204 if(CMAKE_CXX_FLAGS_INIT STREQUAL " ")
 205   set(CMAKE_CXX_FLAGS_INIT)
 206 endif()
 207 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_INIT}" CACHE STRING
 208      "Flags used by the compiler during all build types.")
 209
 210 if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
 211   set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG_INIT}" CACHE STRING
 212      "Flags used by the compiler during debug builds.")
 213   set (CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL_INIT}" CACHE STRING
 214      "Flags used by the compiler during release builds for minimum size.")
 215   set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE_INIT}" CACHE STRING
 216      "Flags used by the compiler during release builds.")
 217   set (CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT}" CACHE STRING
 218      "Flags used by the compiler during release builds with debug info.")
 219
 220 endif()
 221
 222 if(CMAKE_CXX_STANDARD_LIBRARIES_INIT)
 223   set(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES_INIT}"
 224     CACHE STRING "Libraries linked by default with all C++ applications.")
 225   mark_as_advanced(CMAKE_CXX_STANDARD_LIBRARIES)
 226 endif()
 227
 228 include(CMakeCommonLanguageInclude)
 229
 230 # now define the following rules:
 231 # CMAKE_CXX_CREATE_SHARED_LIBRARY
 232 # CMAKE_CXX_CREATE_SHARED_MODULE
 233 # CMAKE_CXX_COMPILE_OBJECT
 234 # CMAKE_CXX_LINK_EXECUTABLE
 235
 236 # variables supplied by the generator at use time
 237 # <TARGET>
 238 # <TARGET_BASE> the target without the suffix
 239 # <OBJECTS>
 240 # <OBJECT>
 241 # <LINK_LIBRARIES>
 242 # <FLAGS>
 243 # <LINK_FLAGS>
 244
 245 # CXX compiler information
 246 # <CMAKE_CXX_COMPILER>
 247 # <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS>
 248 # <CMAKE_CXX_SHARED_MODULE_CREATE_FLAGS>
 249 # <CMAKE_CXX_LINK_FLAGS>
 250
 251 # Static library tools
 252 # <CMAKE_AR>
 253 # <CMAKE_RANLIB>
 254
 255
 256 # create a shared C++ library
 257 if(NOT CMAKE_CXX_CREATE_SHARED_LIBRARY)
 258   set(CMAKE_CXX_CREATE_SHARED_LIBRARY
 259       "<CMAKE_CXX_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
 260 endif()
 261
 262 # create a c++ shared module copy the shared library rule by default
 263 if(NOT CMAKE_CXX_CREATE_SHARED_MODULE)
 264   set(CMAKE_CXX_CREATE_SHARED_MODULE ${CMAKE_CXX_CREATE_SHARED_LIBRARY})
 265 endif()
 266
 267
 268 # Create a static archive incrementally for large object file counts.
 269 # If CMAKE_CXX_CREATE_STATIC_LIBRARY is set it will override these.
 270 if(NOT DEFINED CMAKE_CXX_ARCHIVE_CREATE)
 271   set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> cr <TARGET> <LINK_FLAGS> <OBJECTS>")
 272 endif()
 273 if(NOT DEFINED CMAKE_CXX_ARCHIVE_APPEND)
 274   set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> r  <TARGET> <LINK_FLAGS> <OBJECTS>")
 275 endif()
 276 if(NOT DEFINED CMAKE_CXX_ARCHIVE_FINISH)
 277   set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
 278 endif()
 279
 280 # compile a C++ file into an object file
 281 if(NOT CMAKE_CXX_COMPILE_OBJECT)
 282   set(CMAKE_CXX_COMPILE_OBJECT
 283     "<CMAKE_CXX_COMPILER>  <DEFINES> <FLAGS> -o <OBJECT> -c <SOURCE>")
 284 endif()
 285
 286 if(NOT CMAKE_CXX_LINK_EXECUTABLE)
 287   set(CMAKE_CXX_LINK_EXECUTABLE
 288     "<CMAKE_CXX_COMPILER>  <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS>  -o <TARGET> <LINK_LIBRARIES>")
 289 endif()
 290
 291 mark_as_advanced(
 292 CMAKE_VERBOSE_MAKEFILE
 293 CMAKE_CXX_FLAGS
 294 CMAKE_CXX_FLAGS_RELEASE
 295 CMAKE_CXX_FLAGS_RELWITHDEBINFO
 296 CMAKE_CXX_FLAGS_MINSIZEREL
 297 CMAKE_CXX_FLAGS_DEBUG)
 298
 299 set(CMAKE_CXX_INFORMATION_LOADED 1)
 300