mirror of
https://github.com/tomahawk-player/tomahawk.git
synced 2025-08-09 15:47:38 +02:00
Update breakpad to make it work with MinGW
This commit is contained in:
Dominik Schmidt
234
thirdparty/breakpad/processor/stackwalker.cc
vendored
234
thirdparty/breakpad/processor/stackwalker.cc
vendored
@@ -37,48 +37,93 @@
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "common/scoped_ptr.h"
|
||||
#include "google_breakpad/processor/call_stack.h"
|
||||
#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"
|
||||
#include "processor/scoped_ptr.h"
|
||||
#include "processor/stackwalker_ppc.h"
|
||||
#include "processor/stackwalker_ppc64.h"
|
||||
#include "processor/stackwalker_sparc.h"
|
||||
#include "processor/stackwalker_x86.h"
|
||||
#include "processor/stackwalker_amd64.h"
|
||||
#include "processor/stackwalker_arm.h"
|
||||
#include "processor/stackwalker_arm64.h"
|
||||
#include "processor/stackwalker_mips.h"
|
||||
|
||||
namespace google_breakpad {
|
||||
|
||||
u_int32_t Stackwalker::max_frames_ = 1024;
|
||||
const int Stackwalker::kRASearchWords = 60;
|
||||
|
||||
Stackwalker::Stackwalker(const SystemInfo *system_info,
|
||||
MemoryRegion *memory,
|
||||
const CodeModules *modules,
|
||||
SymbolSupplier *supplier,
|
||||
SourceLineResolverInterface *resolver)
|
||||
uint32_t Stackwalker::max_frames_ = 1024;
|
||||
bool Stackwalker::max_frames_set_ = false;
|
||||
|
||||
uint32_t Stackwalker::max_frames_scanned_ = 1024;
|
||||
|
||||
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_);
|
||||
}
|
||||
|
||||
void InsertSpecialAttentionModule(
|
||||
StackFrameSymbolizer::SymbolizerResult symbolizer_result,
|
||||
const CodeModule* module,
|
||||
vector<const CodeModule*>* modules) {
|
||||
if (!module) {
|
||||
return;
|
||||
}
|
||||
assert(symbolizer_result == StackFrameSymbolizer::kError ||
|
||||
symbolizer_result == StackFrameSymbolizer::kWarningCorruptSymbols);
|
||||
bool found = false;
|
||||
vector<const CodeModule*>::iterator iter;
|
||||
for (iter = modules->begin(); iter != modules->end(); ++iter) {
|
||||
if (*iter == module) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
BPLOG(INFO) << ((symbolizer_result == StackFrameSymbolizer::kError) ?
|
||||
"Couldn't load symbols for: " :
|
||||
"Detected corrupt symbols for: ")
|
||||
<< module->debug_file() << "|" << module->debug_identifier();
|
||||
modules->push_back(module);
|
||||
}
|
||||
}
|
||||
|
||||
bool Stackwalker::Walk(CallStack *stack) {
|
||||
bool Stackwalker::Walk(
|
||||
CallStack* stack,
|
||||
vector<const CodeModule*>* modules_without_symbols,
|
||||
vector<const CodeModule*>* modules_with_corrupt_symbols) {
|
||||
BPLOG_IF(ERROR, !stack) << "Stackwalker::Walk requires |stack|";
|
||||
assert(stack);
|
||||
stack->Clear();
|
||||
|
||||
BPLOG_IF(ERROR, !modules_without_symbols) << "Stackwalker::Walk requires "
|
||||
<< "|modules_without_symbols|";
|
||||
BPLOG_IF(ERROR, !modules_without_symbols) << "Stackwalker::Walk requires "
|
||||
<< "|modules_with_corrupt_symbols|";
|
||||
assert(modules_without_symbols);
|
||||
assert(modules_with_corrupt_symbols);
|
||||
|
||||
// Begin with the context frame, and keep getting callers until there are
|
||||
// no more.
|
||||
|
||||
// Keep track of the number of scanned or otherwise dubious frames seen
|
||||
// so far, as the caller may have set a limit.
|
||||
uint32_t scanned_frames = 0;
|
||||
|
||||
// Take ownership of the pointer returned by GetContextFrame.
|
||||
scoped_ptr<StackFrame> frame(GetContextFrame());
|
||||
|
||||
@@ -88,54 +133,54 @@ 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);
|
||||
StackFrameSymbolizer::SymbolizerResult symbolizer_result =
|
||||
frame_symbolizer_->FillSourceLineInfo(modules_, system_info_,
|
||||
frame.get());
|
||||
switch (symbolizer_result) {
|
||||
case StackFrameSymbolizer::kInterrupt:
|
||||
BPLOG(INFO) << "Stack walk is interrupted.";
|
||||
return false;
|
||||
break;
|
||||
case StackFrameSymbolizer::kError:
|
||||
InsertSpecialAttentionModule(symbolizer_result, frame->module,
|
||||
modules_without_symbols);
|
||||
break;
|
||||
case StackFrameSymbolizer::kWarningCorruptSymbols:
|
||||
InsertSpecialAttentionModule(symbolizer_result, frame->module,
|
||||
modules_with_corrupt_symbols);
|
||||
break;
|
||||
case StackFrameSymbolizer::kNoError:
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
break;
|
||||
}
|
||||
|
||||
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());
|
||||
}
|
||||
// Keep track of the number of dubious frames so far.
|
||||
switch (frame.get()->trust) {
|
||||
case StackFrame::FRAME_TRUST_NONE:
|
||||
case StackFrame::FRAME_TRUST_SCAN:
|
||||
case StackFrame::FRAME_TRUST_CFI_SCAN:
|
||||
scanned_frames++;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
// Add the frame to the call stack. Relinquish the ownership claim
|
||||
// over the frame, because the stack now owns it.
|
||||
stack->frames_.push_back(frame.release());
|
||||
if (stack->frames_.size() > max_frames_) {
|
||||
BPLOG(ERROR) << "The stack is over " << max_frames_ << " frames.";
|
||||
// Only emit an error message in the case where the limit
|
||||
// reached is the default limit, not set by the user.
|
||||
if (!max_frames_set_)
|
||||
BPLOG(ERROR) << "The stack is over " << max_frames_ << " frames.";
|
||||
break;
|
||||
}
|
||||
|
||||
// Get the next frame and take ownership.
|
||||
frame.reset(GetCallerFrame(stack));
|
||||
bool stack_scan_allowed = scanned_frames < max_frames_scanned_;
|
||||
frame.reset(GetCallerFrame(stack, stack_scan_allowed));
|
||||
}
|
||||
|
||||
return true;
|
||||
@@ -144,57 +189,73 @@ 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();
|
||||
uint32_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_PPC64:
|
||||
cpu_stackwalker = new StackwalkerPPC64(system_info,
|
||||
context->GetContextPPC64(),
|
||||
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_MIPS:
|
||||
cpu_stackwalker = new StackwalkerMIPS(system_info,
|
||||
context->GetContextMIPS(),
|
||||
memory, modules, frame_symbolizer);
|
||||
break;
|
||||
|
||||
case MD_CONTEXT_ARM:
|
||||
{
|
||||
int fp_register = -1;
|
||||
if (system_info->os_short == "ios")
|
||||
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;
|
||||
}
|
||||
|
||||
case MD_CONTEXT_ARM64:
|
||||
cpu_stackwalker = new StackwalkerARM64(system_info,
|
||||
context->GetContextARM64(),
|
||||
memory, modules,
|
||||
frame_symbolizer);
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -204,39 +265,30 @@ Stackwalker* Stackwalker::StackwalkerForCPU(
|
||||
return cpu_stackwalker;
|
||||
}
|
||||
|
||||
bool Stackwalker::InstructionAddressSeemsValid(u_int64_t address) {
|
||||
const CodeModule *module = modules_->GetModuleForAddress(address);
|
||||
if (!module) {
|
||||
bool Stackwalker::InstructionAddressSeemsValid(uint64_t address) {
|
||||
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::kNoError &&
|
||||
symbolizer_result != StackFrameSymbolizer::kWarningCorruptSymbols) {
|
||||
// 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();
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user