[sanitizer] Android build cleanup.

[eugenis]

Summary

• Detect Android toolchain target arch and set runtime library name appropriately.
• Merged a lot of Android and non-Android code paths.
• Android is only supported in standalone build of compiler-rt now.
• Linking lsan-common in ASan-Android (makes lsan annotations work).
• Relying on -fsanitize=address linker flag when building tests (again, unification with non-Android path).
• Runtime library moved from lib/asan to lib/linux for some reason. It's probably better this way.

Btw, why separate compiler setting for tests? Will it go away when we switch to standalone build?

[glider]

Some drive-by comments.
This stuff doesn't work for x86-Android, does it?

cmake/config-ix.cmake

95

"detect_target_arch" looks much like "test_target_arch" below, but it populates COMPILER_RT_SUPPORTED_ARCH with several arches instead of only one. I think we need a better name for "detect_target_arch"

122

Is this an arch suffix or an OS suffix? Should the suffix be present on Linux or other OSes?

lib/asan/scripts/asan_device_setup

110–111

So the android runtime is in lib/linux? Why?

lib/asan/tests/CMakeLists.txt

76

Please remove the commented lines (if you meant to) and fix indentation.
Do you still need the comment above now?

93

TODO(eugenis)

lib/sanitizer_common/tests/CMakeLists.txt

62

Link to the bug? (and in other places as well)

test/asan/CMakeLists.txt

10

You'd better list the possible 64-bit arches here to make sure we bail out if an unsupported arch comes around.

18–19

Pls indent this block.

34

Two spaces before the comment, please

test/asan/lit.cfg

58

Are changes to this file related to the CMake changes? If no, can they be landed separately?

[eugenis]

cmake/config-ix.cmake

95

Note the elseif()s. It's at most one arch.
Can you suggest a better name? IMO it is quite good - the function examines compiler output with default flags and detect the target architecture.

122

It's the suffix in libclang_rt.asan-${arch}- <<here>> .so
Renamed to OS_SUFFIX.

lib/asan/scripts/asan_device_setup

110–111

because it's arm-linux-androideabi, so the runtime goes to lib/linux/libclang_rt.asan-arm-android.so

lib/asan/tests/CMakeLists.txt

76

done
the comment is no longer true, removed

lib/sanitizer_common/tests/CMakeLists.txt

62

There is no bug, just a bunch of mail threads.

test/asan/CMakeLists.txt

10

done

18–19

done

34

done

test/asan/lit.cfg

58

Yes. No.
CAN_TARGET_arm_android used to be "TRUE"
Now ANDROID is "1".

[glider]

LGTM

[samsonov]

LGTM. This is really nice.

cmake/Modules/AddCompilerRT.cmake

46–47

While you're here, please mention OUTPUT_NAME in the comment.

cmake/config-ix.cmake

95

Cool. We'd definitely need to do smth. similar for non-Andorid case.

lib/asan/tests/CMakeLists.txt

83

Consider using append_if here as well.

94

incorrect variable name: should be ASAN_UNITTEST_NOINST_LIBS

95

and here

lib/sanitizer_common/tests/CMakeLists.txt

63

append_if

[eugenis]

cmake/Modules/AddCompilerRT.cmake

46–47

done

lib/asan/tests/CMakeLists.txt

83

done

94

good catch

[samsonov]

LGTM

[eugenis]

Thanks for the review.
Committed in r218605.

CMakeLists.txt

 find_flag_in_string("${CMAKE_CXX_FLAGS}" "-stdlib=libc++"
                     COMPILER_RT_USES_LIBCXX)
 
 option(COMPILER_RT_DEBUG "Build runtimes with full debug info" OFF)
 # COMPILER_RT_DEBUG_PYBOOL is used by lit.common.configured.in.
 pythonize_bool(COMPILER_RT_DEBUG)
 
 # We have to support both static and dynamic/shared runtime on Windows.
-if(WIN32)
+# Android only works with dynamic runtime.
+if(WIN32 OR ANDROID)
 option(COMPILER_RT_BUILD_SHARED_ASAN "Build shared version of AddressSanitizer runtime" ON)
 else()
 option(COMPILER_RT_BUILD_SHARED_ASAN "Build shared version of AddressSanitizer runtime" OFF)
 endif()
 
 #================================
 # Setup Compiler Flags
 #================================

cmake/Modules/AddCompilerRT.cmake

set_property(TARGET ${libname} APPEND PROPERTY
     COMPILE_DEFINITIONS ${LIB_DEFS})
 endmacro()
 
 # 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>
 #                         CFLAGS <compile flags>
-#                         DEFS <compile definitions>)
+#                         DEFS <compile definitions>
+#                         OUTPUT_NAME <output library name>)
 macro(add_compiler_rt_runtime name arch type)
   if(CAN_TARGET_${arch})
     parse_arguments(LIB "SOURCES;CFLAGS;DEFS;OUTPUT_NAME" "" ${ARGN})
     add_library(${name} ${type} ${LIB_SOURCES})
     # Setup compile flags and definitions.
     set_target_compile_flags(${name}
       ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
     set_target_link_flags(${name}
       ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
     set_property(TARGET ${name} APPEND PROPERTY
       COMPILE_DEFINITIONS ${LIB_DEFS})
     # Setup correct output directory in the build tree.
     set_target_properties(${name} PROPERTIES
       ARCHIVE_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
       LIBRARY_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
-    if (LIB_OUTPUT_NAME)
+    if ("${LIB_OUTPUT_NAME}" STREQUAL "")
+      set_target_properties(${name} PROPERTIES
+        OUTPUT_NAME ${name}${COMPILER_RT_OS_SUFFIX})
+    else()
       set_target_properties(${name} PROPERTIES
         OUTPUT_NAME ${LIB_OUTPUT_NAME})
     endif()
     # Add installation command.
     install(TARGETS ${name}
       ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
       LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
   else()

cmake/config-ix.cmake

foreach(arg ${ARGN})
     set(argstring "${argstring} ${arg}")
   endforeach()
   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}")
   if(${CAN_TARGET_${arch}})
     list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
-  elseif("${COMPILER_RT_TEST_TARGET_ARCH}" MATCHES "${arch}" OR
-         "${arch}" STREQUAL "arm_android")
+  elseif("${COMPILER_RT_TEST_TARGET_ARCH}" MATCHES "${arch}")
     # 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()
 
+# Add $arch as supported with no additional flags.
+macro(add_default_target_arch arch)
+  set(TARGET_${arch}_CFLAGS "")
+  set(CAN_TARGET_${arch} 1)
+  list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
+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)
+  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)
+  endif()
+endmacro()
+
 # 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()
 
+message("Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}")
+
 # Takes ${ARGN} and puts only supported architectures in @out_var list.
 function(filter_available_targets out_var)
   set(archs)
   foreach(arch ${ARGN})
     list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
     if(NOT (ARCH_INDEX EQUAL -1) AND CAN_TARGET_${arch})
       list(APPEND archs ${arch})
     endif()
   endforeach()
   set(${out_var} ${archs} PARENT_SCOPE)
 endfunction()
 
 # Arhcitectures supported by compiler-rt libraries.
-# FIXME: add arm_android here
 filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
-  x86_64 i386 powerpc64 arm aarch64 mips arm_android)
+  x86_64 i386 powerpc64 arm aarch64 mips)
 filter_available_targets(ASAN_SUPPORTED_ARCH
-  x86_64 i386 powerpc64 arm mips arm_android)
+  x86_64 i386 powerpc64 arm mips)
 filter_available_targets(DFSAN_SUPPORTED_ARCH x86_64)
 filter_available_targets(LSAN_SUPPORTED_ARCH x86_64)
 # LSan common files should be available on all architectures supported
 # by other sanitizers (even if they build into dummy object files).
 filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH
   ${SANITIZER_COMMON_SUPPORTED_ARCH})
 filter_available_targets(MSAN_SUPPORTED_ARCH x86_64)
 filter_available_targets(PROFILE_SUPPORTED_ARCH x86_64 i386 arm aarch64)

 if (COMPILER_RT_HAS_SANITIZER_COMMON AND LSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD")
   set(COMPILER_RT_HAS_LSAN TRUE)
 else()
   set(COMPILER_RT_HAS_LSAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND LSAN_COMMON_SUPPORTED_ARCH AND
-    OS_NAME MATCHES "Darwin|Linux|FreeBSD")
+    OS_NAME MATCHES "Darwin|Linux|FreeBSD|Android")
   set(COMPILER_RT_HAS_LSAN_COMMON TRUE)
 else()
   set(COMPILER_RT_HAS_LSAN_COMMON FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND MSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_MSAN TRUE)

lib/asan/CMakeLists.txt

 append_if(MSVC /DEBUG ASAN_DYNAMIC_CFLAGS)
 
 append_if(COMPILER_RT_HAS_LIBC c ASAN_DYNAMIC_LIBS)
 append_if(COMPILER_RT_HAS_LIBDL dl ASAN_DYNAMIC_LIBS)
 append_if(COMPILER_RT_HAS_LIBM m ASAN_DYNAMIC_LIBS)
 append_if(COMPILER_RT_HAS_LIBPTHREAD pthread ASAN_DYNAMIC_LIBS)
 append_if(COMPILER_RT_HAS_LIBSTDCXX stdc++ ASAN_DYNAMIC_LIBS)
 
+append_if(ANDROID log ASAN_DYNAMIC_LIBS)
+
 # Compile ASan sources into an object library.
 if(APPLE)
   foreach(os ${SANITIZER_COMMON_SUPPORTED_DARWIN_OS})
     add_compiler_rt_darwin_object_library(RTAsan ${os}
       ARCH ${ASAN_SUPPORTED_ARCH}
       SOURCES ${ASAN_SOURCES} ${ASAN_CXX_SOURCES}
       CFLAGS ${ASAN_CFLAGS}
       DEFS ${ASAN_COMMON_DEFINITIONS})
   endforeach()
-elseif(ANDROID)
-  add_library(RTAsan.arm.android OBJECT ${ASAN_SOURCES} ${ASAN_CXX_SOURCES})
-  set_target_compile_flags(RTAsan.arm.android ${ASAN_CFLAGS})
-  set_property(TARGET RTAsan.arm.android APPEND PROPERTY
-    COMPILE_DEFINITIONS ${ASAN_COMMON_DEFINITIONS})
 else()
   foreach(arch ${ASAN_SUPPORTED_ARCH})
     add_compiler_rt_object_library(RTAsan ${arch}
       SOURCES ${ASAN_SOURCES} CFLAGS ${ASAN_CFLAGS}
       DEFS ${ASAN_COMMON_DEFINITIONS})
     add_compiler_rt_object_library(RTAsan_cxx ${arch}
       SOURCES ${ASAN_CXX_SOURCES} CFLAGS ${ASAN_CFLAGS}
       DEFS ${ASAN_COMMON_DEFINITIONS})
add_compiler_rt_darwin_dynamic_runtime(clang_rt.asan_${os}_dynamic ${os}
       SOURCES $<TARGET_OBJECTS:RTAsan.${os}>
               $<TARGET_OBJECTS:RTInterception.${os}>
               $<TARGET_OBJECTS:RTSanitizerCommon.${os}>
               $<TARGET_OBJECTS:RTLSanCommon.${os}>
       CFLAGS ${ASAN_CFLAGS}
       DEFS ${ASAN_COMMON_DEFINITIONS})
     add_dependencies(asan clang_rt.asan_${os}_dynamic)
   endforeach()
-
-elseif(ANDROID)
-  add_library(clang_rt.asan-arm-android SHARED
-    $<TARGET_OBJECTS:RTAsan.arm.android>
-    $<TARGET_OBJECTS:RTInterception.arm.android>
-    $<TARGET_OBJECTS:RTSanitizerCommon.arm.android>)
-  set_target_compile_flags(clang_rt.asan-arm-android
-    ${ASAN_CFLAGS})
-  set_property(TARGET clang_rt.asan-arm-android APPEND PROPERTY
-    COMPILE_DEFINITIONS ${ASAN_COMMON_DEFINITIONS})
-  target_link_libraries(clang_rt.asan-arm-android dl log)
-  add_dependencies(asan clang_rt.asan-arm-android)
-  install(TARGETS clang_rt.asan-arm-android
-          ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
-          LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
 else()
   # Build separate libraries for each target.
   foreach(arch ${ASAN_SUPPORTED_ARCH})
     set(ASAN_COMMON_RUNTIME_OBJECTS
       $<TARGET_OBJECTS:RTInterception.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>)
-    if (NOT WIN32)
+    if(NOT WIN32)
       # We can't build Leak Sanitizer on Windows yet.
       list(APPEND ASAN_COMMON_RUNTIME_OBJECTS
            $<TARGET_OBJECTS:RTLSanCommon.${arch}>)
     endif()
 
     add_compiler_rt_runtime(clang_rt.asan-${arch} ${arch} STATIC
       SOURCES $<TARGET_OBJECTS:RTAsan_preinit.${arch}>
               $<TARGET_OBJECTS:RTAsan.${arch}>
foreach(arch ${ASAN_SUPPORTED_ARCH})
     if (COMPILER_RT_BUILD_SHARED_ASAN)
       add_compiler_rt_runtime(clang_rt.asan-preinit-${arch} ${arch} STATIC
         SOURCES $<TARGET_OBJECTS:RTAsan_preinit.${arch}>
         CFLAGS ${ASAN_CFLAGS}
         DEFS ${ASAN_COMMON_DEFINITIONS})
       add_dependencies(asan clang_rt.asan-preinit-${arch})
 
       if (WIN32)
-         set(SHARED_ASAN_NAME clang_rt.asan_dynamic-${arch})
+         set(SHARED_ASAN_NAME clang_rt.asan_dynamic-${arch}${COMPILER_RT_OS_SUFFIX})
       else()
-         set(SHARED_ASAN_NAME clang_rt.asan-${arch})
+         set(SHARED_ASAN_NAME clang_rt.asan-${arch}${COMPILER_RT_OS_SUFFIX})
       endif()
 
       add_compiler_rt_runtime(clang_rt.asan-dynamic-${arch} ${arch} SHARED
         OUTPUT_NAME ${SHARED_ASAN_NAME}
         SOURCES $<TARGET_OBJECTS:RTAsan_dynamic.${arch}>
                 ${ASAN_COMMON_RUNTIME_OBJECTS}
         CFLAGS ${ASAN_DYNAMIC_CFLAGS}
         DEFS ${ASAN_DYNAMIC_DEFINITIONS})

lib/asan/scripts/asan_device_setup

 if [[ -d "$lib" ]]; then
     ASAN_RT_PATH="$lib"
 elif [[ -f "$lib" && "$lib" == *"$ASAN_RT" ]]; then
     ASAN_RT_PATH=$(dirname "$lib")
 elif [[ -f "$HERE/$ASAN_RT" ]]; then
     ASAN_RT_PATH="$HERE"
 elif [[ $(basename "$HERE") == "bin" ]]; then
     # We could be in the toolchain's base directory.
-    # Consider ../lib, ../lib/asan and ../lib/clang/$VERSION/lib/linux.
-    P=$(ls "$HERE"/../lib/"$ASAN_RT" "$HERE"/../lib/asan/"$ASAN_RT" "$HERE"/../lib/clang/*/lib/linux/"$ASAN_RT" 2>/dev/null | sort | tail -1)
+    # Consider ../lib, ../lib/asan, ../lib/linux and ../lib/clang/$VERSION/lib/linux.
+    P=$(ls "$HERE"/../lib/"$ASAN_RT" "$HERE"/../lib/asan/"$ASAN_RT" "$HERE"/../lib/linux/"$ASAN_RT" "$HERE"/../lib/clang/*/lib/linux/"$ASAN_RT" 2>/dev/null | sort | tail -1)
     if [[ -n "$P" ]]; then
         ASAN_RT_PATH="$(dirname "$P")"
     fi
 fi
 
 if [[ -z "$ASAN_RT_PATH" || ! -f "$ASAN_RT_PATH/$ASAN_RT" ]]; then
     echo ">> ASan runtime library not found"
     exit 1

lib/asan/tests/CMakeLists.txt

if(APPLE)
   list(APPEND ASAN_UNITTEST_COMMON_LINKFLAGS -framework Foundation)
 endif()
 if(ANDROID)
   list(APPEND ASAN_UNITTEST_COMMON_LINKFLAGS -pie)
 endif()
 
 set(ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS
   ${ASAN_UNITTEST_COMMON_LINKFLAGS})
-# On Android, we link with ASan runtime manually. On other platforms we depend
-# on Clang driver behavior, passing -fsanitize=address flag.
-if(NOT ANDROID)
-  list(APPEND ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS -fsanitize=address)
-endif()
 
 set(ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINKFLAGS
   ${ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS}
   -shared-libasan)
 
+set(ASAN_UNITTEST_INSTRUMENTED_LIBS)
+# NDK r10 requires -latomic almost always.
+append_if(ANDROID atomic ASAN_UNITTEST_INSTRUMENTED_LIBS)
+
 set(ASAN_UNITTEST_NOINST_LINKFLAGS ${ASAN_UNITTEST_COMMON_LINKFLAGS})
 append_if(COMPILER_RT_HAS_LIBM -lm ASAN_UNITTEST_NOINST_LINKFLAGS)
 append_if(COMPILER_RT_HAS_LIBDL -ldl ASAN_UNITTEST_NOINST_LINKFLAGS)
 append_if(COMPILER_RT_HAS_LIBPTHREAD -pthread ASAN_UNITTEST_NOINST_LINKFLAGS)
 append_if(COMPILER_RT_HAS_LIBPTHREAD -pthread
           ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINKFLAGS)
 
+# TODO(eugenis): move all -l flags above to _LIBS?
+set(ASAN_UNITTEST_NOINST_LIBS)
+append_if(ANDROID log ASAN_UNITTEST_NOINST_LIBS)
+# NDK r10 requires -latomic almost always.
+append_if(ANDROID atomic ASAN_UNITTEST_NOINST_LIBS)
+
 # Compile source for the given architecture, using compiler
 # options in ${ARGN}, and add it to the object list.
 macro(asan_compile obj_list source arch kind)
   get_filename_component(basename ${source} NAME)
   set(output_obj "${obj_list}.${basename}.${arch}${kind}.o")
   get_target_flags_for_arch(${arch} TARGET_CFLAGS)
   set(COMPILE_DEPS ${ASAN_UNITTEST_HEADERS} ${ASAN_BLACKLIST_FILE})
   if(NOT COMPILER_RT_STANDALONE_BUILD)
set(ASAN_TEST_RUNTIME_OBJECTS
       $<TARGET_OBJECTS:RTLSanCommon.osx>)
   else()
     set(ASAN_TEST_RUNTIME_OBJECTS
       $<TARGET_OBJECTS:RTAsan.${arch}>
       $<TARGET_OBJECTS:RTAsan_cxx.${arch}>
       $<TARGET_OBJECTS:RTInterception.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>)
-    if(NOT MSVC)
+    if(NOT WIN32)
       list(APPEND ASAN_TEST_RUNTIME_OBJECTS
            $<TARGET_OBJECTS:RTLSanCommon.${arch}>)
     endif()
   endif()
   add_library(${ASAN_TEST_RUNTIME} STATIC ${ASAN_TEST_RUNTIME_OBJECTS})
   set_target_properties(${ASAN_TEST_RUNTIME} PROPERTIES
     ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
   # Uninstrumented tests.
if(COMPILER_RT_CAN_EXECUTE_TESTS AND NOT ANDROID)
   foreach(arch ${ASAN_SUPPORTED_ARCH})
     add_asan_tests_for_arch_and_kind(${arch} "-inline")
     add_asan_tests_for_arch_and_kind(${arch} "-with-calls"
       -mllvm -asan-instrumentation-with-call-threshold=0)
   endforeach()
 endif()
 
 if(ANDROID)
-  # We assume that unit tests on Android are built in a build
-  # tree with fresh Clang as a host compiler.
-  
+  foreach(arch ${ASAN_SUPPORTED_ARCH})
     # Test w/o ASan instrumentation. Link it with ASan statically.
-  add_executable(AsanNoinstTest
-    $<TARGET_OBJECTS:RTAsan.arm.android>
-    $<TARGET_OBJECTS:RTInterception.arm.android>
-    $<TARGET_OBJECTS:RTSanitizerCommon.arm.android>
+    add_executable(AsanNoinstTest # FIXME: .arch?
+      $<TARGET_OBJECTS:RTAsan.${arch}>
+      $<TARGET_OBJECTS:RTInterception.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
       ${COMPILER_RT_GTEST_SOURCE}
       ${ASAN_NOINST_TEST_SOURCES})
     set_target_compile_flags(AsanNoinstTest ${ASAN_UNITTEST_COMMON_CFLAGS})
     set_target_link_flags(AsanNoinstTest ${ASAN_UNITTEST_NOINST_LINKFLAGS})
-  target_link_libraries(AsanNoinstTest log)
+    target_link_libraries(AsanNoinstTest ${ASAN_UNITTEST_NOINST_LIBS})
 
     # Test with ASan instrumentation. Link with ASan dynamic runtime.
     add_executable(AsanTest
       ${COMPILER_RT_GTEST_SOURCE}
       ${ASAN_INST_TEST_SOURCES})
     set_target_compile_flags(AsanTest ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS})
     set_target_link_flags(AsanTest ${ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS})
-  target_link_libraries(AsanTest clang_rt.asan-arm-android)
+    target_link_libraries(AsanTest ${ASAN_UNITTEST_INSTRUMENTED_LIBS})
 
     # Setup correct output directory and link flags.
     set_target_properties(AsanNoinstTest AsanTest PROPERTIES
       RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-  # Add unit test to test suite.
+    # Add unit tests to the test suite.
     add_dependencies(AsanUnitTests AsanNoinstTest AsanTest)
+  endforeach()
 endif()

lib/interception/CMakeLists.txt

 if(APPLE)
   # Build universal binary on APPLE.
   foreach(os ${SANITIZER_COMMON_SUPPORTED_DARWIN_OS})
     add_compiler_rt_darwin_object_library(RTInterception ${os}
       ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH}
       SOURCES ${INTERCEPTION_SOURCES}
       CFLAGS ${INTERCEPTION_CFLAGS})
   endforeach()
-elseif(ANDROID)
-  add_library(RTInterception.arm.android OBJECT ${INTERCEPTION_SOURCES})
-  set_target_compile_flags(RTInterception.arm.android
-    ${INTERCEPTION_CFLAGS})
 else()
   # Otherwise, build separate libraries for each target.
   foreach(arch ${SANITIZER_COMMON_SUPPORTED_ARCH})
     add_compiler_rt_object_library(RTInterception ${arch}
       SOURCES ${INTERCEPTION_SOURCES} CFLAGS ${INTERCEPTION_CFLAGS})
   endforeach()
 endif()

lib/lsan/CMakeLists.txt

 
 if(APPLE)
   foreach(os ${SANITIZER_COMMON_SUPPORTED_DARWIN_OS})
     add_compiler_rt_darwin_object_library(RTLSanCommon ${os}
       ARCH ${LSAN_COMMON_SUPPORTED_ARCH}
       SOURCES ${LSAN_COMMON_SOURCES}
       CFLAGS ${LSAN_CFLAGS})
   endforeach()
-elseif(NOT ANDROID)
+else()
   foreach(arch ${LSAN_COMMON_SUPPORTED_ARCH})
     add_compiler_rt_object_library(RTLSanCommon ${arch}
       SOURCES ${LSAN_COMMON_SOURCES}
       CFLAGS ${LSAN_CFLAGS})
   endforeach()
 
   foreach(arch ${LSAN_SUPPORTED_ARCH})
     add_compiler_rt_runtime(clang_rt.lsan-${arch} ${arch} STATIC

lib/sanitizer_common/CMakeLists.txt

if(APPLE)
   foreach(os ${SANITIZER_COMMON_SUPPORTED_DARWIN_OS})
     add_compiler_rt_darwin_object_library(RTSanitizerCommon ${os}
       ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH}
       SOURCES ${SANITIZER_SOURCES} ${SANITIZER_LIBCDEP_SOURCES}
       CFLAGS ${SANITIZER_CFLAGS}
       DEFS ${SANITIZER_COMMON_DEFINITIONS})
     list(APPEND SANITIZER_RUNTIME_LIBRARIES RTSanitizerCommon.${os})
   endforeach()
-elseif(ANDROID)
-  add_library(RTSanitizerCommon.arm.android OBJECT
-    ${SANITIZER_SOURCES} ${SANITIZER_LIBCDEP_SOURCES})
-  set_target_compile_flags(RTSanitizerCommon.arm.android
-    ${SANITIZER_CFLAGS})
-  set_property(TARGET RTSanitizerCommon.arm.android APPEND PROPERTY
-    COMPILE_DEFINITIONS ${SANITIZER_COMMON_DEFINITIONS})
-  list(APPEND SANITIZER_RUNTIME_LIBRARIES RTSanitizerCommon.arm.android)
 else()
   # Otherwise, build separate libraries for each target.
   foreach(arch ${SANITIZER_COMMON_SUPPORTED_ARCH})
     add_compiler_rt_object_library(RTSanitizerCommon ${arch}
       SOURCES ${SANITIZER_SOURCES} CFLAGS ${SANITIZER_CFLAGS}
       DEFS ${SANITIZER_COMMON_DEFINITIONS})
     add_compiler_rt_object_library(RTSanitizerCommonLibc ${arch}
       SOURCES ${SANITIZER_LIBCDEP_SOURCES} CFLAGS ${SANITIZER_CFLAGS}

lib/sanitizer_common/tests/CMakeLists.txt

 else()
   list(APPEND ASAN_UNITTEST_COMMON_CFLAGS -g)
 endif()
 
 if(NOT MSVC)
   list(APPEND SANITIZER_TEST_LINK_FLAGS_COMMON --driver-mode=g++)
 endif()
 
+set(SANITIZER_TEST_LINK_LIBS)
+append_if(ANDROID log SANITIZER_TEST_LINK_LIBS)
+# NDK r10 requires -latomic almost always.
+append_if(ANDROID atomic SANITIZER_TEST_LINK_LIBS)
+
 append_if(COMPILER_RT_HAS_LIBDL -ldl SANITIZER_TEST_LINK_FLAGS_COMMON)
 append_if(COMPILER_RT_HAS_LIBPTHREAD -pthread SANITIZER_TEST_LINK_FLAGS_COMMON)
 # x86_64 FreeBSD 9.2 additionally requires libc++ to build the tests. Also,
 # 'libm' shall be specified explicitly to build i386 tests.
 if(CMAKE_SYSTEM MATCHES "FreeBSD-9.2-RELEASE")
   list(APPEND SANITIZER_TEST_LINK_FLAGS_COMMON "-lc++ -lm")
 endif()
 
if(CAN_TARGET_x86_64)
     add_sanitizer_tests_for_arch(x86_64)
   endif()
   if(CAN_TARGET_i386)
     add_sanitizer_tests_for_arch(i386)
   endif()
 endif()
 
 if(ANDROID)
-  # We assume that unit tests on Android are built in a build
-  # tree with fresh Clang as a host compiler.
+  foreach(arch ${SANITIZER_COMMON_SUPPORTED_ARCH})
     add_executable(SanitizerTest
       ${SANITIZER_UNITTESTS}
       ${COMPILER_RT_GTEST_SOURCE}
-    $<TARGET_OBJECTS:RTSanitizerCommon.arm.android>)
+      $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>)
     set_target_compile_flags(SanitizerTest
       ${SANITIZER_COMMON_CFLAGS}
       ${SANITIZER_TEST_CFLAGS_COMMON})
     # Setup correct output directory and link flags.
     set_target_properties(SanitizerTest PROPERTIES
       RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
     set_target_link_flags(SanitizerTest ${SANITIZER_TEST_LINK_FLAGS_COMMON})
-  target_link_libraries(SanitizerTest log)
+    target_link_libraries(SanitizerTest ${SANITIZER_TEST_LINK_LIBS})
     # Add unit test to test suite.
     add_dependencies(SanitizerUnitTests SanitizerTest)
+  endforeach()
 endif()

test/asan/CMakeLists.txt

 set(ASAN_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 set(ASAN_TESTSUITES)
 
-if(CAN_TARGET_arm_android)
-  # This is only true if we are cross-compiling.
-  # Build all tests with host compiler and use host tools.
-  set(ASAN_TEST_TARGET_CC ${CMAKE_C_COMPILER})
+macro(get_bits_for_arch arch bits)
+  if (${arch} STREQUAL "arm" OR
+      ${arch} STREQUAL "i386" OR
+      ${arch} STREQUAL "mips")
+    set(bits 32)
+  elseif (${arch} STREQUAL "aarch64" OR
+      ${arch} STREQUAL "x86_64" OR
+      ${arch} STREQUAL "mips64")
+    set(bits 64)
+  else()
+    message(FATAL_ERROR "Unknown target architecture: ${arch}")
+  endif()
+endmacro()
+
+# TODO: merge with non-ANDROID case
+if(ANDROID)
+  foreach(arch ${ASAN_SUPPORTED_ARCH})
+    set(ASAN_TEST_TARGET_CC ${COMPILER_RT_TEST_COMPILER})
     set(ASAN_TEST_TARGET_CFLAGS ${COMPILER_RT_TEST_COMPILER_CFLAGS})
-  get_filename_component(ASAN_TEST_LLVM_TOOLS_DIR ${CMAKE_C_COMPILER} PATH)
-  set(ASAN_TEST_CONFIG_SUFFIX "-arm-android")
-  set(ASAN_TEST_BITS "32")
+    set(ASAN_TEST_CONFIG_SUFFIX "-${arch}-android")
+    get_bits_for_arch(${arch} ASAN_TEST_BITS)
     set(ASAN_TEST_DYNAMIC True)
-  set(ASAN_TEST_TARGET_ARCH "arm-android")
+    set(ASAN_TEST_TARGET_ARCH "${arch}-android")
+    string(TOUPPER ${arch} ARCH_UPPER_CASE)
+    set(CONFIG ${ARCH_UPPER_CASE}AndroidConfig)
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
-    ${CMAKE_CURRENT_BINARY_DIR}/ARMAndroidConfig/lit.site.cfg
+      ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG}/lit.site.cfg
       )
-  list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/ARMAndroidConfig)
-endif()
+    list(APPEND ASAN_TESTSUITES
+      ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG})
+  endforeach()
+
+else()  # Not Android
 
   if(CAN_TARGET_arm)
     # This is only true if we are cross-compiling.
     # Build all tests with host compiler and use host tools.
     set(ASAN_TEST_TARGET_CC ${COMPILER_RT_TEST_COMPILER})
     set(ASAN_TEST_TARGET_CFLAGS ${COMPILER_RT_TEST_COMPILER_CFLAGS})
     set(ASAN_TEST_CONFIG_SUFFIX "-arm-linux")
     set(ASAN_TEST_BITS "32")
     set(ASAN_TEST_DYNAMIC False)
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/ARMLinuxConfig/lit.site.cfg
       )
     list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/ARMLinuxConfig)
   endif()
 
   if(CAN_TARGET_aarch64)
     # This is only true if we are cross-compiling.
     # Build all tests with host compiler and use host tools.
     set(ASAN_TEST_TARGET_CC ${COMPILER_RT_TEST_COMPILER})
     set(ASAN_TEST_TARGET_CFLAGS ${COMPILER_RT_TEST_COMPILER_CFLAGS})
     set(ASAN_TEST_CONFIG_SUFFIX "-aarch64-linux")
     set(ASAN_TEST_BITS "64")
     set(ASAN_TEST_DYNAMIC False)
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/AArch64LinuxConfig/lit.site.cfg
       )
     list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/AArch64LinuxConfig)
   endif()
 
   if(CAN_TARGET_x86_64 OR CAN_TARGET_powerpc64)
     set(ASAN_TEST_CONFIG_SUFFIX "64")
     set(ASAN_TEST_BITS "64")
     set(ASAN_TEST_TARGET_CFLAGS ${TARGET_64_BIT_CFLAGS})
     set(ASAN_TEST_DYNAMIC False)
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/64bitConfig/lit.site.cfg
       )
     list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/64bitConfig)
     if(COMPILER_RT_BUILD_SHARED_ASAN)
       set(ASAN_TEST_CONFIG_SUFFIX "64-Dynamic")
       set(ASAN_TEST_DYNAMIC True)
       configure_lit_site_cfg(
         ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
         ${CMAKE_CURRENT_BINARY_DIR}/64bitConfig-dynamic/lit.site.cfg)
       list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/64bitConfig-dynamic)
     endif()
   endif()
 
   if(CAN_TARGET_i386)
     set(ASAN_TEST_CONFIG_SUFFIX "32")
     set(ASAN_TEST_BITS "32")
     set(ASAN_TEST_TARGET_CFLAGS ${TARGET_32_BIT_CFLAGS})
     set(ASAN_TEST_DYNAMIC False)
     set(ASAN_TEST_TARGET_ARCH "i386")
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig/lit.site.cfg
       )
     list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig)
     if(COMPILER_RT_BUILD_SHARED_ASAN)
       set(ASAN_TEST_CONFIG_SUFFIX "32-Dynamic")
       set(ASAN_TEST_DYNAMIC True)
       configure_lit_site_cfg(
         ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
         ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig-dynamic/lit.site.cfg)
       list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig-dynamic)
     endif()
   endif()
 
   if(CAN_TARGET_mips)
     set(ASAN_TEST_CONFIG_SUFFIX "32")
     set(ASAN_TEST_BITS "32")
     set(ASAN_TEST_TARGET_CFLAGS ${TARGET_32_BIT_CFLAGS})
     set(ASAN_TEST_DYNAMIC False)
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig/lit.site.cfg
       )
     list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig)
     if(COMPILER_RT_BUILD_SHARED_ASAN)
       set(ASAN_TEST_CONFIG_SUFFIX "32-Dynamic")
       set(ASAN_TEST_DYNAMIC True)
       configure_lit_site_cfg(
         ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
         ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig-dynamic/lit.site.cfg)
       list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig-dynamic)
     endif()
   endif()
+endif()  # Not Android
 
 if(COMPILER_RT_INCLUDE_TESTS)
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg)
 endif()
 
 set(ASAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
 if(COMPILER_RT_STANDALONE_BUILD)
   list(APPEND ASAN_TEST_DEPS ${LLVM_TOOLS_BINARY_DIR}/FileCheck)
 else()
   list(APPEND ASAN_TEST_DEPS asan)
 endif()
 
 # FIXME: support unit test in the android test runner
-if(COMPILER_RT_INCLUDE_TESTS AND NOT CAN_TARGET_arm_android)
+if(COMPILER_RT_INCLUDE_TESTS AND NOT ANDROID)
   list(APPEND ASAN_TEST_DEPS AsanUnitTests)
   list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit)
 endif()
 add_lit_testsuite(check-asan "Running the AddressSanitizer tests"
   ${ASAN_TESTSUITES}
   DEPENDS ${ASAN_TEST_DEPS})
 set_target_properties(check-asan PROPERTIES FOLDER "ASan tests")

test/asan/lit.cfg

if config.asan_dynamic:
   clang_asan_cxxflags = clang_asan_static_cxxflags + ['-shared-libasan']
   config.available_features.add("asan-dynamic-runtime")
 else:
   clang_asan_cflags = clang_asan_static_cflags
   clang_asan_cxxflags = clang_asan_static_cxxflags
   config.available_features.add("asan-static-runtime")
 
 asan_lit_source_dir = get_required_attr(config, "asan_lit_source_dir")
-if config.android == "TRUE":
+if config.android == "1":
   config.available_features.add('android')
   clang_wrapper = os.path.join(asan_lit_source_dir,
                                "android_commands", "android_compile.py") + " "
 else:
   clang_wrapper = ""
 
 def build_invocation(compile_flags):
   return " " + " ".join([clang_wrapper, config.clang] + compile_flags) + " "
sanitizer_common_source_dir = os.path.join(
   get_required_attr(config, "compiler_rt_src_root"), "lib", "sanitizer_common")
 sancov = os.path.join(sanitizer_common_source_dir, "scripts", "sancov.py")
 if not os.path.exists(sancov):
   lit_config.fatal("Can't find script on path %r" % sancov)
 python_exec = get_required_attr(config, "python_executable")
 config.substitutions.append( ("%sancov", python_exec + " " + sancov + " ") )
 
 # Determine kernel bitness
-if config.host_arch.find('64') != -1 and config.android != "TRUE":
+if config.host_arch.find('64') != -1 and config.android != "1":
   kernel_bits = '64'
 else:
   kernel_bits = '32'
 
 config.substitutions.append( ('CHECK-%kernel_bits', ("CHECK-kernel-" + kernel_bits + "-bits")))
 
 config.available_features.add("asan-" + config.bits + "-bits")
 

test/asan/lit.site.cfg.in

 ## Autogenerated by LLVM/Clang configuration.
 # Do not edit!
 
 # Tool-specific config options.
 config.name_suffix = "@ASAN_TEST_CONFIG_SUFFIX@"
 config.asan_lit_source_dir = "@ASAN_LIT_SOURCE_DIR@"
 config.target_cflags = "@ASAN_TEST_TARGET_CFLAGS@"
 config.clang = "@ASAN_TEST_TARGET_CC@"
-config.llvm_tools_dir = "@ASAN_TEST_LLVM_TOOLS_DIR@"
+config.llvm_tools_dir = "@LLVM_TOOLS_BINARY_DIR@"
 config.bits = "@ASAN_TEST_BITS@"
-config.android = "@CAN_TARGET_arm_android@"
+config.android = "@ANDROID@"
 config.asan_dynamic = @ASAN_TEST_DYNAMIC@
 config.target_arch = "@ASAN_TEST_TARGET_ARCH@"
 
 # Load common config for all compiler-rt lit tests.
 lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
 
 # Load tool-specific config that would do the real work.
 lit_config.load_config(config, "@ASAN_LIT_SOURCE_DIR@/lit.cfg")