1 //===-- sanitizer_stacktrace.h ----------------------------------*- C++ -*-===// 2 // 3 // This file is distributed under the University of Illinois Open Source 4 // License. See LICENSE.TXT for details. 5 // 6 //===----------------------------------------------------------------------===// 7 // 8 // This file is shared between AddressSanitizer and ThreadSanitizer 9 // run-time libraries. 10 //===----------------------------------------------------------------------===// 11 #ifndef SANITIZER_STACKTRACE_H 12 #define SANITIZER_STACKTRACE_H 13 14 #include "sanitizer_internal_defs.h" 15 16 namespace __sanitizer { 17 18 static const u32 kStackTraceMax = 256; 19 20 #if SANITIZER_LINUX && defined(__mips__) 21 # define SANITIZER_CAN_FAST_UNWIND 0 22 #elif SANITIZER_WINDOWS 23 # define SANITIZER_CAN_FAST_UNWIND 0 24 #elif SANITIZER_OPENBSD 25 # define SANITIZER_CAN_FAST_UNWIND 0 26 #else 27 # define SANITIZER_CAN_FAST_UNWIND 1 28 #endif 29 30 // Fast unwind is the only option on Mac for now; we will need to 31 // revisit this macro when slow unwind works on Mac, see 32 // https://github.com/google/sanitizers/issues/137 33 #if SANITIZER_MAC || SANITIZER_OPENBSD || SANITIZER_RTEMS 34 # define SANITIZER_CAN_SLOW_UNWIND 0 35 #else 36 # define SANITIZER_CAN_SLOW_UNWIND 1 37 #endif 38 39 struct StackTrace { 40 const uptr *trace; 41 u32 size; 42 u32 tag; 43 44 static const int TAG_UNKNOWN = 0; 45 static const int TAG_ALLOC = 1; 46 static const int TAG_DEALLOC = 2; 47 static const int TAG_CUSTOM = 100; // Tool specific tags start here. 48 49 StackTrace() : trace(nullptr), size(0), tag(0) {} 50 StackTrace(const uptr *trace, u32 size) : trace(trace), size(size), tag(0) {} 51 StackTrace(const uptr *trace, u32 size, u32 tag) 52 : trace(trace), size(size), tag(tag) {} 53 54 // Prints a symbolized stacktrace, followed by an empty line. 55 void Print() const; 56 57 static bool WillUseFastUnwind(bool request_fast_unwind) { 58 if (!SANITIZER_CAN_FAST_UNWIND) 59 return false; 60 else if (!SANITIZER_CAN_SLOW_UNWIND) 61 return true; 62 return request_fast_unwind; 63 } 64 65 static uptr GetCurrentPc(); 66 static inline uptr GetPreviousInstructionPc(uptr pc); 67 static uptr GetNextInstructionPc(uptr pc); 68 typedef bool (*SymbolizeCallback)(const void *pc, char *out_buffer, 69 int out_size); 70 }; 71 72 // Performance-critical, must be in the header. 73 ALWAYS_INLINE 74 uptr StackTrace::GetPreviousInstructionPc(uptr pc) { 75 #if defined(__arm__) 76 // T32 (Thumb) branch instructions might be 16 or 32 bit long, 77 // so we return (pc-2) in that case in order to be safe. 78 // For A32 mode we return (pc-4) because all instructions are 32 bit long. 79 return (pc - 3) & (~1); 80 #elif defined(__powerpc__) || defined(__powerpc64__) || defined(__aarch64__) 81 // PCs are always 4 byte aligned. 82 return pc - 4; 83 #elif defined(__sparc__) || defined(__mips__) 84 return pc - 8; 85 #else 86 return pc - 1; 87 #endif 88 } 89 90 // StackTrace that owns the buffer used to store the addresses. 91 struct BufferedStackTrace : public StackTrace { 92 uptr trace_buffer[kStackTraceMax]; 93 uptr top_frame_bp; // Optional bp of a top frame. 94 95 BufferedStackTrace() : StackTrace(trace_buffer, 0), top_frame_bp(0) {} 96 97 void Init(const uptr *pcs, uptr cnt, uptr extra_top_pc = 0); 98 void Unwind(u32 max_depth, uptr pc, uptr bp, void *context, uptr stack_top, 99 uptr stack_bottom, bool request_fast_unwind); 100 101 void Reset() { 102 *static_cast<StackTrace *>(this) = StackTrace(trace_buffer, 0); 103 top_frame_bp = 0; 104 } 105 106 private: 107 void FastUnwindStack(uptr pc, uptr bp, uptr stack_top, uptr stack_bottom, 108 u32 max_depth); 109 void SlowUnwindStack(uptr pc, u32 max_depth); 110 void SlowUnwindStackWithContext(uptr pc, void *context, 111 u32 max_depth); 112 void PopStackFrames(uptr count); 113 uptr LocatePcInTrace(uptr pc); 114 115 BufferedStackTrace(const BufferedStackTrace &) = delete; 116 void operator=(const BufferedStackTrace &) = delete; 117 }; 118 119 // Check if given pointer points into allocated stack area. 120 static inline bool IsValidFrame(uptr frame, uptr stack_top, uptr stack_bottom) { 121 return frame > stack_bottom && frame < stack_top - 2 * sizeof (uhwptr); 122 } 123 124 } // namespace __sanitizer 125 126 // Use this macro if you want to print stack trace with the caller 127 // of the current function in the top frame. 128 #define GET_CALLER_PC_BP_SP \ 129 uptr bp = GET_CURRENT_FRAME(); \ 130 uptr pc = GET_CALLER_PC(); \ 131 uptr local_stack; \ 132 uptr sp = (uptr)&local_stack 133 134 #define GET_CALLER_PC_BP \ 135 uptr bp = GET_CURRENT_FRAME(); \ 136 uptr pc = GET_CALLER_PC(); 137 138 // Use this macro if you want to print stack trace with the current 139 // function in the top frame. 140 #define GET_CURRENT_PC_BP_SP \ 141 uptr bp = GET_CURRENT_FRAME(); \ 142 uptr pc = StackTrace::GetCurrentPc(); \ 143 uptr local_stack; \ 144 uptr sp = (uptr)&local_stack 145 146 147 #endif // SANITIZER_STACKTRACE_H 148