light up ASan on ARM. XFAILed failing tests

[garious]

Summary

Marked currently failing tests with XFAIL. Tests that hang are marked Unsupported.

To try, configure your standalone compiler-rt build with the following CMake variables:

CMAKE_C_COMPILER=arm-linux-gnueabi-gcc
COMPILER_RT_TEST_COMPILER=clang
COMPILER_RT_TEST_TARGET_TRIPLE=arm-linux-gnueabi
COMPILER_RT_TEST_COMPILER_CFLAGS='-target arm-linux-gnueabi --sysroot=$ARM_SYSROOT -B$GCC_DIR'
COMPILER_RT_EMULATOR=qemu-arm-wrapper.sh

[kcc]

What's the plan for removing these XFAILS?
Also, Android is also ARM, and I thought we already run these lit tests there.
eugenis?

[eugenis]

We don't run these tests on Android as I did not have time to finish deployment.

I suspect at least part of these failures are specific to arm-linux, and not arm in general?

[garious]

Some are just ARM Linux (fast unwind not working as expected and giving us bad stack traces). Some are triggering segfaults when looking up shadow memory. Some hang and might indicate qemu-arm bugs - those are marked "REQUIRES: stable-runtime" in this patch.

I can't commit to fixing all the XFAILs before the 3.5 release. Would anyone be able to lend a hand? I think the first step would be to set up a qemu-arm bot so that we can standardize on a runtime environment and configuration. For instance, to get ASan to start up, I had to configure qemu to reserve zero bytes for guest virtual address space (-R 0) and I don't understand why that is needed.

As for Android, I hear the Android emulator is based on qemu. Maybe this bot can build and test both arm-linux and android?

[ygribov]

Some are just ARM Linux (fast unwind not working as expected and giving us bad stack traces).

These should be fixable by adding -fno-omit-frame-pointer to tests' CXXFLAGS or fast_unwind_on_malloc=0 to ASAN_OPTIONS. Problems may also be caused by broken unwind tables in ARM backend.

[garious]

Rebased on http://reviews.llvm.org/rL209699 and http://reviews.llvm.org/D3794

[garious]

Closed by commit rL209862 (authored by @garious).

test/asan/TestCases/Linux/clone_test.cc

 // RUN: %clangxx_asan -O1 %s -o %t && %run %t | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -o %t && %run %t | FileCheck %s
 // RUN: %clangxx_asan -O3 %s -o %t && %run %t | FileCheck %s
+// XFAIL: arm
 
 #include <stdio.h>
 #include <sched.h>

test/asan/TestCases/Linux/glob.cc

 // RUN: %clangxx_asan -O0 %s -o %t && %run %t %p 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O3 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+// XFAIL: arm
 
 #include <assert.h>
 #include <glob.h>

test/asan/TestCases/Linux/heavy_uar_test.cc

 // RUN:   not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -o %t && \
 // RUN:   not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm
 
 // FIXME: Fix this test under GCC.
 // REQUIRES: Clang

test/asan/TestCases/Linux/malloc_delete_mismatch.cc

 // Also works if no malloc context is available.
 // RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
 // RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm
 #include <stdlib.h>
 
 static volatile char *x;

test/asan/TestCases/Linux/ptrace.cc

 // RUN: %clangxx_asan -O0 %s -o %t && %run %t
 // RUN: %clangxx_asan -DPOSITIVE -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm
 
 #include <assert.h>
 #include <stdio.h>

test/asan/TestCases/Linux/stack-trace-dlclose.cc

 // RUN: %clangxx_asan -DSHARED %s -shared -o %T/stack_trace_dlclose.so -fPIC
 // RUN: %clangxx_asan -DSO_DIR=\"%T\" %s -o %t
 // RUN: ASAN_OPTIONS=exitcode=0 %run %t 2>&1 | FileCheck %s
+// XFAIL: arm
 
 #include <assert.h>
 #include <dlfcn.h>

test/asan/TestCases/Linux/uar_signals.cc

 // This test checks that the implementation of use-after-return
 // is async-signal-safe.
 // RUN: %clangxx_asan -O1 %s -o %t -lpthread && %run %t
+// REQUIRES: stable-runtime
 #include <signal.h>
 #include <stdlib.h>
 #include <stdio.h>

test/asan/TestCases/Posix/shared-lib-test.cc

 // RUN: %clangxx_asan -O2 %s -ldl -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O3 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
 // RUN: %clangxx_asan -O3 %s -ldl -o %t && not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm
 
 #if !defined(SHARED_LIB)
 #include <dlfcn.h>

test/asan/TestCases/Posix/start-deactivated.cc

 // RUN: %clangxx -O0 %s -c -o %t.o
 // RUN: %clangxx_asan -O0 %t.o -ldl -o %t
 // RUN: ASAN_OPTIONS=start_deactivated=1 not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm
 
 #if !defined(SHARED_LIB)
 #include <dlfcn.h>

test/asan/TestCases/asan-symbolize-sanity-test.cc

 // RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
 // RUN: %clangxx_asan -O0 %s -ldl -o %t
 // RUN: env ASAN_OPTIONS=symbolize=0 not %run %t 2>&1 | %asan_symbolize | FileCheck %s
+// XFAIL: arm
 
 #if !defined(SHARED_LIB)
 #include <dlfcn.h>

test/asan/TestCases/current_allocated_bytes.cc

 // RUN: %clangxx_asan -O0 %s -lpthread -o %t && %run %t
 // RUN: %clangxx_asan -O2 %s -lpthread -o %t && %run %t
+// REQUIRES: stable-runtime
 
 #include <assert.h>
 #include <pthread.h>

test/asan/TestCases/deep_stack_uaf.cc

 
 // RUN: %clangxx_asan -O0 %s -o %t 2>&1
 // RUN: env ASAN_OPTIONS=malloc_context_size=120:redzone=512 not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm
 #include <stdlib.h>
 #include <stdio.h>
 

test/asan/TestCases/deep_thread_stack.cc

 // RUN: %clangxx_asan -O1 %s -lpthread -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -lpthread -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O3 %s -lpthread -o %t && not %run %t 2>&1 | FileCheck %s
+// REQUIRES: stable-runtime
 
 #include <pthread.h>
 

test/asan/TestCases/double-free.cc

 // Also works if no malloc context is available.
 // RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
 // RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm
 
 #include <stdlib.h>
 #include <string.h>

test/asan/TestCases/gc-test.cc

 // RUN: %clangxx_asan %s -lpthread -o %t
 // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
 // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK0
+// XFAIL: arm
 
 #include <assert.h>
 #include <stdio.h>

test/asan/TestCases/invalid-free.cc

 // Also works if no malloc context is available.
 // RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
 // RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm
 
 #include <stdlib.h>
 #include <string.h>

test/asan/TestCases/large_func_test.cc

 // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// XFAIL: arm
 
 #include <stdlib.h>
 __attribute__((noinline))

test/asan/TestCases/mmap_limit_mb.cc

 // RUN: env ASAN_OPTIONS=mmap_limit_mb=500 %run %t 50 1000000
 // RUN: env ASAN_OPTIONS=mmap_limit_mb=500 not %run %t 500 16 2>&1 | FileCheck %s
 // RUN: env ASAN_OPTIONS=mmap_limit_mb=500 not %run %t 500 1000000 2>&1 | FileCheck %s
+// XFAIL: arm
 
 #include <assert.h>
 #include <stdlib.h>

test/asan/TestCases/sanity_check_pure_c.c

 // Sanity checking a test in pure C with -pie.
 // RUN: %clang_asan -O2 %s -pie -fPIE -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm
 
 #include <stdlib.h>
 int main() {

test/asan/TestCases/strdup_oob_test.cc

 // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm
 
 #include <string.h>
 

test/asan/TestCases/strncpy-overflow.cc

 // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 
 // REQUIRES: compiler-rt-optimized
+// XFAIL: arm
 
 #include <string.h>
 #include <stdlib.h>

test/asan/TestCases/use-after-delete.cc

 // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// XFAIL: arm
 
 #include <stdlib.h>
 int main() {

test/asan/TestCases/use-after-free-right.cc

 // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// XFAIL: arm
 
 // Test use-after-free report in the case when access is at the right border of
 // the allocation.

test/asan/TestCases/use-after-free.cc

 // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// XFAIL: arm
 
 #include <stdlib.h>
 int main() {

test/asan/lit.cfg

 
 config.available_features.add("asan-" + config.bits + "-bits")
 
+# Allow tests to use REQUIRES=stable-runtime.  For use when you cannot use XFAIL
+# because the test hangs.
+if config.target_arch != 'arm':
+  config.available_features.add('stable-runtime')
+
 # Turn on leak detection on 64-bit Linux.
 if config.host_os == 'Linux' and config.bits == '64':
   config.environment['ASAN_OPTIONS'] = 'detect_leaks=1'