Simplify Symbolizer::SymbolizePC() interface.

[samsonov]

Summary

Return a linked list of AddressInfo objects,
instead of using an array of these objects as an output parameter.
This simplifies the code in callers of this function (especially
TSan).

Fix a few memory leaks from internal allocator, when the returned
AddressInfo objects were not properly cleared.

[earthdok]

lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.cc

86

We have SymbolizeCode(), SymbolizeData() and struct SymbolizeCodeData. Confusing. Besides, "Data" doesn't really tell you anything. This should be renamed to something like SymbolizeCodeResult.

87

I'm not happy with this name. Maybe "result" or "first"? I'd prefer the latter.

[samsonov]

Address comments.

lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.cc

86

Renamed to SymbolizeCodeCallbackArg.

87

Done

[earthdok]

LSan and sanitizer_common lgtm

[samsonov]

Dmitry, any comments on the TSan side?

[dvyukov]

lib/sanitizer_common/sanitizer_symbolizer.cc

56

who is deallocating next?

lib/tsan/rtl/tsan_rtl_report.cc

75

who is deallocating last_frame?
here and below

lib/tsan/rtl/tsan_symbolize.cc

58

SymbolizedFrame is somewhat confusing here, because it is whole stack rather than a single frame.
I would s/SymbolizedFrame/SymbolizedStack/

[samsonov]

Address review comments. Fix Go build.

lib/sanitizer_common/sanitizer_symbolizer.cc

56

OMG. Fixed.

lib/tsan/rtl/tsan_rtl_report.cc

75

Fixed (now this is done by ClearAll()) function.

lib/tsan/rtl/tsan_symbolize.cc

58

Done.

[samsonov]

Rebase to trunk.

[dvyukov]

LGTM

lib/lsan/lsan_common.cc

if (flags()->exitcode) {
       if (common_flags()->coverage)
         __sanitizer_cov_dump();
       internal__exit(flags()->exitcode);
     }
   }
 }
 
 static Suppression *GetSuppressionForAddr(uptr addr) {
-  Suppression *s;
+  Suppression *s = nullptr;
 
   // Suppress by module name.
   const char *module_name;
   uptr module_offset;
-  if (Symbolizer::GetOrInit()
-          ->GetModuleNameAndOffsetForPC(addr, &module_name, &module_offset) &&
+  if (Symbolizer::GetOrInit()->GetModuleNameAndOffsetForPC(addr, &module_name,
+                                                           &module_offset) &&
       SuppressionContext::Get()->Match(module_name, SuppressionLeak, &s))
     return s;
 
   // Suppress by file or function name.
-  static const uptr kMaxAddrFrames = 16;
-  InternalScopedBuffer<AddressInfo> addr_frames(kMaxAddrFrames);
-  for (uptr i = 0; i < kMaxAddrFrames; i++) new (&addr_frames[i]) AddressInfo();
-  uptr addr_frames_num = Symbolizer::GetOrInit()->SymbolizePC(
-      addr, addr_frames.data(), kMaxAddrFrames);
-  for (uptr i = 0; i < addr_frames_num; i++) {
-    if (SuppressionContext::Get()->Match(addr_frames[i].function,
-                                         SuppressionLeak, &s) ||
-        SuppressionContext::Get()->Match(addr_frames[i].file, SuppressionLeak,
-                                         &s))
-      return s;
+  SymbolizedFrame *frames = Symbolizer::GetOrInit()->SymbolizePC(addr);
+  for (SymbolizedFrame *cur = frames; cur; cur = cur->next) {
+    if (SuppressionContext::Get()->Match(cur->info.function, SuppressionLeak,
+                                         &s) ||
+        SuppressionContext::Get()->Match(cur->info.file, SuppressionLeak, &s)) {
+      break;
     }
-  return 0;
+  }
+  frames->ClearAll();
+  return s;
 }
 
 static Suppression *GetSuppressionForStack(u32 stack_trace_id) {
   StackTrace stack = StackDepotGet(stack_trace_id);
   for (uptr i = 0; i < stack.size; i++) {
     Suppression *s = GetSuppressionForAddr(
         StackTrace::GetPreviousInstructionPc(stack.trace[i]));
     if (s) return s;

lib/sanitizer_common/sanitizer_common_libcdep.cc

 static void (*sandboxing_callback)();
 void SetSandboxingCallback(void (*f)()) {
   sandboxing_callback = f;
 }
 
 void ReportErrorSummary(const char *error_type, StackTrace *stack) {
   if (!common_flags()->print_summary)
     return;
-  AddressInfo ai;
 #if !SANITIZER_GO
   if (stack->size > 0 && Symbolizer::GetOrInit()->CanReturnFileLineInfo()) {
     // Currently, we include the first stack frame into the report summary.
     // Maybe sometimes we need to choose another frame (e.g. skip memcpy/etc).
     uptr pc = StackTrace::GetPreviousInstructionPc(stack->trace[0]);
-    Symbolizer::GetOrInit()->SymbolizePC(pc, &ai, 1);
+    SymbolizedFrame *frame = Symbolizer::GetOrInit()->SymbolizePC(pc);
+    const AddressInfo &ai = frame->info;
+    ReportErrorSummary(error_type, ai.file, ai.line, ai.function);
+    frame->ClearAll();
   }
-#endif
+#else
+  AddressInfo ai;
   ReportErrorSummary(error_type, ai.file, ai.line, ai.function);
+#endif
 }
 
 }  // namespace __sanitizer
 
 void NOINLINE
 __sanitizer_sandbox_on_notify(__sanitizer_sandbox_arguments *args) {
   PrepareForSandboxing(args);
   if (sandboxing_callback)
     sandboxing_callback();
 }

lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc

 
 namespace __sanitizer {
 
 void StackTrace::Print() const {
   if (trace == nullptr || size == 0) {
     Printf("    <empty stack>\n\n");
     return;
   }
-  const int kMaxAddrFrames = 64;
-  InternalScopedBuffer<AddressInfo> addr_frames(kMaxAddrFrames);
-  for (uptr i = 0; i < kMaxAddrFrames; i++)
-    new(&addr_frames[i]) AddressInfo();
   InternalScopedString frame_desc(GetPageSizeCached() * 2);
   uptr frame_num = 0;
   for (uptr i = 0; i < size && trace[i]; i++) {
     // PCs in stack traces are actually the return addresses, that is,
     // addresses of the next instructions after the call.
     uptr pc = GetPreviousInstructionPc(trace[i]);
-    uptr addr_frames_num = Symbolizer::GetOrInit()->SymbolizePC(
-        pc, addr_frames.data(), kMaxAddrFrames);
-    if (addr_frames_num == 0) {
-      addr_frames[0].address = pc;
-      addr_frames_num = 1;
-    }
-    for (uptr j = 0; j < addr_frames_num; j++) {
-      AddressInfo &info = addr_frames[j];
+    SymbolizedFrame *frames = Symbolizer::GetOrInit()->SymbolizePC(pc);
+    CHECK(frames);
+    for (SymbolizedFrame *cur = frames; cur; cur = cur->next) {
       frame_desc.clear();
       RenderFrame(&frame_desc, common_flags()->stack_trace_format, frame_num++,
-                  info, common_flags()->strip_path_prefix);
+                  cur->info, common_flags()->strip_path_prefix);
       Printf("%s\n", frame_desc.data());
-      info.Clear();
     }
+    frames->ClearAll();
   }
   // Always print a trailing empty line after stack trace.
   Printf("\n");
 }
 
 void BufferedStackTrace::Unwind(uptr max_depth, uptr pc, uptr bp, void *context,
                                 uptr stack_top, uptr stack_bottom,
                                 bool request_fast_unwind) {

lib/sanitizer_common/sanitizer_symbolizer.h

 // communicate with it.
 //
 // Generally we should try to avoid calling system library functions during
 // symbolization (and use their replacements from sanitizer_libc.h instead).
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_SYMBOLIZER_H
 #define SANITIZER_SYMBOLIZER_H
 
-#include "sanitizer_allocator_internal.h"
-#include "sanitizer_internal_defs.h"
-#include "sanitizer_libc.h"
+#include "sanitizer_common.h"
+#include "sanitizer_mutex.h"
 
 namespace __sanitizer {
 
 struct AddressInfo {
+  // Owns all the string members. Storage for them is
+  // (de)allocated using sanitizer internal allocator.
   uptr address;
 
   char *module;
   uptr module_offset;
 
   static const uptr kUnknown = ~(uptr)0;
   char *function;
   uptr function_offset;
 
   char *file;
   int line;
   int column;
 
-  AddressInfo() {
-    internal_memset(this, 0, sizeof(AddressInfo));
-    function_offset = kUnknown;
-  }
-
+  AddressInfo();
   // Deletes all strings and resets all fields.
-  void Clear() {
-    InternalFree(module);
-    InternalFree(function);
-    InternalFree(file);
-    internal_memset(this, 0, sizeof(AddressInfo));
-    function_offset = kUnknown;
-  }
-
+  void Clear();
   void FillAddressAndModuleInfo(uptr addr, const char *mod_name,
-                                uptr mod_offset) {
-    address = addr;
-    module = internal_strdup(mod_name);
-    module_offset = mod_offset;
-  }
+                                uptr mod_offset);
+};
+
+struct SymbolizedFrame {
+  SymbolizedFrame *next;
+  AddressInfo info;
+  static SymbolizedFrame *New(uptr addr);
+  // Clears current, and all subsequent frames in the linked list.
+  void ClearAll();
+
+ private:
+  SymbolizedFrame();
 };
 
 // For now, DataInfo is used to describe global variable.
 struct DataInfo {
+  // Owns all the string members. Storage for them is
+  // (de)allocated using sanitizer internal allocator.
   char *module;
   uptr module_offset;
   char *name;
   uptr start;
   uptr size;
 
-  DataInfo() {
-    internal_memset(this, 0, sizeof(DataInfo));
-  }
-
-  void Clear() {
-    InternalFree(module);
-    InternalFree(name);
-    internal_memset(this, 0, sizeof(DataInfo));
-  }
+  DataInfo();
+  void Clear();
 };
 
 class Symbolizer {
  public:
   /// Initialize and return platform-specific implementation of symbolizer
   /// (if it wasn't already initialized).
   static Symbolizer *GetOrInit();
-  // Fills at most "max_frames" elements of "frames" with descriptions
-  // for a given address (in all inlined functions). Returns the number
-  // of descriptions actually filled.
-  virtual uptr SymbolizePC(uptr address, AddressInfo *frames, uptr max_frames) {
-    return 0;
+  // Returns a list of symbolized frames for a given address (containing
+  // all inlined functions, if necessary).
+  virtual SymbolizedFrame *SymbolizePC(uptr address) {
+    return SymbolizedFrame::New(address);
   }
   virtual bool SymbolizeData(uptr address, DataInfo *info) {
     return false;
   }
   virtual bool GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
                                            uptr *module_address) {
     return false;
   }

lib/sanitizer_common/sanitizer_symbolizer.cc

 //===-- sanitizer_symbolizer.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 shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
+#include "sanitizer_allocator_internal.h"
 #include "sanitizer_platform.h"
 #include "sanitizer_internal_defs.h"
+#include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_symbolizer.h"
 
 namespace __sanitizer {
 
+AddressInfo::AddressInfo() {
+  internal_memset(this, 0, sizeof(AddressInfo));
+  function_offset = kUnknown;
+}
+
+void AddressInfo::Clear() {
+  InternalFree(module);
+  InternalFree(function);
+  InternalFree(file);
+  internal_memset(this, 0, sizeof(AddressInfo));
+  function_offset = kUnknown;
+}
+
+void AddressInfo::FillAddressAndModuleInfo(uptr addr, const char *mod_name,
+                                           uptr mod_offset) {
+  address = addr;
+  module = internal_strdup(mod_name);
+  module_offset = mod_offset;
+}
+
+SymbolizedFrame::SymbolizedFrame() : next(nullptr), info() {}
+
+SymbolizedFrame *SymbolizedFrame::New(uptr addr) {
+  void *mem = InternalAlloc(sizeof(SymbolizedFrame));
+  SymbolizedFrame *res = new(mem) SymbolizedFrame();
+  res->info.address = addr;
+  return res;
+}
+
+void SymbolizedFrame::ClearAll() {
+  info.Clear();
+  if (next) {
+    next->ClearAll();
+    next = nullptr;
+  }
+}
+
+DataInfo::DataInfo() {
+  internal_memset(this, 0, sizeof(DataInfo));
+}
+
+void DataInfo::Clear() {
+  InternalFree(module);
+  InternalFree(name);
+  internal_memset(this, 0, sizeof(DataInfo));
+}
+
 Symbolizer *Symbolizer::symbolizer_;
 StaticSpinMutex Symbolizer::init_mu_;
 LowLevelAllocator Symbolizer::symbolizer_allocator_;
 
 Symbolizer *Symbolizer::Disable() {
   CHECK_EQ(0, symbolizer_);
   // Initialize a dummy symbolizer.
   symbolizer_ = new(symbolizer_allocator_) Symbolizer;

lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.h

 #endif
 
 namespace __sanitizer {
 
 class LibbacktraceSymbolizer {
  public:
   static LibbacktraceSymbolizer *get(LowLevelAllocator *alloc);
 
-  uptr SymbolizeCode(uptr addr, AddressInfo *frames, uptr max_frames,
-                     const char *module_name, uptr module_offset);
+  SymbolizedFrame *SymbolizeCode(uptr addr, const char *module_name,
+                                 uptr module_offset);
 
   bool SymbolizeData(DataInfo *info);
 
   // May return NULL if demangling failed.
   static char *Demangle(const char *name, bool always_alloc = false);
 
  private:
   explicit LibbacktraceSymbolizer(void *state) : state_(state) {}
 
   void *state_;  // Leaked.
 };
 
 }  // namespace __sanitizer
 #endif  // SANITIZER_SYMBOLIZER_LIBBACKTRACE_H

lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.cc

if (cplus_demangle_v3_callback(name, DMGL_PARAMS | DMGL_ANSI,
     return buf;
   }
   if (data.buf)
     InternalFree(data.buf);
   return 0;
 }
 # endif  // SANITIZER_CP_DEMANGLE
 
 struct SymbolizeCodeData {
-  AddressInfo *frames;
-  uptr n_frames;
-  uptr max_frames;
+  SymbolizedFrame *res;
+  SymbolizedFrame *last;
   const char *module_name;
   uptr module_offset;
+
+  void append(SymbolizedFrame *f) {
+    if (last != nullptr) {
+      last->next = f;
+      last = f;
+    } else {
+      res = f;
+      last = f;
+    }
+  }
 };
 
 extern "C" {
 static int SymbolizeCodePCInfoCallback(void *vdata, uintptr_t addr,
                                        const char *filename, int lineno,
                                        const char *function) {
   SymbolizeCodeData *cdata = (SymbolizeCodeData *)vdata;
   if (function) {
-    AddressInfo *info = &cdata->frames[cdata->n_frames++];
-    info->Clear();
+    SymbolizedFrame *cur = SymbolizedFrame::New(addr);
+    cdata->append(cur);
+    AddressInfo *info = &cur->info;
     info->FillAddressAndModuleInfo(addr, cdata->module_name,
                                    cdata->module_offset);
     info->function = LibbacktraceSymbolizer::Demangle(function, true);
     if (filename)
       info->file = internal_strdup(filename);
     info->line = lineno;
-    if (cdata->n_frames == cdata->max_frames)
-      return 1;
   }
   return 0;
 }
 
 static void SymbolizeCodeCallback(void *vdata, uintptr_t addr,
                                   const char *symname, uintptr_t, uintptr_t) {
   SymbolizeCodeData *cdata = (SymbolizeCodeData *)vdata;
   if (symname) {
-    AddressInfo *info = &cdata->frames[0];
-    info->Clear();
+    SymbolizedFrame *cur = SymbolizedFrame::New(addr);
+    cdata->append(cur);
+    AddressInfo *info = &cur->info;
     info->FillAddressAndModuleInfo(addr, cdata->module_name,
                                    cdata->module_offset);
     info->function = LibbacktraceSymbolizer::Demangle(symname, true);
-    cdata->n_frames = 1;
   }
 }
 
 static void SymbolizeDataCallback(void *vdata, uintptr_t, const char *symname,
                                   uintptr_t symval, uintptr_t symsize) {
   DataInfo *info = (DataInfo *)vdata;
   if (symname && symval) {
     info->name = LibbacktraceSymbolizer::Demangle(symname, true);
LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
   // State created in backtrace_create_state is leaked.
   void *state = (void *)(backtrace_create_state("/proc/self/exe", 0,
                                                 ErrorCallback, NULL));
   if (!state)
     return 0;
   return new(*alloc) LibbacktraceSymbolizer(state);
 }
 
-uptr LibbacktraceSymbolizer::SymbolizeCode(uptr addr, AddressInfo *frames,
-                                           uptr max_frames,
+SymbolizedFrame *LibbacktraceSymbolizer::SymbolizeCode(uptr addr,
                                                        const char *module_name,
                                                        uptr module_offset) {
   SymbolizeCodeData data;
-  data.frames = frames;
-  data.n_frames = 0;
-  data.max_frames = max_frames;
+  data.res = nullptr;
+  data.last = nullptr;
   data.module_name = module_name;
   data.module_offset = module_offset;
   backtrace_pcinfo((backtrace_state *)state_, addr, SymbolizeCodePCInfoCallback,
                    ErrorCallback, &data);
-  if (data.n_frames)
-    return data.n_frames;
+  if (data.res)
+    return data.res;
   backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeCodeCallback,
                     ErrorCallback, &data);
-  return data.n_frames;
+  return data.res;
 }
 
 bool LibbacktraceSymbolizer::SymbolizeData(DataInfo *info) {
   backtrace_syminfo((backtrace_state *)state_, info->address,
                     SymbolizeDataCallback, ErrorCallback, info);
   return true;
 }
 
 #else  // SANITIZER_LIBBACKTRACE
 
 LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
   return 0;
 }
 
-uptr LibbacktraceSymbolizer::SymbolizeCode(uptr addr, AddressInfo *frames,
-                                           uptr max_frames,
+SymbolizedFrame *LibbacktraceSymbolizer::SymbolizeCode(uptr addr,
                                                        const char *module_name,
                                                        uptr module_offset) {
   (void)state_;
-  return 0;
+  return nullptr;
 }
 
 bool LibbacktraceSymbolizer::SymbolizeData(DataInfo *info) {
   return false;
 }
 
 #endif  // SANITIZER_LIBBACKTRACE
 

lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc

public:
   POSIXSymbolizer(ExternalSymbolizerInterface *external_symbolizer,
                   InternalSymbolizer *internal_symbolizer,
                   LibbacktraceSymbolizer *libbacktrace_symbolizer)
       : Symbolizer(),
         external_symbolizer_(external_symbolizer),
         internal_symbolizer_(internal_symbolizer),
         libbacktrace_symbolizer_(libbacktrace_symbolizer) {}
 
-  uptr SymbolizePC(uptr addr, AddressInfo *frames, uptr max_frames) {
+  SymbolizedFrame *SymbolizePC(uptr addr) override {
     BlockingMutexLock l(&mu_);
-    if (max_frames == 0)
-      return 0;
     const char *module_name;
     uptr module_offset;
     if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset))
-      return 0;
+      return SymbolizedFrame::New(addr);
     // First, try to use libbacktrace symbolizer (if it's available).
     if (libbacktrace_symbolizer_ != 0) {
       mu_.CheckLocked();
-      uptr res = libbacktrace_symbolizer_->SymbolizeCode(
-          addr, frames, max_frames, module_name, module_offset);
-      if (res > 0)
+      if (SymbolizedFrame *res = libbacktrace_symbolizer_->SymbolizeCode(
+              addr, module_name, module_offset))
         return res;
     }
+    SymbolizedFrame *res = SymbolizedFrame::New(addr);
+    res->info.FillAddressAndModuleInfo(addr, module_name, module_offset);
+
     const char *str = SendCommand(false, module_name, module_offset);
     if (str == 0) {
       // Symbolizer was not initialized or failed. Fill only data
       // about module name and offset.
-      AddressInfo *info = &frames[0];
-      info->Clear();
-      info->FillAddressAndModuleInfo(addr, module_name, module_offset);
-      return 1;
+      return res;
     }
-    uptr frame_id = 0;
-    for (frame_id = 0; frame_id < max_frames; frame_id++) {
-      AddressInfo *info = &frames[frame_id];
+
+    bool top_frame = true;
+    SymbolizedFrame *last = res;
+    while (true) {
       char *function_name = 0;
       str = ExtractToken(str, "\n", &function_name);
       CHECK(function_name);
       if (function_name[0] == '\0') {
         // There are no more frames.
         break;
       }
-      info->Clear();
-      info->FillAddressAndModuleInfo(addr, module_name, module_offset);
+      SymbolizedFrame *cur;
+      if (top_frame) {
+        cur = res;
+        top_frame = false;
+      } else {
+        cur = SymbolizedFrame::New(addr);
+        cur->info.FillAddressAndModuleInfo(addr, module_name, module_offset);
+        last->next = cur;
+        last = cur;
+      }
+
+      AddressInfo *info = &cur->info;
       info->function = function_name;
       // Parse <file>:<line>:<column> buffer.
       char *file_line_info = 0;
       str = ExtractToken(str, "\n", &file_line_info);
       CHECK(file_line_info);
       const char *line_info = ExtractToken(file_line_info, ":", &info->file);
       line_info = ExtractInt(line_info, ":", &info->line);
       line_info = ExtractInt(line_info, "", &info->column);
       InternalFree(file_line_info);
 
       // Functions and filenames can be "??", in which case we write 0
       // to address info to mark that names are unknown.
       if (0 == internal_strcmp(info->function, "??")) {
         InternalFree(info->function);
         info->function = 0;
       }
       if (0 == internal_strcmp(info->file, "??")) {
         InternalFree(info->file);
         info->file = 0;
       }
     }
-    if (frame_id == 0) {
-      // Make sure we return at least one frame.
-      AddressInfo *info = &frames[0];
-      info->Clear();
-      info->FillAddressAndModuleInfo(addr, module_name, module_offset);
-      frame_id = 1;
-    }
-    return frame_id;
+    return res;
   }
 
   bool SymbolizeData(uptr addr, DataInfo *info) {
     BlockingMutexLock l(&mu_);
     LoadedModule *module = FindModuleForAddress(addr);
     if (module == 0)
       return false;
     const char *module_name = module->full_name();

lib/sanitizer_common/sanitizer_symbolizer_win.cc

 #include "sanitizer_symbolizer.h"
 
 namespace __sanitizer {
 
 class WinSymbolizer : public Symbolizer {
  public:
   WinSymbolizer() : initialized_(false) {}
 
-  uptr SymbolizePC(uptr addr, AddressInfo *frames, uptr max_frames) {
-    if (max_frames == 0)
-      return 0;
-
+  SymbolizedFrame *SymbolizePC(uptr addr) override {
+    SymbolizedFrame *frame = SymbolizedFrame::New(addr);
     BlockingMutexLock l(&dbghelp_mu_);
     if (!initialized_) {
       if (!TrySymInitialize()) {
         // OK, maybe the client app has called SymInitialize already.
         // That's a bit unfortunate for us as all the DbgHelp functions are
         // single-threaded and we can't coordinate with the app.
         // FIXME: Can we stop the other threads at this point?
         // Anyways, we have to reconfigure stuff to make sure that SymInitialize
SymbolizedFrame *SymbolizePC(uptr addr) override {
     char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(CHAR)];
     PSYMBOL_INFO symbol = (PSYMBOL_INFO)buffer;
     symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
     symbol->MaxNameLen = MAX_SYM_NAME;
     DWORD64 offset = 0;
     BOOL got_objname = SymFromAddr(GetCurrentProcess(),
                                    (DWORD64)addr, &offset, symbol);
     if (!got_objname)
-      return 0;
+      return frame;
 
     DWORD unused;
     IMAGEHLP_LINE64 line_info;
     line_info.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
     BOOL got_fileline = SymGetLineFromAddr64(GetCurrentProcess(), (DWORD64)addr,
                                              &unused, &line_info);
-    AddressInfo *info = &frames[0];
-    info->Clear();
-    info->function = internal_strdup(symbol->Name);
-    info->function_offset = (uptr)offset;
+    frame->info.function = internal_strdup(symbol->Name);
+    frame->info.function_offset = (uptr)offset;
     if (got_fileline) {
-      info->file = internal_strdup(line_info.FileName);
-      info->line = line_info.LineNumber;
+      frame->info.file = internal_strdup(line_info.FileName);
+      frame->info.line = line_info.LineNumber;
     }
 
     IMAGEHLP_MODULE64 mod_info;
     internal_memset(&mod_info, 0, sizeof(mod_info));
     mod_info.SizeOfStruct = sizeof(mod_info);
     if (SymGetModuleInfo64(GetCurrentProcess(), addr, &mod_info))
-      info->FillAddressAndModuleInfo(addr, mod_info.ImageName,
+      frame->info.FillAddressAndModuleInfo(addr, mod_info.ImageName,
                                            addr - (uptr)mod_info.BaseOfImage);
-    return 1;
+    return frame;
   }
 
   bool CanReturnFileLineInfo() {
     return true;
   }
 
   const char *Demangle(const char *name) {
     CHECK(initialized_);

lib/tsan/rtl/tsan_report.h

enum ReportType {
   ReportTypeMutexBadReadLock,
   ReportTypeMutexBadReadUnlock,
   ReportTypeSignalUnsafe,
   ReportTypeErrnoInSignal,
   ReportTypeDeadlock
 };
 
 struct ReportStack {
-  ReportStack *next;
-  AddressInfo info;
+  SymbolizedFrame *frames;
   bool suppressable;
-  static ReportStack *New(uptr addr);
+  static ReportStack *New();
 
  private:
   ReportStack();
 };
 
 struct ReportMopMutex {
   u64 id;
   bool write;

lib/tsan/rtl/tsan_report.cc

 #include "tsan_platform.h"
 #include "tsan_rtl.h"
 #include "sanitizer_common/sanitizer_placement_new.h"
 #include "sanitizer_common/sanitizer_report_decorator.h"
 #include "sanitizer_common/sanitizer_stacktrace_printer.h"
 
 namespace __tsan {
 
-ReportStack::ReportStack() : next(nullptr), info(), suppressable(false) {}
+ReportStack::ReportStack() : frames(nullptr), suppressable(false) {}
 
-ReportStack *ReportStack::New(uptr addr) {
+ReportStack *ReportStack::New() {
   void *mem = internal_alloc(MBlockReportStack, sizeof(ReportStack));
-  ReportStack *res = new(mem) ReportStack();
-  res->info.address = addr;
-  return res;
+  return new(mem) ReportStack();
 }
 
 ReportLocation::ReportLocation(ReportLocationType type)
     : type(type), global(), heap_chunk_start(0), heap_chunk_size(0), tid(0),
       fd(0), suppressable(false), stack(nullptr) {}
 
 ReportLocation *ReportLocation::New(ReportLocationType type) {
   void *mem = internal_alloc(MBlockReportStack, sizeof(ReportLocation));
static const char *ReportTypeString(ReportType typ) {
   return "";
 }
 
 void PrintStack(const ReportStack *ent) {
   if (ent == 0) {
     Printf("    [failed to restore the stack]\n\n");
     return;
   }
-  for (int i = 0; ent && ent->info.address; ent = ent->next, i++) {
+  SymbolizedFrame *frame = ent->frames;
+  for (int i = 0; frame && frame->info.address; frame = frame->next, i++) {
     InternalScopedString res(2 * GetPageSizeCached());
-    RenderFrame(&res, common_flags()->stack_trace_format, i, ent->info,
+    RenderFrame(&res, common_flags()->stack_trace_format, i, frame->info,
                 common_flags()->strip_path_prefix, "__interceptor_");
     Printf("%s\n", res.data());
   }
   Printf("\n");
 }
 
 static void PrintMutexSet(Vector<ReportMopMutex> const& mset) {
   for (uptr i = 0; i < mset.Size(); i++) {
if (rep->stacks.Size())
     return rep->stacks[0];
   if (rep->mutexes.Size())
     return rep->mutexes[0]->stack;
   if (rep->threads.Size())
     return rep->threads[0]->stack;
   return 0;
 }
 
-ReportStack *SkipTsanInternalFrames(ReportStack *ent) {
-  while (FrameIsInternal(ent) && ent->next)
-    ent = ent->next;
-  return ent;
+static bool FrameIsInternal(const SymbolizedFrame *frame) {
+  if (frame == 0)
+    return false;
+  const char *file = frame->info.file;
+  return file != 0 &&
+         (internal_strstr(file, "tsan_interceptors.cc") ||
+          internal_strstr(file, "sanitizer_common_interceptors.inc") ||
+          internal_strstr(file, "tsan_interface_"));
+}
+
+static SymbolizedFrame *SkipTsanInternalFrames(SymbolizedFrame *frames) {
+  while (FrameIsInternal(frames) && frames->next)
+    frames = frames->next;
+  return frames;
 }
 
 void PrintReport(const ReportDesc *rep) {
   Decorator d;
   Printf("==================\n");
   const char *rep_typ_str = ReportTypeString(rep->typ);
   Printf("%s", d.Warning());
   Printf("WARNING: ThreadSanitizer: %s (pid=%d)\n", rep_typ_str,
void PrintReport(const ReportDesc *rep) {
   }
 
   for (uptr i = 0; i < rep->threads.Size(); i++)
     PrintThread(rep->threads[i]);
 
   if (rep->typ == ReportTypeThreadLeak && rep->count > 1)
     Printf("  And %d more similar thread leaks.\n\n", rep->count - 1);
 
-  if (ReportStack *ent = SkipTsanInternalFrames(ChooseSummaryStack(rep))) {
-    const AddressInfo &info = ent->info;
+  if (ReportStack *stack = ChooseSummaryStack(rep)) {
+    if (SymbolizedFrame *frame = SkipTsanInternalFrames(stack->frames)) {
+      const AddressInfo &info = frame->info;
       ReportErrorSummary(rep_typ_str, info.file, info.line, info.function);
     }
+  }
 
   Printf("==================\n");
 }
 
 #else  // #ifndef TSAN_GO
 
 const int kMainThreadId = 1;
 

lib/tsan/rtl/tsan_rtl.h

 void ForkChildAfter(ThreadState *thr, uptr pc);
 
 void ReportRace(ThreadState *thr);
 bool OutputReport(ThreadState *thr, const ScopedReport &srep);
 bool IsFiredSuppression(Context *ctx, const ScopedReport &srep,
                         StackTrace trace);
 bool IsExpectedReport(uptr addr, uptr size);
 void PrintMatchedBenignRaces();
-bool FrameIsInternal(const ReportStack *frame);
-ReportStack *SkipTsanInternalFrames(ReportStack *ent);
 
 #if defined(TSAN_DEBUG_OUTPUT) && TSAN_DEBUG_OUTPUT >= 1
 # define DPrintf Printf
 #else
 # define DPrintf(...)
 #endif
 
 #if defined(TSAN_DEBUG_OUTPUT) && TSAN_DEBUG_OUTPUT >= 2

lib/tsan/rtl/tsan_rtl_report.cc

 #else
 SANITIZER_INTERFACE_ATTRIBUTE
 bool WEAK OnReport(const ReportDesc *rep, bool suppressed) {
   (void)rep;
   return suppressed;
 }
 #endif
 
-static void StackStripMain(ReportStack *stack) {
-  ReportStack *last_frame = 0;
-  ReportStack *last_frame2 = 0;
-  for (ReportStack *ent = stack; ent; ent = ent->next) {
+static void StackStripMain(SymbolizedFrame *frames) {
+  SymbolizedFrame *last_frame = nullptr;
+  SymbolizedFrame *last_frame2 = nullptr;
+  for (SymbolizedFrame *cur = frames; cur; cur = cur->next) {
     last_frame2 = last_frame;
-    last_frame = ent;
+    last_frame = cur;
   }
 
   if (last_frame2 == 0)
     return;
-  const char *last = last_frame->info.function;
 #ifndef TSAN_GO
+  const char *last = last_frame->info.function;
   const char *last2 = last_frame2->info.function;
   // Strip frame above 'main'
   if (last2 && 0 == internal_strcmp(last2, "main")) {
-    last_frame2->next = 0;
+    last_frame->ClearAll();
+    last_frame2->next = nullptr;
   // Strip our internal thread start routine.
   } else if (last && 0 == internal_strcmp(last, "__tsan_thread_start_func")) {
-    last_frame2->next = 0;
+    last_frame->ClearAll();
+    last_frame2->next = nullptr;
   // Strip global ctors init.
   } else if (last && 0 == internal_strcmp(last, "__do_global_ctors_aux")) {
-    last_frame2->next = 0;
+    last_frame->ClearAll();
+    last_frame2->next = nullptr;
   // If both are 0, then we probably just failed to symbolize.
   } else if (last || last2) {
     // Ensure that we recovered stack completely. Trimmed stack
     // can actually happen if we do not instrument some code,
     // so it's only a debug print. However we must try hard to not miss it
     // due to our fault.
-    DPrintf("Bottom stack frame of stack %zx is missed\n", stack->pc);
+    DPrintf("Bottom stack frame of stack %zx is missed\n", stack->info.address);
   }
 #else
   // The last frame always point into runtime (gosched0, goexit0, runtime.main).
-  last_frame2->next = 0;
-  (void)last;
+  last_frame->ClearAll();
+  last_frame2->next = nullptr;
 #endif
 }
 
 ReportStack *SymbolizeStackId(u32 stack_id) {
   if (stack_id == 0)
     return 0;
   StackTrace stack = StackDepotGet(stack_id);
   if (stack.trace == nullptr)
     return nullptr;
   return SymbolizeStack(stack);
 }
 
 static ReportStack *SymbolizeStack(StackTrace trace) {
   if (trace.size == 0)
     return 0;
-  ReportStack *stack = 0;
+  SymbolizedFrame *top = nullptr;
   for (uptr si = 0; si < trace.size; si++) {
     const uptr pc = trace.trace[si];
 #ifndef TSAN_GO
-    // We obtain the return address, that is, address of the next instruction,
-    // so offset it by 1 byte.
+    // We obtain the return address, but we're interested in the previous
+    // instruction.
     const uptr pc1 = StackTrace::GetPreviousInstructionPc(pc);
 #else
     // FIXME(dvyukov): Go sometimes uses address of a function as top pc.
     uptr pc1 = pc;
     if (si != trace.size - 1)
       pc1 -= 1;
 #endif
-    ReportStack *ent = SymbolizeCode(pc1);
+    SymbolizedFrame *ent = SymbolizeCode(pc1);
     CHECK_NE(ent, 0);
-    ReportStack *last = ent;
+    SymbolizedFrame *last = ent;
     while (last->next) {
       last->info.address = pc;  // restore original pc for report
       last = last->next;
     }
     last->info.address = pc;  // restore original pc for report
-    last->next = stack;
-    stack = ent;
+    last->next = top;
+    top = ent;
   }
-  StackStripMain(stack);
+  StackStripMain(top);
+
+  ReportStack *stack = ReportStack::New();
+  stack->frames = top;
   return stack;
 }
 
 ScopedReport::ScopedReport(ReportType typ) {
   ctx->thread_registry->CheckLocked();
   void *mem = internal_alloc(MBlockReport, sizeof(ReportDesc));
   rep_ = new(mem) ReportDesc;
   rep_->typ = typ;
if (addr == s->pc) {
       if (s->supp)
         s->supp->hit_count++;
       return true;
     }
   }
   return false;
 }
 
-bool FrameIsInternal(const ReportStack *frame) {
-  if (frame == 0)
-    return false;
-  const char *file = frame->info.file;
-  return file != 0 &&
-         (internal_strstr(file, "tsan_interceptors.cc") ||
-          internal_strstr(file, "sanitizer_common_interceptors.inc") ||
-          internal_strstr(file, "tsan_interface_"));
-}
-
 static bool RaceBetweenAtomicAndFree(ThreadState *thr) {
   Shadow s0(thr->racy_state[0]);
   Shadow s1(thr->racy_state[1]);
   CHECK(!(s0.IsAtomic() && s1.IsAtomic()));
   if (!s0.IsAtomic() && !s1.IsAtomic())
     return true;
   if (s0.IsAtomic() && s1.IsFreed())
     return true;

lib/tsan/rtl/tsan_suppressions.cc

 uptr IsSuppressed(ReportType typ, const ReportStack *stack, Suppression **sp) {
   if (!SuppressionContext::Get()->SuppressionCount() || stack == 0 ||
       !stack->suppressable)
     return 0;
   SuppressionType stype = conv(typ);
   if (stype == SuppressionNone)
     return 0;
   Suppression *s;
-  for (const ReportStack *frame = stack; frame; frame = frame->next) {
+  for (const SymbolizedFrame *frame = stack->frames; frame;
+       frame = frame->next) {
     const AddressInfo &info = frame->info;
     if (SuppressionContext::Get()->Match(info.function, stype, &s) ||
         SuppressionContext::Get()->Match(info.file, stype, &s) ||
         SuppressionContext::Get()->Match(info.module, stype, &s)) {
       DPrintf("ThreadSanitizer: matched suppression '%s'\n", s->templ);
       s->hit_count++;
       *sp = s;
       return info.address;

lib/tsan/rtl/tsan_symbolize.h

 
 #include "tsan_defs.h"
 #include "tsan_report.h"
 
 namespace __tsan {
 
 void EnterSymbolizer();
 void ExitSymbolizer();
-ReportStack *SymbolizeCode(uptr addr);
+SymbolizedFrame *SymbolizeCode(uptr addr);
 ReportLocation *SymbolizeData(uptr addr);
 void SymbolizeFlush();
 
 ReportStack *NewReportStackEntry(uptr addr);
 
 }  // namespace __tsan
 
 #endif  // TSAN_SYMBOLIZE_H

lib/tsan/rtl/tsan_symbolize.cc

 
 bool __tsan_symbolize_external(uptr pc,
                                char *func_buf, uptr func_siz,
                                char *file_buf, uptr file_siz,
                                int *line, int *col) {
   return false;
 }
 
-ReportStack *SymbolizeCode(uptr addr) {
+SymbolizedFrame *SymbolizeCode(uptr addr) {
   // Check if PC comes from non-native land.
   if (addr & kExternalPCBit) {
     // Declare static to not consume too much stack space.
     // We symbolize reports in a single thread, so this is fine.
     static char func_buf[1024];
     static char file_buf[1024];
     int line, col;
-    ReportStack *ent = ReportStack::New(addr);
-    if (!__tsan_symbolize_external(addr, func_buf, sizeof(func_buf),
-                                  file_buf, sizeof(file_buf), &line, &col))
-      return ent;
-    ent->info.function = internal_strdup(func_buf);
-    ent->info.file = internal_strdup(file_buf);
-    ent->info.line = line;
-    ent->info.column = col;
-    return ent;
+    SymbolizedFrame *frame = SymbolizedFrame::New(addr);
+    if (__tsan_symbolize_external(addr, func_buf, sizeof(func_buf), file_buf,
+                                  sizeof(file_buf), &line, &col)) {
+      frame->info.function = internal_strdup(func_buf);
+      frame->info.file = internal_strdup(file_buf);
+      frame->info.line = line;
+      frame->info.column = col;
     }
-  static const uptr kMaxAddrFrames = 16;
-  InternalScopedBuffer<AddressInfo> addr_frames(kMaxAddrFrames);
-  for (uptr i = 0; i < kMaxAddrFrames; i++)
-    new(&addr_frames[i]) AddressInfo();
-  uptr addr_frames_num = Symbolizer::GetOrInit()->SymbolizePC(
-      addr, addr_frames.data(), kMaxAddrFrames);
-  if (addr_frames_num == 0)
-    return ReportStack::New(addr);
-  ReportStack *top = 0;
-  ReportStack *bottom = 0;
-  for (uptr i = 0; i < addr_frames_num; i++) {
-    ReportStack *cur_entry = ReportStack::New(addr);
-    cur_entry->info = addr_frames[i];
-    if (i == 0)
-      top = cur_entry;
-    else
-      bottom->next = cur_entry;
-    bottom = cur_entry;
+    return frame;
   }
-  return top;
+  return Symbolizer::GetOrInit()->SymbolizePC(addr);
 }
 
 ReportLocation *SymbolizeData(uptr addr) {
   DataInfo info;
   if (!Symbolizer::GetOrInit()->SymbolizeData(addr, &info))
     return 0;
   ReportLocation *ent = ReportLocation::New(ReportLocationGlobal);
   ent->global = info;
   return ent;
 }
 
 void SymbolizeFlush() {
   Symbolizer::GetOrInit()->Flush();
 }
 
 }  // namespace __tsan

lib/ubsan/ubsan_diag.cc

Location __ubsan::getCallerLocation(uptr CallerLoc) {
   return getFunctionLocation(Loc, 0);
 }
 
 Location __ubsan::getFunctionLocation(uptr Loc, const char **FName) {
   if (!Loc)
     return Location();
   InitIfNecessary();
 
-  AddressInfo Info;
-  if (!Symbolizer::GetOrInit()->SymbolizePC(Loc, &Info, 1) || !Info.module ||
-      !*Info.module)
+  SymbolizedFrame *Frames = Symbolizer::GetOrInit()->SymbolizePC(Loc);
+  const AddressInfo &Info = Frames->info;
+
+  if (!Info.module) {
+    Frames->ClearAll();
     return Location(Loc);
+  }
 
   if (FName && Info.function)
-    *FName = Info.function;
+    *FName = internal_strdup(Info.function);
 
-  if (!Info.file)
-    return ModuleLocation(Info.module, Info.module_offset);
+  if (!Info.file) {
+    ModuleLocation MLoc(internal_strdup(Info.module), Info.module_offset);
+    Frames->ClearAll();
+    return MLoc;
+  }
 
-  return SourceLocation(Info.file, Info.line, Info.column);
+  SourceLocation SLoc(internal_strdup(Info.file), Info.line, Info.column);
+  Frames->ClearAll();
+  return SLoc;
 }
 
 Diag &Diag::operator<<(const TypeDescriptor &V) {
   return AddArg(V.getTypeName());
 }
 
 Diag &Diag::operator<<(const Value &V) {
   if (V.getType().isSignedIntegerTy())