[DFSan] Fix overuse of REQUIRES: in tests.

[browneee]

Summary

Following suggestion on D140690.

[browneee]

Fix updated line numbers in test.

[MaskRay]

Looks great!

[browneee]

Fix other line number.

[browneee]

Abandon due to D140744 being submitted.

[MaskRay]

clang/lib/Driver/ToolChains/Linux.cpp

766

This change is still useful and worth submitting :)

clang/lib/Driver/ToolChains/Linux.cpp

SanitizerMask Linux::getSupportedSanitizers() const {
   Res |= SanitizerKind::PointerCompare;
   Res |= SanitizerKind::PointerSubtract;
   Res |= SanitizerKind::Fuzzer;
   Res |= SanitizerKind::FuzzerNoLink;
   Res |= SanitizerKind::KernelAddress;
   Res |= SanitizerKind::Memory;
   Res |= SanitizerKind::Vptr;
   Res |= SanitizerKind::SafeStack;
-  if (IsX86_64 || IsMIPS64 || IsAArch64)
+  if (IsX86_64)
     Res |= SanitizerKind::DataFlow;
   if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsArmArch || IsPowerPC64 ||
       IsRISCV64 || IsSystemZ || IsHexagon)
     Res |= SanitizerKind::Leak;
   if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64 || IsSystemZ ||
       IsLoongArch64)
     Res |= SanitizerKind::Thread;
   if (IsX86_64)

compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake

 endif()
 
 set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64} ${RISCV64}
     ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} ${S390X} ${SPARC} ${SPARCV9}
     ${HEXAGON} ${LOONGARCH64})
 set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X} ${SPARC} ${SPARCV9} ${HEXAGON}
     ${LOONGARCH64})
-set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
+set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64})
 
 if(ANDROID)
   set(OS_NAME "Android")
 else()
   set(OS_NAME "${CMAKE_SYSTEM_NAME}")
 endif()
 
 if(OS_NAME MATCHES "Linux")

compiler-rt/test/dfsan/atomic.cpp

 // RUN: %clangxx_dfsan %s -fno-exceptions -o %t && %run %t
 // RUN: %clangxx_dfsan -DORIGIN_TRACKING -mllvm -dfsan-track-origins=1 %s -fno-exceptions -o %t && %run %t
 //
-// REQUIRES: x86_64-target-arch
-//
 // Use -fno-exceptions to turn off exceptions to avoid instrumenting
 // __cxa_begin_catch, std::terminate and __gxx_personality_v0.
 //
 // TODO: Support builtin atomics. For example, https://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
 // DFSan instrumentation pass cannot identify builtin callsites yet.
 
 #include <sanitizer/dfsan_interface.h>
 

compiler-rt/test/dfsan/basic.c

 // RUN: %clang_dfsan %s -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 // Tests that labels are propagated through loads and stores.
 
 #include <sanitizer/dfsan_interface.h>
 #include <assert.h>
 
 int main(void) {
   int i = 1;

compiler-rt/test/dfsan/conditional_callbacks.c

 // RUN: %clang_dfsan -fno-sanitize=dataflow -O2 -fPIE -DCALLBACKS -c %s -o %t-callbacks.o
 // RUN: %clang_dfsan -fsanitize-ignorelist=%S/Inputs/flags_abilist.txt -O2 -mllvm -dfsan-conditional-callbacks %s %t-callbacks.o -o %t
 // RUN: %run %t FooBarBaz 2>&1 | FileCheck %s
 //
 // RUN: %clang_dfsan -fno-sanitize=dataflow -O2 -fPIE -DCALLBACKS -DORIGINS -c %s -o %t-callbacks-orig.o
 // RUN: %clang_dfsan -fsanitize-ignorelist=%S/Inputs/flags_abilist.txt -O2 -mllvm -dfsan-conditional-callbacks -mllvm -dfsan-track-origins=1 -DORIGINS %s %t-callbacks-orig.o -o %t-orig
 // RUN: %run %t-orig FooBarBaz 2>&1 | FileCheck %s
-//
-// REQUIRES: x86_64-target-arch
 
 // Tests that callbacks are inserted for conditionals when
 // -dfsan-conditional-callbacks is specified.
 
 #include <assert.h>
 #include <sanitizer/dfsan_interface.h>
 #include <stdio.h>
 #include <string.h>

compiler-rt/test/dfsan/conditional_callbacks_sig.c

 // RUN: %clang_dfsan -fno-sanitize=dataflow -O2 -fPIE -DCALLBACKS -c %s -o %t-callbacks.o
 // RUN: %clang_dfsan -fsanitize-ignorelist=%S/Inputs/flags_abilist.txt -O2 -mllvm -dfsan-conditional-callbacks %s %t-callbacks.o -o %t
 // RUN: %run %t FooBarBaz 2>&1 | FileCheck %s
-//
-// REQUIRES: x86_64-target-arch
 
 #include <assert.h>
 #include <sanitizer/dfsan_interface.h>
 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
 #include <unistd.h>

compiler-rt/test/dfsan/custom.cpp

 // RUN: %clang_dfsan %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t
 // RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES %s -o %t && %run %t
 // RUN: %clang_dfsan -DORIGIN_TRACKING -mllvm -dfsan-track-origins=1 -mllvm -dfsan-combine-pointer-labels-on-load=false -DSTRICT_DATA_DEPENDENCIES %s -o %t && %run %t
 // RUN: %clang_dfsan -DORIGIN_TRACKING -mllvm -dfsan-track-origins=1 -mllvm -dfsan-combine-pointer-labels-on-load=false %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t
 //
 // Tests custom implementations of various glibc functions.
-//
-// REQUIRES: x86_64-target-arch
 
 #pragma clang diagnostic ignored "-Wformat-extra-args"
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <arpa/inet.h>
 #include <assert.h>
 #include <fcntl.h>

compiler-rt/test/dfsan/dfsan_get_track_origins.c

 // RUN: %clang_dfsan -DTRACK_ORIGINS=2 -mllvm -dfsan-track-origins=2 %s -o %t && %run %t
 // RUN: %clang_dfsan -DTRACK_ORIGINS=1 -mllvm -dfsan-track-origins=1 %s -o %t && %run %t
 // RUN: %clang_dfsan -DTRACK_ORIGINS=0 %s -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <assert.h>
 
 int main(int argc, char *argv[]) {
   assert(dfsan_get_track_origins() == TRACK_ORIGINS);
 }

compiler-rt/test/dfsan/event_callbacks.c

 // RUN: %clang_dfsan -fno-sanitize=dataflow -O2 -fPIE -DCALLBACKS -c %s -o %t-callbacks.o
 // RUN: %clang_dfsan -O2 -mllvm -dfsan-event-callbacks %s %t-callbacks.o -o %t
 // RUN: %run %t FooBarBaz 2>&1 | FileCheck %s
-//
-// REQUIRES: x86_64-target-arch
 
 // Tests that callbacks are inserted for store events when
 // -dfsan-event-callbacks is specified.
 
 #include <assert.h>
 #include <sanitizer/dfsan_interface.h>
 #include <stdio.h>
 #include <string.h>

compiler-rt/test/dfsan/fast8labels.c

 // RUN: %clang_dfsan %s -o %t
 // RUN: %run %t
-//
-// REQUIRES: x86_64-target-arch
-//
+
 #include <sanitizer/dfsan_interface.h>
 
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>
 
 int foo(int a, int b) {
   return a + b;

compiler-rt/test/dfsan/flags.c

 // RUN: %clang_dfsan %s -fsanitize-ignorelist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && DFSAN_OPTIONS=warn_unimplemented=1 %run %t 2>&1 | FileCheck %s
 // RUN: %clang_dfsan %s -fsanitize-ignorelist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && DFSAN_OPTIONS=warn_unimplemented=0 %run %t 2>&1 | count 0
 // RUN: %clang_dfsan %s -fsanitize-ignorelist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && DFSAN_OPTIONS=warn_nonzero_labels=1 %run %t 2>&1 | FileCheck --check-prefix=CHECK-NONZERO %s
-//
-// REQUIRES: x86_64-target-arch
 
 // Tests that flags work correctly.
 
 #include <sanitizer/dfsan_interface.h>
 
 int f(int i) {
   return i;
 }

compiler-rt/test/dfsan/flush.c

 // Tests dfsan_flush().
 // RUN: %clang_dfsan %s -o %t && %run %t
 // RUN: %clang_dfsan -DORIGIN_TRACKING -mllvm -dfsan-track-origins=1 %s -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 #include <assert.h>
 #include <stdlib.h>
 
 int global;
 
 int main() {

compiler-rt/test/dfsan/fncall.c

 // RUN: %clang_dfsan %s -o %t && %run %t
 //
-// REQUIRES: x86_64-target-arch
-//
 // Tests that labels are propagated through function calls.
 
 #include <sanitizer/dfsan_interface.h>
 #include <assert.h>
 
 int f(int x) {
   int j = 2;
   dfsan_label j_label = 2;

compiler-rt/test/dfsan/force_zero.c

 // RUN: %clang_dfsan %s -fsanitize-ignorelist=%S/Inputs/flags_abilist.txt -DFORCE_ZERO_LABELS -o %t && %run %t
 // RUN: %clang_dfsan %s -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <assert.h>
 
 int function_to_force_zero(int i, int* out) {
   *out = i;
   return i;

compiler-rt/test/dfsan/fork.cpp

 // Test that chained origins are fork-safe.
 // Run a number of threads that create new chained origins, then fork
 // and verify that origin reads do not deadlock in the child process.
 //
 // RUN: %clangxx_dfsan %s -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 //
 // RUN: %clangxx_dfsan -mllvm -dfsan-track-origins=1 %s -o %t
 // RUN: DFSAN_OPTIONS=store_context_size=1000,origin_history_size=0,origin_history_per_stack_limit=0 %run %t 2>&1 | FileCheck %s
-//
-// REQUIRES: x86_64-target-arch
 
 #include <assert.h>
 #include <errno.h>
 #include <pthread.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/time.h>

compiler-rt/test/dfsan/gep.c

 // RUN: %clang_dfsan %s -mllvm -dfsan-combine-offset-labels-on-gep=false -Wno-error=int-conversion -o %t && %run %t
 // RUN: %clang_dfsan %s -DPROP_OFFSET_LABELS -Wno-error=int-conversion -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 // Tests that labels are propagated through GEP.
 
 #include <sanitizer/dfsan_interface.h>
 #include <assert.h>
 
 int main(void) {
   int i = 1;

compiler-rt/test/dfsan/interceptors.c

 // RUN: %clang_dfsan -mllvm -dfsan-combine-pointer-labels-on-load=false %s -o %t && %run %t
 // RUN: %clang_dfsan -DORIGIN_TRACKING -mllvm -dfsan-track-origins=1 -mllvm -dfsan-combine-pointer-labels-on-load=false %s -o %t && %run %t
 //
 // Tests custom implementations of various glibc functions.
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <assert.h>
 #include <malloc.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>

compiler-rt/test/dfsan/libatomic.c

 // RUN: %clang_dfsan -g3 -DDATA_BYTES=3 %s -fno-exceptions -latomic -o %t && %run %t
 // RUN: %clang_dfsan -g3 -DDATA_BYTES=3 -DORIGIN_TRACKING -mllvm -dfsan-track-origins=1 %s -fno-exceptions -latomic -o %t && %run %t
 // RUN: %clang_dfsan -g3 -DDATA_BYTES=32 %s -fno-exceptions -latomic -o %t && %run %t
 // RUN: %clang_dfsan -g3 -DDATA_BYTES=32 -DORIGIN_TRACKING -mllvm -dfsan-track-origins=1 %s -fno-exceptions -latomic -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 #include <assert.h>
 #include <sanitizer/dfsan_interface.h>
 #include <stdatomic.h>
 
 typedef struct __attribute((packed)) {
   uint8_t val[DATA_BYTES];
 } idata;

compiler-rt/test/dfsan/lookup_table.c

 // RUN: %clang_dfsan %s -mllvm -dfsan-combine-offset-labels-on-gep=false -mllvm -dfsan-combine-pointer-labels-on-load=false -mllvm -dfsan-combine-taint-lookup-table=remap_to_upper -DLOOKUP_TABLE -o %t && %run %t
 // RUN: %clang_dfsan %s -mllvm -dfsan-combine-offset-labels-on-gep=false -mllvm -dfsan-combine-pointer-labels-on-load=false -mllvm -dfsan-combine-taint-lookup-table=no_match -o %t && %run %t
 // RUN: %clang_dfsan %s -mllvm -dfsan-combine-offset-labels-on-gep=false -mllvm -dfsan-combine-pointer-labels-on-load=false -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 #include <assert.h>
 
 const char remap_to_upper[256] = {
     '.', '.', '.', '.', '.', '.', '.', '.', '.',
     '.', '.', '.', '.', '.', '.', '.', '.', '.',
     '.', '.', '.', '.', '.', '.', '.', '.', '.',

compiler-rt/test/dfsan/mmap_at_init.c

 // RUN: %clang_dfsan -fno-sanitize=dataflow -DCALLOC -c %s -o %t-calloc.o
 // RUN: %clang_dfsan %s %t-calloc.o -o %t
 // RUN: %run %t
 //
-// REQUIRES: x86_64-target-arch
-//
 // Tests that calling mmap() during during dfsan initialization works.
 
 #include <sanitizer/dfsan_interface.h>
 #include <sys/mman.h>
 #include <unistd.h>
 
 #ifdef CALLOC
 

compiler-rt/test/dfsan/origin_add_label.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 //
 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 -mllvm -dfsan-instrument-with-call-threshold=0 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 __attribute__((noinline)) uint64_t foo(uint64_t a, uint64_t b) { return a + b; }
 
 int main(int argc, char *argv[]) {
   uint64_t a = 10;
   uint64_t b = 20;

compiler-rt/test/dfsan/origin_branch.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 __attribute__((noinline)) uint64_t foo(uint64_t x, uint64_t y) { return x + y; }
 
 int main(int argc, char *argv[]) {
   uint64_t a = 10;
   uint64_t b = 20;

compiler-rt/test/dfsan/origin_disabled.c

 // RUN: %clang_dfsan -gmlt %s -o %t && %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 int main(int argc, char *argv[]) {
   uint64_t a = 10;
   dfsan_set_label(8, &a, sizeof(a));
   dfsan_print_origin_trace(&a, NULL);
 }
 
 // CHECK: DFSan: origin tracking is not enabled. Did you specify the -dfsan-track-origins=1 option?

compiler-rt/test/dfsan/origin_id_stack_trace.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 //
 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 -mllvm -dfsan-instrument-with-call-threshold=0 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 #include <stdio.h>
 #include <string.h>
 
 __attribute__((noinline)) int foo(int a, int b) { return a + b; }
 
 __attribute__((noinline)) void bar(int depth, void *addr, int size) {

compiler-rt/test/dfsan/origin_invalid.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-// 
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 int main(int argc, char *argv[]) {
   uint64_t a = 10;
   dfsan_set_label(1, &a, sizeof(a));
 
   // Manually compute origin address for &a.

compiler-rt/test/dfsan/origin_ld_lost.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 //
-// REQUIRES: x86_64-target-arch
-//
 // Test origin tracking can lost origins at 2-byte load with addr % 4 == 3.
 
 #include <sanitizer/dfsan_interface.h>
 
 __attribute__((noinline)) uint16_t foo(uint16_t a, uint16_t b) { return a + b; }
 
 int main(int argc, char *argv[]) {
   uint64_t a __attribute__((aligned(4))) = 1;

compiler-rt/test/dfsan/origin_ldst.c

 // RUN: %clang_dfsan -gmlt -DTEST32 -DALIGN=2 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 //
 // RUN: %clang_dfsan -gmlt -DALIGN=1 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 //
-// REQUIRES: x86_64-target-arch
-//
 // Test origin tracking is accurate in terms of partial store/load, and
 // different aligments. Do not test alignments that are not power of 2.
 // Compilers do not always allow this.
 
 #include <sanitizer/dfsan_interface.h>
 
 #ifdef TEST64
 typedef uint64_t FULL_TYPE;

compiler-rt/test/dfsan/origin_limit.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t
 //
 // RUN: %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 //
 // RUN: DFSAN_OPTIONS=origin_history_size=2 %run %t >%t.out 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK2 < %t.out
 //
 // RUN: DFSAN_OPTIONS=origin_history_size=0 %run %t >%t.out 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK0 < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <stdio.h>
 
 __attribute__((noinline)) int foo(int a, int b) { return a + b; }
 
 int main(int argc, char *argv[]) {

compiler-rt/test/dfsan/origin_memcpy.c

 // RUN: %clang_dfsan -gmlt -DOFFSET=0 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK0 < %t.out
 // 
 // RUN: %clang_dfsan -gmlt -DOFFSET=10 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK10 < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <string.h>
 
 int xx[10000];
 int yy[10000];
 volatile int idx = 30;

compiler-rt/test/dfsan/origin_memmove.c

 // RUN: %clang_dfsan -gmlt -DOFFSET=0 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK0 < %t.out
 //
 // RUN: %clang_dfsan -gmlt -DOFFSET=10 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK10 < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <string.h>
 
 int xx[10000];
 
 volatile int idx = 30;

compiler-rt/test/dfsan/origin_memset.c

 // RUN: %clang_dfsan -gmlt -DOFFSET=0 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK0 < %t.out
 // 
 // RUN: %clang_dfsan -gmlt -DOFFSET=10 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK10 < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <string.h>
 
 int xx[10000];
 
 volatile int idx = 30;

compiler-rt/test/dfsan/origin_of_first_taint.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t 2>&1 | FileCheck %s
-//
-// REQUIRES: x86_64-target-arch
 
 #include <assert.h>
 #include <sanitizer/dfsan_interface.h>
 #include <stdio.h>
 
 __attribute__((noinline)) uint64_t foo(uint64_t a, uint64_t b) { return a + b; }
 
 int main(int argc, char *argv[]) {

compiler-rt/test/dfsan/origin_overlapped.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 int main(int argc, char *argv[]) {
   char volatile z1;
   char volatile z2;
   dfsan_set_label(8, (void *)&z1, sizeof(z1));
   dfsan_set_label(16, (void *)&z2, sizeof(z2)); // overwritting the old origin.

compiler-rt/test/dfsan/origin_set_label.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 // 
 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 -mllvm -dfsan-instrument-with-call-threshold=0 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 __attribute__((noinline)) uint64_t foo(uint64_t a, uint64_t b) { return a + b; }
 
 int main(int argc, char *argv[]) {
   uint64_t a = 10;
   uint64_t b = 20;

compiler-rt/test/dfsan/origin_stack_trace.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 //
 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 -mllvm -dfsan-instrument-with-call-threshold=0 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <assert.h>
 #include <malloc.h>
 #include <sanitizer/dfsan_interface.h>
 #include <stdio.h>
 #include <string.h>
 
 #define NOINLINE __attribute__((noinline))

compiler-rt/test/dfsan/origin_track_ld.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=2 %s -o %t && \
 // RUN:     %run %t > %t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 __attribute__((noinline)) uint64_t foo(uint64_t a, uint64_t b) { return a + b; }
 
 int main(int argc, char *argv[]) {
   uint64_t a = 10;
   uint64_t b = 20;

compiler-rt/test/dfsan/origin_unaligned_memtrans.c

 // RUN: %clang_dfsan -gmlt -DOFFSET=0 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK0 < %t.out
 // 
 // RUN: %clang_dfsan -gmlt -DOFFSET=10 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK10 < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <string.h>
 
 char xx[10000];
 char yy[10000];
 volatile int idx = 30;

compiler-rt/test/dfsan/origin_untainted.c

 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 int main(int argc, char *argv[]) {
   uint64_t a = 10;
   dfsan_print_origin_trace(&a, NULL);
 }
 
 // CHECK: DFSan: no tainted value at {{.*}}

compiler-rt/test/dfsan/origin_with_sigactions.c

 //
 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 //
 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-instrument-with-call-threshold=0 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <assert.h>
 #include <signal.h>
 #include <string.h>
 #include <sys/types.h>
 #include <unistd.h>

compiler-rt/test/dfsan/origin_with_signals.cpp

 // Check that stores in signal handlers are not recorded in origin history.
 //
 // Origin tracking uses ChainedOriginDepot that is not async signal safe, so we
 // do not track origins inside signal handlers.
 //
 // RUN: %clangxx_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 //
 // RUN: %clangxx_dfsan -gmlt -mllvm -dfsan-instrument-with-call-threshold=0 -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <signal.h>
 #include <string.h>
 #include <sys/types.h>
 #include <unistd.h>
 

compiler-rt/test/dfsan/pair.cpp

 // RUN: %clangxx_dfsan %s -mllvm -dfsan-track-select-control-flow=false -mllvm -dfsan-combine-pointer-labels-on-load=false -O0 -DO0 -o %t && %run %t
 // RUN: %clangxx_dfsan %s -mllvm -dfsan-track-select-control-flow=false -mllvm -dfsan-combine-pointer-labels-on-load=false -O1 -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 #include <algorithm>
 #include <assert.h>
 #include <sanitizer/dfsan_interface.h>
 #include <utility>
 
 __attribute__((noinline))
 std::pair<int *, int>

compiler-rt/test/dfsan/propagate.c

 // RUN: %clang_dfsan %s -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 // Tests that labels are propagated through computation and that union labels
 // are properly created.
 
 #include <sanitizer/dfsan_interface.h>
 #include <assert.h>
 
 int main(void) {

compiler-rt/test/dfsan/pthread.c

 // RUN: %clang_dfsan %s -o %t && %run %t
 //
 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 //
 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 -mllvm -dfsan-instrument-with-call-threshold=0 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <assert.h>
 #include <pthread.h>
 #include <string.h>
 
 const int kNumThreads = 24;

compiler-rt/test/dfsan/reaches_function.c

 // RUN: %clang_dfsan -fno-sanitize=dataflow -O2 -fPIE -DCALLBACKS -c %s -o %t-callbacks.o
 // RUN: %clang_dfsan -gmlt -fsanitize-ignorelist=%S/Inputs/flags_abilist.txt -O2 -mllvm -dfsan-reaches-function-callbacks=1 %s %t-callbacks.o -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
 // RUN: %clang_dfsan -fno-sanitize=dataflow -O2 -fPIE -DCALLBACKS -DORIGIN_TRACKING -c %s -o %t-callbacks.o
 // RUN: %clang_dfsan -gmlt -fsanitize-ignorelist=%S/Inputs/flags_abilist.txt -O2 -mllvm -dfsan-reaches-function-callbacks=1 -mllvm -dfsan-track-origins=2 %s %t-callbacks.o -o %t
 // RUN: %run %t 2>&1 | FileCheck --check-prefix=CHECK-ORIGIN-TRACKING %s
 
-// REQUIRES: x86_64-target-arch
-
 // Tests that callbacks are inserted for reached functions when
 // -dfsan-reaches-function-callbacks is specified.
 
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>
 #include <sanitizer/dfsan_interface.h>
 

compiler-rt/test/dfsan/release_shadow_space.c

 // DFSAN_OPTIONS=no_huge_pages_for_shadow=false RUN: %clang_dfsan %s -o %t && %run %t
 // DFSAN_OPTIONS=no_huge_pages_for_shadow=true RUN: %clang_dfsan %s -o %t && %run %t
 // DFSAN_OPTIONS=no_huge_pages_for_shadow=false RUN: %clang_dfsan %s -DORIGIN_TRACKING -mllvm -dfsan-track-origins=1 -o %t && %run %t
 // DFSAN_OPTIONS=no_huge_pages_for_shadow=true RUN: %clang_dfsan %s -DORIGIN_TRACKING -mllvm -dfsan-track-origins=1 -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 #include <assert.h>
 #include <sanitizer/dfsan_interface.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/mman.h>
 #include <unistd.h>

compiler-rt/test/dfsan/sigaction.c

 // RUN: %clang_dfsan -DUSE_SIGNAL_ACTION -Wno-error=int-conversion %s -o %t && %run %t
 // RUN: %clang_dfsan -Wno-error=int-conversion %s -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <assert.h>
 #include <signal.h>
 #include <string.h>
 #include <sys/types.h>
 #include <unistd.h>

compiler-rt/test/dfsan/sigaction_stress_test.c

 // RUN: %clangxx_dfsan %s -o %t && %run %t
 // RUN: %clangxx_dfsan -mllvm -dfsan-track-origins=1 %s -o %t && %run %t
 // RUN: %clangxx_dfsan -mllvm -dfsan-track-origins=1 -mllvm -dfsan-instrument-with-call-threshold=0 %s -o %t && %run %t
 //
 // Test that the state of shadows from a sigaction handler are consistent.
-//
-// REQUIRES: x86_64-target-arch
 
 #include <signal.h>
 #include <stdarg.h>
 #include <sanitizer/dfsan_interface.h>
 #include <assert.h>
 #include <sys/time.h>
 #include <stdio.h>
 

compiler-rt/test/dfsan/stack_trace.c

 // RUN: %clang_dfsan -gmlt %s -o %t && %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
-//
-// REQUIRES: x86_64-target-arch
 
 #include <assert.h>
 #include <sanitizer/dfsan_interface.h>
 #include <stdio.h>
 #include <string.h>
 
 #define NOINLINE __attribute__((noinline))
 
int main(int argc, char *argv[]) {
   // CHECK: ==OUTPUT==
   // CHECK: #0 {{.*}} in main [[FILEPATH:.*]]/stack_trace.c:[[# @LINE - 5 ]]
   // CHECK: ==EOS==
 
   length = baz(8, buf, sizeof(buf));
   printf("==OUTPUT==\n%s==EOS==\n", buf);
 
   // CHECK: ==OUTPUT==
-  // CHECK: #0 {{.*}} in bar.dfsan [[FILEPATH]]/stack_trace.c:15
-  // CHECK-COUNT-8: #{{[1-9]+}} {{.*}} in bar.dfsan [[FILEPATH]]/stack_trace.c:18
-  // CHECK: #9 {{.*}} in baz.dfsan [[FILEPATH]]/stack_trace.c:22
+  // CHECK: #0 {{.*}} in bar.dfsan [[FILEPATH]]/stack_trace.c:11
+  // CHECK-COUNT-8: #{{[1-9]+}} {{.*}} in bar.dfsan [[FILEPATH]]/stack_trace.c:16
+  // CHECK: #9 {{.*}} in baz.dfsan [[FILEPATH]]/stack_trace.c:19
   // CHECK: #10 {{.*}} in main [[FILEPATH]]/stack_trace.c:[[# @LINE - 7 ]]
   // CHECK: ==EOS==
 
   char tinybuf[8];
   size_t same_length = baz(8, tinybuf, sizeof(tinybuf));
 
   printf("==TRUNCATED OUTPUT==\n%s==EOS==\n", tinybuf);
   // CHECK: ==TRUNCATED OUTPUT==

compiler-rt/test/dfsan/struct.c

 // RUN: %clang_dfsan %s -O1 -o %t && %run %t
 // RUN: %clang_dfsan %s -O0 -DO0 -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 #include <assert.h>
 #include <sanitizer/dfsan_interface.h>
 
 typedef struct Pair {
   int i;
   char *ptr;
 } Pair;

compiler-rt/test/dfsan/threaded_flush.c

 // Tests that doing dfsan_flush() while another thread is executing doesn't
 // segfault.
 // RUN: %clang_dfsan %s -o %t && %run %t
-//
-// REQUIRES: x86_64-target-arch
 
 #include <assert.h>
 #include <pthread.h>
 #include <sanitizer/dfsan_interface.h>
 #include <stdlib.h>
 
 static unsigned char GlobalBuf[4096];
 static int ShutDownThread;

compiler-rt/test/dfsan/trace-cmp.c

 // Checks that dfsan works with trace-cmp instrumentation, even if some hooks
 // are not defined (relies on week hooks implemented in dfsan).
 //
 // RUN: %clang_dfsan -fsanitize-coverage=trace-pc-guard,pc-table,func,trace-cmp %s -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
-//
-// REQUIRES: x86_64-target-arch
 
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 
 #include <sanitizer/dfsan_interface.h>
 
 uint32_t a4, b4;

compiler-rt/test/dfsan/vararg.c

 // RUN: %clang_dfsan %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 // RUN: %run %t foo
-//
-// REQUIRES: x86_64-target-arch
 
 #include <stdio.h>
 
 int do_nothing(const char *format, ...) {
   return 0;
 }
 
 int main(int argc, char **argv) {

compiler-rt/test/dfsan/write_callback.c

 // RUN: %clang_dfsan %s -o %t && %run %t | FileCheck %s
-//
-// REQUIRES: x86_64-target-arch
 
 // Tests that the custom implementation of write() does writes with or without
 // a callback set using dfsan_set_write_callback().
 // REQUIRES: stable-runtime
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <assert.h>