[compiler-rt][Android] Stop using detect_target_arch

[rprichard]

Summary

For Android only, compiler-rt used detect_target_arch to select the
architecture to target. detect_target_arch was added in Sept 2014
(SVN r218605). At that time, compiler-rt selected the default arch
using ${LLVM_NATIVE_ARCH}, which seems to have been the host
architecture and therefore not suitable for cross-compilation.

The compiler-rt build system was refactored in Sept 2015 (SVN r247094
and SVN r247099) to use COMPILER_RT_DEFAULT_TARGET_TRIPLE to control
the target arch rather than LLVM_NATIVE_ARCH. This approach is simpler
and also works for Android cross-compilation, so remove the
detect_target_arch function.

Android targets i686, but compiler-rt seems to identify 32-bit x86 as
"i386". For Android, we were previously calling add_default_target_arch
with i386, and calling add_default_target_arch with i686 does not build
anything. i686 is not listed in builtin-config-ix.cmake,
ALL_BUILTIN_SUPPORTED_ARCH.

[rprichard]

This is an upstreamed version of: https://android-review.googlesource.com/c/toolchain/llvm-project/+/1322413/1/compiler-rt/cmake/base-config-ix.cmake

[rprichard]

This Android-specific call to detect_target_arch is apparently the only call. It was originally added in https://reviews.llvm.org/rL218605.

[compnerd]

I think that something changed or there is some misunderstanding. You are absolutely correct about the compiler runtime dependency. However, the symbol being checked here is _not_ a compile check, its a preprocessor check. Those are architectural macros that CPP is expected to provide. We should fix that instead.

[rprichard]

LLVM's detect_target_arch is using check_symbol_exists, which is provided by CMake itself and uses try_compile to build and link a test executable.

CMake's desire to link an executable when that isn't possible breaks a few other things:

• CMake implicitly checks whether the compiler is working, so it must be overridden, e.g.: D39715
• The unwind.h detection breaks, so the __gcc_personality_v0 routine might be incorrectly omitted.

There is a CMAKE_TRY_COMPILE_TARGET_TYPE variable that can be set to STATIC_LIBRARY to disable the linking. It looks like it's currently used in libunwind. D70815, D71117.

The new variable was added after LLVM's current minimum version of CMake 3.4.3. (However, it looks like Android's build system is using CMake 3.17, so it could probably set CMAKE_TRY_COMPILE_TARGET_TYPE when it invokes cmake on lib/builtins/CMakeLists.txt.)

It looks like compiler-rt defines a try_compile_only macro that skips linking. Maybe compiler-rt could have preprocessor symbol detection that uses try_compile_only, but I think we want to remove try_compile_only after the next CMake version bump (http://lists.llvm.org/pipermail/llvm-dev/2019-October/136370.html).

The detect_target_arch function is only used for Android, so it seemed simple to remove it and have the Android build more closely resemble other configurations. I'm not sure why we did it this way to begin with, though. That's something I could dig into.

[compnerd]

Hmm, I think that an explanation of why it was this way originally along with the explanation that you just gave that this is specific to android and that this change would unify the behaviour between the various targets, sounds like a good approach to me. For some reason I was under the impression that this was shared with Linux as well. But, I do agree with you, that if its actually making everything more similar, it is better. Please do update the commit message with the additional information before merging, but otherwise, LGTM.

[rprichard]

Passing -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY fixes detect_target_arch and unwind.h autodetection, so I don't strictly need this revision anymore. It is a nice simplification, though, so I'll still commit it. I did some digging to figure out why detect_target_arch was needed. When it was added in 2014, the compiler-rt target selection was based on LLVM_NATIVE_ARCH, which appears to have been the host architecture, so not suitable for cross-compilation.

e.g. From rL218605:

 # Generate the COMPILER_RT_SUPPORTED_ARCH list.
 if(ANDROID)
-  test_target_arch(arm_android "")
+  # Can't rely on LLVM_NATIVE_ARCH in cross-compilation.
+  # Examine compiler output instead.
+  detect_target_arch()
+  set(COMPILER_RT_OS_SUFFIX "-android")
 else()
   if("${LLVM_NATIVE_ARCH}" STREQUAL "X86")
     if (NOT MSVC)
       test_target_arch(x86_64 ${TARGET_64_BIT_CFLAGS})
     endif()
     test_target_arch(i386 ${TARGET_32_BIT_CFLAGS})
   elseif("${LLVM_NATIVE_ARCH}" STREQUAL "PowerPC")
     test_target_arch(powerpc64 ${TARGET_64_BIT_CFLAGS})
   elseif("${LLVM_NATIVE_ARCH}" STREQUAL "Mips")
     test_target_arch(mips "")
   endif()
   # Build ARM libraries if we are configured to test on ARM
   if("${COMPILER_RT_TEST_TARGET_ARCH}" MATCHES "arm|aarch64")
     test_target_arch(arm "-march=armv7-a")
     test_target_arch(aarch64 "-march=armv8-a")
   endif()
+  set(COMPILER_RT_OS_SUFFIX "")
 endif()

[dmajor]

Hi, this commit seems to have caused a problem in Firefox. We're no longer getting a libclang_rt.profile-arm-android.a in our clang package when we request armv7-linux-android. Does arm need special translation similar to the i686->i386 special case?

[aeubanks]

We're also getting issues due to this, aarch64/arm targets no longer exist in android-aarch64/build.ninja.
See https://crbug.com/1105568.

Will revert soon since multiple people are complaining.

[aeubanks]

Confirmed that reverting this fixes the issue, reverted in bef00b244c3140558c574cc106771b0f2452ef84.

[dmajor]

The revert fixes our build too. Just in time for the 11.0.0 branch, thanks @aeubanks!

compiler-rt/cmake/Modules/CompilerRTUtils.cmake

if(${CAN_TARGET_${arch}})
     list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
   elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" STREQUAL "${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()
 
-macro(detect_target_arch)
-  check_symbol_exists(__arm__ "" __ARM)
-  check_symbol_exists(__aarch64__ "" __AARCH64)
-  check_symbol_exists(__x86_64__ "" __X86_64)
-  check_symbol_exists(__i386__ "" __I386)
-  check_symbol_exists(__mips__ "" __MIPS)
-  check_symbol_exists(__mips64__ "" __MIPS64)
-  check_symbol_exists(__powerpc64__ "" __PPC64)
-  check_symbol_exists(__powerpc64le__ "" __PPC64LE)
-  check_symbol_exists(__riscv "" __RISCV)
-  check_symbol_exists(__s390x__ "" __S390X)
-  check_symbol_exists(__sparc "" __SPARC)
-  check_symbol_exists(__sparcv9 "" __SPARCV9)
-  check_symbol_exists(__wasm32__ "" __WEBASSEMBLY32)
-  check_symbol_exists(__wasm64__ "" __WEBASSEMBLY64)
-  check_symbol_exists(__ve__ "" __VE)
-  if(__ARM)
-    add_default_target_arch(arm)
-  elseif(__AARCH64)
-    add_default_target_arch(aarch64)
-  elseif(__X86_64)
-    add_default_target_arch(x86_64)
-  elseif(__I386)
-    add_default_target_arch(i386)
-  elseif(__MIPS64) # must be checked before __MIPS
-    add_default_target_arch(mips64)
-  elseif(__MIPS)
-    add_default_target_arch(mips)
-  elseif(__PPC64)
-    add_default_target_arch(powerpc64)
-  elseif(__PPC64LE)
-    add_default_target_arch(powerpc64le)
-  elseif(__RISCV)
-    if(CMAKE_SIZEOF_VOID_P EQUAL "4")
-      add_default_target_arch(riscv32)
-    elseif(CMAKE_SIZEOF_VOID_P EQUAL "8")
-      add_default_target_arch(riscv64)
-    else()
-      message(FATAL_ERROR "Unsupport XLEN for RISC-V")
-    endif()
-  elseif(__S390X)
-    add_default_target_arch(s390x)
-  elseif(__SPARCV9)
-    add_default_target_arch(sparcv9)
-  elseif(__SPARC)
-    add_default_target_arch(sparc)
-  elseif(__WEBASSEMBLY32)
-    add_default_target_arch(wasm32)
-  elseif(__WEBASSEMBLY64)
-    add_default_target_arch(wasm64)
-  elseif(__VE)
-    add_default_target_arch(ve)
-  endif()
-endmacro()
-
 macro(load_llvm_config)
   if (NOT LLVM_CONFIG_PATH)
     find_program(LLVM_CONFIG_PATH "llvm-config"
                  DOC "Path to llvm-config binary")
     if (NOT LLVM_CONFIG_PATH)
       message(WARNING "UNSUPPORTED COMPILER-RT CONFIGURATION DETECTED: "
                       "llvm-config not found.\n"
                       "Reconfigure with -DLLVM_CONFIG_PATH=path/to/llvm-config.")

compiler-rt/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)
-    # Examine compiler output to determine target architecture.
-    detect_target_arch()
+    if(${COMPILER_RT_DEFAULT_TARGET_ARCH} STREQUAL "i686")
+      add_default_target_arch(i386)
+    else()
+      add_default_target_arch(${COMPILER_RT_DEFAULT_TARGET_ARCH})
+    endif()
     set(COMPILER_RT_OS_SUFFIX "-android")
   elseif(NOT APPLE) # Supported archs for Apple platforms are generated later
     if(COMPILER_RT_DEFAULT_TARGET_ONLY)
       add_default_target_arch(${COMPILER_RT_DEFAULT_TARGET_ARCH})
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "i[2-6]86|x86|amd64")
       if(NOT MSVC)
         if(CMAKE_SYSTEM_NAME MATCHES "OpenBSD")
           if (CMAKE_SIZEOF_VOID_P EQUAL 4)