[compiler-rt] Symbolizer refactoring: Link symbolizer tools into a fallback chain

[kubamracek]

Summary

Part of http://reviews.llvm.org/D7827. Although we currently always use only one (or zero) symbolizer tool from POSIXSymbolizer, let's prepare a "fallback chain", which will be useful in the planned atos- and dladdr-based symbolizers.

[samsonov]

lib/sanitizer_common/sanitizer_symbolizer_internal.h

31

You need a SymbolizerTool constructor that would initialize next to nullptr. Also, add a comment here why you need it.

lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc

353–354

Consider just taking IntrusiveList<SymbolizerTool> as an input parameter. Otherwise you:

• need to call tools_.clear() in constructor anyway
• introduce an implicit assertion that AppendSymbolizerTool should be called before using any other methods.

369

Why not just return here?

389

ditto

[kubamracek]

Addressing review comments.

[samsonov]

LGTM, but please address the comment.

lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc

354

IntrusiveList is designed to be a POD, I think it would be easier to just pass it by value and copy it...

519

That is, no need to call to symbolizer_allocator_ here, just

IntrusiveList<SymbolizerTool> list;
list.clear();
//...
return new(symbolizer_allocator_) POSIXSymbolizer(list);

[kubamracek]

Landed in r231361.

lib/sanitizer_common/sanitizer_symbolizer_internal.h

 // InternalAlloc) and null-terminataed buffer is returned. They return a pointer
 // to the next characted after the found delimiter.
 const char *ExtractToken(const char *str, const char *delims, char **result);
 const char *ExtractInt(const char *str, const char *delims, int *result);
 const char *ExtractUptr(const char *str, const char *delims, uptr *result);
 
 class SymbolizerTool {
  public:
+  // POSIXSymbolizer implements a "fallback chain" of symbolizer tools. In a
+  // request to symbolize an address, if one tool returns false, the next tool
+  // in the chain will be tried.
+  SymbolizerTool *next;
+
+  SymbolizerTool() : next(nullptr) { }
+
   // Can't declare pure virtual functions in sanitizer runtimes:
   // __cxa_pure_virtual might be unavailable.
 
   // The |stack| parameter is inout. It is pre-filled with the address,
   // module base and module offset values and is to be used to construct
   // other stack frames.
   virtual bool SymbolizePC(uptr addr, SymbolizedStack *stack) {
     UNIMPLEMENTED();

lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc

  public:
   static InternalSymbolizer *get(LowLevelAllocator *alloc) { return 0; }
 };
 
 #endif  // SANITIZER_SUPPORTS_WEAK_HOOKS
 
 class POSIXSymbolizer : public Symbolizer {
  public:
-  explicit POSIXSymbolizer(SymbolizerTool *symbolizer_tool)
-      : Symbolizer(), symbolizer_tool_(symbolizer_tool) {}
+   explicit POSIXSymbolizer(IntrusiveList<SymbolizerTool> *tools)
+       : Symbolizer(), tools_(tools) {}
 
   SymbolizedStack *SymbolizePC(uptr addr) override {
     BlockingMutexLock l(&mu_);
     const char *module_name;
     uptr module_offset;
     SymbolizedStack *res = SymbolizedStack::New(addr);
     if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset))
       return res;
     // Always fill data about module name and offset.
     res->info.FillModuleInfo(module_name, module_offset);
-    if (symbolizer_tool_) {
+    for (auto iter = Iterator(tools_); iter.hasNext();) {
+      auto *tool = iter.next();
       SymbolizerScope sym_scope(this);
-      symbolizer_tool_->SymbolizePC(addr, res);
+      if (tool->SymbolizePC(addr, res)) {
+        return res;
+      }
     }
     return res;
   }
 
   bool SymbolizeData(uptr addr, DataInfo *info) override {
     BlockingMutexLock l(&mu_);
     LoadedModule *module = FindModuleForAddress(addr);
     if (module == 0)
       return false;
     const char *module_name = module->full_name();
     uptr module_offset = addr - module->base_address();
     info->Clear();
     info->module = internal_strdup(module_name);
     info->module_offset = module_offset;
-    if (symbolizer_tool_) {
+    for (auto iter = Iterator(tools_); iter.hasNext();) {
+      auto *tool = iter.next();
       SymbolizerScope sym_scope(this);
-      symbolizer_tool_->SymbolizeData(addr, info);
+      if (tool->SymbolizeData(addr, info)) {
+        return true;
+      }
     }
     return true;
   }
 
   bool GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
                                    uptr *module_address) override {
     BlockingMutexLock l(&mu_);
     return FindModuleNameAndOffsetForAddress(pc, module_name, module_address);
   }
 
   bool CanReturnFileLineInfo() override {
-    return symbolizer_tool_ != nullptr;
+    return !tools_->empty();
   }
 
   void Flush() override {
     BlockingMutexLock l(&mu_);
-    if (symbolizer_tool_) {
+    for (auto iter = Iterator(tools_); iter.hasNext();) {
+      auto *tool = iter.next();
       SymbolizerScope sym_scope(this);
-      symbolizer_tool_->Flush();
+      tool->Flush();
     }
   }
 
   const char *Demangle(const char *name) override {
     BlockingMutexLock l(&mu_);
-    if (symbolizer_tool_) {
+    for (auto iter = Iterator(tools_); iter.hasNext();) {
+      auto *tool = iter.next();
       SymbolizerScope sym_scope(this);
-      if (const char *demangled = symbolizer_tool_->Demangle(name))
+      if (const char *demangled = tool->Demangle(name))
         return demangled;
     }
     return DemangleCXXABI(name);
   }
 
   void PrepareForSandboxing() override {
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
     BlockingMutexLock l(&mu_);
private:
   // 16K loaded modules should be enough for everyone.
   static const uptr kMaxNumberOfModuleContexts = 1 << 14;
   LoadedModule *modules_;  // Array of module descriptions is leaked.
   uptr n_modules_;
   // If stale, need to reload the modules before looking up addresses.
   bool modules_fresh_;
   BlockingMutex mu_;
 
-  SymbolizerTool *const symbolizer_tool_;         // Leaked.
+  typedef IntrusiveList<SymbolizerTool>::Iterator Iterator;
+  IntrusiveList<SymbolizerTool> *tools_;  // Leaked.
 };
 
 static SymbolizerTool *ChooseSymbolizer(LowLevelAllocator *allocator) {
   if (!common_flags()->symbolize) {
     return nullptr;
   }
   if (SymbolizerTool *tool = InternalSymbolizer::get(allocator)) {
     return tool;
if (common_flags()->allow_addr2line) {
     if (const char *addr2line_path = FindPathToBinary("addr2line")) {
       return new(*allocator) Addr2LinePool(addr2line_path, allocator);
     }
   }
   return nullptr;
 }
 
 Symbolizer *Symbolizer::PlatformInit() {
-  return new(symbolizer_allocator_)
-      POSIXSymbolizer(ChooseSymbolizer(&symbolizer_allocator_));
+  IntrusiveList<SymbolizerTool> *list =
+      new (symbolizer_allocator_) IntrusiveList<SymbolizerTool>();
+  list->clear();
+  if (SymbolizerTool *tool = ChooseSymbolizer(&symbolizer_allocator_)) {
+    list->push_back(tool);
+  }
+  return new(symbolizer_allocator_) POSIXSymbolizer(list);  
 }
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_POSIX