Remove stable-runtime from many tests

[fmayer]

Summary

They pass on x86_64 host, arm64 host, and Android.

[fmayer]

fix halt-on-error

compiler-rt/test/hwasan/TestCases/Linux/aligned_alloc-alignment.cpp

 // RUN: %clangxx_hwasan -O0 %s -o %t
 // RUN: %env_hwasan_opts=allocator_may_return_null=0 not %run %t 2>&1 | FileCheck %s
 // RUN: %env_hwasan_opts=allocator_may_return_null=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NULL
 
 // UNSUPPORTED: android
 
-// REQUIRES: stable-runtime
-
 #include <stdio.h>
 #include <stdlib.h>
 
 extern void *aligned_alloc(size_t alignment, size_t size);
 
 int main() {
   void *p = aligned_alloc(17, 100);
   // CHECK: ERROR: HWAddressSanitizer: invalid alignment requested in aligned_alloc: 17

compiler-rt/test/hwasan/TestCases/Linux/pvalloc-overflow.cpp

 // RUN: %clangxx_hwasan -O0 %s -o %t
 // RUN: %env_hwasan_opts=allocator_may_return_null=0 not %run %t m1 2>&1 | FileCheck %s
 // RUN: %env_hwasan_opts=allocator_may_return_null=1     %run %t m1 2>&1 | FileCheck %s --check-prefix=CHECK-NULL
 // RUN: %env_hwasan_opts=allocator_may_return_null=0 not %run %t psm1 2>&1 | FileCheck %s
 // RUN: %env_hwasan_opts=allocator_may_return_null=1     %run %t psm1 2>&1 | FileCheck %s --check-prefix=CHECK-NULL
 
 // UNSUPPORTED: android
 
-// REQUIRES: stable-runtime
-
 // Checks that pvalloc overflows are caught. If the allocator is allowed to
 // return null, the errno should be set to ENOMEM.
 
 #include <assert.h>
 #include <errno.h>
 #include <malloc.h>
 #include <stdint.h>
 #include <string.h>

compiler-rt/test/hwasan/TestCases/Posix/posix_memalign-alignment.cpp

 // RUN: %clangxx_hwasan -O0 %s -o %t
 // RUN: %env_hwasan_opts=allocator_may_return_null=0 not %run %t 2>&1 | FileCheck %s
 // RUN: %env_hwasan_opts=allocator_may_return_null=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NULL
 
-// REQUIRES: stable-runtime
-
 #include <stdio.h>
 #include <stdlib.h>
 
 int main() {
   void *p = reinterpret_cast<void*>(42);
   int res = posix_memalign(&p, 17, 100);
   // CHECK: ERROR: HWAddressSanitizer: invalid alignment requested in posix_memalign: 17
   // CHECK: {{#0 0x.* in .*posix_memalign}}
   // CHECK: {{#1 0x.* in main .*posix_memalign-alignment.cpp:}}[[@LINE-3]]
   // CHECK: SUMMARY: HWAddressSanitizer: invalid-posix-memalign-alignment
 
   printf("pointer after failed posix_memalign: %zd\n", (size_t)p);
   // CHECK-NULL: pointer after failed posix_memalign: 42
 
   return 0;
 }

compiler-rt/test/hwasan/TestCases/allocator_returns_null.cpp

 // RUN:   | FileCheck %s --check-prefix=CHECK-nCRASH
 // RUN: %env_hwasan_opts=allocator_may_return_null=1 not %run %t new 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nCRASH-OOM
 // RUN: %env_hwasan_opts=allocator_may_return_null=0 not %run %t new-nothrow 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nnCRASH
 // RUN: %env_hwasan_opts=allocator_may_return_null=1     %run %t new-nothrow 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nnNULL
 
-// REQUIRES: stable-runtime
-
 // TODO(alekseyshl): Fix it.
 // UNSUPPORTED: android
 
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

compiler-rt/test/hwasan/TestCases/check-interface.cpp

 // RUN: %clangxx_hwasan -mllvm -hwasan-instrument-with-calls=1 -O0 %s -o %t
 // RUN: %clangxx_hwasan -mllvm -hwasan-instrument-with-calls=1 -O0 %s -o %t -fsanitize-recover=hwaddress
 
-// REQUIRES: stable-runtime
-
 // Utilizes all flavors of __hwasan_load/store interface functions to verify
 // that the instrumentation and the interface provided by HWASan do match.
 // In case of a discrepancy, this test fails to link.
 
 #include <sanitizer/hwasan_interface.h>
 
 #define F(T) void f_##T(T *a, T *b) { *a = *b; }
 

compiler-rt/test/hwasan/TestCases/deep-recursion.c

 // RUN: %clang_hwasan -O1 %s -o %t
 // RUN: %env_hwasan_opts=stack_history_size=1 not %run %t 2>&1 | FileCheck %s --check-prefix=D1
 // RUN: %env_hwasan_opts=stack_history_size=2 not %run %t 2>&1 | FileCheck %s --check-prefix=D2
 // RUN: %env_hwasan_opts=stack_history_size=3 not %run %t 2>&1 | FileCheck %s --check-prefix=D3
 // RUN: %env_hwasan_opts=stack_history_size=5 not %run %t 2>&1 | FileCheck %s --check-prefix=D5
 // RUN:                                       not %run %t 2>&1 | FileCheck %s --check-prefix=DEFAULT
 
 // Run the same tests as above, but using the __hwasan_add_frame_record libcall.
 // The output should be the exact same.
 // RUN: %clang_hwasan -O1 %s -o %t -mllvm -hwasan-record-stack-history=libcall
 // RUN: %env_hwasan_opts=stack_history_size=1 not %run %t 2>&1 | FileCheck %s --check-prefix=D1
 // RUN: %env_hwasan_opts=stack_history_size=2 not %run %t 2>&1 | FileCheck %s --check-prefix=D2
 // RUN: %env_hwasan_opts=stack_history_size=3 not %run %t 2>&1 | FileCheck %s --check-prefix=D3
 // RUN: %env_hwasan_opts=stack_history_size=5 not %run %t 2>&1 | FileCheck %s --check-prefix=D5
 // RUN:                                       not %run %t 2>&1 | FileCheck %s --check-prefix=DEFAULT
 
-// REQUIRES: stable-runtime
-
 // Stack histories are currently not recorded on x86.
 // XFAIL: target=x86_64{{.*}}
 
 #include <stdlib.h>
 // At least -O1 is needed for this function to not have a stack frame on
 // AArch64.
 void USE(void *x) { // pretend_to_do_something(void *x)
   __asm__ __volatile__("" : : "r" (x) : "memory");

compiler-rt/test/hwasan/TestCases/double-free.c

 // RUN: %clang_hwasan %s -o %t && not %run %t 2>&1 | FileCheck %s
 
-// REQUIRES: stable-runtime
-
 #include <stdlib.h>
 #include <stdio.h>
 #include <sanitizer/hwasan_interface.h>
 
 int main() {
   __hwasan_enable_allocator_tagging();
   char * volatile x = (char*)malloc(40);
   free(x);

compiler-rt/test/hwasan/TestCases/halt-on-error.cpp

 // RUN: %clangxx_hwasan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefixes=COMMON
 // RUN: %clangxx_hwasan -O0 %s -o %t && not %env_hwasan_opts=halt_on_error=1 %run %t 2>&1 | FileCheck %s --check-prefix=COMMON
 // RUN: %clangxx_hwasan -O0 %s -o %t && not %env_hwasan_opts=halt_on_error=0 %run %t 2>&1 | FileCheck %s --check-prefix=COMMON
 
 // RUN: %clangxx_hwasan -O0 %s -o %t -fsanitize-recover=hwaddress && not %run %t 2>&1 | FileCheck %s --check-prefix=COMMON
 // RUN: %clangxx_hwasan -O0 %s -o %t -fsanitize-recover=hwaddress && not %env_hwasan_opts=halt_on_error=1 %run %t 2>&1 | FileCheck %s --check-prefix=COMMON
 // RUN: %clangxx_hwasan -O0 %s -o %t -fsanitize-recover=hwaddress && not %env_hwasan_opts=halt_on_error=0 %run %t 2>&1 | FileCheck %s --check-prefixes=COMMON,RECOVER
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-instrument-with-calls=1 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=COMMON
 // RUN: %clangxx_hwasan -mllvm -hwasan-instrument-with-calls=1 -O0 %s -o %t && not %env_hwasan_opts=halt_on_error=1 %run %t 2>&1 | FileCheck %s --check-prefix=COMMON
 // RUN: %clangxx_hwasan -mllvm -hwasan-instrument-with-calls=1 -O0 %s -o %t && not %env_hwasan_opts=halt_on_error=0 %run %t 2>&1 | FileCheck %s --check-prefix=COMMON
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-instrument-with-calls=1 -O0 %s -o %t -fsanitize-recover=hwaddress && not %run %t 2>&1 | FileCheck %s --check-prefix=COMMON
 // RUN: %clangxx_hwasan -mllvm -hwasan-instrument-with-calls=1 -O0 %s -o %t -fsanitize-recover=hwaddress && not %env_hwasan_opts=halt_on_error=1 %run %t 2>&1 | FileCheck %s --check-prefix=COMMON
 // RUN: %clangxx_hwasan -mllvm -hwasan-instrument-with-calls=1 -O0 %s -o %t -fsanitize-recover=hwaddress && not %env_hwasan_opts=halt_on_error=0 %run %t 2>&1 | FileCheck %s --check-prefixes=COMMON,RECOVER
 
-// REQUIRES: stable-runtime
-
 #include <stdlib.h>
 #include <sanitizer/hwasan_interface.h>
 
 int main() {
   __hwasan_enable_allocator_tagging();
   int* volatile x = (int*)malloc(16);
   free(x);
   __hwasan_disable_allocator_tagging();
   return x[2] + ((char *)x)[6] + ((char *)x)[9];
   // COMMON: READ of size 4 at
   // When instrumenting with callbacks, main is actually #1, and #0 is __hwasan_load4.
-  // COMMON: #{{.*}} in main {{.*}}halt-on-error.cpp:27
+  // COMMON: #{{.*}} in main {{.*}}halt-on-error.cpp:[[@LINE-3]]
   // COMMON: SUMMARY: HWAddressSanitizer: tag-mismatch {{.*}} in
 
   // RECOVER: READ of size 1 at
-  // RECOVER: #{{.*}} in main {{.*}}halt-on-error.cpp:27
+  // RECOVER: #{{.*}} in main {{.*}}halt-on-error.cpp:[[@LINE-7]]
   // RECOVER: SUMMARY: HWAddressSanitizer: tag-mismatch {{.*}} in
 
   // RECOVER: READ of size 1 at
-  // RECOVER: #{{.*}} in main {{.*}}halt-on-error.cpp:27
+  // RECOVER: #{{.*}} in main {{.*}}halt-on-error.cpp:[[@LINE-11]]
   // RECOVER: SUMMARY: HWAddressSanitizer: tag-mismatch {{.*}} in
 
   // COMMON-NOT: tag-mismatch
 }

compiler-rt/test/hwasan/TestCases/heap-buffer-overflow-into.c

 // RUN: %clang_hwasan  %s -o %t
 // RUN: not %run %t 5 10 2>&1 | FileCheck %s --check-prefix=CHECK5
 // RUN: not %run %t 7 10 2>&1 | FileCheck %s --check-prefix=CHECK7
 // RUN: not %run %t 8 20 2>&1 | FileCheck %s --check-prefix=CHECK8
 // RUN: not %run %t 32 20 2>&1 | FileCheck %s --check-prefix=CHECK32
 
-// REQUIRES: stable-runtime
-
 #include <sanitizer/hwasan_interface.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 int main(int argc, char **argv) {
   __hwasan_enable_allocator_tagging();
   if (argc < 2) {

compiler-rt/test/hwasan/TestCases/heap-buffer-overflow.c

 // RUN: %clang_hwasan  %s -o %t
 // RUN: not %run %t 40 2>&1 | FileCheck %s --check-prefix=CHECK40
 // RUN: not %run %t 80 2>&1 | FileCheck %s --check-prefix=CHECK80
 // RUN: not %run %t -30 2>&1 | FileCheck %s --check-prefix=CHECKm30
 // RUN: not %run %t -30 1000000 2>&1 | FileCheck %s --check-prefix=CHECKMm30
 // RUN: not %run %t 1000000 1000000 2>&1 | FileCheck %s --check-prefix=CHECKM
 
 // Test OOB within the granule.
 // RUN: not %run %t 31 2>&1 | FileCheck %s --check-prefix=CHECK31
 // RUN: not %run %t 30 20 2>&1 | FileCheck %s --check-prefix=CHECK20
 
-// REQUIRES: stable-runtime
-
 #include <stdlib.h>
 #include <stdio.h>
 #include <sanitizer/hwasan_interface.h>
 
 static volatile char sink;
 
 int main(int argc, char **argv) {
   __hwasan_enable_allocator_tagging();

compiler-rt/test/hwasan/TestCases/hwasan-print-shadow.cpp

 // RUN: %clangxx_hwasan -DSIZE=16 -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
 
-// REQUIRES: stable-runtime
-
 #include <assert.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <sanitizer/hwasan_interface.h>
 
 int main() {
   char *alloc = (char *)malloc(4096);
 

compiler-rt/test/hwasan/TestCases/hwasan_symbolize.cpp

 // RUN: %clang_hwasan -Wl,--build-id -g %s -o %t
 // RUN: echo '[{"prefix": "'"$(realpath $(dirname %s))"'/", "link": "http://test.invalid/{file}:{line}"}]' > %t.linkify
 // RUN: %env_hwasan_opts=symbolize=0 not %run %t 2>&1 | hwasan_symbolize --html --symbols $(dirname %t) --index | FileCheck %s
 // RUN: %env_hwasan_opts=symbolize=0 not %run %t 2>&1 | hwasan_symbolize --html --linkify %t.linkify --symbols $(dirname %t) --index | FileCheck --check-prefixes=CHECK,LINKIFY %s
 // RUN: %env_hwasan_opts=symbolize=0 not %run %t 2>&1 | hwasan_symbolize --symbols $(dirname %t) --index | FileCheck %s
 
-// REQUIRES: stable-runtime
-
 #include <sanitizer/hwasan_interface.h>
 #include <stdlib.h>
 
 static volatile char sink;
 
 int main(int argc, char **argv) {
   __hwasan_enable_allocator_tagging();
   char *volatile x = (char *)malloc(10);

compiler-rt/test/hwasan/TestCases/libc_thread_freeres.c

 // RUN: %clang_hwasan %s -o %t && %env_hwasan_opts=random_tags=1 %run %t
-// REQUIRES: stable-runtime
 
 #include <pthread.h>
 #include <sanitizer/hwasan_interface.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 void *ThreadFn(void *) {

compiler-rt/test/hwasan/TestCases/longjmp.c

 // RUN: %clang_hwasan -O0 -DNEGATIVE %s -o %t && %run %t 2>&1
 // RUN: %clang_hwasan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
-// REQUIRES: stable-runtime, pointer-tagging
+// REQUIRES: pointer-tagging
 
 #include <stdlib.h>
 #include <assert.h>
 #include <sanitizer/hwasan_interface.h>
 
 __attribute__((noinline))
 int f(void *caller_frame) {
   int z = 0;

compiler-rt/test/hwasan/TestCases/many-threads-uaf.c

 // RUN: %clang_hwasan %s -o %t && not %env_hwasan_opts=verbose_threads=1 %run %t 2>&1 | FileCheck %s
-// REQUIRES: stable-runtime
 
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 
 #include <sanitizer/hwasan_interface.h>
 
 void *BoringThread(void *arg) {

compiler-rt/test/hwasan/TestCases/mem-intrinsics.c

 // RUN: %clang_hwasan %s -DTEST_NO=1 -mllvm -hwasan-instrument-mem-intrinsics -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=WRITE
 // RUN: %clang_hwasan %s -DTEST_NO=2 -mllvm -hwasan-instrument-mem-intrinsics -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=READ
 // RUN: %clang_hwasan %s -DTEST_NO=3 -mllvm -hwasan-instrument-mem-intrinsics -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=WRITE
 // RUN: %clang_hwasan %s -DTEST_NO=2 -mllvm -hwasan-instrument-mem-intrinsics -o %t && not %env_hwasan_opts=halt_on_error=0 %run %t 2>&1 | FileCheck %s --check-prefix=RECOVER
 
-// REQUIRES: stable-runtime, pointer-tagging
+// REQUIRES: pointer-tagging
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 int main() {
   char Q[16] __attribute__((aligned(256)));

compiler-rt/test/hwasan/TestCases/print-memory-usage.c

 // Tests __hwasan_print_memory_usage.
 // RUN: %clang_hwasan %s -o %t
 // RUN: ulimit -s 1000
 // RUN: %run %t 2>&1 | FileCheck %s
-// REQUIRES: stable-runtime
 
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <sanitizer/hwasan_interface.h>
 

compiler-rt/test/hwasan/TestCases/pthread_create.c

 // Tests that our thread initialization hooks work properly with random_tags=1.
 // RUN: %clang_hwasan %s -o %t
 // RUN: %env_hwasan_opts=random_tags=1 %run %t
-// REQUIRES: stable-runtime
 
 #include <pthread.h>
 
 #include <sanitizer/hwasan_interface.h>
 
 volatile int state;
 
 void *Increment(void *arg) {

compiler-rt/test/hwasan/TestCases/pthread_exit.c

 // Tests pthread_exit.
 // RUN: %clang_hwasan %s -o %t && %run %t
-// REQUIRES: stable-runtime
+
 #include <pthread.h>
 int main() { pthread_exit(NULL); }

compiler-rt/test/hwasan/TestCases/realloc-after-free.c

 // RUN: %clang_hwasan %s -o %t
 // RUN: not %run %t 50 2>&1 | FileCheck %s
 // RUN: not %run %t 40 2>&1 | FileCheck %s
 // RUN: not %run %t 30 2>&1 | FileCheck %s
 
-// REQUIRES: stable-runtime
-
 #include <stdlib.h>
 #include <stdio.h>
 #include <sanitizer/hwasan_interface.h>
 
 int main(int argc, char **argv) {
   __hwasan_enable_allocator_tagging();
   if (argc != 2) return 0;
   int realloc_size = atoi(argv[1]);

compiler-rt/test/hwasan/TestCases/rich-stack.c

 // Test how stack frames are reported (not fully implemented yet).
 // RUN: %clang_hwasan %s -o %t
 // RUN: not %run %t 3 2 -1 2>&1 | FileCheck %s --check-prefix=R321
-// REQUIRES: stable-runtime, pointer-tagging
+// REQUIRES: pointer-tagging
 
 #include <stdint.h>
 #include <stdlib.h>
 void USE(void *x) { // pretend_to_do_something(void *x)
   __asm__ __volatile__("" : : "r" (x) : "memory");
 }
 void USE2(void *a, void *b) { USE(a); USE(b); }
 void USE4(void *a, void *b, void *c, void *d) { USE2(a, b); USE2(c, d); }

compiler-rt/test/hwasan/TestCases/stack-history-length.c

 // RUN: %clang_hwasan -O1 %s -o %t
 // RUN: %env_hwasan_opts=stack_history_size=2048 not %run %t 2045 2>&1 | FileCheck %s --check-prefix=YES
 // RUN: %env_hwasan_opts=stack_history_size=2048 not %run %t 2047 2>&1 | FileCheck %s --check-prefix=NO
 
 // Run the same tests as above, but using the __hwasan_add_frame_record libcall.
 // The output should be the exact same.
 // RUN: %clang_hwasan -O1 %s -o %t -mllvm -hwasan-record-stack-history=libcall
 // RUN: %env_hwasan_opts=stack_history_size=2048 not %run %t 2045 2>&1 | FileCheck %s --check-prefix=YES
 // RUN: %env_hwasan_opts=stack_history_size=2048 not %run %t 2047 2>&1 | FileCheck %s --check-prefix=NO
 
-// REQUIRES: stable-runtime
-
 // Stack histories are currently not recorded on x86.
 // XFAIL: target=x86_64{{.*}}
 
 #include <stdlib.h>
 
 void USE(void *x) { // pretend_to_do_something(void *x)
   __asm__ __volatile__("" : : "r" (x) : "memory");
 }

compiler-rt/test/hwasan/TestCases/stack-oob.c

 // RUN: %clang_hwasan_oldrt -DSIZE=2 -O0 %s -o %t && %run %t
 // RUN: %clang_hwasan -DSIZE=2 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clang_hwasan_oldrt -DSIZE=15 -O0 %s -o %t && %run %t
 // RUN: %clang_hwasan -DSIZE=15 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clang_hwasan_oldrt -DSIZE=16 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clang_hwasan -DSIZE=16 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clang_hwasan -DSIZE=64 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clang_hwasan -DSIZE=0x1000 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
-// REQUIRES: stable-runtime
-
 // Stack short granules are currently not implemented on x86.
 // RISC-V target doesn't support oldrt
 // XFAIL: target={{(x86_64|riscv64).*}}
 
 #include <stdlib.h>
 #include <sanitizer/hwasan_interface.h>
 
 __attribute__((noinline))

compiler-rt/test/hwasan/TestCases/stack-uar.c

 // Tests use-after-return detection and reporting.
 // RUN: %clang_hwasan -g %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clang_hwasan -g %s -o %t && not %env_hwasan_opts=symbolize=0 %run %t 2>&1 | FileCheck %s --check-prefix=NOSYM
 
 // Run the same test as above, but using the __hwasan_add_frame_record libcall.
 // The output should be the exact same.
 // RUN: %clang_hwasan -g %s -o %t -mllvm -hwasan-record-stack-history=libcall && not %env_hwasan_opts=symbolize=0 %run %t 2>&1 | FileCheck %s --check-prefix=NOSYM
 
-// REQUIRES: stable-runtime
-
 // Stack histories currently are not recorded on x86.
 // XFAIL: target=x86_64{{.*}}
 
 void USE(void *x) { // pretend_to_do_something(void *x)
   __asm__ __volatile__("" : : "r" (x) : "memory");
 }
 
 __attribute__((noinline))

compiler-rt/test/hwasan/TestCases/stack-uas.c

 // Tests use-after-scope detection and reporting.
 // RUN: %clang_hwasan -mllvm -hwasan-use-after-scope -g %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clang_hwasan -mllvm -hwasan-use-after-scope -g %s -o %t && not %env_hwasan_opts=symbolize=0 %run %t 2>&1 | FileCheck %s --check-prefix=NOSYM
 
 // RUN: %clang_hwasan -mllvm -hwasan-use-after-scope=false -g %s -o %t && %run %t 2>&1
 // Use after scope is turned off by default.
 // RUN: %clang_hwasan -g %s -o %t && %run %t 2>&1
 
 // RUN: %clang_hwasan -mllvm -hwasan-use-after-scope -g %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 // Run the same test as above, but using the __hwasan_add_frame_record libcall.
 // The output should be the exact same.
 // RUN: %clang_hwasan -mllvm -hwasan-use-after-scope -mllvm -hwasan-record-stack-history=libcall -g %s -o %t && not %env_hwasan_opts=symbolize=0 %run %t 2>&1 | FileCheck %s --check-prefix=NOSYM
 
-// REQUIRES: stable-runtime
-
 // Stack histories currently are not recorded on x86.
 // XFAIL: target=x86_64{{.*}}
 
 void USE(void *x) { // pretend_to_do_something(void *x)
   __asm__ __volatile__(""
                        :
                        : "r"(x)
                        : "memory");

compiler-rt/test/hwasan/TestCases/tag-mismatch-border-address.c

 // Make sure we do not segfault when checking an address close to kLowMemEnd.
 // RUN: %clang_hwasan  %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK
 
-// REQUIRES: stable-runtime
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
 
 #include <sanitizer/hwasan_interface.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 
 static volatile char sink;

compiler-rt/test/hwasan/TestCases/tail-magic.c

 // Tests free_checks_tail_magic=1.
 // RUN: %clang_hwasan %s -o %t
 // RUN: %env_hwasan_opts=free_checks_tail_magic=0     %run %t
 // RUN: %env_hwasan_opts=free_checks_tail_magic=1 not %run %t 2>&1 | \
 // RUN:   FileCheck --check-prefixes=CHECK,CHECK-NONLASTGRANULE --strict-whitespace %s
 // RUN:                                           not %run %t 2>&1 | \
 // RUN:   FileCheck --check-prefixes=CHECK,CHECK-NONLASTGRANULE --strict-whitespace %s
 // RUN: %clang_hwasan -DLAST_GRANULE %s -o %t
 // RUN: not %run %t 2>&1 | \
 // RUN:   FileCheck --check-prefixes=CHECK,CHECK-LASTGRANULE --strict-whitespace %s
 
-// REQUIRES: stable-runtime
-
 #include <stdlib.h>
 #include <stdio.h>
 #include <sanitizer/hwasan_interface.h>
 
 static volatile char *sink;
 
 // Overwrite the tail in a non-hwasan function so that we don't detect the
 // stores as OOB.

compiler-rt/test/hwasan/TestCases/thread-uaf.c

 // Tests UAF detection where Allocate/Deallocate/Use
 // happen in separate threads.
 // RUN: %clang_hwasan %s -o %t && not %run %t 2>&1 | FileCheck %s
-// REQUIRES: stable-runtime
 
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 
 #include <sanitizer/hwasan_interface.h>
 
 char *volatile x;

compiler-rt/test/hwasan/TestCases/uaf_with_rb_distance.c

 // Checks how we print the developer note "hwasan_dev_note_heap_rb_distance".
 // RUN: %clang_hwasan %s -o %t
 // RUN: not %run %t 10 2>&1 | FileCheck %s --check-prefix=D10
 // RUN: not %run %t 42 2>&1 | FileCheck %s --check-prefix=D42
 
-// REQUIRES: stable-runtime
-
 #include <stdlib.h>
 #include <stdio.h>
 #include <sanitizer/hwasan_interface.h>
 
 
 void *p[100];
 
 int main(int argc, char **argv) {

compiler-rt/test/hwasan/TestCases/use-after-free-and-overflow.c

 // Checks that we do not print a faraway buffer overrun if we find a
 // use-after-free.
 // RUN: %clang_hwasan -O0 %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK
-// REQUIRES: stable-runtime
 
 #include <sanitizer/hwasan_interface.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #define ALLOC_ATTEMPTS 256
 
 char *Untag(void *x) {

compiler-rt/test/hwasan/TestCases/use-after-free.c

 // RUN: %clang_hwasan -O0 -DISREAD=1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK
 // RUN: %clang_hwasan -O1 -DISREAD=1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK
 // RUN: %clang_hwasan -O2 -DISREAD=1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK
 // RUN: %clang_hwasan -O3 -DISREAD=1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK
 
 // RUN: %clang_hwasan -O0 -DISREAD=0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK
 
-// REQUIRES: stable-runtime
-
 #include <stdlib.h>
 #include <stdio.h>
 #include <sanitizer/hwasan_interface.h>
 
 int main() {
   __hwasan_enable_allocator_tagging();
   char * volatile x = (char*)malloc(10);
   free(x);

compiler-rt/test/hwasan/TestCases/use-after-scope-capture.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope --std=c++11 -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 #include <functional>
 
 int main() {
   std::function<int()> f;
   {
     volatile int x = 0;
     f = [&x]() __attribute__((noinline)) {

compiler-rt/test/hwasan/TestCases/use-after-scope-dtor-order.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope -O1 %s -o %t && \
 // RUN:     not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 #include <stdio.h>
 
 struct IntHolder {
   explicit IntHolder(int *val = 0) : val_(val) {}
   __attribute__((noinline)) ~IntHolder() {
     printf("Value: %d\n", *val_); // BOOM
     // CHECK: ERROR: HWAddressSanitizer: tag-mismatch

compiler-rt/test/hwasan/TestCases/use-after-scope-goto.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope -O0 %s -o %t && %run %t
 
 // Function jumps over variable initialization making lifetime analysis
 // ambiguous. Asan should ignore such variable and program must not fail.
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 #include <stdlib.h>
 
 int *ptr;
 
 void f1(int cond) {
   if (cond)
     goto label;

compiler-rt/test/hwasan/TestCases/use-after-scope-if.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope -O1 %s -o %t && \
 // RUN:     not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 int *p;
 bool b = true;
 
 int main() {
   if (b) {
     int x[5];
     p = x + 1;
   }
   return *p; // BOOM
   // CHECK: ERROR: HWAddressSanitizer: tag-mismatch
   // CHECK:  #0 0x{{.*}} in main {{.*}}.cpp:[[@LINE-2]]
   // CHECK: Cause: stack tag-mismatch
 }

compiler-rt/test/hwasan/TestCases/use-after-scope-inlined.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // Test with "-O2" only to make sure inlining (leading to use-after-scope)
 // happens. "always_inline" is not enough, as Clang doesn't emit
 // llvm.lifetime intrinsics at -O0.
 //
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope -O2 %s -o %t && \
 // RUN:     not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 int *arr;
 __attribute__((always_inline)) void inlined(int arg) {
   int x[5];
   for (int i = 0; i < arg; i++)
     x[i] = i;
   arr = x;
 }
 
 int main(int argc, char *argv[]) {
   inlined(argc);
   return arr[argc - 1]; // BOOM
   // CHECK: ERROR: HWAddressSanitizer: tag-mismatch
   // CHECK: Cause: stack tag-mismatch
 }

compiler-rt/test/hwasan/TestCases/use-after-scope-loop-bug.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope -O1 %s -o %t && \
 // RUN:     not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 volatile int *p;
 
 int main() {
   // Variable goes in and out of scope.
   for (int i = 0; i < 3; ++i) {
     int x[3] = {i, i, i};
     p = x + i;
   }
   return *p; // BOOM
   // CHECK: ERROR: HWAddressSanitizer: tag-mismatch
   // CHECK:  #0 0x{{.*}} in main {{.*}}use-after-scope-loop-bug.cpp:[[@LINE-2]]
   // CHECK: Cause: stack tag-mismatch
 }

compiler-rt/test/hwasan/TestCases/use-after-scope-loop-removed.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope -O1 %s -o %t && \
 // RUN:     not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 #include <stdlib.h>
 
 int *p;
 
 int main() {
   for (int i = 0; i < 3; i++) {
     int x;
     p = &x;
   }
   return *p; // BOOM
   // CHECK: ERROR: HWAddressSanitizer: tag-mismatch
   // CHECK:  #0 0x{{.*}} in main {{.*}}use-after-scope-loop-removed.cpp:[[@LINE-2]]
   // CHECK: Cause: stack tag-mismatch
 }

compiler-rt/test/hwasan/TestCases/use-after-scope-loop.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope -O1 %s -o %t && \
 // RUN:     not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 int *p[3];
 
 int main() {
   for (int i = 0; i < 3; i++) {
     int x;
     p[i] = &x;
   }
   return **p; // BOOM
   // CHECK: ERROR: HWAddressSanitizer: tag-mismatch
   // CHECK: #0 0x{{.*}} in main {{.*}}.cpp:[[@LINE-2]]
   // CHECK: Cause: stack tag-mismatch
 }

compiler-rt/test/hwasan/TestCases/use-after-scope-nobug.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope -O1 %s -o %t && %run %t
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 #include <stdio.h>
 #include <stdlib.h>
 
 int *p[3];
 
 int main() {
   // Variable goes in and out of scope.
   for (int i = 0; i < 3; i++) {
     int x;
     p[i] = &x;
   }
   printf("PASSED\n");
   return 0;
 }

compiler-rt/test/hwasan/TestCases/use-after-scope-setjmp.cpp

 // RUN: %clangxx_hwasan  -mllvm -hwasan-use-stack-safety=0 -mllvm -hwasan-use-after-scope -O2 %s -o %t && \
 // RUN:     %run %t 2>&1
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 #include <sanitizer/hwasan_interface.h>
 #include <setjmp.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <sys/types.h>
 #include <unistd.h>

compiler-rt/test/hwasan/TestCases/use-after-scope-temp.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope -std=c++11 -O1 %s -o %t && \
 // RUN:     not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 struct IntHolder {
   int val;
 };
 
 const IntHolder *saved;
 
 __attribute__((noinline)) void save(const IntHolder &holder) {

compiler-rt/test/hwasan/TestCases/use-after-scope-temp2.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope -std=c++11 -O1 %s -o %t && \
 // RUN:     not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 struct IntHolder {
   __attribute__((noinline)) const IntHolder &Self() const {
     return *this;
   }
   int val = 3;
 };
 

compiler-rt/test/hwasan/TestCases/use-after-scope-types.cpp

 // RUN: not %run %t-noexcept 5 2>&1 | FileCheck %s
 // RUN: not %run %t-noexcept 6 2>&1 | FileCheck %s
 // RUN: not %run %t-noexcept 7 2>&1 | FileCheck %s
 // RUN: not %run %t-noexcept 8 2>&1 | FileCheck %s
 // RUN: not %run %t-noexcept 9 2>&1 | FileCheck %s
 // RUN: not %run %t-noexcept 10 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 #include <stdlib.h>
 #include <string>
 #include <vector>
 
 template <class T>
 struct Ptr {
   void Store(T *ptr) { t = ptr; }

compiler-rt/test/hwasan/TestCases/use-after-scope.cpp

 // This is the ASAN test of the same name ported to HWAsan.
 
 // RUN: %clangxx_hwasan -mllvm -hwasan-use-after-scope -O1 %s -o %t && \
 // RUN:     not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-target-arch || riscv64-target-arch
-// REQUIRES: stable-runtime
 
 volatile int *p = 0;
 
 int main() {
   {
     int x = 0;
     p = &x;
   }
   *p = 5; // BOOM
   // CHECK: ERROR: HWAddressSanitizer: tag-mismatch
   // CHECK:  #0 0x{{.*}} in main {{.*}}use-after-scope.cpp:[[@LINE-2]]
   // CHECK: Cause: stack tag-mismatch
   return 0;
 }

compiler-rt/test/hwasan/TestCases/verbose_threads.c

 // RUN: %clang_hwasan %s -o %t && %env_hwasan_opts=verbose_threads=1 %run %t 2>&1 | FileCheck %s --implicit-check-not=0x000000000000
-// REQUIRES: stable-runtime
 
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 
 #include <sanitizer/hwasan_interface.h>
 
 // CHECK: sizeof(Thread): [[#]] sizeof(HeapRB): [[#]] sizeof(StackRB): [[#]]