[LSAN][HWASAN] Run LSAN tests with HWASAN enabled

[kstoimenov]

Summary

A lot of tests are disabled by using UNSUPPORTED. The plan is to remove UNSUPPORTED for tests that are fixed.

[vitalybuka]

compiler-rt/test/lsan/TestCases/Darwin/dispatch.mm

58 ↗

(On Diff #492592)

These lines deserve a separate patch

compiler-rt/test/lsan/TestCases/Linux/cleanup_in_tsd_destructor.c

14

You can have multiple // UNSUPPORTED
Comment would be nice

[kstoimenov]

Made all unsupported.

[kstoimenov]

Only one unsupported.

[vitalybuka]

compiler-rt/test/lsan/CMakeLists.txt

30

why if (arch STREQUAL "x86_64")?
add FIXME if it's temporarily

[kstoimenov]

Added fixme.

[kstoimenov]

compiler-rt/test/lsan/CMakeLists.txt

30

Done.

[Enna1]

Hi, is there any plan to support hwasan leak check on Android? :)

[hans]

I think this broke Mac: https://green.lab.llvm.org/green/job/clang-stage1-RA/32739/

For example:

LeakSanitizer-HWAddressSanitizer-x86_64.TestCases/Darwin.dispatch.mm (from LeakSanitizer-HWAddressSanitizer-x86_64)

+ : 'RUN: at line 2'
+ /Users/buildslave/jenkins/workspace/clang-stage1-RA@2/clang-build/./bin/clang --driver-mode=g++ -O0 -arch x86_64 -stdlib=libc++ -mmacosx-version-min=10.10 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.1.sdk -gline-tables-only -fsanitize=hwaddress -fuse-ld=lld -fsanitize-hwaddress-experimental-aliasing -I/Users/buildslave/jenkins/workspace/clang-stage1-RA@2/llvm-project/compiler-rt/test/lsan/../ /Users/buildslave/jenkins/workspace/clang-stage1-RA@2/llvm-project/compiler-rt/test/lsan/TestCases/Darwin/dispatch.mm -DDISPATCH_ASYNC -o /Users/buildslave/jenkins/workspace/clang-stage1-RA@2/clang-build/tools/clang/runtime/compiler-rt-bins/test/lsan/X86_64HWAsanConfig/TestCases/Darwin/Output/dispatch.mm.tmp-async -framework Foundation
clang-17: error: unsupported option '-fsanitize=hwaddress' for target 'x86_64-apple-darwin19.5.0'
clang-17: error: invalid linker name in argument '-fuse-ld=lld'

[kstoimenov]

Added some previous fixes.

[kstoimenov]

Removed Apple as it is not supported by HWASAN.

[kstoimenov]

In D142676#4091533, @hans wrote:

I think this broke Mac: https://green.lab.llvm.org/green/job/clang-stage1-RA/32739/

For example:

LeakSanitizer-HWAddressSanitizer-x86_64.TestCases/Darwin.dispatch.mm (from LeakSanitizer-HWAddressSanitizer-x86_64)

+ : 'RUN: at line 2'
+ /Users/buildslave/jenkins/workspace/clang-stage1-RA@2/clang-build/./bin/clang --driver-mode=g++ -O0 -arch x86_64 -stdlib=libc++ -mmacosx-version-min=10.10 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.1.sdk -gline-tables-only -fsanitize=hwaddress -fuse-ld=lld -fsanitize-hwaddress-experimental-aliasing -I/Users/buildslave/jenkins/workspace/clang-stage1-RA@2/llvm-project/compiler-rt/test/lsan/../ /Users/buildslave/jenkins/workspace/clang-stage1-RA@2/llvm-project/compiler-rt/test/lsan/TestCases/Darwin/dispatch.mm -DDISPATCH_ASYNC -o /Users/buildslave/jenkins/workspace/clang-stage1-RA@2/clang-build/tools/clang/runtime/compiler-rt-bins/test/lsan/X86_64HWAsanConfig/TestCases/Darwin/Output/dispatch.mm.tmp-async -framework Foundation
clang-17: error: unsupported option '-fsanitize=hwaddress' for target 'x86_64-apple-darwin19.5.0'
clang-17: error: invalid linker name in argument '-fuse-ld=lld'

Looks like -fsanitize=hwaddress is not supported on Mac. I re-landed this with Mac disabled. Will keep an eye on your builds.

[kstoimenov]

In D142676#4089660, @Enna1 wrote:

Hi, is there any plan to support hwasan leak check on Android? :)

I am working on generic support, focusing on x86 for now. Theoretically it should work on ARM, but I haven't tried that. I am also not sure is there anything specific which needs to be done to make it work on Android on top of making it work on ARM. You can try flipping the cf.detect_leaks flag in compiler-rt/lib/hwasan/hwasan.cpp to see if it works :-)

[vitalybuka]

compiler-rt/test/lsan/CMakeLists.txt

32

We should make hwasan unsupported on lib/ level

compiler-rt/test/lsan/CMakeLists.txt

 set(LSAN_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 set(LSAN_TESTSUITES)
- 
 set(LSAN_TEST_ARCH ${LSAN_SUPPORTED_ARCH})
 if(APPLE)
   darwin_filter_host_archs(LSAN_SUPPORTED_ARCH LSAN_TEST_ARCH)
 endif()
 
 foreach(arch ${LSAN_TEST_ARCH})
   set(LSAN_TEST_TARGET_ARCH ${arch})
   string(TOLOWER "-${arch}" LSAN_TEST_CONFIG_SUFFIX)
   get_test_cc_for_arch(${arch} LSAN_TEST_TARGET_CC LSAN_TEST_TARGET_CFLAGS)
   string(TOUPPER ${arch} ARCH_UPPER_CASE)
+
   set(LSAN_LIT_TEST_MODE "Standalone")
   set(CONFIG_NAME ${ARCH_UPPER_CASE}LsanConfig)
-
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
     ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg.py)
   list(APPEND LSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
 
   set(CONFIG_NAME ${ARCH_UPPER_CASE}AsanConfig)
   set(LSAN_LIT_TEST_MODE "AddressSanitizer")
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
+    ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg.py)
+  list(APPEND LSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
 
+  # Fixme: make this generic 64 bit check once confirmed that at least
+  # ARM64 works.
+  if (arch STREQUAL "x86_64" AND NOT APPLE)
+    set(CONFIG_NAME ${ARCH_UPPER_CASE}HWAsanConfig)
+    set(LSAN_LIT_TEST_MODE "HWAddressSanitizer")
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
       ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg.py)
     list(APPEND LSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
+  endif()
 endforeach()
 
 set(LSAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
 if(NOT COMPILER_RT_STANDALONE_BUILD)
   list(APPEND LSAN_TEST_DEPS lsan asan)
 endif()
 add_lit_testsuite(check-lsan "Running the LeakSanitizer tests"
   ${LSAN_TESTSUITES}
   DEPENDS ${LSAN_TEST_DEPS})
 set_target_properties(check-lsan PROPERTIES FOLDER "Compiler-RT Misc")

compiler-rt/test/lsan/TestCases/Linux/cleanup_in_tsd_destructor.c

 // Regression test for thread lifetime tracking. Thread data should be
 // considered live during the thread's termination, at least until the
+
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
 // user-installed TSD destructors have finished running (since they may contain
 // additional cleanup tasks). LSan doesn't actually meet that goal 100%, but it
 // makes its best effort.
 // RUN: %clang_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=0:use_tls=1" %run %t
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=0:use_tls=0" not %run %t 2>&1 | FileCheck %s
 
 // Investigate why it does not fail with use_stack=0
 // UNSUPPORTED: arm-linux || armhf-linux
 
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "sanitizer/lsan_interface.h"
 #include "sanitizer_common/print_address.h"

compiler-rt/test/lsan/TestCases/Linux/disabler_in_tsd_destructor.c

 // Regression test. Disabler should not depend on TSD validity.
 // RUN: %clang_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=0:use_tls=1:use_ld_allocations=0" %run %t
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "sanitizer/lsan_interface.h"
 
 pthread_key_t key;

compiler-rt/test/lsan/TestCases/Linux/fork_threaded.cpp

 // Test that thread local data is handled correctly after forking without
 // exec(). In this test leak checking is initiated from a non-main thread.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 __thread void *thread_local_var;

compiler-rt/test/lsan/TestCases/Linux/guard-page.c

 // Check that if LSan finds that SP doesn't point into thread stack (e.g.
 // if swapcontext is used), LSan will not hit the guard page.
 // RUN: %clang_lsan %s -o %t && %run %t
+
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
 // Missing 'getcontext' and 'makecontext' on Android.
 // UNSUPPORTED: android
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <pthread.h>

compiler-rt/test/lsan/TestCases/Linux/libdl_deadlock.cpp

 // Regression test for a deadlock in leak detection,
 // where lsan would call dl_iterate_phdr while holding the allocator lock.
 // RUN: %clangxx_lsan %s -o %t && %run %t
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <link.h>
 #include <mutex>
 #include <stdlib.h>
 #include <thread>
 #include <unistd.h>
 
 std::mutex in, out;
 

compiler-rt/test/lsan/TestCases/Linux/log-path_test.cpp

 // RUN: %clangxx_lsan %s -o %t
+
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
 // The globs below do not work in the lit shell.
 
 // Regular run.
 // RUN: %env_lsan_opts="use_stacks=0" not %run %t > %t.out 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.out
 
 // Good log_path.
 // RUN: rm -f %t.log.* %t.log

compiler-rt/test/lsan/TestCases/Linux/use_tls_pthread_specific_dynamic.cpp

 // Test that dynamically allocated thread-specific storage is included in the root set.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 // Investigate why it does not fail with use_tls=0
 // UNSUPPORTED: arm-linux || armhf-linux
 
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"

compiler-rt/test/lsan/TestCases/Linux/use_tls_pthread_specific_static.cpp

 // Test that statically allocated thread-specific storage is included in the root set.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"
 
 // From glibc: this many keys are stored in the thread descriptor directly.
 const unsigned PTHREAD_KEY_2NDLEVEL_SIZE = 32;

compiler-rt/test/lsan/TestCases/Linux/use_tls_static.cpp

 // Test that statically allocated TLS space is included in the root set.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"
 
 __thread void *tls_var;
 
 int main() {
   tls_var = malloc(1337);
   print_address("Test alloc: ", 1, tls_var);
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

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

 // RUN: %clangxx_lsan -O2 %s -o %t && %run %t 2>&1 | FileCheck %s
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 extern "C"
 const char *__lsan_default_options() {
   // CHECK: Available flags for {{Leak|Address}}Sanitizer:
   return "verbosity=1 help=1";
 }
 
 int main() {
   return 0;
 }

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

 // Test for __lsan_disable() / __lsan_enable().
 // RUN: %clang_lsan %s -o %t
 // RUN: %env_lsan_opts=report_objects=1:use_registers=0:use_stacks=0:use_tls=0 not %run %t 2>&1 | FileCheck %s
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 // Investigate why it does not fail with use_tls=0
 // UNSUPPORTED: arm-linux || armhf-linux
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "sanitizer/lsan_interface.h"
 

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

 // Test for __lsan_do_leak_check(). We test it by making the leak check run
 // before global destructors, which also tests compatibility with HeapChecker's
+
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
 // "normal" mode (LSan runs in "strict" mode by default).
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-strict %s
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0 not %run %t foo 2>&1 | FileCheck --check-prefix=CHECK-normal %s
 
 // Investigate why LeakyGlobal leak does show
 // UNSUPPORTED: arm-linux || armhf-linux
 

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

 // A benchmark that executes malloc/free pairs in parallel.
 // Usage: ./a.out number_of_threads total_number_of_allocations
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts=use_ld_allocations=0 %run %t 5 1000000 2>&1
+
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
 #include <assert.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 
 int num_threads;
 int total_num_alloc;
 const int kMaxNumThreads = 5000;

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

 // Test for __lsan_ignore_object().
 // RUN: %clang_lsan %s -o %t
 // RUN: %env_lsan_opts=report_objects=1:use_registers=0:use_stacks=0:use_tls=0 not %run %t 2>&1 | FileCheck %s
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 // Investigate why it does not fail with use_stack=0
 // UNSUPPORTED: arm-linux || armhf-linux
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "sanitizer/lsan_interface.h"
 

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

 // Test for the leak_check_at_exit flag.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0 not %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-do
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0:leak_check_at_exit=0 not %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0:leak_check_at_exit=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <sanitizer/lsan_interface.h>
 
 int main(int argc, char *argv[]) {
   fprintf(stderr, "Test alloc: %p.\n", malloc(1337));
   if (argc > 1)
     __lsan_do_leak_check();
   return 0;
 }
 
 // CHECK-do: SUMMARY: {{(Leak|Address)}}Sanitizer:
 // CHECK-dont-NOT: SUMMARY: {{(Leak|Address)}}Sanitizer:

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

 // Test for disabling LSan at link-time.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0 %run %t
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0 not %run %t foo 2>&1 | FileCheck %s
+
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
 //
 // UNSUPPORTED: darwin
 
 #include <sanitizer/lsan_interface.h>
 
 int argc_copy;
 
 extern "C" {

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

 // RUN: %clang_lsan %s -o %t
 // RUN: %env_lsan_opts=use_stacks=0 not %run %t 2>&1 | FileCheck %s
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 /// Fails when only leak sanitizer is enabled
 // UNSUPPORTED: arm-linux, armhf-linux
 
 #include <stdio.h>
 #include <stdlib.h>
 
 // CHECK: {{Leak|Address}}Sanitizer: detected memory leaks
 // CHECK: {{Leak|Address}}Sanitizer: 1 byte(s) leaked in 1 allocation(s).
 
 int main() {
   // The behavior of malloc(0) is implementation-defined.
   char *p = malloc(0);
   fprintf(stderr, "zero: %p\n", p);
   p = 0;
 }

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

 // Test that lsan handles tls correctly for many threads
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 // On glibc, this requires the range returned by GetTLS to include
 // specific_1stblock and specific in `struct pthread`.
 // UNSUPPORTED: arm-linux, armhf-linux
 
 // TSD on NetBSD does not use TLS
 // UNSUPPORTED: target={{.*netbsd.*}}
 
 #include <assert.h>

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

 // Test that lsan handles tls correctly for many threads
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 // Patch r303906 did not fix all the problems.
 // UNSUPPORTED: arm-linux,armhf-linux
 
 #include <assert.h>
 #include <limits.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <unistd.h>

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

 // Regression test: pointers to self should not confuse LSan into thinking the
 // object is indirectly leaked. Only external pointers count.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=0" not %run %t 2>&1 | FileCheck %s
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"
 
 int main() {
   void *p = malloc(1337);
   *reinterpret_cast<void **>(p) = p;
   print_address("Test alloc: ", 1, p);
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

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
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 /// Fails when only leak sanitizer is enabled
 // UNSUPPORTED: arm-linux, armhf-linux
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 // CHECK: {{Leak|Address}}Sanitizer failed to allocate 0x100001 bytes

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
+
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
 //
 // UNSUPPORTED: darwin
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sanitizer/lsan_interface.h>

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

 // Test for __lsan_(un)register_root_region().
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0 %run %t
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0 not %run %t foo 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts=use_stacks=0:use_registers=0:use_root_regions=0 not %run %t 2>&1 | FileCheck %s
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <unistd.h>
 
 #include <sanitizer/lsan_interface.h>
 

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

 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts=use_registers=0:use_stacks=0 not %run %t 2>&1 | FileCheck %s
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "sanitizer/lsan_interface.h"
 
 extern "C"
 const char *__lsan_default_suppressions() {
   return "leak:*LSanTestLeakingFunc*";

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

 // RUN: %clangxx_lsan %s -o %t
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 // 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

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

 // We can't unwind stack if we're running coroutines on heap-allocated
 // memory. Make sure we don't report these leaks.
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts= %run %t 2>&1
 // RUN: %env_lsan_opts= not %run %t foo 2>&1 | FileCheck %s
 // Missing 'getcontext' and 'makecontext' on Android.
 // UNSUPPORTED: target={{(arm|aarch64|loongarch64|powerpc64).*}},android
 
 #include "sanitizer_common/sanitizer_ucontext.h"
 #include <stdio.h>

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

 // Test that fake stack (introduced by ASan's use-after-return mode) is included
 // in the root set.
 // RUN: %clangxx_lsan %s -O2 -o %t
 // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1 %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=0" not %run %t 2>&1 | FileCheck %s
 // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1 %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=1" %run %t 2>&1
 // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1 %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 // Investigate why it does not fail with use_stack=0
 // UNSUPPORTED: arm-linux || armhf-linux
 
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"
 
 int main() {

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

 // Test that initialized globals are included in the root set.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_globals=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_globals=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"
 
 void *data_var = (void *)1;
 
 int main() {
   data_var = malloc(1337);
   print_address("Test alloc: ", 1, data_var);
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

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

 // Test that uninitialized globals are included in the root set.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_globals=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_globals=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"
 
 void *bss_var;
 
 int main() {
   bss_var = malloc(1337);
   print_address("Test alloc: ", 1, bss_var);
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

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

 // Test that registers of running threads are included in the root set.
 // RUN: %clangxx_lsan -pthread %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include "sanitizer_common/print_address.h"
 #include <assert.h>
 #include <pthread.h>
 #include <sched.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 extern "C" void *registers_thread_func(void *arg) {

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

 // Test that registers of running threads are included in the root set.
 // RUN: %clangxx_lsan -pthread %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 // FIXME: Support more platforms.
 // REQUIRES: x86-target-arch && linux
 
 #include "sanitizer_common/print_address.h"
 #include <assert.h>
 #include <pthread.h>
 #include <sched.h>
 #include <stdio.h>

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

 // Test that stack of main thread is included in the root set.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"
 
 int main() {
   void *stack_var = malloc(1337);
   print_address("Test alloc: ", 1, stack_var);
   // Do not return from main to prevent the pointer from going out of scope.
   exit(0);
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

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

 // Test that stacks of non-main threads are included in the root set.
 // RUN: %clangxx_lsan -pthread %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <assert.h>
 #include <pthread.h>
 #include <sched.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"
 
 extern "C"

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

 // Test that unaligned pointers are detected correctly.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_unaligned=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_unaligned=1" %run %t 2>&1
 
+// Fixme: remove once test passes with hwasan
+// UNSUPPORTED: hwasan
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "sanitizer_common/print_address.h"
 
 void *arr[2];
 
 int main() {

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

lit_config.fatal(
       "No attribute %r in test configuration! You may need to run "
       "tests from your build directory or add this attribute "
       "to lit.site.cfg.py " % attr_name)
   return attr_value
 
 # Setup source root.
 config.test_source_root = os.path.dirname(__file__)
 
-# Choose between standalone and LSan+ASan modes.
+# Choose between standalone and LSan+(ASan|HWAsan) modes.
 lsan_lit_test_mode = get_required_attr(config, 'lsan_lit_test_mode')
+target_arch = getattr(config, 'target_arch', None)
 
 if lsan_lit_test_mode == "Standalone":
   config.name = "LeakSanitizer-Standalone"
   lsan_cflags = ["-fsanitize=leak"]
 elif lsan_lit_test_mode == "AddressSanitizer":
   config.name = "LeakSanitizer-AddressSanitizer"
   lsan_cflags = ["-fsanitize=address"]
   config.available_features.add('asan')
   if config.host_os == 'NetBSD':
     config.substitutions.insert(0, ('%run', config.netbsd_noaslr_prefix))
+elif lsan_lit_test_mode == "HWAddressSanitizer":
+  config.name = "LeakSanitizer-HWAddressSanitizer"
+  lsan_cflags = ["-fsanitize=hwaddress"]
+  if target_arch == "x86_64":
+    lsan_cflags = lsan_cflags + [ '-fsanitize-hwaddress-experimental-aliasing']
+  config.available_features.add('hwasan')
+  if config.host_os == 'NetBSD':
+    config.substitutions.insert(0, ('%run', config.netbsd_noaslr_prefix))
 else:
   lit_config.fatal("Unknown LSan test mode: %r" % lsan_lit_test_mode)
 config.name += config.name_suffix
 
 # Platform-specific default LSAN_OPTIONS for lit tests.
 default_common_opts_str = ':'.join(list(config.default_sanitizer_opts))
 default_lsan_opts = default_common_opts_str + ':detect_leaks=1'
 if config.host_os == 'Darwin':

 
 def build_invocation(compile_flags):
   return " " + " ".join([config.clang] + compile_flags) + " "
 
 config.substitutions.append( ("%clang ", build_invocation(clang_cflags)) )
 config.substitutions.append( ("%clangxx ", build_invocation(clang_cxxflags)) )
 config.substitutions.append( ("%clang_lsan ", build_invocation(clang_lsan_cflags)) )
 config.substitutions.append( ("%clangxx_lsan ", build_invocation(clang_lsan_cxxflags)) )
+config.substitutions.append( ("%clang_hwasan ", build_invocation(clang_lsan_cflags)) )
+config.substitutions.append( ("%clangxx_hwasan ", build_invocation(clang_lsan_cxxflags)) )
+
 
 # LeakSanitizer tests are currently supported on
 # Android{aarch64, x86, x86_64}, x86-64 Linux, PowerPC64 Linux, arm Linux, mips64 Linux, s390x Linux, loongarch64 Linux and x86_64 Darwin.
 supported_android = config.android and config.target_arch in ['x86_64', 'i386', 'aarch64'] and 'android-thread-properties-api' in config.available_features
 supported_linux = (not config.android) and config.host_os == 'Linux' and config.host_arch in ['aarch64', 'x86_64', 'ppc64', 'ppc64le', 'mips64', 'riscv64', 'arm', 'armhf', 'armv7l', 's390x', 'loongarch64']
 supported_darwin = config.host_os == 'Darwin' and config.target_arch in ['x86_64']
 supported_netbsd = config.host_os == 'NetBSD' and config.target_arch in ['x86_64', 'i386']
 if not (supported_android or supported_linux or supported_darwin or supported_netbsd):
   config.unsupported = True
 
 # Don't support Thumb due to broken fast unwinder
 if re.search('mthumb', config.target_cflags) is not None:
   config.unsupported = True
 
 config.suffixes = ['.c', '.cpp', '.mm']