src/processor/fast_source_line_resolver_unittest.cc - nest-cam/v350/breakpad - Git at Google

 // 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();
 }
	// 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();
	}