| // Copyright (c) 2010 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. |
| // |
| // fast_source_line_resolver_unittest.cc: Unit tests for FastSourceLineResolver. |
| // Two different approaches for testing fast source line resolver: |
| // First, use the same unit test data for basic source line resolver. |
| // Second, read data from symbol files, load them as basic modules, and then |
| // serialize them and load the serialized data as fast modules. Then compare |
| // modules to assure the fast module contains exactly the same data as |
| // basic module. |
| // |
| // Author: Siyang Xie (lambxsy@google.com) |
| |
| #include <assert.h> |
| #include <stdio.h> |
| |
| #include <sstream> |
| #include <string> |
| |
| #include "breakpad_googletest_includes.h" |
| #include "common/using_std_string.h" |
| #include "google_breakpad/processor/code_module.h" |
| #include "google_breakpad/processor/stack_frame.h" |
| #include "google_breakpad/processor/memory_region.h" |
| #include "processor/logging.h" |
| #include "processor/module_serializer.h" |
| #include "processor/module_comparer.h" |
| |
| namespace { |
| |
| using google_breakpad::SourceLineResolverBase; |
| using google_breakpad::BasicSourceLineResolver; |
| using google_breakpad::FastSourceLineResolver; |
| using google_breakpad::ModuleSerializer; |
| using google_breakpad::ModuleComparer; |
| using google_breakpad::CFIFrameInfo; |
| using google_breakpad::CodeModule; |
| using google_breakpad::MemoryRegion; |
| using google_breakpad::StackFrame; |
| using google_breakpad::WindowsFrameInfo; |
| using google_breakpad::linked_ptr; |
| using google_breakpad::scoped_ptr; |
| |
| class TestCodeModule : public CodeModule { |
| public: |
| explicit TestCodeModule(string code_file) : code_file_(code_file) {} |
| virtual ~TestCodeModule() {} |
| |
| virtual uint64_t base_address() const { return 0; } |
| virtual uint64_t size() const { return 0xb000; } |
| virtual string code_file() const { return code_file_; } |
| virtual string code_identifier() const { return ""; } |
| virtual string debug_file() const { return ""; } |
| virtual string debug_identifier() const { return ""; } |
| virtual string version() const { return ""; } |
| virtual CodeModule* Copy() const { |
| return new TestCodeModule(code_file_); |
| } |
| virtual bool is_unloaded() const { return false; } |
| virtual uint64_t shrink_down_delta() const { return 0; } |
| virtual void SetShrinkDownDelta(uint64_t shrink_down_delta) {} |
| |
| private: |
| string code_file_; |
| }; |
| |
| // A mock memory region object, for use by the STACK CFI tests. |
| class MockMemoryRegion: public MemoryRegion { |
| uint64_t GetBase() const { return 0x10000; } |
| uint32_t GetSize() const { return 0x01000; } |
| bool GetMemoryAtAddress(uint64_t address, uint8_t* value) const { |
| *value = address & 0xff; |
| return true; |
| } |
| bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const { |
| *value = address & 0xffff; |
| return true; |
| } |
| bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const { |
| switch (address) { |
| case 0x10008: *value = 0x98ecadc3; break; // saved %ebx |
| case 0x1000c: *value = 0x878f7524; break; // saved %esi |
| case 0x10010: *value = 0x6312f9a5; break; // saved %edi |
| case 0x10014: *value = 0x10038; break; // caller's %ebp |
| case 0x10018: *value = 0xf6438648; break; // return address |
| default: *value = 0xdeadbeef; break; // junk |
| } |
| return true; |
| } |
| bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const { |
| *value = address; |
| return true; |
| } |
| void Print() const { |
| assert(false); |
| } |
| }; |
| |
| // Verify that, for every association in ACTUAL, EXPECTED has the same |
| // association. (That is, ACTUAL's associations should be a subset of |
| // EXPECTED's.) Also verify that ACTUAL has associations for ".ra" and |
| // ".cfa". |
| static bool VerifyRegisters( |
| const char* file, int line, |
| const CFIFrameInfo::RegisterValueMap<uint32_t>& expected, |
| const CFIFrameInfo::RegisterValueMap<uint32_t>& actual) { |
| CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator a; |
| a = actual.find(".cfa"); |
| if (a == actual.end()) |
| return false; |
| a = actual.find(".ra"); |
| if (a == actual.end()) |
| return false; |
| for (a = actual.begin(); a != actual.end(); a++) { |
| CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator e = |
| expected.find(a->first); |
| if (e == expected.end()) { |
| fprintf(stderr, "%s:%d: unexpected register '%s' recovered, value 0x%x\n", |
| file, line, a->first.c_str(), a->second); |
| return false; |
| } |
| if (e->second != a->second) { |
| fprintf(stderr, |
| "%s:%d: register '%s' recovered value was 0x%x, expected 0x%x\n", |
| file, line, a->first.c_str(), a->second, e->second); |
| return false; |
| } |
| // Don't complain if this doesn't recover all registers. Although |
| // the DWARF spec says that unmentioned registers are undefined, |
| // GCC uses omission to mean that they are unchanged. |
| } |
| return true; |
| } |
| |
| static bool VerifyEmpty(const StackFrame& frame) { |
| if (frame.function_name.empty() && |
| frame.source_file_name.empty() && |
| frame.source_line == 0) |
| return true; |
| return false; |
| } |
| |
| static void ClearSourceLineInfo(StackFrame* frame) { |
| frame->function_name.clear(); |
| frame->module = NULL; |
| frame->source_file_name.clear(); |
| frame->source_line = 0; |
| } |
| |
| class TestFastSourceLineResolver : public ::testing::Test { |
| public: |
| void SetUp() { |
| testdata_dir = string(getenv("srcdir") ? getenv("srcdir") : ".") + |
| "/src/processor/testdata"; |
| } |
| |
| string symbol_file(int file_index) { |
| std::stringstream ss; |
| ss << testdata_dir << "/module" << file_index << ".out"; |
| return ss.str(); |
| } |
| |
| ModuleSerializer serializer; |
| BasicSourceLineResolver basic_resolver; |
| FastSourceLineResolver fast_resolver; |
| ModuleComparer module_comparer; |
| |
| string testdata_dir; |
| }; |
| |
| // Test adapted from basic_source_line_resolver_unittest. |
| TEST_F(TestFastSourceLineResolver, TestLoadAndResolve) { |
| TestCodeModule module1("module1"); |
| ASSERT_TRUE(basic_resolver.LoadModule(&module1, symbol_file(1))); |
| ASSERT_TRUE(basic_resolver.HasModule(&module1)); |
| // Convert module1 to fast_module: |
| ASSERT_TRUE(serializer.ConvertOneModule( |
| module1.code_file(), &basic_resolver, &fast_resolver)); |
| ASSERT_TRUE(fast_resolver.HasModule(&module1)); |
| |
| TestCodeModule module2("module2"); |
| ASSERT_TRUE(basic_resolver.LoadModule(&module2, symbol_file(2))); |
| ASSERT_TRUE(basic_resolver.HasModule(&module2)); |
| // Convert module2 to fast_module: |
| ASSERT_TRUE(serializer.ConvertOneModule( |
| module2.code_file(), &basic_resolver, &fast_resolver)); |
| ASSERT_TRUE(fast_resolver.HasModule(&module2)); |
| |
| StackFrame frame; |
| scoped_ptr<WindowsFrameInfo> windows_frame_info; |
| scoped_ptr<CFIFrameInfo> cfi_frame_info; |
| frame.instruction = 0x1000; |
| frame.module = NULL; |
| fast_resolver.FillSourceLineInfo(&frame); |
| ASSERT_FALSE(frame.module); |
| ASSERT_TRUE(frame.function_name.empty()); |
| ASSERT_EQ(frame.function_base, 0U); |
| ASSERT_TRUE(frame.source_file_name.empty()); |
| ASSERT_EQ(frame.source_line, 0); |
| ASSERT_EQ(frame.source_line_base, 0U); |
| |
| frame.module = &module1; |
| fast_resolver.FillSourceLineInfo(&frame); |
| ASSERT_EQ(frame.function_name, "Function1_1"); |
| ASSERT_TRUE(frame.module); |
| ASSERT_EQ(frame.module->code_file(), "module1"); |
| ASSERT_EQ(frame.function_base, 0x1000U); |
| ASSERT_EQ(frame.source_file_name, "file1_1.cc"); |
| ASSERT_EQ(frame.source_line, 44); |
| ASSERT_EQ(frame.source_line_base, 0x1000U); |
| windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame)); |
| ASSERT_TRUE(windows_frame_info.get()); |
| ASSERT_FALSE(windows_frame_info->allocates_base_pointer); |
| ASSERT_EQ(windows_frame_info->program_string, |
| "$eip 4 + ^ = $esp $ebp 8 + = $ebp $ebp ^ ="); |
| |
| ClearSourceLineInfo(&frame); |
| frame.instruction = 0x800; |
| frame.module = &module1; |
| fast_resolver.FillSourceLineInfo(&frame); |
| ASSERT_TRUE(VerifyEmpty(frame)); |
| windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame)); |
| ASSERT_FALSE(windows_frame_info.get()); |
| |
| frame.instruction = 0x1280; |
| fast_resolver.FillSourceLineInfo(&frame); |
| ASSERT_EQ(frame.function_name, "Function1_3"); |
| ASSERT_TRUE(frame.source_file_name.empty()); |
| ASSERT_EQ(frame.source_line, 0); |
| windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame)); |
| ASSERT_TRUE(windows_frame_info.get()); |
| ASSERT_EQ(windows_frame_info->type_, WindowsFrameInfo::STACK_INFO_UNKNOWN); |
| ASSERT_FALSE(windows_frame_info->allocates_base_pointer); |
| ASSERT_TRUE(windows_frame_info->program_string.empty()); |
| |
| frame.instruction = 0x1380; |
| fast_resolver.FillSourceLineInfo(&frame); |
| ASSERT_EQ(frame.function_name, "Function1_4"); |
| ASSERT_TRUE(frame.source_file_name.empty()); |
| ASSERT_EQ(frame.source_line, 0); |
| windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame)); |
| ASSERT_TRUE(windows_frame_info.get()); |
| ASSERT_EQ(windows_frame_info->type_, WindowsFrameInfo::STACK_INFO_FRAME_DATA); |
| ASSERT_FALSE(windows_frame_info->allocates_base_pointer); |
| ASSERT_FALSE(windows_frame_info->program_string.empty()); |
| |
| frame.instruction = 0x2000; |
| windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame)); |
| ASSERT_FALSE(windows_frame_info.get()); |
| |
| // module1 has STACK CFI records covering 3d40..3def; |
| // module2 has STACK CFI records covering 3df0..3e9f; |
| // check that FindCFIFrameInfo doesn't claim to find any outside those ranges. |
| frame.instruction = 0x3d3f; |
| frame.module = &module1; |
| cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame)); |
| ASSERT_FALSE(cfi_frame_info.get()); |
| |
| frame.instruction = 0x3e9f; |
| frame.module = &module1; |
| cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame)); |
| ASSERT_FALSE(cfi_frame_info.get()); |
| |
| CFIFrameInfo::RegisterValueMap<uint32_t> current_registers; |
| CFIFrameInfo::RegisterValueMap<uint32_t> caller_registers; |
| CFIFrameInfo::RegisterValueMap<uint32_t> expected_caller_registers; |
| MockMemoryRegion memory; |
| |
| // Regardless of which instruction evaluation takes place at, it |
| // should produce the same values for the caller's registers. |
| expected_caller_registers[".cfa"] = 0x1001c; |
| expected_caller_registers[".ra"] = 0xf6438648; |
| expected_caller_registers["$ebp"] = 0x10038; |
| expected_caller_registers["$ebx"] = 0x98ecadc3; |
| expected_caller_registers["$esi"] = 0x878f7524; |
| expected_caller_registers["$edi"] = 0x6312f9a5; |
| |
| frame.instruction = 0x3d40; |
| frame.module = &module1; |
| current_registers.clear(); |
| current_registers["$esp"] = 0x10018; |
| current_registers["$ebp"] = 0x10038; |
| current_registers["$ebx"] = 0x98ecadc3; |
| current_registers["$esi"] = 0x878f7524; |
| current_registers["$edi"] = 0x6312f9a5; |
| cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame)); |
| ASSERT_TRUE(cfi_frame_info.get()); |
| ASSERT_TRUE(cfi_frame_info.get() |
| ->FindCallerRegs<uint32_t>(current_registers, memory, |
| &caller_registers)); |
| ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__, |
| expected_caller_registers, caller_registers)); |
| |
| frame.instruction = 0x3d41; |
| current_registers["$esp"] = 0x10014; |
| cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame)); |
| ASSERT_TRUE(cfi_frame_info.get()); |
| ASSERT_TRUE(cfi_frame_info.get() |
| ->FindCallerRegs<uint32_t>(current_registers, memory, |
| &caller_registers)); |
| ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__, |
| expected_caller_registers, caller_registers)); |
| |
| frame.instruction = 0x3d43; |
| current_registers["$ebp"] = 0x10014; |
| cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame)); |
| ASSERT_TRUE(cfi_frame_info.get()); |
| ASSERT_TRUE(cfi_frame_info.get() |
| ->FindCallerRegs<uint32_t>(current_registers, memory, |
| &caller_registers)); |
| VerifyRegisters(__FILE__, __LINE__, |
| expected_caller_registers, caller_registers); |
| |
| frame.instruction = 0x3d54; |
| current_registers["$ebx"] = 0x6864f054U; |
| cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame)); |
| ASSERT_TRUE(cfi_frame_info.get()); |
| ASSERT_TRUE(cfi_frame_info.get() |
| ->FindCallerRegs<uint32_t>(current_registers, memory, |
| &caller_registers)); |
| VerifyRegisters(__FILE__, __LINE__, |
| expected_caller_registers, caller_registers); |
| |
| frame.instruction = 0x3d5a; |
| current_registers["$esi"] = 0x6285f79aU; |
| cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame)); |
| ASSERT_TRUE(cfi_frame_info.get()); |
| ASSERT_TRUE(cfi_frame_info.get() |
| ->FindCallerRegs<uint32_t>(current_registers, memory, |
| &caller_registers)); |
| VerifyRegisters(__FILE__, __LINE__, |
| expected_caller_registers, caller_registers); |
| |
| frame.instruction = 0x3d84; |
| current_registers["$edi"] = 0x64061449U; |
| cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame)); |
| ASSERT_TRUE(cfi_frame_info.get()); |
| ASSERT_TRUE(cfi_frame_info.get() |
| ->FindCallerRegs<uint32_t>(current_registers, memory, |
| &caller_registers)); |
| VerifyRegisters(__FILE__, __LINE__, |
| expected_caller_registers, caller_registers); |
| |
| frame.instruction = 0x2900; |
| frame.module = &module1; |
| fast_resolver.FillSourceLineInfo(&frame); |
| ASSERT_EQ(frame.function_name, string("PublicSymbol")); |
| |
| frame.instruction = 0x4000; |
| frame.module = &module1; |
| fast_resolver.FillSourceLineInfo(&frame); |
| ASSERT_EQ(frame.function_name, string("LargeFunction")); |
| |
| frame.instruction = 0x2181; |
| frame.module = &module2; |
| fast_resolver.FillSourceLineInfo(&frame); |
| ASSERT_EQ(frame.function_name, "Function2_2"); |
| ASSERT_EQ(frame.function_base, 0x2170U); |
| ASSERT_TRUE(frame.module); |
| ASSERT_EQ(frame.module->code_file(), "module2"); |
| ASSERT_EQ(frame.source_file_name, "file2_2.cc"); |
| ASSERT_EQ(frame.source_line, 21); |
| ASSERT_EQ(frame.source_line_base, 0x2180U); |
| windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame)); |
| ASSERT_TRUE(windows_frame_info.get()); |
| ASSERT_EQ(windows_frame_info->type_, WindowsFrameInfo::STACK_INFO_FRAME_DATA); |
| ASSERT_EQ(windows_frame_info->prolog_size, 1U); |
| |
| frame.instruction = 0x216f; |
| fast_resolver.FillSourceLineInfo(&frame); |
| ASSERT_EQ(frame.function_name, "Public2_1"); |
| |
| ClearSourceLineInfo(&frame); |
| frame.instruction = 0x219f; |
| frame.module = &module2; |
| fast_resolver.FillSourceLineInfo(&frame); |
| ASSERT_TRUE(frame.function_name.empty()); |
| |
| frame.instruction = 0x21a0; |
| frame.module = &module2; |
| fast_resolver.FillSourceLineInfo(&frame); |
| ASSERT_EQ(frame.function_name, "Public2_2"); |
| } |
| |
| TEST_F(TestFastSourceLineResolver, TestInvalidLoads) { |
| TestCodeModule module3("module3"); |
| ASSERT_TRUE(basic_resolver.LoadModule(&module3, |
| testdata_dir + "/module3_bad.out")); |
| ASSERT_TRUE(basic_resolver.HasModule(&module3)); |
| ASSERT_TRUE(basic_resolver.IsModuleCorrupt(&module3)); |
| // Convert module3 to fast_module: |
| ASSERT_TRUE(serializer.ConvertOneModule(module3.code_file(), |
| &basic_resolver, |
| &fast_resolver)); |
| ASSERT_TRUE(fast_resolver.HasModule(&module3)); |
| ASSERT_TRUE(fast_resolver.IsModuleCorrupt(&module3)); |
| |
| TestCodeModule module4("module4"); |
| ASSERT_TRUE(basic_resolver.LoadModule(&module4, |
| testdata_dir + "/module4_bad.out")); |
| ASSERT_TRUE(basic_resolver.HasModule(&module4)); |
| ASSERT_TRUE(basic_resolver.IsModuleCorrupt(&module4)); |
| // Convert module4 to fast_module: |
| ASSERT_TRUE(serializer.ConvertOneModule(module4.code_file(), |
| &basic_resolver, |
| &fast_resolver)); |
| ASSERT_TRUE(fast_resolver.HasModule(&module4)); |
| ASSERT_TRUE(fast_resolver.IsModuleCorrupt(&module4)); |
| |
| TestCodeModule module5("module5"); |
| ASSERT_FALSE(fast_resolver.LoadModule(&module5, |
| testdata_dir + "/invalid-filename")); |
| ASSERT_FALSE(fast_resolver.HasModule(&module5)); |
| |
| TestCodeModule invalidmodule("invalid-module"); |
| ASSERT_FALSE(fast_resolver.HasModule(&invalidmodule)); |
| } |
| |
| TEST_F(TestFastSourceLineResolver, TestUnload) { |
| TestCodeModule module1("module1"); |
| ASSERT_FALSE(basic_resolver.HasModule(&module1)); |
| |
| ASSERT_TRUE(basic_resolver.LoadModule(&module1, symbol_file(1))); |
| ASSERT_TRUE(basic_resolver.HasModule(&module1)); |
| // Convert module1 to fast_module. |
| ASSERT_TRUE(serializer.ConvertOneModule(module1.code_file(), |
| &basic_resolver, |
| &fast_resolver)); |
| ASSERT_TRUE(fast_resolver.HasModule(&module1)); |
| basic_resolver.UnloadModule(&module1); |
| fast_resolver.UnloadModule(&module1); |
| ASSERT_FALSE(fast_resolver.HasModule(&module1)); |
| |
| ASSERT_TRUE(basic_resolver.LoadModule(&module1, symbol_file(1))); |
| ASSERT_TRUE(basic_resolver.HasModule(&module1)); |
| // Convert module1 to fast_module. |
| ASSERT_TRUE(serializer.ConvertOneModule(module1.code_file(), |
| &basic_resolver, |
| &fast_resolver)); |
| ASSERT_TRUE(fast_resolver.HasModule(&module1)); |
| } |
| |
| TEST_F(TestFastSourceLineResolver, CompareModule) { |
| char* symbol_data; |
| size_t symbol_data_size; |
| string symbol_data_string; |
| string filename; |
| |
| for (int module_index = 0; module_index < 3; ++module_index) { |
| std::stringstream ss; |
| ss << testdata_dir << "/module" << module_index << ".out"; |
| filename = ss.str(); |
| ASSERT_TRUE(SourceLineResolverBase::ReadSymbolFile( |
| symbol_file(module_index), &symbol_data, &symbol_data_size)); |
| symbol_data_string.assign(symbol_data, symbol_data_size); |
| delete [] symbol_data; |
| ASSERT_TRUE(module_comparer.Compare(symbol_data_string)); |
| } |
| } |
| |
| } // namespace |
| |
| int main(int argc, char* argv[]) { |
| ::testing::InitGoogleTest(&argc, argv); |
| return RUN_ALL_TESTS(); |
| } |
