[asan] Support line numbers in StackVarDescr

[kubamracek]

Summary

When -fsanitize-address-use-after-scope is used, the instrumentation produces line numbers in stack frame descriptions. This patch make sure the ASan runtime supports this format (ParseFrameDescription needs to be able to parse "varname:line") and prepares lit tests to allow line numbers in ASan report output.

[vitalybuka]

LGTM

compiler-rt/trunk/lib/asan/asan_descriptions.cc

static void PrintAccessAndVarIntersection(const StackVarDescr &var, uptr addr,
   InternalScopedString str(1024);
   str.append("    [%zd, %zd)", var.beg, var_end);
   // Render variable name.
   str.append(" '");
   for (uptr i = 0; i < var.name_len; ++i) {
     str.append("%c", var.name_pos[i]);
   }
   str.append("'");
+  if (var.line > 0) {
+    str.append(" (line %d)", var.line);
+  }
   if (pos_descr) {
     Decorator d;
     // FIXME: we may want to also print the size of the access here,
     // but in case of accesses generated by memset it may be confusing.
     str.append("%s <== Memory access at offset %zd %s this variable%s\n",
                d.Location(), addr, pos_descr, d.EndLocation());
   } else {
     str.append("\n");

compiler-rt/trunk/lib/asan/asan_report.h

 
 namespace __asan {
 
 struct StackVarDescr {
   uptr beg;
   uptr size;
   const char *name_pos;
   uptr name_len;
+  uptr line;
 };
 
 // Returns the number of globals close to the provided address and copies
 // them to "globals" array.
 int GetGlobalsForAddress(uptr addr, __asan_global *globals, u32 *reg_sites,
                          int max_globals);
 
 const char *MaybeDemangleGlobalName(const char *name);

compiler-rt/trunk/lib/asan/asan_report.cc

 // ---------------------- Address Descriptions ------------------- {{{1
 
 bool ParseFrameDescription(const char *frame_descr,
                            InternalMmapVector<StackVarDescr> *vars) {
   CHECK(frame_descr);
   char *p;
   // This string is created by the compiler and has the following form:
   // "n alloc_1 alloc_2 ... alloc_n"
-  // where alloc_i looks like "offset size len ObjectName".
+  // where alloc_i looks like "offset size len ObjectName"
+  // or                       "offset size len ObjectName:line".
   uptr n_objects = (uptr)internal_simple_strtoll(frame_descr, &p, 10);
   if (n_objects == 0)
     return false;
 
   for (uptr i = 0; i < n_objects; i++) {
     uptr beg  = (uptr)internal_simple_strtoll(p, &p, 10);
     uptr size = (uptr)internal_simple_strtoll(p, &p, 10);
     uptr len  = (uptr)internal_simple_strtoll(p, &p, 10);
     if (beg == 0 || size == 0 || *p != ' ') {
       return false;
     }
     p++;
-    StackVarDescr var = {beg, size, p, len};
+    char *colon_pos = internal_strchr(p, ':');
+    uptr line = 0;
+    uptr name_len = len;
+    if (colon_pos != nullptr && colon_pos < p + len) {
+      name_len = colon_pos - p;
+      line = (uptr)internal_simple_strtoll(colon_pos + 1, nullptr, 10);
+    }
+    StackVarDescr var = {beg, size, p, name_len, line};
     vars->push_back(var);
     p += len;
   }
 
   return true;
 }
 
 // -------------------- Different kinds of reports ----------------- {{{1

compiler-rt/trunk/test/asan/TestCases/Linux/memmem_test.cc

int main(int argc, char **argv) {
   void *res;
   if (argc == 1)
     res = memmem(a1, sizeof(a1) + 1, a2, sizeof(a2));  // BOOM
   else
     res = memmem(a1, sizeof(a1), a2, sizeof(a2) + 1);  // BOOM
   // A1: AddressSanitizer: stack-buffer-overflow
   // A1: {{#0.*memmem}}
   // A1-NEXT: {{#1.*main}}
-  // A1: 'a1' <== Memory access at offset
+  // A1: 'a1'{{.*}} <== Memory access at offset
   //
   // A2: AddressSanitizer: stack-buffer-overflow
   // A2: {{#0.*memmem}}
-  // A2: 'a2' <== Memory access at offset
+  // A2: 'a2'{{.*}} <== Memory access at offset
   return res == NULL;
 }

compiler-rt/trunk/test/asan/TestCases/Posix/stack-use-after-return.cc

 
 __attribute__((noinline))
 void Func2(char *x) {
   fprintf(stderr, "2: %p\n", x);
   *x = 1;
   // CHECK: WRITE of size 1 {{.*}} thread T0
   // CHECK:     #0{{.*}}Func2{{.*}}stack-use-after-return.cc:[[@LINE-2]]
   // CHECK: is located in stack of thread T0 at offset
-  // CHECK: 'local' <== Memory access at offset {{16|32}} is inside this variable
+  // CHECK: 'local'{{.*}} <== Memory access at offset {{16|32}} is inside this variable
   // THREAD: WRITE of size 1 {{.*}} thread T{{[1-9]}}
   // THREAD:     #0{{.*}}Func2{{.*}}stack-use-after-return.cc:[[@LINE-6]]
   // THREAD: is located in stack of thread T{{[1-9]}} at offset
-  // THREAD: 'local' <== Memory access at offset {{16|32}} is inside this variable
+  // THREAD: 'local'{{.*}} <== Memory access at offset {{16|32}} is inside this variable
   // CHECK-20: T0: FakeStack created:{{.*}} stack_size_log: 20
   // CHECK-24: T0: FakeStack created:{{.*}} stack_size_log: 24
 }
 
 void *Thread(void *unused)  {
   Func2(Func1());
   return NULL;
 }

compiler-rt/trunk/test/asan/TestCases/Windows/dll_intercept_memchr.cc

int test_function() {
   memchr(buff, 'z', 7);
 // CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: READ of size 7 at [[ADDR]] thread T0
 // CHECK-NEXT:  __asan_wrap_memchr
 // CHECK-NEXT:  memchr
 // CHECK-NEXT:  test_function {{.*}}dll_intercept_memchr.cc:[[@LINE-5]]
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
 // CHECK-NEXT:  test_function {{.*}}dll_intercept_memchr.cc
-// CHECK: 'buff' <== Memory access at offset {{.*}} overflows this variable
+// CHECK: 'buff'{{.*}} <== Memory access at offset {{.*}} overflows this variable
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/Windows/dll_intercept_memcpy.cc

// CHECK: Initial test OK
 
   memcpy(buff2, buff1, 6);
 // CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 6 at [[ADDR]] thread T0
 // CHECK-NEXT:  __asan_{{.*}}memcpy
 // CHECK-NEXT:  test_function {{.*}}dll_intercept_memcpy.cc:[[@LINE-4]]
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
 // CHECK-NEXT:  test_function {{.*}}dll_intercept_memcpy.cc
-// CHECK: 'buff2' <== Memory access at offset {{.*}} overflows this variable
+// CHECK: 'buff2'{{.*}} <== Memory access at offset {{.*}} overflows this variable
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/Windows/dll_intercept_memcpy_indirect.cc

// CHECK: Initial test OK
   call_memcpy(&memcpy, buff2, buff1, 6);
 // CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 6 at [[ADDR]] thread T0
 // CHECK-NEXT:  __asan_{{.*}}mem{{.*}}
 // CHECK-NEXT:  call_memcpy
 // CHECK-NEXT:  test_function {{.*}}dll_intercept_memcpy_indirect.cc:[[@LINE-5]]
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
 // CHECK-NEXT:  test_function {{.*}}dll_intercept_memcpy_indirect.cc
-// CHECK: 'buff2' <== Memory access at offset {{.*}} overflows this variable
+// CHECK: 'buff2'{{.*}} <== Memory access at offset {{.*}} overflows this variable
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/Windows/dll_intercept_memset.cc

// CHECK: Initial test OK
 
   memset(buff, 'c', 6);
 // CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 6 at [[ADDR]] thread T0
 // CHECK-NEXT:  __asan_memset
 // CHECK-NEXT:  test_function {{.*}}dll_intercept_memset.cc:[[@LINE-4]]
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
 // CHECK-NEXT:  test_function {{.*}}dll_intercept_memset.cc
-// CHECK: 'buff' <== Memory access at offset {{.*}} overflows this variable
+// CHECK: 'buff'{{.*}} <== Memory access at offset {{.*}} overflows this variable
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/Windows/dll_noreturn.cc

 // CHECK: AddressSanitizer: stack-buffer-underflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT:  noreturn_f{{.*}}dll_noreturn.cc:[[@LINE-4]]
 // CHECK-NEXT:  test_function{{.*}}dll_noreturn.cc
 // CHECK-NEXT:  main{{.*}}dll_host.cc
 //
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
 // CHECK-NEXT:  noreturn_f{{.*}}dll_noreturn.cc
-// CHECK: 'buffer' <== Memory access at offset [[OFFSET]] underflows this variable
+// CHECK: 'buffer'{{.*}} <== Memory access at offset [[OFFSET]] underflows this variable
 // CHECK-LABEL: SUMMARY
 }
 
 extern "C" __declspec(dllexport)
 int test_function() {
   noreturn_f();
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/Windows/dll_poison_unpoison.cc

 // CHECK: AddressSanitizer: use-after-poison on address [[ADDR:0x[0-9a-f]+]]
 // CHECK-NEXT: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: should_crash{{.*}}\dll_poison_unpoison.cc
 // CHECK-NEXT: test_function{{.*}}\dll_poison_unpoison.cc:[[@LINE-4]]
 // CHECK-NEXT: main
 //
 // CHECK: [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
 // CHECK-NEXT: test_function{{.*}}\dll_poison_unpoison.cc
-// CHECK: 'buffer' <== Memory access at offset [[OFFSET]] is inside this variable
+// CHECK: 'buffer'{{.*}} <== Memory access at offset [[OFFSET]] is inside this variable
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/Windows/dll_stack_use_after_return.cc

int test_function() {
   *x = 42;
 // CHECK: AddressSanitizer: stack-use-after-return
 // CHECK: WRITE of size 1 at [[ADDR:.*]] thread T0
 // CHECK-NEXT:  test_function{{.*}}dll_stack_use_after_return.cc:[[@LINE-3]]
 // CHECK-NEXT:  main
 //
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
 // CHECK-NEXT: #0 {{.*}} foo{{.*}}dll_stack_use_after_return.cc
-// CHECK: 'stack_buffer' <== Memory access at offset [[OFFSET]] is inside this variable
+// CHECK: 'stack_buffer'{{.*}} <== Memory access at offset [[OFFSET]] is inside this variable
   return 0;
 }
 

compiler-rt/trunk/test/asan/TestCases/Windows/dll_thread_stack_array_left_oob.cc

DWORD WINAPI thread_proc(void *context) {
   stack_buffer[subscript] = 42;
 // CHECK: AddressSanitizer: stack-buffer-underflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T1
 // CHECK-NEXT:  thread_proc{{.*}}dll_thread_stack_array_left_oob.cc:[[@LINE-3]]
 //
 // CHECK: Address [[ADDR]] is located in stack of thread T1 at offset [[OFFSET:.*]] in frame
 // CHECK-NEXT:  thread_proc{{.*}}dll_thread_stack_array_left_oob.cc
 //
-// CHECK: 'stack_buffer' <== Memory access at offset [[OFFSET]] underflows this variable
+// CHECK: 'stack_buffer'{{.*}} <== Memory access at offset [[OFFSET]] underflows this variable
 
   return 0;
 }
 
 extern "C" __declspec(dllexport)
 int test_function() {
   HANDLE thr = CreateThread(NULL, 0, thread_proc, NULL, 0, NULL);
 // CHECK-LABEL: Thread T1 created by T0 here:

compiler-rt/trunk/test/asan/TestCases/Windows/intercept_memcpy.cc

// CHECK: Initial test OK
   call_memcpy(&memcpy, buff2, buff1, 6);
 // CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 6 at [[ADDR]] thread T0
 // CHECK-NEXT:  __asan_{{.*}}mem{{.*}}
 // CHECK-NEXT:  call_mem{{.*}}
 // CHECK-NEXT:  main {{.*}}intercept_memcpy.cc:[[@LINE-5]]
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
 // CHECK-NEXT:   #0 {{.*}} main
-// CHECK: 'buff2' <== Memory access at offset {{.*}} overflows this variable
+// CHECK: 'buff2'{{.*}} <== Memory access at offset {{.*}} overflows this variable
 }

compiler-rt/trunk/test/asan/TestCases/Windows/intercept_strlen.cc

// CHECK: Initial test OK
   int len = strlen(str);
 // CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // FIXME: Should be READ of size 1, see issue 155.
 // CHECK: READ of size {{[0-9]+}} at [[ADDR]] thread T0
 // CHECK:      strlen 
 // CHECK-NEXT: main {{.*}}intercept_strlen.cc:[[@LINE-5]]
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
 // CHECK-NEXT: main {{.*}}intercept_strlen.cc
-// CHECK: 'str' <== Memory access at offset {{.*}} overflows this variable
+// CHECK: 'str'{{.*}} <== Memory access at offset {{.*}} overflows this variable
   return len < 6;
 }

compiler-rt/trunk/test/asan/TestCases/Windows/stack_array_left_oob.cc

 // RUN: %clang_cl_asan -O0 %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 
 int main() {
   int subscript = -1;
   char buffer[42];
   buffer[subscript] = 42;
 // CHECK: AddressSanitizer: stack-buffer-underflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cc}}:[[@LINE-3]]
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
 // CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cc}}
-// CHECK: 'buffer' <== Memory access at offset [[OFFSET]] underflows this variable
+// CHECK: 'buffer'{{.*}} <== Memory access at offset [[OFFSET]] underflows this variable
 }

compiler-rt/trunk/test/asan/TestCases/Windows/stack_array_right_oob.cc

 // RUN: %clang_cl_asan -O0 %s -Fe%t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 
 int main() {
   int subscript = 42;
   char buffer[42];
   buffer[subscript] = 42;
 // CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cc}}:[[@LINE-3]]
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
 // CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cc}}
-// CHECK: 'buffer' <== Memory access at offset [[OFFSET]] overflows this variable
+// CHECK: 'buffer'{{.*}} <== Memory access at offset [[OFFSET]] overflows this variable
 }

compiler-rt/trunk/test/asan/TestCases/Windows/stack_use_after_return.cc

int main() {
   *x = 42;
 // CHECK: AddressSanitizer: stack-use-after-return
 // CHECK: WRITE of size 1 at {{.*}} thread T0
 // CHECK-NEXT: {{#0 0x.* in main .*stack_use_after_return.cc}}:[[@LINE-3]]
 //
 // CHECK: is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
 // CHECK-NEXT: {{#0 0x.* in foo.*stack_use_after_return.cc}}
 //
-// CHECK: 'stack_buffer' <== Memory access at offset [[OFFSET]] is inside this variable
+// CHECK: 'stack_buffer'{{.*}} <== Memory access at offset [[OFFSET]] is inside this variable
 }

compiler-rt/trunk/test/asan/TestCases/Windows/wrong_downcast_on_stack.cc

int main(void) {
   Parent p;
   Child *c = (Child*)&p;  // Intentional error here!
   c->extra_field = 42;
 // CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 4 at [[ADDR]] thread T0
 // CHECK-NEXT:  {{#0 0x[0-9a-f]* in main .*wrong_downcast_on_stack.cc}}:[[@LINE-3]]
 // CHECK: [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:[0-9]+]] in frame
 // CHECK-NEXT:  {{#0 0x[0-9a-f]* in main }}
-// CHECK:  'p' <== Memory access at offset [[OFFSET]] overflows this variable
+// CHECK:  'p'{{.*}} <== Memory access at offset [[OFFSET]] overflows this variable
   return 0;
 }
 

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

int main(int argc, char **argv) {
   memset(BBB, 0, sizeof(BBB));
   memset(CCC, 0, sizeof(CCC));
   int res = 0;
   char *p = AAA + idx;
   printf("AAA: %p\ny: %p\nz: %p\np: %p\n", AAA, BBB, CCC, p);
   // make sure BBB and CCC are not removed;
   return *(short*)(p) + BBB[argc % 2] + CCC[argc % 2];
 }
-// CHECK-m2: 'AAA' <== {{.*}}underflows this variable
-// CHECK-m1: 'AAA' <== {{.*}}partially underflows this variable
-// CHECK-9:  'AAA' <== {{.*}}partially overflows this variable
-// CHECK-10: 'AAA' <== {{.*}}overflows this variable
-// 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
+// CHECK-m2: 'AAA'{{.*}} <== {{.*}}underflows this variable
+// CHECK-m1: 'AAA'{{.*}} <== {{.*}}partially underflows this variable
+// CHECK-9:  'AAA'{{.*}} <== {{.*}}partially overflows this variable
+// CHECK-10: 'AAA'{{.*}} <== {{.*}}overflows this variable
+// 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

compiler-rt/trunk/test/asan/TestCases/strcasestr-1.c

 #include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   char *r = 0;
   char s2[] = "c";
   char s1[4] = "abC";
   __asan_poison_memory_region ((char *)&s1[2], 2);
   r = strcasestr(s1, s2);
-  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK:'s1'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == s1 + 2);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strcasestr-2.c

 
 int main(int argc, char **argv) {
   char *r = 0;
   char s1[] = "ab";
   char s2[4] = "cba";
   __asan_poison_memory_region ((char *)&s2[2], 2);
   r = strcasestr(s1, s2);
   assert(r == 0);
-  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK:'s2'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strcspn-1.c

 // Test string s1 overflow in strcspn function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strspn asan option
 // RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 #include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   size_t r;
   char s2[] = "ab";
   char s1[4] = "caB";
   __asan_poison_memory_region ((char *)&s1[2], 2);
   r = strcspn(s1, s2);
-  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK:'s1'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == 1);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strcspn-2.c

 // Test stopset overflow in strcspn function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strcspn asan option
 // RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 #include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   size_t r;
   char s1[] = "ab";
   char s2[4] = "abc";
   __asan_poison_memory_region ((char *)&s2[2], 2);
   r = strcspn(s1, s2);
-  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK:'s2'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == 0);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strpbrk-1.c

 // Test string s1 overflow in strpbrk function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strpbrk asan option
 // RUN: %env_asan_opts=intercept_strpbrk=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 #include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   char *r;
   char s2[] = "ab";
   char s1[4] = "cab";
   __asan_poison_memory_region ((char *)&s1[2], 2);
   r = strpbrk(s1, s2);
-  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK:'s1'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == s1 + 1);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strpbrk-2.c

 // Test stopset overflow in strpbrk function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strpbrk asan option
 // RUN: %env_asan_opts=intercept_strpbrk=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 #include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   char *r;
   char s1[] = "c";
   char s2[4] = "bca";
   __asan_poison_memory_region ((char *)&s2[2], 2);
   r = strpbrk(s1, s2);
-  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK:'s2'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == s1);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strspn-1.c

 // Test string s1 overflow in strspn function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strspn asan option
 // RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 #include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   size_t r;
   char s2[] = "ab";
   char s1[4] = "acb";
   __asan_poison_memory_region ((char *)&s1[2], 2);
   r = strspn(s1, s2);
-  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK:'s1'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == 1);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strspn-2.c

 // Test stopset overflow in strspn function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strspn asan option
 // RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 #include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   size_t r;
   char s1[] = "bbc";
   char s2[5] = "abcd";
   __asan_poison_memory_region ((char *)&s2[3], 2);
   r = strspn(s1, s2);
-  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK:'s2'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r >= 2);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strstr-1.c

 #include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   char *r = 0;
   char s2[] = "c";
   char s1[4] = "acb";
   __asan_poison_memory_region ((char *)&s1[2], 2);
   r = strstr(s1, s2);
-  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} {{partially overflows this variable|is inside this variable}}
+  // CHECK:'s1'{{.*}} <== Memory access at offset {{[0-9]+}} {{partially overflows this variable|is inside this variable}}
   assert(r == s1 + 1);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strstr-2.c

 #include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   char *r = 0;
   char s1[] = "ab";
   char s2[4] = "cab";
   __asan_poison_memory_region ((char *)&s2[2], 2);
   r = strstr(s1, s2);
-  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK:'s2'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == 0);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strtok.c

 // Check that we find overflows in the delimiters on the first call
 // with strict_string_checks.
 void test1() {
   char *token;
   char s[4] = "abc";
   char token_delimiter[2] = "b";
   __asan_poison_memory_region ((char *)&token_delimiter[1], 2);
   token = strtok(s, token_delimiter);
-  // CHECK1:'token_delimiter' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK1: 'token_delimiter'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
 }
 
 // Check that we find overflows in the delimiters on the second call (str == NULL)
 // with strict_string_checks.
 void test2() {
   char *token;
   char s[4] = "abc";
   char token_delimiter[2] = "b";
   token = strtok(s, token_delimiter);
   assert(strcmp(token, "a") == 0);
   __asan_poison_memory_region ((char *)&token_delimiter[1], 2);
   token = strtok(NULL, token_delimiter);
-  // CHECK2:'token_delimiter' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK2: 'token_delimiter'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
 }
 
 // Check that we find overflows in the string (only on the first call) with strict_string_checks.
 void test3() {
   char *token;
   char s[4] = "abc";
   char token_delimiter[2] = "b";
   __asan_poison_memory_region ((char *)&s[3], 2);
   token = strtok(s, token_delimiter);
-  // CHECK3:'s' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK3: 's'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
 }
 
 // Check that we do not crash when strtok returns NULL with strict_string_checks.
 void test4() {
   char *token;
   char s[] = "";
   char token_delimiter[] = "a";
   token = strtok(s, token_delimiter);
   assert(token == NULL);
 }
 
 // Check that we find overflows in the string (only on the first call) with !strict_string_checks.
 void test5() {
   char *token;
   char s[4] = "abc";
   char token_delimiter[2] = "d";
   __asan_poison_memory_region ((char *)&s[2], 2);
   __asan_poison_memory_region ((char *)&token_delimiter[1], 2);
   token = strtok(s, token_delimiter);
-  // CHECK5:'s' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  // CHECK5: 's'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
 }
 
 // Check that we find overflows in the delimiters (only on the first call) with !strict_string_checks.
 void test6() {
   char *token;
   char s[4] = "abc";
   char token_delimiter[1] = {'d'};
   __asan_poison_memory_region ((char *)&token_delimiter[1], 2);
   token = strtok(s, &token_delimiter[1]);
-  // CHECK6:'token_delimiter' <== Memory access at offset {{[0-9]+}} overflows this variable
+  // CHECK6: 'token_delimiter'{{.*}} <== Memory access at offset {{[0-9]+}} overflows this variable
 }
 
 int main(int argc, char **argv) {
   if (argc != 2) return 1;
   if (!strcmp(argv[1], "test1")) test1();
   if (!strcmp(argv[1], "test2")) test2();
   if (!strcmp(argv[1], "test3")) test3();
   if (!strcmp(argv[1], "test4")) test4();
   if (!strcmp(argv[1], "test5")) test5();
   if (!strcmp(argv[1], "test6")) test6();
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/use-after-scope-inlined.cc

 
 int main(int argc, char *argv[]) {
   inlined(argc);
   return arr[argc - 1];  // BOOM
   // CHECK: ERROR: AddressSanitizer: stack-use-after-scope
   // CHECK: READ of size 4 at 0x{{.*}} thread T0
   // CHECK:   #0 0x{{.*}} in main
   // CHECK:      {{.*}}use-after-scope-inlined.cc:[[@LINE-4]]
-  // CHECK: Address 0x{{.*}} is located in stack of thread T0 at offset
-  // CHECK:      [[OFFSET:[^ ]*]] in frame
-  // CHECK: main
-  // CHECK:   {{\[}}[[OFFSET]], {{.*}}) 'x.i:[[@LINE-15]]'
+  // CHECK: Address 0x{{.*}} is located in stack of thread T0 at offset [[OFFSET:[^ ]*]] in frame
+  // CHECK:      {{.*}} in main
+  // CHECK:   This frame has
+  // CHECK:     {{\[}}[[OFFSET]], {{.*}}) 'x.i' (line [[@LINE-15]])
 }