[ubsan] Enable UBsan in sanitizer_common tests

[vitalybuka]

Summary

Failing tests just marked as UNSUPPORTED or XFAIL.
Some of them can be easily supported, but I'll do this in separate patches.

compiler-rt/test/sanitizer_common/CMakeLists.txt

 set(SANITIZER_COMMON_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 set(SANITIZER_COMMON_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
 set(SANITIZER_COMMON_TESTSUITES)
 
 set(SUPPORTED_TOOLS)
 if(CMAKE_SYSTEM_NAME MATCHES "Darwin|Linux|FreeBSD|NetBSD" AND NOT ANDROID)
   list(APPEND SUPPORTED_TOOLS asan)
 endif()
 if(CMAKE_SYSTEM_NAME MATCHES "Linux" AND NOT ANDROID)
   list(APPEND SUPPORTED_TOOLS tsan)
   list(APPEND SUPPORTED_TOOLS msan)
   list(APPEND SUPPORTED_TOOLS lsan)
+  list(APPEND SUPPORTED_TOOLS ubsan)
 endif()
 
 # Create a separate config for each tool we support.
 foreach(tool ${SUPPORTED_TOOLS})
   string(TOUPPER ${tool} tool_toupper)
   if(${tool_toupper}_SUPPORTED_ARCH AND NOT COMPILER_RT_STANDALONE_BUILD)
     list(APPEND SANITIZER_COMMON_TEST_DEPS ${tool})
   endif()

compiler-rt/test/sanitizer_common/TestCases/Linux/allow_user_segv.cc

 // RUN: %env_tool_opts=handle_segv=0:allow_user_segv_handler=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK0
 // RUN: %env_tool_opts=handle_segv=1:allow_user_segv_handler=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
 // RUN: %env_tool_opts=handle_segv=2:allow_user_segv_handler=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK2
 // clang-format on
 
 // Remove when fixed: https://github.com/google/sanitizers/issues/637
 // UNSUPPORTED: msan
 // UNSUPPORTED: tsan
+// UNSUPPORTED: ubsan
 
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 struct sigaction original_sigaction_sigbus;
 struct sigaction original_sigaction_sigsegv;
 

compiler-rt/test/sanitizer_common/TestCases/Linux/assert.cc

 // Test the handle_abort option.
 // RUN: %clang %s -o %t
 // RUN:                              not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
 // RUN: %env_tool_opts=handle_abort=0 not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
 // RUN: %env_tool_opts=handle_abort=1 not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
 // FIXME: implement in other sanitizers, not just asan.
 // XFAIL: msan
 // XFAIL: tsan
+// XFAIL: ubsan
 #include <assert.h>
 #include <stdio.h>
 #include <sanitizer/asan_interface.h>
 
 void death() {
   fprintf(stderr, "DEATH CALLBACK\n");
 }
 
 int main(int argc, char **argv) {
   __sanitizer_set_death_callback(death);
   assert(argc == 100);
 }
 // CHECK1: ERROR: {{.*}}Sanitizer:
 // CHECK1: DEATH CALLBACK
 // CHECK0-NOT: Sanitizer

compiler-rt/test/sanitizer_common/TestCases/Linux/decorate_proc_maps.cc

 
 // CHECK-tsan: rw-p {{.*}} [shadow]
 // CHECK-tsan: rw-p {{.*}} [meta shadow]
 // CHECK-tsan: rw-p {{.*}} [trace 0]
 // CHECK-tsan: rw-p {{.*}} [trace header 0]
 // CHECK-tsan: rw-p {{.*}} [trace 1]
 // CHECK-tsan: rw-p {{.*}} [trace header 1]
 
-// Nothing interesting with standalone LSan.
+// Nothing interesting with standalone LSan and UBSan.
 // CHECK-lsan: decorate_proc_maps
+// CHECK-ubsan: decorate_proc_maps

compiler-rt/test/sanitizer_common/TestCases/Linux/deepbind.cc

 // RUN: %clangxx %s -o %t && %run not %t 1 2>&1 | FileCheck %s
-// UNSUPPORTED: lsan, android
+// UNSUPPORTED: lsan,ubsan,android
 
 #include <dlfcn.h>
 #include <stdio.h>
 #include <string>
 
 int main (int argc, char *argv[]) {
   // CHECK: You are trying to dlopen a <arbitrary path> shared library with RTLD_DEEPBIND flag
   void *lib = dlopen("<arbitrary path>", RTLD_NOW | RTLD_DEEPBIND);
   return 0;
 }

compiler-rt/test/sanitizer_common/TestCases/Linux/hard_rss_limit_mb_test.cc

 // Check hard_rss_limit_mb. Not all sanitizers implement it yet.
 // RUN: %clangxx -O2 %s -o %t
 //
 // Run with limit should fail:
 // RUN: %env_tool_opts=hard_rss_limit_mb=100                           not %run %t 2>&1 | FileCheck %s
 // This run uses getrusage:
 // RUN: %env_tool_opts=hard_rss_limit_mb=100:can_use_proc_maps_statm=0 not %run %t 2>&1 | FileCheck %s
 //
 // Run w/o limit or with a large enough limit should pass:
 // RUN: %env_tool_opts=hard_rss_limit_mb=1000 %run %t
 // RUN: %run %t
 //
 // FIXME: make it work for other sanitizers.
 // XFAIL: lsan
 // XFAIL: tsan
 // XFAIL: msan
+// XFAIL: ubsan
 
 #include <string.h>
 #include <stdio.h>
 #include <unistd.h>
 
 const int kNumAllocs = 200 * 1000;
 const int kAllocSize = 1000;
 volatile char *sink[kNumAllocs];

compiler-rt/test/sanitizer_common/TestCases/Linux/ill.cc

 // Test the handle_sigill option.
 // RUN: %clang %s -o %t -O1
 // RUN:                                not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
 // RUN: %env_tool_opts=handle_sigill=0 not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
 // RUN: %env_tool_opts=handle_sigill=1 not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
 // FIXME: implement in other sanitizers, not just asan.
 // XFAIL: msan
 // XFAIL: tsan
+// XFAIL: ubsan
 //
 // FIXME: seems to fail on ARM
 // REQUIRES: x86_64-target-arch
 #include <assert.h>
 #include <stdio.h>
 #include <sanitizer/asan_interface.h>
 
 void death() {

compiler-rt/test/sanitizer_common/TestCases/Linux/mlock_test.cc

 // RUN: %clang  %s -o %t && %run %t
-// XFAIL: lsan
+// XFAIL: ubsan,lsan
 
 #include <assert.h>
 #include <sys/mman.h>
 
 int main() {
   assert(0 == mlockall(MCL_CURRENT));
   assert(0 == mlock((void *)0x12345, 0x5678));
   assert(0 == munlockall());
   assert(0 == munlock((void *)0x987, 0x654));
 }
 

compiler-rt/test/sanitizer_common/TestCases/Linux/mprobe.cc

 // RUN: %clangxx %s -o %t && %run %t 2>&1 | FileCheck %s
-// UNSUPPORTED: android
+// UNSUPPORTED: android, ubsan
 
 #include <stdio.h>
 #include <stdlib.h>
 #if defined(__GLIBC_PREREQ) && __GLIBC_PREREQ(2, 2)
 #include <mcheck.h>
 #else
 #define MCHECK_OK 0
 extern "C" int mcheck(void (*abortfunc)(int mstatus));

compiler-rt/test/sanitizer_common/TestCases/Linux/sem_init_glibc.cc

 // RUN: %clangxx -O0 -g %s -lutil -o %t && %run %t
 // This test depends on the glibc layout of struct sem_t and checks that we
 // don't leave sem_t::private uninitialized.
-// UNSUPPORTED: android, lsan-x86
+// UNSUPPORTED: android, lsan-x86, ubsan
 #include <features.h>
 #include <assert.h>
 #include <semaphore.h>
 #include <string.h>
 #include <stdint.h>
 
 // On powerpc64be semval_t must be 64 bits even with "old" versions of glibc.
 #if __PPC64__ && __BIG_ENDIAN__

compiler-rt/test/sanitizer_common/TestCases/Linux/soft_rss_limit_mb_test.cc

 // Check soft_rss_limit_mb. Not all sanitizers implement it yet.
 // RUN: %clangxx -O2 %s -o %t
 //
 // Run with limit should fail:
 // RUN: %env_tool_opts=soft_rss_limit_mb=220:quarantine_size=1:allocator_may_return_null=1     %run %t 2>&1 | FileCheck %s -check-prefix=CHECK_MAY_RETURN_1
 // RUN: %env_tool_opts=soft_rss_limit_mb=220:quarantine_size=1:allocator_may_return_null=0 not %run %t 2>&1 | FileCheck %s -check-prefix=CHECK_MAY_RETURN_0
 
 // This run uses getrusage. We can only test getrusage when allocator_may_return_null=0
 // because getrusage gives us max-rss, not current-rss.
 // RUN: %env_tool_opts=soft_rss_limit_mb=220:quarantine_size=1:allocator_may_return_null=0:can_use_proc_maps_statm=0 not %run %t 2>&1 | FileCheck %s -check-prefix=CHECK_MAY_RETURN_0
 // REQUIRES: stable-runtime
 
 // FIXME: make it work for other sanitizers.
 // XFAIL: lsan
 // XFAIL: tsan
 // XFAIL: msan
+// XFAIL: ubsan
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 
 static const int kMaxNumAllocs = 1 << 9;
 static const int kAllocSize = 1 << 20;  // Large enough to go via mmap.
 

compiler-rt/test/sanitizer_common/TestCases/Linux/unexpected_format_specifier_test.cc

 // RUN: %clang -w -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: lsan
 // UNSUPPORTED: msan
+// UNSUPPORTED: ubsan
 #include <stdio.h>
 int main() {
   int a;
   printf("%Q\n", 1);
   printf("%Q\n", 1);
   printf("%Q\n", 1);
 }
 // CHECK: unexpected format specifier in printf interceptor: %Q (reported once per process)
 // CHECK-NOT: unexpected format specifier in printf interceptor

compiler-rt/test/sanitizer_common/TestCases/Posix/dedup_token_length_test.cc

 // Test dedup_token_length
 // RUN: %clangxx -O0 %s -o %t
 // RUN: env %tool_options='abort_on_error=0'                       not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK0 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=0' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK0 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=1' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK1 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=2' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK2 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=3' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK3 --match-full-lines
 
 // REQUIRES: stable-runtime
 // FIXME: implement SEGV handler in other sanitizers, not just asan.
 // XFAIL: msan
 // XFAIL: tsan
+// XFAIL: ubsan
 
 volatile int *null = 0;
 
 namespace Xyz {
   template<class A, class B> void Abc() {
     *null = 0;
   }
 }

compiler-rt/test/sanitizer_common/TestCases/Posix/fpe.cc

 // Test the handle_sigfpe option.
 // RUN: %clang %s -o %t
 // RUN:                               not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
 // RUN: %env_tool_opts=handle_sigfpe=0 not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
 // RUN: %env_tool_opts=handle_sigfpe=1 not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
 // FIXME: implement in other sanitizers, not just asan.
 // XFAIL: msan
 // XFAIL: tsan
+// XFAIL: ubsan
 //
 // FIXME: seems to fail on ARM
 // REQUIRES: x86_64-target-arch
 #include <assert.h>
 #include <stdio.h>
 #include <sanitizer/asan_interface.h>
 
 void death() {

compiler-rt/test/sanitizer_common/TestCases/Posix/sanitizer_set_death_callback_test.cc

 // RUN: %clangxx -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: stable-runtime
 
 // For standalone LSan on x86 we have a problem: compiler spills the address
 // of allocated at line 42 memory thus memory block allocated in Leak() function
 // ends up to be classified as reachable despite the fact we zero out 'sink' at
 // the last line of main function. The problem doesn't reproduce with ASan because
 // quarantine prohibits memory block reuse for different allocations.
 // XFAIL: lsan-x86
+// XFAIL: ubsan
 
 #include <sanitizer/common_interface_defs.h>
 #include <stdio.h>
 
 volatile char *zero = 0;
 
 void Death() {
   fprintf(stderr, "DEATH CALLBACK EXECUTED\n");

compiler-rt/test/sanitizer_common/TestCases/Posix/sanitizer_set_report_fd_test.cc

 // Test __sanitizer_set_report_fd:
 // RUN: %clangxx -O2 %s -o %t
 // RUN: not %run %t 2>&1   | FileCheck %s
 // RUN: not %run %t stdout | FileCheck %s
 // RUN: not %run %t %t-out && FileCheck < %t-out %s
 
 // REQUIRES: stable-runtime
 // FIXME: implement SEGV handler in other sanitizers, not just asan.
 // XFAIL: msan
 // XFAIL: tsan
+// XFAIL: ubsan
 
 #include <sanitizer/common_interface_defs.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>

compiler-rt/test/sanitizer_common/TestCases/Posix/weak_hook_test.cc

 // Test the weak hooks.
 // RUN: %clangxx %s -o %t
 // RUN: %run %t
 
 // Hooks are not implemented for lsan.
 // XFAIL: lsan
+// XFAIL: ubsan
 
 #include <string.h>
 #include <assert.h>
 
 bool seen_memcmp, seen_strncmp, seen_strncasecmp, seen_strcmp, seen_strcasecmp,
     seen_strstr, seen_strcasestr, seen_memmem;
 
 extern "C" {

compiler-rt/test/sanitizer_common/TestCases/corelimit.cc

 // RUN: %clangxx -O0 %s -o %t && %run %t
-// UNSUPPORTED: lsan
+// UNSUPPORTED: lsan,ubsan
 
 #include <assert.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 
 int main() {
   struct rlimit lim_core;
   getrlimit(RLIMIT_CORE, &lim_core);
   void *p;
   if (sizeof(p) == 8) {
     assert(0 == lim_core.rlim_max);
   }
   return 0;
 }

compiler-rt/test/sanitizer_common/TestCases/malloc_hook.cc

 // RUN: %clangxx -O2 %s -o %t && %run %t 2>&1 | FileCheck %s
 
 // Malloc/free hooks are not supported on Windows.
 // XFAIL: win32
+// XFAIL: ubsan
 
 #include <stdlib.h>
 #include <unistd.h>
 #include <sanitizer/allocator_interface.h>
 
 extern "C" {
 const volatile void *global_ptr;
 

compiler-rt/test/sanitizer_common/TestCases/options-include.cc

 // RUN: %clangxx -O0 %s -o %t
+// UNSUPPORTED: ubsan
 
 // Recursive include: options1 includes options2
 // RUN: echo "symbolize=1" > %t.options1.txt
 // RUN: echo "include='%t.options2.txt'" >>%t.options1.txt
 // RUN: echo "help=1" >%t.options2.txt
 // RUN: echo "help=1" >%t.options.options-include.cc.tmp
 // RUN: cat %t.options1.txt
 // RUN: cat %t.options2.txt

compiler-rt/test/sanitizer_common/TestCases/print-stack-trace.cc

 // RUN: %clangxx -O0 %s -o %t && %env_tool_opts=stack_trace_format=DEFAULT %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx -O3 %s -o %t && %env_tool_opts=stack_trace_format=DEFAULT %run %t 2>&1 | FileCheck %s
 // RUN: %env_tool_opts=stack_trace_format='"frame:%n lineno:%l"' %run %t 2>&1 | FileCheck %s --check-prefix=CUSTOM
 // RUN: %env_tool_opts=symbolize_inline_frames=false:stack_trace_format=DEFAULT %run %t 2>&1 | FileCheck %s --check-prefix=NOINLINE
 
 // UNSUPPORTED: darwin
+// XFAIL: ubsan
 
 #include <sanitizer/common_interface_defs.h>
 
 static inline void FooBarBaz() {
   __sanitizer_print_stack_trace();
 }
 
 int main() {

compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_no_prune.cc

 // Tests -fsanitize-coverage=no-prune
 //
 // REQUIRES: has_sancovcc,stable-runtime
 // UNSUPPORTED: i386-darwin
-// XFAIL: tsan
+// XFAIL: ubsan,tsan
 //
 // RUN: %clangxx -O0 %s -S -o - -emit-llvm -fsanitize-coverage=trace-pc,bb,no-prune 2>&1 | grep "call void @__sanitizer_cov_trace_pc" | count 3
 // RUN: %clangxx -O0 %s -S -o - -emit-llvm -fsanitize-coverage=trace-pc,bb          2>&1 | grep "call void @__sanitizer_cov_trace_pc" | count 2
 // RUN: %clangxx -O0 %s -S -o - -emit-llvm -fsanitize-coverage=trace-pc,no-prune    2>&1 | grep "call void @__sanitizer_cov_trace_pc" | count 4
 // RUN: %clangxx -O0 %s -S -o - -emit-llvm -fsanitize-coverage=trace-pc             2>&1 | grep "call void @__sanitizer_cov_trace_pc" | count 3
 
 void foo(int *a) {
   if (a)
     *a = 1;
 }

compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_pc_guard-dso.cc

 // Tests trace pc guard coverage collection.
 //
 // REQUIRES: has_sancovcc,stable-runtime
+// UNSUPPORTED: ubsan
 // XFAIL: tsan,darwin,powerpc64,s390x,mips
 //
 // RUN: DIR=%t_workdir
 // RUN: CLANG_ARGS="-O0 -fsanitize-coverage=trace-pc-guard"
 // RUN: rm -rf $DIR
 // RUN: mkdir -p $DIR
 // RUN: cd $DIR
 // RUN: %clangxx -DSHARED1 $CLANG_ARGS -shared %s -o %t_1.so -fPIC

 // CHECK-NEXT: bar
 // CHECK-NEXT: baz
 // CHECK-DAG: SanitizerCoverage: ./sanitizer_coverage_trace_pc_guard-dso.{{.*}}.sancov: 2 PCs written
 // CHECK-DAG: SanitizerCoverage: ./sanitizer_coverage_trace_pc_guard-dso.{{.*}}_2.so.{{.*}}.sancov: 1 PCs written
 // CHECK-DAG: SanitizerCoverage: ./sanitizer_coverage_trace_pc_guard-dso.{{.*}}_1.so.{{.*}}.sancov: 1 PCs written
 //
 // CHECK-SANCOV: Ignoring {{.*}}_1.so and its coverage because __sanitizer_cov* functions were not found.
 // CHECK-SANCOV: Ignoring {{.*}}_2.so and its coverage because __sanitizer_cov* functions were not found.
-// CHECK-SANCOV-NEXT: sanitizer_coverage_trace_pc_guard-dso.cc:29 foo
-// CHECK-SANCOV-NEXT: sanitizer_coverage_trace_pc_guard-dso.cc:34 main
+// CHECK-SANCOV-NEXT: sanitizer_coverage_trace_pc_guard-dso.cc:[[@LINE-42]] foo
+// CHECK-SANCOV-NEXT: sanitizer_coverage_trace_pc_guard-dso.cc:[[@LINE-38]] main

compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_pc_guard.cc

 // Tests trace pc guard coverage collection.
 //
 // REQUIRES: has_sancovcc,stable-runtime
-// UNSUPPORTED: i386-darwin
+// UNSUPPORTED: ubsan,i386-darwin
 // XFAIL: tsan,powerpc64,s390x,mips
 //
 // RUN: DIR=%t_workdir
 // RUN: rm -rf $DIR
 // RUN: mkdir -p $DIR
 // RUN: cd $DIR
 // RUN: %clangxx -O0 -fsanitize-coverage=trace-pc-guard %s -ldl -o %t
 // RUN: %env_tool_opts=coverage=1 %t 2>&1 | FileCheck %s
int main() {
   foo();
 }
 
 // CHECK: main
 // CHECK-NEXT: foo
 // CHECK-NEXT: foo
 // CHECK-NEXT: SanitizerCoverage: ./sanitizer_coverage_trace_pc_guard.{{.*}}.sancov: 2 PCs written
 //
-// CHECK-SANCOV: sanitizer_coverage_trace_pc_guard.cc:23 foo
-// CHECK-SANCOV-NEXT: sanitizer_coverage_trace_pc_guard.cc:28 main
+// CHECK-SANCOV: sanitizer_coverage_trace_pc_guard.cc:[[@LINE-16]] foo
+// CHECK-SANCOV-NEXT: sanitizer_coverage_trace_pc_guard.cc:[[@LINE-12]] main
 //
 // CHECK-NOCOV-NOT: SanitizerCoverage

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

elif config.tool_name == "tsan":
   tool_cflags = ["-fsanitize=thread"]
   tool_options = "TSAN_OPTIONS"
 elif config.tool_name == "msan":
   tool_cflags = ["-fsanitize=memory"]
   tool_options = "MSAN_OPTIONS"
 elif config.tool_name == "lsan":
   tool_cflags = ["-fsanitize=leak"]
   tool_options = "LSAN_OPTIONS"
+elif config.tool_name == "ubsan":
+  tool_cflags = ["-fsanitize=undefined"]
+  tool_options = "UBSAN_OPTIONS"
 else:
   lit_config.fatal("Unknown tool for sanitizer_common tests: %r" % config.tool_name)
 
 config.available_features.add(config.tool_name)
 
 if config.target_arch not in ['arm', 'armhf', 'aarch64']:
   config.available_features.add('stable-runtime')