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).

compiler-rt/trunk/test/asan/TestCases/Linux/clone_test.cc

 // Regression test for:
 // http://code.google.com/p/address-sanitizer/issues/detail?id=37
 
 // RUN: %clangxx_asan -O0 %s -o %t && %run %t | FileCheck %s
 // 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>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 

compiler-rt/trunk/test/asan/TestCases/Linux/glob.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // 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>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <string>
 

compiler-rt/trunk/test/asan/TestCases/Linux/heavy_uar_test.cc

 // RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1
 // RUN: %clangxx_asan -O0 %s -o %t && \
 // 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
 
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 

compiler-rt/trunk/test/asan/TestCases/Linux/malloc_delete_mismatch.cc

 // Check that we detect malloc/delete mismatch only if the approptiate flag
 // is set.
 
 // RUN: %clangxx_asan -g %s -o %t 2>&1
 
 // Find error and provide malloc context.
 // RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=ALLOC-STACK
 
 // No error here.
 // RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=0 %run %t
 
 // 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;
 
 int main() {
   x = (char*)malloc(10);
   x[0] = 0;
   delete x;

compiler-rt/trunk/test/asan/TestCases/Linux/ptrace.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // 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>
 #include <sys/ptrace.h>
 #include <sys/types.h>
 #include <sys/user.h>
 #include <sys/wait.h>
 #include <unistd.h>

compiler-rt/trunk/test/asan/TestCases/Linux/stack-trace-dlclose.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // 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>
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 
 #include <sanitizer/common_interface_defs.h>

compiler-rt/trunk/test/asan/TestCases/Posix/asan-symbolize-sanity-test.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // Check that asan_symbolize.py script works (for binaries, ASan RTL and
 // shared object files.
 
 // 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>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <string>
 

compiler-rt/trunk/test/asan/TestCases/Posix/shared-lib-test.cc

 // RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
 // RUN: %clangxx_asan -O0 %s -ldl -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O1 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
 // RUN: %clangxx_asan -O1 %s -ldl -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
 // 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>
 #include <stdio.h>
 #include <string.h>
 
 #include <string>
 

compiler-rt/trunk/test/asan/TestCases/Posix/start-deactivated.cc

 // Test for ASAN_OPTIONS=start_deactivated=1 mode.
 // Main executable is uninstrumented, but linked to ASan runtime. The shared
 // library is instrumented. Memory errors before dlopen are not detected.
 
 // RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
 // 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>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 

compiler-rt/trunk/test/asan/TestCases/deep_stack_uaf.cc

 // Check that we can store lots of stack frames if asked to.
 
 // 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>
 
 template <int depth>
 struct DeepFree {
   static void free(char *x) {
     DeepFree<depth - 1>::free(x);
   }

compiler-rt/trunk/test/asan/TestCases/double-free.cc

 // RUN: %clangxx_asan -O0 %s -o %t 2>&1
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=MALLOC-CTX
 
 // 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>
 int main(int argc, char **argv) {
   char *x = (char*)malloc(10 * sizeof(char));
   memset(x, 0, 10);
   int res = x[argc];
   free(x);

compiler-rt/trunk/test/asan/TestCases/gc-test.cc

 // RUN: %clangxx_asan %s -pthread -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>
 #include <pthread.h>
 #include <sanitizer/asan_interface.h>
 
 static const int kNumThreads = 2;
 

compiler-rt/trunk/test/asan/TestCases/invalid-free.cc

 // RUN: %clangxx_asan -O0 %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=MALLOC-CTX
 
 // 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>
 int main(int argc, char **argv) {
   char *x = (char*)malloc(10 * sizeof(char));
   memset(x, 0, 10);
   int res = x[argc];
   free(x + 5);  // BOOM
   // CHECK: AddressSanitizer: attempting free on address{{.*}}in thread T0
   // CHECK: invalid-free.cc:[[@LINE-2]]
   // CHECK: is located 5 bytes inside of 10-byte region
   // CHECK: allocated by thread T0 here:
   // MALLOC-CTX: invalid-free.cc:[[@LINE-8]]
   return res;
 }

compiler-rt/trunk/test/asan/TestCases/large_func_test.cc

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // 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))
 static void LargeFunction(int *x, int zero) {
   x[0]++;
   x[1]++;
   x[2]++;
   x[3]++;

compiler-rt/trunk/test/asan/TestCases/mmap_limit_mb.cc

 // Test the mmap_limit_mb flag.
 //
 // RUN: %clangxx_asan -O2 %s -o %t
 // RUN: %run %t 100 16
 // RUN: %run %t 100 1000000
 // RUN: env ASAN_OPTIONS=mmap_limit_mb=500 %run %t 50 16
 // 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>
 #include <stdio.h>
 
 #include <algorithm>
 #include <vector>
 

compiler-rt/trunk/test/asan/TestCases/sanity_check_pure_c.c

 // Sanity checking a test in pure C.
 // RUN: %clang_asan -O2 %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 // 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() {
   char *x = (char*)malloc(10 * sizeof(char));
   free(x);
   return x[5];
   // CHECK: heap-use-after-free
   // CHECK: free
   // CHECK: main{{.*}}sanity_check_pure_c.c:[[@LINE-4]]
   // CHECK: malloc
   // CHECK: main{{.*}}sanity_check_pure_c.c:[[@LINE-7]]
 }

compiler-rt/trunk/test/asan/TestCases/strncpy-overflow.cc

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // 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
 
 // REQUIRES: compiler-rt-optimized
+// XFAIL: arm
 
 #include <string.h>
 #include <stdlib.h>
 int main(int argc, char **argv) {
   char *hello = (char*)malloc(6);
   strcpy(hello, "hello");
   char *short_buffer = (char*)malloc(9);
   strncpy(short_buffer, hello, 10);  // BOOM

compiler-rt/trunk/test/asan/TestCases/use-after-delete.cc

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // 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() {
   char * volatile x = new char[10];
   delete[] x;
   return x[5];
   // CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
   // CHECK:   {{0x.* at pc 0x.* bp 0x.* sp 0x.*}}

compiler-rt/trunk/test/asan/TestCases/use-after-free-right.cc

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // 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.
 
 #include <stdlib.h>
 int main() {
   volatile char *x = (char*)malloc(sizeof(char));
   free((void*)x);

compiler-rt/trunk/test/asan/TestCases/use-after-free.cc

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
 // 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() {
   char *x = (char*)malloc(10 * sizeof(char));
   free(x);
   return x[5];
   // CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
   // CHECK:   {{0x.* at pc 0x.* bp 0x.* sp 0x.*}}