src/processor/module_comparer.cc - 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.
 //
 // module_comparer.cc: ModuleComparer implementation.
 // See module_comparer.h for documentation.
 //
 // Author: lambxsy@google.com (Siyang Xie)

 #include "processor/module_comparer.h"

 #include <map>
 #include <string>

 #include "common/scoped_ptr.h"
 #include "processor/basic_code_module.h"
 #include "processor/logging.h"

 #define ASSERT_TRUE(condition) \
   if (!(condition)) { \
     BPLOG(ERROR) << "FAIL: " << #condition << " @ " \
                  << __FILE__ << ":" << __LINE__; \
     return false; \
   }

 #define ASSERT_FALSE(condition) ASSERT_TRUE(!(condition))

 namespace google_breakpad {

 bool ModuleComparer::Compare(const string& symbol_data) {
   scoped_ptr<BasicModule> basic_module(new BasicModule("test_module"));
   scoped_ptr<FastModule> fast_module(new FastModule("test_module"));

   // Load symbol data into basic_module
   scoped_array<char> buffer(new char[symbol_data.size() + 1]);
   memcpy(buffer.get(), symbol_data.c_str(), symbol_data.size());
   buffer.get()[symbol_data.size()] = '\0';
   ASSERT_TRUE(basic_module->LoadMapFromMemory(buffer.get(),
                                               symbol_data.size() + 1));
   buffer.reset();

   // Serialize BasicSourceLineResolver::Module.
   unsigned int serialized_size = 0;
   scoped_array<char> serialized_data(
       serializer_.Serialize(*(basic_module.get()), &serialized_size));
   ASSERT_TRUE(serialized_data.get());
   BPLOG(INFO) << "Serialized size = " << serialized_size << " Bytes";

   // Load FastSourceLineResolver::Module using serialized data.
   ASSERT_TRUE(fast_module->LoadMapFromMemory(serialized_data.get(),
                                              serialized_size));
   ASSERT_TRUE(fast_module->IsCorrupt() == basic_module->IsCorrupt());

   // Compare FastSourceLineResolver::Module with
   // BasicSourceLineResolver::Module.
   ASSERT_TRUE(CompareModule(basic_module.get(), fast_module.get()));

   return true;
 }

 // Traversal the content of module and do comparison
 bool ModuleComparer::CompareModule(const BasicModule *basic_module,
                                   const FastModule *fast_module) const {
   // Compare name_.
   ASSERT_TRUE(basic_module->name_ == fast_module->name_);

   // Compare files_:
   {
     BasicModule::FileMap::const_iterator iter1 = basic_module->files_.begin();
     FastModule::FileMap::iterator iter2 = fast_module->files_.begin();
     while (iter1 != basic_module->files_.end()
         && iter2 != fast_module->files_.end()) {
       ASSERT_TRUE(iter1->first == iter2.GetKey());
       string tmp(iter2.GetValuePtr());
       ASSERT_TRUE(iter1->second == tmp);
       ++iter1;
       ++iter2;
     }
     ASSERT_TRUE(iter1 == basic_module->files_.end());
     ASSERT_TRUE(iter2 == fast_module->files_.end());
   }

   // Compare functions_:
   {
     RangeMap<MemAddr, linked_ptr<BasicFunc> >::MapConstIterator iter1;
     StaticRangeMap<MemAddr, FastFunc>::MapConstIterator iter2;
     iter1 = basic_module->functions_.map_.begin();
     iter2 = fast_module->functions_.map_.begin();
     while (iter1 != basic_module->functions_.map_.end()
         && iter2 != fast_module->functions_.map_.end()) {
       ASSERT_TRUE(iter1->first == iter2.GetKey());
       ASSERT_TRUE(iter1->second.base() == iter2.GetValuePtr()->base());
       ASSERT_TRUE(CompareFunction(
           iter1->second.entry().get(), iter2.GetValuePtr()->entryptr()));
       ++iter1;
       ++iter2;
     }
     ASSERT_TRUE(iter1 == basic_module->functions_.map_.end());
     ASSERT_TRUE(iter2 == fast_module->functions_.map_.end());
   }

   // Compare public_symbols_:
   {
     AddressMap<MemAddr, linked_ptr<BasicPubSymbol> >::MapConstIterator iter1;
     StaticAddressMap<MemAddr, FastPubSymbol>::MapConstIterator iter2;
     iter1 = basic_module->public_symbols_.map_.begin();
     iter2 = fast_module->public_symbols_.map_.begin();
     while (iter1 != basic_module->public_symbols_.map_.end()
           && iter2 != fast_module->public_symbols_.map_.end()) {
       ASSERT_TRUE(iter1->first == iter2.GetKey());
       ASSERT_TRUE(ComparePubSymbol(
           iter1->second.get(), iter2.GetValuePtr()));
       ++iter1;
       ++iter2;
     }
     ASSERT_TRUE(iter1 == basic_module->public_symbols_.map_.end());
     ASSERT_TRUE(iter2 == fast_module->public_symbols_.map_.end());
   }

   // Compare windows_frame_info_[]:
   for (int i = 0; i < WindowsFrameInfo::STACK_INFO_LAST; ++i) {
     ASSERT_TRUE(CompareCRM(&(basic_module->windows_frame_info_[i]),
                            &(fast_module->windows_frame_info_[i])));
   }

   // Compare cfi_initial_rules_:
   {
     RangeMap<MemAddr, string>::MapConstIterator iter1;
     StaticRangeMap<MemAddr, char>::MapConstIterator iter2;
     iter1 = basic_module->cfi_initial_rules_.map_.begin();
     iter2 = fast_module->cfi_initial_rules_.map_.begin();
     while (iter1 != basic_module->cfi_initial_rules_.map_.end()
         && iter2 != fast_module->cfi_initial_rules_.map_.end()) {
       ASSERT_TRUE(iter1->first == iter2.GetKey());
       ASSERT_TRUE(iter1->second.base() == iter2.GetValuePtr()->base());
       string tmp(iter2.GetValuePtr()->entryptr());
       ASSERT_TRUE(iter1->second.entry() == tmp);
       ++iter1;
       ++iter2;
     }
     ASSERT_TRUE(iter1 == basic_module->cfi_initial_rules_.map_.end());
     ASSERT_TRUE(iter2 == fast_module->cfi_initial_rules_.map_.end());
   }

   // Compare cfi_delta_rules_:
   {
     map<MemAddr, string>::const_iterator iter1;
     StaticMap<MemAddr, char>::iterator iter2;
     iter1 = basic_module->cfi_delta_rules_.begin();
     iter2 = fast_module->cfi_delta_rules_.begin();
     while (iter1 != basic_module->cfi_delta_rules_.end()
         && iter2 != fast_module->cfi_delta_rules_.end()) {
       ASSERT_TRUE(iter1->first == iter2.GetKey());
       string tmp(iter2.GetValuePtr());
       ASSERT_TRUE(iter1->second == tmp);
       ++iter1;
       ++iter2;
     }
     ASSERT_TRUE(iter1 == basic_module->cfi_delta_rules_.end());
     ASSERT_TRUE(iter2 == fast_module->cfi_delta_rules_.end());
   }

   return true;
 }

 bool ModuleComparer::CompareFunction(const BasicFunc *basic_func,
                                     const FastFunc *fast_func_raw) const {
   FastFunc* fast_func = new FastFunc();
   fast_func->CopyFrom(fast_func_raw);
   ASSERT_TRUE(basic_func->name == fast_func->name);
   ASSERT_TRUE(basic_func->address == fast_func->address);
   ASSERT_TRUE(basic_func->size == fast_func->size);

   // compare range map of lines:
   RangeMap<MemAddr, linked_ptr<BasicLine> >::MapConstIterator iter1;
   StaticRangeMap<MemAddr, FastLine>::MapConstIterator iter2;
   iter1 = basic_func->lines.map_.begin();
   iter2 = fast_func->lines.map_.begin();
   while (iter1 != basic_func->lines.map_.end()
       && iter2 != fast_func->lines.map_.end()) {
     ASSERT_TRUE(iter1->first == iter2.GetKey());
     ASSERT_TRUE(iter1->second.base() == iter2.GetValuePtr()->base());
     ASSERT_TRUE(CompareLine(iter1->second.entry().get(),
                             iter2.GetValuePtr()->entryptr()));
     ++iter1;
     ++iter2;
   }
   ASSERT_TRUE(iter1 == basic_func->lines.map_.end());
   ASSERT_TRUE(iter2 == fast_func->lines.map_.end());

   delete fast_func;
   return true;
 }

 bool ModuleComparer::CompareLine(const BasicLine *basic_line,
                                 const FastLine *fast_line_raw) const {
   FastLine *fast_line = new FastLine;
   fast_line->CopyFrom(fast_line_raw);

   ASSERT_TRUE(basic_line->address == fast_line->address);
   ASSERT_TRUE(basic_line->size == fast_line->size);
   ASSERT_TRUE(basic_line->source_file_id == fast_line->source_file_id);
   ASSERT_TRUE(basic_line->line == fast_line->line);

   delete fast_line;
   return true;
 }

 bool ModuleComparer::ComparePubSymbol(const BasicPubSymbol* basic_ps,
                                      const FastPubSymbol* fastps_raw) const {
   FastPubSymbol *fast_ps = new FastPubSymbol;
   fast_ps->CopyFrom(fastps_raw);
   ASSERT_TRUE(basic_ps->name == fast_ps->name);
   ASSERT_TRUE(basic_ps->address == fast_ps->address);
   ASSERT_TRUE(basic_ps->parameter_size == fast_ps->parameter_size);
   delete fast_ps;
   return true;
 }

 bool ModuleComparer::CompareWFI(const WindowsFrameInfo& wfi1,
                                const WindowsFrameInfo& wfi2) const {
   ASSERT_TRUE(wfi1.type_ == wfi2.type_);
   ASSERT_TRUE(wfi1.valid == wfi2.valid);
   ASSERT_TRUE(wfi1.prolog_size == wfi2.prolog_size);
   ASSERT_TRUE(wfi1.epilog_size == wfi2.epilog_size);
   ASSERT_TRUE(wfi1.parameter_size == wfi2.parameter_size);
   ASSERT_TRUE(wfi1.saved_register_size == wfi2.saved_register_size);
   ASSERT_TRUE(wfi1.local_size == wfi2.local_size);
   ASSERT_TRUE(wfi1.max_stack_size == wfi2.max_stack_size);
   ASSERT_TRUE(wfi1.allocates_base_pointer == wfi2.allocates_base_pointer);
   ASSERT_TRUE(wfi1.program_string == wfi2.program_string);
   return true;
 }

 // Compare ContainedRangeMap
 bool ModuleComparer::CompareCRM(
     const ContainedRangeMap<MemAddr, linked_ptr<WFI> >* basic_crm,
     const StaticContainedRangeMap<MemAddr, char>* fast_crm) const {
   ASSERT_TRUE(basic_crm->base_ == fast_crm->base_);

   if (!basic_crm->entry_.get() || !fast_crm->entry_ptr_) {
     // empty entry:
     ASSERT_TRUE(!basic_crm->entry_.get() && !fast_crm->entry_ptr_);
   } else {
     WFI newwfi;
     newwfi.CopyFrom(fast_resolver_->CopyWFI(fast_crm->entry_ptr_));
     ASSERT_TRUE(CompareWFI(*(basic_crm->entry_.get()), newwfi));
   }

   if ((!basic_crm->map_ || basic_crm->map_->empty())
       || fast_crm->map_.empty()) {
     ASSERT_TRUE((!basic_crm->map_ || basic_crm->map_->empty())
                && fast_crm->map_.empty());
   } else {
     ContainedRangeMap<MemAddr, linked_ptr<WFI> >::MapConstIterator iter1;
     StaticContainedRangeMap<MemAddr, char>::MapConstIterator iter2;
     iter1 = basic_crm->map_->begin();
     iter2 = fast_crm->map_.begin();
     while (iter1 != basic_crm->map_->end()
         && iter2 != fast_crm->map_.end()) {
       ASSERT_TRUE(iter1->first == iter2.GetKey());
       StaticContainedRangeMap<MemAddr, char>* child =
           new StaticContainedRangeMap<MemAddr, char>(
               reinterpret_cast<const char*>(iter2.GetValuePtr()));
       ASSERT_TRUE(CompareCRM(iter1->second, child));
       delete child;
       ++iter1;
       ++iter2;
     }
     ASSERT_TRUE(iter1 == basic_crm->map_->end());
     ASSERT_TRUE(iter2 == fast_crm->map_.end());
   }

   return true;
 }

 }  // namespace google_breakpad
	// 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.
	//
	// module_comparer.cc: ModuleComparer implementation.
	// See module_comparer.h for documentation.
	//
	// Author: lambxsy@google.com (Siyang Xie)

	#include "processor/module_comparer.h"

	#include <map>
	#include <string>

	#include "common/scoped_ptr.h"
	#include "processor/basic_code_module.h"
	#include "processor/logging.h"

	#define ASSERT_TRUE(condition) \
	if (!(condition)) { \
	BPLOG(ERROR) << "FAIL: " << #condition << " @ " \
	<< __FILE__ << ":" << __LINE__; \
	return false; \
	}

	#define ASSERT_FALSE(condition) ASSERT_TRUE(!(condition))

	namespace google_breakpad {

	bool ModuleComparer::Compare(const string& symbol_data) {
	scoped_ptr<BasicModule> basic_module(new BasicModule("test_module"));
	scoped_ptr<FastModule> fast_module(new FastModule("test_module"));

	// Load symbol data into basic_module
	scoped_array<char> buffer(new char[symbol_data.size() + 1]);
	memcpy(buffer.get(), symbol_data.c_str(), symbol_data.size());
	buffer.get()[symbol_data.size()] = '\0';
	ASSERT_TRUE(basic_module->LoadMapFromMemory(buffer.get(),
	symbol_data.size() + 1));
	buffer.reset();

	// Serialize BasicSourceLineResolver::Module.
	unsigned int serialized_size = 0;
	scoped_array<char> serialized_data(
	serializer_.Serialize(*(basic_module.get()), &serialized_size));
	ASSERT_TRUE(serialized_data.get());
	BPLOG(INFO) << "Serialized size = " << serialized_size << " Bytes";

	// Load FastSourceLineResolver::Module using serialized data.
	ASSERT_TRUE(fast_module->LoadMapFromMemory(serialized_data.get(),
	serialized_size));
	ASSERT_TRUE(fast_module->IsCorrupt() == basic_module->IsCorrupt());

	// Compare FastSourceLineResolver::Module with
	// BasicSourceLineResolver::Module.
	ASSERT_TRUE(CompareModule(basic_module.get(), fast_module.get()));

	return true;
	}

	// Traversal the content of module and do comparison
	bool ModuleComparer::CompareModule(const BasicModule *basic_module,
	const FastModule *fast_module) const {
	// Compare name_.
	ASSERT_TRUE(basic_module->name_ == fast_module->name_);

	// Compare files_:
	{
	BasicModule::FileMap::const_iterator iter1 = basic_module->files_.begin();
	FastModule::FileMap::iterator iter2 = fast_module->files_.begin();
	while (iter1 != basic_module->files_.end()
	&& iter2 != fast_module->files_.end()) {
	ASSERT_TRUE(iter1->first == iter2.GetKey());
	string tmp(iter2.GetValuePtr());
	ASSERT_TRUE(iter1->second == tmp);
	++iter1;
	++iter2;
	}
	ASSERT_TRUE(iter1 == basic_module->files_.end());
	ASSERT_TRUE(iter2 == fast_module->files_.end());
	}

	// Compare functions_:
	{
	RangeMap<MemAddr, linked_ptr<BasicFunc> >::MapConstIterator iter1;
	StaticRangeMap<MemAddr, FastFunc>::MapConstIterator iter2;
	iter1 = basic_module->functions_.map_.begin();
	iter2 = fast_module->functions_.map_.begin();
	while (iter1 != basic_module->functions_.map_.end()
	&& iter2 != fast_module->functions_.map_.end()) {
	ASSERT_TRUE(iter1->first == iter2.GetKey());
	ASSERT_TRUE(iter1->second.base() == iter2.GetValuePtr()->base());
	ASSERT_TRUE(CompareFunction(
	iter1->second.entry().get(), iter2.GetValuePtr()->entryptr()));
	++iter1;
	++iter2;
	}
	ASSERT_TRUE(iter1 == basic_module->functions_.map_.end());
	ASSERT_TRUE(iter2 == fast_module->functions_.map_.end());
	}

	// Compare public_symbols_:
	{
	AddressMap<MemAddr, linked_ptr<BasicPubSymbol> >::MapConstIterator iter1;
	StaticAddressMap<MemAddr, FastPubSymbol>::MapConstIterator iter2;
	iter1 = basic_module->public_symbols_.map_.begin();
	iter2 = fast_module->public_symbols_.map_.begin();
	while (iter1 != basic_module->public_symbols_.map_.end()
	&& iter2 != fast_module->public_symbols_.map_.end()) {
	ASSERT_TRUE(iter1->first == iter2.GetKey());
	ASSERT_TRUE(ComparePubSymbol(
	iter1->second.get(), iter2.GetValuePtr()));
	++iter1;
	++iter2;
	}
	ASSERT_TRUE(iter1 == basic_module->public_symbols_.map_.end());
	ASSERT_TRUE(iter2 == fast_module->public_symbols_.map_.end());
	}

	// Compare windows_frame_info_[]:
	for (int i = 0; i < WindowsFrameInfo::STACK_INFO_LAST; ++i) {
	ASSERT_TRUE(CompareCRM(&(basic_module->windows_frame_info_[i]),
	&(fast_module->windows_frame_info_[i])));
	}

	// Compare cfi_initial_rules_:
	{
	RangeMap<MemAddr, string>::MapConstIterator iter1;
	StaticRangeMap<MemAddr, char>::MapConstIterator iter2;
	iter1 = basic_module->cfi_initial_rules_.map_.begin();
	iter2 = fast_module->cfi_initial_rules_.map_.begin();
	while (iter1 != basic_module->cfi_initial_rules_.map_.end()
	&& iter2 != fast_module->cfi_initial_rules_.map_.end()) {
	ASSERT_TRUE(iter1->first == iter2.GetKey());
	ASSERT_TRUE(iter1->second.base() == iter2.GetValuePtr()->base());
	string tmp(iter2.GetValuePtr()->entryptr());
	ASSERT_TRUE(iter1->second.entry() == tmp);
	++iter1;
	++iter2;
	}
	ASSERT_TRUE(iter1 == basic_module->cfi_initial_rules_.map_.end());
	ASSERT_TRUE(iter2 == fast_module->cfi_initial_rules_.map_.end());
	}

	// Compare cfi_delta_rules_:
	{
	map<MemAddr, string>::const_iterator iter1;
	StaticMap<MemAddr, char>::iterator iter2;
	iter1 = basic_module->cfi_delta_rules_.begin();
	iter2 = fast_module->cfi_delta_rules_.begin();
	while (iter1 != basic_module->cfi_delta_rules_.end()
	&& iter2 != fast_module->cfi_delta_rules_.end()) {
	ASSERT_TRUE(iter1->first == iter2.GetKey());
	string tmp(iter2.GetValuePtr());
	ASSERT_TRUE(iter1->second == tmp);
	++iter1;
	++iter2;
	}
	ASSERT_TRUE(iter1 == basic_module->cfi_delta_rules_.end());
	ASSERT_TRUE(iter2 == fast_module->cfi_delta_rules_.end());
	}

	return true;
	}

	bool ModuleComparer::CompareFunction(const BasicFunc *basic_func,
	const FastFunc *fast_func_raw) const {
	FastFunc* fast_func = new FastFunc();
	fast_func->CopyFrom(fast_func_raw);
	ASSERT_TRUE(basic_func->name == fast_func->name);
	ASSERT_TRUE(basic_func->address == fast_func->address);
	ASSERT_TRUE(basic_func->size == fast_func->size);

	// compare range map of lines:
	RangeMap<MemAddr, linked_ptr<BasicLine> >::MapConstIterator iter1;
	StaticRangeMap<MemAddr, FastLine>::MapConstIterator iter2;
	iter1 = basic_func->lines.map_.begin();
	iter2 = fast_func->lines.map_.begin();
	while (iter1 != basic_func->lines.map_.end()
	&& iter2 != fast_func->lines.map_.end()) {
	ASSERT_TRUE(iter1->first == iter2.GetKey());
	ASSERT_TRUE(iter1->second.base() == iter2.GetValuePtr()->base());
	ASSERT_TRUE(CompareLine(iter1->second.entry().get(),
	iter2.GetValuePtr()->entryptr()));
	++iter1;
	++iter2;
	}
	ASSERT_TRUE(iter1 == basic_func->lines.map_.end());
	ASSERT_TRUE(iter2 == fast_func->lines.map_.end());

	delete fast_func;
	return true;
	}

	bool ModuleComparer::CompareLine(const BasicLine *basic_line,
	const FastLine *fast_line_raw) const {
	FastLine *fast_line = new FastLine;
	fast_line->CopyFrom(fast_line_raw);

	ASSERT_TRUE(basic_line->address == fast_line->address);
	ASSERT_TRUE(basic_line->size == fast_line->size);
	ASSERT_TRUE(basic_line->source_file_id == fast_line->source_file_id);
	ASSERT_TRUE(basic_line->line == fast_line->line);

	delete fast_line;
	return true;
	}

	bool ModuleComparer::ComparePubSymbol(const BasicPubSymbol* basic_ps,
	const FastPubSymbol* fastps_raw) const {
	FastPubSymbol *fast_ps = new FastPubSymbol;
	fast_ps->CopyFrom(fastps_raw);
	ASSERT_TRUE(basic_ps->name == fast_ps->name);
	ASSERT_TRUE(basic_ps->address == fast_ps->address);
	ASSERT_TRUE(basic_ps->parameter_size == fast_ps->parameter_size);
	delete fast_ps;
	return true;
	}

	bool ModuleComparer::CompareWFI(const WindowsFrameInfo& wfi1,
	const WindowsFrameInfo& wfi2) const {
	ASSERT_TRUE(wfi1.type_ == wfi2.type_);
	ASSERT_TRUE(wfi1.valid == wfi2.valid);
	ASSERT_TRUE(wfi1.prolog_size == wfi2.prolog_size);
	ASSERT_TRUE(wfi1.epilog_size == wfi2.epilog_size);
	ASSERT_TRUE(wfi1.parameter_size == wfi2.parameter_size);
	ASSERT_TRUE(wfi1.saved_register_size == wfi2.saved_register_size);
	ASSERT_TRUE(wfi1.local_size == wfi2.local_size);
	ASSERT_TRUE(wfi1.max_stack_size == wfi2.max_stack_size);
	ASSERT_TRUE(wfi1.allocates_base_pointer == wfi2.allocates_base_pointer);
	ASSERT_TRUE(wfi1.program_string == wfi2.program_string);
	return true;
	}

	// Compare ContainedRangeMap
	bool ModuleComparer::CompareCRM(
	const ContainedRangeMap<MemAddr, linked_ptr<WFI> >* basic_crm,
	const StaticContainedRangeMap<MemAddr, char>* fast_crm) const {
	ASSERT_TRUE(basic_crm->base_ == fast_crm->base_);

	if (!basic_crm->entry_.get() \|\| !fast_crm->entry_ptr_) {
	// empty entry:
	ASSERT_TRUE(!basic_crm->entry_.get() && !fast_crm->entry_ptr_);
	} else {
	WFI newwfi;
	newwfi.CopyFrom(fast_resolver_->CopyWFI(fast_crm->entry_ptr_));
	ASSERT_TRUE(CompareWFI(*(basic_crm->entry_.get()), newwfi));
	}

	if ((!basic_crm->map_ \|\| basic_crm->map_->empty())
	\|\| fast_crm->map_.empty()) {
	ASSERT_TRUE((!basic_crm->map_ \|\| basic_crm->map_->empty())
	&& fast_crm->map_.empty());
	} else {
	ContainedRangeMap<MemAddr, linked_ptr<WFI> >::MapConstIterator iter1;
	StaticContainedRangeMap<MemAddr, char>::MapConstIterator iter2;
	iter1 = basic_crm->map_->begin();
	iter2 = fast_crm->map_.begin();
	while (iter1 != basic_crm->map_->end()
	&& iter2 != fast_crm->map_.end()) {
	ASSERT_TRUE(iter1->first == iter2.GetKey());
	StaticContainedRangeMap<MemAddr, char>* child =
	new StaticContainedRangeMap<MemAddr, char>(
	reinterpret_cast<const char*>(iter2.GetValuePtr()));
	ASSERT_TRUE(CompareCRM(iter1->second, child));
	delete child;
	++iter1;
	++iter2;
	}
	ASSERT_TRUE(iter1 == basic_crm->map_->end());
	ASSERT_TRUE(iter2 == fast_crm->map_.end());
	}

	return true;
	}

	} // namespace google_breakpad