[compiler-rt] r231162 - Symbolizer refactoring: Unify access to symbolizer tools from POSIXSymbolizer
Kuba Brecka
kuba.brecka at gmail.com
Tue Mar 3 15:13:02 PST 2015
Author: kuba.brecka
Date: Tue Mar 3 17:13:02 2015
New Revision: 231162
URL: http://llvm.org/viewvc/llvm-project?rev=231162&view=rev
Log:
Symbolizer refactoring: Unify access to symbolizer tools from POSIXSymbolizer
Reviewed at http://reviews.llvm.org/D8029
Modified:
compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_internal.h
compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc
Modified: compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_internal.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_internal.h?rev=231162&r1=231161&r2=231162&view=diff
==============================================================================
--- compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_internal.h (original)
+++ compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_internal.h Tue Mar 3 17:13:02 2015
@@ -46,8 +46,9 @@ class SymbolizerTool {
virtual void Flush() {}
+ // Return nullptr to fallback to the default __cxxabiv1 demangler.
virtual const char *Demangle(const char *name) {
- return name;
+ return nullptr;
}
};
Modified: compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc?rev=231162&r1=231161&r2=231162&view=diff
==============================================================================
--- compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc (original)
+++ compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc Tue Mar 3 17:13:02 2015
@@ -173,6 +173,7 @@ class LLVMSymbolizer : public Symbolizer
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 @@ class InternalSymbolizer : public Symbol
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 InternalSymbolizer : public Symbol
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 @@ class POSIXSymbolizer : public Symbolize
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 @@ class POSIXSymbolizer : public Symbolize
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 @@ class POSIXSymbolizer : public Symbolize
}
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 @@ class POSIXSymbolizer : public Symbolize
}
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,43 @@ class POSIXSymbolizer : public Symbolize
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') {
+ // External symbolizer is explicitly disabled. Do nothing.
+ 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
More information about the llvm-commits
mailing list