From 6354cffeb0c854dac46d81210c59f7037230cc54 Mon Sep 17 00:00:00 2001 From: "mmandlis@chromium.org" Date: Wed, 19 Nov 2014 21:33:26 +0000 Subject: Microdump processing implementation According to design document: http://goo.gl/B3wIRN This is an initial implementation version, support ARM architecture only. BUG=chromium:410294 R=primiano@chromium.org Review URL: https://breakpad.appspot.com/5714003 git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@1403 4c0a9323-5329-0410-9bdc-e9ce6186880e --- src/google_breakpad/processor/microdump.h | 122 ++++++++++ .../processor/microdump_processor.h | 3 + src/google_breakpad/processor/process_state.h | 4 +- src/processor/basic_code_modules.cc | 5 + src/processor/basic_code_modules.h | 5 +- src/processor/microdump.cc | 262 +++++++++++++++++++++ src/processor/microdump_processor.cc | 42 +++- src/processor/microdump_processor_unittest.cc | 138 ++++++++++- src/processor/testdata/microdump.dmp | 157 ++++++++++++ .../libchromeshell.so.sym | 249 ++++++++++++++++++++ 10 files changed, 982 insertions(+), 5 deletions(-) create mode 100644 src/google_breakpad/processor/microdump.h create mode 100644 src/processor/microdump.cc create mode 100644 src/processor/testdata/microdump.dmp create mode 100644 src/processor/testdata/symbols/microdump/libchromeshell.so/76304586D0CD2C8FF899C602BF1756A20/libchromeshell.so.sym (limited to 'src') diff --git a/src/google_breakpad/processor/microdump.h b/src/google_breakpad/processor/microdump.h new file mode 100644 index 00000000..3676bd67 --- /dev/null +++ b/src/google_breakpad/processor/microdump.h @@ -0,0 +1,122 @@ +// Copyright (c) 2014 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. + +// microdump.h: A microdump reader. Microdump is a minified variant of a +// minidump (see minidump.h for documentation) which contains the minimum +// amount of information required to get a stack trace for the crashing thread. +// The information contained in a microdump is: +// - the crashing thread stack +// - system information (os type / version) +// - cpu context (state of the registers) +// - list of mmaps + +#ifndef GOOGLE_BREAKPAD_PROCESSOR_MICRODUMP_H__ +#define GOOGLE_BREAKPAD_PROCESSOR_MICRODUMP_H__ + +#include +#include + +#include "common/scoped_ptr.h" +#include "common/using_std_string.h" +#include "google_breakpad/processor/dump_context.h" +#include "google_breakpad/processor/memory_region.h" +#include "processor/basic_code_modules.h" + +namespace google_breakpad { + +// MicrodumpModuleList contains all of the loaded code modules for a process +// in the form of MicrodumpModules. It maintains a vector of these modules +// and provides access to a code module corresponding to a specific address. +class MicrodumpModules : public BasicCodeModules { + public: + // Takes over ownership of |module|. + void Add(const CodeModule* module); +}; + +// MicrodumpContext carries a CPU-specific context. +// See dump_context.h for documentation. +class MicrodumpContext : public DumpContext { + public: + virtual void SetContextARM(MDRawContextARM* arm); +}; + +// This class provides access to microdump memory regions. +// See memory_region.h for documentation. +class MicrodumpMemoryRegion : public MemoryRegion { + public: + MicrodumpMemoryRegion(); + virtual ~MicrodumpMemoryRegion() {} + + // Set this region's address and contents. If we have placed an + // instance of this class in a test fixture class, individual tests + // can use this to provide the region's contents. + void Init(uint64_t base_address, const std::vector& contents); + + virtual uint64_t GetBase() const; + virtual uint32_t GetSize() const; + + virtual bool GetMemoryAtAddress(uint64_t address, uint8_t* value) const; + virtual bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const; + virtual bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const; + virtual bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const; + + // Print a human-readable representation of the object to stdout. + virtual void Print() const; + + private: + // Fetch a little-endian value from ADDRESS in contents_ whose size + // is BYTES, and store it in *VALUE. Returns true on success. + template + bool GetMemoryLittleEndian(uint64_t address, ValueType* value) const; + + uint64_t base_address_; + std::vector contents_; +}; + +// Microdump is the user's interface to a microdump file. It provides access to +// the microdump's context, memory regions and modules. +class Microdump { + public: + explicit Microdump(const string& contents); + virtual ~Microdump() {} + + DumpContext* GetContext() { return context_.get(); } + MicrodumpMemoryRegion* GetMemory() { return stack_region_.get(); } + MicrodumpModules* GetModules() { return modules_.get(); } + + private: + scoped_ptr context_; + scoped_ptr stack_region_; + scoped_ptr modules_; +}; + +} // namespace google_breakpad + +#endif // GOOGLE_BREAKPAD_PROCESSOR_MICRODUMP_H__ + diff --git a/src/google_breakpad/processor/microdump_processor.h b/src/google_breakpad/processor/microdump_processor.h index 6ba6221d..1322a01c 100644 --- a/src/google_breakpad/processor/microdump_processor.h +++ b/src/google_breakpad/processor/microdump_processor.h @@ -27,6 +27,9 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// The processor for microdump (a reduced dump containing only the state of the +// crashing thread). See crbug.com/410294 for more info and design docs. + #ifndef GOOGLE_BREAKPAD_PROCESSOR_MICRODUMP_PROCESSOR_H__ #define GOOGLE_BREAKPAD_PROCESSOR_MICRODUMP_PROCESSOR_H__ diff --git a/src/google_breakpad/processor/process_state.h b/src/google_breakpad/processor/process_state.h index 88f826c2..a33b2123 100644 --- a/src/google_breakpad/processor/process_state.h +++ b/src/google_breakpad/processor/process_state.h @@ -117,8 +117,10 @@ class ProcessState { ExploitabilityRating exploitability() const { return exploitability_; } private: - // MinidumpProcessor is responsible for building ProcessState objects. + // MinidumpProcessor and MicrodumpProcessor are responsible for building + // ProcessState objects. friend class MinidumpProcessor; + friend class MicrodumpProcessor; // The time-date stamp of the minidump (time_t format) uint32_t time_date_stamp_; diff --git a/src/processor/basic_code_modules.cc b/src/processor/basic_code_modules.cc index 588140c8..40b45a8b 100644 --- a/src/processor/basic_code_modules.cc +++ b/src/processor/basic_code_modules.cc @@ -73,6 +73,11 @@ BasicCodeModules::BasicCodeModules(const CodeModules *that) } } +BasicCodeModules::BasicCodeModules() + : main_address_(0), + map_(new RangeMap >()) { +} + BasicCodeModules::~BasicCodeModules() { delete map_; } diff --git a/src/processor/basic_code_modules.h b/src/processor/basic_code_modules.h index d302287e..ace569b8 100644 --- a/src/processor/basic_code_modules.h +++ b/src/processor/basic_code_modules.h @@ -67,7 +67,9 @@ class BasicCodeModules : public CodeModules { virtual const CodeModule* GetModuleAtIndex(unsigned int index) const; virtual const CodeModules* Copy() const; - private: + protected: + BasicCodeModules(); + // The base address of the main module. uint64_t main_address_; @@ -75,6 +77,7 @@ class BasicCodeModules : public CodeModules { // address range. RangeMap > *map_; + private: // Disallow copy constructor and assignment operator. BasicCodeModules(const BasicCodeModules &that); void operator=(const BasicCodeModules &that); diff --git a/src/processor/microdump.cc b/src/processor/microdump.cc new file mode 100644 index 00000000..3e45d175 --- /dev/null +++ b/src/processor/microdump.cc @@ -0,0 +1,262 @@ +// Copyright (c) 2014 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. + +// microdump.cc: A microdump reader. +// +// See microdump.h for documentation. + +#include "google_breakpad/processor/microdump.h" + +#include +#include + +#include +#include +#include +#include + +#include "google_breakpad/common/minidump_cpu_arm.h" +#include "google_breakpad/processor/code_module.h" +#include "processor/basic_code_module.h" +#include "processor/linked_ptr.h" +#include "processor/logging.h" +#include "processor/range_map-inl.h" + +namespace { +static const char kGoogleBreakpadKey[] = "/google-breakpad("; +static const char kMicrodumpBegin[] = "-----BEGIN BREAKPAD MICRODUMP-----"; +static const char kMicrodumpEnd[] = "-----END BREAKPAD MICRODUMP-----"; +static const char kOsKey[] = ": O "; +static const char kCpuKey[] = ": C "; +static const char kMmapKey[] = ": M "; +static const char kStackKey[] = ": S "; +static const char kStackFirstLineKey[] = ": S 0 "; +static const char kArmArchitecture[] = "armv7l"; + +template +T HexStrToL(const string& str) { + uint64_t res = 0; + std::istringstream ss(str); + ss >> std::hex >> res; + return static_cast(res); +} + +std::vector ParseHexBuf(const string& str) { + std::vector buf; + for (size_t i = 0; i < str.length(); i += 2) { + buf.push_back(HexStrToL(str.substr(i, 2))); + } + return buf; +} + +} // namespace + +namespace google_breakpad { + +// +// MicrodumpModules +// + +void MicrodumpModules::Add(const CodeModule* module) { + linked_ptr module_ptr(module); + if (!map_->StoreRange(module->base_address(), module->size(), module_ptr)) { + BPLOG(ERROR) << "Module " << module->code_file() << + " could not be stored"; + } +} + + +// +// MicrodumpContext +// + +void MicrodumpContext::SetContextARM(MDRawContextARM* arm) { + DumpContext::SetContextFlags(MD_CONTEXT_ARM); + DumpContext::SetContextARM(arm); + valid_ = true; +} + + +// +// MicrodumpMemoryRegion +// + +MicrodumpMemoryRegion::MicrodumpMemoryRegion() : base_address_(0) { } + +void MicrodumpMemoryRegion::Init(uint64_t base_address, + const std::vector& contents) { + base_address_ = base_address; + contents_ = contents; +} + +uint64_t MicrodumpMemoryRegion::GetBase() const { return base_address_; } + +uint32_t MicrodumpMemoryRegion::GetSize() const { return contents_.size(); } + +bool MicrodumpMemoryRegion::GetMemoryAtAddress(uint64_t address, + uint8_t* value) const { + return GetMemoryLittleEndian(address, value); +} + +bool MicrodumpMemoryRegion::GetMemoryAtAddress(uint64_t address, + uint16_t* value) const { + return GetMemoryLittleEndian(address, value); +} + +bool MicrodumpMemoryRegion::GetMemoryAtAddress(uint64_t address, + uint32_t* value) const { + return GetMemoryLittleEndian(address, value); +} + +bool MicrodumpMemoryRegion::GetMemoryAtAddress(uint64_t address, + uint64_t* value) const { + return GetMemoryLittleEndian(address, value); +} + +template +bool MicrodumpMemoryRegion::GetMemoryLittleEndian(uint64_t address, + ValueType* value) const { + if (address < base_address_ || + address - base_address_ + sizeof(ValueType) > contents_.size()) + return false; + ValueType v = 0; + uint64_t start = address - base_address_; + // The loop condition is odd, but it's correct for size_t. + for (size_t i = sizeof(ValueType) - 1; i < sizeof(ValueType); i--) + v = (v << 8) | static_cast(contents_[start + i]); + *value = v; + return true; +} + +void MicrodumpMemoryRegion::Print() const { + // Not reached, just needed to honor the base class contract. + assert(false); +} + +// +// Microdump +// +Microdump::Microdump(const string& contents) + : context_(new MicrodumpContext()), + stack_region_(new MicrodumpMemoryRegion()), + modules_(new MicrodumpModules()) { + assert(!contents.empty()); + + bool in_microdump = false; + string line; + uint64_t stack_start = 0; + std::vector stack_content; + string arch; + + std::istringstream stream(contents); + while (std::getline(stream, line)) { + if (line.find(kGoogleBreakpadKey) == string::npos) { + continue; + } + if (line.find(kMicrodumpBegin) != string::npos) { + in_microdump = true; + continue; + } + if (line.find(kMicrodumpEnd) != string::npos) { + break; + } + + if (!in_microdump) { + continue; + } + + size_t pos; + if ((pos = line.find(kOsKey)) != string::npos) { + string os_str(line, pos + strlen(kOsKey)); + std::istringstream os_tokens(os_str); + string unused_id; + os_tokens >> unused_id; + os_tokens >> arch; + arch = arch.substr(1, arch.length() - 2); // remove quotes + // OS line also contains release and version for future use. + } else if ((pos = line.find(kStackKey)) != string::npos) { + if (line.find(kStackFirstLineKey) != string::npos) { + // The first line of the stack (S 0 stack header) provides the value of + // the stack pointer, the start address of the stack being dumped and + // the length of the stack. We could use it in future to double check + // that we received all the stack as expected. + continue; + } + string stack_str(line, pos + strlen(kStackKey)); + std::istringstream stack_tokens(stack_str); + string start_addr_str; + string raw_content; + stack_tokens >> start_addr_str; + stack_tokens >> raw_content; + uint64_t start_addr = HexStrToL(start_addr_str); + + if (stack_start != 0) { + // Verify that the stack chunks in the microdump are contiguous. + assert(start_addr == stack_start + stack_content.size()); + } else { + stack_start = start_addr; + } + std::vector chunk = ParseHexBuf(raw_content); + stack_content.insert(stack_content.end(), chunk.begin(), chunk.end()); + + } else if ((pos = line.find(kCpuKey)) != string::npos) { + string cpu_state_str(line, pos + strlen(kCpuKey)); + std::vector cpu_state_raw = ParseHexBuf(cpu_state_str); + if (strcmp(arch.c_str(), kArmArchitecture) == 0) { + MDRawContextARM* arm = new MDRawContextARM(); + memcpy(arm, &cpu_state_raw[0], cpu_state_raw.size()); + context_->SetContextARM(arm); + } else { + std::cerr << "Unsupported architecture: " << arch << std::endl; + } + } else if ((pos = line.find(kMmapKey)) != string::npos) { + string mmap_line(line, pos + strlen(kMmapKey)); + std::istringstream mmap_tokens(mmap_line); + string addr, offset, size, identifier, filename; + mmap_tokens >> addr; + mmap_tokens >> offset; + mmap_tokens >> size; + mmap_tokens >> identifier; + mmap_tokens >> filename; + + modules_->Add(new BasicCodeModule( + HexStrToL(addr), // base_address + HexStrToL(size), // size + filename, // code_file + identifier, // code_identifier + filename, // debug_file + identifier, // debug_identifier + "")); // version + } + } + stack_region_->Init(stack_start, stack_content); +} + +} // namespace google_breakpad + diff --git a/src/processor/microdump_processor.cc b/src/processor/microdump_processor.cc index c9229525..40b3688e 100644 --- a/src/processor/microdump_processor.cc +++ b/src/processor/microdump_processor.cc @@ -27,6 +27,10 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// microdump_processor.cc: A microdump processor. +// +// See microdump_processor.h for documentation. + #include "google_breakpad/processor/microdump_processor.h" #include @@ -35,8 +39,11 @@ #include "common/using_std_string.h" #include "google_breakpad/processor/call_stack.h" +#include "google_breakpad/processor/microdump.h" #include "google_breakpad/processor/process_state.h" +#include "google_breakpad/processor/stackwalker.h" #include "google_breakpad/processor/stack_frame_symbolizer.h" +#include "processor/logging.h" namespace google_breakpad { @@ -51,7 +58,40 @@ ProcessResult MicrodumpProcessor::Process(const string µdump_contents, ProcessState* process_state) { assert(process_state); - // TODO(mmandlis): Implement MicrodumpProcessor. See crbug.com/410294 + process_state->Clear(); + + if (microdump_contents.empty()) { + BPLOG(ERROR) << "Microdump is empty."; + return PROCESS_ERROR_MINIDUMP_NOT_FOUND; + } + + Microdump microdump(microdump_contents); + process_state->modules_ = microdump.GetModules()->Copy(); + scoped_ptr stackwalker( + Stackwalker::StackwalkerForCPU( + &process_state->system_info_, + microdump.GetContext(), + microdump.GetMemory(), + process_state->modules_, + frame_symbolizer_)); + + scoped_ptr stack(new CallStack()); + if (stackwalker.get()) { + if (!stackwalker->Walk(stack.get(), + &process_state->modules_without_symbols_, + &process_state->modules_with_corrupt_symbols_)) { + BPLOG(INFO) << "Processing was interrupted."; + return PROCESS_SYMBOL_SUPPLIER_INTERRUPTED; + } + } else { + BPLOG(ERROR) << "No stackwalker found for microdump."; + return PROCESS_ERROR_NO_THREAD_LIST; + } + + process_state->threads_.push_back(stack.release()); + process_state->thread_memory_regions_.push_back(microdump.GetMemory()); + process_state->crashed_ = true; + process_state->requesting_thread_ = 0; return PROCESS_OK; } diff --git a/src/processor/microdump_processor_unittest.cc b/src/processor/microdump_processor_unittest.cc index 45e534ab..9353383c 100644 --- a/src/processor/microdump_processor_unittest.cc +++ b/src/processor/microdump_processor_unittest.cc @@ -29,18 +29,152 @@ // Unit test for MicrodumpProcessor. +#include +#include +#include +#include + #include "breakpad_googletest_includes.h" +#include "google_breakpad/processor/basic_source_line_resolver.h" +#include "google_breakpad/processor/call_stack.h" +#include "google_breakpad/processor/microdump_processor.h" +#include "google_breakpad/processor/process_state.h" +#include "google_breakpad/processor/stack_frame.h" +#include "google_breakpad/processor/stack_frame_symbolizer.h" +#include "processor/simple_symbol_supplier.h" +#include "processor/stackwalker_unittest_utils.h" namespace { +using google_breakpad::BasicSourceLineResolver; +using google_breakpad::MicrodumpProcessor; +using google_breakpad::ProcessState; +using google_breakpad::SimpleSymbolSupplier; +using google_breakpad::StackFrameSymbolizer; + class MicrodumpProcessorTest : public ::testing::Test { + public: + MicrodumpProcessorTest() + : files_path_(string(getenv("srcdir") ? getenv("srcdir") : ".") + + "/src/processor/testdata/") { + } + + void ReadFile(const string& file_name, string* file_contents) { + assert(file_contents); + std::ifstream file_stream(file_name.c_str(), std::ios::in); + ASSERT_TRUE(file_stream.good()); + std::vector bytes; + file_stream.seekg(0, std::ios_base::end); + ASSERT_TRUE(file_stream.good()); + bytes.resize(file_stream.tellg()); + file_stream.seekg(0, std::ios_base::beg); + ASSERT_TRUE(file_stream.good()); + file_stream.read(&bytes[0], bytes.size()); + ASSERT_TRUE(file_stream.good()); + *file_contents = string(&bytes[0], bytes.size()); + } + + google_breakpad::ProcessResult ProcessMicrodump( + const string& symbols_file, + const string& microdump_contents, + ProcessState* state) { + SimpleSymbolSupplier supplier(symbols_file); + BasicSourceLineResolver resolver; + StackFrameSymbolizer frame_symbolizer(&supplier, &resolver); + MicrodumpProcessor processor(&frame_symbolizer); + + return processor.Process(microdump_contents, state); + } + + string files_path_; }; -// TODO(mmandlis): Add MicrodumpProcessor tests. See crbug.com/410294 +TEST_F(MicrodumpProcessorTest, TestProcess_Empty) { + ProcessState state; + google_breakpad::ProcessResult result = + ProcessMicrodump("", "", &state); + ASSERT_EQ(google_breakpad::PROCESS_ERROR_MINIDUMP_NOT_FOUND, result); +} + +TEST_F(MicrodumpProcessorTest, TestProcess_Invalid) { + ProcessState state; + google_breakpad::ProcessResult result = + ProcessMicrodump("", "This is not a valid microdump", &state); + ASSERT_EQ(google_breakpad::PROCESS_ERROR_NO_THREAD_LIST, result); +} + +TEST_F(MicrodumpProcessorTest, TestProcess_MissingSymbols) { + string microdump_file = files_path_ + "microdump.dmp"; + string microdump_contents; + ReadFile(microdump_file, µdump_contents); + + ProcessState state; + + google_breakpad::ProcessResult result = + ProcessMicrodump("", microdump_contents, &state); + + ASSERT_EQ(google_breakpad::PROCESS_OK, result); + + ASSERT_TRUE(state.crashed()); + ASSERT_EQ(0, state.requesting_thread()); + + ASSERT_EQ(104U, state.modules()->module_count()); + ASSERT_EQ(1U, state.threads()->size()); + ASSERT_EQ(4U, state.threads()->at(0)->frames()->size()); + + ASSERT_EQ("", + state.threads()->at(0)->frames()->at(0)->function_name); + ASSERT_EQ("", + state.threads()->at(0)->frames()->at(3)->function_name); +} + +TEST_F(MicrodumpProcessorTest, TestProcess_UnsupportedArch) { + string microdump_contents = + "W/google-breakpad(26491): -----BEGIN BREAKPAD MICRODUMP-----\n" + "W/google-breakpad(26491): O A \"unsupported-arch\"\n" + "W/google-breakpad(26491): S 0 A48BD840 A48BD000 00002000\n"; + + ProcessState state; + + google_breakpad::ProcessResult result = + ProcessMicrodump("", microdump_contents, &state); + + ASSERT_EQ(google_breakpad::PROCESS_ERROR_NO_THREAD_LIST, result); +} + +TEST_F(MicrodumpProcessorTest, TestProcess) { + string symbols_file = files_path_ + "symbols/microdump"; + + string microdump_file = files_path_ + "microdump.dmp"; + string microdump_contents; + ReadFile(microdump_file, µdump_contents); + + ProcessState state; + + google_breakpad::ProcessResult result = + ProcessMicrodump(symbols_file, microdump_contents, &state); + + ASSERT_EQ(google_breakpad::PROCESS_OK, result); + ASSERT_TRUE(state.crashed()); + ASSERT_EQ(0, state.requesting_thread()); + ASSERT_EQ(104U, state.modules()->module_count()); + ASSERT_EQ(1U, state.threads()->size()); + + ASSERT_EQ(21U, state.threads()->at(0)->frames()->size()); + + ASSERT_EQ("content::::CrashIntentionally", + state.threads()->at(0)->frames()->at(0)->function_name); + ASSERT_EQ("content::::MaybeHandleDebugURL", + state.threads()->at(0)->frames()->at(1)->function_name); + ASSERT_EQ("content::Start", + state.threads()->at(0)->frames()->at(19)->function_name); + ASSERT_EQ("libchromeshell.so", + state.threads()->at(0)->frames()->at(19)->module->code_file()); +} } // namespace -int main(int argc, char *argv[]) { +int main(int argc, char* argv[]) { ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } diff --git a/src/processor/testdata/microdump.dmp b/src/processor/testdata/microdump.dmp new file mode 100644 index 00000000..e641a477 --- /dev/null +++ b/src/processor/testdata/microdump.dmp @@ -0,0 +1,157 @@ +W/IInputConnectionWrapper(26278): endBatchEdit on inactive InputConnection +W/google-breakpad(26491): -----BEGIN BREAKPAD MICRODUMP----- +W/google-breakpad(26491): O A "armv7l" "3.4.0-perf-g60eefcd "#1 SMP PREEMPT Fri Oct 10 18:28:38 UTC 2014" +W/google-breakpad(26491): S 0 A48BD840 A48BD000 00002000 +W/google-breakpad(26491): S A48BD000 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000AE4755410000803F000000000000803F00000000D43DFDB60000803F0000000000000000000000FF404000000100B4008CD08BA470F0DB024800000001000000636572733400000001000000AE4755410000803F000000000000803F00000000000000000000803F0000000000000000000000FF404000000100B40035FFB899E8D08BA483B3AF997D01000007000000D880E0A170C53DB70140E0A170C53DB7000000000000000004D18BA470F0DB0238C14BB7C4D18BA440D18BA400000000CCD18BA440D18BA4C4D18BA49790C5980000803FD43DFDB6000000000000803F000000000000000000000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFFC8D18BA4C8D18BA48040959A219FF79800000000C2244B3A680000009CD28BA4 +W/google-breakpad(26491): S A48BD180 CCD18BA4ACD28BA4C4D18BA438C14BB7CCD18BA401000000D43DFDB60596C598F4D78BA49CD28BA4CCD18BA4F17FC598F4D78BA42B86C598000000FF404000000100B4000900000005000000F843369BDCD18BA440000000000000000000000000000000000000000000803F12000000CD4C0542D43DFDB6D43DFDB6D43DFDB650E74AB7C0DA42B784D68BA4800A49B738D38BA4C2244B3A38D38BA40E00000068D38BA40E00000050D28BA450D88BA4ACD38BA4F4D78BA4D43DFDB67564C598A0D38BA488D38BA4090000000500000000000000FFFFFFFF00000000FFFFFFFF06000000D43DFDB668D38BA4C2244B3A60D38BA4D43DFDB6A4D28BA4000000009CD88BA4C2244B3A00000000F4D78BA4A4D88BA4D43DFDB6F4D78BA40B72C5980000000000000000FFFFFFFFD0D28BA400000000FFFFFFFF0000000084D88BA468D38BA401000000F4D78BA418D38BA4000000002DB2C598B4D88BA48CD88BA494D88BA4FFFFFFFF0E0000000100000050D88BA45CD38BA468D38BA401000000 +W/google-breakpad(26491): S A48BD300 60D38BA4ACD38BA4F4D78BA459B2C59884D88BA43CD48BA450D88BA450D88BA450D88BA450D88BA450D88BA450D88BA4B8D28BA450D88BA450D88BA477BDC598F4D78BA484D88BA478D58B0084D88BA40000000001000000B8268D9A0E0000000000000006000000000000000600000000000000FFFFFFFF00000000FFFFFFFF090000000500000000000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000C843369BBCD38BA40004000000000000D8D98BA43CD58BA484D98BA4D43DFDB67564C59830D58BA418D58BA409000000050000000E000000010000000E0000000100000006000000D43DFDB6F8D48BA4C2244B3AF0D48BA4D43DFDB634D48BA40000000024DA8BA4C2244B3A0000000084D98BA42CDA8BA4C2244B3A84D98BA484D98BA434DA8BA420D58BA4D8D98BA4A8D48BA400000000FFFFFFFF000000000CDA8BA4F8D48BA40100000084D98BA4A8D48BA4000000002DB2C5983CDA8BA414DA8BA41CDA8BA4BB010000986D43B7E4D48BA4 +W/google-breakpad(26491): S A48BD480 D8D98BA4ECD48BA4F8D48BA401000000F0D48BA43CD58BA484D98BA459B2C5980CDA8BA4986D43B7C8D98BA40000000000000000C8D98BA4C8D98BA477BDC59848D48BA4D8D98BA4E8D98BA40000000000000000E8D98BA4E8D98BA477BDC59800000000FFFFFFFF000000001CDA8BA40000000001000000000000000000000000000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000C843369B5CD58BA40004000000000000D43DFDB600000000050000007CD58BA4D43DFDB6D43DFDB685B9C598480000000000000005000000380A4CB701000000C843369B9CD58BA40004000000000000A5833D9A800A49B7E850FDB60000000000000000BC50659A39ED2099780A49B7000000C0F0DA42B70000000001000000000000000100000000000000200843B7E850FDB6010000000100000084D68BA400000000F0DA42B779A0F89870D68BA4C2244B3A +W/google-breakpad(26491): S A48BD600 FEFFFFFF989946B7000000007D0100008B32649A91F22099709946B7A0D88BA4385E43B70000000080010000000000007D0100000000000000000000C2244B3AF8D88BA470D78BA4000000007D0100008B32649A8BF52099000000007D010000000070C10000000080010000000000007D010000C2244B3AFEFFFFFF989946B7000000007D0100008B32649A91F22099800A49B7000000006014389B0000000080010000000000007D010000FFFFFFFFFFFFFFFF000000000000000000000000F0DA42B700000000F0DA42B7D43DFDB6D43DFDB6C2244B3A08EE42B768D78BA430D78BA420D78BA410D78BA40000000068D78BA430D78BA420D78BA447F920990000000000000000800100007D0100000000000000000000800100007D0100000000000000000000800100000000000007000000A39025995CD78BA4385E43B77C9946B768D78BA460D78BA45CD78BA40100000027A82599709946B7385E43B74CC64E9B01000000B4D88BA40F0000000100000000000000B4D88BA401000000 +W/google-breakpad(26491): S A48BD780 90D88BA42D14F998B4D88BA46BE32099010000004DA42599AA9802000000000038C14BB7CCD78BA40500000048DC8BA401000000385B569A2F000000C2244B3A50D88BA468D88BA4F4D78BA450D88BA484D88BA4F4D78BA4F4D78BA468D88BA4F4D78BA4294DC598F4D78BA484D88BA4D43DFDB62844369B38C14BB70F0000000F00000068D88BA44CC64E9B0500000038C14BB748DC8BA468D88BA400000000686A4B9B48DC8BA44CD88BA4BB48C5986600000050D88BA468D88BA4E9C1369A000000007041989A807F000043DD0E996368726F6D653A2F2F637261736800A45ED88BA450D88BA468C14BB7A3D42099C2244B3A0000000047C14BB738C14BB701001044000000000600000000000000FFFFFFFF00000000FFFFFFFF090000000500000000000000FFFFFFFF0E0000000100000000000000FFFFFFFF00000000FFFFFFFF0000000000000000C2244B3AB8C23DB784DF40B77EC74C9B70DF40B748DC8BA46BD98BA448DD8BA4F903C49848DD8BA41DD1369A409D41B77983A198 +W/google-breakpad(26491): S A48BD900 B0C23DB700000000D43DFDB6A8C23DB7CCDB8BA448DC8BA47EC74C9BA0D98BA470DF40B76BD98BA43C4B3AB74F41379A01000000FFFFFFFFFFFFFFFF6BD98BA46CD98BA46CD98BA404000000E8DD8BA401000000385B569A21000000D43DFDB67CD98BA41CDA8BA47CD98B0000000000E8DD8BA44349C59894D98BA400000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF000000000000000000000000FFFFFFFF00000000F8D98BA410000000F8D98BA48DC49D9800000000F8D98BA400000000B548C59800000000000000004CDE8BA47BD9C498000000007DDAD62000000000D43DFDB618F348B70000000000D98BA4E8D98BA40003450100000000F8D98BA4F8D98BA400DA8BA400000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF0000000000000000C2244B3A60F348B76F2FA198800000000100000074DE8BA498DA8BA448DC8BA47132A198 +W/google-breakpad(26491): S A48BDA80 98DA8BA400000000D43DFDB6682F4BB7682F4BB773F91B99E4F248B7800000008000000001000000140000002E000000986D43B7DCDA8BA4090000004800000048DC8BA4385B569A2CDB8BA40C41EFA35441EFA3C2244B3A682F4BB7209C41B7D43DFDB6699C2F9A01000000C2244B3AB8C23DB7C2244B3AA8C23DB7C2244B3A682F4BB7682F4BB7089C41B7C7552F9AACDC8BA410000000E8DD8BA410000000E8DD8BA48DC49D98E8DD8BA46949C59874DE8BA4C2244B3A74DE8BA4FCDB8BA4682F4BB770DF40B748DC8BA4010000003C4B3AB7F903C498CCDB8BA4D335379A9935379A0100000000010000D43DFDB62E000000D43DFDB604DE8BA4D43DFDB600000000F776A298E705030008000000D43DFDB690D03BB714DE8BA410D83CB714DE8BA4E706A298F8B343B7000000C014DC8BA400B443B73CDC8BA4F93AFAB600B443B714DC8BA414DC8BA4A8C23DB7A4DF40B70E000000FFFFFFFFDCBC889AF3B6889A680300009935379AD43DFDB6D43DFDB665D6EB98A9D5EB98681C3EB7 +W/google-breakpad(26491): S A48BDC00 000000000000000090D23BB700000000BCE18BA400000000000000001000000000000000FFFFFFFF18000000010000001A0000002E00000000000000FFFFFFFF0000000001010000B8C24BB7070F699A17000000385B569A97C24BB788C24BB7010E699A000000000600000000000000FFFFFFFF00000000FFFFFFFF090000000500000000000000FFFFFFFF0E0000000100000000000000FFFFFFFF00000000FFFFFFFF000000000000000010094BB77DDAD6202E0000009DDD1B22E8084BB7E8084BB700DD8BA400000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF000000000000000001000000010000020500000001DE8BA400D13BB70037A298F4AE3CB7000000000000000024DD8BA424DD8BA400000000000000000000000000DF8BA4C2244B3AFCF732039200000048DD8BA448DD8BA400000000B335FAB6F55805212E000000FFFFFFFFFFFFFFFF0000000001000000 +W/google-breakpad(26491): S A48BDD80 0000000098664BB712000000385B569AECE08BA470664BB770664BB700C29D9800000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF0000000000000000C0664BB7000000001000000071B6A09898664BB798664BB70000000000000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF0000000000000000000000000000000000000000003DFDB678C63DB7DD7FB7FC3E652E00FFFFFFFFFFFFFFFF00C63DB700C93DB7D8E08BA4E706A298C2244B3A74DE8BA474DE8BA400000000000000000D03A298D43DFDB60100000034134AB704E28BA4D43DFDB6010000002C134AB704E28BA401000000E706A298000000000D03A298010000000100000000000000010000000001000000000000000000000D03A298200100009B3B2099D27CBA0004000000800C49B7840C49B7 +W/google-breakpad(26491): S A48BDF00 FBFFFFFFC2244B3A000000000000000038C63DB7D8D942B701000000CFB7379AD8D942B7C2244B3AD43DFDB6C2244B3A74C63DB7C2244B3A78C63DB701000000070000006B109F9868DF8BA438A43DB7D43DFDB66CC63DB774C63DB73D471F9930134AB70100000038A43DB730134AB701000000C2244B3A14000000C2244B3A01000000D43DFDB6BCE18BA428CA3DB70000000014000000010000000100000014000000CD7DA298C2244B3A5B7FA29800010000E78EA098D8D942B7C2244B3AD8D942B728E08BA414000000D3C0379A508E525462E60700000000000000000058A641B7EDCF379A625A92FC3E652E0014E08BA4C2244B3A08D740B7682F4BB76CC63DB728CA3DB738C93DB7D8E08BA444384D9B190F599AD43DFDB609481F99E9471F99682F4BB73CC63DB723891B9AECE08BA430863AB77A010100BDF4EB9830863AB7C2244B3A682F4BB7F0FB3DB728CA3DB7B7CD1C9AB5D31C9AC1D31C9AB5D31C9A3CC63DB7682F4BB7682F4BB7ECE08BA428CA3DB738C93DB7E5E4EB98 +W/google-breakpad(26491): S A48BE080 000000000000000000000000000000000000000000000000006642B70000000000000000C2244B3A00000000C2244B3AD43DFDB6C2244B3AD43DFDB634134AB7000000401F000000FE1BCFFB3D0000000F5C05212E00000000000000A8E18BA4E803000000E38BA4190F599A80CD4BB7A8E18BA4BCE18BA400E38BA479CD4BB768CD4BB7C2244B3A10E18BA400E38BA4BCE18BA468C74C9B0000000090E18BA400E38BA4190F599AA4E78BA455D59E98D43DFDB6FD97A098C2244B3A18E38BA4D43DFDB690D03BB70000000090D03BB701000000E706A298DCE68BA490D03BB7010000000000000000000000660E599A010000000000000002E430F48F03A29800E38BA4C2244B3A01000000C2244B3A11D0EB98C2244B3A00000000C2244B3AA0C23DB7000000C000000000A8C23DB701000000C2244B3A20134AB7000000000000000090D23BB70000000004E58BA40000000000DC8BA414A43DB7D0E68BA4D43DFDB600E38BA404E28BA40100000000E38BA40000000000000000E39DA098 +W/google-breakpad(26491): S A48BE200 D43DFDB620134AB78CE78BA403000000FFFFFFFF38E28BA490D03BB70000000090D03BB703C19D980000000080D03BB7D43DFDB67792A09890D03BB72E00000018023EB7A57D1B9A58EA2A9B571F819A5401000059901B9A000000000B000000000000000B000000000000000B00000000010000C2244B3A60A94AB7D0E28BA4189849B7DCE68BA40CE78BA4C59F9E982E000000B8E28BA4B8E28BA4212EA1981500000079A3A09808054BB7D4E28BA401000000C2244B3A08E38BA4D0E68BA400E38BA46235E020DCE68BA46D9EA098D0E68BA400E38BA400000000D0E68BA400E38BA46235E020DCE68BA40CE78BA460D13BB7000000000000000055B2A09848503CB7030000000F5C05212E0000000000000000000000502F4BB7F5CAEB9804C2949A19E3629A5C00000011D0EB98F20000000100000048D13BB7D0E68BA46235E0202E000000010000009BB8A098D43DFDB6D43DFDB66235E0202E0000006D363600000000000001000090083EB7A8FA3DB7080000000000000008000000 +W/google-breakpad(26491): S A48BE380 000100000500000028AE3DB7F0E38BA41CE48BA44CE48BA4E8CF3DB7F0E38BA4A8FA3DB76F7F9F989D571F994798379A04000000D86DF800AC2B989AD43DFDB6000000006C40549A010000000000000060E83CB725AE379A5B76379A000000005B76379A000000005B76379A00000000E8CF3DB701B5379A00000000C4A33DB7C8A33DB72CE48BA403000000C2244B3ADCE48BA4D43DFDB6D0E68BA4C0E58BA430E68BA4F8E7889A6CE58BA400E68BA40100000011ACA09830E68BA4FFB5A298C2244B3AD0E68BA4D0E68BA40600000000000000060000000001000089083BB770083BB7A0E48BA4D8043EB7D8043EB734C83DB70600000000000000060000000001000080FE3AB74CC64E9B0300000008583BB7B8E48BA4DCE48BA434C83DB704C83DB7B8E48BA4D43DFDB615B0379A80FE3AB70100000000000000000000000000000000000000000000000000000000000000000000000000000028583BB76CC63DB7E8E48BA400000000C2244B3A04E58BA430E58BA4C0E58BA48381A198 +W/google-breakpad(26491): S A48BE500 30E68BA4000000000000000090D23BB7000000000000000000000000BCE18BA4C2244B3AD0E68BA4A8E58BA4D996A098D0E68BA40000000001000000010001000000000030E58BA4D0E68BA413ED389A0100000084168D9A9CE68BA40100000000000000D43DFDB60C000000B4E88BA4000000000000000000000000000000000000000000000000000000000000000058203E9B8DE58BA46A5C05212E00000048CF3BB770245C0028833E9B00000000A8E58BA4A8E58BA4000000000000000000000000008000000000000090FF3AB7B0003BB730023BB70A000000A7C4589A0000000088993DB738FB3AB704E68BA404E68BA4A7719F9831FB3AB720FB3AB728BB359B00E68BA420E68BA478E83CB720E68BA404E68BA404E68BA4FFFFFFFF00000000000000000000000000000000C81D3E9B01000000C09C3DB7E8823E9B010001B700000000D0B33DB709670000D8B63DB70967000000FA3AB7382D3BB78C3B989AB0023DB7FCF93AB7E8F93AB73CC63DB700000000FFFFFFFF08000000 +W/google-breakpad(26491): S A48BE680 09000000FFFFFFFF00000000C2244B3AFFFFFFFFD43DFDB6D43DFDB6A7C4589A00000000BCE88BA4B4E88BA4BD569F989CE68BA4656E2D5553008BA401000000C8E98BA4B9E68BA4B4E68BA4656E2D5520B9359B48D13BB700000000E06343B7A86343B7186443B7349F44B7E06343B7A86343B7186443B7349F44B7C89E44B7260000000000000000000000189849B7C09849B7989B49B70000000013E78BA46235E0202E00000038D03AB738D03AB7A8D03AB73C083BB738D03AB738D03AB7A8D03AB73C083BB730083BB7080000000000000028C941B73CC941B748C941B700000000000000000000000000000000D4E78BA4DFA19D98D4E78BA46CE78BA46CE78BA40000000030E58BA420134AB708A43DB714A43DB718A43DB7000000000000000098E78BA480D03BB7304C3DB720D13BB7FFC49D98D43DFDB6C2244B3ABCE88BA4BCE88BA4384B3AB702000000D43DFDB6B4E88BA410000000D8CC4A9BC071D1127B24549AD4E78BA4D43DFDB6D43DFDB6F776A2980100000001000000 +W/google-breakpad(26491): S A48BE800 C2244B3ACD7DA298C2244B3A5B7FA29807000000080000001809D873C2244B3A1809D87394EA8BA45CE88BA494EA8BA45CE88BA48DE418B5883E989AD43DFDB60C3E3CB700000000FF0100005B8C08B594EA8BA490420FB70000000098383AB730413AB790420FB798383AB7430000005500000000000000983A2CB504000000013DFDB6C2244B3A4E051000C2244B3AD4E88BA438C03CB7B4E88BA4D43DFDB6BCE88BA4382D3BB7C04EC212B725549A9CE88BA4382D3BB70000000072656E6465726572001C549AD43DFDB6C4E88BA4BCE88BA4747970650000000042FA3AB730FA3AB7D8E88BA4D4E88BA479B60AB554E98BA4A852FDB600000000D8E98BA450E98BA454E98BA458E98BA4604D0FB70300000098383AB70000000021B524B540E98BA444E98BA4000000000100000057EBC4A428000000010000001A00000038C03CB703000000609AD412B335FAB60000FDB628000000000000006FC74C9BD43DFDB6609AD41298383AB7C2244B3AC071D112C2244B3A38C03CB73CC24E9B +W/google-breakpad(26491): S A48BE980 38C03CB76FC74C9BD43DFDB6609AD41298383AB7CD1F549A30413AB7C8422DB5C0EA8BA400EA8BA42757000018EA8BA438EA8BA4D43DFDB6604D0FB700000000E0EA8BA420EA8BA4384B3AB70000000058EA8BA484EA8BA4000000000000000000000000FC9329B5109429B530413AB708EA8BA484EA8BA440C0D7734300000000000000010000000075D01298383AB7010000000700000098383AB730413AB790420FB798383AB7430000004300000000000000C04EC21220422DB501413AB79796ACA401000000C8EA8BA4C8EA8BA400EB8BA4000000000000000000000000090000000000000018EA8BA40000000001000000000000000000430000005500090000000000430038EA8BA4C2244B3A005AC712AF010000005AC712B808DA7305000000609AD41298383AB75B64D5A46808DA7300000000010000000075D0120000000040C0D77384EA8BA400000000C2244B3A005AC712B808DA7305000000609AD412C04EC212C071D112A978DCA4B808DA73005AC71240C0D77305000000 +W/google-breakpad(26491): S A48BEB00 609AD412005AC71240C0D7738D59DCA440C0D773804FC2120F000000D43DFDB6609AD41204000000FF0100000000000000000000A09C29B544A429B500A429B500000000409AD412609AD41204000000FF010000000000000000000001000000000000000100000001000000B0420FB790420FB7C071D112804FC212A08BBA6FF8EB8BA400000000C0EB8BA40D3C0F72A08BBA6FE4EB8BA4D43DFDB630413AB7B0EB8BA460EC8BA4E0EB8BA4093B07B500000000804FC21220A90EB7D43DFDB6A08BBA6F1C393AB798383AB7A08BBA6F78EC8BA4E1711BB560EC8BA42C298070040000002C29807060EC8BA4D43DFDB698383AB7430000000000000000000000000000000000000001000000FFFFFFFF8B000000C2244B3AA0423AB730413AB70000000060EC8BA448EC8BA440ED8BA460ED8BA4804FC2122C29807039431FB560EC8BA42C29807078EC8BA47DADF8B610000000450FD9B5010000000F00000000000000000000002C298070010000000400000078EC8BA4804FC21203000000 +W/google-breakpad(26491): S A48BEC80 0051FDB6B335FAB60000FDB6C2244B3ABCEC8BA428F839B7D43DFDB6D8ED8BA428ED8BA4E86F2DB560ED8BA4092E22B510F839B7000000C00000000018F839B728ED8BA418F839B70000000098383AB788712DB504FDFFFFE86F2DB540ED8BA44300000021AB20B500000000000000000000000000000000000000000000000000000000405B2DB5D43DFDB638ED8BA4109C29B5DC9429B5109C29B5FC9329B5109429B50000000001000000000000000000000000005500000000000000550098383AB730413AB790420FB798383AB7430000005500000000000000000000000000430078000000E03E3AB7051BF9B6FFFFFFFF000000000000000000000000210000001000000018F839B7C2244B3AFFFFFFFFD83E3AB7183F3AB7D83E3AB778000000E03E3AB7E03E3AB789E8F8B6D0ED8BA4A9E8F8B689E8F8B6E03E3AB789E8F8B67DC8F8B6D0ED8BA400000000D0ED8BA4D83E3AB7160000000000000000000000C2244B3A1C3F3AB70000000000000000000000000000000000000000 +W/google-breakpad(26491): S A48BEE00 000000000000000098383AB70000000000000000A0433AB7000000000000000000000000C8083BB7187A3CB788053DB730FF3BB7107A3EB70100000018293BB730A241B700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +W/google-breakpad(26491): S A48BEF80 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +W/google-breakpad(26491): C 0600004050D88BA42F000000010000000000000050D88BA468D88BA4686A4B9B48DC8BA44CD88BA401000000D43DFDB648DD8BA4F3A19D9840D88BA4F9C1369A96A9369A300000680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +W/google-breakpad(26491): M 987AB000 00000000 02BAF000 76304586D0CD2C8FF899C602BF1756A20 libchromeshell.so +W/google-breakpad(26491): M 9B35A000 00000000 0015C000 000000000000000000000000000000000 RELRO:libchromeshell.so (deleted) +W/google-breakpad(26491): M 9B4B6000 02D0A000 00016000 000000000000000000000000000000000 libchromeshell.so +W/google-breakpad(26491): M A47A3000 00000000 00011000 AC480D966558562B46D4583A55D904E60 libchromium_android_linker.so +W/google-breakpad(26491): M AC35D000 00000000 00003000 932CC9935B065A05D39E38681E0A5F2E0 libwebviewchromium_loader.so +W/google-breakpad(26491): M AC360000 00000000 00010000 E2C6CBE7D4588EF8111B01903B27FEA80 libandroid.so +W/google-breakpad(26491): M AC370000 00000000 00142000 83D249BAACD2F2C10C13B70C1F64252C0 libGLESv2_adreno.so +W/google-breakpad(26491): M AC4B3000 00000000 00034000 58A32EAAFDADB17139F988E96B860C8E0 libGLESv1_CM_adreno.so +W/google-breakpad(26491): M AC4E7000 00000000 00034000 C71008FE91C209D6D5E9EA5DBB44BF080 libgsl.so +W/google-breakpad(26491): M AC51B000 00000000 0002A000 134B50AAA945C8C16B0021DF014AA6150 libEGL_adreno.so +W/google-breakpad(26491): M ACE37000 00000000 00018000 9D372357993C7650365479A34E676E290 libjavacrypto.so +W/google-breakpad(26491): M ACE4F000 00000000 00009000 0D2147262F4305E3AED211CB96FC96BA0 librs_jni.so +W/google-breakpad(26491): M ACE58000 00000000 00006000 3F276EEAE72C2C9FC768FF2E482957510 libaudioeffect_jni.so +W/google-breakpad(26491): M ACE5E000 00000000 00004000 CDA9BA072D4DECC71C5E63467275E7EE0 libsoundpool.so +W/google-breakpad(26491): M ACE62000 00000000 0000E000 D02CB251CF8787A770DE2CFDC52A2B040 libstagefright_amrnb_common.so +W/google-breakpad(26491): M ACE70000 00000000 0001B000 F59669C665FE4B073886A8DAAECEA86F0 libvorbisidec.so +W/google-breakpad(26491): M ACE8B000 00000000 00004000 9FC00D0B150FE9FC57763A76206D1D550 libstagefright_yuv.so +W/google-breakpad(26491): M ACE90000 00000000 0001F000 C2D6408786A8582A0EAE64D047577F800 libstagefright_omx.so +W/google-breakpad(26491): M ACEAF000 00000000 00003000 E11DA546CE9E08D1D647E8E1135DAD810 libstagefright_enc_common.so +W/google-breakpad(26491): M ACEB2000 00000000 00007000 741CC494F5299870A1C62FD71E37AE5F0 libstagefright_avc_common.so +W/google-breakpad(26491): M ACEB9000 00000000 00005000 D3EA22EB9F383751AB500AE5951F0DB30 libpowermanager.so +W/google-breakpad(26491): M ACEBE000 00000000 0003C000 F19A7DFF3B6F3AF94EAE23CA21905BAD0 libopus.so +W/google-breakpad(26491): M ACEFA000 00000000 0001B000 87AFCC5E47ED503148F1AA03777E88590 libdrmframework.so +W/google-breakpad(26491): M ACF16000 00000000 00114000 A0D663218D972496B104B7B9FF0727BD0 libstagefright.so +W/google-breakpad(26491): M AD02A000 00000000 00016000 55B5F5E024DB37CABEC6A8F31DD950870 libmtp.so +W/google-breakpad(26491): M AD040000 00000000 0000B000 D2AB743CCCD8D2EB9B66A47707CC1E530 libjhead.so +W/google-breakpad(26491): M AD04C000 00000000 0002C000 4D1E2F0F58012FABA091A21E4CEEFFE20 libexif.so +W/google-breakpad(26491): M AD078000 00000000 0003C000 20D19E07A0CA5B5790EEB83C8F6915570 libmedia_jni.so +W/google-breakpad(26491): M AFE8A000 00000000 00003000 8FF5949AE957364C270D0F448DAD4FE20 libjnigraphics.so +W/google-breakpad(26491): M AFE8D000 00000000 00008000 F2B1298EE4C6EA0900CDACD17FB5C16B0 libcompiler_rt.so +W/google-breakpad(26491): M AFE95000 00000000 00004000 37FA52E92BF716E0268B9619EE8D61630 libadreno_utils.so +W/google-breakpad(26491): M AFE9B000 00000000 00003000 F36630BD0C6DC4B52A0E5D5D57BE682A0 memtrack.msm8960.so +W/google-breakpad(26491): M B15AB000 00000000 00038000 FE4EB304B0639D600DFB5871136831C50 libjavacore.so +W/google-breakpad(26491): M B4FC8000 00000000 00009000 CF0326786BDECFB45A519C7005E851000 libbacktrace_libc++.so +W/google-breakpad(26491): M B4FD2000 00000000 00304000 3E343A5B3F9534F5E40AD9BEAC46C8E80 libart.so +W/google-breakpad(26491): M B52F9000 00000000 00004000 3CBDF0DE27B9554508AD60FDC96CBC620 libusbhost.so +W/google-breakpad(26491): M B52FD000 00000000 00041000 36F280D15D51F4EEFA92279E8BBD84360 libssl.so +W/google-breakpad(26491): M B533E000 00000000 0005F000 D02DDA779C053EF3CC279A1E1789C4250 libsqlite.so +W/google-breakpad(26491): M B539E000 00000000 0000F000 F954BA248E12C9AF32F54434F977FEF80 libsoundtrigger.so +W/google-breakpad(26491): M B53AD000 00000000 0000E000 125671BDF56FEE67902BE338575373000 libselinux.so +W/google-breakpad(26491): M B53BB000 00000000 00004000 4E6C8C876BA563C3C4B0B3BA562093920 libprocessgroup.so +W/google-breakpad(26491): M B53BF000 00000000 0045B000 83C5B450634DDB5C4FC41CA61A35B3740 libpdfium.so +W/google-breakpad(26491): M B581F000 00000000 00004000 56B149396A4DAF176E26B4A85DA87BF30 libnetd_client.so +W/google-breakpad(26491): M B5823000 00000000 00007000 A20D742D5BF711D12587563B5C4BF64A0 libnativehelper.so +W/google-breakpad(26491): M B582A000 00000000 00004000 495F8887F27909EE1E3E69A657E0A9AB0 libnativebridge.so +W/google-breakpad(26491): M B582E000 00000000 0000C000 31B45FE1FA6CC789F945332C6FECF9750 libminikin.so +W/google-breakpad(26491): M B583A000 00000000 00003000 CCA8BE0D07D24523C8D02FEE5F724EA70 libmemtrack.so +W/google-breakpad(26491): M B583D000 00000000 00015000 60A6E0B998632198B80EB0941121CD710 libstagefright_foundation.so +W/google-breakpad(26491): M B5852000 00000000 00051000 6E42AB0836D73C21533C08A98EE7B24C0 libsonivox.so +W/google-breakpad(26491): M B58A8000 00000000 0000F000 E43E7FA869E4BCDAA3CC9601DF5A6A520 libcommon_time_client.so +W/google-breakpad(26491): M B58B7000 00000000 0000A000 C84019C90BCA7E95A773B5A75A460D880 libnbaio.so +W/google-breakpad(26491): M B58C1000 00000000 0009A000 895A37F76D93E51B0ED7E90E5B71A9330 libmedia.so +W/google-breakpad(26491): M B595B000 00000000 0003C000 C5323479053FDA41E355482925A30D120 libinputflinger.so +W/google-breakpad(26491): M B5997000 00000000 0001B000 74F168649BE8583159D23A6406D107740 libinput.so +W/google-breakpad(26491): M B59B2000 00000000 0000F000 41712F8718C430707F8CEE5532CB59200 libimg_utils.so +W/google-breakpad(26491): M B59C1000 00000000 00032000 89A4F06810290EEAF309C12642A3ECFA0 libjpeg.so +W/google-breakpad(26491): M B59F4000 00000000 0022F000 65E6AAFD915FB244BFE6BE6C4E5E3EC40 libskia.so +W/google-breakpad(26491): M B5C28000 00000000 0001D000 23FBB5490C5DBF1E99CD76AC2AA151410 libRScpp.so +W/google-breakpad(26491): M B5C45000 00000000 00028000 3BFE44EFE288C7A1AD7BE317B9F1BDBC0 libpng.so +W/google-breakpad(26491): M B5C6D000 00000000 0005A000 659F1470013A04F7702E4BAB65F034E70 libft2.so +W/google-breakpad(26491): M B5CC7000 00000000 0003D000 FB93884C5EC21F71C68861C20993EB6C0 libbcinfo.so +W/google-breakpad(26491): M B5D04000 00000000 00023000 21B734672A14ED6267B966640C16823E0 libbcc.so +W/google-breakpad(26491): M B5D47000 00000000 00094000 BE6F28596E6CE20F5E49A9E0BC824DA00 libc++.so +W/google-breakpad(26491): M B5DDD000 00000000 00938000 377A25164D6ACDC0F7A38F5E378EC8670 libLLVM.so +W/google-breakpad(26491): M B671C000 00000000 0003A000 8D7E15A890FAF52D874044C9F02C6D130 libRS.so +W/google-breakpad(26491): M B6756000 00000000 0004C000 670166E37528A7F183D1B05F52020ABD0 libhwui.so +W/google-breakpad(26491): M B67A2000 00000000 00110000 1B1FD653750DE88B86D7E83095EE37160 libicuuc.so +W/google-breakpad(26491): M B68B6000 00000000 00006000 F4F99E4A6E63BF8C8005D96B2BAC8CEB0 libgabi++.so +W/google-breakpad(26491): M B68BC000 00000000 00167000 237F53C12084A7F42405B410FDE8B4020 libicui18n.so +W/google-breakpad(26491): M B6A23000 00000000 00048000 AC5AE16EC01F4362C8E63DF66565090D0 libharfbuzz_ng.so +W/google-breakpad(26491): M B6A6B000 00000000 00005000 254351EC49125FE3A72F78EAB38381410 libwpa_client.so +W/google-breakpad(26491): M B6A70000 00000000 00007000 F8BA9819E3B7FA0BE155985B6C09FC570 libnetutils.so +W/google-breakpad(26491): M B6A77000 00000000 00006000 C08391F010B5A32265D4D781325FFCEE0 libhardware_legacy.so +W/google-breakpad(26491): M B6A7E000 00000000 00017000 B98E65710C415C83E972EBDC1EB52AC00 libexpat.so +W/google-breakpad(26491): M B6A95000 00000000 00102000 E26A420F0A5BCD2AC04E9B7B19F67C3D0 libcrypto.so +W/google-breakpad(26491): M B6B99000 00000000 00003000 914425D16565257955F7E1574360B71F0 libhardware.so +W/google-breakpad(26491): M B6B9C000 00000000 0000C000 4F3E1A188AE72585AF4278E4FA5266730 libui.so +W/google-breakpad(26491): M B6BA8000 00000000 00003000 2D9083CB8C22C02E1412DA13B1CA43AE0 libsync.so +W/google-breakpad(26491): M B6BAB000 00000000 0004F000 559E784386AC5E53A9D4D7F9916AA7F90 libgui.so +W/google-breakpad(26491): M B6BFA000 00000000 00008000 D8696CD80D9B725AFEA007DFCE2562E60 libcamera_metadata.so +W/google-breakpad(26491): M B6C02000 00000000 0003A000 116B760482930C77445ABAC1A3276D0B0 libcamera_client.so +W/google-breakpad(26491): M B6C3C000 00000000 00006000 AC1D054A26491BE96E8BCCB1E5F2926F0 libspeexresampler.so +W/google-breakpad(26491): M B6C42000 00000000 00006000 D330B25521C028B95D7E9360F7C6D6510 libaudioutils.so +W/google-breakpad(26491): M B6C48000 00000000 0001A000 03AD92B0BEDAA751C0016E97AE374CAE0 libz.so +W/google-breakpad(26491): M B6C62000 00000000 00030000 AC6C388A36224541CD74B35818111B760 libbinder.so +W/google-breakpad(26491): M B6C92000 00000000 00028000 102764B5F4D4D6F6F1A0C7360182BDEE0 libandroidfw.so +W/google-breakpad(26491): M B6CBA000 00000000 0000B000 E2F67EE50006FD0ED1482E1463C5CCFF0 libGLESv2.so +W/google-breakpad(26491): M B6CC5000 00000000 00007000 EFE6AB19F4060BCECF8CF0E68958C2F60 libGLESv1_CM.so +W/google-breakpad(26491): M B6CCC000 00000000 00004000 C91EAF69D18F0D499BD58532BBA173690 libETC1.so +W/google-breakpad(26491): M B6CD0000 00000000 00004000 7AE0C00FAEDEA3E81109CC784D49A6960 libunwind-ptrace.so +W/google-breakpad(26491): M B6CD4000 00000000 0000E000 EF89B10946BDF6079AAF789F56192FDA0 libunwind.so +W/google-breakpad(26491): M B6D28000 00000000 00007000 3874D35A672DF92604963290963F44990 libgccdemangle.so +W/google-breakpad(26491): M B6D31000 00000000 00008000 45B51BF91D330E793C9142C2617D7A8E0 libbacktrace.so +W/google-breakpad(26491): M B6D3A000 00000000 00018000 4939CC7D9325757DDAB52A218D55F4720 libutils.so +W/google-breakpad(26491): M B6D52000 00000000 0003B000 2FE003E5119C67BABE1A9FAB459A5A5D0 libstlport.so +W/google-breakpad(26491): M B6D8D000 00000000 0000D000 8AE85E0A2B96C0006F4BC72D01BDB7BD0 libcutils.so +W/google-breakpad(26491): M B6D9B000 00000000 00071000 A12BAF7D82BE28EC681730452D351E880 libGLES_trace.so +W/google-breakpad(26491): M B6E0C000 00000000 00068000 924D4C5446BF1132A902C15519E5C4FD0 libEGL.so +W/google-breakpad(26491): M B6E77000 00000000 000DC000 EE75A142ED1607624B6579D4590DD7CB0 libandroid_runtime.so +W/google-breakpad(26491): M B6F53000 00000000 00004000 DFCD7772F3A5BD1E84A50C4DBFDE6F570 libstdc++.so +W/google-breakpad(26491): M B6F57000 00000000 00019000 AE3467401278371A956801500FC8187D0 libm.so +W/google-breakpad(26491): M B6F71000 00000000 00007000 0A492DEF82842051996A468D87F23F010 liblog.so +W/google-breakpad(26491): M B6F79000 00000000 0005A000 10EC186B04E97F6A24DAA891779479380 libc.so +W/google-breakpad(26491): M B6FDD000 00000000 00003000 D773C773634B82249E887ECBC5D28C900 libsigchain.so +W/google-breakpad(26491): -----END BREAKPAD MICRODUMP----- +W/google-breakpad(26354): ### ### ### ### ### ### ### ### ### ### ### ### ### +W/google-breakpad(26354): Chrome build fingerprint: +W/google-breakpad(26354): Developer Build +W/google-breakpad(26354): 1 +W/google-breakpad(26354): ### ### ### ### ### ### ### ### ### ### ### ### ### +--------- beginning of crash +F/libc (26354): Fatal signal 11 (SIGSEGV), code 1, fault addr 0x0 in tid 26375 (CrRendererMain) +D/audio_hw_primary( 195): disable_audio_route: reset and update mixer path: low-latency-playback +D/audio_hw_primary( 195): disable_snd_device: snd_device(2: speaker) +I/DEBUG (17356): *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** +I/DEBUG (17356): Build fingerprint: 'google/occam/mako:5.0/LRX21J/1543521:userdebug/dev-keys' +I/DEBUG (17356): Revision: '10' +I/DEBUG (17356): ABI: 'arm' +I/DEBUG (17356): pid: 26354, tid: 26375, name: CrRendererMain >>> org.chromium.chrome.shell:sandboxed_process0 <<< +I/DEBUG (17356): signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x0 +I/DEBUG (17356): r0 a48bd850 r1 0000002f r2 00000001 r3 00000000 +I/DEBUG (17356): r4 a48bd850 r5 a48bd868 r6 9b4b6a68 r7 a48bdc48 +I/DEBUG (17356): r8 a48bd84c r9 00000001 sl b6fd3dd4 fp a48bdd48 +I/DEBUG (17356): ip 989da1f3 sp a48bd840 lr 9a36c1f9 pc 9a36a996 cpsr 68000030 +I/DEBUG (17356): +I/DEBUG (17356): backtrace: +I/DEBUG (17356): #00 pc 01bbf996 /data/app/org.chromium.chrome.shell-1/lib/arm/libchromeshell.so +I/DEBUG (17356): +I/DEBUG (17356): Tombstone written to: /data/tombstones/tombstone_00 +W diff --git a/src/processor/testdata/symbols/microdump/libchromeshell.so/76304586D0CD2C8FF899C602BF1756A20/libchromeshell.so.sym b/src/processor/testdata/symbols/microdump/libchromeshell.so/76304586D0CD2C8FF899C602BF1756A20/libchromeshell.so.sym new file mode 100644 index 00000000..70f1589c --- /dev/null +++ b/src/processor/testdata/symbols/microdump/libchromeshell.so/76304586D0CD2C8FF899C602BF1756A20/libchromeshell.so.sym @@ -0,0 +1,249 @@ +MODULE Linux arm 76304586D0CD2C8FF899C602BF1756A20 libchromeshell.so +FILE 46 /s/chrome-brkpad/src/out/Debug/../../base/bits.h +FILE 47 /s/chrome-brkpad/src/out/Debug/../../base/build_time.cc +FILE 48 /s/chrome-brkpad/src/out/Debug/../../base/callback.h +FILE 177 /s/chrome-brkpad/src/out/Debug/../../base/memory/weak_ptr.h +FILE 178 /s/chrome-brkpad/src/out/Debug/../../base/message_loop/incoming_task_queue.cc +FILE 179 /s/chrome-brkpad/src/out/Debug/../../base/message_loop/message_loop.cc +FILE 183 /s/chrome-brkpad/src/out/Debug/../../base/message_loop/message_pump.cc +FILE 184 /s/chrome-brkpad/src/out/Debug/../../base/message_loop/message_pump_android.cc +FILE 185 /s/chrome-brkpad/src/out/Debug/../../base/message_loop/message_pump_default.cc +FILE 272 /s/chrome-brkpad/src/out/Debug/../../base/rand_util.cc +FILE 273 /s/chrome-brkpad/src/out/Debug/../../base/rand_util_posix.cc +FILE 274 /s/chrome-brkpad/src/out/Debug/../../base/run_loop.cc +FILE 275 /s/chrome-brkpad/src/out/Debug/../../base/safe_strerror_posix.cc +FILE 384 /s/chrome-brkpad/src/out/Debug/../../base/tracking_info.h +FILE 385 /s/chrome-brkpad/src/out/Debug/../../base/tuple.h +FILE 2458 /s/chrome-brkpad/src/out/Debug/../../content/app/android/content_main.cc +FILE 2459 /s/chrome-brkpad/src/out/Debug/../../content/app/android/library_loader_hooks.cc +FILE 2460 /s/chrome-brkpad/src/out/Debug/../../content/app/content_main_runner.cc +FILE 3100 /s/chrome-brkpad/src/out/Debug/../../content/child/child_shared_bitmap_manager.cc +FILE 3101 /s/chrome-brkpad/src/out/Debug/../../content/child/child_thread.cc +FILE 3102 /s/chrome-brkpad/src/out/Debug/../../content/child/child_thread.h +FILE 3103 /s/chrome-brkpad/src/out/Debug/../../content/child/content_child_helpers.cc +FILE 3366 /s/chrome-brkpad/src/out/Debug/../../content/common/message_router.cc +FILE 3398 /s/chrome-brkpad/src/out/Debug/../../content/common/ssl_status_serialization.cc +FILE 3402 /s/chrome-brkpad/src/out/Debug/../../content/common/user_agent.cc +FILE 3403 /s/chrome-brkpad/src/out/Debug/../../content/common/utility_messages.h +FILE 3808 /s/chrome-brkpad/src/out/Debug/../../content/renderer/render_frame_impl.cc +FILE 3822 /s/chrome-brkpad/src/out/Debug/../../content/renderer/renderer_blink_platform_impl.cc +FILE 3823 /s/chrome-brkpad/src/out/Debug/../../content/renderer/renderer_clipboard_client.cc +FILE 3824 /s/chrome-brkpad/src/out/Debug/../../content/renderer/renderer_main.cc +FILE 4111 /s/chrome-brkpad/src/out/Debug/../../ipc/ipc_channel_handle.h +FILE 4112 /s/chrome-brkpad/src/out/Debug/../../ipc/ipc_channel_posix.cc +FILE 4113 /s/chrome-brkpad/src/out/Debug/../../ipc/ipc_channel_proxy.cc +FUNC 241df8 4 0 xsltStrxfrm +FUNC 241dfc 1c 0 base::debug::StackTrace::StackTrace +242378 2 1361 76 +24237a 22 1361 76 +24239c 10 26 75 +FUNC 2423ac 1fc 0 base::debug::TaskAnnotator::RunTask +2423b6 2 31 75 +24254a 4 60 75 +24254e 6 401 48 +25e6bc c 208 179 +FUNC 25e6c8 1a 0 base::MessageLoop::Run +25e6c8 4 306 179 +25e6cc 6 307 179 +25e6d2 6 308 179 +25e6d8 6 308 179 +FUNC 25ed20 128 0 base::MessageLoop::RunTask +25ed20 c 432 179 +25ed2c 2 432 179 +25edca 6 444 179 +25edd0 12 447 179 +25ede2 a 192 16276 +FUNC 25ee48 140 0 base::MessageLoop::DeferOrRunPendingTask +25ee48 4 454 179 +25ee4c 4 455 179 +25ee64 8 456 179 +25ee6c 6 459 179 +25ee72 a 672 16220 +25ee88 14 1061 16220 +25fb9e 1e 372 179 +FUNC 25fbbc 70 0 base::MessageLoop::RunHandler +25fbfc 6 405 179 +25fc02 8 415 179 +25fc0a 6 415 179 +FUNC 2601e2 98 0 base::MessageLoop::DoWork +2601e2 4 544 179 +26023a 2 562 179 +26023c 8 563 179 +260244 8 563 179 +26024c c 565 179 +260258 8 566 179 +26031c 8 158 179 +FUNC 260840 104 0 base::MessagePumpDefault::Run +26088e 4 36 185 +260892 8 32 185 +26089a 2 33 185 +26d14a 1e 92 274 +FUNC 26d168 30 0 base::RunLoop::Run +26d168 4 47 274 +26d17c 6 54 274 +26d30c 6 43 314 +26d312 6 12 280 +71338c 6 420 4113 +713392 1e 421 4113 +FUNC 7133b0 188 0 IPC::ChannelProxy::Context::OnDispatchMessage +7134ce 4 270 4113 +7134d2 8 271 4113 +7134da a 274 4113 +FUNC a497e8 26 0 content::MessageRouter::RouteMessage +a497e8 2 49 3366 +a497ea 2 49 3366 +a497f6 8 50 3366 +a497fe 2 51 3366 +a49800 8 54 3366 +1a0d70a a 96 357 +FUNC 1a0d714 264 0 content::ChildThread::OnMessageReceived +1a0d714 2 464 3101 +1a0d918 a 502 3101 +1bbf942 6 92 3807 +1bbf948 6 92 3807 +1bbf976 1e 95 3807 +FUNC 1bbf994 6 0 content::::CrashIntentionally +1bbf994 6 267 3808 +1bc116c 6 156 16266 +1bc1172 1e 1484 3808 +FUNC 1bc1190 19c 0 content::::MaybeHandleDebugURL +1bc11ee 6 309 3808 +1bc11f4 4 310 3808 +1bc11f8 10 311 3808 +FUNC 1bc2102 106 0 content::RenderFrameImpl::PrepareRenderViewForNavigation +1bc2102 8 4007 3808 +1bc210a 2 4008 3808 +1bc210c 4 4009 3808 +1bc2110 8 4007 3808 +1bc2118 4 4008 3808 +FUNC 1bc8324 c7c 0 content::RenderFrameImpl::OnMessageReceived +1bc8324 c 854 3808 +1bc8330 2 860 3808 +1bc85be 8 378 3264 +1bc85c6 4 378 3264 +1bc85ca 8 548 385 +1bc85d2 a 80 385 +FUNC 1bc909c 7e0 0 content::RenderFrameImpl::OnNavigate +1bc909c c 925 3808 +1bc912c 2 932 3808 +1bc912e 20 936 3808 +1bc914e 6 933 3808 +1bc91be 12 945 3808 +FUNC 1be39f8 3ec 0 content::RendererMain +1be39f8 12 103 3824 +1be3d0e 4 235 3824 +1be3d12 c 236 3824 +1be3d1e 6 225 3824 +1d96e7e 2 248 169 +1d96e80 2c 54 2458 +FUNC 1d96eac 17c 0 content::Start +1d96fc6 2 48 2458 +1d96fc8 4 48 2458 +1d96fcc 2 1464 76 +1d973f8 28 822 2460 +FUNC 1d97420 fc 0 content::RunNamedProcessTypeMain +1d97420 c 386 2460 +1d9746e e 423 2460 +1d9747c c 411 2460 +1d97488 8 417 2460 +1d974e4 38 440 2460 +FUNC 1d9751c d0 0 content::ContentMainRunnerImpl::Run +1d9751c e 772 2460 +1d975b2 6 789 2460 +1d975b8 6 156 16266 +STACK CFI INIT 242330 7c .cfa: sp 0 + .ra: lr +STACK CFI INIT 2423ac 1fc .cfa: sp 0 + .ra: lr +STACK CFI 2423b0 .cfa: sp 36 + .ra: .cfa -4 + ^ r10: .cfa -12 + ^ r11: .cfa -8 + ^ r4: .cfa -36 + ^ r5: .cfa -32 + ^ r6: .cfa -28 + ^ r7: .cfa -24 + ^ r8: .cfa -20 + ^ r9: .cfa -16 + ^ +STACK CFI 2423b2 .cfa: sp 208 + +STACK CFI INIT 25e6bc c .cfa: sp 0 + .ra: lr +STACK CFI INIT 0 18 .cfa: sp 0 + .ra: lr +STACK CFI INIT 25e6c8 1a .cfa: sp 0 + .ra: lr +STACK CFI 25e6ca .cfa: sp 8 + .ra: .cfa -4 + ^ r4: .cfa -8 + ^ +STACK CFI 25e6cc .cfa: sp 32 + +STACK CFI INIT 25ed20 128 .cfa: sp 0 + .ra: lr +STACK CFI 25ed24 .cfa: sp 20 + .ra: .cfa -4 + ^ r4: .cfa -20 + ^ r5: .cfa -16 + ^ r6: .cfa -12 + ^ r7: .cfa -8 + ^ +STACK CFI 25ed2c .cfa: sp 208 + +STACK CFI 25ee2a .cfa: sp 20 + +STACK CFI INIT 25ee48 140 .cfa: sp 0 + .ra: lr +STACK CFI 25ee4c .cfa: sp 48 + .ra: .cfa -4 + ^ r10: .cfa -12 + ^ r11: .cfa -8 + ^ r4: .cfa -36 + ^ r5: .cfa -32 + ^ r6: .cfa -28 + ^ r7: .cfa -24 + ^ r8: .cfa -20 + ^ r9: .cfa -16 + ^ +STACK CFI INIT 25effc 24 .cfa: sp 0 + .ra: lr +STACK CFI 25fb1c .cfa: sp 216 + +STACK CFI 25fbac .cfa: sp 28 + +STACK CFI INIT 25fbbc 70 .cfa: sp 0 + .ra: lr +STACK CFI 25fbbe .cfa: sp 16 + .ra: .cfa -4 + ^ r4: .cfa -16 + ^ r5: .cfa -12 + ^ r6: .cfa -8 + ^ +STACK CFI 25fbc2 .cfa: sp 200 + +STACK CFI 25fc1e .cfa: sp 16 + +STACK CFI INIT 2601e2 98 .cfa: sp 0 + .ra: lr +STACK CFI 2601e6 .cfa: sp 24 + .ra: .cfa -4 + ^ r4: .cfa -24 + ^ r5: .cfa -20 + ^ r6: .cfa -16 + ^ r7: .cfa -12 + ^ r8: .cfa -8 + ^ +STACK CFI 2601ec .cfa: sp 80 + +STACK CFI 108 .cfa: sp 32 + .ra: .cfa -4 + ^ r4: .cfa -24 + ^ r5: .cfa -20 + ^ r6: .cfa -16 + ^ r7: .cfa -12 + ^ r8: .cfa -8 + ^ +STACK CFI 10a .cfa: sp 24 + +STACK CFI INIT 260840 104 .cfa: sp 0 + .ra: lr +STACK CFI 260846 .cfa: sp 36 + .ra: .cfa -4 + ^ r10: .cfa -12 + ^ r11: .cfa -8 + ^ r4: .cfa -36 + ^ r5: .cfa -32 + ^ r6: .cfa -28 + ^ r7: .cfa -24 + ^ r8: .cfa -20 + ^ r9: .cfa -16 + ^ +STACK CFI 26084e .cfa: sp 232 + +STACK CFI 260930 .cfa: sp 36 + +STACK CFI 26d0fc .cfa: sp 184 + +STACK CFI 26d158 .cfa: sp 16 + +STACK CFI INIT 26d168 30 .cfa: sp 0 + .ra: lr +STACK CFI 26d16a .cfa: sp 12 + .ra: .cfa -4 + ^ r4: .cfa -12 + ^ r5: .cfa -8 + ^ +STACK CFI 26d16c .cfa: sp 48 + +STACK CFI 2ce518 .cfa: sp 192 + +STACK CFI 2ce562 .cfa: sp 16 + +STACK CFI INIT 7133b0 188 .cfa: sp 0 + .ra: lr +STACK CFI 7133b4 .cfa: sp 36 + .ra: .cfa -4 + ^ r10: .cfa -12 + ^ r11: .cfa -8 + ^ r4: .cfa -36 + ^ r5: .cfa -32 + ^ r6: .cfa -28 + ^ r7: .cfa -24 + ^ r8: .cfa -20 + ^ r9: .cfa -16 + ^ +STACK CFI 7133ba .cfa: sp 176 + +STACK CFI 71351e .cfa: sp 36 + +STACK CFI INIT 22f794 58 .cfa: sp 0 + .ra: lr +STACK CFI a497c6 .cfa: sp 16 + .ra: .cfa -4 + ^ r4: .cfa -16 + ^ r5: .cfa -12 + ^ r6: .cfa -8 + ^ +STACK CFI a497e0 .cfa: sp 0 + .ra: .ra r4: r4 r5: r5 r6: r6 +STACK CFI INIT a497e8 26 .cfa: sp 0 + .ra: lr +STACK CFI a497ea .cfa: sp 16 + .ra: .cfa -4 + ^ r3: .cfa -16 + ^ r4: .cfa -12 + ^ r5: .cfa -8 + ^ +STACK CFI INIT 0 46 .cfa: sp 0 + .ra: lr +STACK CFI 2 .cfa: sp 24 + .ra: .cfa -4 + ^ r4: .cfa -16 + ^ r5: .cfa -12 + ^ r6: .cfa -8 + ^ +STACK CFI 44 .cfa: sp 16 + +STACK CFI 394494 .cfa: sp 16 + +STACK CFI INIT 1a0d714 264 .cfa: sp 0 + .ra: lr +STACK CFI 1a0d716 .cfa: sp 20 + .ra: .cfa -4 + ^ r4: .cfa -20 + ^ r5: .cfa -16 + ^ r6: .cfa -12 + ^ r7: .cfa -8 + ^ +STACK CFI 1a0d71c .cfa: sp 80 + +STACK CFI 1a0d924 .cfa: sp 20 + +STACK CFI INIT 1a0d978 78 .cfa: sp 0 + .ra: lr +STACK CFI INIT 0 2 .cfa: sp 0 + .ra: lr +STACK CFI INIT 1bbf994 6 .cfa: sp 0 + .ra: lr +STACK CFI INIT 1bc1190 19c .cfa: sp 0 + .ra: lr +STACK CFI 1bc1194 .cfa: sp 36 + .ra: .cfa -4 + ^ r10: .cfa -12 + ^ r11: .cfa -8 + ^ r4: .cfa -36 + ^ r5: .cfa -32 + ^ r6: .cfa -28 + ^ r7: .cfa -24 + ^ r8: .cfa -20 + ^ r9: .cfa -16 + ^ +STACK CFI 1bc119e .cfa: sp 184 + +STACK CFI 1bc1338 .cfa: sp 112 + +STACK CFI INIT 1bc2102 106 .cfa: sp 0 + .ra: lr +STACK CFI 1bc2106 .cfa: sp 28 + .ra: .cfa -4 + ^ r4: .cfa -28 + ^ r5: .cfa -24 + ^ r6: .cfa -20 + ^ r7: .cfa -16 + ^ r8: .cfa -12 + ^ r9: .cfa -8 + ^ +STACK CFI 1bc210a .cfa: sp 56 + +STACK CFI 1bc2204 .cfa: sp 28 + +STACK CFI INIT 1bc2208 6c .cfa: sp 0 + .ra: lr +STACK CFI INIT 1bc8324 c7c .cfa: sp 0 + .ra: lr +STACK CFI 1bc8328 .cfa: sp 36 + .ra: .cfa -4 + ^ r10: .cfa -12 + ^ r11: .cfa -8 + ^ r4: .cfa -36 + ^ r5: .cfa -32 + ^ r6: .cfa -28 + ^ r7: .cfa -24 + ^ r8: .cfa -20 + ^ r9: .cfa -16 + ^ +STACK CFI 1bc8338 .cfa: sp 1216 + +STACK CFI c0 .cfa: sp 24 + +STACK CFI INIT 1bc909c 7e0 .cfa: sp 0 + .ra: lr +STACK CFI 1bc90a4 .cfa: sp 36 + .ra: .cfa -4 + ^ r10: .cfa -12 + ^ r11: .cfa -8 + ^ r4: .cfa -36 + ^ r5: .cfa -32 + ^ r6: .cfa -28 + ^ r7: .cfa -24 + ^ r8: .cfa -20 + ^ r9: .cfa -16 + ^ +STACK CFI 1bc90b2 .cfa: sp 560 + +STACK CFI 108 .cfa: sp 32 + .ra: .cfa -4 + ^ r4: .cfa -24 + ^ r5: .cfa -20 + ^ r6: .cfa -16 + ^ r7: .cfa -12 + ^ r8: .cfa -8 + ^ +STACK CFI 10a .cfa: sp 24 + +STACK CFI INIT 28a980 28 .cfa: sp 0 + .ra: lr +STACK CFI 28a982 .cfa: sp 16 + .ra: .cfa -4 + ^ r4: .cfa -16 + ^ r5: .cfa -12 + ^ r6: .cfa -8 + ^ +STACK CFI INIT 1be39f8 3ec .cfa: sp 0 + .ra: lr +STACK CFI 1be39fc .cfa: sp 36 + .ra: .cfa -4 + ^ r10: .cfa -12 + ^ r11: .cfa -8 + ^ r4: .cfa -36 + ^ r5: .cfa -32 + ^ r6: .cfa -28 + ^ r7: .cfa -24 + ^ r8: .cfa -20 + ^ r9: .cfa -16 + ^ +STACK CFI 1be3a0a .cfa: sp 664 + +STACK CFI 1be3d78 .cfa: sp 36 + +STACK CFI 1d96e8e .cfa: sp 20 + +STACK CFI INIT 1d96eac 17c .cfa: sp 0 + .ra: lr +STACK CFI 1d96eb2 .cfa: sp 28 + .ra: .cfa -4 + ^ r4: .cfa -28 + ^ r5: .cfa -24 + ^ r6: .cfa -20 + ^ r7: .cfa -16 + ^ r8: .cfa -12 + ^ r9: .cfa -8 + ^ +STACK CFI 1d96ebc .cfa: sp 280 + +STACK CFI 1d96ffa .cfa: sp 28 + +STACK CFI INIT 22f794 58 .cfa: sp 0 + .ra: lr +STACK CFI 231cb6 .cfa: sp 28 + +STACK CFI INIT 1d97420 fc .cfa: sp 0 + .ra: lr +STACK CFI 1d97424 .cfa: sp 32 + .ra: .cfa -4 + ^ r10: .cfa -8 + ^ r4: .cfa -32 + ^ r5: .cfa -28 + ^ r6: .cfa -24 + ^ r7: .cfa -20 + ^ r8: .cfa -16 + ^ r9: .cfa -12 + ^ +STACK CFI 1d97432 .cfa: sp 200 + +STACK CFI 1d974f2 .cfa: sp 32 + +STACK CFI INIT 1d9751c d0 .cfa: sp 0 + .ra: lr +STACK CFI 1d97522 .cfa: sp 28 + .ra: .cfa -4 + ^ r4: .cfa -28 + ^ r5: .cfa -24 + ^ r6: .cfa -20 + ^ r7: .cfa -16 + ^ r8: .cfa -12 + ^ r9: .cfa -8 + ^ +STACK CFI 1d9752a .cfa: sp 232 + -- cgit v1.2.1