syzygy/pdb/pdb_dbi_stream.cc - syzygy - Git at Google

 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "syzygy/pdb/pdb_dbi_stream.h"

 #include "base/strings/stringprintf.h"
 #include "syzygy/common/align.h"
 #include "syzygy/pdb/pdb_constants.h"
 #include "syzygy/pdb/pdb_stream.h"
 #include "syzygy/pdb/pdb_stream_reader.h"
 #include "syzygy/pdb/pdb_util.h"

 namespace pdb {

 bool DbiModuleInfo::Read(common::BinaryStreamParser* parser) {
   DCHECK(parser != nullptr);

   if (!parser->Read(&module_info_base_) || !parser->ReadString(&module_name_) ||
       !parser->ReadString(&object_name_) || !parser->AlignTo(4)) {
     LOG(ERROR) << "Unable to read module information.";
     return false;
   }

   return true;
 }

 // Reads the header from the Dbi stream of the PDB.
 bool DbiStream::ReadDbiHeaders(pdb::PdbStream* stream) {
   DCHECK(stream != NULL);

   if (!stream->ReadBytesAt(0, sizeof(header_), &header_)) {
     LOG(ERROR) << "Unable to read the header of the Dbi Stream.";
     return false;
   }

   size_t dbg_header_offs = pdb::GetDbiDbgHeaderOffset(header_);
   if (!stream->ReadBytesAt(dbg_header_offs, sizeof(dbg_header_),
                            &dbg_header_)) {
     LOG(ERROR) << "Unable to read Dbg header of the Dbi Stream.";
     return false;
   }

   return true;
 }

 // Reads the module info substream from the Dbi stream of the PDB.
 bool DbiStream::ReadDbiModuleInfo(pdb::PdbStream* stream) {
   DCHECK(stream != NULL);

   // This substream starts just after the Dbi header in the Dbi stream.
   size_t module_start = sizeof(pdb::DbiHeader);

   pdb::PdbStreamReaderWithPosition reader(module_start, header_.gp_modi_size,
                                           stream);
   common::BinaryStreamParser parser(&reader);
   // Read each module info block.
   while (!reader.AtEnd()) {
     DbiModuleInfo module_info;
     if (!module_info.Read(&parser))
       return false;
     modules_.push_back(module_info);
   }

   if (!reader.AtEnd()) {
     LOG(ERROR) << "Module info substream of the Dbi stream is not valid.";
     return false;
   }

   return true;
 }

 // Reads the section contribs substream from the Dbi stream of the PDB.
 bool DbiStream::ReadDbiSectionContribs(pdb::PdbStream* stream) {
   DCHECK(stream != NULL);

   size_t section_contribs_start = sizeof(pdb::DbiHeader) + header_.gp_modi_size;
   pdb::PdbStreamReaderWithPosition reader(
       section_contribs_start, header_.section_contribution_size, stream);
   common::BinaryStreamParser parser(&reader);
   uint32_t signature = 0;
   if (!parser.Read(&signature)) {
     LOG(ERROR) << "Unable to seek to section contributions substream.";
     return false;
   }

   if (signature != kPdbDbiSectionContribsSignature) {
     LOG(ERROR) << "Unexpected signature for the section contribs substream. "
                << "Expected "
                << base::StringPrintf("0x%08X", kPdbDbiSectionContribsSignature)
                << ", read "
                << base::StringPrintf("0x%08X", signature) << ".";
     return false;
   }

   size_t section_contrib_count =
       (header_.section_contribution_size - reader.Position()) /
       sizeof(DbiSectionContrib);

   if (!parser.ReadMultiple(section_contrib_count, &section_contribs_)) {
     LOG(ERROR) << "Unable to read section contributions.";
     return false;
   }

   if (!reader.AtEnd()) {
     LOG(ERROR) << "Section contribs substream of the Dbi stream is not valid.";
     return false;
   }

   return true;
 }

 // Reads the section map substream from the Dbi stream of the PDB.
 bool DbiStream::ReadDbiSectionMap(pdb::PdbStream* stream) {
   DCHECK(stream != NULL);

   size_t section_map_start = sizeof(pdb::DbiHeader)
       + header_.gp_modi_size
       + header_.section_contribution_size;
   pdb::PdbStreamReaderWithPosition reader(section_map_start,
                                           header_.section_map_size, stream);
   common::BinaryStreamParser parser(&reader);
   uint16_t number_of_sections = 0;
   if (!parser.Read(&number_of_sections)) {
     LOG(ERROR) << "Unable to read the length of the section map in the Dbi "
                << "stream.";
     return false;
   }

   // The number of section appears to be present twice. This check ensure that
   // the value are always equals. If it's not it'll give us a sample to
   // understand what's this value.
   uint16_t number_of_sections_copy = 0;
   if (!parser.Read(&number_of_sections_copy)) {
     LOG(ERROR) << "Unable to read the copy of the length of the section map in "
                << "the Dbi stream.";
     return false;
   }

   if (number_of_sections != number_of_sections_copy) {
     LOG(ERROR) << "Mismatched values for the length of the section map ("
                <<  number_of_sections << " vs "<< number_of_sections_copy
                << ").";
     return false;
   }

   while (!reader.AtEnd()) {
     DbiSectionMapItem section_map_item;
     if (!parser.Read(&section_map_item)) {
       LOG(ERROR) << "Failed to read a section map item";
       return false;
     }

     section_map_[section_map_item.section_number] = section_map_item;
   }

   if (section_map_.size() != number_of_sections) {
     LOG(ERROR) << "Unexpected number of sections in the section map (expected "
                << number_of_sections << ", read " << section_map_.size()
                << ").";
     return false;
   }

   if (!reader.AtEnd()) {
     LOG(ERROR) << "Section map substream of the Dbi stream is not valid.";
     return false;
   }

   return true;
 }

 // Reads the file info substream from the Dbi stream of the PDB.
 // The structure of this substream is:
 // Header | File-blocks table | Offset table | Name table.
 // - The header contains the number of entries in the File-blocks table (16
 //    bits) followed by the number of entries in the offset table (16 bits). You
 //   have to multiply each size by 4 to obtain the size in bytes.
 // - The file-blocks table is divided in 2 parts. The first part contains the
 //   starting index of each block (16 bits) and the second one contains
 //   the length of these blocks. These value refer to the offset table. It
 //   seems that there's always a last block with a starting value equal to the
 //   length of the offset table and a length of 0 at the end of this table.
 // - The offset table contains offsets to the beginning of file names in the
 //   name table. These offsets are relative to the beginning of the name table.
 // - The name table contain all the filenames used in this substream.
 bool DbiStream::ReadDbiFileInfo(pdb::PdbStream* stream) {
   DCHECK(stream != NULL);

   size_t file_info_start = sizeof(pdb::DbiHeader)
       + header_.gp_modi_size
       + header_.section_contribution_size
       + header_.section_map_size;
   pdb::PdbStreamReaderWithPosition reader(file_info_start,
                                           header_.file_info_size, stream);
   common::BinaryStreamParser parser(&reader);

   uint16_t file_blocks_table_size = 0;
   uint16_t offset_table_size = 0;
   if (!parser.Read(&file_blocks_table_size) ||
       !parser.Read(&offset_table_size)) {
     LOG(ERROR) << "Unable to read the header of the file info substream.";
     return false;
   }

   // Calculate the starting address of the different sections of this substream.
   size_t file_blocks_table_start = file_info_start + reader.Position();
   size_t offset_table_start =
       file_blocks_table_start + file_blocks_table_size * sizeof(uint32_t);

   if (!ReadDbiFileInfoBlocks(stream,
                              file_blocks_table_size,
                              file_blocks_table_start,
                              offset_table_start)) {
     return false;
   }

   size_t name_table_start =
       offset_table_start + offset_table_size * sizeof(uint32_t);
   size_t file_info_end = file_info_start + header_.file_info_size;

   // Read the name table in this substream.
   if (!ReadDbiFileNameTable(stream,
                             name_table_start,
                             file_info_end)) {
     return false;
   }

   return true;
 }

 bool DbiStream::ReadDbiFileInfoBlocks(pdb::PdbStream* stream,
                                       uint16_t file_blocks_table_size,
                                       size_t file_blocks_table_start,
                                       size_t offset_table_start) {
   file_info_.first.resize(file_blocks_table_size);

   // The block info data is composed of two parallel arrays in the stream.
   // The first array is an array of uint16_t block start positions, and the
   // second one is an array of uint16_t lengths.
   // Each {start, length} pair notes the location and length of variable-length
   // array of uint16_t identifiers. These identifiers in turn then point to
   // locations in the file name table, and so identify a file name.
   // This is done because there's a lot of repetition in the file name data, as
   // every compilation unit ends up including a subset of the same files.

   // Create a reader over the start position array.
   pdb::PdbStreamReaderWithPosition start_reader(
       file_blocks_table_start, file_blocks_table_size * sizeof(uint16_t),
       stream);
   common::BinaryStreamParser start_parser(&start_reader);

   // Create a reader over the length array.
   size_t file_block_length_start =
       file_blocks_table_start + file_blocks_table_size * sizeof(uint16_t);
   pdb::PdbStreamReaderWithPosition length_reader(
       file_block_length_start, file_blocks_table_size * sizeof(uint16_t),
       stream);
   common::BinaryStreamParser length_parser(&length_reader);

   // Read information about each block of the file info substream.
   for (int i = 0; i < file_blocks_table_size; ++i) {
     uint16_t block_start = 0;
     uint16_t block_length = 0;
     if (!start_parser.Read(&block_start) ||
         !length_parser.Read(&block_length)) {
       LOG(ERROR) << "Unable to read the file info substream.";
       return false;
     }

     pdb::PdbStreamReaderWithPosition block_reader(
         offset_table_start + block_start * sizeof(uint32_t),
         block_length * sizeof(uint32_t), stream);
     common::BinaryStreamParser block_parser(&block_reader);
     // Fill the file list.
     if (!block_parser.ReadMultiple(block_length, &file_info_.first.at(i))) {
       LOG(ERROR) << "Unable to read the file info substream.";
       return false;
     }
   }

   return true;
 }

 // It would be useful to move this code to a more generic function if we see
 // this structure somewhere else in the PDB.
 bool DbiStream::ReadDbiFileNameTable(pdb::PdbStream* stream,
                                      size_t name_table_start,
                                      size_t name_table_end) {
   DCHECK_LE(name_table_start, name_table_end);
   pdb::PdbStreamReaderWithPosition reader(
       name_table_start, name_table_end - name_table_start, stream);
   common::BinaryStreamParser parser(&reader);

   while (!reader.AtEnd()) {
     std::string filename;
     size_t pos = reader.Position();
     if (!parser.ReadString(&filename)) {
       LOG(ERROR) << "Unable to read the name table of the file info substream.";
       return false;
     }
     file_info_.second.emplace(static_cast<uint32_t>(pos), filename);
   }

   if (!reader.AtEnd()) {
     LOG(ERROR) << "File info substream of the Dbi stream is not valid.";
     return false;
   }

   return true;
 }

 bool DbiStream::ReadDbiECInfo(pdb::PdbStream* stream) {
   // It's important to note that the ec_info_size field appears after the
   // dbg_header_size field in the header of this stream but the EC info
   // substream is located before the DbgHeader substream.
   size_t ec_info_start = sizeof(pdb::DbiHeader)
       + header_.gp_modi_size
       + header_.section_contribution_size
       + header_.section_map_size
       + header_.file_info_size
       + header_.ts_map_size;
   size_t ec_info_end = ec_info_start + header_.ec_info_size;

   return ReadStringTable(stream,
                          "EC info",
                          ec_info_start,
                          ec_info_end,
                          &ec_info_vector_);
 }

 bool DbiStream::Read(pdb::PdbStream* stream ) {
   DCHECK(stream != NULL);

   if (!ReadDbiHeaders(stream))
     return false;

   if (!ReadDbiModuleInfo(stream))
     return false;

   if (!ReadDbiSectionContribs(stream))
     return false;

   if (!ReadDbiSectionMap(stream))
     return false;

   if (!ReadDbiFileInfo(stream))
     return false;

   if (header_.ts_map_size != 0) {
     LOG(ERROR) << "The length of the TS map is expected to be null but we've "
                << "read a length of " << header_.ts_map_size << ".";
     return false;
   }

   if (!ReadDbiECInfo(stream))
     return false;

   return true;
 }

 }  // namespace pdb
	// Copyright 2012 Google Inc. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "syzygy/pdb/pdb_dbi_stream.h"

	#include "base/strings/stringprintf.h"
	#include "syzygy/common/align.h"
	#include "syzygy/pdb/pdb_constants.h"
	#include "syzygy/pdb/pdb_stream.h"
	#include "syzygy/pdb/pdb_stream_reader.h"
	#include "syzygy/pdb/pdb_util.h"

	namespace pdb {

	bool DbiModuleInfo::Read(common::BinaryStreamParser* parser) {
	DCHECK(parser != nullptr);

	if (!parser->Read(&module_info_base_) \|\| !parser->ReadString(&module_name_) \|\|
	!parser->ReadString(&object_name_) \|\| !parser->AlignTo(4)) {
	LOG(ERROR) << "Unable to read module information.";
	return false;
	}

	return true;
	}

	// Reads the header from the Dbi stream of the PDB.
	bool DbiStream::ReadDbiHeaders(pdb::PdbStream* stream) {
	DCHECK(stream != NULL);

	if (!stream->ReadBytesAt(0, sizeof(header_), &header_)) {
	LOG(ERROR) << "Unable to read the header of the Dbi Stream.";
	return false;
	}

	size_t dbg_header_offs = pdb::GetDbiDbgHeaderOffset(header_);
	if (!stream->ReadBytesAt(dbg_header_offs, sizeof(dbg_header_),
	&dbg_header_)) {
	LOG(ERROR) << "Unable to read Dbg header of the Dbi Stream.";
	return false;
	}

	return true;
	}

	// Reads the module info substream from the Dbi stream of the PDB.
	bool DbiStream::ReadDbiModuleInfo(pdb::PdbStream* stream) {
	DCHECK(stream != NULL);

	// This substream starts just after the Dbi header in the Dbi stream.
	size_t module_start = sizeof(pdb::DbiHeader);

	pdb::PdbStreamReaderWithPosition reader(module_start, header_.gp_modi_size,
	stream);
	common::BinaryStreamParser parser(&reader);
	// Read each module info block.
	while (!reader.AtEnd()) {
	DbiModuleInfo module_info;
	if (!module_info.Read(&parser))
	return false;
	modules_.push_back(module_info);
	}

	if (!reader.AtEnd()) {
	LOG(ERROR) << "Module info substream of the Dbi stream is not valid.";
	return false;
	}

	return true;
	}

	// Reads the section contribs substream from the Dbi stream of the PDB.
	bool DbiStream::ReadDbiSectionContribs(pdb::PdbStream* stream) {
	DCHECK(stream != NULL);

	size_t section_contribs_start = sizeof(pdb::DbiHeader) + header_.gp_modi_size;
	pdb::PdbStreamReaderWithPosition reader(
	section_contribs_start, header_.section_contribution_size, stream);
	common::BinaryStreamParser parser(&reader);
	uint32_t signature = 0;
	if (!parser.Read(&signature)) {
	LOG(ERROR) << "Unable to seek to section contributions substream.";
	return false;
	}

	if (signature != kPdbDbiSectionContribsSignature) {
	LOG(ERROR) << "Unexpected signature for the section contribs substream. "
	<< "Expected "
	<< base::StringPrintf("0x%08X", kPdbDbiSectionContribsSignature)
	<< ", read "
	<< base::StringPrintf("0x%08X", signature) << ".";
	return false;
	}

	size_t section_contrib_count =
	(header_.section_contribution_size - reader.Position()) /
	sizeof(DbiSectionContrib);

	if (!parser.ReadMultiple(section_contrib_count, &section_contribs_)) {
	LOG(ERROR) << "Unable to read section contributions.";
	return false;
	}

	if (!reader.AtEnd()) {
	LOG(ERROR) << "Section contribs substream of the Dbi stream is not valid.";
	return false;
	}

	return true;
	}

	// Reads the section map substream from the Dbi stream of the PDB.
	bool DbiStream::ReadDbiSectionMap(pdb::PdbStream* stream) {
	DCHECK(stream != NULL);

	size_t section_map_start = sizeof(pdb::DbiHeader)
	+ header_.gp_modi_size
	+ header_.section_contribution_size;
	pdb::PdbStreamReaderWithPosition reader(section_map_start,
	header_.section_map_size, stream);
	common::BinaryStreamParser parser(&reader);
	uint16_t number_of_sections = 0;
	if (!parser.Read(&number_of_sections)) {
	LOG(ERROR) << "Unable to read the length of the section map in the Dbi "
	<< "stream.";
	return false;
	}

	// The number of section appears to be present twice. This check ensure that
	// the value are always equals. If it's not it'll give us a sample to
	// understand what's this value.
	uint16_t number_of_sections_copy = 0;
	if (!parser.Read(&number_of_sections_copy)) {
	LOG(ERROR) << "Unable to read the copy of the length of the section map in "
	<< "the Dbi stream.";
	return false;
	}

	if (number_of_sections != number_of_sections_copy) {
	LOG(ERROR) << "Mismatched values for the length of the section map ("
	<< number_of_sections << " vs "<< number_of_sections_copy
	<< ").";
	return false;
	}

	while (!reader.AtEnd()) {
	DbiSectionMapItem section_map_item;
	if (!parser.Read(&section_map_item)) {
	LOG(ERROR) << "Failed to read a section map item";
	return false;
	}

	section_map_[section_map_item.section_number] = section_map_item;
	}

	if (section_map_.size() != number_of_sections) {
	LOG(ERROR) << "Unexpected number of sections in the section map (expected "
	<< number_of_sections << ", read " << section_map_.size()
	<< ").";
	return false;
	}

	if (!reader.AtEnd()) {
	LOG(ERROR) << "Section map substream of the Dbi stream is not valid.";
	return false;
	}

	return true;
	}

	// Reads the file info substream from the Dbi stream of the PDB.
	// The structure of this substream is:
	// Header \| File-blocks table \| Offset table \| Name table.
	// - The header contains the number of entries in the File-blocks table (16
	// bits) followed by the number of entries in the offset table (16 bits). You
	// have to multiply each size by 4 to obtain the size in bytes.
	// - The file-blocks table is divided in 2 parts. The first part contains the
	// starting index of each block (16 bits) and the second one contains
	// the length of these blocks. These value refer to the offset table. It
	// seems that there's always a last block with a starting value equal to the
	// length of the offset table and a length of 0 at the end of this table.
	// - The offset table contains offsets to the beginning of file names in the
	// name table. These offsets are relative to the beginning of the name table.
	// - The name table contain all the filenames used in this substream.
	bool DbiStream::ReadDbiFileInfo(pdb::PdbStream* stream) {
	DCHECK(stream != NULL);

	size_t file_info_start = sizeof(pdb::DbiHeader)
	+ header_.gp_modi_size
	+ header_.section_contribution_size
	+ header_.section_map_size;
	pdb::PdbStreamReaderWithPosition reader(file_info_start,
	header_.file_info_size, stream);
	common::BinaryStreamParser parser(&reader);

	uint16_t file_blocks_table_size = 0;
	uint16_t offset_table_size = 0;
	if (!parser.Read(&file_blocks_table_size) \|\|
	!parser.Read(&offset_table_size)) {
	LOG(ERROR) << "Unable to read the header of the file info substream.";
	return false;
	}

	// Calculate the starting address of the different sections of this substream.
	size_t file_blocks_table_start = file_info_start + reader.Position();
	size_t offset_table_start =
	file_blocks_table_start + file_blocks_table_size * sizeof(uint32_t);

	if (!ReadDbiFileInfoBlocks(stream,
	file_blocks_table_size,
	file_blocks_table_start,
	offset_table_start)) {
	return false;
	}

	size_t name_table_start =
	offset_table_start + offset_table_size * sizeof(uint32_t);
	size_t file_info_end = file_info_start + header_.file_info_size;

	// Read the name table in this substream.
	if (!ReadDbiFileNameTable(stream,
	name_table_start,
	file_info_end)) {
	return false;
	}

	return true;
	}

	bool DbiStream::ReadDbiFileInfoBlocks(pdb::PdbStream* stream,
	uint16_t file_blocks_table_size,
	size_t file_blocks_table_start,
	size_t offset_table_start) {
	file_info_.first.resize(file_blocks_table_size);

	// The block info data is composed of two parallel arrays in the stream.
	// The first array is an array of uint16_t block start positions, and the
	// second one is an array of uint16_t lengths.
	// Each {start, length} pair notes the location and length of variable-length
	// array of uint16_t identifiers. These identifiers in turn then point to
	// locations in the file name table, and so identify a file name.
	// This is done because there's a lot of repetition in the file name data, as
	// every compilation unit ends up including a subset of the same files.

	// Create a reader over the start position array.
	pdb::PdbStreamReaderWithPosition start_reader(
	file_blocks_table_start, file_blocks_table_size * sizeof(uint16_t),
	stream);
	common::BinaryStreamParser start_parser(&start_reader);

	// Create a reader over the length array.
	size_t file_block_length_start =
	file_blocks_table_start + file_blocks_table_size * sizeof(uint16_t);
	pdb::PdbStreamReaderWithPosition length_reader(
	file_block_length_start, file_blocks_table_size * sizeof(uint16_t),
	stream);
	common::BinaryStreamParser length_parser(&length_reader);

	// Read information about each block of the file info substream.
	for (int i = 0; i < file_blocks_table_size; ++i) {
	uint16_t block_start = 0;
	uint16_t block_length = 0;
	if (!start_parser.Read(&block_start) \|\|
	!length_parser.Read(&block_length)) {
	LOG(ERROR) << "Unable to read the file info substream.";
	return false;
	}

	pdb::PdbStreamReaderWithPosition block_reader(
	offset_table_start + block_start * sizeof(uint32_t),
	block_length * sizeof(uint32_t), stream);
	common::BinaryStreamParser block_parser(&block_reader);
	// Fill the file list.
	if (!block_parser.ReadMultiple(block_length, &file_info_.first.at(i))) {
	LOG(ERROR) << "Unable to read the file info substream.";
	return false;
	}
	}

	return true;
	}

	// It would be useful to move this code to a more generic function if we see
	// this structure somewhere else in the PDB.
	bool DbiStream::ReadDbiFileNameTable(pdb::PdbStream* stream,
	size_t name_table_start,
	size_t name_table_end) {
	DCHECK_LE(name_table_start, name_table_end);
	pdb::PdbStreamReaderWithPosition reader(
	name_table_start, name_table_end - name_table_start, stream);
	common::BinaryStreamParser parser(&reader);

	while (!reader.AtEnd()) {
	std::string filename;
	size_t pos = reader.Position();
	if (!parser.ReadString(&filename)) {
	LOG(ERROR) << "Unable to read the name table of the file info substream.";
	return false;
	}
	file_info_.second.emplace(static_cast<uint32_t>(pos), filename);
	}

	if (!reader.AtEnd()) {
	LOG(ERROR) << "File info substream of the Dbi stream is not valid.";
	return false;
	}

	return true;
	}

	bool DbiStream::ReadDbiECInfo(pdb::PdbStream* stream) {
	// It's important to note that the ec_info_size field appears after the
	// dbg_header_size field in the header of this stream but the EC info
	// substream is located before the DbgHeader substream.
	size_t ec_info_start = sizeof(pdb::DbiHeader)
	+ header_.gp_modi_size
	+ header_.section_contribution_size
	+ header_.section_map_size
	+ header_.file_info_size
	+ header_.ts_map_size;
	size_t ec_info_end = ec_info_start + header_.ec_info_size;

	return ReadStringTable(stream,
	"EC info",
	ec_info_start,
	ec_info_end,
	&ec_info_vector_);
	}

	bool DbiStream::Read(pdb::PdbStream* stream ) {
	DCHECK(stream != NULL);

	if (!ReadDbiHeaders(stream))
	return false;

	if (!ReadDbiModuleInfo(stream))
	return false;

	if (!ReadDbiSectionContribs(stream))
	return false;

	if (!ReadDbiSectionMap(stream))
	return false;

	if (!ReadDbiFileInfo(stream))
	return false;

	if (header_.ts_map_size != 0) {
	LOG(ERROR) << "The length of the TS map is expected to be null but we've "
	<< "read a length of " << header_.ts_map_size << ".";
	return false;
	}

	if (!ReadDbiECInfo(stream))
	return false;

	return true;
	}

	} // namespace pdb