Adding experimental build support for building compiler-rt for iOS.

[beanz]

Summary

This patch updates and modifies some of the CMake support for building on Darwin platforms with the goal of adding support for iOS and making the code more managable. The following changes are present:

• Updated add_compiler_rt_object_libraries to properly handle setting architectures
• Added cmake/Modules/CompilerRTDarwinUtils.cmake to contain darwin-specific functions for detecting toolchain features
• Added iOS-specific flags
• Re-structured the code for setting platform-specific flags and enabling platforms
• Updated call sites of add_compiler_rt_darwin_dynamic_runtime to use SANITIZER_COMMON_DARWIN_${os}_ARCHES
• Added COMPILER_RT_ENABLE_IOS option (default value is Off) to control building for iOS

[filcab]

Thanks for adding this!

CMakeLists.txt

349

Nit: If we're printing a status message, I think we could spare the bytes to print "Simulator" :-)

cmake/Modules/CompilerRTDarwinUtils.cmake

2

This seems misleading. xcodebuild doesn't seem to honour SDKROOT.

If I have 10.10 and 10.9 installed, and set SDKROOT=/.../Xcode.app/.../MacOSX10.9.sdk, I get:

[~]% xcodebuild -version -sdk macosx Path
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.10.sdk

(This is really handy when you have an SDK available for 10.(X+1), but are running on 10.X.

lib/asan/CMakeLists.txt

116

Just to be sure, ASan will be supported on all of the arch + OS that sanitizer_common will run on? (at first sight, it almost looks like a copy-paste bug)

You're adding object_libraries (line 80) for ASAN_SUPPORTED_ARCH, but then generate dynamic_runtimes for SANITIZER_COMMON_..._ARCHES. Shouldn't these be the same, at least?

lib/ubsan/CMakeLists.txt

47

Just to be sure, UBSan will be supported on all of the arch + OS that sanitizer_common will run on?

Same comment as ASan (check line 42 here).

[beanz]

I will update the patches shortly.

cmake/Modules/CompilerRTDarwinUtils.cmake

2

I'll reword. Xcodebuild doesn't respect SDKROOT if you specify -sdk, which is why you would see that behavior.

lib/asan/CMakeLists.txt

116

Anna would have to comment as to what ASan will or won't be supported on. I'm just trying to make it build, and ASAN_SUPPORTED_ARCH is set to i386;x86_64, which just doesn't work on iOS. For Darwin we always need platform-specific arch settings.

The line 80 thing is just an oddity of the moment. If you look at add_compiler_rt_object_libraries, it actually ignores the ARCH setting that comes in because it needs platform-specific archs.

lib/ubsan/CMakeLists.txt

47

Again, I can't really comment about official support. I'm just trying to make it build and you can't build UBSan for iOS targeting x86.

My goal in these patches was to identify up front the architectures that your host toolchain is capable of targeting for each target OS, and build everything for all of them.

[beanz]

Updating based on feedback from filcab.

[filcab]

Hi Chris,

[samsonov]

I support the direction of this patch, but think it needs to be somewhat polished.
Most importantly, I'd suggest to split it into several smaller patches, that would be either to digest, review, and eventually land.
For example, substantial part of this changes is refactoring (introducing CompilerRTDarwinUtils, moving some functions there,
factoring out common flags to DARWIN_COMMON_CFLAGS, etc.), that can be committed first.

More comments inline.

CMakeLists.txt

300

This looks weird. It's just a coincidence that -stdlib=libc++ is both linker and compile flag. Not all compiler flags might be passed here.

307

Keep DARWIN_COMMON_LINKFLAGS first for consistency.

320

Do you actually need to do all this setup if IOSSIM_SDK_DIR is not specified? It would make sense to group flag setup and darwin_test_archs invocation together.

335

Print them after you calculated them?

361

This is confusing, we don't set anything below.

cmake/Modules/AddCompilerRT.cmake

23

This is really confusing now - you never use ARCHS input list on Darwin at all. The user should have the ability to restrict the set of architectures she targets - this is exactly the reason why we have ASAN_SUPPORTED_ARCH, UBSAN_SUPPORTED_ARCH and so on. There is no guarantee that we would be able to build ASan runtime for all architectures that our host toolchain can target for OS.

At the very least it means that you should calculate the intersection of ${LIB_ARCHS} and ${SANITIZER_COMMON_DARWIN_${os}_ARCHES}. But now all this gets complicated - different architectures are available on different OSes, so it turns out that the input parameters of modified add_compiler_rt_object_libraries don't work well. I see no "easy" fix for that - probably we should start to make complex intrusive changes and move from keeping the list of "supported architectures" (COMPILER_RT_SUPPORTED_ARCH) and "supported OSes" (SANITIZER_COMMON_SUPPORTED_OS) to a list of "supported triples"
(well, in fact, OS-arch pairs).

cmake/Modules/CompilerRTDarwinUtils.cmake

28

What if ld -v failed?

32

I think it's easier to scrape this information with regexp matching. For example, see the calculation of SANITIZER_MIN_OSX_VERSION from -mmacosx-version-min= in CMakeLists.txt. Then you will also be able to detect an error when you're unable to find configured to support archs: substring.

34

Why do you refer to the number of convex uniform honeycombs here?

66

Some of this code duplicates logic from cmake/config-ix.cmake that calculates COMPILER_RT_SUPPORTED_ARCH. I think you'd need to use the latter variable on Darwin (although that's tricky - see rant about triples above).

lib/asan/CMakeLists.txt

116

See note above.

[beanz]

Alexey,

Thanks for the feedback. I'll split this up and revise as you suggested. I'm going out of town this evening until 7/7, so I probably won't send updated patches until I get back in July.

Thanks,
-Chris

CMakeLists.txt

 append_list_if(COMPILER_RT_HAS_WC99_EXTENSIONS_FLAG -Wno-c99-extensions SANITIZER_COMMON_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WNON_VIRTUAL_DTOR_FLAG -Wno-non-virtual-dtor SANITIZER_COMMON_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WD4146_FLAG /wd4146 SANITIZER_COMMON_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WD4291_FLAG /wd4291 SANITIZER_COMMON_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WD4391_FLAG /wd4391 SANITIZER_COMMON_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WD4722_FLAG /wd4722 SANITIZER_COMMON_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WD4800_FLAG /wd4800 SANITIZER_COMMON_CFLAGS)
 if(APPLE)
-  macro(find_darwin_sdk_dir var sdk_name)
-    # Let's first try the internal SDK, otherwise use the public SDK.
-    execute_process(
-      COMMAND xcodebuild -version -sdk ${sdk_name}.internal Path
-      OUTPUT_VARIABLE ${var}
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-      ERROR_FILE /dev/null
-    )
-    if(${var} STREQUAL "")
-      execute_process(
-        COMMAND xcodebuild -version -sdk ${sdk_name} Path
-        OUTPUT_VARIABLE ${var}
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-        ERROR_FILE /dev/null
-      )
-    endif()
-  endmacro()
+  include(CompilerRTDarwinUtils)
+
+  option(COMPILER_RT_ENABLE_IOS "Enable building for iOS - Experimental" Off)
 
   find_darwin_sdk_dir(OSX_SDK_DIR macosx)
   find_darwin_sdk_dir(IOSSIM_SDK_DIR iphonesimulator)
+  find_darwin_sdk_dir(IOS_SDK_DIR iphoneos)
 
+  darwin_get_toolchain_supported_archs(toolchain_arches)
+
+  # Note: In order to target x86_64h on OS X the minimum deployment target must
+  # be 10.8 or higher.
   set(SANITIZER_COMMON_SUPPORTED_OS osx)
   string(REGEX MATCH "-mmacosx-version-min=([.0-9]+)"
          MACOSX_VERSION_MIN_FLAG "${CMAKE_CXX_FLAGS}")
   if(MACOSX_VERSION_MIN_FLAG)
     set(SANITIZER_MIN_OSX_VERSION "${CMAKE_MATCH_1}")
     if(SANITIZER_MIN_OSX_VERSION VERSION_LESS "10.7")
       message(FATAL_ERROR "Too old OS X version: ${SANITIZER_MIN_OSX_VERSION}")
     endif()
   else()
     set(SANITIZER_MIN_OSX_VERSION 10.7)
-    if(IOSSIM_SDK_DIR)
-      list(APPEND SANITIZER_COMMON_SUPPORTED_OS iossim)
-    endif()
   endif()
 
-  set(CMAKE_OSX_DEPLOYMENT_TARGET "") # We're setting the flag manually below.
-  set(DARWIN_osx_CFLAGS -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION}
-    -stdlib=libc++)
-  set(DARWIN_iossim_CFLAGS
-    -stdlib=libc++
-    -mios-simulator-version-min=7.0 -isysroot ${IOSSIM_SDK_DIR})
+  set(DARWIN_COMMON_CFLAGS -stdlib=libc++)
+  set(DARWIN_COMMON_LINKFLAGS
+    ${DARWIN_COMMON_CFLAGS}
+    -lc++
+    -lc++abi)
+  
+  set(DARWIN_osx_CFLAGS
+    ${DARWIN_COMMON_CFLAGS}
+    -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION})
   set(DARWIN_osx_LINKFLAGS -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION}
-    -stdlib=libc++ -lc++ -lc++abi)
+    ${DARWIN_COMMON_LINKFLAGS})
+
+  set(DARWIN_iossim_CFLAGS
+    ${DARWIN_COMMON_CFLAGS}
+    -mios-simulator-version-min=7.0
+    -isysroot ${IOSSIM_SDK_DIR})
   set(DARWIN_iossim_LINKFLAGS
-    -stdlib=libc++ -lc++ -lc++abi
+    ${DARWIN_COMMON_LINKFLAGS}
     -Wl,-ios_simulator_version_min,7.0.0
     -mios-simulator-version-min=7.0
     -isysroot ${IOSSIM_SDK_DIR})
 
+  set(DARWIN_ios_CFLAGS
+    ${DARWIN_COMMON_CFLAGS}
+    -miphoneos-version-min=7.0
+    -isysroot ${IOS_SDK_DIR})
+  set(DARWIN_ios_LINKFLAGS
+    ${DARWIN_COMMON_LINKFLAGS}
+    -Wl,-ios_version_min,7.0.0
+    -miphoneos-version-min=7.0
+    -isysroot ${IOS_SDK_DIR})
+
   if(OSX_SDK_DIR)
     list(APPEND DARWIN_osx_CFLAGS -isysroot ${OSX_SDK_DIR})
     list(APPEND DARWIN_osx_LINKFLAGS -isysroot ${OSX_SDK_DIR})
   endif()
+
+  message(STATUS "Toolchain supported arches: ${toolchain_arches}")
+
+  # these tests have to happen after the flag variables are setup
+  if(NOT MACOSX_VERSION_MIN_FLAG)
+    darwin_test_archs(osx
+      SANITIZER_COMMON_DARWIN_osx_ARCHES
+      ${toolchain_arches})
+    message(STATUS "OSX supported arches: ${SANITIZER_COMMON_DARWIN_osx_ARCHES}")
+
+    if(IOSSIM_SDK_DIR)
+      list(APPEND SANITIZER_COMMON_SUPPORTED_OS iossim)
+      darwin_test_archs(iossim
+        SANITIZER_COMMON_DARWIN_iossim_ARCHES
+        ${toolchain_arches})
+      message(STATUS "iOS Sim supported arches: ${SANITIZER_COMMON_DARWIN_iossim_ARCHES}")
+    endif()
+
+    if(IOS_SDK_DIR AND COMPILER_RT_ENABLE_IOS)
+      list(APPEND SANITIZER_COMMON_SUPPORTED_OS ios)
+      darwin_test_archs(ios
+        SANITIZER_COMMON_DARWIN_ios_ARCHES
+        ${toolchain_arches})
+      message(STATUS "iOS supported arches: ${SANITIZER_COMMON_DARWIN_ios_ARCHES}")
+    endif()
+  endif()
+
+  set(CMAKE_OSX_DEPLOYMENT_TARGET "") # We're setting the flag manually below.
+
 endif()
 
 add_subdirectory(include)
 
 set(COMPILER_RT_LIBCXX_PATH ${LLVM_MAIN_SRC_DIR}/projects/libcxx)
 if(EXISTS ${COMPILER_RT_LIBCXX_PATH}/)
   set(COMPILER_RT_HAS_LIBCXX_SOURCES TRUE)
 else()

cmake/Modules/AddCompilerRT.cmake

 function(add_compiler_rt_object_libraries name)
   cmake_parse_arguments(LIB "" "" "OS;ARCHS;SOURCES;CFLAGS;DEFS" ${ARGN})
   set(libnames)
   if(APPLE)
     foreach(os ${LIB_OS})
       set(libname "${name}.${os}")
       set(libnames ${libnames} ${libname})
       set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS})
+      set(extra_linkflags_${libname} ${DARWIN_${os}_LINKFLAGS})
+      set(LIB_ARCHS_${libname} ${SANITIZER_COMMON_DARWIN_${os}_ARCHES})
     endforeach()
   else()
     foreach(arch ${LIB_ARCHS})
       set(libname "${name}.${arch}")
       set(libnames ${libnames} ${libname})
       set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS})
       if(NOT CAN_TARGET_${arch})
         message(FATAL_ERROR "Archtecture ${arch} can't be targeted")
         return()
       endif()
     endforeach()
   endif()
   
   foreach(libname ${libnames})
     add_library(${libname} OBJECT ${LIB_SOURCES})
     set_target_compile_flags(${libname}
       ${CMAKE_CXX_FLAGS} ${extra_cflags_${libname}} ${LIB_CFLAGS})
     set_property(TARGET ${libname} APPEND PROPERTY
       COMPILE_DEFINITIONS ${LIB_DEFS})
     if(APPLE)
-      set_target_properties(${libname} PROPERTIES OSX_ARCHITECTURES "${LIB_ARCHS}")
+      set_target_properties(${libname} PROPERTIES
+        OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}"
+        LINK_FLAGS "${extra_linkflags_${libname}}")
     endif()
   endforeach()
 endfunction()
 
 # Adds static or shared runtime for a given architecture and puts it in the
 # proper directory in the build and install trees.
 # add_compiler_rt_runtime(<name> <arch> {STATIC,SHARED}
 #                         SOURCES <source files>

cmake/Modules/CompilerRTDarwinUtils.cmake

+# On OS X SDKs can be installed anywhere on the base system and xcode-select
+# or SDKROOT can be used to set the default one to use. We want to find the SDKs
+# that are present in the current Xcode
+function(find_darwin_sdk_dir var sdk_name)
+  # Let's first try the internal SDK, otherwise use the public SDK.
+  execute_process(
+    COMMAND xcodebuild -version -sdk ${sdk_name}.internal Path
+    OUTPUT_VARIABLE var_internal
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_FILE /dev/null
+  )
+  if("" STREQUAL "${var_internal}")
+    execute_process(
+      COMMAND xcodebuild -version -sdk ${sdk_name} Path
+      OUTPUT_VARIABLE var_internal
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      ERROR_FILE /dev/null
+    )
+  endif()
+  set(${var} ${var_internal} PARENT_SCOPE)
+endfunction()
+
+# There isn't a clear mapping of what architectures are supported with a given
+# target platform, but ld's version output does list the architectures it can
+# link for.
+function(darwin_get_toolchain_supported_archs output_var)
+  execute_process(
+    COMMAND ld -v
+    ERROR_VARIABLE LINKER_VERSION)
+
+  string(FIND ${LINKER_VERSION} "configured to support archs:" LINE_START)
+  string(SUBSTRING ${LINKER_VERSION} ${LINE_START} -1 ARCHES_LINE)
+  string(SUBSTRING ${ARCHES_LINE} 28 -1 ARCHES_LINE)
+  string(FIND ${ARCHES_LINE} "\n" LINE_END)
+  string(SUBSTRING ${ARCHES_LINE} 0 ${LINE_END} ARCHES_LINE)
+  string(STRIP ${ARCHES_LINE} ARCHES_LINE)
+  string(REPLACE " " ";" ARCHES ${ARCHES_LINE})
+  
+  set(${output_var} ${ARCHES} PARENT_SCOPE)
+endfunction()
+
+# 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(darwin_test_archs os valid_archs)
+  set(archs ${ARGN})
+  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() { return 0; }\n")
+
+  set(os_linker_flags)
+  foreach(flag ${DARWIN_${os}_LINKFLAGS})
+    set(os_linker_flags "${os_linker_flags} ${flag}")
+  endforeach()
+
+  # The simple program will build for x86_64h on the simulator because it is 
+  # compatible with x86_64 libraries (mostly).
+  if(${os} STREQUAL "iossim")
+    list(REMOVE_ITEM archs "x86_64h")
+  endif()
+
+  set(WORKING_ARCHES)
+  foreach(arch ${archs})
+    
+    set(arch_linker_flags "-arch ${arch} ${os_linker_flags}")
+    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)
+    if(${CAN_TARGET_${os}_${arch}})
+      list(APPEND WORKING_ARCHES ${arch})
+    endif()
+  endforeach()
+  set(${valid_archs} ${WORKING_ARCHES} PARENT_SCOPE)
+endfunction()
 No newline at end of file

lib/asan/CMakeLists.txt

add_compiler_rt_object_libraries(RTAsan_dynamic_version_script_dummy
     DEFS ${ASAN_DYNAMIC_DEFINITIONS})
 endif()
 
 # Build ASan runtimes shipped with Clang.
 add_custom_target(asan)
 if(APPLE)
   foreach (os ${SANITIZER_COMMON_SUPPORTED_OS})
     add_compiler_rt_darwin_dynamic_runtime(clang_rt.asan_${os}_dynamic ${os}
-      ARCHS ${ASAN_SUPPORTED_ARCH}
+      ARCHS ${SANITIZER_COMMON_DARWIN_${os}_ARCHES}
       SOURCES $<TARGET_OBJECTS:RTAsan.${os}>
               $<TARGET_OBJECTS:RTInterception.${os}>
               $<TARGET_OBJECTS:RTSanitizerCommon.${os}>
               $<TARGET_OBJECTS:RTLSanCommon.${os}>
               $<TARGET_OBJECTS:RTUbsan.${os}>
       CFLAGS ${ASAN_DYNAMIC_CFLAGS}
       DEFS ${ASAN_DYNAMIC_DEFINITIONS})
     add_dependencies(asan clang_rt.asan_${os}_dynamic)

lib/ubsan/CMakeLists.txt

if(COMPILER_RT_HAS_UBSAN)
     # Initializer of standalone UBSan runtime.
     add_compiler_rt_object_libraries(RTUbsan_standalone
       OS ${SANITIZER_COMMON_SUPPORTED_OS}
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       SOURCES ${UBSAN_STANDALONE_SOURCES}
       CFLAGS ${UBSAN_STANDALONE_CFLAGS})
     foreach(os ${SANITIZER_COMMON_SUPPORTED_OS})
       add_compiler_rt_darwin_dynamic_runtime(clang_rt.ubsan_${os}_dynamic ${os}
-        ARCHS ${UBSAN_SUPPORTED_ARCH}
+        ARCHS ${SANITIZER_COMMON_DARWIN_${os}_ARCHES}
         SOURCES $<TARGET_OBJECTS:RTUbsan.${os}>
                 $<TARGET_OBJECTS:RTUbsan_standalone.${os}>
                 $<TARGET_OBJECTS:RTSanitizerCommon.${os}>)
 
       add_dependencies(ubsan clang_rt.ubsan_${os}_dynamic)
     endforeach()
   endif()