generic-library/breakpad
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactor the logic of resolving source line info into helper class.

Browse Source 
http://breakpad.appspot.com/459002/


git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@1068 4c0a9323-5329-0410-9bdc-e9ce6186880e
This commit is contained in:
SiyangXie@gmail.com
2012-10-10 21:41:52 +00:00
parent f72b9c6ff4
commit bab770045b
22 changed files with 813 additions and 926 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
src/processor/stackwalker.cc
View File

@@ -41,9 +41,8 @@
#include "google_breakpad/processor/code_module.h"
#include "google_breakpad/processor/code_modules.h"
#include "google_breakpad/processor/minidump.h"
#include "google_breakpad/processor/source_line_resolver_interface.h"
#include "google_breakpad/processor/stack_frame.h"
#include "google_breakpad/processor/symbol_supplier.h"
#include "google_breakpad/processor/stack_frame_symbolizer.h"
#include "google_breakpad/processor/system_info.h"
#include "processor/linked_ptr.h"
#include "processor/logging.h"
@@ -58,20 +57,19 @@ namespace google_breakpad {
u_int32_t Stackwalker::max_frames_ = 1024;
Stackwalker::Stackwalker(const SystemInfo *system_info,
MemoryRegion *memory,
const CodeModules *modules,
SymbolSupplier *supplier,
SourceLineResolverInterface *resolver)
Stackwalker::Stackwalker(const SystemInfo* system_info,
MemoryRegion* memory,
const CodeModules* modules,
StackFrameSymbolizer* frame_symbolizer)
: system_info_(system_info),
memory_(memory),
modules_(modules),
resolver_(resolver),
supplier_(supplier) {
frame_symbolizer_(frame_symbolizer) {
assert(frame_symbolizer_);
}
bool Stackwalker::Walk(CallStack *stack) {
bool Stackwalker::Walk(CallStack* stack) {
BPLOG_IF(ERROR, !stack) << "Stackwalker::Walk requires |stack|";
assert(stack);
stack->Clear();
@@ -88,42 +86,12 @@ bool Stackwalker::Walk(CallStack *stack) {
// context frame (above) or a caller frame (below).
// Resolve the module information, if a module map was provided.
if (modules_) {
const CodeModule *module =
modules_->GetModuleForAddress(frame->instruction);
if (module) {
frame->module = module;
if (resolver_ &&
!resolver_->HasModule(frame->module) &&
no_symbol_modules_.find(
module->code_file()) == no_symbol_modules_.end() &&
supplier_) {
string symbol_file;
char *symbol_data = NULL;
SymbolSupplier::SymbolResult symbol_result =
supplier_->GetCStringSymbolData(module,
system_info_,
&symbol_file,
&symbol_data);
switch (symbol_result) {
case SymbolSupplier::FOUND:
resolver_->LoadModuleUsingMemoryBuffer(frame->module,
symbol_data);
break;
case SymbolSupplier::NOT_FOUND:
no_symbol_modules_.insert(module->code_file());
break; // nothing to do
case SymbolSupplier::INTERRUPT:
return false;
}
// Inform symbol supplier to free the unused data memory buffer.
if (resolver_->ShouldDeleteMemoryBufferAfterLoadModule())
supplier_->FreeSymbolData(module);
}
if (resolver_)
resolver_->FillSourceLineInfo(frame.get());
}
StackFrameSymbolizer::SymbolizerResult symbolizer_result =
frame_symbolizer_->FillSourceLineInfo(modules_, system_info_,
frame.get());
if (symbolizer_result == StackFrameSymbolizer::INTERRUPT) {
BPLOG(INFO) << "Stack walk is interrupted.";
return false;
}
// Add the frame to the call stack. Relinquish the ownership claim
@@ -144,47 +112,42 @@ bool Stackwalker::Walk(CallStack *stack) {
// static
Stackwalker* Stackwalker::StackwalkerForCPU(
const SystemInfo *system_info,
MinidumpContext *context,
MemoryRegion *memory,
const CodeModules *modules,
SymbolSupplier *supplier,
SourceLineResolverInterface *resolver) {
const SystemInfo* system_info,
MinidumpContext* context,
MemoryRegion* memory,
const CodeModules* modules,
StackFrameSymbolizer* frame_symbolizer) {
if (!context) {
BPLOG(ERROR) << "Can't choose a stackwalker implementation without context";
return NULL;
}
Stackwalker *cpu_stackwalker = NULL;
Stackwalker* cpu_stackwalker = NULL;
u_int32_t cpu = context->GetContextCPU();
switch (cpu) {
case MD_CONTEXT_X86:
cpu_stackwalker = new StackwalkerX86(system_info,
context->GetContextX86(),
memory, modules, supplier,
resolver);
memory, modules, frame_symbolizer);
break;
case MD_CONTEXT_PPC:
cpu_stackwalker = new StackwalkerPPC(system_info,
context->GetContextPPC(),
memory, modules, supplier,
resolver);
memory, modules, frame_symbolizer);
break;
case MD_CONTEXT_AMD64:
cpu_stackwalker = new StackwalkerAMD64(system_info,
context->GetContextAMD64(),
memory, modules, supplier,
resolver);
memory, modules, frame_symbolizer);
break;
case MD_CONTEXT_SPARC:
cpu_stackwalker = new StackwalkerSPARC(system_info,
context->GetContextSPARC(),
memory, modules, supplier,
resolver);
memory, modules, frame_symbolizer);
break;
case MD_CONTEXT_ARM:
@@ -193,8 +156,8 @@ Stackwalker* Stackwalker::StackwalkerForCPU(
fp_register = MD_CONTEXT_ARM_REG_IOS_FP;
cpu_stackwalker = new StackwalkerARM(system_info,
context->GetContextARM(),
fp_register, memory, modules,
supplier, resolver);
fp_register, memory, modules,
frame_symbolizer);
break;
}
@@ -205,38 +168,28 @@ Stackwalker* Stackwalker::StackwalkerForCPU(
}
bool Stackwalker::InstructionAddressSeemsValid(u_int64_t address) {
const CodeModule *module = modules_->GetModuleForAddress(address);
if (!module) {
StackFrame frame;
frame.instruction = address;
StackFrameSymbolizer::SymbolizerResult symbolizer_result =
frame_symbolizer_->FillSourceLineInfo(modules_, system_info_, &frame);
if (!frame.module) {
// not inside any loaded module
return false;
}
if (!resolver_ || !supplier_) {
// we don't have a resolver and or symbol supplier,
// but we're inside a known module
if (!frame_symbolizer_->HasImplementation()) {
// No valid implementation to symbolize stack frame, but the address is
// within a known module.
return true;
}
if (!resolver_->HasModule(module)) {
string symbol_file;
char *symbol_data = NULL;
SymbolSupplier::SymbolResult symbol_result =
supplier_->GetCStringSymbolData(module, system_info_,
&symbol_file, &symbol_data);
if (symbol_result != SymbolSupplier::FOUND ||
!resolver_->LoadModuleUsingMemoryBuffer(module,
symbol_data)) {
// we don't have symbols, but we're inside a loaded module
return true;
}
if (symbolizer_result != StackFrameSymbolizer::NO_ERROR) {
// Some error occurred during symbolization, but the address is within a
// known module
return true;
}
StackFrame frame;
frame.module = module;
frame.instruction = address;
resolver_->FillSourceLineInfo(&frame);
// we have symbols, so return true if inside a function
return !frame.function_name.empty();
}