Index: lib/sanitizer_common/sanitizer_symbolizer_internal.h
===================================================================
--- lib/sanitizer_common/sanitizer_symbolizer_internal.h
+++ lib/sanitizer_common/sanitizer_symbolizer_internal.h
@@ -46,8 +46,9 @@
 
   virtual void Flush() {}
 
+  // Return nullptr to fallback to the default __cxxabiv1 demangler.
   virtual const char *Demangle(const char *name) {
-    return name;
+    return nullptr;
   }
 };
 
Index: lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc
===================================================================
--- lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc
+++ lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc
@@ -173,6 +173,7 @@
     if (const char *buf =
             SendCommand(/*is_data*/ true, info->module, info->module_offset)) {
       ParseSymbolizeDataOutput(buf, info);
+      info->start += (addr - info->module_offset);  // Add the base address.
       return true;
     }
     return false;
@@ -301,7 +302,10 @@
   bool SymbolizeData(uptr addr, DataInfo *info) override {
     bool result = __sanitizer_symbolize_data(info->module, info->module_offset,
                                              buffer_, kBufferSize);
-    if (result) ParseSymbolizeDataOutput(buffer_, info);
+    if (result) {
+      ParseSymbolizeDataOutput(buffer_, info);
+      info->start += (addr - info->module_offset);  // Add the base address.
+    }
     return result;
   }
 
@@ -346,13 +350,8 @@
 
 class POSIXSymbolizer : public Symbolizer {
  public:
-  POSIXSymbolizer(SymbolizerTool *external_symbolizer,
-                  SymbolizerTool *internal_symbolizer,
-                  LibbacktraceSymbolizer *libbacktrace_symbolizer)
-      : Symbolizer(),
-        external_symbolizer_(external_symbolizer),
-        internal_symbolizer_(internal_symbolizer),
-        libbacktrace_symbolizer_(libbacktrace_symbolizer) {}
+  explicit POSIXSymbolizer(SymbolizerTool *symbolizer_tool)
+      : Symbolizer(), symbolizer_tool_(symbolizer_tool) {}
 
   SymbolizedStack *SymbolizePC(uptr addr) override {
     BlockingMutexLock l(&mu_);
@@ -363,15 +362,9 @@
       return res;
     // Always fill data about module name and offset.
     res->info.FillModuleInfo(module_name, module_offset);
-    // First, try to use libbacktrace symbolizer (if it's available).
-    if (libbacktrace_symbolizer_ != 0) {
-      mu_.CheckLocked();
-      if (libbacktrace_symbolizer_->SymbolizePC(addr, res))
-        return res;
-    }
-    if (SymbolizerTool *tool = GetSymbolizerTool()) {
+    if (symbolizer_tool_) {
       SymbolizerScope sym_scope(this);
-      tool->SymbolizePC(addr, res);
+      symbolizer_tool_->SymbolizePC(addr, res);
     }
     return res;
   }
@@ -386,17 +379,10 @@
     info->Clear();
     info->module = internal_strdup(module_name);
     info->module_offset = module_offset;
-    // First, try to use libbacktrace symbolizer (if it's available).
-    if (libbacktrace_symbolizer_ != 0) {
-      mu_.CheckLocked();
-      if (libbacktrace_symbolizer_->SymbolizeData(addr, info))
-        return true;
-    }
-    if (SymbolizerTool *tool = GetSymbolizerTool()) {
+    if (symbolizer_tool_) {
       SymbolizerScope sym_scope(this);
-      tool->SymbolizeData(addr, info);
+      symbolizer_tool_->SymbolizeData(addr, info);
     }
-    info->start += module->base_address();
     return true;
   }
 
@@ -407,30 +393,24 @@
   }
 
   bool CanReturnFileLineInfo() override {
-    return internal_symbolizer_ != 0 || external_symbolizer_ != 0 ||
-           libbacktrace_symbolizer_ != 0;
+    return symbolizer_tool_ != nullptr;
   }
 
   void Flush() override {
     BlockingMutexLock l(&mu_);
-    if (internal_symbolizer_ != 0) {
+    if (symbolizer_tool_) {
       SymbolizerScope sym_scope(this);
-      internal_symbolizer_->Flush();
+      symbolizer_tool_->Flush();
     }
   }
 
   const char *Demangle(const char *name) override {
     BlockingMutexLock l(&mu_);
-    // Run hooks even if we don't use internal symbolizer, as cxxabi
-    // demangle may call system functions.
-    SymbolizerScope sym_scope(this);
-    // Try to use libbacktrace demangler (if available).
-    if (libbacktrace_symbolizer_ != 0) {
-      if (const char *demangled = libbacktrace_symbolizer_->Demangle(name))
+    if (symbolizer_tool_) {
+      SymbolizerScope sym_scope(this);
+      if (const char *demangled = symbolizer_tool_->Demangle(name))
         return demangled;
     }
-    if (internal_symbolizer_ != 0)
-      return internal_symbolizer_->Demangle(name);
     return DemangleCXXABI(name);
   }
 
@@ -443,13 +423,6 @@
   }
 
  private:
-  SymbolizerTool *GetSymbolizerTool() {
-    mu_.CheckLocked();
-    if (internal_symbolizer_) return internal_symbolizer_;
-    if (external_symbolizer_) return external_symbolizer_;
-    return nullptr;
-  }
-
   LoadedModule *FindModuleForAddress(uptr address) {
     mu_.CheckLocked();
     bool modules_were_reloaded = false;
@@ -499,47 +472,42 @@
   bool modules_fresh_;
   BlockingMutex mu_;
 
-  SymbolizerTool *const external_symbolizer_;         // Leaked.
-  SymbolizerTool *const internal_symbolizer_;         // Leaked.
-  LibbacktraceSymbolizer *libbacktrace_symbolizer_;   // Leaked.
+  SymbolizerTool *const symbolizer_tool_;         // Leaked.
 };
 
-Symbolizer *Symbolizer::PlatformInit() {
+static SymbolizerTool *ChooseSymbolizer(LowLevelAllocator *allocator) {
   if (!common_flags()->symbolize) {
-    return new(symbolizer_allocator_) POSIXSymbolizer(0, 0, 0);
+    return nullptr;
   }
-  InternalSymbolizer* internal_symbolizer =
-      InternalSymbolizer::get(&symbolizer_allocator_);
-  SymbolizerTool *external_symbolizer = 0;
-  LibbacktraceSymbolizer *libbacktrace_symbolizer = 0;
-
-  if (!internal_symbolizer) {
-    libbacktrace_symbolizer =
-        LibbacktraceSymbolizer::get(&symbolizer_allocator_);
-    if (!libbacktrace_symbolizer) {
-      const char *path_to_external = common_flags()->external_symbolizer_path;
-      if (path_to_external && path_to_external[0] == '\0') {
-        // External symbolizer is explicitly disabled. Do nothing.
-      } else {
-        // Find path to llvm-symbolizer if it's not provided.
-        if (!path_to_external)
-          path_to_external = FindPathToBinary("llvm-symbolizer");
-        if (path_to_external) {
-          external_symbolizer = new(symbolizer_allocator_)
-              LLVMSymbolizer(path_to_external, &symbolizer_allocator_);
-        } else if (common_flags()->allow_addr2line) {
-          // If llvm-symbolizer is not found, try to use addr2line.
-          if (const char *addr2line_path = FindPathToBinary("addr2line")) {
-            external_symbolizer = new(symbolizer_allocator_)
-                Addr2LinePool(addr2line_path, &symbolizer_allocator_);
-          }
-        }
-      }
+  if (SymbolizerTool *tool = InternalSymbolizer::get(allocator)) {
+    return tool;
+  }
+  if (SymbolizerTool *tool = LibbacktraceSymbolizer::get(allocator)) {
+    return tool;
+  }
+  const char *path_to_external = common_flags()->external_symbolizer_path;
+  if (path_to_external && path_to_external[0] == '\0') {
+    return nullptr;
+  }
+  // Find path to llvm-symbolizer if it's not provided.
+  if (!path_to_external) {
+    path_to_external = FindPathToBinary("llvm-symbolizer");
+  }
+  if (path_to_external) {
+    return new(*allocator) LLVMSymbolizer(path_to_external, allocator);
+  }
+  if (common_flags()->allow_addr2line) {
+    // If llvm-symbolizer is not found, try to use addr2line.
+    if (const char *addr2line_path = FindPathToBinary("addr2line")) {
+      return new(*allocator) Addr2LinePool(addr2line_path, allocator);
     }
   }
+  return nullptr;
+}
 
-  return new(symbolizer_allocator_) POSIXSymbolizer(
-      external_symbolizer, internal_symbolizer, libbacktrace_symbolizer);
+Symbolizer *Symbolizer::PlatformInit() {
+  return new(symbolizer_allocator_)
+      POSIXSymbolizer(ChooseSymbolizer(&symbolizer_allocator_));
 }
 
 }  // namespace __sanitizer