SwitchEmu/breakpad
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/breakpad.git synced 2026-03-04 03:52:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Adding support for mips.

Browse Source 
Support for mips cpu is added to all breakapad targets including unittests.

BUG=none
TEST=unittests

Review URL: https://breakpad.appspot.com/614002



git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@1212 4c0a9323-5329-0410-9bdc-e9ce6186880e
This commit is contained in:
gordana.cmiljanovic@imgtec.com
2013-09-11 11:37:04 +00:00
parent ae35566b8d
commit f78839c157
31 changed files with 2095 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
src/processor/minidump.cc
View File

@@ -844,6 +844,71 @@ bool MinidumpContext::Read(uint32_t expected_size) {
break;
}
case MD_CONTEXT_MIPS: {
if (expected_size != sizeof(MDRawContextMIPS)) {
BPLOG(ERROR) << "MinidumpContext MIPS size mismatch, "
<< expected_size
<< " != "
<< sizeof(MDRawContextMIPS);
return false;
}
scoped_ptr<MDRawContextMIPS> context_mips(new MDRawContextMIPS());
// Set the context_flags member, which has already been read, and
// read the rest of the structure beginning with the first member
// after context_flags.
context_mips->context_flags = context_flags;
size_t flags_size = sizeof(context_mips->context_flags);
uint8_t* context_after_flags =
reinterpret_cast<uint8_t*>(context_mips.get()) + flags_size;
if (!minidump_->ReadBytes(context_after_flags,
sizeof(MDRawContextMIPS) - flags_size)) {
BPLOG(ERROR) << "MinidumpContext could not read MIPS context";
return false;
}
// Do this after reading the entire MDRawContext structure because
// GetSystemInfo may seek minidump to a new position.
if (!CheckAgainstSystemInfo(cpu_type)) {
BPLOG(ERROR) << "MinidumpContext MIPS does not match system info";
return false;
}
if (minidump_->swap()) {
// context_mips->context_flags was already swapped.
for (int ireg_index = 0;
ireg_index < MD_CONTEXT_MIPS_GPR_COUNT;
++ireg_index) {
Swap(&context_mips->iregs[ireg_index]);
}
Swap(&context_mips->mdhi);
Swap(&context_mips->mdlo);
for (int dsp_index = 0;
dsp_index < MD_CONTEXT_MIPS_DSP_COUNT;
++dsp_index) {
Swap(&context_mips->hi[dsp_index]);
Swap(&context_mips->lo[dsp_index]);
}
Swap(&context_mips->dsp_control);
Swap(&context_mips->epc);
Swap(&context_mips->badvaddr);
Swap(&context_mips->status);
Swap(&context_mips->cause);
for (int fpr_index = 0;
fpr_index < MD_FLOATINGSAVEAREA_MIPS_FPR_COUNT;
++fpr_index) {
Swap(&context_mips->float_save.regs[fpr_index]);
}
Swap(&context_mips->float_save.fpcsr);
Swap(&context_mips->float_save.fir);
}
context_.ctx_mips = context_mips.release();
break;
}
default: {
// Unknown context type - Don't log as an error yet. Let the
// caller work that out.
@@ -901,6 +966,9 @@ bool MinidumpContext::GetInstructionPointer(uint64_t* ip) const {
case MD_CONTEXT_X86:
*ip = context_.x86->eip;
break;
case MD_CONTEXT_MIPS:
*ip = context_.ctx_mips->epc;
break;
default:
// This should never happen.
BPLOG(ERROR) << "Unknown CPU architecture in GetInstructionPointer";
@@ -965,6 +1033,15 @@ const MDRawContextARM* MinidumpContext::GetContextARM() const {
return context_.arm;
}
const MDRawContextMIPS* MinidumpContext::GetContextMIPS() const {
if (GetContextCPU() != MD_CONTEXT_MIPS) {
BPLOG(ERROR) << "MinidumpContext cannot get MIPS context";
return NULL;
}
return context_.ctx_mips;
}
void MinidumpContext::FreeContext() {
switch (GetContextCPU()) {
case MD_CONTEXT_X86:
@@ -991,6 +1068,10 @@ void MinidumpContext::FreeContext() {
delete context_.arm;
break;
case MD_CONTEXT_MIPS:
delete context_.ctx_mips;
break;
default:
// There is no context record (valid_ is false) or there's a
// context record for an unknown CPU (shouldn't happen, only known
@@ -1060,6 +1141,11 @@ bool MinidumpContext::CheckAgainstSystemInfo(uint32_t context_cpu_type) {
if (system_info_cpu_type == MD_CPU_ARCHITECTURE_ARM)
return_value = true;
break;
case MD_CONTEXT_MIPS:
if (system_info_cpu_type == MD_CPU_ARCHITECTURE_MIPS)
return_value = true;
break;
}
BPLOG_IF(ERROR, !return_value) << "MinidumpContext CPU " <<
@@ -1338,6 +1424,53 @@ void MinidumpContext::Print() {
break;
}
case MD_CONTEXT_MIPS: {
const MDRawContextMIPS* context_mips = GetContextMIPS();
printf("MDRawContextMIPS\n");
printf(" context_flags = 0x%x\n",
context_mips->context_flags);
for (int ireg_index = 0;
ireg_index < MD_CONTEXT_MIPS_GPR_COUNT;
++ireg_index) {
printf(" iregs[%2d] = 0x%" PRIx64 "\n",
ireg_index, context_mips->iregs[ireg_index]);
}
printf(" mdhi = 0x%" PRIx64 "\n",
context_mips->mdhi);
printf(" mdlo = 0x%" PRIx64 "\n",
context_mips->mdhi);
for (int dsp_index = 0;
dsp_index < MD_CONTEXT_MIPS_DSP_COUNT;
++dsp_index) {
printf(" hi[%1d] = 0x%" PRIx32 "\n",
dsp_index, context_mips->hi[dsp_index]);
printf(" lo[%1d] = 0x%" PRIx32 "\n",
dsp_index, context_mips->lo[dsp_index]);
}
printf(" dsp_control = 0x%" PRIx32 "\n",
context_mips->dsp_control);
printf(" epc = 0x%" PRIx64 "\n",
context_mips->epc);
printf(" badvaddr = 0x%" PRIx64 "\n",
context_mips->badvaddr);
printf(" status = 0x%" PRIx32 "\n",
context_mips->status);
printf(" cause = 0x%" PRIx32 "\n",
context_mips->cause);
for (int fpr_index = 0;
fpr_index < MD_FLOATINGSAVEAREA_MIPS_FPR_COUNT;
++fpr_index) {
printf(" float_save.regs[%2d] = 0x%" PRIx64 "\n",
fpr_index, context_mips->float_save.regs[fpr_index]);
}
printf(" float_save.fpcsr = 0x%" PRIx32 "\n",
context_mips->float_save.fpcsr);
printf(" float_save.fir = 0x%" PRIx32 "\n",
context_mips->float_save.fir);
break;
}
default: {
break;
}

5
src/processor/minidump_processor.cc
View File

@@ -505,6 +505,11 @@ bool MinidumpProcessor::GetCPUInfo(Minidump *dump, SystemInfo *info) {
break;
}
case MD_CPU_ARCHITECTURE_MIPS: {
info->cpu = "mips";
break;
}
default: {
// Assign the numeric architecture ID into the CPU string.
char cpu_string[7];

59
src/processor/minidump_stackwalk.cc
View File

@@ -72,6 +72,7 @@ using google_breakpad::StackFrameSPARC;
using google_breakpad::StackFrameX86;
using google_breakpad::StackFrameAMD64;
using google_breakpad::StackFrameARM;
using google_breakpad::StackFrameMIPS;
// Separator character for machine readable output.
static const char kOutputSeparator = '|';
@@ -271,7 +272,63 @@ static void PrintStack(const CallStack *stack, const string &cpu) {
sequence = PrintRegister("lr", frame_arm->context.iregs[14], sequence);
if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_PC)
sequence = PrintRegister("pc", frame_arm->context.iregs[15], sequence);
}
} else if (cpu == "mips") {
const StackFrameMIPS* frame_mips =
reinterpret_cast<const StackFrameMIPS*>(frame);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_GP)
sequence = PrintRegister64("gp",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_GP],
sequence);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_SP)
sequence = PrintRegister64("sp",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_SP],
sequence);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_FP)
sequence = PrintRegister64("fp",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_FP],
sequence);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_RA)
sequence = PrintRegister64("ra",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_RA],
sequence);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_PC)
sequence = PrintRegister64("pc", frame_mips->context.epc, sequence);
// Save registers s0-s7
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S0)
sequence = PrintRegister64("s0",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S0],
sequence);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S1)
sequence = PrintRegister64("s1",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S1],
sequence);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S2)
sequence = PrintRegister64("s2",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S2],
sequence);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S3)
sequence = PrintRegister64("s3",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S3],
sequence);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S4)
sequence = PrintRegister64("s4",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S4],
sequence);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S5)
sequence = PrintRegister64("s5",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S5],
sequence);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S6)
sequence = PrintRegister64("s6",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S6],
sequence);
if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S7)
sequence = PrintRegister64("s7",
frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S7],
sequence);
}
printf("\n Found by: %s\n", frame->trust_description().c_str());
}
}

113
src/processor/minidump_unittest.cc
View File

@@ -1150,4 +1150,117 @@ TEST(Dump, OneExceptionARMOldFlags) {
EXPECT_EQ(0x2e951ef7U, raw_context.cpsr);
}
TEST(Dump, OneExceptionMIPS) {
Dump dump(0, kLittleEndian);
MDRawContextMIPS raw_context;
raw_context.context_flags = MD_CONTEXT_MIPS_INTEGER;
raw_context.iregs[0] = 0x3ecba80d;
raw_context.iregs[1] = 0x382583b9;
raw_context.iregs[2] = 0x7fccc03f;
raw_context.iregs[3] = 0xf62f8ec2;
raw_context.iregs[4] = 0x46a6a6a8;
raw_context.iregs[5] = 0x6a5025e2;
raw_context.iregs[6] = 0xd9fabb4a;
raw_context.iregs[7] = 0x6913f540;
raw_context.iregs[8] = 0xbffe6eda;
raw_context.iregs[9] = 0xb2ce1e2d;
raw_context.iregs[10] = 0x659caaa4;
raw_context.iregs[11] = 0xf0e0d0c0;
raw_context.iregs[12] = 0xa9b8c7d6;
raw_context.iregs[13] = 0x12345678;
raw_context.iregs[14] = 0xabcd1234;
raw_context.iregs[15] = 0x10203040;
raw_context.iregs[16] = 0xa80d3ecb;
raw_context.iregs[17] = 0x83b93825;
raw_context.iregs[18] = 0xc03f7fcc;
raw_context.iregs[19] = 0x8ec2f62f;
raw_context.iregs[20] = 0xa6a846a6;
raw_context.iregs[21] = 0x25e26a50;
raw_context.iregs[22] = 0xbb4ad9fa;
raw_context.iregs[23] = 0xf5406913;
raw_context.iregs[24] = 0x6edabffe;
raw_context.iregs[25] = 0x1e2db2ce;
raw_context.iregs[26] = 0xaaa4659c;
raw_context.iregs[27] = 0xd0c0f0e0;
raw_context.iregs[28] = 0xc7d6a9b8;
raw_context.iregs[29] = 0x56781234;
raw_context.iregs[30] = 0x1234abcd;
raw_context.iregs[31] = 0x30401020;
Context context(dump, raw_context);
Exception exception(dump, context,
0x1234abcd, // Thread id.
0xdcba4321, // Exception code.
0xf0e0d0c0, // Exception flags.
0x0919a9b9); // Exception address.
dump.Add(&context);
dump.Add(&exception);
dump.Finish();
string contents;
ASSERT_TRUE(dump.GetContents(&contents));
istringstream minidump_stream(contents);
Minidump minidump(minidump_stream);
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(1U, minidump.GetDirectoryEntryCount());
MinidumpException *md_exception = minidump.GetException();
ASSERT_TRUE(md_exception != NULL);
uint32_t thread_id;
ASSERT_TRUE(md_exception->GetThreadID(&thread_id));
ASSERT_EQ(0x1234abcdU, thread_id);
const MDRawExceptionStream* raw_exception = md_exception->exception();
ASSERT_TRUE(raw_exception != NULL);
EXPECT_EQ(0xdcba4321, raw_exception->exception_record.exception_code);
EXPECT_EQ(0xf0e0d0c0, raw_exception->exception_record.exception_flags);
EXPECT_EQ(0x0919a9b9U,
raw_exception->exception_record.exception_address);
MinidumpContext* md_context = md_exception->GetContext();
ASSERT_TRUE(md_context != NULL);
ASSERT_EQ((uint32_t) MD_CONTEXT_MIPS, md_context->GetContextCPU());
const MDRawContextMIPS* md_raw_context = md_context->GetContextMIPS();
ASSERT_TRUE(md_raw_context != NULL);
ASSERT_EQ((uint32_t) MD_CONTEXT_MIPS_INTEGER,
(md_raw_context->context_flags & MD_CONTEXT_MIPS_INTEGER));
EXPECT_EQ(0x3ecba80dU, raw_context.iregs[0]);
EXPECT_EQ(0x382583b9U, raw_context.iregs[1]);
EXPECT_EQ(0x7fccc03fU, raw_context.iregs[2]);
EXPECT_EQ(0xf62f8ec2U, raw_context.iregs[3]);
EXPECT_EQ(0x46a6a6a8U, raw_context.iregs[4]);
EXPECT_EQ(0x6a5025e2U, raw_context.iregs[5]);
EXPECT_EQ(0xd9fabb4aU, raw_context.iregs[6]);
EXPECT_EQ(0x6913f540U, raw_context.iregs[7]);
EXPECT_EQ(0xbffe6edaU, raw_context.iregs[8]);
EXPECT_EQ(0xb2ce1e2dU, raw_context.iregs[9]);
EXPECT_EQ(0x659caaa4U, raw_context.iregs[10]);
EXPECT_EQ(0xf0e0d0c0U, raw_context.iregs[11]);
EXPECT_EQ(0xa9b8c7d6U, raw_context.iregs[12]);
EXPECT_EQ(0x12345678U, raw_context.iregs[13]);
EXPECT_EQ(0xabcd1234U, raw_context.iregs[14]);
EXPECT_EQ(0x10203040U, raw_context.iregs[15]);
EXPECT_EQ(0xa80d3ecbU, raw_context.iregs[16]);
EXPECT_EQ(0x83b93825U, raw_context.iregs[17]);
EXPECT_EQ(0xc03f7fccU, raw_context.iregs[18]);
EXPECT_EQ(0x8ec2f62fU, raw_context.iregs[19]);
EXPECT_EQ(0xa6a846a6U, raw_context.iregs[20]);
EXPECT_EQ(0x25e26a50U, raw_context.iregs[21]);
EXPECT_EQ(0xbb4ad9faU, raw_context.iregs[22]);
EXPECT_EQ(0xf5406913U, raw_context.iregs[23]);
EXPECT_EQ(0x6edabffeU, raw_context.iregs[24]);
EXPECT_EQ(0x1e2db2ceU, raw_context.iregs[25]);
EXPECT_EQ(0xaaa4659cU, raw_context.iregs[26]);
EXPECT_EQ(0xd0c0f0e0U, raw_context.iregs[27]);
EXPECT_EQ(0xc7d6a9b8U, raw_context.iregs[28]);
EXPECT_EQ(0x56781234U, raw_context.iregs[29]);
EXPECT_EQ(0x1234abcdU, raw_context.iregs[30]);
EXPECT_EQ(0x30401020U, raw_context.iregs[31]);
}
} // namespace

7
src/processor/stackwalker.cc
View File

@@ -53,6 +53,7 @@
#include "processor/stackwalker_x86.h"
#include "processor/stackwalker_amd64.h"
#include "processor/stackwalker_arm.h"
#include "processor/stackwalker_mips.h"
namespace google_breakpad {
@@ -230,6 +231,12 @@ Stackwalker* Stackwalker::StackwalkerForCPU(
context->GetContextSPARC(),
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;

300
src/processor/stackwalker_mips.cc Normal file
View File

@@ -0,0 +1,300 @@
// Copyright (c) 2013 Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// stackwalker_mips.cc: MIPS-specific stackwalker.
//
// See stackwalker_mips.h for documentation.
//
// Author: Tata Elxsi
#include "common/scoped_ptr.h"
#include "google_breakpad/processor/call_stack.h"
#include "google_breakpad/processor/code_modules.h"
#include "google_breakpad/processor/memory_region.h"
#include "google_breakpad/processor/source_line_resolver_interface.h"
#include "google_breakpad/processor/stack_frame_cpu.h"
#include "processor/cfi_frame_info.h"
#include "processor/logging.h"
#include "processor/postfix_evaluator-inl.h"
#include "processor/stackwalker_mips.h"
#include "processor/windows_frame_info.h"
#include "google_breakpad/common/minidump_cpu_mips.h"
namespace google_breakpad {
StackwalkerMIPS::StackwalkerMIPS(const SystemInfo* system_info,
const MDRawContextMIPS* context,
MemoryRegion* memory,
const CodeModules* modules,
StackFrameSymbolizer* resolver_helper)
: Stackwalker(system_info, memory, modules, resolver_helper),
context_(context) {
if (memory_ && memory_->GetBase() + memory_->GetSize() - 1 > 0xffffffff) {
BPLOG(ERROR) << "Memory out of range for stackwalking: "
<< HexString(memory_->GetBase())
<< "+"
<< HexString(memory_->GetSize());
memory_ = NULL;
}
}
StackFrame* StackwalkerMIPS::GetContextFrame() {
if (!context_) {
BPLOG(ERROR) << "Can't get context frame without context.";
return NULL;
}
StackFrameMIPS* frame = new StackFrameMIPS();
// The instruction pointer is stored directly in a register, so pull it
// straight out of the CPU context structure.
frame->context = *context_;
frame->context_validity = StackFrameMIPS::CONTEXT_VALID_ALL;
frame->trust = StackFrame::FRAME_TRUST_CONTEXT;
frame->instruction = frame->context.epc;
return frame;
}
// Register names for mips.
static const char* const kRegisterNames[] = {
"$zero", "$at", "$v0", "$v1", "$a0", "$a1", "$a2", "$a3", "$to", "$t1",
"$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$s0", "$s1", "$s2", "$s3",
"$s4", "$s5", "$s6", "$s7", "$t8", "$t9", "$k0", "$k1", "$gp", "$sp",
"$fp", "$ra", NULL
// TODO(gordanac): add float point save registers
};
StackFrameMIPS* StackwalkerMIPS::GetCallerByCFIFrameInfo(
const vector<StackFrame*>& frames,
CFIFrameInfo* cfi_frame_info) {
StackFrameMIPS* last_frame = static_cast<StackFrameMIPS*>(frames.back());
unsigned long sp = 0, pc = 0;
// Populate a dictionary with the valid register values in last_frame.
CFIFrameInfo::RegisterValueMap<uint32_t> callee_registers;
// Use the STACK CFI data to recover the caller's register values.
CFIFrameInfo::RegisterValueMap<uint32_t> caller_registers;
for (int i = 0; kRegisterNames[i]; ++i) {
caller_registers[kRegisterNames[i]] = last_frame->context.iregs[i];
callee_registers[kRegisterNames[i]] = last_frame->context.iregs[i];
}
if (!cfi_frame_info->FindCallerRegs(callee_registers, *memory_,
&caller_registers)) {
return NULL;
}
CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator entry =
caller_registers.find(".cfa");
if (entry != caller_registers.end()) {
sp = entry->second;
caller_registers["$sp"] = entry->second;
}
entry = caller_registers.find(".ra");
if (entry != caller_registers.end()) {
caller_registers["$ra"] = entry->second;
pc = entry->second - 2 * sizeof(pc);
}
caller_registers["$pc"] = pc;
// Construct a new stack frame given the values the CFI recovered.
scoped_ptr<StackFrameMIPS> frame(new StackFrameMIPS());
for (int i = 0; kRegisterNames[i]; ++i) {
CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator caller_entry =
caller_registers.find(kRegisterNames[i]);
if (caller_entry != caller_registers.end()) {
// The value of this register is recovered; fill the context with the
// value from caller_registers.
frame->context.iregs[i] = caller_entry->second;
frame->context_validity |= StackFrameMIPS::RegisterValidFlag(i);
} else if ((i >= INDEX_MIPS_REG_S0 && i <= INDEX_MIPS_REG_S7 ||
i > INDEX_MIPS_REG_GP && i < INDEX_MIPS_REG_RA) &&
(last_frame->context_validity &
StackFrameMIPS::RegisterValidFlag(i))) {
// If the STACK CFI data doesn't mention some callee-save register, and
// it is valid in the callee, assume the callee has not yet changed it.
// Calee-save registers according to the MIPS o32 ABI specification are:
// $s0 to $s7
// $sp, $s8
frame->context.iregs[i] = last_frame->context.iregs[i];
frame->context_validity |= StackFrameMIPS::RegisterValidFlag(i);
}
}
frame->context.epc = caller_registers["$pc"];
frame->instruction = caller_registers["$pc"];
frame->context_validity |= StackFrameMIPS::CONTEXT_VALID_PC;
frame->context.iregs[MD_CONTEXT_MIPS_REG_RA] = caller_registers["$ra"];
frame->context_validity |= StackFrameMIPS::CONTEXT_VALID_RA;
frame->trust = StackFrame::FRAME_TRUST_CFI;
return frame.release();
}
StackFrame* StackwalkerMIPS::GetCallerFrame(const CallStack* stack,
bool stack_scan_allowed) {
if (!memory_ || !stack) {
BPLOG(ERROR) << "Can't get caller frame without memory or stack";
return NULL;
}
const vector<StackFrame*>& frames = *stack->frames();
StackFrameMIPS* last_frame = static_cast<StackFrameMIPS*>(frames.back());
scoped_ptr<StackFrameMIPS> new_frame;
// See if there is DWARF call frame information covering this address.
scoped_ptr<CFIFrameInfo> cfi_frame_info(
frame_symbolizer_->FindCFIFrameInfo(last_frame));
if (cfi_frame_info.get())
new_frame.reset(GetCallerByCFIFrameInfo(frames, cfi_frame_info.get()));
// If caller frame is not found in CFI try analyzing the stack.
if (stack_scan_allowed && !new_frame.get()) {
new_frame.reset(GetCallerByStackScan(frames));
}
// If nothing worked, tell the caller.
if (!new_frame.get()) {
return NULL;
}
// Treat an instruction address of 0 as end-of-stack.
if (new_frame->context.epc == 0) {
return NULL;
}
// If the new stack pointer is at a lower address than the old, then
// that's clearly incorrect. Treat this as end-of-stack to enforce
// progress and avoid infinite loops.
if (new_frame->context.iregs[MD_CONTEXT_MIPS_REG_SP] <=
last_frame->context.iregs[MD_CONTEXT_MIPS_REG_SP]) {
return NULL;
}
return new_frame.release();
}
StackFrameMIPS* StackwalkerMIPS::GetCallerByStackScan(
const vector<StackFrame*>& frames) {
const uint32_t kMaxFrameStackSize = 1024;
const uint32_t kMinArgsOnStack = 4;
StackFrameMIPS* last_frame = static_cast<StackFrameMIPS*>(frames.back());
uint32_t last_sp = last_frame->context.iregs[MD_CONTEXT_MIPS_REG_SP];
uint32_t caller_pc, caller_sp, caller_fp;
// Return address cannot be obtained directly.
// Force stackwalking.
// We cannot use frame pointer to get the return address.
// We'll scan the stack for a
// return address. This can happen if last_frame is executing code
// for a module for which we don't have symbols.
int count = kMaxFrameStackSize / sizeof(caller_pc);
if (frames.size() > 1) {
// In case of mips32 ABI stack frame of a nonleaf function
// must have minimum stack frame assigned for 4 arguments (4 words).
// Move stack pointer for 4 words to avoid reporting non-existing frames
// for all frames except the topmost one.
// There is no way of knowing if topmost frame belongs to a leaf or
// a nonleaf function.
last_sp += kMinArgsOnStack * sizeof(caller_pc);
// Adjust 'count' so that return address is scanned only in limits
// of one stack frame.
count -= kMinArgsOnStack;
}
do {
// Scanning for return address from stack pointer of the last frame.
if (!ScanForReturnAddress(last_sp, &caller_sp, &caller_pc, count)) {
// If we can't find an instruction pointer even with stack scanning,
// give up.
BPLOG(ERROR) << " ScanForReturnAddress failed ";
return NULL;
}
// Get $fp stored in the stack frame.
if (!memory_->GetMemoryAtAddress(caller_sp - sizeof(caller_pc),
&caller_fp)) {
BPLOG(INFO) << " GetMemoryAtAddress for fp failed " ;
return NULL;
}
count = count - (caller_sp - last_sp) / sizeof(caller_pc);
// Now scan the next address in the stack.
last_sp = caller_sp + sizeof(caller_pc);
} while ((caller_fp - caller_sp >= kMaxFrameStackSize) && count > 0);
if (!count) {
BPLOG(INFO) << " No frame found " ;
return NULL;
}
// ScanForReturnAddress found a reasonable return address. Advance
// $sp to the location above the one where the return address was
// found.
caller_sp += sizeof(caller_pc);
// caller_pc is actually containing $ra value;
// $pc is two instructions before $ra,
// so the caller_pc needs to be decremented accordingly.
caller_pc -= 2 * sizeof(caller_pc);
// Create a new stack frame (ownership will be transferred to the caller)
// and fill it in.
StackFrameMIPS* frame = new StackFrameMIPS();
frame->trust = StackFrame::FRAME_TRUST_SCAN;
frame->context = last_frame->context;
frame->context.epc = caller_pc;
frame->context_validity |= StackFrameMIPS::CONTEXT_VALID_PC;
frame->instruction = caller_pc;
frame->context.iregs[MD_CONTEXT_MIPS_REG_SP] = caller_sp;
frame->context_validity |= StackFrameMIPS::CONTEXT_VALID_SP;
frame->context.iregs[MD_CONTEXT_MIPS_REG_FP] = caller_fp;
frame->context_validity |= StackFrameMIPS::CONTEXT_VALID_FP;
frame->context.iregs[MD_CONTEXT_MIPS_REG_RA] =
caller_pc + 2 * sizeof(caller_pc);
frame->context_validity |= StackFrameMIPS::CONTEXT_VALID_RA;
return frame;
}
} // namespace google_breakpad

85
src/processor/stackwalker_mips.h Normal file
View File

@@ -0,0 +1,85 @@
// Copyright (c) 2013 Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// stackwalker_mips.h: MIPS-specific stackwalker.
//
// Provides stack frames given MIPS register context and a memory region
// corresponding to a MIPSstack.
//
// Author: Tata Elxsi
#ifndef PROCESSOR_STACKWALKER_MIPS_H__
#define PROCESSOR_STACKWALKER_MIPS_H__
#include "google_breakpad/common/breakpad_types.h"
#include "google_breakpad/common/minidump_format.h"
#include "google_breakpad/processor/stackwalker.h"
#include "google_breakpad/processor/stack_frame_cpu.h"
#include "processor/cfi_frame_info.h"
namespace google_breakpad {
class CodeModules;
class StackwalkerMIPS : public Stackwalker {
public:
// Context is a MIPS context object that gives access to mips-specific
// register state corresponding to the innermost called frame to be
// included in the stack. The other arguments are passed directly
// through to the base Stackwalker constructor.
StackwalkerMIPS(const SystemInfo* system_info,
const MDRawContextMIPS* context,
MemoryRegion* memory,
const CodeModules* modules,
StackFrameSymbolizer* frame_symbolizer);
private:
// Implementation of Stackwalker, using mips context and stack conventions.
virtual StackFrame* GetContextFrame();
virtual StackFrame* GetCallerFrame(const CallStack* stack,
bool stack_scan_allowed);
// Use cfi_frame_info (derived from STACK CFI records) to construct
// the frame that called frames.back(). The caller takes ownership
// of the returned frame. Return NULL on failure.
StackFrameMIPS* GetCallerByCFIFrameInfo(const vector<StackFrame*>& frames,
CFIFrameInfo* cfi_frame_info);
// Scan the stack for plausible return address and frame pointer pair.
// The caller takes ownership of the returned frame. Return NULL on failure.
StackFrameMIPS* GetCallerByStackScan(const vector<StackFrame*>& frames);
// Stores the CPU context corresponding to the innermost stack frame to
// be returned by GetContextFrame.
const MDRawContextMIPS* context_;
};
} // namespace google_breakpad
#endif // PROCESSOR_STACKWALKER_MIPS_H__

697
src/processor/stackwalker_mips_unittest.cc Normal file
View File

@@ -0,0 +1,697 @@
// Copyright (c) 2013, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Original author: Gordana Cmiljanovic <gordana.cmiljanovic@imgtec.com>
// stackwalker_mips_unittest.cc: Unit tests for StackwalkerMIPS class.
#include <string.h>
#include <string>
#include <vector>
#include "breakpad_googletest_includes.h"
#include "common/test_assembler.h"
#include "common/using_std_string.h"
#include "google_breakpad/common/minidump_format.h"
#include "google_breakpad/processor/basic_source_line_resolver.h"
#include "google_breakpad/processor/call_stack.h"
#include "google_breakpad/processor/code_module.h"
#include "google_breakpad/processor/source_line_resolver_interface.h"
#include "google_breakpad/processor/stack_frame_cpu.h"
#include "processor/stackwalker_unittest_utils.h"
#include "processor/stackwalker_mips.h"
#include "processor/windows_frame_info.h"
using google_breakpad::BasicSourceLineResolver;
using google_breakpad::CallStack;
using google_breakpad::CodeModule;
using google_breakpad::StackFrameSymbolizer;
using google_breakpad::StackFrame;
using google_breakpad::StackFrameMIPS;
using google_breakpad::Stackwalker;
using google_breakpad::StackwalkerMIPS;
using google_breakpad::SystemInfo;
using google_breakpad::WindowsFrameInfo;
using google_breakpad::test_assembler::kLittleEndian;
using google_breakpad::test_assembler::Label;
using google_breakpad::test_assembler::Section;
using std::vector;
using testing::_;
using testing::AnyNumber;
using testing::Return;
using testing::SetArgumentPointee;
using testing::Test;
class StackwalkerMIPSFixture {
public:
StackwalkerMIPSFixture()
: stack_section(kLittleEndian),
// Give the two modules reasonable standard locations and names
// for tests to play with.
module1(0x00400000, 0x10000, "module1", "version1"),
module2(0x00500000, 0x10000, "module2", "version2") {
// Identify the system as a Linux system.
system_info.os = "Linux";
system_info.os_short = "linux";
system_info.os_version = "Observant Opossum"; // Jealous Jellyfish
system_info.cpu = "mips";
system_info.cpu_info = "";
// Put distinctive values in the raw CPU context.
BrandContext(&raw_context);
// Create some modules with some stock debugging information.
modules.Add(&module1);
modules.Add(&module2);
// By default, none of the modules have symbol info; call
// SetModuleSymbols to override this.
EXPECT_CALL(supplier, GetCStringSymbolData(_, _, _, _, _))
.WillRepeatedly(Return(MockSymbolSupplier::NOT_FOUND));
// Avoid GMOCK WARNING "Uninteresting mock function call - returning
// directly" for FreeSymbolData().
EXPECT_CALL(supplier, FreeSymbolData(_)).Times(AnyNumber());
// Reset max_frames_scanned since it's static.
Stackwalker::set_max_frames_scanned(1024);
}
// Set the Breakpad symbol information that supplier should return for
// MODULE to INFO.
void SetModuleSymbols(MockCodeModule* module, const string& info) {
size_t buffer_size;
char* buffer = supplier.CopySymbolDataAndOwnTheCopy(info, &buffer_size);
EXPECT_CALL(supplier, GetCStringSymbolData(module, &system_info, _, _, _))
.WillRepeatedly(DoAll(SetArgumentPointee<3>(buffer),
SetArgumentPointee<4>(buffer_size),
Return(MockSymbolSupplier::FOUND)));
}
// Populate stack_region with the contents of stack_section. Use
// stack_section.start() as the region's starting address.
void RegionFromSection() {
string contents;
ASSERT_TRUE(stack_section.GetContents(&contents));
stack_region.Init(stack_section.start().Value(), contents);
}
// Fill RAW_CONTEXT with pseudo-random data, for round-trip checking.
void BrandContext(MDRawContextMIPS* raw_context) {
uint8_t x = 173;
for (size_t i = 0; i < sizeof(*raw_context); ++i)
reinterpret_cast<uint8_t*>(raw_context)[i] = (x += 17);
}
SystemInfo system_info;
MDRawContextMIPS raw_context;
Section stack_section;
MockMemoryRegion stack_region;
MockCodeModule module1;
MockCodeModule module2;
MockCodeModules modules;
MockSymbolSupplier supplier;
BasicSourceLineResolver resolver;
CallStack call_stack;
const vector<StackFrame*>* frames;
};
class SanityCheck: public StackwalkerMIPSFixture, public Test { };
TEST_F(SanityCheck, NoResolver) {
stack_section.start() = 0x80000000;
stack_section.D32(0).D32(0x0);
RegionFromSection();
raw_context.epc = 0x00400020;
raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
StackFrameSymbolizer frame_symbolizer(NULL, NULL);
StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
&frame_symbolizer);
// This should succeed, even without a resolver or supplier.
vector<const CodeModule*> modules_without_symbols;
vector<const CodeModule*> modules_with_corrupt_symbols;
ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
&modules_with_corrupt_symbols));
ASSERT_EQ(1U, modules_without_symbols.size());
ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
StackFrameMIPS* frame = static_cast<StackFrameMIPS*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
}
class GetContextFrame: public StackwalkerMIPSFixture, public Test { };
TEST_F(GetContextFrame, Simple) {
stack_section.start() = 0x80000000;
stack_section.D32(0).D32(0x0);
RegionFromSection();
raw_context.epc = 0x00400020;
raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
&frame_symbolizer);
vector<const CodeModule*> modules_without_symbols;
vector<const CodeModule*> modules_with_corrupt_symbols;
ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
&modules_with_corrupt_symbols));
ASSERT_EQ(1U, modules_without_symbols.size());
ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
StackFrameMIPS* frame = static_cast<StackFrameMIPS*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
}
// The stackwalker should be able to produce the context frame even
// without stack memory present.
TEST_F(GetContextFrame, NoStackMemory) {
raw_context.epc = 0x00400020;
raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
StackwalkerMIPS walker(&system_info, &raw_context, NULL, &modules,
&frame_symbolizer);
vector<const CodeModule*> modules_without_symbols;
vector<const CodeModule*> modules_with_corrupt_symbols;
ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
&modules_with_corrupt_symbols));
ASSERT_EQ(1U, modules_without_symbols.size());
ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
StackFrameMIPS* frame = static_cast<StackFrameMIPS*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
}
class GetCallerFrame: public StackwalkerMIPSFixture, public Test { };
TEST_F(GetCallerFrame, ScanWithoutSymbols) {
// When the stack walker resorts to scanning the stack,
// only addresses located within loaded modules are
// considered valid return addresses.
// Force scanning through three frames to ensure that the
// stack pointer is set properly in scan-recovered frames.
stack_section.start() = 0x80000000;
uint32_t return_address1 = 0x00400100;
uint32_t return_address2 = 0x00400900;
Label frame1_sp, frame2_sp;
stack_section
// frame 0
.Append(16, 0) // space
.D32(0x00490000) // junk that's not
.D32(0x00600000) // a return address
.D32(frame1_sp) // stack pointer
.D32(return_address1) // actual return address
// frame 1
.Mark(&frame1_sp)
.Append(16, 0) // space
.D32(0xF0000000) // more junk
.D32(0x0000000D)
.D32(frame2_sp) // stack pointer
.D32(return_address2) // actual return address
// frame 2
.Mark(&frame2_sp)
.Append(32, 0); // end of stack
RegionFromSection();
raw_context.epc = 0x00405510;
raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = stack_section.start().Value();
raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = return_address1;
StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
&frame_symbolizer);
vector<const CodeModule*> modules_without_symbols;
vector<const CodeModule*> modules_with_corrupt_symbols;
ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
&modules_with_corrupt_symbols));
ASSERT_EQ(1U, modules_without_symbols.size());
ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(3U, frames->size());
StackFrameMIPS* frame0 = static_cast<StackFrameMIPS*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameMIPS::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
StackFrameMIPS* frame1 = static_cast<StackFrameMIPS*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameMIPS::CONTEXT_VALID_PC |
StackFrameMIPS::CONTEXT_VALID_SP |
StackFrameMIPS::CONTEXT_VALID_FP |
StackFrameMIPS::CONTEXT_VALID_RA),
frame1->context_validity);
EXPECT_EQ(return_address1 - 2 * sizeof(return_address1), frame1->context.epc);
EXPECT_EQ(frame1_sp.Value(), frame1->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
StackFrameMIPS* frame2 = static_cast<StackFrameMIPS*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame2->trust);
ASSERT_EQ((StackFrameMIPS::CONTEXT_VALID_PC |
StackFrameMIPS::CONTEXT_VALID_SP |
StackFrameMIPS::CONTEXT_VALID_FP |
StackFrameMIPS::CONTEXT_VALID_RA),
frame2->context_validity);
EXPECT_EQ(return_address2 - 2 * sizeof(return_address2), frame2->context.epc);
EXPECT_EQ(frame2_sp.Value(), frame2->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
}
TEST_F(GetCallerFrame, ScanWithFunctionSymbols) {
// During stack scanning, if a potential return address
// is located within a loaded module that has symbols,
// it is only considered a valid return address if it
// lies within a function's bounds.
stack_section.start() = 0x80000000;
uint32_t return_address = 0x00500200;
Label frame1_sp;
stack_section
// frame 0
.Append(16, 0) // space
.D32(0x00490000) // junk that's not
.D32(0x00600000) // a return address
.D32(0x00401000) // a couple of plausible addresses
.D32(0x0050F000) // that are not within functions
.D32(frame1_sp) // stack pointer
.D32(return_address) // actual return address
// frame 1
.Mark(&frame1_sp)
.Append(32, 0); // end of stack
RegionFromSection();
raw_context.epc = 0x00400200;
raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = stack_section.start().Value();
raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = return_address;
SetModuleSymbols(&module1,
// The youngest frame's function.
"FUNC 100 400 10 monotreme\n");
SetModuleSymbols(&module2,
// The calling frame's function.
"FUNC 100 400 10 marsupial\n");
StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
&frame_symbolizer);
vector<const CodeModule*> modules_without_symbols;
vector<const CodeModule*> modules_with_corrupt_symbols;
ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
&modules_with_corrupt_symbols));
ASSERT_EQ(0U, modules_without_symbols.size());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
StackFrameMIPS* frame0 = static_cast<StackFrameMIPS*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameMIPS::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
EXPECT_EQ("monotreme", frame0->function_name);
EXPECT_EQ(0x00400100U, frame0->function_base);
StackFrameMIPS* frame1 = static_cast<StackFrameMIPS*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameMIPS::CONTEXT_VALID_PC |
StackFrameMIPS::CONTEXT_VALID_SP |
StackFrameMIPS::CONTEXT_VALID_FP |
StackFrameMIPS::CONTEXT_VALID_RA),
frame1->context_validity);
EXPECT_EQ(return_address - 2 * sizeof(return_address), frame1->context.epc);
EXPECT_EQ(frame1_sp.Value(), frame1->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
EXPECT_EQ("marsupial", frame1->function_name);
EXPECT_EQ(0x00500100U, frame1->function_base);
}
TEST_F(GetCallerFrame, CheckStackFrameSizeLimit) {
// If the stackwalker resorts to stack scanning, it will scan only
// 1024 bytes of stack which correspondes to maximum size of stack frame.
stack_section.start() = 0x80000000;
uint32_t return_address1 = 0x00500100;
uint32_t return_address2 = 0x00500900;
Label frame1_sp, frame2_sp;
stack_section
// frame 0
.Append(32, 0) // space
.D32(0x00490000) // junk that's not
.D32(0x00600000) // a return address
.Append(96, 0) // more space
.D32(frame1_sp) // stack pointer
.D32(return_address1) // actual return address
// frame 1
.Mark(&frame1_sp)
.Append(128 * 4, 0) // space
.D32(0x00F00000) // more junk
.D32(0x0000000D)
.Append(128 * 4, 0) // more space
.D32(frame2_sp) // stack pointer
.D32(return_address2) // actual return address
// (won't be found)
// frame 2
.Mark(&frame2_sp)
.Append(32, 0); // end of stack
RegionFromSection();
raw_context.epc = 0x00405510;
raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = stack_section.start().Value();
raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = return_address1;
StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
&frame_symbolizer);
vector<const CodeModule*> modules_without_symbols;
vector<const CodeModule*> modules_with_corrupt_symbols;
ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
&modules_with_corrupt_symbols));
ASSERT_EQ(2U, modules_without_symbols.size());
ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
ASSERT_EQ("module2", modules_without_symbols[1]->debug_file());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
StackFrameMIPS* frame0 = static_cast<StackFrameMIPS*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameMIPS::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
StackFrameMIPS* frame1 = static_cast<StackFrameMIPS*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameMIPS::CONTEXT_VALID_PC |
StackFrameMIPS::CONTEXT_VALID_SP |
StackFrameMIPS::CONTEXT_VALID_FP |
StackFrameMIPS::CONTEXT_VALID_RA),
frame1->context_validity);
EXPECT_EQ(return_address1 - 2 * sizeof(return_address1), frame1->context.epc);
EXPECT_EQ(frame1_sp.Value(), frame1->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
}
// Test that set_max_frames_scanned prevents using stack scanning
// to find caller frames.
TEST_F(GetCallerFrame, ScanningNotAllowed) {
// When the stack walker resorts to scanning the stack,
// only fixed number of frames are allowed to be scanned out from stack
stack_section.start() = 0x80000000;
uint32_t return_address1 = 0x00500100;
uint32_t return_address2 = 0x00500900;
Label frame1_sp, frame2_sp;
stack_section
// frame 0
.Append(32, 0) // space
.D32(0x00490000) // junk that's not
.D32(0x00600000) // a return address
.Append(96, 0) // more space
.D32(frame1_sp) // stack pointer
.D32(return_address1) // actual return address
// frame 1
.Mark(&frame1_sp)
.Append(128 * 4, 0) // space
.D32(0x00F00000) // more junk
.D32(0x0000000D)
.Append(128 * 4, 0) // more space
.D32(frame2_sp) // stack pointer
.D32(return_address2) // actual return address
// (won't be found)
// frame 2
.Mark(&frame2_sp)
.Append(32, 0); // end of stack
RegionFromSection();
raw_context.epc = 0x00405510;
raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = stack_section.start().Value();
raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = return_address1;
StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
&frame_symbolizer);
Stackwalker::set_max_frames_scanned(0);
vector<const CodeModule*> modules_without_symbols;
vector<const CodeModule*> modules_with_corrupt_symbols;
ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
&modules_with_corrupt_symbols));
ASSERT_EQ(1U, modules_without_symbols.size());
ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
StackFrameMIPS* frame0 = static_cast<StackFrameMIPS*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameMIPS::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
}
struct CFIFixture: public StackwalkerMIPSFixture {
CFIFixture() {
// Provide some STACK CFI records;
SetModuleSymbols(&module1,
// The youngest frame's function.
"FUNC 4000 1000 0 enchiridion\n"
// Initially, nothing has been pushed on the stack,
// and the return address is still in the $ra register.
"STACK CFI INIT 4000 1000 .cfa: $sp 0 + .ra: $ra\n"
// Move stack pointer.
"STACK CFI 4004 .cfa: $sp 32 +\n"
// store $fp and ra
"STACK CFI 4008 $fp: .cfa -8 + ^ .ra: .cfa -4 + ^\n"
// restore $fp
"STACK CFI 400c .cfa: $fp 32 +\n"
// restore $sp
"STACK CFI 4018 .cfa: $sp 32 +\n"
"STACK CFI 4020 $fp: $fp .cfa: $sp 0 + .ra: .ra\n"
// The calling function.
"FUNC 5000 1000 0 epictetus\n"
// Initially, nothing has been pushed on the stack,
// and the return address is still in the $ra register.
"STACK CFI INIT 5000 1000 .cfa: $sp .ra: $ra\n"
// Mark it as end of stack.
"STACK CFI INIT 5000 8 .cfa: $sp 0 + .ra: $ra\n"
// A function whose CFI makes the stack pointer
// go backwards.
"FUNC 6000 1000 20 palinal\n"
"STACK CFI INIT 6000 1000 .cfa: $sp 4 - .ra: $ra\n"
// A function with CFI expressions that can't be
// evaluated.
"FUNC 7000 1000 20 rhetorical\n"
"STACK CFI INIT 7000 1000 .cfa: moot .ra: ambiguous\n"
);
// Provide some distinctive values for the caller's registers.
expected.epc = 0x00405508;
expected.iregs[MD_CONTEXT_MIPS_REG_S0] = 0x0;
expected.iregs[MD_CONTEXT_MIPS_REG_S1] = 0x1;
expected.iregs[MD_CONTEXT_MIPS_REG_S2] = 0x2;
expected.iregs[MD_CONTEXT_MIPS_REG_S3] = 0x3;
expected.iregs[MD_CONTEXT_MIPS_REG_S4] = 0x4;
expected.iregs[MD_CONTEXT_MIPS_REG_S5] = 0x5;
expected.iregs[MD_CONTEXT_MIPS_REG_S6] = 0x6;
expected.iregs[MD_CONTEXT_MIPS_REG_S7] = 0x7;
expected.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
expected.iregs[MD_CONTEXT_MIPS_REG_FP] = 0x80000000;
expected.iregs[MD_CONTEXT_MIPS_REG_RA] = 0x00405510;
// Expect CFI to recover all callee-save registers. Since CFI is the
// only stack frame construction technique we have, aside from the
// context frame itself, there's no way for us to have a set of valid
// registers smaller than this.
expected_validity = (StackFrameMIPS::CONTEXT_VALID_PC |
StackFrameMIPS::CONTEXT_VALID_S0 |
StackFrameMIPS::CONTEXT_VALID_S1 |
StackFrameMIPS::CONTEXT_VALID_S2 |
StackFrameMIPS::CONTEXT_VALID_S3 |
StackFrameMIPS::CONTEXT_VALID_S4 |
StackFrameMIPS::CONTEXT_VALID_S5 |
StackFrameMIPS::CONTEXT_VALID_S6 |
StackFrameMIPS::CONTEXT_VALID_S7 |
StackFrameMIPS::CONTEXT_VALID_SP |
StackFrameMIPS::CONTEXT_VALID_FP |
StackFrameMIPS::CONTEXT_VALID_RA);
// By default, context frames provide all registers, as normal.
context_frame_validity = StackFrameMIPS::CONTEXT_VALID_ALL;
// By default, registers are unchanged.
raw_context = expected;
}
// Walk the stack, using stack_section as the contents of the stack
// and raw_context as the current register values. (Set the stack
// pointer to the stack's starting address.) Expect two stack
// frames; in the older frame, expect the callee-saves registers to
// have values matching those in 'expected'.
void CheckWalk() {
RegionFromSection();
raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = stack_section.start().Value();
StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
StackwalkerMIPS walker(&system_info, &raw_context, &stack_region,
&modules, &frame_symbolizer);
vector<const CodeModule*> modules_without_symbols;
vector<const CodeModule*> modules_with_corrupt_symbols;
ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
&modules_with_corrupt_symbols));
ASSERT_EQ(0U, modules_without_symbols.size());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
StackFrameMIPS* frame0 = static_cast<StackFrameMIPS*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameMIPS::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ("enchiridion", frame0->function_name);
EXPECT_EQ(0x00404000U, frame0->function_base);
StackFrameMIPS* frame1 = static_cast<StackFrameMIPS*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame1->trust);
ASSERT_EQ(expected_validity, frame1->context_validity);
EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S0],
frame1->context.iregs[MD_CONTEXT_MIPS_REG_S0]);
EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S1],
frame1->context.iregs[MD_CONTEXT_MIPS_REG_S1]);
EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S2],
frame1->context.iregs[MD_CONTEXT_MIPS_REG_S2]);
EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S3],
frame1->context.iregs[MD_CONTEXT_MIPS_REG_S3]);
EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S4],
frame1->context.iregs[MD_CONTEXT_MIPS_REG_S4]);
EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S5],
frame1->context.iregs[MD_CONTEXT_MIPS_REG_S5]);
EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S6],
frame1->context.iregs[MD_CONTEXT_MIPS_REG_S6]);
EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S7],
frame1->context.iregs[MD_CONTEXT_MIPS_REG_S7]);
EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_FP],
frame1->context.iregs[MD_CONTEXT_MIPS_REG_FP]);
EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_RA],
frame1->context.iregs[MD_CONTEXT_MIPS_REG_RA]);
EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_SP],
frame1->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
EXPECT_EQ(expected.epc, frame1->context.epc);
EXPECT_EQ(expected.epc, frame1->instruction);
EXPECT_EQ("epictetus", frame1->function_name);
EXPECT_EQ(0x00405000U, frame1->function_base);
}
// The values we expect to find for the caller's registers.
MDRawContextMIPS expected;
// The validity mask for expected.
int expected_validity;
// The validity mask to impose on the context frame.
int context_frame_validity;
};
class CFI: public CFIFixture, public Test { };
// TODO(gordanac): add CFI tests
TEST_F(CFI, At4004) {
Label frame1_sp = expected.iregs[MD_CONTEXT_MIPS_REG_SP];
stack_section
// frame0
.Append(24, 0) // space
.D32(frame1_sp) // stack pointer
.D32(0x00405510) // return address
.Mark(&frame1_sp); // This effectively sets stack_section.start().
raw_context.epc = 0x00404004;
CheckWalk();
}
// Check that we reject rules that would cause the stack pointer to
// move in the wrong direction.
TEST_F(CFI, RejectBackwards) {
raw_context.epc = 0x40005000;
raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = 0x00405510;
StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
&frame_symbolizer);
vector<const CodeModule*> modules_without_symbols;
vector<const CodeModule*> modules_with_corrupt_symbols;
ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
&modules_with_corrupt_symbols));
ASSERT_EQ(0U, modules_without_symbols.size());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
}
// Check that we reject rules whose expressions' evaluation fails.
TEST_F(CFI, RejectBadExpressions) {
raw_context.epc = 0x00407000;
raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = 0x00405510;
StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
&frame_symbolizer);
vector<const CodeModule*> modules_without_symbols;
vector<const CodeModule*> modules_with_corrupt_symbols;
ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
&modules_with_corrupt_symbols));
ASSERT_EQ(0U, modules_without_symbols.size());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
}

36
src/processor/synth_minidump.cc
View File

@@ -195,6 +195,42 @@ Context::Context(const Dump &dump, const MDRawContextARM &context)
assert(Size() == sizeof(MDRawContextARM));
}
Context::Context(const Dump &dump, const MDRawContextMIPS &context)
: Section(dump) {
// The caller should have properly set the CPU type flag.
assert(context.context_flags & MD_CONTEXT_MIPS);
D32(context.context_flags);
D32(context._pad0);
for (int i = 0; i < MD_CONTEXT_MIPS_GPR_COUNT; ++i)
D64(context.iregs[i]);
D64(context.mdhi);
D64(context.mdlo);
for (int i = 0; i < MD_CONTEXT_MIPS_DSP_COUNT; ++i)
D32(context.hi[i]);
for (int i = 0; i < MD_CONTEXT_MIPS_DSP_COUNT; ++i)
D32(context.lo[i]);
D32(context.dsp_control);
D32(context._pad1);
D64(context.epc);
D64(context.badvaddr);
D32(context.status);
D32(context.cause);
for (int i = 0; i < MD_FLOATINGSAVEAREA_MIPS_FPR_COUNT; ++i)
D64(context.float_save.regs[i]);
D32(context.float_save.fpcsr);
D32(context.float_save.fir);
assert(Size() == sizeof(MDRawContextMIPS));
}
Thread::Thread(const Dump &dump,
uint32_t thread_id, const Memory &stack, const Context &context,
uint32_t suspend_count, uint32_t priority_class,

1
src/processor/synth_minidump.h
View File

@@ -228,6 +228,7 @@ class Context: public Section {
// Create a context belonging to DUMP whose contents are a copy of CONTEXT.
Context(const Dump &dump, const MDRawContextX86 &context);
Context(const Dump &dump, const MDRawContextARM &context);
Context(const Dump &dump, const MDRawContextMIPS &context);
// Add an empty context to the dump.
Context(const Dump &dump) : Section(dump) {}
// Add constructors for other architectures here. Remember to byteswap.