[asan] Use exact comparison in BufferedStackTrace::LocatePcInTrace

[vitalybuka]

Summary

Pass optional caller_pc.

Replace GET_CURRENT_PC_BP_SP with GET_CURRENT_BP_SP and make code use
GET_CALLER_PC.

lib/asan/asan_allocator.h

 void *asan_malloc(uptr size, BufferedStackTrace *stack);
 void *asan_calloc(uptr nmemb, uptr size, BufferedStackTrace *stack);
 void *asan_realloc(void *p, uptr size, BufferedStackTrace *stack);
 void *asan_valloc(uptr size, BufferedStackTrace *stack);
 void *asan_pvalloc(uptr size, BufferedStackTrace *stack);
 
 int asan_posix_memalign(void **memptr, uptr alignment, uptr size,
                         BufferedStackTrace *stack);
-uptr asan_malloc_usable_size(const void *ptr, uptr pc, uptr bp);
+uptr asan_malloc_usable_size(const void *ptr, uptr pc, uptr caller_pc, uptr bp);
 
 uptr asan_mz_size(const void *ptr);
 void asan_mz_force_lock();
 void asan_mz_force_unlock();
 
 void PrintInternalAllocatorStats();
 void AsanSoftRssLimitExceededCallback(bool exceeded);
 
 }  // namespace __asan
 #endif  // ASAN_ALLOCATOR_H

lib/asan/asan_allocator.cc

 int asan_posix_memalign(void **memptr, uptr alignment, uptr size,
                         BufferedStackTrace *stack) {
   void *ptr = instance.Allocate(size, alignment, stack, FROM_MALLOC, true);
   CHECK(IsAligned((uptr)ptr, alignment));
   *memptr = ptr;
   return 0;
 }
 
-uptr asan_malloc_usable_size(const void *ptr, uptr pc, uptr bp) {
+uptr asan_malloc_usable_size(const void *ptr, uptr pc, uptr caller_pc,
+                             uptr bp) {
   if (!ptr) return 0;
   uptr usable_size = instance.AllocationSize(reinterpret_cast<uptr>(ptr));
   if (flags()->check_malloc_usable_size && (usable_size == 0)) {
-    GET_STACK_TRACE_FATAL(pc, bp);
+    GET_STACK_TRACE_FATAL(pc, caller_pc, bp);
     ReportMallocUsableSizeNotOwned((uptr)ptr, &stack);
   }
   return usable_size;
 }
 
 uptr asan_mz_size(const void *ptr) {
   return instance.AllocationSize(reinterpret_cast<uptr>(ptr));
 }

lib/asan/asan_errors.cc

void ErrorStackOverflow::Print() {
   Printf("%s", d.Warning());
   Report(
       "ERROR: AddressSanitizer: %s on address %p"
       " (pc %p bp %p sp %p T%d)\n", scariness.GetDescription(),
       (void *)addr, (void *)pc, (void *)bp, (void *)sp, tid);
   Printf("%s", d.EndWarning());
   scariness.Print();
   BufferedStackTrace stack;
-  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, pc, bp, context,
+  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, pc, 0, bp, context,
                                   common_flags()->fast_unwind_on_fatal);
   stack.Print();
   ReportErrorSummary(scariness.GetDescription(), &stack);
 }
 
 static void MaybeDumpInstructionBytes(uptr pc) {
   if (!flags()->dump_instruction_bytes || (pc < GetPageSizeCached())) return;
   InternalScopedString str(1024);
const char *access_type =
             ? "WRITE"
             : (write_flag == SignalContext::READ ? "READ" : "UNKNOWN");
     Report("The signal is caused by a %s memory access.\n", access_type);
     if (addr < GetPageSizeCached())
       Report("Hint: address points to the zero page.\n");
   }
   scariness.Print();
   BufferedStackTrace stack;
-  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, pc, bp, context,
+  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, pc, 0, bp, context,
                                   common_flags()->fast_unwind_on_fatal);
   stack.Print();
   MaybeDumpInstructionBytes(pc);
   MaybeDumpRegisters(context);
   Printf("AddressSanitizer can not provide additional info.\n");
   ReportErrorSummary(description, &stack);
 }
 
 void ErrorDoubleFree::Print() {
   Decorator d;
   Printf("%s", d.Warning());
   char tname[128];
   Report(
       "ERROR: AddressSanitizer: attempting %s on %p in "
       "thread T%d%s:\n",
       scariness.GetDescription(), addr_description.addr, tid,
       ThreadNameWithParenthesis(tid, tname, sizeof(tname)));
   Printf("%s", d.EndWarning());
   scariness.Print();
-  GET_STACK_TRACE_FATAL(second_free_stack->trace[0],
-                        second_free_stack->top_frame_bp);
+  GET_STACK_TRACE_FATAL(
+      second_free_stack->trace[0],
+      second_free_stack->size > 1 ? second_free_stack->trace[1] : 0,
   stack.Print();
   addr_description.Print();
   ReportErrorSummary(scariness.GetDescription(), &stack);
 }
 
 void ErrorNewDeleteSizeMismatch::Print() {
   Decorator d;
   Printf("%s", d.Warning());
   char tname[128];
   Report(
       "ERROR: AddressSanitizer: %s on %p in thread "
       "T%d%s:\n",
       scariness.GetDescription(), addr_description.addr, tid,
       ThreadNameWithParenthesis(tid, tname, sizeof(tname)));
   Printf("%s  object passed to delete has wrong type:\n", d.EndWarning());
   Printf(
       "  size of the allocated type:   %zd bytes;\n"
       "  size of the deallocated type: %zd bytes.\n",
       addr_description.chunk_access.chunk_size, delete_size);
   CHECK_GT(free_stack->size, 0);
   scariness.Print();
-  GET_STACK_TRACE_FATAL(free_stack->trace[0], free_stack->top_frame_bp);
+  GET_STACK_TRACE_FATAL(free_stack->trace[0],
+                        free_stack->size > 1 ? free_stack->trace[1] : 0,
+                        free_stack->top_frame_bp);
   stack.Print();
   addr_description.Print();
   ReportErrorSummary(scariness.GetDescription(), &stack);
   Report(
       "HINT: if you don't care about these errors you may set "
       "ASAN_OPTIONS=new_delete_type_mismatch=0\n");
 }
 
 void ErrorFreeNotMalloced::Print() {
   Decorator d;
   Printf("%s", d.Warning());
   char tname[128];
   Report(
       "ERROR: AddressSanitizer: attempting free on address "
       "which was not malloc()-ed: %p in thread T%d%s\n",
       addr_description.Address(), tid,
       ThreadNameWithParenthesis(tid, tname, sizeof(tname)));
   Printf("%s", d.EndWarning());
   CHECK_GT(free_stack->size, 0);
   scariness.Print();
-  GET_STACK_TRACE_FATAL(free_stack->trace[0], free_stack->top_frame_bp);
+  GET_STACK_TRACE_FATAL(free_stack->trace[0],
+                        free_stack->size > 1 ? free_stack->trace[1] : 0,
+                        free_stack->top_frame_bp);
   stack.Print();
   addr_description.Print();
   ReportErrorSummary(scariness.GetDescription(), &stack);
 }
 
 void ErrorAllocTypeMismatch::Print() {
   static const char *alloc_names[] = {"INVALID", "malloc", "operator new",
                                       "operator new []"};
   static const char *dealloc_names[] = {"INVALID", "free", "operator delete",
                                         "operator delete []"};
   CHECK_NE(alloc_type, dealloc_type);
   Decorator d;
   Printf("%s", d.Warning());
   Report("ERROR: AddressSanitizer: %s (%s vs %s) on %p\n",
          scariness.GetDescription(),
          alloc_names[alloc_type], dealloc_names[dealloc_type],
          addr_description.addr);
   Printf("%s", d.EndWarning());
   CHECK_GT(dealloc_stack->size, 0);
   scariness.Print();
-  GET_STACK_TRACE_FATAL(dealloc_stack->trace[0], dealloc_stack->top_frame_bp);
+  GET_STACK_TRACE_FATAL(dealloc_stack->trace[0],
+                        dealloc_stack->size > 1 ? dealloc_stack->trace[1] : 0,
+                        dealloc_stack->top_frame_bp);
   stack.Print();
   addr_description.Print();
   ReportErrorSummary(scariness.GetDescription(), &stack);
   Report(
       "HINT: if you don't care about these errors you may set "
       "ASAN_OPTIONS=alloc_dealloc_mismatch=0\n");
 }
 

 }
 
 void ErrorInvalidPointerPair::Print() {
   Decorator d;
   Printf("%s", d.Warning());
   Report("ERROR: AddressSanitizer: %s: %p %p\n", scariness.GetDescription(),
          addr1_description.Address(), addr2_description.Address());
   Printf("%s", d.EndWarning());
-  GET_STACK_TRACE_FATAL(pc, bp);
+  GET_STACK_TRACE_FATAL(pc, 0, bp);
   stack.Print();
   addr1_description.Print();
   addr2_description.Print();
   ReportErrorSummary(scariness.GetDescription(), &stack);
 }
 
 static bool AdjacentShadowValuesAreFullyPoisoned(u8 *s) {
   return s[-1] > 127 && s[1] > 127;
void ErrorGeneric::Print() {
 
   char tname[128];
   Printf("%s%s of size %zu at %p thread T%d%s%s\n", d.Access(),
          access_size ? (is_write ? "WRITE" : "READ") : "ACCESS", access_size,
          (void *)addr, tid,
          ThreadNameWithParenthesis(tid, tname, sizeof(tname)), d.EndAccess());
 
   scariness.Print();
-  GET_STACK_TRACE_FATAL(pc, bp);
+  GET_STACK_TRACE_FATAL(pc, 0, bp);
   stack.Print();
 
   // Pass bug_descr because we have a special case for
   // initialization-order-fiasco
   addr_description.Print(bug_descr);
   if (shadow_val == kAsanContiguousContainerOOBMagic)
     PrintContainerOverflowHint();
   ReportErrorSummary(bug_descr, &stack);
   PrintShadowMemoryForAddress(addr);
 }
 
 }  // namespace __asan

lib/asan/asan_interceptors.cc

return !AddressIsPoisoned(beg) &&
            !AddressIsPoisoned(beg + size / 2);
   return false;
 }
 
 struct AsanInterceptorContext {
   const char *interceptor_name;
 };
 
+NOINLINE
+static void ReportGenericErrorInCaller(uptr bp, uptr sp, uptr addr,
+                                       bool is_write, uptr access_size) {
+  uptr pc = GET_CALLER_PC();
+  ReportGenericError(pc, bp, sp, addr, is_write, access_size, 0, false);
+}
+
 // We implement ACCESS_MEMORY_RANGE, ASAN_READ_RANGE,
 // and ASAN_WRITE_RANGE as macro instead of function so
 // that no extra frames are created, and stack trace contains
 // relevant information only.
 // We check all shadow bytes.
-#define ACCESS_MEMORY_RANGE(ctx, offset, size, isWrite) do {            \
-    uptr __offset = (uptr)(offset);                                     \
-    uptr __size = (uptr)(size);                                         \
-    uptr __bad = 0;                                                     \
-    if (__offset > __offset + __size) {                                 \
-      GET_STACK_TRACE_FATAL_HERE;                                       \
-      ReportStringFunctionSizeOverflow(__offset, __size, &stack);       \
-    }                                                                   \
-    if (!QuickCheckForUnpoisonedRegion(__offset, __size) &&             \
-        (__bad = __asan_region_is_poisoned(__offset, __size))) {        \
-      AsanInterceptorContext *_ctx = (AsanInterceptorContext *)ctx;     \
-      bool suppressed = false;                                          \
-      if (_ctx) {                                                       \
-        suppressed = IsInterceptorSuppressed(_ctx->interceptor_name);   \
-        if (!suppressed && HaveStackTraceBasedSuppressions()) {         \
-          GET_STACK_TRACE_FATAL_HERE;                                   \
-          suppressed = IsStackTraceSuppressed(&stack);                  \
-        }                                                               \
-      }                                                                 \
-      if (!suppressed) {                                                \
-        GET_CURRENT_PC_BP_SP;                                           \
-        ReportGenericError(pc, bp, sp, __bad, isWrite, __size, 0, false);\
-      }                                                                 \
-    }                                                                   \
+#define ACCESS_MEMORY_RANGE(ctx, offset, size, isWrite)               \
+  do {                                                                \
+    uptr __offset = (uptr)(offset);                                   \
+    uptr __size = (uptr)(size);                                       \
+    uptr __bad = 0;                                                   \
+    if (__offset > __offset + __size) {                               \
+      GET_STACK_TRACE_FATAL_HERE;                                     \
+      ReportStringFunctionSizeOverflow(__offset, __size, &stack);     \
+    }                                                                 \
+    if (!QuickCheckForUnpoisonedRegion(__offset, __size) &&           \
+        (__bad = __asan_region_is_poisoned(__offset, __size))) {      \
+      AsanInterceptorContext *_ctx = (AsanInterceptorContext *)ctx;   \
+      bool suppressed = false;                                        \
+      if (_ctx) {                                                     \
+        suppressed = IsInterceptorSuppressed(_ctx->interceptor_name); \
+        if (!suppressed && HaveStackTraceBasedSuppressions()) {       \
+          GET_STACK_TRACE_FATAL_HERE;                                 \
+          suppressed = IsStackTraceSuppressed(&stack);                \
+        }                                                             \
+      }                                                               \
+      if (!suppressed) {                                              \
+        uptr local_stack;                                             \
+        uptr sp = (uptr)&local_stack;                                 \
+        uptr bp = GET_CURRENT_FRAME();                                \
+        ReportGenericErrorInCaller(bp, sp, __bad, isWrite, __size);   \
+      }                                                               \
+    }                                                                 \
   } while (0)
 
 // memcpy is called during __asan_init() from the internals of printf(...).
 // We do not treat memcpy with to==from as a bug.
 // See http://llvm.org/bugs/show_bug.cgi?id=11763.
 #define ASAN_MEMCPY_IMPL(ctx, to, from, size)                           \
   do {                                                                  \
     if (UNLIKELY(!asan_inited)) return internal_memcpy(to, from, size); \

lib/asan/asan_malloc_linux.cc

 INTERCEPTOR(void*, __libc_memalign, uptr boundary, uptr size) {
   GET_STACK_TRACE_MALLOC;
   void *res = asan_memalign(boundary, size, &stack, FROM_MALLOC);
   DTLS_on_libc_memalign(res, size);
   return res;
 }
 
 INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
-  GET_CURRENT_PC_BP_SP;
-  (void)sp;
-  return asan_malloc_usable_size(ptr, pc, bp);
+  return asan_malloc_usable_size(ptr, StackTrace::GetCurrentPc(),
+                                 GET_CALLER_PC(), GET_CURRENT_FRAME());
 }
 
 // We avoid including malloc.h for portability reasons.
 // man mallinfo says the fields are "long", but the implementation uses int.
 // It doesn't matter much -- we just need to make sure that the libc's mallinfo
 // is not called.
 struct fake_mallinfo {
   int x[10];

lib/asan/asan_malloc_win.cc

 
 ALLOCATION_FUNCTION_ATTRIBUTE
 void *_recalloc_base(void *p, size_t n, size_t elem_size) {
   return _recalloc(p, n, elem_size);
 }
 
 ALLOCATION_FUNCTION_ATTRIBUTE
 size_t _msize(const void *ptr) {
-  GET_CURRENT_PC_BP_SP;
-  (void)sp;
-  return asan_malloc_usable_size(ptr, pc, bp);
+  return asan_malloc_usable_size(ptr, StackTrace::GetCurrentPc(),
+                                 GET_CALLER_PC(), GET_CURRENT_FRAME());
 }
 
 ALLOCATION_FUNCTION_ATTRIBUTE
 void *_expand(void *memblock, size_t size) {
   // _expand is used in realloc-like functions to resize the buffer if possible.
   // We don't want memory to stand still while resizing buffers, so return 0.
   return 0;
 }
if (dwFlags & HEAP_REALLOC_IN_PLACE_ONLY)
     return nullptr;
   CHECK(dwFlags == 0 && "unsupported heap flags");
   return asan_realloc(lpMem, dwBytes, &stack);
 }
 
 INTERCEPTOR_WINAPI(SIZE_T, HeapSize, HANDLE hHeap, DWORD dwFlags,
                    LPCVOID lpMem) {
   CHECK(dwFlags == 0 && "unsupported heap flags");
-  GET_CURRENT_PC_BP_SP;
-  (void)sp;
-  return asan_malloc_usable_size(lpMem, pc, bp);
+  return asan_malloc_usable_size(lpMem, StackTrace::GetCurrentPc(),
+                                 GET_CALLER_PC(), GET_CURRENT_FRAME());
 }
 
 namespace __asan {
 
 static void TryToOverrideFunction(const char *fname, uptr new_func) {
   // Failure here is not fatal. The CRT may not be present, and different CRT
   // versions use different symbols.
   if (!__interception::OverrideFunction(fname, new_func))

lib/asan/asan_poisoning.cc

uptr __asan_region_is_poisoned(uptr beg, uptr size) {
   // Find it slowly.
   for (; beg < end; beg++)
     if (__asan::AddressIsPoisoned(beg))
       return beg;
   UNREACHABLE("mem_is_zero returned false, but poisoned byte was not found");
   return 0;
 }
 
-#define CHECK_SMALL_REGION(p, size, isWrite)                  \
-  do {                                                        \
-    uptr __p = reinterpret_cast<uptr>(p);                     \
-    uptr __size = size;                                       \
-    if (UNLIKELY(__asan::AddressIsPoisoned(__p) ||            \
-        __asan::AddressIsPoisoned(__p + __size - 1))) {       \
-      GET_CURRENT_PC_BP_SP;                                   \
-      uptr __bad = __asan_region_is_poisoned(__p, __size);    \
-      __asan_report_error(pc, bp, sp, __bad, isWrite, __size, 0);\
-    }                                                         \
-  } while (false);                                            \
-
+NOINLINE
+static void report_error(uptr bp, uptr sp, uptr addr, bool is_write,
+                         uptr size) {
+  uptr pc = GET_CALLER_PC();
+  __asan_report_error(pc, bp, sp, addr, is_write, size, 0);
+}
+
+#define CHECK_SMALL_REGION(p, size, isWrite)                     \
+  do {                                                           \
+    uptr __p = reinterpret_cast<uptr>(p);                        \
+    uptr __size = size;                                          \
+    if (UNLIKELY(__asan::AddressIsPoisoned(__p) ||               \
+                 __asan::AddressIsPoisoned(__p + __size - 1))) { \
+      uptr local_stack;                                          \
+      uptr sp = (uptr)&local_stack;                              \
+      uptr bp = GET_CURRENT_FRAME();                             \
+      uptr __bad = __asan_region_is_poisoned(__p, __size);       \
+      report_error(bp, sp, __bad, isWrite, __size);              \
+    }                                                            \
+  } while (false);
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE
 u16 __sanitizer_unaligned_load16(const uu16 *p) {
   CHECK_SMALL_REGION(p, sizeof(*p), false);
   return *p;
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE

lib/asan/asan_stack.h

 void SetMallocContextSize(u32 size);
 u32 GetMallocContextSize();
 
 // Get the stack trace with the given pc and bp.
 // The pc will be in the position 0 of the resulting stack trace.
 // The bp may refer to the current frame or to the caller's frame.
 ALWAYS_INLINE
 void GetStackTraceWithPcBpAndContext(BufferedStackTrace *stack, uptr max_depth,
-                                     uptr pc, uptr bp, void *context,
-                                     bool fast) {
+                                     uptr pc, uptr caller_pc, uptr bp,
+                                     void *context, bool fast) {
 #if SANITIZER_WINDOWS
   stack->Unwind(max_depth, pc, bp, context, 0, 0, fast);
 #else
   AsanThread *t;
   stack->size = 0;
   if (LIKELY(asan_inited)) {
     if ((t = GetCurrentThread()) && !t->isUnwinding()) {
       // On FreeBSD the slow unwinding that leverages _Unwind_Backtrace()
       // yields the call stack of the signal's handler and not of the code
       // that raised the signal (as it does on Linux).
       if (SANITIZER_FREEBSD && t->isInDeadlySignal()) fast = true;
       uptr stack_top = t->stack_top();
       uptr stack_bottom = t->stack_bottom();
       ScopedUnwinding unwind_scope(t);
       if (!SANITIZER_MIPS || IsValidFrame(bp, stack_top, stack_bottom)) {
-        stack->Unwind(max_depth, pc, bp, context, stack_top, stack_bottom,
-                      fast);
+        stack->Unwind(max_depth, pc, caller_pc, bp, context, stack_top,
+                      stack_bottom, fast);
       }
     } else if (!t && !fast) {
       /* If GetCurrentThread() has failed, try to do slow unwind anyways. */
-      stack->Unwind(max_depth, pc, bp, context, 0, 0, false);
+      stack->Unwind(max_depth, pc, caller_pc, bp, context, 0, 0, false);
     }
   }
 #endif // SANITIZER_WINDOWS
 }
 
 } // namespace __asan
 
 // NOTE: A Rule of thumb is to retrieve stack trace in the interceptors
 // as early as possible (in functions exposed to the user), as we generally
 // don't want stack trace to contain functions from ASan internals.
 
-#define GET_STACK_TRACE(max_size, fast)                                        \
-  BufferedStackTrace stack;                                                    \
-  if (max_size <= 2) {                                                         \
-    stack.size = max_size;                                                     \
-    if (max_size > 0) {                                                        \
-      stack.top_frame_bp = GET_CURRENT_FRAME();                                \
-      stack.trace_buffer[0] = StackTrace::GetCurrentPc();                      \
-      if (max_size > 1)                                                        \
-        stack.trace_buffer[1] = GET_CALLER_PC();                               \
-    }                                                                          \
-  } else {                                                                     \
-    GetStackTraceWithPcBpAndContext(&stack, max_size,                          \
-                                    StackTrace::GetCurrentPc(),                \
-                                    GET_CURRENT_FRAME(), 0, fast);             \
+#define GET_STACK_TRACE(max_size, fast)                                \
+  BufferedStackTrace stack;                                            \
+  if (max_size <= 2) {                                                 \
+    stack.size = max_size;                                             \
+    if (max_size > 0) {                                                \
+      stack.top_frame_bp = GET_CURRENT_FRAME();                        \
+      stack.trace_buffer[0] = StackTrace::GetCurrentPc();              \
+      if (max_size > 1) stack.trace_buffer[1] = GET_CALLER_PC();       \
+    }                                                                  \
+  } else {                                                             \
+    GetStackTraceWithPcBpAndContext(                                   \
+        &stack, max_size, StackTrace::GetCurrentPc(), GET_CALLER_PC(), \
+        GET_CURRENT_FRAME(), 0, fast);                                 \
   }
 
-#define GET_STACK_TRACE_FATAL(pc, bp)                                          \
-  BufferedStackTrace stack;                                                    \
-  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, pc, bp, 0,           \
-                                  common_flags()->fast_unwind_on_fatal)
+#define GET_STACK_TRACE_FATAL(pc, caller_pc, bp)                             \
+  BufferedStackTrace stack;                                                  \
+  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, pc, caller_pc, bp, \
+                                  0, common_flags()->fast_unwind_on_fatal)
 
-#define GET_STACK_TRACE_SIGNAL(sig)                                            \
-  BufferedStackTrace stack;                                                    \
-  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax,                      \
-                                  (sig).pc, (sig).bp, (sig).context,           \
+#define GET_STACK_TRACE_SIGNAL(sig)                                    \
+  BufferedStackTrace stack;                                            \
+  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, (sig).pc, 0, \
+                                  (sig).bp, (sig).context,             \
                                   common_flags()->fast_unwind_on_fatal)
 
 #define GET_STACK_TRACE_FATAL_HERE                                \
   GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_fatal)
 
 #define GET_STACK_TRACE_CHECK_HERE                                \
   GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_check)
 

lib/asan/tests/asan_interface_test.cc

 //===-- asan_interface_test.cc --------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 //===----------------------------------------------------------------------===//
-#include "asan_test_utils.h"
 #include <sanitizer/allocator_interface.h>
 #include <sanitizer/asan_interface.h>
+#include <sanitizer_common/sanitizer_internal_defs.h>
+#include "asan_test_utils.h"
 
 TEST(AddressSanitizerInterface, GetEstimatedAllocatedSize) {
   EXPECT_EQ(0U, __sanitizer_get_estimated_allocated_size(0));
   const size_t sizes[] = { 1, 30, 1<<30 };
   for (size_t i = 0; i < 3; i++) {
     EXPECT_EQ(sizes[i], __sanitizer_get_estimated_allocated_size(sizes[i]));
   }
 }
static void ErrorReportCallbackOneToZ(const char *report) {
   ASSERT_EQ(6, write(2, "ABCDEF", 6));
   ASSERT_EQ(report_len, write(2, report, report_len));
   ASSERT_EQ(6, write(2, "ABCDEF", 6));
   _exit(1);
 }
 
 TEST(AddressSanitizerInterface, SetErrorReportCallbackTest) {
   __asan_set_error_report_callback(ErrorReportCallbackOneToZ);
-  EXPECT_DEATH(__asan_report_error(0, 0, 0, 0, true, 1),
+  EXPECT_DEATH(__asan_report_error((void *)GET_CALLER_PC(), 0, 0, 0, true, 1),
                ASAN_PCRE_DOTALL "ABCDEF.*AddressSanitizer.*WRITE.*ABCDEF");
   __asan_set_error_report_callback(NULL);
 }
 #endif
 
 TEST(AddressSanitizerInterface, GetOwnershipStressTest) {
   std::vector<char *> pointers;
   std::vector<size_t> sizes;

lib/asan/tests/asan_noinst_test.cc

if ((i % 3) == 0) {
       switch ((my_rand_r(&seed) % 128)) {
         case 0: size += 1024; break;
         case 1: size += 2048; break;
         case 2: size += 4096; break;
       }
       size_t alignment = 1 << (my_rand_r(&seed) % 10 + 1);
       char *ptr = (char*)__asan::asan_memalign(alignment, size,
                                                &stack2, __asan::FROM_MALLOC);
-      EXPECT_EQ(size, __asan::asan_malloc_usable_size(ptr, 0, 0));
+      EXPECT_EQ(size, __asan::asan_malloc_usable_size(ptr, 0, 0, 0));
       vec.push_back(ptr);
       ptr[0] = 0;
       ptr[size-1] = 0;
       ptr[size/2] = 0;
     }
   }
   for (size_t i = 0; i < vec.size(); i++)
     __asan::asan_free(vec[i], &stack3, __asan::FROM_MALLOC);

lib/lsan/lsan.h

 // This file is a part of LeakSanitizer.
 // Private header for standalone LSan RTL.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 
-#define GET_STACK_TRACE(max_size, fast)                                        \
-  BufferedStackTrace stack;                                                    \
-  {                                                                            \
-    uptr stack_top = 0, stack_bottom = 0;                                      \
-    ThreadContext *t;                                                          \
-    if (fast && (t = CurrentThreadContext())) {                                \
-      stack_top = t->stack_end();                                              \
-      stack_bottom = t->stack_begin();                                         \
-    }                                                                          \
-    if (!SANITIZER_MIPS ||                                                     \
-        IsValidFrame(GET_CURRENT_FRAME(), stack_top, stack_bottom)) {          \
-      stack.Unwind(max_size, StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(),  \
-                   /* context */ 0, stack_top, stack_bottom, fast);            \
-    }                                                                          \
+#define GET_STACK_TRACE(max_size, fast)                                   \
+  BufferedStackTrace stack;                                               \
+  {                                                                       \
+    uptr stack_top = 0, stack_bottom = 0;                                 \
+    ThreadContext *t;                                                     \
+    if (fast && (t = CurrentThreadContext())) {                           \
+      stack_top = t->stack_end();                                         \
+      stack_bottom = t->stack_begin();                                    \
+    }                                                                     \
+    if (!SANITIZER_MIPS ||                                                \
+        IsValidFrame(GET_CURRENT_FRAME(), stack_top, stack_bottom)) {     \
+      stack.Unwind(max_size, StackTrace::GetCurrentPc(), GET_CALLER_PC(), \
+                   GET_CURRENT_FRAME(), /* context */ 0, stack_top,       \
+                   stack_bottom, fast);                                   \
+    }                                                                     \
   }
 
 #define GET_STACK_TRACE_FATAL \
   GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_fatal)
 
 #define GET_STACK_TRACE_MALLOC                                      \
   GET_STACK_TRACE(__sanitizer::common_flags()->malloc_context_size, \
                   common_flags()->fast_unwind_on_malloc)

lib/msan/msan.cc

 }
 
 void GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc, uptr bp,
                    bool request_fast_unwind) {
   MsanThread *t = GetCurrentThread();
   if (!t || !StackTrace::WillUseFastUnwind(request_fast_unwind)) {
     // Block reports from our interceptors during _Unwind_Backtrace.
     SymbolizerScope sym_scope;
-    return stack->Unwind(max_s, pc, bp, nullptr, 0, 0, request_fast_unwind);
+    return stack->Unwind(max_s, pc, 0, bp, nullptr, 0, 0, request_fast_unwind);
   }
-  stack->Unwind(max_s, pc, bp, nullptr, t->stack_top(), t->stack_bottom(),
+  stack->Unwind(max_s, pc, 0, bp, nullptr, t->stack_top(), t->stack_bottom(),
                 request_fast_unwind);
 }
 
 void PrintWarning(uptr pc, uptr bp) {
   PrintWarningWithOrigin(pc, bp, __msan_origin_tls);
 }
 
 void PrintWarningWithOrigin(uptr pc, uptr bp, u32 origin) {

lib/sanitizer_common/sanitizer_internal_defs.h

 #undef INT64_MAX
 #define INT64_MAX              (__INT64_C(9223372036854775807))
 #undef UINT64_MAX
 #define UINT64_MAX             (__UINT64_C(18446744073709551615))
 
 enum LinkerInitialized { LINKER_INITIALIZED = 0 };
 
 #if !defined(_MSC_VER) || defined(__clang__)
-# define GET_CALLER_PC() (uptr)__builtin_return_address(0)
-# define GET_CURRENT_FRAME() (uptr)__builtin_frame_address(0)
+#define GET_CALLER_PC() (__sanitizer::uptr) __builtin_return_address(0)
+#define GET_CURRENT_FRAME() (__sanitizer::uptr) __builtin_frame_address(0)
 inline void Trap() {
   __builtin_trap();
 }
 #else
 extern "C" void* _ReturnAddress(void);
 extern "C" void* _AddressOfReturnAddress(void);
 # pragma intrinsic(_ReturnAddress)
 # pragma intrinsic(_AddressOfReturnAddress)
-# define GET_CALLER_PC() (uptr)_ReturnAddress()
+#define GET_CALLER_PC() (__sanitizer::uptr) _ReturnAddress()
 // CaptureStackBackTrace doesn't need to know BP on Windows.
-# define GET_CURRENT_FRAME() (((uptr)_AddressOfReturnAddress()) + sizeof(uptr))
+#define GET_CURRENT_FRAME() \
+  (((__sanitizer::uptr)_AddressOfReturnAddress()) + sizeof(__sanitizer::uptr))
 
 extern "C" void __ud2(void);
 # pragma intrinsic(__ud2)
 inline void Trap() {
   __ud2();
 }
 #endif
 

lib/sanitizer_common/sanitizer_stacktrace.h

 // StackTrace that owns the buffer used to store the addresses.
 struct BufferedStackTrace : public StackTrace {
   uptr trace_buffer[kStackTraceMax];
   uptr top_frame_bp;  // Optional bp of a top frame.
 
   BufferedStackTrace() : StackTrace(trace_buffer, 0), top_frame_bp(0) {}
 
   void Init(const uptr *pcs, uptr cnt, uptr extra_top_pc = 0);
-  void Unwind(u32 max_depth, uptr pc, uptr bp, void *context, uptr stack_top,
-              uptr stack_bottom, bool request_fast_unwind);
+  void Unwind(u32 max_depth, uptr pc, uptr caller_pc, uptr bp, void *context,
+              uptr stack_top, uptr stack_bottom, bool request_fast_unwind);
 
  private:
   void FastUnwindStack(uptr pc, uptr bp, uptr stack_top, uptr stack_bottom,
                        u32 max_depth);
-  void SlowUnwindStack(uptr pc, u32 max_depth);
-  void SlowUnwindStackWithContext(uptr pc, void *context,
+  void SlowUnwindStack(uptr pc, uptr caller_pc, u32 max_depth);
+  void SlowUnwindStackWithContext(uptr pc, uptr caller_pc, void *context,
                                   u32 max_depth);
   void PopStackFrames(uptr count);
-  uptr LocatePcInTrace(uptr pc);
+  uptr LocatePcInTrace(uptr pc, uptr caller_pc);
 
   BufferedStackTrace(const BufferedStackTrace &);
   void operator=(const BufferedStackTrace &);
 };
 
 // Check if given pointer points into allocated stack area.
 static inline bool IsValidFrame(uptr frame, uptr stack_top, uptr stack_bottom) {
   return frame > stack_bottom && frame < stack_top - 2 * sizeof (uhwptr);
 }
 
 }  // namespace __sanitizer
 
 // Use this macro if you want to print stack trace with the caller
 // of the current function in the top frame.
 #define GET_CALLER_PC_BP_SP \
   uptr bp = GET_CURRENT_FRAME();              \
   uptr pc = GET_CALLER_PC();                  \
   uptr local_stack;                           \
   uptr sp = (uptr)&local_stack
 
 #define GET_CALLER_PC_BP \
   uptr bp = GET_CURRENT_FRAME();              \
   uptr pc = GET_CALLER_PC();
 
-// Use this macro if you want to print stack trace with the current
-// function in the top frame.
-#define GET_CURRENT_PC_BP_SP \
-  uptr bp = GET_CURRENT_FRAME();              \
-  uptr pc = StackTrace::GetCurrentPc();   \
-  uptr local_stack;                           \
-  uptr sp = (uptr)&local_stack
-
-
 #endif  // SANITIZER_STACKTRACE_H

lib/sanitizer_common/sanitizer_stacktrace.cc

#endif
     if (pc1 != pc) {
       trace_buffer[size++] = (uptr) pc1;
     }
     bottom = (uptr)frame;
     frame = GetCanonicFrame((uptr)frame[0], stack_top, bottom);
   }
 }
 
-static bool MatchPc(uptr cur_pc, uptr trace_pc, uptr threshold) {
-  return cur_pc - trace_pc <= threshold || trace_pc - cur_pc <= threshold;
-}
-
 void BufferedStackTrace::PopStackFrames(uptr count) {
   CHECK_LT(count, size);
   size -= count;
   for (uptr i = 0; i < size; ++i) {
     trace_buffer[i] = trace_buffer[i + count];
   }
 }
 
-uptr BufferedStackTrace::LocatePcInTrace(uptr pc) {
-  // Use threshold to find PC in stack trace, as PC we want to unwind from may
-  // slightly differ from return address in the actual unwinded stack trace.
-  const int kPcThreshold = 350;
+uptr BufferedStackTrace::LocatePcInTrace(uptr pc, uptr caller_pc) {
+  uptr min_diff = -1;
   for (uptr i = 0; i < size; ++i) {
-    if (MatchPc(pc, trace[i], kPcThreshold))
-      return i;
+    if (trace[i] == pc) return i;
+    if (i && trace[i] == caller_pc) return i - 1;
+    uptr diff = trace[i] < pc ? trace[i] - pc : pc - trace[i];
+    min_diff = min_diff > diff ? diff : min_diff;
   }
   return 0;
 }
 
 }  // namespace __sanitizer

lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc

for (uptr i = 0; i < size && trace[i]; i++) {
     frames->ClearAll();
   }
   // Always print a trailing empty line after stack trace.
   Printf("\n");
   if (dedup_token.length())
     Printf("DEDUP_TOKEN: %s\n", dedup_token.data());
 }
 
-void BufferedStackTrace::Unwind(u32 max_depth, uptr pc, uptr bp, void *context,
-                                uptr stack_top, uptr stack_bottom,
-                                bool request_fast_unwind) {
+void BufferedStackTrace::Unwind(u32 max_depth, uptr pc, uptr caller_pc, uptr bp,
+                                void *context, uptr stack_top,
+                                uptr stack_bottom, bool request_fast_unwind) {
   top_frame_bp = (max_depth > 0) ? bp : 0;
   // Avoid doing any work for small max_depth.
   if (max_depth == 0) {
     size = 0;
     return;
   }
   if (max_depth == 1) {
     size = 1;
     trace_buffer[0] = pc;
     return;
   }
   if (!WillUseFastUnwind(request_fast_unwind)) {
 #if SANITIZER_CAN_SLOW_UNWIND
     if (context)
-      SlowUnwindStackWithContext(pc, context, max_depth);
+      SlowUnwindStackWithContext(pc, caller_pc, context, max_depth);
     else
-      SlowUnwindStack(pc, max_depth);
+      SlowUnwindStack(pc, caller_pc, max_depth);
 #else
     UNREACHABLE("slow unwind requested but not available");
 #endif
   } else {
     FastUnwindStack(pc, bp, stack_top, stack_bottom, max_depth);
   }
 }
 

lib/sanitizer_common/sanitizer_unwind_linux_libcdep.cc

_Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx, void *param) {
   // x86_64) is invalid and stop unwinding here.  If we're adding support for
   // a platform where this isn't true, we need to reconsider this check.
   if (pc < kPageSize) return UNWIND_STOP;
   arg->stack->trace_buffer[arg->stack->size++] = pc;
   if (arg->stack->size == arg->max_depth) return UNWIND_STOP;
   return UNWIND_CONTINUE;
 }
 
-void BufferedStackTrace::SlowUnwindStack(uptr pc, u32 max_depth) {
+void BufferedStackTrace::SlowUnwindStack(uptr pc, uptr caller_pc,
+                                         u32 max_depth) {
   CHECK_GE(max_depth, 2);
   size = 0;
   UnwindTraceArg arg = {this, Min(max_depth + 1, kStackTraceMax)};
   _Unwind_Backtrace(Unwind_Trace, &arg);
   // We need to pop a few frames so that pc is on top.
-  uptr to_pop = LocatePcInTrace(pc);
+  uptr to_pop = LocatePcInTrace(pc, caller_pc);
   // trace_buffer[0] belongs to the current function so we always pop it,
   // unless there is only 1 frame in the stack trace (1 frame is always better
   // than 0!).
   // 1-frame stacks don't normally happen, but this depends on the actual
   // unwinder implementation (libgcc, libunwind, etc) which is outside of our
   // control.
   if (to_pop == 0 && size > 1)
     to_pop = 1;
   PopStackFrames(to_pop);
   trace_buffer[0] = pc;
 }
 
-void BufferedStackTrace::SlowUnwindStackWithContext(uptr pc, void *context,
+void BufferedStackTrace::SlowUnwindStackWithContext(uptr pc, uptr caller_pc,
+                                                    void *context,
                                                     u32 max_depth) {
   CHECK_GE(max_depth, 2);
   if (!unwind_backtrace_signal_arch) {
-    SlowUnwindStack(pc, max_depth);
+    SlowUnwindStack(pc, caller_pc, max_depth);
     return;
   }
 
   void *map = acquire_my_map_info_list();
   CHECK(map);
   InternalScopedBuffer<backtrace_frame_t> frames(kStackTraceMax);
   // siginfo argument appears to be unused.
   sptr res = unwind_backtrace_signal_arch(/* siginfo */ 0, context, map,

lib/sanitizer_common/tests/sanitizer_stacktrace_test.cc

 
 class FastUnwindTest : public ::testing::Test {
  protected:
   virtual void SetUp();
   virtual void TearDown();
   bool TryFastUnwind(uptr max_depth) {
     if (!StackTrace::WillUseFastUnwind(true))
       return false;
-    trace.Unwind(max_depth, start_pc, (uptr)&fake_stack[0], 0, fake_top,
+    trace.Unwind(max_depth, start_pc, 0, (uptr)&fake_stack[0], 0, fake_top,
                  fake_bottom, true);
     return true;
   }
 
   void *mapping;
   uhwptr *fake_stack;
   const uptr fake_stack_size = 10;
   uhwptr start_pc;

 }
 
 TEST(SlowUnwindTest, ShortStackTrace) {
   if (StackTrace::WillUseFastUnwind(false))
     return;
   BufferedStackTrace stack;
   uptr pc = StackTrace::GetCurrentPc();
   uptr bp = GET_CURRENT_FRAME();
-  stack.Unwind(0, pc, bp, 0, 0, 0, false);
+  stack.Unwind(0, pc, 0, bp, 0, 0, 0, false);
   EXPECT_EQ(0U, stack.size);
   EXPECT_EQ(0U, stack.top_frame_bp);
-  stack.Unwind(1, pc, bp, 0, 0, 0, false);
+  stack.Unwind(1, pc, 0, bp, 0, 0, 0, false);
   EXPECT_EQ(1U, stack.size);
   EXPECT_EQ(pc, stack.trace[0]);
   EXPECT_EQ(bp, stack.top_frame_bp);
 }
 
 }  // namespace __sanitizer

lib/tsan/rtl/tsan_rtl_report.cc

 // http://reviews.llvm.org/D19148#406208
 // Also see PR27280 comment 2 and 3 for breaking examples and analysis.
 ALWAYS_INLINE
 void PrintCurrentStackSlow(uptr pc) {
 #if !SANITIZER_GO
   BufferedStackTrace *ptrace =
       new(internal_alloc(MBlockStackTrace, sizeof(BufferedStackTrace)))
           BufferedStackTrace();
-  ptrace->Unwind(kStackTraceMax, pc, 0, 0, 0, 0, false);
+  ptrace->Unwind(kStackTraceMax, pc, 0, 0, 0, 0, 0, false);
   for (uptr i = 0; i < ptrace->size / 2; i++) {
     uptr tmp = ptrace->trace_buffer[i];
     ptrace->trace_buffer[i] = ptrace->trace_buffer[ptrace->size - i - 1];
     ptrace->trace_buffer[ptrace->size - i - 1] = tmp;
   }
   PrintStack(SymbolizeStack(*ptrace));
 #endif
 }

lib/ubsan/ubsan_diag.cc

static void MaybePrintStackTrace(uptr pc, uptr bp) {
   // We can only use slow unwind, as we don't have any information about stack
   // top/bottom.
   // FIXME: It's better to respect "fast_unwind_on_fatal" runtime flag and
   // fetch stack top/bottom information if we have it (e.g. if we're running
   // under ASan).
   if (StackTrace::WillUseFastUnwind(false))
     return;
   BufferedStackTrace stack;
-  stack.Unwind(kStackTraceMax, pc, bp, 0, 0, 0, false);
+  stack.Unwind(kStackTraceMax, pc, 0, bp, 0, 0, 0, false);
   stack.Print();
 }
 
 static const char *ConvertTypeToString(ErrorType Type) {
   switch (Type) {
 #define UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName)                      \
   case ErrorType::Name:                                                        \
     return SummaryKind;