[test][sanitizer] Prepare test for Internal Symbolizer

compiler-rt/test/CMakeLists.txt

option(COMPILER_RT_TEST_STANDALONE_BUILD_LIBS
   build are configured to use the same runtime library path."
   ON)
 pythonize_bool(COMPILER_RT_TEST_STANDALONE_BUILD_LIBS)
 
 pythonize_bool(LLVM_ENABLE_EXPENSIVE_CHECKS)
 
 pythonize_bool(ZLIB_FOUND)
 
+pythonize_bool(COMPILER_RT_ENABLE_INTERNAL_SYMBOLIZER)
+
 configure_compiler_rt_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.common.configured.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.common.configured)
 
 # BlocksRuntime (and most of builtins) testsuites are not yet ported to lit.
 # add_subdirectory(BlocksRuntime)
 
 set(SANITIZER_COMMON_LIT_TEST_DEPS)

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

 if re.match(r"^x86_64.*-linux", config.target_triple):
     config.available_features.add("x86_64-linux")
 
 config.available_features.add("host-byteorder-" + sys.byteorder + "-endian")
 
 if config.have_zlib:
     config.available_features.add("zlib")
 
+if config.have_internal_symbolizer:
+    config.available_features.add("internal_symbolizer")
+
 # Use ugly construction to explicitly prohibit "clang", "clang++" etc.
 # in RUN lines.
 config.substitutions.append(
     (
         " clang",
         """\n\n*** Do not use 'clangXXX' in tests,
      instead define '%clangXXX' substitution in lit config. ***\n\n""",
     )

compiler-rt/test/lit.common.configured.in

 elif config.android:
   if config.target_arch == "i386":
     set_default("target_suffix", "-i686-android")
   else:
     set_default("target_suffix", "-%s-android" % config.target_arch)
 else:
   set_default("target_suffix", "-%s" % config.target_arch)
 
+set_default("have_internal_symbolizer", @COMPILER_RT_ENABLE_INTERNAL_SYMBOLIZER_PYBOOL@)
 set_default("have_zlib", @ZLIB_FOUND_PYBOOL@)
 set_default("libcxx_used", "@LLVM_LIBCXX_USED@")
 
 # LLVM tools dir can be passed in lit parameters, so try to
 # apply substitution.
 config.llvm_tools_dir = lit_config.substitute(config.llvm_tools_dir)
 config.clang = lit_config.substitute(config.clang)
 config.compiler_rt_libdir = lit_config.substitute(config.compiler_rt_libdir)

compiler-rt/test/lsan/TestCases/realloc_too_big.c

 // RUN: %clang_lsan %s -o %t
-// RUN: %env_lsan_opts=allocator_may_return_null=1:max_allocation_size_mb=1:use_stacks=0 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_lsan_opts=allocator_may_return_null=1:max_allocation_size_mb=16:use_stacks=0 not %run %t 2>&1 | FileCheck %s
 
 /// Fails when only leak sanitizer is enabled
 // UNSUPPORTED: arm-linux, armhf-linux
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-// CHECK: {{.*}}Sanitizer failed to allocate 0x100001 bytes
+// CHECK: {{.*}}Sanitizer failed to allocate 0x1000001 bytes
 
 // CHECK: {{.*}}Sanitizer: detected memory leaks
 // CHECK: {{.*}}Sanitizer: 9 byte(s) leaked in 1 allocation(s).
 
 int main() {
   char *p = malloc(9);
   fprintf(stderr, "nine: %p\n", p);
-  assert(realloc(p, 0x100001) == NULL); // 1MiB+1
+  assert(realloc(p, 0x1000001) == NULL); // 16MiB+1
   p = 0;
 }

compiler-rt/test/lsan/TestCases/recoverable_leak_check.cpp

 // Test for on-demand leak checking.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0 %run %t foo 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0 %run %t 2>&1 | FileCheck %s
 
 // UNSUPPORTED: darwin
 
+// FIXME: Investigate.
+// XFAIL: internal_symbolizer && lsan-standalone && i386-linux
+
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sanitizer/lsan_interface.h>
 
 void *p;
 

compiler-rt/test/lsan/TestCases/suppressions_file.cpp

 // RUN: %clangxx_lsan %s -o %t
 
 // RUN: rm -f %t.supp
 // RUN: touch %t.supp
 // RUN: %push_to_device %t.supp %device_rundir/%t.supp
 // RUN: %env_lsan_opts="use_registers=0:use_stacks=0:suppressions='%device_rundir/%t.supp'" not %run %t 2>&1 | FileCheck %s --check-prefix=NOSUPP
 
 // RUN: echo "leak:*LSanTestLeakingFunc*" > %t.supp
 // RUN: %push_to_device  %t.supp %device_rundir/%t.supp
 // RUN: %env_lsan_opts="use_registers=0:use_stacks=0:suppressions='%device_rundir/%t.supp'" not %run %t 2>&1 | FileCheck %s
 //
 // RUN: echo "leak:%t" > %t.supp
 // RUN: %push_to_device  %t.supp %device_rundir/%t.supp
 // RUN: %env_lsan_opts="use_registers=0:use_stacks=0:suppressions='%device_rundir/%t.supp':symbolize=false" %run %t
 
+// FIXME: Investigate.
+// XFAIL: internal_symbolizer && lsan-standalone && i386-linux
+
 #include <stdio.h>
 #include <stdlib.h>
 
 void *LSanTestLeakingFunc() {
   void *p = malloc(666);
   fprintf(stderr, "Test alloc: %p.\n", p);
   return p;
 }

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

 // XFAIL: ubsan
 
 // THUMB starts background thead only for Asan.
 // XFAIL: target=thumb{{.*}} && !asan
 
 // https://github.com/google/sanitizers/issues/981
 // UNSUPPORTED: android-26
 
+// Symbolizer needs to allocated memory when reporting.
+// UNSUPPORTED: internal_symbolizer
+
 #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/max_allocation_size.cpp

 // RUN: %env_tool_opts=max_allocation_size_mb=2:allocator_may_return_null=0 \
 // RUN:   not %run %t strndup 2>&1 | FileCheck %s --check-prefix=CHECK-sCRASH
 // RUN: %env_tool_opts=max_allocation_size_mb=2:allocator_may_return_null=1 \
 // RUN:   %run %t strndup 2>&1 | FileCheck %s --check-prefix=CHECK-NULL
 
 // win32 is disabled due to failing errno tests.
 // UNSUPPORTED: ubsan, target={{.*windows-msvc.*}}
 
+// Symbolizer needs to allocated memory when reporting.
+// UNSUPPORTED: internal_symbolizer
+
 #include <assert.h>
 #include <errno.h>
 #include <limits>
 #include <new>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 

compiler-rt/test/ubsan/TestCases/TypeCheck/vptr-virtual-base.cpp

 // RUN: %clangxx -frtti -fsanitize=null,vptr -fno-sanitize-recover=vptr -g %s -O3 -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
+// FIXME: Investigate.
+// XFAIL: internal_symbolizer && (ubsan-tsan || ubsan-msan)
+
 // REQUIRES: shared_cxxabi
 // REQUIRES: cxxabi
 // UNSUPPORTED: target={{.*windows-msvc.*}}
 // Nested crash reported
 // UNSUPPORTED: target={{.*freebsd.*}}
 // FIXME: Itanium demangling isn't done for the type names on MinGW targets.
 // XFAIL: target={{.*windows-gnu.*}}
 

compiler-rt/test/ubsan/TestCases/TypeCheck/vptr.cpp

 // RUN: %env_ubsan_opts=halt_on_error=1:suppressions='"%t.supp"' %run %t fV
 // RUN: %env_ubsan_opts=halt_on_error=1:suppressions='"%t.supp"' %run %t cV
 // RUN: %env_ubsan_opts=halt_on_error=1:suppressions='"%t.supp"' %run %t oU
 // RUN: %env_ubsan_opts=halt_on_error=1:suppressions='"%t.supp"' %run %t dT
 
 // RUN: echo "vptr_check:S" > %t.loc-supp
 // RUN: %env_ubsan_opts=halt_on_error=1:suppressions='"%t.loc-supp"' not %run %t x- 2>&1 | FileCheck %s --check-prefix=CHECK-LOC-SUPPRESS
 
+// FIXME: Investigate.
+// XFAIL: internal_symbolizer && (ubsan-tsan || ubsan-msan)
+
 // REQUIRES: stable-runtime, cxxabi
 // UNSUPPORTED: target={{.*windows-msvc.*}}
 // Suppressions file not pushed to the device.
 // UNSUPPORTED: android
 // Compilation error
 // UNSUPPORTED: target={{.*openbsd.*}}
 // Compilation error
 // UNSUPPORTED: target={{.*freebsd.*}}