[RISC-V][HWASAN] Adjust lit test support for RISC-V HWASAN feature

[smd]

Summary

[10/11] patch series to port HWASAN for riscv64

Depends On D131575

[craig.topper]

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

18

Why is there an x86 change in here?

[smd]

Addressing comments

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

18

Fixed, thanks

[smd]

With proper fixes to Linux kernel now more tests should work

[vitalybuka]

if

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

6

I am not sure if I understand pointer-tagging and stable-runtime in context of hwasan.
I hope to setup aarch64 buildbot for HWASAN soon, maybe I'll cleanup those features
We don't want to list of archs in half of the tests explicitly

[smd]

Introduce some new tests

[smd]

Moving tests to previous patches

[smd]

@vitalybuka
After all the adjustments and supporting globals I have this picture:

Failed Tests (3):
  HWAddressSanitizer-riscv64 :: TestCases/stack-oob.c
  HWAddressSanitizer-riscv64 :: TestCases/try-catch.cpp
  HWAddressSanitizer-riscv64 :: TestCases/exported-tagged-global.c

The first two fail since risc-v doesn't have oldrt support and the last one fails due to aarch64 specific option(--aarch64-enable-global-isel-at-O=1).
Do you have any ideas how we should handle this? I.e. split those tests or just mark them as XFAIL and call it a day?

Thanks

[smd]

Updating tests

compiler-rt/test/hwasan/TestCases/Linux/atfork.cpp

 // RUN: %clang_hwasan -O0 %s -o %t && %run %t 2>&1
 
-// REQUIRES: aarch64-target-arch || x86_64-target-arch
+// REQUIRES: aarch64-target-arch || x86_64-target-arch || riscv64-target-arch
 // REQUIRES: pointer-tagging
 
+// For now RISC-V doesn't support tagging global variables
+// XFAIL: riscv64-target-arch
+
 #include <assert.h>
 #include <pthread.h>
 #include <sanitizer/hwasan_interface.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>

compiler-rt/test/hwasan/TestCases/Linux/create-thread-stress.cpp

 // Stress test for https://reviews.llvm.org/D101881
 // RUN: %clangxx_hwasan -DREUSE=0 %s -pthread -O2 -o %t && %run %t 2>&1
 // RUN: %clangxx_hwasan -DREUSE=1 %s -pthread -O2 -o %t_reuse && %run %t_reuse 2>&1
 
+// For now RISC-V doesn't support tagging global variables
+// XFAIL: riscv64-target-arch
+
 #include <thread>
 #include <vector>
 
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <stdio.h>

compiler-rt/test/hwasan/TestCases/Linux/vfork.c

 // https://github.com/google/sanitizers/issues/925
 // RUN: %clang_hwasan -O0 %s -o %t && %run %t 2>&1
 
-// REQUIRES: aarch64-target-arch || x86_64-target-arch
+// REQUIRES: aarch64-target-arch || x86_64-target-arch || riscv64-target-arch
 // REQUIRES: pointer-tagging
 
 #include <assert.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <sanitizer/hwasan_interface.h>

compiler-rt/test/hwasan/TestCases/exported-tagged-global.c

 // RUN: %clang_hwasan %s -o %t
 // RUN: %run %t
 // RUN: %clang_hwasan -O1 %s -o %t
 // RUN: %run %t
 // RUN: %clang_hwasan -O1 -mllvm --aarch64-enable-global-isel-at-O=1 %s -o %t
 // RUN: %run %t
-// REQUIRES: aarch64-target-arch
+// REQUIRES: aarch64-target-arch || riscv64-target-arch
+
+// For now RISC-V doesn't support tagging global variables
+// XFAIL: riscv64-target-arch
 
 static int global;
 
 __attribute__((optnone)) int *address_of_global() { return &global; }
 
 int main(int argc, char **argv) {
   int *global_address = address_of_global();
   *global_address = 13;
   return 0;
 }

compiler-rt/test/hwasan/TestCases/global-with-reduction.c

 // RUN: %clang_hwasan -DUSE_NOSANITIZE %s -o %t && %run %t 0
 // RUN: %clang_hwasan -DUSE_NOSANITIZE %s -o %t && %run %t 1
 // RUN: %clang_hwasan -DUSE_NOSANITIZE %s -o %t -fno-pic && %run %t 1
 // RUN: %clang_hwasan -DUSE_NOSANITIZE %s -o %t -O2 && %run %t 1
 // RUN: %clang_hwasan -DUSE_NOSANITIZE %s -o %t -fno-pic -O2 && %run %t 1
 
 // REQUIRES: pointer-tagging
 
+// For now RISC-V doesn't support tagging global variables
+// XFAIL: riscv64-target-arch
+
 #include <stdlib.h>
 
 // GlobalOpt may replace the current GV with a new boolean-typed GV. Previously,
 // this resulted in the "nosanitize" getting dropped because while the data/code
 // references to the GV were updated, the old metadata references weren't.
 int* f() {
 #ifdef USE_NOSANITIZE
 __attribute__((no_sanitize("hwaddress"))) static int x = 1;

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

 // RUN: %clang_hwasan -DUSE_NOSANITIZE %s -o %t && %run %t 0
 // RUN: %clang_hwasan -DUSE_NOSANITIZE %s -o %t && %run %t 1
 // RUN: %clang_hwasan -DUSE_NOSANITIZE %s -o %t -fno-pic && %run %t 1
 // RUN: %clang_hwasan -DUSE_NOSANITIZE %s -o %t -O2 && %run %t 1
 // RUN: %clang_hwasan -DUSE_NOSANITIZE %s -o %t -fno-pic -O2 && %run %t 1
 
 // REQUIRES: pointer-tagging
 
+// For now RISC-V doesn't support tagging global variables
+// XFAIL: riscv64-target-arch
+
 #include <stdlib.h>
 
 int a = 1;
 #ifdef USE_NOSANITIZE
 __attribute__((no_sanitize("hwaddress"))) int x = 1;
 #else // USE_NOSANITIZE
 int x = 1;
 #endif // USE_NOSANITIZE

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
 
+// For now RISC-V doesn't support tagging global variables
+// XFAIL: riscv64-target-arch
+
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 
 #include <sanitizer/hwasan_interface.h>
 
 void *BoringThread(void *arg) {
   char * volatile x = (char*)malloc(10);

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
 
+// For now RISC-V doesn't support tagging global variables
+// XFAIL: riscv64-target-arch
+
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <sanitizer/hwasan_interface.h>
 
 int state;

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
 
+// For now RISC-V doesn't support tagging global variables
+// XFAIL: riscv64-target-arch
+
 #include <pthread.h>
 
 #include <sanitizer/hwasan_interface.h>
 
 volatile int state;
 
 void *Increment(void *arg) {
   ++state;

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: x86_64
-
 void USE(void *x) { // pretend_to_do_something(void *x)
   __asm__ __volatile__(""
                        :
                        : "r"(x)
                        : "memory");
 }
 
 __attribute__((noinline)) void Unrelated1() {
   int A[2];
   USE(&A[0]);
 }
 __attribute__((noinline)) void Unrelated2() {
   int BB[3];
   USE(&BB[0]);
 }
 __attribute__((noinline)) void Unrelated3() {
   int CCC[4];
   USE(&CCC[0]);
 }
 
 __attribute__((noinline)) char buggy() {
   char *volatile p;
   {
-    char zzz[0x1000];
+    char zzz[0x1000] = {};
     p = zzz;
   }
   return *p;
 }
 
 int main() {
   Unrelated1();
   Unrelated2();

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
+// 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;
 extern void *__hwasan_shadow_memory_dynamic_address;

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
 
+// For now RISC-V doesn't support tagging global variables
+// XFAIL: riscv64-target-arch
+
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 
 #include <sanitizer/hwasan_interface.h>
 
 char *volatile x;
 int state;

compiler-rt/test/hwasan/TestCases/try-catch.cpp

 // This test is broken with shared libstdc++ / libc++ on Android.
 // RUN: %clangxx_hwasan -static-libstdc++ %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=GOOD
 // RUN: %clangxx_hwasan -static-libstdc++ -DNO_SANITIZE_F %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=GOOD
 // RUN: %clangxx_hwasan_oldrt -static-libstdc++ %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=GOOD
 // RUN: %clangxx_hwasan_oldrt -static-libstdc++ %s -mllvm -hwasan-instrument-landing-pads=0 -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=BAD
 
 // C++ tests on x86_64 require instrumented libc++/libstdc++.
-// REQUIRES: aarch64-target-arch
+// REQUIRES: aarch64-target-arch || riscv64-target-arch
 
 #include <stdexcept>
 #include <cstdio>
 
 static void optimization_barrier(void* arg) {
   asm volatile("" : : "r"(arg) : "memory");
 }
 

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
+// REQUIRES: aarch64-target-arch || riscv64-target-arch
 // REQUIRES: stable-runtime
 
 #include <functional>
 
 int main() {
   std::function<int()> f;
   {
     int x = 0;

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
+// 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

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
+// REQUIRES: aarch64-target-arch || riscv64-target-arch
 // REQUIRES: stable-runtime
 
 #include <stdlib.h>
 
 int *ptr;
 
 void f1(int cond) {
   if (cond)

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
+// 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
+// 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
+// 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
+// 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
+// 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
+// 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
+// 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>

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
+// REQUIRES: aarch64-target-arch || riscv64-target-arch
 // REQUIRES: stable-runtime
 
 struct IntHolder {
   int val;
 };
 
 const IntHolder *saved;
 

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
+// 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 4 2>&1 | FileCheck %s
 // 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
+// REQUIRES: aarch64-target-arch || riscv64-target-arch
 // REQUIRES: stable-runtime
 
 #include <stdlib.h>
 #include <string>
 #include <vector>
 
 template <class T>
 struct 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
+// 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;
 }