[CMake] NFC. Add support for testing the compiler without testing the linker

[beanz]

Summary

One of the big limitations we have in the compiler-rt build system today is that we cannot bootstrap building the builtins because you need a fully functional toolchain to pass CMake's tests.

This change adds support for compile only tests.

It is NFC because nothing is using the compile-only tests yet.

I believe this is the last separable part of D16653.

[compnerd]

cmake/Modules/BuiltinTests.cmake

9 ↗

(On Diff #55497)

Is there an assumption that we will only use a GNU style driver? What is insufficient about CMAKE_C_COMPILE_OBJECT?

[beanz]

cmake/Modules/BuiltinTests.cmake

9 ↗

(On Diff #55497)

Generally I think that we *should* be able to assume a Unix-conformant driver because if you're building the builtin library and you're not using Clang to do it you're probably doing something wrong.

That statement isn't true for the wider compiler-rt project, but I don't think we should be supporting the builtin libraries on any other toolchains.

That said, writing some CMake goop to construct a compiler command based on CMAKE_C_COMPILE_OBJECT shouldn't be too bad, so I'll do it.

[beanz]

Use CMAKE_C_COMPILE_OBJECT as the template for the compiler command.

[beanz]

Fixing a bug relating to stringify-ing and un-stringifying lists... I literally just documented this behavior, I should know better. Also fixed formatting to 80-col.

[rnk]

compiler-rt/trunk/cmake/Modules/BuiltinTests.cmake

55

Trusting the return code of the compiler is a bit naive. Upstream cmake tests all of the following messages to find unsupported flags:

macro (CHECK_COMPILER_FLAG_COMMON_PATTERNS _VAR)
   set(${_VAR}
     FAIL_REGEX "[Uu]nrecogni[sz]ed .*option"               # GNU, NAG
     FAIL_REGEX "unknown .*option"                          # Clang
     FAIL_REGEX "optimization flag .* not supported"        # Clang
     FAIL_REGEX "unknown argument ignored"                  # Clang (cl)
     FAIL_REGEX "ignoring unknown option"                   # MSVC, Intel
     FAIL_REGEX "warning D9002"                             # MSVC, any lang
     FAIL_REGEX "option.*not supported"                     # Intel
     FAIL_REGEX "invalid argument .*option"                 # Intel
     FAIL_REGEX "ignoring option .*argument required"       # Intel
     FAIL_REGEX "ignoring option .*argument is of wrong type" # Intel
     FAIL_REGEX "[Uu]nknown option"                         # HP
     FAIL_REGEX "[Ww]arning: [Oo]ption"                     # SunPro
     FAIL_REGEX "command option .* is not recognized"       # XL
     FAIL_REGEX "command option .* contains an incorrect subargument" # XL
     FAIL_REGEX "not supported in this configuration. ignored"       # AIX
     FAIL_REGEX "File with unknown suffix passed to linker" # PGI
     FAIL_REGEX "[Uu]nknown switch"                         # PGI
     FAIL_REGEX "WARNING: unknown flag:"                    # Open64
     FAIL_REGEX "Incorrect command line option:"            # Borland
     FAIL_REGEX "Warning: illegal option"                   # SunStudio 12
     FAIL_REGEX "[Ww]arning: Invalid suboption"             # Fujitsu
   )
endmacro ()

We don't support most of those compilers, but we do support MSVC, which ignores unknown flags, so we need to do something here.

[rnk]

compiler-rt/trunk/cmake/Modules/BuiltinTests.cmake

55

I bring this up because it means we get warnings on Windows:
http://lab.llvm.org:8011/builders/sanitizer-windows/builds/26602/steps/build%20compiler-rt/logs/warnings%20%2832%29
cl : Command line warning D9002 : ignoring unknown option '-std=gnu99'

[beanz]

@rnk, posted a patch -> https://reviews.llvm.org/D23030

-Chris

compiler-rt/trunk/cmake/Modules/BuiltinTests.cmake

+
+# This function takes an OS and a list of architectures and identifies the
+# subset of the architectures list that the installed toolchain can target.
+function(try_compile_only output)
+  set(SIMPLE_C ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/src.c)
+  file(WRITE ${SIMPLE_C} "int foo(int x, int y) { return x + y; }\n")
+  string(REGEX MATCHALL "<[A-Za-z0-9_]*>" substitutions
+         ${CMAKE_C_COMPILE_OBJECT})
+  string(REPLACE ";" " " extra_flags "${ARGN}")
+
+  set(test_compile_command "${CMAKE_C_COMPILE_OBJECT}")
+  foreach(substitution ${substitutions})
+    if(substitution STREQUAL "<CMAKE_C_COMPILER>")
+      string(REPLACE "<CMAKE_C_COMPILER>"
+             "${CMAKE_C_COMPILER}" test_compile_command ${test_compile_command})
+    elseif(substitution STREQUAL "<OBJECT>")
+      string(REPLACE "<OBJECT>"
+             "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/test.o"
+             test_compile_command ${test_compile_command})
+    elseif(substitution STREQUAL "<SOURCE>")
+      string(REPLACE "<SOURCE>" "${SIMPLE_C}" test_compile_command
+             ${test_compile_command})
+    elseif(substitution STREQUAL "<FLAGS>")
+      string(REPLACE "<FLAGS>" "${CMAKE_C_FLAGS} ${extra_flags}"
+             test_compile_command ${test_compile_command})
+    else()
+      string(REPLACE "${substitution}" "" test_compile_command
+             ${test_compile_command})
+    endif()
+  endforeach()
+
+  string(REPLACE " " ";" test_compile_command "${test_compile_command}")
+
+  execute_process(
+    COMMAND ${test_compile_command}
+    RESULT_VARIABLE result
+    OUTPUT_VARIABLE TEST_OUTPUT
+    ERROR_VARIABLE TEST_ERROR
+  )
+  if(result EQUAL 0)
+    set(${output} True PARENT_SCOPE)
+  else()
+    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Testing compiler for supporting " ${ARGN} ":\n"
+        "Command: ${test_compile_command}\n"
+        "${TEST_OUTPUT}\n${TEST_ERROR}\n${result}\n")
+    set(${output} False PARENT_SCOPE)
+  endif()
+endfunction()
+
+function(builtin_check_c_compiler_flag flag output)
+  message(STATUS "Performing Test ${output}")
+  try_compile_only(result ${flag})
+  set(${output} ${result} PARENT_SCOPE)
+  if(${result})
+    message(STATUS "Performing Test ${output} - Success")
+  else()
+    message(STATUS "Performing Test ${output} - Failed")
+  endif()
+endfunction()

compiler-rt/trunk/cmake/Modules/CompilerRTDarwinUtils.cmake

 # subset of the architectures list that the installed toolchain can target.
 function(darwin_test_archs os valid_archs)
   if(${valid_archs})
     message(STATUS "Using cached valid architectures for ${os}.")
     return()
   endif()
 
   set(archs ${ARGN})
+  if(NOT TEST_COMPILE_ONLY)
     message(STATUS "Finding valid architectures for ${os}...")
     set(SIMPLE_CPP ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/src.cpp)
     file(WRITE ${SIMPLE_CPP} "#include <iostream>\nint main() { std::cout << std::endl; return 0; }\n")
   
     set(os_linker_flags)
     foreach(flag ${DARWIN_${os}_LINKFLAGS})
       set(os_linker_flags "${os_linker_flags} ${flag}")
     endforeach()
+  endif()
 
   # The simple program will build for x86_64h on the simulator because it is 
   # compatible with x86_64 libraries (mostly), but since x86_64h isn't actually
   # a valid or useful architecture for the iOS simulator we should drop it.
   if(${os} MATCHES "^(iossim|tvossim|watchossim)$")
     list(REMOVE_ITEM archs "x86_64h")
   endif()
 
   set(working_archs)
   foreach(arch ${archs})
-    
     set(arch_linker_flags "-arch ${arch} ${os_linker_flags}")
+    if(TEST_COMPILE_ONLY)
+      try_compile_only(CAN_TARGET_${os}_${arch} -v -arch ${arch} ${DARWIN_${os}_CFLAGS})
+    else()
       try_compile(CAN_TARGET_${os}_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_CPP}
                   COMPILE_DEFINITIONS "-v -arch ${arch}" ${DARWIN_${os}_CFLAGS}
                   CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS=${arch_linker_flags}"
                   OUTPUT_VARIABLE TEST_OUTPUT)
+    endif()
     if(${CAN_TARGET_${os}_${arch}})
       list(APPEND working_archs ${arch})
     else()
       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
         "Testing compiler for supporting ${os}-${arch}:\n"
         "${TEST_OUTPUT}\n")
     endif()
   endforeach()

compiler-rt/trunk/cmake/Modules/CompilerRTUtils.cmake

macro(test_target_arch arch def)
   set(TARGET_${arch}_CFLAGS ${ARGN})
   set(argstring "")
   foreach(arg ${ARGN})
     set(argstring "${argstring} ${arg}")
   endforeach()
   check_compile_definition("${def}" "${argstring}" HAS_${arch}_DEF)
   if(NOT HAS_${arch}_DEF)
     set(CAN_TARGET_${arch} FALSE)
+  elseif(TEST_COMPILE_ONLY)
+    try_compile_only(CAN_TARGET_${arch} ${TARGET_${arch}_CFLAGS})
   else()
     set(argstring "${CMAKE_EXE_LINKER_FLAGS} ${argstring}")
     try_compile(CAN_TARGET_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_SOURCE}
                 COMPILE_DEFINITIONS "${TARGET_${arch}_CFLAGS}"
                 OUTPUT_VARIABLE TARGET_${arch}_OUTPUT
                 CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS:STRING=${argstring}")
   endif()
   if(${CAN_TARGET_${arch}})
     list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
   elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "${arch}" AND
          COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE)
     # Bail out if we cannot target the architecture we plan to test.
     message(FATAL_ERROR "Cannot compile for ${arch}:\n${TARGET_${arch}_OUTPUT}")
   endif()
 endmacro()