[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 ↗

(On Diff #458259)

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_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 after",
                  (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 before",
                  (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(

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
   EXPECT_DEATH(MEMSET(array + length + 1, 0, 10),
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
   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
   EXPECT_DEATH(M::transfer(dest, src - 1, size),
                LeftOOBReadMessage(sizeof(T)));

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 to the left 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));
   }

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

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];

 #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(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/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_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/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/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_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_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_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/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/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/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/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/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;
 }