[LSAN] Enable some tests which are passing as is in HWASAN.

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
 
+// 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 <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 

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

int main(int argc, char *argv[]) {
   void **p_in_tls = StoreToTLS(p);
   assert(*p_in_tls == p);
   print_address("Test alloc: ", 1, p);
   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:
+// CHECK: SUMMARY: {{.*}}Sanitizer:
 
 #else  // BUILD_DSO
 // A loadable module with a large thread local section, which would require
 // allocation of a new TLS storage chunk when loaded with dlopen(). We use it
 // to test the reachability of such chunks in LSan tests.
 
 // This must be large enough that it doesn't fit into preallocated static TLS
 // space (see STATIC_TLS_SURPLUS in glibc).
 __thread void *huge_thread_local_array[(1 << 20) / sizeof(void *)];
 
 extern "C" void **StoreToTLS(void *p) {
   huge_thread_local_array[0] = p;
   return &huge_thread_local_array[0];
 }
 #endif  // BUILD_DSO

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

int main() {
   res = pthread_setspecific(key, p);
   assert(res == 0);
   print_address("Test alloc: ", 1, p);
   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:
+// CHECK: SUMMARY: {{.*}}Sanitizer:

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"
 
 int main() {
   // Explicitly ignored object.
   void **p = malloc(sizeof(void *));
   // Transitively ignored object.
   *p = malloc(666);
   // Non-ignored object.
   volatile void *q = malloc(1337);
   fprintf(stderr, "Test alloc: %p.\n", p);
   __lsan_ignore_object(p);
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:.*]].
-// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: 1337 byte(s) leaked in 1 allocation(s)
+// CHECK: SUMMARY: {{.*}}Sanitizer: 1337 byte(s) leaked in 1 allocation(s)

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

int main() {
   // maxsize in primary allocator is always less than this (1 << 25).
   void *large_alloc = malloc(33554432);
   print_address("Test alloc: ", 1, large_alloc);
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (33554432 bytes)
-// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
+// CHECK: SUMMARY: {{.*}}Sanitizer:

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>
 
 int main(int argc, char *argv[]) {
   size_t size = getpagesize() * 2;
   void *p =
       mmap(0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
   assert(p);
   // Make half of the memory inaccessible. LSan must not crash trying to read it.
   assert(0 == mprotect((char *)p + size / 2, size / 2, PROT_NONE));
 
   __lsan_register_root_region(p, size);
   *((void **)p) = malloc(1337);
   fprintf(stderr, "Test alloc: %p.\n", p);
   if (argc > 1)
     __lsan_unregister_root_region(p, size);
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:.*]].
-// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: 1337 byte(s) leaked in 1 allocation(s)
+// CHECK: SUMMARY: {{.*}}Sanitizer: 1337 byte(s) leaked in 1 allocation(s)

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

 __attribute__((no_sanitize_address))
 void ConfirmPointerHasSurvived() {
   print_address("Value after LSan: ", 1, *pp);
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK-sanity: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
-// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
+// CHECK: SUMMARY: {{.*}}Sanitizer:
 // CHECK-sanity: Value after LSan: [[ADDR]]