Enable cross-compilation across architectures on android

[fjricci]

Summary

This patch fixes cross-architecture compilation,
by allowing flags like -target and --sysroot to be set for
architecture testing and compilation.

[fjricci]

Fix CMAKE_C_FLAG spelling

[fjricci]

Fix whitespace

[beanz]

You shouldn't need to do this. CMAKE_${LANG}_FLAGS is implicitly read by CMake when constructing the compiler command line.

-Chris

[fjricci]

It looks to me like CMAKE_CXX_FLAGS is applied explicitly in add_compiler_rt_object_libraries, which makes me think that we do need to add them explicitly:

foreach(libname ${libnames})
  add_library(${libname} OBJECT ${LIB_SOURCES})
  set_target_compile_flags(${libname}
      ${CMAKE_CXX_FLAGS} ${extra_cflags_${libname}} ${LIB_CFLAGS})

This is not true for add_compiler_rt_runtime. If I set CMAKE_CXX_FLAGS and CMAKE_C_FLAGS without this patch, the flags passed do not end up in the compile commands when building the builtins.

[compnerd]

Why not do the same as add_compiler_rt_object_libraries and do this in add_compiler_rt_runtime?

[fjricci]

add_compiler_rt_runtime is used to build both c and c++ sources, depending on the object being built. In addition, the other objects using this function already add SANITIZER_COMMON_CFLAGS, which contains the necessary compilation flags (added via check_c[xx]_compiler_flags). The builtins are the only object which are built without the SANITIZER_COMMON_CFLAGS, and therefore don't have any of the user-specified compilation flags.

[compnerd]

SANITIZER_COMMON_CFLAGS are strictly for the sanitizers. Why not have a builtins equivalent? Im trying to understand why the builtins and sanitizers are being treated differently in handling of the flags.

[fjricci]

I could add a builtins equivalent, if that seems like a better approach. It's a non-trivial diff though.

[fjricci]

After further investigation, I think the patch in its current form is still the best solution.

The sanitizers add CMAKE_CXX_FLAGS, inside of add_compiler_rt_object_libraries. The builtins, which are C sources, require an analagous addition of CMAKE_C_FLAGS.

However, because of the shared usage of add_compiler_rt_runtime to compile non-C objects, the flags cannot be added in that function.

That makes the current location the most correct location to add the flags.

cmake/base-config-ix.cmake

if (MSVC_COMPAT_VERSION MATCHES "^[0-9].+$")
         # logic.
         append("${MSVC_VERSION_FLAG}" COMPILER_RT_TEST_COMPILER_CFLAGS)
       endif()
     endif()
   endif()
 
   # Generate the COMPILER_RT_SUPPORTED_ARCH list.
   if(ANDROID)
+    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${CMAKE_CFLAGS}")
     # Examine compiler output to determine target architecture.
     detect_target_arch()
     set(COMPILER_RT_OS_SUFFIX "-android")
   elseif(NOT APPLE) # Supported archs for Apple platforms are generated later
     if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "i[2-6]86|x86|amd64")
       if(NOT MSVC)
         test_target_arch(x86_64 "" "-m64")
         # FIXME: We build runtimes for both i686 and i386, as "clang -m32" may

lib/builtins/CMakeLists.txt

if (CAN_TARGET_${arch})
       # same symbols, making the symbol selection non-deterministic.
       foreach (_file ${${arch}_SOURCES})
         if (${_file} MATCHES ${arch}/*)
           get_filename_component(_name ${_file} NAME)
           string(REPLACE ".S" ".c" _cname "${_name}")
           list(REMOVE_ITEM ${arch}_SOURCES ${_cname})
         endif ()
       endforeach ()
-
       add_compiler_rt_runtime(clang_rt.builtins
                               STATIC
                               ARCHS ${arch}
                               SOURCES ${${arch}_SOURCES}
-                              CFLAGS ${maybe_stdc99}
+                              CFLAGS ${maybe_stdc99} ${CMAKE_CFLAGS}
                               PARENT_TARGET builtins)
     endif ()
   endforeach ()
 endif ()
 
 add_dependencies(compiler-rt builtins)