[asan] Properly mark or disable tests that only work with shadow scale of 3

[waltl]

Change approach to only override shadow scale in compiler_rt

[waltl]

Minor cleanup.

[waltl]

Replace "UNSUPPORTED: custom-shadow-scale" with "REQUIRED: shadow-scale-3"

[vitalybuka]

I hope we are going to try to remove some "REQUIRES: shadow-scale-3" by updating test later

compiler-rt/lib/asan/tests/asan_asm_test.cc

 //===-- asan_asm_test.cc --------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 //===----------------------------------------------------------------------===//
 #include "asan_test_utils.h"
 
-#if defined(__linux__)
+#if defined(__linux__) &&                                                      \
+    (!defined(ASAN_SHADOW_SCALE) || ASAN_SHADOW_SCALE == 3)
 
 // Assembly instrumentation is broken on x86 Android (x86 + PIC + shared runtime
 // library). See https://github.com/google/sanitizers/issues/353
 #if defined(__x86_64__) ||                                                     \
     (defined(__i386__) && defined(__SSE2__) && !defined(__ANDROID__))
 
 #include <emmintrin.h>
 

compiler-rt/lib/asan/tests/asan_interface_test.cc

 }
 
 TEST(AddressSanitizerInterface, DeathCallbackTest) {
   __asan_set_death_callback(MyDeathCallback);
   EXPECT_DEATH(DoDoubleFree(), "MyDeathCallback");
   __asan_set_death_callback(NULL);
 }
 
-static const char* kUseAfterPoisonErrorMessage = "use-after-poison";
-
 #define GOOD_ACCESS(ptr, offset)  \
     EXPECT_FALSE(__asan_address_is_poisoned(ptr + offset))
 
 #define BAD_ACCESS(ptr, offset) \
     EXPECT_TRUE(__asan_address_is_poisoned(ptr + offset))
 
+#if !defined(ASAN_SHADOW_SCALE) || ASAN_SHADOW_SCALE == 3
+static const char* kUseAfterPoisonErrorMessage = "use-after-poison";
+
 TEST(AddressSanitizerInterface, SimplePoisonMemoryRegionTest) {
   char *array = Ident((char*)malloc(120));
   // poison array[40..80)
   __asan_poison_memory_region(array + 40, 40);
   GOOD_ACCESS(array, 39);
   GOOD_ACCESS(array, 80);
   BAD_ACCESS(array, 40);
   BAD_ACCESS(array, 60);
TEST(AddressSanitizerInterface, OverlappingPoisonMemoryRegionTest) {
   __asan_unpoison_memory_region(array + 24, 72);
   BAD_ACCESS(array, 23);
   GOOD_ACCESS(array, 24);
   GOOD_ACCESS(array, 60);
   GOOD_ACCESS(array, 95);
   BAD_ACCESS(array, 96);
   free(array);
 }
+#endif
 
 TEST(AddressSanitizerInterface, PushAndPopWithPoisoningTest) {
   // Vector of capacity 20
   char *vec = Ident((char*)malloc(20));
   __asan_poison_memory_region(vec, 20);
   for (size_t i = 0; i < 7; i++) {
     // Simulate push_back.
     __asan_unpoison_memory_region(vec + i, 1);
     GOOD_ACCESS(vec, i);
     BAD_ACCESS(vec, i + 1);
   }
   for (size_t i = 7; i > 0; i--) {
     // Simulate pop_back.
     __asan_poison_memory_region(vec + i - 1, 1);
     BAD_ACCESS(vec, i - 1);
     if (i > 1) GOOD_ACCESS(vec, i - 2);
   }
   free(vec);
 }
 
+#if !defined(ASAN_SHADOW_SCALE) || ASAN_SHADOW_SCALE == 3
 // Make sure that each aligned block of size "2^granularity" doesn't have
 // "true" value before "false" value.
 static void MakeShadowValid(bool *shadow, int length, int granularity) {
   bool can_be_poisoned = true;
   for (int i = length - 1; i >= 0; i--) {
     if (!shadow[i])
       can_be_poisoned = false;
     if (!can_be_poisoned)
for (size_t s1 = 1; l1 + s1 <= kSize; s1++) {
             ASSERT_EQ(expected[i], __asan_address_is_poisoned(arr + i));
           }
         }
       }
     }
   }
   free(arr);
 }
+#endif
 
 TEST(AddressSanitizerInterface, GlobalRedzones) {
   GOOD_ACCESS(glob1, 1 - 1);
   GOOD_ACCESS(glob2, 2 - 1);
   GOOD_ACCESS(glob3, 3 - 1);
   GOOD_ACCESS(glob4, 4 - 1);
   GOOD_ACCESS(glob5, 5 - 1);
   GOOD_ACCESS(glob6, 6 - 1);

compiler-rt/test/asan/TestCases/Linux/allocator_oom_test.cc

 // RUN: %env_asan_opts=allocator_may_return_null=0 not %run %t realloc-after-malloc 2>&1 \
 // RUN:   | FileCheck %s --check-prefixes=CHECK-MALLOC-REALLOC,CHECK-CRASH
 // RUN: %env_asan_opts=allocator_may_return_null=1     %run %t realloc-after-malloc 2>&1 \
 // RUN:   | FileCheck %s --check-prefixes=CHECK-MALLOC-REALLOC,CHECK-NULL
 
 // ASan shadow memory on s390 is too large for this test.
 // AArch64 bots fail on this test.
 // TODO(alekseys): Android lit do not run ulimit on device.
-// UNSUPPORTED: s390,android,arm,aarch64
+// UNSUPPORTED: s390,android,arm,aarch64,custom-shadow-scale
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <assert.h>
 
 int main(int argc, char **argv) {
   assert(argc == 2);

compiler-rt/test/asan/TestCases/Linux/asan-asm-stacktrace-test.cc

 
 // CHECK: READ of size 4
 // CHECK-NEXT: {{#0 0x[0-9a-fA-F]+ in foo}}
 // CHECK-NEXT: {{#1 0x[0-9a-fA-F]+ in main}}
 
 // CHECK-nounwind: READ of size 4
 // CHECK-nounwind-NEXT: {{#0 0x[0-9a-fA-F]+ in foo}}
 
+// UNSUPPORTED: custom-shadow-scale
 __attribute__((noinline)) int foo(size_t n, int *buffer) {
   int r;
   __asm__("movl (%[buffer], %[n], 4), %[r]  \n\t"
           : [r] "=r"(r)
           : [buffer] "r"(buffer), [n] "r"(n)
           : "memory");
   return r;
 }
 
 int main() {
   const size_t n = 16;
   int *buffer = new int[n];
   foo(n, buffer);
   delete[] buffer;
   return 0;
 }

compiler-rt/test/asan/TestCases/Linux/asan_prelink_test.cc

 // Test if asan works with prelink.
 // It does not actually use prelink, but relies on ld's flag -Ttext-segment
 // or gold's flag -Ttext (we try the first flag first, if that fails we
 // try the second flag).
 //
 // RUN: %clangxx_asan -c %s -o %t.o
 // RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so -Wl,-Ttext-segment=0x3600000000 ||\
 // RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so -Wl,-Ttext=0x3600000000
 // RUN: %clangxx_asan %t.o %t.so -Wl,-R. -o %t
 // RUN: %env_asan_opts=verbosity=1 %run %t 2>&1 | FileCheck %s
 
 // GNU driver doesn't handle .so files properly.
 // REQUIRES: x86_64-target-arch, Clang
+// UNSUPPORTED: custom-shadow-scale
 #if BUILD_SO
 int G;
 int *getG() {
   return &G;
 }
 #else
 #include <stdio.h>
 extern int *getG();
 int main(int argc, char **argv) {
   long p = (long)getG();
   printf("SO mapped at %lx\n", p & ~0xffffffffUL);
   *getG() = 0;
 }
 #endif
 // CHECK: 0x003000000000, 0x004fffffffff{{.*}} MidMem
 // CHECK: SO mapped at 3600000000

compiler-rt/test/asan/TestCases/Linux/cuda_test.cc

 // Emulate the behavior of the NVIDIA CUDA driver
 // that mmaps memory inside the asan's shadow gap.
 //
 // REQUIRES: x86_64-target-arch
+// UNSUPPORTED: custom-shadow-scale
 //
 // RUN: %clangxx_asan %s -o %t
 // RUN: not %env_asan_opts=protect_shadow_gap=1 %t 2>&1 | FileCheck %s  --check-prefix=CHECK-PROTECT1
 // RUN: not                                     %t 2>&1 | FileCheck %s  --check-prefix=CHECK-PROTECT1
 // RUN: not %env_asan_opts=protect_shadow_gap=0 %t 2>&1 | FileCheck %s  --check-prefix=CHECK-PROTECT0
 #include <assert.h>
 #include <unistd.h>
 #include <sys/mman.h>
int main(void) {
   // CHECK-PROTECT1: AddressSanitizer: SEGV on unknown address 0x0000bfff8000
 
   // Poison a part of gap's shadow:
   __asan_poison_memory_region((void*)Base, 4096);
   // Now we should fail with use-after-poison.
   *(char*)(Base + 1234) = 1;
   // CHECK-PROTECT0: AddressSanitizer: use-after-poison on address 0x0002000004d2
 }
-
-

compiler-rt/test/asan/TestCases/Linux/kernel-area.cc

 // CHECK-kernel-32-bits: || `[0x27{{0+}}, 0x37{{f+}}]` || HighShadow ||
 // CHECK-kernel-32-bits: || `[0x24{{0+}}, 0x26{{f+}}]` || ShadowGap  ||
 //
 // CHECK-kernel-64-bits: || `[0x4{{0+}}, 0x{{f+}}]` || HighMem    ||
 // CHECK-kernel-64-bits: || `[0x28{{0+}}, 0x3{{f+}}]` || HighShadow ||
 // CHECK-kernel-64-bits: || `[0x24{{0+}}, 0x27{{f+}}]` || ShadowGap  ||
 //
 // REQUIRES: i386-target-arch
+// UNSUPPORTED: custom-shadow-scale
 
 int main() {
   return 0;
 }
-

compiler-rt/test/asan/TestCases/Linux/nohugepage_test.cc

 // Regression test for
 // https://code.google.com/p/chromium/issues/detail?id=446692
 // where asan consumed too much RAM due to transparent hugetables.
 //
 // RUN: %clangxx_asan -g %s -o %t
 // RUN: %env_asan_opts=no_huge_pages_for_shadow=1 %run %t 2>&1 | FileCheck %s
 // RUN: %run %t 2>&1 | FileCheck %s
 //
 // Would be great to run the test with no_huge_pages_for_shadow=0, but
 // the result will depend on the OS version and settings...
 //
 // REQUIRES: x86_64-target-arch
+// UNSUPPORTED: custom-shadow-scale
 //
 // WARNING: this test is very subtle and may nto work on some systems.
 // If this is the case we'll need to futher improve it or disable it.
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>

compiler-rt/test/asan/TestCases/intra-object-overflow.cc

 // RUN: %clangxx_asan -O0 -fsanitize-address-field-padding=1  %s -o %t
 // RUN: not %run %t 11 2>&1 | FileCheck %s
 // RUN: %run %t 10
 //
 // FIXME: fix 32-bits.
 // REQUIRES: asan-64-bits
 // FIXME: Implement ASan intra-object padding in Clang's MS record layout
-// UNSUPPORTED: win32
+// UNSUPPORTED: win32, custom-shadow-scale
 #include <stdio.h>
 #include <stdlib.h>
 class Foo {
  public:
   Foo() : pre1(1), pre2(2), post1(3), post2(4) {
   }
   virtual ~Foo() {
   }

compiler-rt/test/asan/TestCases/small_memcpy_test.cc

 // Test that small memcpy works correctly.
 
 // RUN: %clangxx_asan %s -o %t
 // RUN: not %run %t 8 24 2>&1 | FileCheck %s --check-prefix=CHECK
 // RUN: not %run %t 16 32 2>&1 | FileCheck %s --check-prefix=CHECK
 // RUN: not %run %t 24 40 2>&1 | FileCheck %s --check-prefix=CHECK
 // RUN: not %run %t 32 48 2>&1 | FileCheck %s --check-prefix=CHECK
 // RUN: not %run %t 40 56 2>&1 | FileCheck %s --check-prefix=CHECK
 // RUN: not %run %t 48 64 2>&1 | FileCheck %s --check-prefix=CHECK
+// UNSUPPORTED: custom-shadow-scale
 #include <assert.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 
 #include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {

compiler-rt/test/asan/TestCases/stack-buffer-overflow-with-position.cc

 // CHECK-30: 'BBB'{{.*}} <== {{.*}}underflows this variable
 // CHECK-31: 'BBB'{{.*}} <== {{.*}}partially underflows this variable
 // CHECK-41: 'BBB'{{.*}} <== {{.*}}partially overflows this variable
 // CHECK-42: 'BBB'{{.*}} <== {{.*}}overflows this variable
 // CHECK-62: 'CCC'{{.*}} <== {{.*}}underflows this variable
 // CHECK-63: 'CCC'{{.*}} <== {{.*}}partially underflows this variable
 // CHECK-73: 'CCC'{{.*}} <== {{.*}}partially overflows this variable
 // CHECK-74: 'CCC'{{.*}} <== {{.*}}overflows this variable
+// UNSUPPORTED: custom-shadow-scale

compiler-rt/test/asan/TestCases/strtol_strict.c

 // RUN: %env_asan_opts=strict_string_checks=false %run %t test5 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t test5 2>&1 | FileCheck %s --check-prefix=CHECK5
 // RUN: %run %t test6 2>&1
 // RUN: %env_asan_opts=strict_string_checks=false %run %t test6 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t test6 2>&1 | FileCheck %s --check-prefix=CHECK6
 // RUN: %run %t test7 2>&1
 // RUN: %env_asan_opts=strict_string_checks=false %run %t test7 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t test7 2>&1 | FileCheck %s --check-prefix=CHECK7
+// UNSUPPORTED: custom-shadow-scale
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <sanitizer/asan_interface.h>
 
 void test1(char *array, char *endptr) {

compiler-rt/test/asan/TestCases/strtoll_strict.c

 // RUN: %env_asan_opts=strict_string_checks=false %run %t test6 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t test6 2>&1 | FileCheck %s --check-prefix=CHECK6
 // RUN: %run %t test7 2>&1
 // RUN: %env_asan_opts=strict_string_checks=false %run %t test7 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t test7 2>&1 | FileCheck %s --check-prefix=CHECK7
 
 // FIXME: Enable strtoll interceptor.
 // XFAIL: win32
+// UNSUPPORTED: custom-shadow-scale
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sanitizer/asan_interface.h>
 
 void test1(char *array, char *endptr) {
   // Buffer overflow if there is no terminating null (depends on base)