[asan] Use exact comparison in BufferedStackTrace::LocatePcInTrace

[vitalybuka]

Summary

Make sure that BufferedStackTrace in malloc interceptors has top frame
calculated with GET_CALLER_PC.

Replace GET_CURRENT_PC_BP_SP with GET_CURRENT_BP_SP and make code use
GET_CALLER_PC.

[eugenis]

What if we used GET_CALLER_PC in the interceptor functions instead of GET_CURRENT_PC_BP_SP? That would provide an address in the user code, which MatchPc could match exactly and take one step back to get the interceptor frame?

[eugenis]

Sorry, I still don't like this.
You are basically fixing up the stack trace so it can be reliably re-unwound, but this fixup only holds in the callees of the current function, and it's not clear what the exact set of functions need this and how to maintain this in the future.

As I see it, the problem is not really with the stack trace itself. We are replacing it with a better trace later anyway. The problem is to keep enough information to trim the new trace at the right point.

When malloc_context_size > 1, exact matching trace[1] and then stepping back should work strictly better than the current code. When malloc_context_size<=1, we can keep the current behavior, or add a new field to store caller-pc from the interceptor PoV.

lib/asan/asan_stack.h

63

Please rename to GetStackTraceWithCurrentPcBpAndContext, or something like that

[vitalybuka]

renamed function

[vitalybuka]

UNREACHABLE("Trace must contain 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 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

 }
 
 void PrintInternalAllocatorStats() {
   instance.PrintStats();
 }
 
 void *asan_memalign(uptr alignment, uptr size, BufferedStackTrace *stack,
                     AllocType alloc_type) {
+  if (stack->size) stack->trace_buffer[0] = GET_CALLER_PC();
   return instance.Allocate(size, alignment, stack, alloc_type, true);
 }
 
 void asan_free(void *ptr, BufferedStackTrace *stack, AllocType alloc_type) {
+  if (stack->size) stack->trace_buffer[0] = GET_CALLER_PC();
   instance.Deallocate(ptr, 0, stack, alloc_type);
 }
 
 void asan_sized_free(void *ptr, uptr size, BufferedStackTrace *stack,
                      AllocType alloc_type) {
+  if (stack->size) stack->trace_buffer[0] = GET_CALLER_PC();
   instance.Deallocate(ptr, size, stack, alloc_type);
 }
 
 void *asan_malloc(uptr size, BufferedStackTrace *stack) {
+  if (stack->size) stack->trace_buffer[0] = GET_CALLER_PC();
   return instance.Allocate(size, 8, stack, FROM_MALLOC, true);
 }
 
 void *asan_calloc(uptr nmemb, uptr size, BufferedStackTrace *stack) {
+  if (stack->size) stack->trace_buffer[0] = GET_CALLER_PC();
   return instance.Calloc(nmemb, size, stack);
 }
 
 void *asan_realloc(void *p, uptr size, BufferedStackTrace *stack) {
+  if (stack->size) stack->trace_buffer[0] = GET_CALLER_PC();
   if (!p)
     return instance.Allocate(size, 8, stack, FROM_MALLOC, true);
   if (size == 0) {
     instance.Deallocate(p, 0, stack, FROM_MALLOC);
     return nullptr;
   }
   return instance.Reallocate(p, size, stack);
 }
 
 void *asan_valloc(uptr size, BufferedStackTrace *stack) {
+  if (stack->size) stack->trace_buffer[0] = GET_CALLER_PC();
   return instance.Allocate(size, GetPageSizeCached(), stack, FROM_MALLOC, true);
 }
 
 void *asan_pvalloc(uptr size, BufferedStackTrace *stack) {
+  if (stack->size) stack->trace_buffer[0] = GET_CALLER_PC();
   uptr PageSize = GetPageSizeCached();
   size = RoundUpTo(size, PageSize);
   if (size == 0) {
     // pvalloc(0) should allocate one page.
     size = PageSize;
   }
   return instance.Allocate(size, PageSize, stack, FROM_MALLOC, true);
 }
 
 int asan_posix_memalign(void **memptr, uptr alignment, uptr size,
                         BufferedStackTrace *stack) {
+  if (stack->size) stack->trace_buffer[0] = GET_CALLER_PC();
   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 bp) {
   if (!ptr) return 0;
   uptr usable_size = instance.AllocationSize(reinterpret_cast<uptr>(ptr));
   if (flags()->check_malloc_usable_size && (usable_size == 0)) {
+    uptr pc = GET_CALLER_PC();
     GET_STACK_TRACE_FATAL(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_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) {                                              \
+        GET_CURRENT_BP_SP;                                            \
+        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;
+  GET_CURRENT_BP_SP;
   (void)sp;
-  return asan_malloc_usable_size(ptr, pc, bp);
+  return asan_malloc_usable_size(ptr, bp);
 }
 
 // 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;
+  GET_CURRENT_BP_SP;
   (void)sp;
-  return asan_malloc_usable_size(ptr, pc, bp);
+  return asan_malloc_usable_size(ptr, bp);
 }
 
 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;
+  GET_CURRENT_BP_SP;
   (void)sp;
-  return asan_malloc_usable_size(lpMem, pc, bp);
+  return asan_malloc_usable_size(lpMem, bp);
 }
 
 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))) { \
+      GET_CURRENT_BP_SP;                                         \
+      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

if (LIKELY(asan_inited)) {
     } else if (!t && !fast) {
       /* If GetCurrentThread() has failed, try to do slow unwind anyways. */
       stack->Unwind(max_depth, pc, bp, context, 0, 0, false);
     }
   }
 #endif // SANITIZER_WINDOWS
 }
 
+void GetStackTraceWithCurrentPcBpAndContext(BufferedStackTrace *stack,
+                                            uptr max_depth, uptr bp,
+                                            void *context, bool fast);
+
 } // 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 {                                                                \
+    GetStackTraceWithCurrentPcBpAndContext(&stack, max_size,              \
+                                           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_SIGNAL(sig)                                            \

lib/asan/asan_stack.cc

 void SetMallocContextSize(u32 size) {
   atomic_store(&malloc_context_size, size, memory_order_release);
 }
 
 u32 GetMallocContextSize() {
   return atomic_load(&malloc_context_size, memory_order_acquire);
 }
 
+NOINLINE
+void GetStackTraceWithCurrentPcBpAndContext(BufferedStackTrace *stack,
+                                            uptr max_depth, uptr bp,
+                                            void *context, bool fast) {
+  GetStackTraceWithPcBpAndContext(stack, max_depth, GET_CALLER_PC(), bp,
+                                  context, fast);
+}
+
 }  // namespace __asan
 
 // ------------------ Interface -------------- {{{1
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_print_stack_trace() {
   using namespace __asan;
   PRINT_CURRENT_STACK();
 }
 }  // extern "C"

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));
       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/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

#define GET_CALLER_PC_BP_SP \
   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;                           \
+#define GET_CURRENT_BP_SP        \
+  uptr bp = GET_CURRENT_FRAME(); \
+  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;
-  for (uptr i = 0; i < size; ++i) {
-    if (MatchPc(pc, trace[i], kPcThreshold))
-      return i;
-  }
+  for (uptr i = 0; i < size; ++i)
+    if (trace[i] == pc) return i;
+  UNREACHABLE("Trace must contain PC");
   return 0;
 }
 
 }  // namespace __sanitizer