[ASan] rename left/right to before/after.

[fmayer]

Summary

left/right is a weird way to refer to address ordering.

[fmayer]

test update

[kcc]

not arguing for or against, but I wonder how many output parsers will break.

[fmayer]

In D132611#3747396, @kcc wrote:

not arguing for or against, but I wonder how many output parsers will break.

not sure about asan, for hwasan we did some quite significant changes to the output format, and no one complained at us.

[eugenis]

I think this is a pretty minor change - we are not touching the general structure of the report, nor introducing a new error type (even though the latter happens from time to time).

[kcc]

In D132611#3747406, @fmayer wrote:

In D132611#3747396, @kcc wrote:

not arguing for or against, but I wonder how many output parsers will break.

not sure about asan, for hwasan we did some quite significant changes to the output format, and no one complained at us.

The number of users is different. At the very least I would check with ClusterFuzz

[fmayer]

Need to fix tests, sorry, messed something up.

[fmayer]

fix tests

[fmayer]

https://github.com/google/clusterfuzz/blob/master/src/clusterfuzz/tests/test.py still passes if I change https://github.com/google/clusterfuzz/blob/master/src/clusterfuzz/tests/testdata/asan_stacktrace.txt to use the new format

[fmayer]

update

[phosek]

This is fine from my perspective, if we want to be extra cautious it might be worth sending an announcement to Discourse before landing this change.

[fmayer]

In D132611#3760351, @phosek wrote:

This is fine from my perspective, if we want to be extra cautious it might be worth sending an announcement to Discourse before landing this change.

OK. Posted a notice to #sanitizers on Discord and https://discourse.llvm.org/t/psa-asan-and-hwasan-output-format-changes/65024.

[MaskRay]

Thanks for starting the post. Personally I think the rename improves clarify.

[eugenis]

LGTM

[thakis]

If you want to update this, please do it everywhere.

(I don't think it's clearer and it broke a bunch of our tests, so I'm a bit grumpy about this change. Apologies.)

compiler-rt/lib/asan/asan_allocator.cpp

804

This still says left

compiler-rt/lib/asan/asan_descriptions.cpp

131

So does this.

[fmayer]

In D132611#3778826, @thakis wrote:

If you want to update this, please do it everywhere.

(I don't think it's clearer and it broke a bunch of our tests, so I'm a bit grumpy about this change. Apologies.)

Sorry about breaking your tests, the apologies are mine. Could you share the test that was broken? Was it only tests or also some parser? D133582 sorts out the remaining references to left/right in the asan code.

[thakis]

We had a bunch of gtest death tests to check that the sanitizers are working. They did a write to the left or right if an array, and checked that that a) crashed b) the crash message contained the text "left of" / "right of". Fairly easy to update, but also a bit churny, for subjectively not a lot of upside. (But if y'all think this is a better diag, that's enough of course.)

Thank you for updating the rest to make the codebase self-consistent again!

[enh]

In D132611#3780832, @thakis wrote:

We had a bunch of gtest death tests to check that the sanitizers are working. They did a write to the left or right if an array, and checked that that a) crashed b) the crash message contained the text "left of" / "right of". Fairly easy to update, but also a bit churny, for subjectively not a lot of upside. (But if y'all think this is a better diag, that's enough of course.)

yeah, we won't know for a while, but i'm hopeful that (in my day job as "Android C/C++ crash dump bug concierge") i'll have to explain "self explanatory" (hw)asan bug reports less frequently...

it took a pretty sophisticated C programmer explicitly saying "i don't know what '0 bytes to the right' is telling me" for me to be brave enough to complain to the asan folks, even though i'd always had to translate these in my head myself. if _he_ didn't get it, the average NDK user never will.

the same person also noticed that in the shadow map we dump shadow addresses rather than "real" addresses, which i'd never noticed because i just ignore that bit as being "for experts only". one day i might be brave enough to admit that i don't know whether i'm supposed to be using it, and if so, for what :-)

[fmayer]

In D132611#3781029, @enh wrote:

the same person also noticed that in the shadow map we dump shadow addresses rather than "real" addresses, which i'd never noticed because i just ignore that bit as being "for experts only". one day i might be brave enough to admit that i don't know whether i'm supposed to be using it, and if so, for what :-)

FYI this was addressed in D133391 and D133380.

compiler-rt/lib/asan/asan_allocator.cpp

if (atomic_load(&m->chunk_state, memory_order_acquire) != CHUNK_ALLOCATED)
       return 0;
     if (m->Beg() != p) return 0;
     return m->UsedSize();
   }
 
   AsanChunkView FindHeapChunkByAddress(uptr addr) {
     AsanChunk *m1 = GetAsanChunkByAddr(addr);
     sptr offset = 0;
     if (!m1 || AsanChunkView(m1).AddrIsAtLeft(addr, 1, &offset)) {
       // The address is in the chunk's left redzone, so maybe it is actually
-      // a right buffer overflow from the other chunk to the left.
-      // Search a bit to the left to see if there is another chunk.
+      // a right buffer overflow from the other chunk before.
+      // Search a bit before to see if there is another chunk.
       AsanChunk *m2 = nullptr;
       for (uptr l = 1; l < GetPageSizeCached(); l++) {
         m2 = GetAsanChunkByAddr(addr - l);
         if (m2 == m1) continue;  // Still the same chunk.
         break;
       }
       if (m2 && AsanChunkView(m2).AddrIsAtRight(addr, 1, &offset))
         m1 = ChooseChunk(addr, m2, m1);

compiler-rt/lib/asan/asan_descriptions.cpp

static void GetAccessToHeapChunkInformation(ChunkAccess *descr,
   descr->alloc_type = chunk.GetAllocType();
 }
 
 static void PrintHeapChunkAccess(uptr addr, const ChunkAccess &descr) {
   Decorator d;
   InternalScopedString str;
   str.append("%s", d.Location());
   switch (descr.access_type) {
     case kAccessTypeLeft:
-      str.append("%p is located %zd bytes to the left of",
+      str.append("%p is located %zd bytes before",
                  (void *)descr.bad_addr, descr.offset);
       break;
     case kAccessTypeRight:
-      str.append("%p is located %zd bytes to the right of",
+      str.append("%p is located %zd bytes after",
                  (void *)descr.bad_addr, descr.offset);
       break;
     case kAccessTypeInside:
       str.append("%p is located %zd bytes inside of", (void *)descr.bad_addr,
                  descr.offset);
       break;
     case kAccessTypeUnknown:
       str.append(

 
 // Global descriptions
 static void DescribeAddressRelativeToGlobal(uptr addr, uptr access_size,
                                             const __asan_global &g) {
   InternalScopedString str;
   Decorator d;
   str.append("%s", d.Location());
   if (addr < g.beg) {
-    str.append("%p is located %zd bytes to the left", (void *)addr,
+    str.append("%p is located %zd bytes before", (void *)addr,
                g.beg - addr);
   } else if (addr + access_size > g.beg + g.size) {
     if (addr < g.beg + g.size) addr = g.beg + g.size;
-    str.append("%p is located %zd bytes to the right", (void *)addr,
+    str.append("%p is located %zd bytes after", (void *)addr,
                addr - (g.beg + g.size));
   } else {
     // Can it happen?
-    str.append("%p is located %zd bytes inside", (void *)addr, addr - g.beg);
+    str.append("%p is located %zd bytes inside of", (void *)addr, addr - g.beg);
   }
-  str.append(" of global variable '%s' defined in '",
+  str.append(" global variable '%s' defined in '",
              MaybeDemangleGlobalName(g.name));
   PrintGlobalLocation(&str, g);
   str.append("' (0x%zx) of size %zu\n", g.beg, g.size);
   str.append("%s", d.Default());
   PrintGlobalNameIfASCII(&str, g);
   Printf("%s", str.data());
 }
 

compiler-rt/lib/asan/tests/asan_mem_test.cpp

void MemSetOOBTestTemplate(size_t length) {
 
   // memset 0 bytes
   MEMSET(array - 10, element, zero);
   MEMSET(array - 1, element, zero);
   MEMSET(array, element, zero);
   MEMSET(array + length, 0, zero);
   MEMSET(array + length + 1, 0, zero);
 
-  // try to memset bytes to the right of array
+  // try to memset bytes after array
   EXPECT_DEATH(MEMSET(array, 0, size + 1),
                RightOOBWriteMessage(0));
   EXPECT_DEATH(MEMSET((char*)(array + length) - 1, element, 6),
                RightOOBWriteMessage(0));
   EXPECT_DEATH(MEMSET(array + 1, element, size + sizeof(T)),
                RightOOBWriteMessage(0));
-  // whole interval is to the right
+  // whole interval is after
   EXPECT_DEATH(MEMSET(array + length + 1, 0, 10),
                RightOOBWriteMessage(sizeof(T)));
 
-  // try to memset bytes to the left of array
+  // try to memset bytes before array
   EXPECT_DEATH(MEMSET((char*)array - 1, element, size),
                LeftOOBWriteMessage(1));
   EXPECT_DEATH(MEMSET((char*)array - 5, 0, 6),
                LeftOOBWriteMessage(5));
   if (length >= 100) {
     // Large OOB, we find it only if the redzone is large enough.
     EXPECT_DEATH(memset(array - 5, element, size + 5 * sizeof(T)),
                  LeftOOBWriteMessage(5 * sizeof(T)));
   }
-  // whole interval is to the left
+  // whole interval is before
   EXPECT_DEATH(MEMSET(array - 2, 0, sizeof(T)),
                LeftOOBWriteMessage(2 * sizeof(T)));
 
-  // try to memset bytes both to the left & to the right
+  // try to memset bytes both before & after
   EXPECT_DEATH(MEMSET((char*)array - 2, element, size + 4),
                LeftOOBWriteMessage(2));
 
   free(array);
 }
 
 TEST(AddressSanitizer, MemSetOOBTest) {
   MemSetOOBTestTemplate<char>(100);

 TEST(AddressSanitizer, LargeOOBInMemset) {
   for (size_t size = 200; size < 100000; size += size / 2) {
     char *x1, *x2;
     if (!Ident(AllocateTwoAdjacentArrays)(&x1, &x2, size))
       continue;
     // fprintf(stderr, "  large oob memset: %p %p %zd\n", x1, x2, size);
     // Do a memset on x1 with huge out-of-bound access that will end up in x2.
     EXPECT_DEATH(Ident(memset)(x1, 0, size * 2),
-                 "is located 0 bytes to the right");
+                 "is located 0 bytes after");
     delete [] x1;
     delete [] x2;
     return;
   }
   assert(0 && "Did not find two adjacent malloc-ed pointers");
 }
 
 // Same test for memcpy and memmove functions
void MemTransferOOBTestTemplate(size_t length) {
   M::transfer(dest, src, 1);
 
   // transfer zero bytes
   M::transfer(dest - 1, src, 0);
   M::transfer(dest + length, src, zero);
   M::transfer(dest, src - 1, zero);
   M::transfer(dest, src, zero);
 
-  // try to change mem to the right of dest
+  // try to change mem after dest
   EXPECT_DEATH(M::transfer(dest + 1, src, size),
                RightOOBWriteMessage(0));
   EXPECT_DEATH(M::transfer((char*)(dest + length) - 1, src, 5),
                RightOOBWriteMessage(0));
 
-  // try to change mem to the left of dest
+  // try to change mem before dest
   EXPECT_DEATH(M::transfer(dest - 2, src, size),
                LeftOOBWriteMessage(2 * sizeof(T)));
   EXPECT_DEATH(M::transfer((char*)dest - 3, src, 4),
                LeftOOBWriteMessage(3));
 
-  // try to access mem to the right of src
+  // try to access mem after src
   EXPECT_DEATH(M::transfer(dest, src + 2, size),
                RightOOBReadMessage(0));
   EXPECT_DEATH(M::transfer(dest, (char*)(src + length) - 3, 6),
                RightOOBReadMessage(0));
 
-  // try to access mem to the left of src
+  // try to access mem before src
   EXPECT_DEATH(M::transfer(dest, src - 1, size),
                LeftOOBReadMessage(sizeof(T)));
   EXPECT_DEATH(M::transfer(dest, (char*)src - 6, 7),
                LeftOOBReadMessage(6));
 
   // Generally we don't need to test cases where both accessing src and writing
   // to dest address to poisoned memory.
 

compiler-rt/lib/asan/tests/asan_oob_test.cpp

NOINLINE void oob_test(int size, int off) {
   // fprintf(stderr, "writing %d byte(s) into [%p,%p) with offset %d\n",
   //        sizeof(T), p, p + size, off);
   asan_write((T*)(p + off));
   free_aaa(p);
 }
 
 static std::string GetLeftOOBMessage(int off) {
   char str[100];
-  sprintf(str, "is located.*%d byte.*to the left", off);
+  sprintf(str, "is located.*%d byte.*before", off);
   return str;
 }
 
 static std::string GetRightOOBMessage(int off) {
   char str[100];
 #if !defined(_WIN32)
   // FIXME: Fix PR42868 and remove SEGV match.
-  sprintf(str, "is located.*%d byte.*to the right|SEGV", off);
+  sprintf(str, "is located.*%d byte.*after|SEGV", off);
 #else
   // `|` doesn't work in googletest's regexes on Windows,
   // see googletest/docs/advanced.md#regular-expression-syntax
   // But it's not needed on Windows anyways.
-  sprintf(str, "is located.*%d byte.*to the right", off);
+  sprintf(str, "is located.*%d byte.*after", off);
 #endif
   return str;
 }
 
 template<typename T>
 void OOBTest() {
   for (int size = sizeof(T); size < 20; size += 5) {
     for (int i = -5; i < 0; i++)

compiler-rt/lib/asan/tests/asan_str_test.cpp

 
 std::string RightOOBReadMessage(OOBKind oob_kind, int oob_distance) {
   return oob_kind == OOBKind::Stack ? kStackReadOverflow
                                     : ::RightOOBReadMessage(oob_distance);
 }
 }  // namespace
 
 // Input to a test is a zero-terminated string str with given length
-// Accesses to the bytes to the left and to the right of str
+// Accesses to the bytes before and after str
 // are presumed to produce OOB errors
 void StrLenOOBTestTemplate(char *str, size_t length, OOBKind oob_kind) {
   // Normal strlen calls
   EXPECT_EQ(strlen(str), length);
   if (length > 0) {
     EXPECT_EQ(length - 1, strlen(str + 1));
     EXPECT_EQ(0U, strlen(str + length));
   }
   // Arg of strlen is not malloced, OOB access
   if (oob_kind != OOBKind::Global) {
-    // We don't insert RedZones to the left of global variables
+    // We don't insert RedZones before global variables
     EXPECT_DEATH(Ident(strlen(str - 1)), LeftOOBReadMessage(oob_kind, 1));
     EXPECT_DEATH(Ident(strlen(str - 5)), LeftOOBReadMessage(oob_kind, 5));
   }
   EXPECT_DEATH(Ident(strlen(str + length + 1)),
                RightOOBReadMessage(oob_kind, 0));
   // Overwrite terminator
   str[length] = 'a';
   // String is not zero-terminated, strlen will lead to OOB access

compiler-rt/lib/asan/tests/asan_test.cpp

#endif
   EXPECT_NE(SIG_ERR, signal(SIGSEGV, my_signal_sighandler));
   EXPECT_DEATH(*c = 0, kOverriddenSignalHandler);
 }
 }  // namespace
 #endif
 
 static void TestLargeMalloc(size_t size) {
   char buff[1024];
-  sprintf(buff, "is located 1 bytes to the left of %lu-byte", (long)size);
+  sprintf(buff, "is located 1 bytes before %lu-byte", (long)size);
   EXPECT_DEATH(Ident((char*)malloc(size))[-1] = 0, buff);
 }
 
 TEST(AddressSanitizer, LargeMallocTest) {
   const int max_size = (SANITIZER_WORDSIZE == 32) ? 1 << 26 : 1 << 28;
   for (int i = 113; i < max_size; i = i * 2 + 13) {
     TestLargeMalloc(i);
   }
 }
 
 #if !GTEST_USES_SIMPLE_RE
 TEST(AddressSanitizer, HugeMallocTest) {
   if (SANITIZER_WORDSIZE != 64 || ASAN_AVOID_EXPENSIVE_TESTS) return;
   size_t n_megs = 4100;
   EXPECT_DEATH(Ident((char*)malloc(n_megs << 20))[-1] = 0,
-               "is located 1 bytes to the left|"
+               "is located 1 bytes before|"
                "AddressSanitizer failed to allocate");
 }
 #endif
 
 #if SANITIZER_TEST_HAS_MEMALIGN
 void MemalignRun(size_t align, size_t size, int idx) {
   char *p = (char *)memalign(align, size);
   Ident(p)[idx] = 0;
   free(p);
 }
 
 TEST(AddressSanitizer, memalign) {
   for (int align = 16; align <= (1 << 23); align *= 2) {
     size_t size = align * 5;
     EXPECT_DEATH(MemalignRun(align, size, -1),
-                 "is located 1 bytes to the left");
+                 "is located 1 bytes before");
     EXPECT_DEATH(MemalignRun(align, size, size + 1),
-                 "is located 1 bytes to the right");
+                 "is located 1 bytes after");
   }
 }
 #endif  // SANITIZER_TEST_HAS_MEMALIGN
 
 void *ManyThreadsWorker(void *a) {
   for (int iter = 0; iter < 100; iter++) {
     for (size_t size = 100; size < 2000; size *= 2) {
       free(Ident(malloc(size)));
if (((uintptr_t)a % 16) != 0)
     p = a + 8;
   assert(((uintptr_t)p % 16) == 0);
   __m128i value_wide = _mm_set1_epi16(0x1234);
   EXPECT_DEATH(_mm_store_si128((__m128i*)p, value_wide),
                "AddressSanitizer: heap-buffer-overflow");
   EXPECT_DEATH(_mm_store_si128((__m128i*)p, value_wide),
                "WRITE of size 16");
   EXPECT_DEATH(_mm_store_si128((__m128i*)p, value_wide),
-               "located 0 bytes to the right of 12-byte");
+               "located 0 bytes after 12-byte");
   free(a);
 }
 #endif
 
 // FIXME: All tests that use this function should be turned into lit tests.
 std::string RightOOBErrorMessage(int oob_distance, bool is_write) {
   assert(oob_distance >= 0);
   char expected_str[100];
   sprintf(expected_str, ASAN_PCRE_DOTALL
 #if !GTEST_USES_SIMPLE_RE
           "buffer-overflow.*%s.*"
 #endif
-          "located %d bytes to the right",
+          "located %d bytes after",
 #if !GTEST_USES_SIMPLE_RE
           is_write ? "WRITE" : "READ",
 #endif
           oob_distance);
   return std::string(expected_str);
 }
 
 std::string RightOOBWriteMessage(int oob_distance) {
   return RightOOBErrorMessage(oob_distance, /*is_write*/true);
 }
 
 std::string RightOOBReadMessage(int oob_distance) {
   return RightOOBErrorMessage(oob_distance, /*is_write*/false);
 }
 
 // FIXME: All tests that use this function should be turned into lit tests.
 std::string LeftOOBErrorMessage(int oob_distance, bool is_write) {
   assert(oob_distance > 0);
   char expected_str[100];
   sprintf(expected_str,
 #if !GTEST_USES_SIMPLE_RE
           ASAN_PCRE_DOTALL "%s.*"
 #endif
-          "located %d bytes to the left",
+          "located %d bytes before",
 #if !GTEST_USES_SIMPLE_RE
           is_write ? "WRITE" : "READ",
 #endif
           oob_distance);
   return std::string(expected_str);
 }
 
 std::string LeftOOBWriteMessage(int oob_distance) {
   return LeftOOBErrorMessage(oob_distance, /*is_write*/true);
 }
 
 std::string LeftOOBReadMessage(int oob_distance) {
   return LeftOOBErrorMessage(oob_distance, /*is_write*/false);
 }
 
 std::string LeftOOBAccessMessage(int oob_distance) {
   assert(oob_distance > 0);
   char expected_str[100];
-  sprintf(expected_str, "located %d bytes to the left", oob_distance);
+  sprintf(expected_str, "located %d bytes before", oob_distance);
   return std::string(expected_str);
 }
 
 char* MallocAndMemsetString(size_t size, char ch) {
   char *s = Ident((char*)malloc(size));
   memset(s, ch, size);
   return s;
 }
 
 char* MallocAndMemsetString(size_t size) {
   return MallocAndMemsetString(size, 'z');
 }
 
 #if SANITIZER_GLIBC
 #define READ_TEST(READ_N_BYTES)                                          \
   char *x = new char[10];                                                \
   int fd = open("/proc/self/stat", O_RDONLY);                            \
   ASSERT_GT(fd, 0);                                                      \
   EXPECT_DEATH(READ_N_BYTES,                                             \
                ASAN_PCRE_DOTALL                                          \
                "AddressSanitizer: heap-buffer-overflow"                  \
-               ".* is located 0 bytes to the right of 10-byte region");  \
+               ".* is located 0 bytes after 10-byte region");  \
   close(fd);                                                             \
   delete [] x;                                                           \
 
 TEST(AddressSanitizer, pread) {
   READ_TEST(pread(fd, x, 15, 0));
 }
 
 TEST(AddressSanitizer, pread64) {
TEST(AddressSanitizer, GlobalTest) {
 
   glob5[Ident(0)] = 0;
   glob5[Ident(1)] = 0;
   glob5[Ident(2)] = 0;
   glob5[Ident(3)] = 0;
   glob5[Ident(4)] = 0;
 
   EXPECT_DEATH(glob5[Ident(5)] = 0,
-               "0 bytes to the right of global variable.*glob5.* size 5");
+               "0 bytes after global variable.*glob5.* size 5");
   EXPECT_DEATH(glob5[Ident(5+6)] = 0,
-               "6 bytes to the right of global variable.*glob5.* size 5");
+               "6 bytes after global variable.*glob5.* size 5");
   Ident(static110);  // avoid optimizations
   static110[Ident(0)] = 0;
   static110[Ident(109)] = 0;
   EXPECT_DEATH(static110[Ident(110)] = 0,
-               "0 bytes to the right of global variable");
+               "0 bytes after global variable");
   EXPECT_DEATH(static110[Ident(110+7)] = 0,
-               "7 bytes to the right of global variable");
+               "7 bytes after global variable");
 
   Ident(func_static15);  // avoid optimizations
   func_static15[Ident(0)] = 0;
   EXPECT_DEATH(func_static15[Ident(15)] = 0,
-               "0 bytes to the right of global variable");
+               "0 bytes after global variable");
   EXPECT_DEATH(func_static15[Ident(15 + 9)] = 0,
-               "9 bytes to the right of global variable");
+               "9 bytes after global variable");
 
   Ident(fs1);
   Ident(fs2);
   Ident(fs3);
 
   // We don't create left redzones, so this is not 100% guaranteed to fail.
   // But most likely will.
-  EXPECT_DEATH(fs2[Ident(-1)] = 0, "is located.*of global variable");
+  EXPECT_DEATH(fs2[Ident(-1)] = 0, "is located.* global variable");
 
   EXPECT_DEATH(Ident(Ident(ConstGlob)[8]),
-               "is located 1 bytes to the right of .*ConstGlob");
+               "is located 1 bytes after .*ConstGlob");
   EXPECT_DEATH(Ident(Ident(StaticConstGlob)[5]),
-               "is located 2 bytes to the right of .*StaticConstGlob");
+               "is located 2 bytes after .*StaticConstGlob");
 
   // call stuff from another file.
   GlobalsTest(0);
 }
 
 TEST(AddressSanitizer, GlobalStringConstTest) {
   static const char *zoo = "FOOBAR123";
   const char *p = Ident(zoo);

compiler-rt/test/asan/TestCases/Darwin/address-range-limit.mm

int main(int argc, char *argv[]) {
 
   char *ptr = (char *)malloc(10);
   ptr[10] = 'x';  // BOOM
 }
 
 // CHECK: AddressSanitizer: heap-buffer-overflow
 // CHECK: WRITE of size 1
 // CHECK: {{#0 .* in main}}
-// CHECK: is located 0 bytes to the right of 10-byte region
+// CHECK: is located 0 bytes after 10-byte region

compiler-rt/test/asan/TestCases/Darwin/dead-strip.c

 
 int alive[1] = {};
 int dead[1] = {};
 // NM-CHECK: {{^_alive }}
 // NM-CHECK-NOT: {{^_dead }}
 
 int main(int argc, char *argv[]) {
   alive[argc] = 0;
-  // ASAN-CHECK: {{0x.* is located 0 bytes to the right of global variable}}
+  // ASAN-CHECK: {{0x.* is located 0 bytes after global variable}}
   return 0;
 }

compiler-rt/test/asan/TestCases/Darwin/haswell-symbolication.cpp

 }
 
 extern "C"
 void faulty_func(char *p) {
   *p = 'x';  // BOOM
   // CHECK: AddressSanitizer: global-buffer-overflow
   // CHECK-LI: #0 0x{{.*}} in faulty_func{{.*}} {{.*}}haswell-symbolication.cpp:[[@LINE-2]]
   // CHECK-NOLI: #0 0x{{.*}} in faulty_func{{.*}} {{.*}}haswell-symbolication
-  // CHECK: is located 2 bytes to the right of global variable 'faulty_global'
+  // CHECK: is located 2 bytes after global variable 'faulty_global'
   // CHECK-NOT: LLVMSymbolizer: error reading file
 }
 
 int main() {
   check_data_symbolication();
 
   char *p = (char *)(void *)&faulty_global;
   p += 10;
   faulty_func(p);
   return 0;
 }

compiler-rt/test/asan/TestCases/Linux/global-overflow-bfd.cpp

 // Test that gc-sections-friendly instrumentation of globals does not introduce
 // false negatives with the BFD linker.
 // RUN: %clangxx_asan -fuse-ld=bfd -Wl,-gc-sections -ffunction-sections -fdata-sections -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 #include <string.h>
 int main(int argc, char **argv) {
   static char XXX[10];
   static char YYY[10];
   static char ZZZ[10];
   memset(XXX, 0, 10);
   memset(YYY, 0, 10);
   memset(ZZZ, 0, 10);
   int res = YYY[argc * 10];  // BOOOM
   // CHECK: {{READ of size 1 at}}
-  // CHECK: {{located 0 bytes to the right of global variable}}
+  // CHECK: {{located 0 bytes after global variable}}
   res += XXX[argc] + ZZZ[argc];
   return res;
 }

compiler-rt/test/asan/TestCases/Linux/global-overflow-lld.cpp

 // Test that gc-sections-friendly instrumentation of globals does not introduce
 // false negatives with the LLD linker.
 // RUN: %clangxx_asan -fuse-ld=lld -Wl,-gc-sections -ffunction-sections -fdata-sections -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // REQUIRES: lld
 
 #include <string.h>
 int main(int argc, char **argv) {
   static char XXX[10];
   static char YYY[10];
   static char ZZZ[10];
   memset(XXX, 0, 10);
   memset(YYY, 0, 10);
   memset(ZZZ, 0, 10);
   int res = YYY[argc * 10];  // BOOOM
   // CHECK: {{READ of size 1 at}}
-  // CHECK: {{located 0 bytes to the right of global variable}}
+  // CHECK: {{located 0 bytes after global variable}}
   res += XXX[argc] + ZZZ[argc];
   return res;
 }

compiler-rt/test/asan/TestCases/Linux/malloc-in-qsort.cpp

 int main() {
   char a[2] = {1, 2};
   MyQsort(a, 2);
   return GlobalPtr[10];
 }
 
 // Fast unwind may not unwind through qsort.
 // CHECK-FAST: ERROR: AddressSanitizer: heap-buffer-overflow
-// CHECK-FAST: is located 0 bytes to the right
+// CHECK-FAST: is located 0 bytes after
 // CHECK-FAST: #0{{.*}}operator new
 // CHECK-FAST-NEXT: #1{{.*}}QsortCallback
 
 // CHECK-SLOW: ERROR: AddressSanitizer: heap-buffer-overflow
-// CHECK-SLOW: is located 0 bytes to the right
+// CHECK-SLOW: is located 0 bytes after
 // CHECK-SLOW: #0{{.*}}operator new
 // CHECK-SLOW-NEXT: #1{{.*}}QsortCallback
 // CHECK-SLOW: #{{.*}}MyQsort
 // CHECK-SLOW-NEXT: #{{.*}}main

compiler-rt/test/asan/TestCases/Linux/overflow-in-qsort.cpp

 int main() {
   char a[2] = {1, 2};
   MyQsort(a, 2);
 }
 
 // Fast unwind may not unwind through qsort.
 // CHECK-FAST: ERROR: AddressSanitizer: global-buffer-overflow
 // CHECK-FAST: #0{{.*}} in QsortCallback
-// CHECK-FAST: is located 0 bytes to the right of global variable 'global_array
+// CHECK-FAST: is located 0 bytes after global variable 'global_array
 
 // CHECK-SLOW: ERROR: AddressSanitizer: global-buffer-overflow
 // CHECK-SLOW: #0{{.*}} in QsortCallback
 // CHECK-SLOW: #{{.*}} in MyQsort
 // CHECK-SLOW: #{{.*}} in main
-// CHECK-SLOW: is located 0 bytes to the right of global variable 'global_array
+// CHECK-SLOW: is located 0 bytes after global variable 'global_array

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

 // RUN: %clang_asan -O0 %s -o %t -w && not %run %t 2>&1 | FileCheck %s
 // RUN: %clang_asan -O2 %s -o %t -w && not %run %t 2>&1 | FileCheck %s
 
 int global_array[100] = {-1};
 
 // This access is 412 bytes after the start of the global: past the end of the
 // uninstrumented array, but within the bounds of the extended instrumented
 // array. We should ensure this is still instrumented.
 int main(void) { return global_array[103]; }
 
 // CHECK: AddressSanitizer: global-buffer-overflow on address
-// CHECK: is located 12 bytes to the right of global variable 'global_array'
+// CHECK: is located 12 bytes after global variable 'global_array'

compiler-rt/test/asan/TestCases/Posix/start-deactivated.cpp

int main(int argc, char *argv[]) {
   void *p = malloc((unsigned long)-2);
   assert(!p);
   // CHECK: WARNING: AddressSanitizer failed to allocate 0xfff{{.*}} bytes
 
   ((Fn)fn)();
   // CHECK: AddressSanitizer: heap-buffer-overflow
   // CHECK: READ of size 1
   // CHECK: {{#0 .* in do_another_bad_thing}}
-  // CHECK: is located 5 bytes to the right of 100-byte region
+  // CHECK: is located 5 bytes after 100-byte region
   // CHECK: in do_another_bad_thing
 
   return 0;
 }
 
 #else  // SHARED_LIB
 
 #include <stdio.h>

compiler-rt/test/asan/TestCases/Windows/calloc_left_oob.cpp

 // RUN: %clang_cl_asan -Od %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   int *buffer = (int*)calloc(42, sizeof(int));
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 4 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*calloc_left_oob.cpp}}:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 4 bytes to the left of 168-byte region
+// CHECK: [[ADDR]] is located 4 bytes before 168-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* calloc }}
 // CHECK-NEXT: {{#1 .* main .*calloc_left_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

compiler-rt/test/asan/TestCases/Windows/calloc_right_oob.cpp

 // RUN: %clang_cl_asan -Od %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   int *buffer = (int*)calloc(42, sizeof(int));
   buffer[42] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 4 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*calloc_right_oob.cpp}}:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 0 bytes to the right of 168-byte region
+// CHECK: [[ADDR]] is located 0 bytes after 168-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* calloc }}
 // CHECK-NEXT: {{#1 .* main .*calloc_right_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

compiler-rt/test/asan/TestCases/Windows/dll_malloc_left_oob.cpp

 // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
 // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 #include <malloc.h>
 extern "C" __declspec(dllexport)
 int test_function() {
   char *buffer = (char*)malloc(42);
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: test_function {{.*}}dll_malloc_left_oob.cpp:[[@LINE-3]]
 // CHECK-NEXT: main {{.*}}dll_host.cpp
 //
-// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK: [[ADDR]] is located 1 bytes before 42-byte region
 // CHECK-LABEL: allocated by thread T0 here:
 // CHECK-NEXT:   malloc
 // CHECK-NEXT:   test_function {{.*}}dll_malloc_left_oob.cpp:[[@LINE-10]]
 // CHECK-NEXT:   main {{.*}}dll_host.cpp
 // CHECK-LABEL: SUMMARY
   free(buffer);
   return 0;
 }

compiler-rt/test/asan/TestCases/Windows/dll_operator_array_new_left_oob.cpp

 // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
 // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 extern "C" __declspec(dllexport)
 int test_function() {
   char *buffer = new char[42];
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: test_function {{.*}}dll_operator_array_new_left_oob.cpp:[[@LINE-3]]
 // CHECK-NEXT: main {{.*}}dll_host.cpp
 //
-// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK: [[ADDR]] is located 1 bytes before 42-byte region
 // CHECK-LABEL: allocated by thread T0 here:
 // FIXME: Should get rid of the malloc/free frames called from the inside of
 // operator new/delete in DLLs when using -MT CRT.
 // FIXME: The 'operator new' frame should have [].
 // CHECK:        operator new
 // CHECK-NEXT:   test_function {{.*}}dll_operator_array_new_left_oob.cpp:[[@LINE-13]]
 // CHECK-NEXT:   main {{.*}}dll_host.cpp
 // CHECK-LABEL: SUMMARY
   delete [] buffer;
   return 0;
 }

compiler-rt/test/asan/TestCases/Windows/dll_operator_array_new_with_dtor_left_oob.cpp

 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 4 at [[ADDR]] thread T0
 // CHECK-NEXT: test_function {{.*}}dll_operator_array_new_with_dtor_left_oob.cpp:[[@LINE-3]]
 // CHECK-NEXT: main {{.*}}dll_host.cpp
 //
 // FIXME: Currently it says "4 bytes ... left of 172-byte region",
 //        should be "8 bytes ... left of 168-byte region", see
 //        https://code.google.com/p/address-sanitizer/issues/detail?id=314
-// CHECK: [[ADDR]] is located {{.*}} bytes to the left of {{(172|176)}}-byte region
+// CHECK: [[ADDR]] is located {{.*}} bytes before {{(172|176)}}-byte region
 // FIXME: Should get rid of the malloc/free frames called from the inside of
 // operator new/delete in DLLs when using -MT CRT.
 // FIXME: The operator new frame should have [].
 // CHECK-LABEL: allocated by thread T0 here:
 // CHECK:        operator new
 // CHECK-NEXT:   test_function {{.*}}dll_operator_array_new_with_dtor_left_oob.cpp:[[@LINE-16]]
 // CHECK-NEXT:   main {{.*}}dll_host.cpp
 // CHECK-LABEL: SUMMARY
   delete [] buffer;
   return 0;
 }

compiler-rt/test/asan/TestCases/Windows/fuse-lld-globals.cpp

 // RUN: %clangxx_asan -fuse-ld=lld -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 #include <string.h>
 int main(int argc, char **argv) {
   static char XXX[10];
   static char YYY[10];
   static char ZZZ[10];
   memset(XXX, 0, 10);
   memset(YYY, 0, 10);
   memset(ZZZ, 0, 10);
   int res = YYY[argc * 10];  // BOOOM
   // CHECK: {{READ of size 1 at 0x.* thread T0}}
   // CHECK: {{    #0 0x.* in main .*fuse-lld-globals.cpp:}}[[@LINE-2]]
-  // CHECK: {{0x.* is located 0 bytes to the right of global variable}}
+  // CHECK: {{0x.* is located 0 bytes after global variable}}
   // CHECK:   {{.*YYY.* of size 10}}
   res += XXX[argc] + ZZZ[argc];
   return res;
 }

compiler-rt/test/asan/TestCases/Windows/global_const_string_oob.cpp

 // RUN: %clang_cl_asan -Od %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 #include <stdio.h>
 
 extern "C" const char *foo = "foobarspam";
 
 int main(void) {
   if (foo[16])
     printf("Boo\n");
   // CHECK-NOT: Boo
   // CHECK: AddressSanitizer: global-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
   // CHECK: READ of size 1 at [[ADDR]] thread T0
   // CHECK-NEXT:   {{#0 .* main .*global_const_string_oob.cpp:}}[[@LINE-5]]
-  // CHECK: [[ADDR]] is located 5 bytes to the right of global variable [[STR:.*]] defined in {{'.*global_const_string_oob.cpp' .*}} of size 11
+  // CHECK: [[ADDR]] is located 5 bytes after global variable [[STR:.*]] defined in {{'.*global_const_string_oob.cpp' .*}} of size 11
   // CHECK:   [[STR]] is ascii string 'foobarspam'
   return 0;
 }
 

compiler-rt/test/asan/TestCases/Windows/intercept_strdup.cpp

int main() {
   fflush(0);
 // CHECK: H3llo
 
   subscript = -1;
   ptr[subscript] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK:   {{#0 .* main .*}}intercept_strdup.cpp:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 1 bytes to the left of 6-byte region
+// CHECK: [[ADDR]] is located 1 bytes before 6-byte region
 // CHECK: allocated by thread T0 here:
 //
 // The first frame is our wrapper normally but will be malloc in the dynamic
 // config.
 // CHECK:   #0 {{.*}} in {{malloc|__asan_wrap_strdup}}
 //
 // The local call to _strdup above may be the second or third frame depending
 // on whether we're using the dynamic config.
 // CHECK:   #{{[12]}} {{.*}} in main {{.*}}intercept_strdup.cpp:[[@LINE-21]]
   free(ptr);
 }

compiler-rt/test/asan/TestCases/Windows/malloc_left_oob.cpp

 // RUN: %clang_cl_asan -Od %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)malloc(42);
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*malloc_left_oob.cpp}}:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK: [[ADDR]] is located 1 bytes before 42-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* malloc }}
 // CHECK-NEXT: {{#1 .* main .*malloc_left_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

compiler-rt/test/asan/TestCases/Windows/malloc_right_oob.cpp

 // RUN: %clang_cl_asan -Od %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)malloc(42);
   buffer[42] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*malloc_right_oob.cpp}}:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 0 bytes to the right of 42-byte region
+// CHECK: [[ADDR]] is located 0 bytes after 42-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* malloc }}
 // CHECK-NEXT: {{#1 .* main .*malloc_right_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

compiler-rt/test/asan/TestCases/Windows/operator_array_new_left_oob.cpp

 // RUN: %clang_cl_asan -Od %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 int main() {
   char *buffer = new char[42];
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*operator_array_new_left_oob.cpp}}:[[@LINE-3]]
 //
-// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK: [[ADDR]] is located 1 bytes before 42-byte region
 // CHECK-LABEL: allocated by thread T0 here:
 // FIXME: The 'operator new' frame should have [].
 // CHECK-NEXT: {{#0 .* operator new}}
 // CHECK-NEXT: {{#1 .* main .*operator_array_new_left_oob.cpp}}:[[@LINE-10]]
   delete [] buffer;
 }

compiler-rt/test/asan/TestCases/Windows/operator_array_new_right_oob.cpp

 // RUN: %clang_cl_asan -Od %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 int main() {
   char *buffer = new char[42];
   buffer[42] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK:   {{#0 .* main .*operator_array_new_right_oob.cpp}}:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 0 bytes to the right of 42-byte region
+// CHECK: [[ADDR]] is located 0 bytes after 42-byte region
 // CHECK: allocated by thread T0 here:
 // FIXME: The 'operator new' frame should have [].
 // CHECK:   {{#0 .* operator new}}
 // CHECK:   {{#1 .* main .*operator_array_new_right_oob.cpp}}:[[@LINE-9]]
   delete [] buffer;
 }

compiler-rt/test/asan/TestCases/Windows/operator_array_new_with_dtor_left_oob.cpp

int main() {
   buffer[hide(-(1 + (int)sizeof(void*) / 4))].x = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 4 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*operator_array_new_with_dtor_left_oob.cpp}}:[[@LINE-3]]
 //
 // FIXME: Currently it says "4 bytes ... left of 172-byte region",
 //        should be "8 bytes ... left of 168-byte region", see
 //        https://code.google.com/p/address-sanitizer/issues/detail?id=314
-// CHECK: [[ADDR]] is located {{.*}} bytes to the left of {{(172|176)}}-byte region
+// CHECK: [[ADDR]] is located {{.*}} bytes before {{(172|176)}}-byte region
 // CHECK-LABEL: allocated by thread T0 here:
 // FIXME: The 'operator new' frame should have [].
 // CHECK-NEXT: {{#0 .* operator new}}
 // CHECK-NEXT: {{#1 .* main .*operator_array_new_with_dtor_left_oob.cpp}}:[[@LINE-13]]
   delete [] buffer;
 }

compiler-rt/test/asan/TestCases/Windows/operator_new_left_oob.cpp

 // RUN: %clang_cl_asan -Od %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 int main() {
   char *buffer = new char;
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK:   {{#0 .* main .*operator_new_left_oob.cpp}}:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 1 bytes to the left of 1-byte region
+// CHECK: [[ADDR]] is located 1 bytes before 1-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK:   {{#0 .* operator new}}
 // CHECK:   {{#1 .* main .*operator_new_left_oob.cpp}}:[[@LINE-8]]
   delete buffer;
 }

compiler-rt/test/asan/TestCases/Windows/operator_new_right_oob.cpp

 // RUN: %clang_cl_asan -Od %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 int main() {
   char *buffer = new char;
   buffer[1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK:   {{#0 .* main .*operator_new_right_oob.cpp}}:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 0 bytes to the right of 1-byte region
+// CHECK: [[ADDR]] is located 0 bytes after 1-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK:   {{#0 .* operator new}}
 // CHECK:   {{#1 .* main .*operator_new_right_oob.cpp}}:[[@LINE-8]]
   delete buffer;
 }

compiler-rt/test/asan/TestCases/Windows/realloc_left_oob.cpp

 // RUN: %clang_cl_asan -Od %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)realloc(0, 42);
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*realloc_left_oob.cpp}}:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK: [[ADDR]] is located 1 bytes before 42-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* realloc }}
 // CHECK-NEXT: {{#1 .* main .*realloc_left_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

compiler-rt/test/asan/TestCases/Windows/realloc_right_oob.cpp

 // RUN: %clang_cl_asan -Od %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)realloc(0, 42);
   buffer[42] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*realloc_right_oob.cpp}}:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 0 bytes to the right of 42-byte region
+// CHECK: [[ADDR]] is located 0 bytes after 42-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* realloc }}
 // CHECK-NEXT: {{#1 .* main .*realloc_right_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

compiler-rt/test/asan/TestCases/Windows/symbols_path.cpp

 // Make sure symbolization works even if the path to the .exe file changes.
 // RUN: mkdir %t || true
 // RUN: %clang_cl_asan -Od %s -Fe%t/symbols_path.exe
 // RUN: not %run %t/symbols_path.exe 2>&1 | FileCheck %s
 // RUN: mkdir %t2 || true
 // RUN: mv %t/* %t2
 // RUN: not %run %t2/symbols_path.exe 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)malloc(42);
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*symbols_path.cpp}}:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK: [[ADDR]] is located 1 bytes before 42-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* malloc}}
 // CHECK-NEXT: {{#1 .* main .*symbols_path.cpp}}:[[@LINE-8]]
   free(buffer);
 }

compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_heap.cpp

 
 int main(void) {
   Parent *p = new Parent;
   Child *c = (Child*)p;  // Intentional error here!
   c->extra_field = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 4 at [[ADDR]] thread T0
 // CHECK:   {{#0 0x[0-9a-f]* in main .*wrong_downcast_on_heap.cpp}}:[[@LINE-3]]
-// CHECK: [[ADDR]] is located 0 bytes to the right of 4-byte region
+// CHECK: [[ADDR]] is located 0 bytes after 4-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK:   #0 {{.*}} operator new
   return 0;
 }
 

compiler-rt/test/asan/TestCases/global-demangle.cpp

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 namespace XXX {
 class YYY {
  public:
   static char ZZZ[];
 };
 char YYY::ZZZ[] = "abc";
 }
 
 int main(int argc, char **argv) {
   return (int)XXX::YYY::ZZZ[argc + 5];  // BOOM
   // CHECK: {{READ of size 1 at 0x.*}}
-  // CHECK: {{0x.* is located 2 bytes to the right of global variable}}
+  // CHECK: {{0x.* is located 2 bytes after global variable}}
   // CHECK: '{{.*}}XXX::YYY::ZZZ{{.*}}' {{.*}} of size 4
   // CHECK: '{{.*}}XXX::YYY::ZZZ{{.*}}' is ascii string 'abc'
 }

compiler-rt/test/asan/TestCases/global-location-nodebug.cpp

 
 /// Solaris ld -S has different semantics.
 // XFAIL: solaris
 
 /// MSVC linker doesn't support `-S`.
 // UNSUPPORTED: windows
 
 // CHECK: AddressSanitizer: global-buffer-overflow
-// CLASS_STATIC-NO-G: 0x{{.*}} is located 4 bytes to the right of global variable '{{.*}}C::array{{.*}}' defined in '{{.*}}global-location.cpp' {{.*}} of size 40
-// GLOB-NO-G: 0x{{.*}} is located 4 bytes to the right of global variable '{{.*}}global{{.*}}' defined in '{{.*}}global-location.cpp' {{.*}} of size 40
-// FUNC_STATIC-NO-G: 0x{{.*}} is located 4 bytes to the right of global variable '{{.*}}main::array{{.*}}' defined in '{{.*}}global-location.cpp' {{.*}} of size 40
-// LITERAL-NO-G: 0x{{.*}} is located 0 bytes to the right of global variable {{.*}} defined in '{{.*}}global-location.cpp' {{.*}} of size 11
+// CLASS_STATIC-NO-G: 0x{{.*}} is located 4 bytes after global variable '{{.*}}C::array{{.*}}' defined in '{{.*}}global-location.cpp' {{.*}} of size 40
+// GLOB-NO-G: 0x{{.*}} is located 4 bytes after global variable '{{.*}}global{{.*}}' defined in '{{.*}}global-location.cpp' {{.*}} of size 40
+// FUNC_STATIC-NO-G: 0x{{.*}} is located 4 bytes after global variable '{{.*}}main::array{{.*}}' defined in '{{.*}}global-location.cpp' {{.*}} of size 40
+// LITERAL-NO-G: 0x{{.*}} is located 0 bytes after global variable {{.*}} defined in '{{.*}}global-location.cpp' {{.*}} of size 11
 // CHECK: SUMMARY: AddressSanitizer: global-buffer-overflow

compiler-rt/test/asan/TestCases/global-location.cpp

 // UNSUPPORTED: darwin
 
 // CHECK: AddressSanitizer: global-buffer-overflow
 
 #include <string.h>
 
 struct C {
   static int array[10];
-  // CLASS_STATIC:      0x{{.*}} is located 4 bytes to the right of global variable 'C::array' defined in '{{.*}}global-location.cpp:[[@LINE-1]]' {{.*}} of size 40
+  // CLASS_STATIC:      0x{{.*}} is located 4 bytes after global variable 'C::array' defined in '{{.*}}global-location.cpp:[[@LINE-1]]' {{.*}} of size 40
 };
 
 int global[10];
-// GLOB:      0x{{.*}} is located 4 bytes to the right of global variable 'global' defined in '{{.*}}global-location.cpp:[[@LINE-1]]' {{.*}} of size 40
+// GLOB:      0x{{.*}} is located 4 bytes after global variable 'global' defined in '{{.*}}global-location.cpp:[[@LINE-1]]' {{.*}} of size 40
 int C::array[10];
 
 int main(int argc, char **argv) {
   int one = argc - 1;
   switch (argv[1][0]) {
   case 'g': return global[one * 11];
   case 'c': return C::array[one * 11];
   case 'f':
     static int array[10];
-    // FUNC_STATIC:      0x{{.*}} is located 4 bytes to the right of global variable 'main::array' defined in '{{.*}}global-location.cpp:[[@LINE-1]]' {{.*}} of size 40
+    // FUNC_STATIC:      0x{{.*}} is located 4 bytes after global variable 'main::array' defined in '{{.*}}global-location.cpp:[[@LINE-1]]' {{.*}} of size 40
     memset(array, 0, 10);
     return array[one * 11];
   case 'l':
     const char *str = "0123456789";
-    // LITERAL:      0x{{.*}} is located 0 bytes to the right of global variable {{.*}} defined in '{{.*}}global-location.cpp:[[@LINE-1]]' {{.*}} of size 11
+    // LITERAL:      0x{{.*}} is located 0 bytes after global variable {{.*}} defined in '{{.*}}global-location.cpp:[[@LINE-1]]' {{.*}} of size 11
     return str[one * 11];
   }
   return 0;
 }
 
 // CHECK: SUMMARY: AddressSanitizer: global-buffer-overflow

compiler-rt/test/asan/TestCases/global-overflow.cpp

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 #include <string.h>
 int main(int argc, char **argv) {
   static char XXX[10];
   static char YYY[10];
   static char ZZZ[10];
   memset(XXX, 0, 10);
   memset(YYY, 0, 10);
   memset(ZZZ, 0, 10);
   int res = YYY[argc * 10];  // BOOOM
   // CHECK: {{READ of size 1 at 0x.* thread T0}}
   // CHECK: {{    #0 0x.* in main .*global-overflow.cpp:}}[[@LINE-2]]
-  // CHECK: {{0x.* is located 0 bytes to the right of global variable}}
+  // CHECK: {{0x.* is located 0 bytes after global variable}}
   // CHECK:   {{.*YYY.* of size 10}}
   res += XXX[argc] + ZZZ[argc];
   return res;
 }

compiler-rt/test/asan/TestCases/global-underflow.cpp

 // RUN: %clangxx_asan -O0 %s %p/Helpers/underflow.cpp -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O1 %s %p/Helpers/underflow.cpp -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s %p/Helpers/underflow.cpp -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O3 %s %p/Helpers/underflow.cpp -o %t && not %run %t 2>&1 | FileCheck %s
 
 int XXX[2] = {2, 3};
 extern int YYY[];
 #include <string.h>
 int main(int argc, char **argv) {
   memset(XXX, 0, 2*sizeof(int));
   // CHECK: {{READ of size 4 at 0x.* thread T0}}
   // CHECK: {{    #0 0x.* in main .*global-underflow.cpp:}}[[@LINE+3]]
-  // CHECK: {{0x.* is located 4 bytes to the left of global variable}}
+  // CHECK: {{0x.* is located 4 bytes before global variable}}
   // CHECK:   {{.*YYY.* of size 12}}
   int res = YYY[-1];
   return res;
 }

compiler-rt/test/asan/TestCases/heap-overflow.cpp

 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   char *x = (char*)malloc(10 * sizeof(char));
   memset(x, 0, 10);
   int res = x[argc * 10];  // BOOOM
   // CHECK: {{READ of size 1 at 0x.* thread T0}}
   // CHECK: {{    #0 0x.* in main .*heap-overflow.cpp:}}[[@LINE-2]]
-  // CHECK: {{0x.* is located 0 bytes to the right of 10-byte region}}
+  // CHECK: {{0x.* is located 0 bytes after 10-byte region}}
   // CHECK: {{allocated by thread T0 here:}}
 
   // CHECK: {{    #0 0x.* in .*malloc}}
   free(x);
   return res;
 }

compiler-rt/test/asan/TestCases/huge_negative_hea_oob.cpp

 // RUN: %clangxx_asan %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O %s -o %t && not %run %t 2>&1 | FileCheck %s
-// Check that we can find huge buffer overflows to the left.
+// Check that we can find huge buffer overflows before.
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   char *x = (char*)malloc(1 << 20);
   memset(x, 0, 10);
   int res = x[-argc * 4000];  // BOOOM
-  // CHECK: is located 4000 bytes to the left of
+  // CHECK: is located 4000 bytes before
   free(x);
   return res;
 }

compiler-rt/test/asan/TestCases/large_func_test.cpp

static void LargeFunction(int *x, int zero) {
   x[18]++;
   x[19]++;
 }
 
 int main(int argc, char **argv) {
   int *x = new int[100];
   LargeFunction(x, argc - 1);
   // CHECK: {{    #1 0x.* in main .*large_func_test.cpp:}}[[@LINE-1]]
-  // CHECK: {{0x.* is located 12 bytes to the right of 400-byte region}}
+  // CHECK: {{0x.* is located 12 bytes after 400-byte region}}
   // CHECK: {{allocated by thread T0 here:}}
   // CHECK-Linux:  {{    #0 0x.* in operator new}}
   // CHECK-SunOS:  {{    #0 0x.* in operator new}}
   // CHECK-Windows:{{    #0 0x.* in operator new}}
   // CHECK-FreeBSD:{{    #0 0x.* in operator new}}
   // CHECK-Darwin: {{    #0 0x.* in .*_Zna}}
   // CHECK-NEXT:   {{    #1 0x.* in main .*large_func_test.cpp:}}[[@LINE-10]]
   int y = x[argc];
   delete[] x;
   return y;
 }

compiler-rt/test/asan/TestCases/load_and_store_n.cpp

 // RUN: %clangxx_asan -O2 -fsanitize-address-outline-instrumentation %s -o %t \
 // RUN:   -mllvm -asan-force-experiment=42
 // RUN: not %run %t A 2>&1 | FileCheck %s --check-prefix=CHECK_0_BYTES
 // RUN: not %run %t B 2>&1 | FileCheck %s --check-prefix=CHECK_0_BYTES
 // RUN: not %run %t C 2>&1 | FileCheck %s --check-prefix=CHECK_1_BYTES
 // RUN: not %run %t D 2>&1 | FileCheck %s --check-prefix=CHECK_1_BYTES
 
 // CHECK_0_BYTES: ERROR: AddressSanitizer: global-buffer-overflow on address [[ADDR:.*]] at
-// CHECK_0_BYTES: [[ADDR]] is located 0 bytes to the right
+// CHECK_0_BYTES: [[ADDR]] is located 0 bytes after
 
 // CHECK_1_BYTES: ERROR: AddressSanitizer: global-buffer-overflow on address [[ADDR:.*]] at
-// CHECK_1_BYTES: [[ADDR]] is located 1 bytes to the right
+// CHECK_1_BYTES: [[ADDR]] is located 1 bytes after
 
 #include <sanitizer/asan_interface.h>
 
 #include <stdlib.h>
 #include <string.h>
 
 static int64_t mem = -1;
 static int64_t *volatile G = &mem;

compiler-rt/test/asan/TestCases/partial_right.cpp

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 #include <stdlib.h>
 int main(int argc, char **argv) {
   volatile int *x = (int*)malloc(2*sizeof(int) + 2);
   int res = x[2];  // BOOOM
   // CHECK: {{READ of size 4 at 0x.* thread T0}}
-  // CHECK: [[ADDR:0x[01-9a-fa-f]+]] is located 0 bytes to the right of {{.*}}-byte region [{{.*}},{{.*}}[[ADDR]])
+  // CHECK: [[ADDR:0x[01-9a-fa-f]+]] is located 0 bytes after {{.*}}-byte region [{{.*}},{{.*}}[[ADDR]])
   return res;
 }

compiler-rt/test/asan/TestCases/poison_partial.cpp

int main(int argc, char **argv) {
   if (argc >= 2)
     x = new char[21];
   else
     x = &g[0];
   memset(x, 0, 21);
   int *y = (int*)x;
   return y[5];
 }
-// CHECK: 0 bytes to the right
+// CHECK: 0 bytes after

compiler-rt/test/asan/TestCases/strncpy-overflow.cpp

int main(int argc, char **argv) {
   char *hello = (char*)malloc(6);
   strcpy(hello, "hello");
   int rval = sink_memory(6, hello);
   char *short_buffer = (char*)malloc(9);
   strncpy(short_buffer, hello, 10);  // BOOM
   // CHECK: {{WRITE of size 10 at 0x.* thread T0}}
   // CHECK: {{    #0 0x.* in .*strncpy}}
   // CHECK: {{    #1 0x.* in main .*strncpy-overflow.cpp:}}[[@LINE-3]]
-  // CHECK: {{0x.* is located 0 bytes to the right of 9-byte region}}
+  // CHECK: {{0x.* is located 0 bytes after 9-byte region}}
   // CHECK: {{allocated by thread T0 here:}}
   // CHECK: {{    #0 0x.* in .*malloc}}
   // CHECK: {{    #1 0x.* in main .*strncpy-overflow.cpp:}}[[@LINE-8]]
   return rval + sink_memory(9, short_buffer);
 }

compiler-rt/test/asan/TestCases/unaligned_loads_and_stores.cpp

int main(int argc, char **argv) {
   if (argc != 2) return 1;
   char *x = new char[16];
   memset(x, 0xab, 16);
   int res = 1;
   switch (argv[1][0]) {
     case 'A': res = __sanitizer_unaligned_load16(x + 15); break;
 //  CHECK-A ERROR: AddressSanitizer: heap-buffer-overflow on address
 //  CHECK-A: main{{.*}}unaligned_loads_and_stores.cpp:[[@LINE-2]]
-//  CHECK-A: is located 0 bytes to the right of 16-byte region
+//  CHECK-A: is located 0 bytes after 16-byte region
     case 'B': res = __sanitizer_unaligned_load32(x + 14); break;
 //  CHECK-B: main{{.*}}unaligned_loads_and_stores.cpp:[[@LINE-1]]
     case 'C': res = __sanitizer_unaligned_load32(x + 13); break;
 //  CHECK-C: main{{.*}}unaligned_loads_and_stores.cpp:[[@LINE-1]]
     case 'D': res = __sanitizer_unaligned_load64(x + 15); break;
 //  CHECK-D: main{{.*}}unaligned_loads_and_stores.cpp:[[@LINE-1]]
     case 'E': res = __sanitizer_unaligned_load64(x + 9); break;
 //  CHECK-E: main{{.*}}unaligned_loads_and_stores.cpp:[[@LINE-1]]
 
     case 'K': __sanitizer_unaligned_store16(x + 15, 0); break;
 //  CHECK-K ERROR: AddressSanitizer: heap-buffer-overflow on address
 //  CHECK-K: main{{.*}}unaligned_loads_and_stores.cpp:[[@LINE-2]]
-//  CHECK-K: is located 0 bytes to the right of 16-byte region
+//  CHECK-K: is located 0 bytes after 16-byte region
     case 'L': __sanitizer_unaligned_store32(x + 15, 0); break;
 //  CHECK-L: main{{.*}}unaligned_loads_and_stores.cpp:[[@LINE-1]]
     case 'M': __sanitizer_unaligned_store32(x + 13, 0); break;
 //  CHECK-M: main{{.*}}unaligned_loads_and_stores.cpp:[[@LINE-1]]
     case 'N': __sanitizer_unaligned_store64(x + 10, 0); break;
 //  CHECK-N: main{{.*}}unaligned_loads_and_stores.cpp:[[@LINE-1]]
     case 'O': __sanitizer_unaligned_store64(x + 14, 0); break;
 //  CHECK-O: main{{.*}}unaligned_loads_and_stores.cpp:[[@LINE-1]]
   }
   delete[] x;
   return res;
 }