[sanitizer] Test ubsan and cfi on android.

[eugenis]

Summary

Enable check-cfi and check-ubsan on Android.
Check-ubsan includes standalone and ubsan+asan, but not tsan or msan.
Cross-dso cfi tests are disabled for now.

[pcc]

CFI parts seem reasonable.

compiler-rt/test/cfi/stats.cpp

7 ↗

(On Diff #117937)

Do you know why it fails?

compiler-rt/test/ubsan/TestCases/TypeCheck/Function/function.cpp

6 ↗

(On Diff #117937)

Presumably this fails when targeting ARM?

Should we instead adjust this to check target instead of host?
http://llvm-cs.pcc.me.uk/projects/compiler-rt/test/ubsan/TestCases/TypeCheck/Function/lit.local.cfg

[eugenis]

compiler-rt/test/cfi/stats.cpp

7 ↗

(On Diff #117937)

Because sanstats input is not transferred back to host :) It's a general issue in lit tests, I'd assume more than half cases of "UNSUPPORTED: android" are caused by this or a related problem.

compiler-rt/test/ubsan/TestCases/TypeCheck/Function/function.cpp

6 ↗

(On Diff #117937)

Oh right, it's not about Android. Function sanitizer is not supported on ARM.

[pcc]

compiler-rt/test/cfi/stats.cpp

7 ↗

(On Diff #117937)

Okay, please mention that in a comment then.

[eugenis]

disable function sanitizer by target_arch instead of host_arch

[eugenis]

FIXME in stats.cpp

[pcc]

LGTM

[vitalybuka]

compiler-rt/test/cfi/stats.cpp

9 ↗

(On Diff #117941)

I guess XFAIL is preferable for fixable issues.
UNSUPPORTED may stay this way even If someone accidentally fix the issue for other reasons

compiler-rt/test/ubsan/lit.common.cfg

50 ↗

(On Diff #117941)

Could we put this into top cfg?

[eugenis]

UNSUPPORTED -> XFAIL

[eugenis]

compiler-rt/test/ubsan/lit.common.cfg

50 ↗

(On Diff #117941)

Yes, but I'd like to do it in a separate change.

compiler-rt/trunk/cmake/config-ix.cmake

 endif()
 set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC64}
     ${MIPS32} ${MIPS64} ${S390X})
 set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X})
 set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64} ${MIPS32} ${MIPS64})
-set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64})
+set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${MIPS64})
 set(ALL_ESAN_SUPPORTED_ARCH ${X86_64} ${MIPS64})
 set(ALL_SCUDO_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${MIPS32} ${MIPS64})
 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64} ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} powerpc64le)
 
 if(APPLE)
   include(CompilerRTDarwinUtils)
 
   find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)

compiler-rt/trunk/test/cfi/cross-dso/lit.local.cfg

 def getRoot(config):
   if not config.parent:
     return config
   return getRoot(config.parent)
 
 root = getRoot(config)
 
-if root.host_os not in ['Linux']:
+if root.host_os not in ['Linux'] or config.android:
   config.unsupported = True

compiler-rt/trunk/test/cfi/lit.cfg

 import lit.formats
 import os
 
 config.name = 'cfi' + config.name_suffix
 config.suffixes = ['.c', '.cpp', '.test']
 config.test_source_root = os.path.dirname(__file__)
 
-clang = ' '.join([config.clang, config.target_cflags])
-clangxx = ' '.join([config.clang, config.target_cflags] + config.cxx_mode_flags)
+clang = ' '.join([config.compile_wrapper, config.clang, config.target_cflags])
+clangxx = ' '.join([config.compile_wrapper, config.clang, config.target_cflags] + config.cxx_mode_flags)
 
 config.substitutions.append((r"%clang ", clang + ' '))
 config.substitutions.append((r"%clangxx ", clangxx + ' '))
 if config.lto_supported:
   clang_cfi = ' '.join(config.lto_launch + [clang] + config.lto_flags + ['-fsanitize=cfi '])
 
   if config.cfi_lit_test_mode == "Devirt":
     config.available_features.add('devirt')

compiler-rt/trunk/test/cfi/stats.cpp

 // RUN: %clangxx_cfi -g -fsanitize-stats -o %t %s
 // RUN: env SANITIZER_STATS_PATH=%t.stats %run %t
 // RUN: sanstats %t.stats | FileCheck %s
 
 // FIXME: We currently emit the wrong debug info under devirtualization.
 // UNSUPPORTED: devirt
 
+// FIXME: %t.stats must be transferred from device to host for this to work on Android.
+// XFAIL: android
+
 struct ABase {};
 
 struct A : ABase {
   virtual void vf() {}
   void nvf() {}
 };
 
 extern "C" __attribute__((noinline)) void vcall(A *a) {

compiler-rt/trunk/test/lit.common.cfg

 else:
   lit_config.fatal("Unsupported compiler id: %r" % compiler_id)
 # Add compiler ID to the list of available features.
 config.available_features.add(compiler_id)
 
 # BFD linker in 64-bit android toolchains fails to find libm.so, which is a
 # transitive shared library dependency (via asan runtime).
 if config.android:
-  config.target_cflags += " -fuse-ld=gold -Wl,--enable-new-dtags"
+  config.target_cflags += " -pie -fuse-ld=gold -Wl,--enable-new-dtags"
 
 # Clear some environment variables that might affect Clang.
 possibly_dangerous_env_vars = ['ASAN_OPTIONS', 'DFSAN_OPTIONS', 'LSAN_OPTIONS',
                                'MSAN_OPTIONS', 'UBSAN_OPTIONS',
                                'COMPILER_PATH', 'RC_DEBUG_OPTIONS',
                                'CINDEXTEST_PREAMBLE_FILE', 'LIBRARY_PATH',
                                'CPATH', 'C_INCLUDE_PATH', 'CPLUS_INCLUDE_PATH',
                                'OBJC_INCLUDE_PATH', 'OBJCPLUS_INCLUDE_PATH',

compiler-rt/trunk/test/sanitizer_common/android_commands/android_run.py

 #!/usr/bin/python
 
 import os, signal, sys, subprocess, tempfile
 from android_common import *
 
 ANDROID_TMPDIR = '/data/local/tmp/Output'
 
 device_binary = host_to_device_path(sys.argv[0])
 
 def build_env():
     args = []
     # Android linker ignores RPATH. Set LD_LIBRARY_PATH to Output dir.
     args.append('LD_LIBRARY_PATH=%s' % (ANDROID_TMPDIR,))
     for (key, value) in os.environ.items():
-        if key in ['ASAN_OPTIONS', 'ASAN_ACTIVATION_OPTIONS', 'SCUDO_OPTIONS']:
+        if key in ['ASAN_OPTIONS', 'ASAN_ACTIVATION_OPTIONS', 'SCUDO_OPTIONS', 'UBSAN_OPTIONS']:
             args.append('%s="%s"' % (key, value))
     return ' '.join(args)
 
 is_64bit = (subprocess.check_output(['file', sys.argv[0] + '.real']).find('64-bit') != -1)
 
 device_env = build_env()
 device_args = ' '.join(sys.argv[1:]) # FIXME: escape?
 device_stdout = device_binary + '.stdout'

compiler-rt/trunk/test/ubsan/CMakeLists.txt

if(COMPILER_RT_HAS_ASAN AND ";${ASAN_SUPPORTED_ARCH};" MATCHES ";${arch};")
     # Disable ubsan with AddressSanitizer tests for Windows 64-bit.
     if(NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4)
       add_ubsan_testsuite("AddressSanitizer" asan ${arch})
     endif()
   endif()
   if(COMPILER_RT_HAS_MSAN AND ";${MSAN_SUPPORTED_ARCH};" MATCHES ";${arch};")
     add_ubsan_testsuite("MemorySanitizer" msan ${arch})
   endif()
-  if(COMPILER_RT_HAS_TSAN AND ";${TSAN_SUPPORTED_ARCH};" MATCHES ";${arch};")
+  if(COMPILER_RT_HAS_TSAN AND ";${TSAN_SUPPORTED_ARCH};" MATCHES ";${arch};" AND NOT ANDROID)
     add_ubsan_testsuite("ThreadSanitizer" tsan ${arch})
   endif()
 endforeach()
 
 add_lit_testsuite(check-ubsan "Running UndefinedBehaviorSanitizer tests"
   ${UBSAN_TESTSUITES}
   DEPENDS ${UBSAN_TEST_DEPS})
 set_target_properties(check-ubsan PROPERTIES FOLDER "Compiler-RT Misc")

compiler-rt/trunk/test/ubsan/TestCases/Integer/suppressions.cpp

 // RUN: %clangxx -fsanitize=integer -g0 %s -o %t
 
 // Suppression by symbol name (unsigned-integer-overflow:do_overflow below)
 // requires the compiler-rt runtime to be able to symbolize stack addresses.
 // REQUIRES: can-symbolize
+// UNSUPPORTED: android
 
 // Fails without any suppression.
 // RUN: %env_ubsan_opts=halt_on_error=1 not %run %t 2>&1 | FileCheck %s
 
 // RUN: echo "signed-integer-overflow:%t" > %t.wrong-supp
 // RUN: %env_ubsan_opts=halt_on_error=1:suppressions='"%t.wrong-supp"' not %run %t 2>&1 | FileCheck %s
 
 // RUN: echo "unsigned-integer-overflow:do_overflow" > %t.func-supp

compiler-rt/trunk/test/ubsan/TestCases/TypeCheck/Function/lit.local.cfg

 # The function type checker is only supported on x86 and x86_64 for now.
-if config.root.host_arch not in ['x86', 'x86_64']:
+if config.target_arch not in ['x86', 'x86_64']:
   config.unsupported = True

compiler-rt/trunk/test/ubsan/lit.common.cfg

 if config.target_arch == 's390x':
   # On SystemZ we need -mbackchain to make the fast unwinder work.
   clang_ubsan_cflags.append("-mbackchain")
 if config.host_os == 'Darwin':
   # On Darwin, we default to `abort_on_error=1`, which would make tests run
   # much slower. Let's override this and run lit tests with 'abort_on_error=0'.
   default_ubsan_opts += ['abort_on_error=0']
   default_ubsan_opts += ['log_to_syslog=0']
+elif config.android:
+  default_ubsan_opts += ['abort_on_error=0']
+
 default_ubsan_opts_str = ':'.join(default_ubsan_opts)
 if default_ubsan_opts_str:
   config.environment['UBSAN_OPTIONS'] = default_ubsan_opts_str
   default_ubsan_opts_str += ':'
 # Substitution to setup UBSAN_OPTIONS in portable way.
 config.substitutions.append(('%env_ubsan_opts=',
                              'env UBSAN_OPTIONS=' + default_ubsan_opts_str))
 
 def build_invocation(compile_flags):
-  return " " + " ".join([config.clang] + compile_flags) + " "
+  return " " + " ".join([config.compile_wrapper, config.clang] + compile_flags) + " "
 
 target_cflags = [get_required_attr(config, "target_cflags")]
 clang_ubsan_cflags += target_cflags
 clang_ubsan_cxxflags = config.cxx_mode_flags + clang_ubsan_cflags
 
 # Define %clang and %clangxx substitutions to use in test RUN lines.
 config.substitutions.append( ("%clang ", build_invocation(clang_ubsan_cflags)) )
 config.substitutions.append( ("%clangxx ", build_invocation(clang_ubsan_cxxflags)) )