cmake/CMakeDetermineCompilerId.cmake

   1
   2 #=============================================================================
   3 # Copyright 2007-2009 Kitware, Inc.
   4 #
   5 # Distributed under the OSI-approved BSD License (the "License");
   6 # see accompanying file Copyright.txt for details.
   7 #
   8 # This software is distributed WITHOUT ANY WARRANTY; without even the
   9 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  10 # See the License for more information.
  11 #=============================================================================
  12 # (To distribute this file outside of CMake, substitute the full
  13 #  License text for the above reference.)
  14
  15 # Function to compile a source file to identify the compiler.  This is
  16 # used internally by CMake and should not be included by user code.
  17 # If successful, sets CMAKE_<lang>_COMPILER_ID and CMAKE_<lang>_PLATFORM_ID
  18
  19 FUNCTION(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
  20   # Make sure the compiler arguments are clean.
  21   STRING(STRIP "${CMAKE_${lang}_COMPILER_ARG1}" CMAKE_${lang}_COMPILER_ID_ARG1)
  22   STRING(REGEX REPLACE " +" ";" CMAKE_${lang}_COMPILER_ID_ARG1 "${CMAKE_${lang}_COMPILER_ID_ARG1}")
  23
  24   # Make sure user-specified compiler flags are used.
  25   IF(CMAKE_${lang}_FLAGS)
  26     SET(CMAKE_${lang}_COMPILER_ID_FLAGS ${CMAKE_${lang}_FLAGS})
  27   ELSE(CMAKE_${lang}_FLAGS)
  28     SET(CMAKE_${lang}_COMPILER_ID_FLAGS $ENV{${flagvar}})
  29   ENDIF(CMAKE_${lang}_FLAGS)
  30   STRING(REGEX REPLACE " " ";" CMAKE_${lang}_COMPILER_ID_FLAGS_LIST "${CMAKE_${lang}_COMPILER_ID_FLAGS}")
  31
  32   # Compute the directory in which to run the test.
  33   SET(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CompilerId${lang})
  34
  35   # Try building with no extra flags and then try each set
  36   # of helper flags.  Stop when the compiler is identified.
  37   FOREACH(flags "" ${CMAKE_${lang}_COMPILER_ID_TEST_FLAGS})
  38     IF(NOT CMAKE_${lang}_COMPILER_ID)
  39       CMAKE_DETERMINE_COMPILER_ID_BUILD("${lang}" "${flags}" "${src}")
  40       FOREACH(file ${COMPILER_${lang}_PRODUCED_FILES})
  41         CMAKE_DETERMINE_COMPILER_ID_CHECK("${lang}" "${CMAKE_${lang}_COMPILER_ID_DIR}/${file}" "${src}")
  42       ENDFOREACH(file)
  43     ENDIF(NOT CMAKE_${lang}_COMPILER_ID)
  44   ENDFOREACH(flags)
  45
  46   # If the compiler is still unknown, try to query its vendor.
  47   IF(NOT CMAKE_${lang}_COMPILER_ID)
  48     CMAKE_DETERMINE_COMPILER_ID_VENDOR(${lang})
  49   ENDIF()
  50
  51   # if the format is unknown after all files have been checked, put "Unknown" in the cache
  52   IF(NOT CMAKE_EXECUTABLE_FORMAT)
  53     SET(CMAKE_EXECUTABLE_FORMAT "Unknown" CACHE INTERNAL "Executable file format")
  54   ENDIF(NOT CMAKE_EXECUTABLE_FORMAT)
  55
  56   # Display the final identification result.
  57   IF(CMAKE_${lang}_COMPILER_ID)
  58     MESSAGE(STATUS "The ${lang} compiler identification is "
  59       "${CMAKE_${lang}_COMPILER_ID}")
  60   ELSE(CMAKE_${lang}_COMPILER_ID)
  61     MESSAGE(STATUS "The ${lang} compiler identification is unknown")
  62   ENDIF(CMAKE_${lang}_COMPILER_ID)
  63
  64   SET(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE)
  65   SET(CMAKE_${lang}_PLATFORM_ID "${CMAKE_${lang}_PLATFORM_ID}" PARENT_SCOPE)
  66   SET(MSVC_${lang}_ARCHITECTURE_ID "${MSVC_${lang}_ARCHITECTURE_ID}"
  67     PARENT_SCOPE)
  68 ENDFUNCTION(CMAKE_DETERMINE_COMPILER_ID)
  69
  70 #-----------------------------------------------------------------------------
  71 # Function to write the compiler id source file.
  72 FUNCTION(CMAKE_DETERMINE_COMPILER_ID_WRITE lang src)
  73   FILE(READ ${CMAKE_ROOT}/Modules/${src}.in ID_CONTENT_IN)
  74   STRING(CONFIGURE "${ID_CONTENT_IN}" ID_CONTENT_OUT @ONLY)
  75   FILE(WRITE ${CMAKE_${lang}_COMPILER_ID_DIR}/${src} "${ID_CONTENT_OUT}")
  76 ENDFUNCTION(CMAKE_DETERMINE_COMPILER_ID_WRITE)
  77
  78 #-----------------------------------------------------------------------------
  79 # Function to build the compiler id source file and look for output
  80 # files.
  81 FUNCTION(CMAKE_DETERMINE_COMPILER_ID_BUILD lang testflags src)
  82   # Create a clean working directory.
  83   FILE(REMOVE_RECURSE ${CMAKE_${lang}_COMPILER_ID_DIR})
  84   FILE(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR})
  85   CMAKE_DETERMINE_COMPILER_ID_WRITE("${lang}" "${src}")
  86
  87   # Construct a description of this test case.
  88   SET(COMPILER_DESCRIPTION
  89     "Compiler: ${CMAKE_${lang}_COMPILER} ${CMAKE_${lang}_COMPILER_ID_ARG1}
  90 Build flags: ${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}
  91 Id flags: ${testflags}
  92 ")
  93
  94   # Compile the compiler identification source.
  95   IF(COMMAND EXECUTE_PROCESS)
  96     EXECUTE_PROCESS(
  97       COMMAND ${CMAKE_${lang}_COMPILER}
  98               ${CMAKE_${lang}_COMPILER_ID_ARG1}
  99               ${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}
 100               ${testflags}
 101               "${src}"
 102       WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
 103       OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
 104       ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
 105       RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT
 106       )
 107   ELSE(COMMAND EXECUTE_PROCESS)
 108     EXEC_PROGRAM(
 109       ${CMAKE_${lang}_COMPILER} ${CMAKE_${lang}_COMPILER_ID_DIR}
 110       ARGS ${CMAKE_${lang}_COMPILER_ID_ARG1}
 111            ${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}
 112            ${testflags}
 113            \"${src}\"
 114       OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
 115       RETURN_VALUE CMAKE_${lang}_COMPILER_ID_RESULT
 116       )
 117   ENDIF(COMMAND EXECUTE_PROCESS)
 118
 119   # Check the result of compilation.
 120   IF(CMAKE_${lang}_COMPILER_ID_RESULT)
 121     # Compilation failed.
 122     SET(MSG
 123       "Compiling the ${lang} compiler identification source file \"${src}\" failed.
 124 ${COMPILER_DESCRIPTION}
 125 The output was:
 126 ${CMAKE_${lang}_COMPILER_ID_RESULT}
 127 ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
 128
 129 ")
 130     FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "${MSG}")
 131     #IF(NOT CMAKE_${lang}_COMPILER_ID_ALLOW_FAIL)
 132     #  MESSAGE(FATAL_ERROR "${MSG}")
 133     #ENDIF(NOT CMAKE_${lang}_COMPILER_ID_ALLOW_FAIL)
 134
 135     # No output files should be inspected.
 136     SET(COMPILER_${lang}_PRODUCED_FILES)
 137   ELSE(CMAKE_${lang}_COMPILER_ID_RESULT)
 138     # Compilation succeeded.
 139     FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 140       "Compiling the ${lang} compiler identification source file \"${src}\" succeeded.
 141 ${COMPILER_DESCRIPTION}
 142 The output was:
 143 ${CMAKE_${lang}_COMPILER_ID_RESULT}
 144 ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
 145
 146 ")
 147
 148     # Find the executable produced by the compiler, try all files in the
 149     # binary dir.
 150     FILE(GLOB COMPILER_${lang}_PRODUCED_FILES
 151       RELATIVE ${CMAKE_${lang}_COMPILER_ID_DIR}
 152       ${CMAKE_${lang}_COMPILER_ID_DIR}/*)
 153     LIST(REMOVE_ITEM COMPILER_${lang}_PRODUCED_FILES "${src}")
 154     FOREACH(file ${COMPILER_${lang}_PRODUCED_FILES})
 155       FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 156         "Compilation of the ${lang} compiler identification source \""
 157         "${src}\" produced \"${file}\"\n\n")
 158     ENDFOREACH(file)
 159
 160     IF(NOT COMPILER_${lang}_PRODUCED_FILES)
 161       # No executable was found.
 162       FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
 163         "Compilation of the ${lang} compiler identification source \""
 164         "${src}\" did not produce an executable in \""
 165         "${CMAKE_${lang}_COMPILER_ID_DIR}\".\n\n")
 166     ENDIF(NOT COMPILER_${lang}_PRODUCED_FILES)
 167   ENDIF(CMAKE_${lang}_COMPILER_ID_RESULT)
 168
 169   # Return the files produced by the compilation.
 170   SET(COMPILER_${lang}_PRODUCED_FILES "${COMPILER_${lang}_PRODUCED_FILES}" PARENT_SCOPE)
 171 ENDFUNCTION(CMAKE_DETERMINE_COMPILER_ID_BUILD lang testflags src)
 172
 173 #-----------------------------------------------------------------------------
 174 # Function to extract the compiler id from an executable.
 175 FUNCTION(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
 176   # Look for a compiler id if not yet known.
 177   IF(NOT CMAKE_${lang}_COMPILER_ID)
 178     # Read the compiler identification string from the executable file.
 179     SET(COMPILER_ID)
 180     SET(PLATFORM_ID)
 181     FILE(STRINGS ${file}
 182       CMAKE_${lang}_COMPILER_ID_STRINGS LIMIT_COUNT 3 REGEX "INFO:")
 183     SET(HAVE_COMPILER_TWICE 0)
 184     FOREACH(info ${CMAKE_${lang}_COMPILER_ID_STRINGS})
 185       IF("${info}" MATCHES ".*INFO:compiler\\[([^]\"]*)\\].*")
 186         IF(COMPILER_ID)
 187           SET(COMPILER_ID_TWICE 1)
 188         ENDIF(COMPILER_ID)
 189         STRING(REGEX REPLACE ".*INFO:compiler\\[([^]]*)\\].*" "\\1"
 190           COMPILER_ID "${info}")
 191       ENDIF("${info}" MATCHES ".*INFO:compiler\\[([^]\"]*)\\].*")
 192       IF("${info}" MATCHES ".*INFO:platform\\[([^]\"]*)\\].*")
 193         STRING(REGEX REPLACE ".*INFO:platform\\[([^]]*)\\].*" "\\1"
 194           PLATFORM_ID "${info}")
 195       ENDIF("${info}" MATCHES ".*INFO:platform\\[([^]\"]*)\\].*")
 196       IF("${info}" MATCHES ".*INFO:arch\\[([^]\"]*)\\].*")
 197         STRING(REGEX REPLACE ".*INFO:arch\\[([^]]*)\\].*" "\\1"
 198           ARCHITECTURE_ID "${info}")
 199       ENDIF("${info}" MATCHES ".*INFO:arch\\[([^]\"]*)\\].*")
 200     ENDFOREACH(info)
 201
 202     # Check if a valid compiler and platform were found.
 203     IF(COMPILER_ID AND NOT COMPILER_ID_TWICE)
 204       SET(CMAKE_${lang}_COMPILER_ID "${COMPILER_ID}")
 205       SET(CMAKE_${lang}_PLATFORM_ID "${PLATFORM_ID}")
 206       SET(MSVC_${lang}_ARCHITECTURE_ID "${ARCHITECTURE_ID}")
 207     ENDIF(COMPILER_ID AND NOT COMPILER_ID_TWICE)
 208
 209     # Check the compiler identification string.
 210     IF(CMAKE_${lang}_COMPILER_ID)
 211       # The compiler identification was found.
 212       FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 213         "The ${lang} compiler identification is ${CMAKE_${lang}_COMPILER_ID}, found in \""
 214         "${file}\"\n\n")
 215     ELSE(CMAKE_${lang}_COMPILER_ID)
 216       # The compiler identification could not be found.
 217       FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
 218         "The ${lang} compiler identification could not be found in \""
 219         "${file}\"\n\n")
 220     ENDIF(CMAKE_${lang}_COMPILER_ID)
 221   ENDIF(NOT CMAKE_${lang}_COMPILER_ID)
 222
 223   # try to figure out the executable format: ELF, COFF, Mach-O
 224   IF(NOT CMAKE_EXECUTABLE_FORMAT)
 225     FILE(READ ${file} CMAKE_EXECUTABLE_MAGIC LIMIT 4 HEX)
 226
 227     # ELF files start with 0x7f"ELF"
 228     IF("${CMAKE_EXECUTABLE_MAGIC}" STREQUAL "7f454c46")
 229       SET(CMAKE_EXECUTABLE_FORMAT "ELF" CACHE INTERNAL "Executable file format")
 230     ENDIF("${CMAKE_EXECUTABLE_MAGIC}" STREQUAL "7f454c46")
 231
 232 #    # COFF (.exe) files start with "MZ"
 233 #    IF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "4d5a....")
 234 #      SET(CMAKE_EXECUTABLE_FORMAT "COFF" CACHE STRING "Executable file format")
 235 #    ENDIF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "4d5a....")
 236 #
 237 #    # Mach-O files start with CAFEBABE or FEEDFACE, according to http://radio.weblogs.com/0100490/2003/01/28.html
 238 #    IF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "cafebabe")
 239 #      SET(CMAKE_EXECUTABLE_FORMAT "MACHO" CACHE STRING "Executable file format")
 240 #    ENDIF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "cafebabe")
 241 #    IF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "feedface")
 242 #      SET(CMAKE_EXECUTABLE_FORMAT "MACHO" CACHE STRING "Executable file format")
 243 #    ENDIF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "feedface")
 244
 245   ENDIF(NOT CMAKE_EXECUTABLE_FORMAT)
 246   IF(NOT DEFINED CMAKE_EXECUTABLE_FORMAT)
 247     SET(CMAKE_EXECUTABLE_FORMAT)
 248   ENDIF()
 249   # Return the information extracted.
 250   SET(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE)
 251   SET(CMAKE_${lang}_PLATFORM_ID "${CMAKE_${lang}_PLATFORM_ID}" PARENT_SCOPE)
 252   SET(MSVC_${lang}_ARCHITECTURE_ID "${MSVC_${lang}_ARCHITECTURE_ID}"
 253     PARENT_SCOPE)
 254   SET(CMAKE_EXECUTABLE_FORMAT "${CMAKE_EXECUTABLE_FORMAT}" PARENT_SCOPE)
 255 ENDFUNCTION(CMAKE_DETERMINE_COMPILER_ID_CHECK lang)
 256
 257 #-----------------------------------------------------------------------------
 258 # Function to query the compiler vendor.
 259 # This uses a table with entries of the form
 260 #   list(APPEND CMAKE_${lang}_COMPILER_ID_VENDORS ${vendor})
 261 #   set(CMAKE_${lang}_COMPILER_ID_VENDOR_FLAGS_${vendor} -some-vendor-flag)
 262 #   set(CMAKE_${lang}_COMPILER_ID_VENDOR_REGEX_${vendor} "Some Vendor Output")
 263 # We try running the compiler with the flag for each vendor and
 264 # matching its regular expression in the output.
 265 FUNCTION(CMAKE_DETERMINE_COMPILER_ID_VENDOR lang)
 266
 267   IF(NOT CMAKE_${lang}_COMPILER_ID_DIR)
 268     # We get here when this function is called not from within CMAKE_DETERMINE_COMPILER_ID()
 269     # This is done e.g. for detecting the compiler ID for assemblers.
 270     # Compute the directory in which to run the test and Create a clean working directory.
 271     SET(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CompilerId${lang})
 272     FILE(REMOVE_RECURSE ${CMAKE_${lang}_COMPILER_ID_DIR})
 273     FILE(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR})
 274   ENDIF(NOT CMAKE_${lang}_COMPILER_ID_DIR)
 275
 276
 277   FOREACH(vendor ${CMAKE_${lang}_COMPILER_ID_VENDORS})
 278     SET(flags ${CMAKE_${lang}_COMPILER_ID_VENDOR_FLAGS_${vendor}})
 279     SET(regex ${CMAKE_${lang}_COMPILER_ID_VENDOR_REGEX_${vendor}})
 280     EXECUTE_PROCESS(
 281       COMMAND ${CMAKE_${lang}_COMPILER}
 282       ${CMAKE_${lang}_COMPILER_ID_ARG1}
 283       ${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}
 284       ${flags}
 285       WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
 286       OUTPUT_VARIABLE output ERROR_VARIABLE output
 287       RESULT_VARIABLE result
 288       TIMEOUT 10
 289       )
 290
 291     IF("${lang}" STREQUAL "ASM")
 292       MESSAGE(STATUS "Checked for ${vendor}")
 293       MESSAGE(STATUS "   Output: -${output}-")
 294       MESSAGE(STATUS "   Result: -${result}-")
 295     ENDIF("${lang}" STREQUAL "ASM")
 296
 297     IF("${output}" MATCHES "${regex}")
 298       FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 299         "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
 300         "matched \"${regex}\":\n${output}")
 301       SET(CMAKE_${lang}_COMPILER_ID "${vendor}" PARENT_SCOPE)
 302       BREAK()
 303     ELSE()
 304       IF("${result}" MATCHES  "timeout")
 305         FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
 306           "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
 307           "terminated after 10 s due to timeout.")
 308       ELSE()
 309         FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
 310           "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
 311           "did not match \"${regex}\":\n${output}")
 312        ENDIF()
 313     ENDIF()
 314   ENDFOREACH()
 315 ENDFUNCTION(CMAKE_DETERMINE_COMPILER_ID_VENDOR)