reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Derived Classes

   94 struct BufferedStackTrace : public StackTrace {

   22 struct VarSizeStackTrace : public StackTrace {

Declarations

   35 struct StackTrace;

References

  819 static StackTrace GetStackTraceFromId(u32 id) {
  821   StackTrace res = StackDepotGet(id);
  829 StackTrace AsanChunkView::GetAllocStack() const {
  833 StackTrace AsanChunkView::GetFreeStack() const {

   66   StackTrace GetAllocStack() const;
   67   StackTrace GetFreeStack() const;

   54   StackTrace stack(nullptr, 0);
   68       trace[i] = StackTrace::GetPreviousInstructionPc(stack.trace[i]);

  174 static StackTrace GetStackTraceFromId(u32 id) {
  176   StackTrace res = StackDepotGet(id);
  377   StackTrace alloca_stack(&frame_pc, 1);
  417   StackTrace alloc_stack = GetStackTraceFromId(alloc_stack_id);
  425     StackTrace free_stack = GetStackTraceFromId(free_stack_id);

   38   stack->Unwind(StackTrace::GetNextInstructionPc(sig.pc), sig.bp, sig.context,

   62   request_fast = StackTrace::WillUseFastUnwind(request_fast);

   66 bool IsStackTraceSuppressed(const StackTrace *stack) {

   24 bool IsStackTraceSuppressed(const StackTrace *stack);

   78                                u32 parent_tid, StackTrace *stack,

   54     StackTrace *stack;
   65                             u32 parent_tid, StackTrace *stack, bool detached);

   25   if (!StackTrace::WillUseFastUnwind(request_fast)) {
   49   __sanitizer::StackTrace StackTrace;

  208   if (!StackTrace::WillUseFastUnwind(request_fast)) {
  213   if (StackTrace::WillUseFastUnwind(request_fast))

   86 void *hwasan_malloc(uptr size, StackTrace *stack);
   87 void *hwasan_calloc(uptr nmemb, uptr size, StackTrace *stack);
   88 void *hwasan_realloc(void *ptr, uptr size, StackTrace *stack);
   89 void *hwasan_reallocarray(void *ptr, uptr nmemb, uptr size, StackTrace *stack);
   90 void *hwasan_valloc(uptr size, StackTrace *stack);
   91 void *hwasan_pvalloc(uptr size, StackTrace *stack);
   92 void *hwasan_aligned_alloc(uptr alignment, uptr size, StackTrace *stack);
   93 void *hwasan_memalign(uptr alignment, uptr size, StackTrace *stack);
   95                         StackTrace *stack);
   96 void hwasan_free(void *ptr, StackTrace *stack);
  112 u32 ChainOrigin(u32 id, StackTrace *stack);
  114 const int STACK_TRACE_TAG_POISON = StackTrace::TAG_CUSTOM + 1;

  102 static void *HwasanAllocate(StackTrace *stack, uptr orig_size, uptr alignment,
  182 static void HwasanDeallocate(StackTrace *stack, void *tagged_ptr) {
  237 static void *HwasanReallocate(StackTrace *stack, void *tagged_ptr_old,
  255 static void *HwasanCalloc(StackTrace *stack, uptr nmemb, uptr size) {
  288 void *hwasan_malloc(uptr size, StackTrace *stack) {
  292 void *hwasan_calloc(uptr nmemb, uptr size, StackTrace *stack) {
  296 void *hwasan_realloc(void *ptr, uptr size, StackTrace *stack) {
  306 void *hwasan_reallocarray(void *ptr, uptr nmemb, uptr size, StackTrace *stack) {
  316 void *hwasan_valloc(uptr size, StackTrace *stack) {
  321 void *hwasan_pvalloc(uptr size, StackTrace *stack) {
  334 void *hwasan_aligned_alloc(uptr alignment, uptr size, StackTrace *stack) {
  344 void *hwasan_memalign(uptr alignment, uptr size, StackTrace *stack) {
  355                         StackTrace *stack) {
  370 void hwasan_free(void *ptr, StackTrace *stack) {

  452   HandleTagMismatch(ai, StackTrace::GetNextInstructionPc(sig.pc), sig.bp, uc);
  465   stack->Unwind(StackTrace::GetNextInstructionPc(sig.pc), sig.bp, sig.context,

   18 static u32 malloc_hash(StackTrace *stack, uptr orig_size) {
   31 static INLINE bool malloc_bisect(StackTrace *stack, uptr orig_size) {

   82 static StackTrace GetStackTraceFromId(u32 id) {
   84   StackTrace res = StackDepotGet(id);
  412 void ReportInvalidFree(StackTrace *stack, uptr tagged_addr) {
  438 void ReportTailOverwritten(StackTrace *stack, uptr tagged_addr, uptr orig_size,
  497 void ReportTagMismatch(StackTrace *stack, uptr tagged_addr, uptr access_size,

   24 void ReportTagMismatch(StackTrace *stack, uptr addr, uptr access_size,
   26 void ReportInvalidFree(StackTrace *stack, uptr addr);
   27 void ReportTailOverwritten(StackTrace *stack, uptr addr, uptr orig_size,

   40   if (StackTrace::WillUseFastUnwind(request_fast) &&
   46     if (StackTrace::WillUseFastUnwind(request_fast))
   92   stack->Unwind(StackTrace::GetNextInstructionPc(sig.pc), sig.bp, sig.context,

   53 static void RegisterAllocation(const StackTrace &stack, void *p, uptr size) {
   70 static void *ReportAllocationSizeTooBig(uptr size, const StackTrace &stack) {
   78 void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
  100 static void *Calloc(uptr nmemb, uptr size, const StackTrace &stack) {
  117 void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
  141                         const StackTrace &stack) {
  156 void *lsan_aligned_alloc(uptr alignment, uptr size, const StackTrace &stack) {
  166 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack) {
  176 void *lsan_malloc(uptr size, const StackTrace &stack) {
  184 void *lsan_realloc(void *p, uptr size, const StackTrace &stack) {
  189                         const StackTrace &stack) {
  199 void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack) {
  203 void *lsan_valloc(uptr size, const StackTrace &stack) {
  208 void *lsan_pvalloc(uptr size, const StackTrace &stack) {

   24 void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
   27 void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
  100                         const StackTrace &stack);
  101 void *lsan_aligned_alloc(uptr alignment, uptr size, const StackTrace &stack);
  102 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack);
  103 void *lsan_malloc(uptr size, const StackTrace &stack);
  105 void *lsan_realloc(void *p, uptr size, const StackTrace &stack);
  107                         const StackTrace &stack);
  108 void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack);
  109 void *lsan_valloc(uptr size, const StackTrace &stack);
  110 void *lsan_pvalloc(uptr size, const StackTrace &stack);

  380   StackTrace stack = map->Get(stack_id);
  498       StackTrace stack = StackDepotGet(m.stack_trace_id());
  648   StackTrace stack = StackDepotGet(stack_trace_id);
  651         StackTrace::GetPreviousInstructionPc(stack.trace[i]));

  289 u32 ChainOrigin(u32 id, StackTrace *stack) {
  295   stack->tag = StackTrace::TAG_UNKNOWN;
  306   if (!t || !StackTrace::WillUseFastUnwind(request_fast)) {
  311   if (StackTrace::WillUseFastUnwind(request_fast))
  381   stack->Unwind(StackTrace::GetNextInstructionPc(sig.pc), sig.bp, sig.context,

  286 void MsanDeallocate(StackTrace *stack, void *ptr);
  288 void *msan_malloc(uptr size, StackTrace *stack);
  289 void *msan_calloc(uptr nmemb, uptr size, StackTrace *stack);
  290 void *msan_realloc(void *ptr, uptr size, StackTrace *stack);
  291 void *msan_reallocarray(void *ptr, uptr nmemb, uptr size, StackTrace *stack);
  292 void *msan_valloc(uptr size, StackTrace *stack);
  293 void *msan_pvalloc(uptr size, StackTrace *stack);
  294 void *msan_aligned_alloc(uptr alignment, uptr size, StackTrace *stack);
  295 void *msan_memalign(uptr alignment, uptr size, StackTrace *stack);
  297                         StackTrace *stack);
  322 u32 ChainOrigin(u32 id, StackTrace *stack);
  324 const int STACK_TRACE_TAG_POISON = StackTrace::TAG_CUSTOM + 1;

  133 static void *MsanAllocate(StackTrace *stack, uptr size, uptr alignment,
  166       stack->tag = StackTrace::TAG_ALLOC;
  175 void MsanDeallocate(StackTrace *stack, void *p) {
  186       stack->tag = StackTrace::TAG_DEALLOC;
  202 void *MsanReallocate(StackTrace *stack, void *old_p, uptr new_size,
  212         stack->tag = StackTrace::TAG_ALLOC;
  227 void *MsanCalloc(StackTrace *stack, uptr nmemb, uptr size) {
  244 void *msan_malloc(uptr size, StackTrace *stack) {
  248 void *msan_calloc(uptr nmemb, uptr size, StackTrace *stack) {
  252 void *msan_realloc(void *ptr, uptr size, StackTrace *stack) {
  262 void *msan_reallocarray(void *ptr, uptr nmemb, uptr size, StackTrace *stack) {
  272 void *msan_valloc(uptr size, StackTrace *stack) {
  276 void *msan_pvalloc(uptr size, StackTrace *stack) {
  289 void *msan_aligned_alloc(uptr alignment, uptr size, StackTrace *stack) {
  299 void *msan_memalign(uptr alignment, uptr size, StackTrace *stack) {
  310                         StackTrace *stack) {

   85   Origin getNextChainedOrigin(StackTrace *stack) const {
   93   StackTrace getStackTraceForHeapOrigin() const {
  102   static Origin CreateHeapOrigin(StackTrace *stack) {
  109   static Origin CreateChainedOrigin(Origin prev, StackTrace *stack) {

   43                 StackTrace *stack) {
   98                          StackTrace *stack) {
  108                          StackTrace *stack) {
  116 void CopyMemory(void *dst, const void *src, uptr size, StackTrace *stack) {
  165 void PoisonMemory(const void *dst, uptr size, StackTrace *stack) {

   31 void CopyOrigin(const void *dst, const void *src, uptr size, StackTrace *stack);
   36                          StackTrace *stack);
   41                          StackTrace *stack);
   45 void CopyMemory(void *dst, const void *src, uptr size, StackTrace *stack);
   54 void PoisonMemory(const void *dst, uptr size, StackTrace *stack);

   54     pc = StackTrace::GetNextInstructionPc(pc);
   64     StackTrace stack;
   75     StackTrace stack = o.getStackTraceForHeapOrigin();
   77       case StackTrace::TAG_ALLOC:
   81       case StackTrace::TAG_DEALLOC:
   98 void ReportUMR(StackTrace *stack, u32 origin) {
  114 void ReportExpectedUMRNotFound(StackTrace *stack) {

   23 void ReportUMR(StackTrace *stack, u32 origin);
   24 void ReportExpectedUMRNotFound(StackTrace *stack);

   24                              const StackTrace *stack_)
   39   const StackTrace* const stack;
   44                                    const StackTrace *stack) {
   55                                          const StackTrace *stack) {
   66 void NORETURN ReportPvallocOverflow(uptr size, const StackTrace *stack) {
   77                                                const StackTrace *stack) {
   87                                                  const StackTrace *stack) {
  105                                                   const StackTrace *stack) {
  119                                          const StackTrace *stack) {
  128 void NORETURN ReportOutOfMemory(uptr requested_size, const StackTrace *stack) {

   23                                    const StackTrace *stack);
   25                                          const StackTrace *stack);
   26 void NORETURN ReportPvallocOverflow(uptr size, const StackTrace *stack);
   28                                                const StackTrace *stack);
   30                                                  const StackTrace *stack);
   32                                                   const StackTrace *stack);
   34                                          const StackTrace *stack);
   35 void NORETURN ReportOutOfMemory(uptr requested_size, const StackTrace *stack);

  334 void ReportErrorSummary(const char *error_type, const StackTrace *trace,

   37   typedef StackTrace args_type;
   97 u32 StackDepotPut(StackTrace stack) {
  102 StackDepotHandle StackDepotPut_WithHandle(StackTrace stack) {
  106 StackTrace StackDepotGet(u32 id) {
  138 StackTrace StackDepotReverseMap::Get(u32 id) {

   37 u32 StackDepotPut(StackTrace stack);
   38 StackDepotHandle StackDepotPut_WithHandle(StackTrace stack);
   40 StackTrace StackDepotGet(u32 id);
   52   StackTrace Get(u32 id);

   94 struct BufferedStackTrace : public StackTrace {

  110   pc = StackTrace::GetPreviousInstructionPc(pc);

   72 void ReportErrorSummary(const char *error_type, const StackTrace *stack,
   83   uptr pc = StackTrace::GetPreviousInstructionPc(stack->trace[0]);
  106   if (StackTrace::WillUseFastUnwind(fast)) {

   32   StackTrace stack = StackDepotGet(stk);

  258   StackTrace stack = StackDepotGet(b->stk);

 1929     ObtainCurrentStack(thr, StackTrace::GetNextInstructionPc(pc), &stack);

  341   stack->Unwind(StackTrace::GetNextInstructionPc(sig.pc), sig.bp, sig.context,

  588   void AddMemoryAccess(uptr addr, uptr external_tag, Shadow s, StackTrace stack,
  590   void AddStack(StackTrace stack, bool suppressable = false);
  695 bool IsFiredSuppression(Context *ctx, ReportType type, StackTrace trace);

   32 static ReportStack *SymbolizeStack(StackTrace trace);
   47   PrintCurrentStackSlow(StackTrace::GetCurrentPc());
  110   StackTrace stack = StackDepotGet(stack_id);
  116 static ReportStack *SymbolizeStack(StackTrace trace) {
  126       pc1 = StackTrace::GetPreviousInstructionPc(pc);
  160 void ScopedReportBase::AddStack(StackTrace stack, bool suppressable) {
  167                                        StackTrace stack, const MutexSet *mset) {
  544 bool IsFiredSuppression(Context *ctx, ReportType type, StackTrace trace) {
  755   PrintCurrentStackSlow(StackTrace::GetCurrentPc());

   57   if (StackTrace::WillUseFastUnwind(request_fast)) {

   22 struct VarSizeStackTrace : public StackTrace {

   39   if (StackTrace::WillUseFastUnwind(fast)) {

   45   uptr PC = StackTrace::GetPreviousInstructionPc(CallerPC);

   23   if (StackTrace::WillUseFastUnwind(request_fast)) {

   49                       StackTrace::GetNextInstructionPc(sig.pc), sig.bp,