1 files changed, 53 insertions, 43 deletions

diff --git a/lib/asan/asan_stack.h b/lib/asan/asan_stack.h
index 97aefd6..6ca9a0b 100644
--- a/lib/asan/asan_stack.h
+++ b/lib/asan/asan_stack.h
@@ -18,77 +18,87 @@
 
 namespace __asan {
 
-static const size_t kStackTraceMax = 64;
+static const uptr kStackTraceMax = 64;
 
 struct AsanStackTrace {
-  size_t size;
-  size_t max_size;
-  uintptr_t trace[kStackTraceMax];
-  static void PrintStack(uintptr_t *addr, size_t size);
+  uptr size;
+  uptr max_size;
+  uptr trace[kStackTraceMax];
+  static void PrintStack(uptr *addr, uptr size);
   void PrintStack() {
     PrintStack(this->trace, this->size);
   }
-  void CopyTo(uintptr_t *dst, size_t dst_size) {
-    for (size_t i = 0; i < size && i < dst_size; i++)
+  void CopyTo(uptr *dst, uptr dst_size) {
+    for (uptr i = 0; i < size && i < dst_size; i++)
       dst[i] = trace[i];
-    for (size_t i = size; i < dst_size; i++)
+    for (uptr i = size; i < dst_size; i++)
       dst[i] = 0;
   }
 
-  void CopyFrom(uintptr_t *src, size_t src_size) {
+  void CopyFrom(uptr *src, uptr src_size) {
     size = src_size;
     if (size > kStackTraceMax) size = kStackTraceMax;
-    for (size_t i = 0; i < size; i++) {
+    for (uptr i = 0; i < size; i++) {
       trace[i] = src[i];
     }
   }
 
-  void FastUnwindStack(uintptr_t pc, uintptr_t bp);
-//  static _Unwind_Reason_Code Unwind_Trace(
-//      struct _Unwind_Context *ctx, void *param);
-  static uintptr_t GetCurrentPc();
+  void GetStackTrace(uptr max_s, uptr pc, uptr bp);
 
-  static size_t CompressStack(AsanStackTrace *stack,
-                            uint32_t *compressed, size_t size);
+  void FastUnwindStack(uptr pc, uptr bp);
+
+  static uptr GetCurrentPc();
+
+  static uptr CompressStack(AsanStackTrace *stack,
+                            u32 *compressed, uptr size);
   static void UncompressStack(AsanStackTrace *stack,
-                              uint32_t *compressed, size_t size);
-  size_t full_frame_count;
+                              u32 *compressed, uptr size);
 };
 
 }  // namespace __asan
 
+// 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
+
+// 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 = AsanStackTrace::GetCurrentPc();   \
+  uptr local_stack;                           \
+  uptr sp = (uptr)&local_stack
+
 // 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.
 // fast_unwind is currently unused.
-#define GET_STACK_TRACE_WITH_PC_AND_BP(max_s, fast_unwind, pc, bp)  \
-  AsanStackTrace stack;                             \
-  {                                                 \
-    uintptr_t saved_pc = pc;                        \
-    uintptr_t saved_bp = bp;                        \
-    stack.size = 0;                                 \
-    stack.full_frame_count = 0;                     \
-    stack.trace[0] = saved_pc;                      \
-    if ((max_s) > 1) {                              \
-      stack.max_size = max_s;                       \
-      stack.FastUnwindStack(saved_pc, saved_bp);    \
-    }                                               \
-  }                                                 \
-
-#define GET_STACK_TRACE_HERE(max_size, fast_unwind)         \
-  GET_STACK_TRACE_WITH_PC_AND_BP(max_size, fast_unwind,     \
-     AsanStackTrace::GetCurrentPc(), GET_CURRENT_FRAME())   \
-
-#define GET_STACK_TRACE_HERE_FOR_MALLOC         \
-  GET_STACK_TRACE_HERE(FLAG_malloc_context_size, FLAG_fast_unwind)
-
-#define GET_STACK_TRACE_HERE_FOR_FREE(ptr) \
-  GET_STACK_TRACE_HERE(FLAG_malloc_context_size, FLAG_fast_unwind)
+#define GET_STACK_TRACE_WITH_PC_AND_BP(max_s, pc, bp)               \
+  AsanStackTrace stack;                                             \
+  stack.GetStackTrace(max_s, pc, bp)
+
+// 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_HERE(max_size)                        \
+  GET_STACK_TRACE_WITH_PC_AND_BP(max_size,                    \
+      AsanStackTrace::GetCurrentPc(), GET_CURRENT_FRAME())
+
+#define GET_STACK_TRACE_HERE_FOR_MALLOC                             \
+  GET_STACK_TRACE_HERE(flags()->malloc_context_size)
+
+#define GET_STACK_TRACE_HERE_FOR_FREE(ptr)                          \
+  GET_STACK_TRACE_HERE(flags()->malloc_context_size)
 
 #define PRINT_CURRENT_STACK()                    \
   {                                              \
-    GET_STACK_TRACE_HERE(kStackTraceMax, false); \
+    GET_STACK_TRACE_HERE(kStackTraceMax);        \
     stack.PrintStack();                          \
-  }                                              \
+  }
 
 #endif  // ASAN_STACK_H