mirror/tomahawk
1
0
Fork 0
mirror of https://github.com/tomahawk-player/tomahawk.git synced 2025-08-18 03:41:27 +02:00
Code Issues Releases Wiki Activity

Update breakpad to make it work with MinGW

Browse Source
This commit is contained in:
Dominik Schmidt
2014-04-14 19:23:44 +02:00
parent c912b76c49
commit b4f05b0831
1049 changed files with 57520 additions and 329083 deletions
Download Patch File Download Diff File Expand all files Collapse all files

732
thirdparty/breakpad/common/pecoff/dump_symbols-inl.h vendored Normal file
View File

@@ -0,0 +1,732 @@
// Copyright (c) 2011 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.
// dump_symbols-inl.h: implement google_breakpad::WriteSymbolFile:
// Find all the debugging info in a file and dump it as a Breakpad symbol file.
#ifndef COMMON_PECOFF_DUMP_SYMBOLS_INL_H
#define COMMON_PECOFF_DUMP_SYMBOLS_INL_H
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef _WIN32
#include <sys/mman.h>
#endif
#include <sys/stat.h>
#include <unistd.h>
#include <libgen.h>
#include <iostream>
#include <set>
#include <utility>
#include <vector>
#include "common/dwarf/bytereader-inl.h"
#include "common/dwarf/dwarf2diehandler.h"
#include "common/dwarf_cfi_to_module.h"
#include "common/dwarf_cu_to_module.h"
#include "common/dwarf_line_to_module.h"
#include "common/module.h"
#include "common/scoped_ptr.h"
#ifndef NO_STABS_SUPPORT
#include "common/stabs_reader.h"
#include "common/stabs_to_module.h"
#endif
#include "common/using_std_string.h"
// This namespace contains helper functions.
namespace {
using google_breakpad::DumpOptions;
using google_breakpad::DwarfCFIToModule;
using google_breakpad::DwarfCUToModule;
using google_breakpad::DwarfLineToModule;
using google_breakpad::Module;
#ifndef NO_STABS_SUPPORT
using google_breakpad::StabsToModule;
#endif
using google_breakpad::scoped_ptr;
//
// FDWrapper
//
// Wrapper class to make sure opened file is closed.
//
class FDWrapper {
public:
explicit FDWrapper(int fd) :
fd_(fd) {}
~FDWrapper() {
if (fd_ != -1)
close(fd_);
}
int get() {
return fd_;
}
int release() {
int fd = fd_;
fd_ = -1;
return fd;
}
private:
int fd_;
};
//
// MmapWrapper
//
// Wrapper class to make sure mapped regions are unmapped.
//
class MmapWrapper {
public:
MmapWrapper() : is_set_(false) {}
~MmapWrapper() {
if (is_set_ && base_ != NULL) {
assert(size_ > 0);
#ifndef _WIN32
munmap(base_, size_);
#else
UnmapViewOfFile(base_);
CloseHandle(hMap_);
#endif
}
}
void *set(int obj_fd, size_t mapped_size) {
#ifndef _WIN32
void *mapped_address = mmap(NULL, mapped_size,
PROT_READ | PROT_WRITE, MAP_PRIVATE, obj_fd, 0);
if (mapped_address == MAP_FAILED)
return NULL;
#else
HANDLE h = (HANDLE)_get_osfhandle(obj_fd);
hMap_ = CreateFileMapping(h, NULL, PAGE_READONLY,0, 0, NULL);
// XXX: should also use SEC_IMAGE_NO_EXECUTE on Windows 6.2 or later
if (!hMap_) {
return NULL;
}
void *mapped_address = MapViewOfFile(hMap_, FILE_MAP_READ, 0, 0, 0);
if (!mapped_address) {
CloseHandle(hMap_);
return NULL;
}
#endif
is_set_ = true;
base_ = mapped_address;
size_ = mapped_size;
return mapped_address;
}
void release() {
assert(is_set_);
is_set_ = false;
base_ = NULL;
size_ = 0;
}
private:
bool is_set_;
void *base_;
size_t size_;
#ifdef _WIN32
HANDLE hMap_;
#endif
};
#ifndef NO_STABS_SUPPORT
template<typename ObjectFileReader>
bool LoadStabs(const typename ObjectFileReader::ObjectFileBase header,
const typename ObjectFileReader::Section stab_section,
const typename ObjectFileReader::Section stabstr_section,
const bool big_endian,
Module* module) {
// A callback object to handle data from the STABS reader.
StabsToModule handler(module);
// Find the addresses of the STABS data, and create a STABS reader object.
// On Linux, STABS entries always have 32-bit values, regardless of the
// address size of the architecture whose code they're describing, and
// the strings are always "unitized".
const uint8_t* stabs = ObjectFileReader::GetSectionPointer(header,
stab_section);
const uint8_t* stabstr = ObjectFileReader::GetSectionPointer(header,
stabstr_section);
google_breakpad::StabsReader reader(stabs,
ObjectFileReader::GetSectionSize(header, stab_section),
stabstr,
ObjectFileReader::GetSectionSize(header, stabstr_section),
big_endian, 4, true, &handler);
// Read the STABS data, and do post-processing.
if (!reader.Process())
return false;
handler.Finalize();
return true;
}
#endif // NO_STABS_SUPPORT
// A line-to-module loader that accepts line number info parsed by
// dwarf2reader::LineInfo and populates a Module and a line vector
// with the results.
class DumperLineToModule: public DwarfCUToModule::LineToModuleHandler {
public:
// Create a line-to-module converter using BYTE_READER.
explicit DumperLineToModule(dwarf2reader::ByteReader *byte_reader)
: byte_reader_(byte_reader) { }
void StartCompilationUnit(const string& compilation_dir) {
compilation_dir_ = compilation_dir;
}
void ReadProgram(const char *program, uint64 length,
Module *module, std::vector<Module::Line> *lines) {
DwarfLineToModule handler(module, compilation_dir_, lines);
dwarf2reader::LineInfo parser(program, length, byte_reader_, &handler);
parser.Start();
}
private:
string compilation_dir_;
dwarf2reader::ByteReader *byte_reader_;
};
template<typename ObjectFileReader>
bool LoadDwarf(const string& dwarf_filename,
const typename ObjectFileReader::ObjectFileBase header,
const bool big_endian,
bool handle_inter_cu_refs,
Module* module) {
typedef typename ObjectFileReader::Section Shdr;
const dwarf2reader::Endianness endianness = big_endian ?
dwarf2reader::ENDIANNESS_BIG : dwarf2reader::ENDIANNESS_LITTLE;
dwarf2reader::ByteReader byte_reader(endianness);
// Construct a context for this file.
DwarfCUToModule::FileContext file_context(dwarf_filename,
module,
handle_inter_cu_refs);
// Build a map of the file's sections.
int num_sections = ObjectFileReader::GetNumberOfSections(header);
for (int i = 0; i < num_sections; ++i) {
const Shdr section = ObjectFileReader::FindSectionByIndex(header, i);
string name = ObjectFileReader::GetSectionName(header, section);
const char* contents = reinterpret_cast<const char *>(ObjectFileReader::GetSectionPointer(header, section));
file_context.AddSectionToSectionMap(name, contents,
ObjectFileReader::GetSectionSize(header, section));
}
// Parse all the compilation units in the .debug_info section.
DumperLineToModule line_to_module(&byte_reader);
dwarf2reader::SectionMap::const_iterator debug_info_entry =
file_context.section_map().find(".debug_info");
assert(debug_info_entry != file_context.section_map().end());
const std::pair<const char*, uint64>& debug_info_section =
debug_info_entry->second;
// This should never have been called if the file doesn't have a
// .debug_info section.
assert(debug_info_section.first);
uint64 debug_info_length = debug_info_section.second;
for (uint64 offset = 0; offset < debug_info_length;) {
// Make a handler for the root DIE that populates MODULE with the
// data that was found.
DwarfCUToModule::WarningReporter reporter(dwarf_filename, offset);
DwarfCUToModule root_handler(&file_context, &line_to_module, &reporter);
// Make a Dwarf2Handler that drives the DIEHandler.
dwarf2reader::DIEDispatcher die_dispatcher(&root_handler);
// Make a DWARF parser for the compilation unit at OFFSET.
dwarf2reader::CompilationUnit reader(file_context.section_map(),
offset,
&byte_reader,
&die_dispatcher);
// Process the entire compilation unit; get the offset of the next.
offset += reader.Start();
}
return true;
}
// Fill REGISTER_NAMES with the register names appropriate to the
// machine architecture, indexed by the register
// numbers used in DWARF call frame information. Return true on
// success, or false if HEADER's machine architecture is not
// supported.
bool DwarfCFIRegisterNames(const char *architecture,
std::vector<string>* register_names) {
if (strcmp(architecture, "x86" ) == 0)
*register_names = DwarfCFIToModule::RegisterNames::I386();
else if (strcmp(architecture, "arm" ) == 0)
*register_names = DwarfCFIToModule::RegisterNames::ARM();
else if (strcmp(architecture, "mips" ) == 0)
*register_names = DwarfCFIToModule::RegisterNames::MIPS();
else if (strcmp(architecture, "x86_64" ) == 0)
*register_names = DwarfCFIToModule::RegisterNames::X86_64();
else
return false;
return true;
}
template<typename ObjectFileReader>
bool LoadDwarfCFI(const string& dwarf_filename,
const typename ObjectFileReader::ObjectFileBase header,
const char* section_name,
const typename ObjectFileReader::Section section,
const bool eh_frame,
const typename ObjectFileReader::Section got_section,
const typename ObjectFileReader::Section text_section,
const bool big_endian,
Module* module) {
// Find the appropriate set of register names for this file's
// architecture.
const char *architecture = ObjectFileReader::Architecture(header);
std::vector<string> register_names;
if (!DwarfCFIRegisterNames(architecture, &register_names)) {
return false;
}
const dwarf2reader::Endianness endianness = big_endian ?
dwarf2reader::ENDIANNESS_BIG : dwarf2reader::ENDIANNESS_LITTLE;
// Find the call frame information and its size.
const char* cfi = reinterpret_cast<const char *>(ObjectFileReader::GetSectionPointer(header, section));
size_t cfi_size = ObjectFileReader::GetSectionSize(header, section);
// Plug together the parser, handler, and their entourages.
DwarfCFIToModule::Reporter module_reporter(dwarf_filename, section_name);
DwarfCFIToModule handler(module, register_names, &module_reporter);
dwarf2reader::ByteReader byte_reader(endianness);
byte_reader.SetAddressSize(ObjectFileReader::kAddrSize);
// Provide the base addresses for .eh_frame encoded pointers, if
// possible.
byte_reader.SetCFIDataBase(ObjectFileReader::GetSectionRVA(header, section) +
ObjectFileReader::GetLoadingAddress(header),
cfi);
if (got_section)
byte_reader.SetDataBase(ObjectFileReader::GetSectionRVA(header, got_section) +
ObjectFileReader::GetLoadingAddress(header));
if (text_section)
byte_reader.SetTextBase(ObjectFileReader::GetSectionRVA(header, text_section) +
ObjectFileReader::GetLoadingAddress(header));
dwarf2reader::CallFrameInfo::Reporter dwarf_reporter(dwarf_filename,
section_name);
dwarf2reader::CallFrameInfo parser(cfi, cfi_size,
&byte_reader, &handler, &dwarf_reporter,
eh_frame);
parser.Start();
return true;
}
bool LoadFile(const string& obj_file, MmapWrapper* map_wrapper,
const void** header) {
int obj_fd = open(obj_file.c_str(), O_RDONLY);
if (obj_fd < 0) {
fprintf(stderr, "Failed to open file '%s': %s\n",
obj_file.c_str(), strerror(errno));
return false;
}
FDWrapper obj_fd_wrapper(obj_fd);
struct stat st;
if (fstat(obj_fd, &st) != 0 && st.st_size <= 0) {
fprintf(stderr, "Unable to fstat file '%s': %s\n",
obj_file.c_str(), strerror(errno));
return false;
}
*header = map_wrapper->set(obj_fd, st.st_size);
if (!(*header)) {
fprintf(stderr, "Failed to mmap file '%s': %s\n",
obj_file.c_str(), strerror(errno));
return false;
}
return true;
}
// Read the .gnu_debuglink and get the debug file name. If anything goes
// wrong, return an empty string.
template<typename ObjectFileReader>
string ReadDebugLink(const char* debuglink,
size_t debuglink_size,
const string& obj_file,
const std::vector<string>& debug_dirs) {
size_t debuglink_len = strlen(debuglink) + 5; // '\0' + CRC32.
debuglink_len = 4 * ((debuglink_len + 3) / 4); // Round to nearest 4 bytes.
// Sanity check.
if (debuglink_len != debuglink_size) {
fprintf(stderr, "Mismatched .gnu_debuglink string / section size: "
"%zx %zx\n", debuglink_len, debuglink_size);
return "";
}
bool found = false;
int debuglink_fd = -1;
string debuglink_path;
std::vector<string>::const_iterator it;
for (it = debug_dirs.begin(); it < debug_dirs.end(); ++it) {
const string& debug_dir = *it;
debuglink_path = debug_dir + "/" + debuglink;
debuglink_fd = open(debuglink_path.c_str(), O_RDONLY);
if (debuglink_fd >= 0) {
found = true;
break;
}
}
if (!found) {
fprintf(stderr, "Failed to find debug file for '%s' after trying:\n",
obj_file.c_str());
for (it = debug_dirs.begin(); it < debug_dirs.end(); ++it) {
const string debug_dir = *it;
fprintf(stderr, " %s/%s\n", debug_dir.c_str(), debuglink);
}
return "";
}
FDWrapper debuglink_fd_wrapper(debuglink_fd);
// TODO(thestig) check the CRC-32 at the end of the .gnu_debuglink
// section.
return debuglink_path;
}
//
// LoadSymbolsInfo
//
// Holds the state between the two calls to LoadSymbols() in case it's necessary
// to follow the .gnu_debuglink section and load debug information from a
// different file.
//
template<typename ObjectFileReader>
class LoadSymbolsInfo {
public:
typedef typename ObjectFileReader::Addr Addr;
explicit LoadSymbolsInfo(const std::vector<string>& dbg_dirs) :
debug_dirs_(dbg_dirs),
has_loading_addr_(false) {}
// Keeps track of which sections have been loaded so sections don't
// accidentally get loaded twice from two different files.
void LoadedSection(const string &section) {
if (loaded_sections_.count(section) == 0) {
loaded_sections_.insert(section);
} else {
fprintf(stderr, "Section %s has already been loaded.\n",
section.c_str());
}
}
// The file and linked debug file are expected to have the same preferred
// loading address.
void set_loading_addr(Addr addr, const string &filename) {
if (!has_loading_addr_) {
loading_addr_ = addr;
loaded_file_ = filename;
return;
}
if (addr != loading_addr_) {
fprintf(stderr,
"file '%s' and debug file '%s' "
"have different load addresses.\n",
loaded_file_.c_str(), filename.c_str());
assert(false);
}
}
// Setters and getters
const std::vector<string>& debug_dirs() const {
return debug_dirs_;
}
string debuglink_file() const {
return debuglink_file_;
}
void set_debuglink_file(string file) {
debuglink_file_ = file;
}
private:
const std::vector<string>& debug_dirs_; // Directories in which to
// search for the debug file.
string debuglink_file_; // Full path to the debug file.
bool has_loading_addr_; // Indicate if LOADING_ADDR_ is valid.
Addr loading_addr_; // Saves the preferred loading address from the
// first call to LoadSymbols().
string loaded_file_; // Name of the file loaded from the first call to
// LoadSymbols().
std::set<string> loaded_sections_; // Tracks the Loaded sections
// between calls to LoadSymbols().
};
template<typename ObjectFileReader>
bool LoadSymbols(const string& obj_file,
const bool big_endian,
const typename ObjectFileReader::ObjectFileBase header,
const bool read_gnu_debug_link,
LoadSymbolsInfo<ObjectFileReader>* info,
const DumpOptions& options,
Module* module) {
typedef typename ObjectFileReader::Addr Addr;
typedef typename ObjectFileReader::Section Shdr;
Addr loading_addr = ObjectFileReader::GetLoadingAddress(header);
module->SetLoadAddress(loading_addr);
info->set_loading_addr(loading_addr, obj_file);
bool found_debug_info_section = false;
bool found_usable_info = false;
if (options.symbol_data != ONLY_CFI) {
#ifndef NO_STABS_SUPPORT
// Look for STABS debugging information, and load it if present.
const Shdr stab_section =
ObjectFileReader::FindSectionByName(".stab", header);
if (stab_section) {
const Shdr stabstr_section = ObjectFileReader::FindLinkedSection(header, stab_section);
if (stabstr_section) {
found_debug_info_section = true;
found_usable_info = true;
info->LoadedSection(".stab");
if (!LoadStabs<ObjectFileReader>(header, stab_section, stabstr_section,
big_endian, module)) {
fprintf(stderr, "%s: \".stab\" section found, but failed to load"
" STABS debugging information\n", obj_file.c_str());
}
}
}
#endif // NO_STABS_SUPPORT
// Look for DWARF debugging information, and load it if present.
const Shdr dwarf_section =
ObjectFileReader::FindSectionByName(".debug_info", header);
if (dwarf_section) {
found_debug_info_section = true;
found_usable_info = true;
info->LoadedSection(".debug_info");
if (!LoadDwarf<ObjectFileReader>(obj_file, header, big_endian,
options.handle_inter_cu_refs, module)) {
fprintf(stderr, "%s: \".debug_info\" section found, but failed to load "
"DWARF debugging information\n", obj_file.c_str());
}
}
}
if (options.symbol_data != NO_CFI) {
// Dwarf Call Frame Information (CFI) is actually independent from
// the other DWARF debugging information, and can be used alone.
const Shdr dwarf_cfi_section =
ObjectFileReader::FindSectionByName(".debug_frame", header);
if (dwarf_cfi_section) {
// Ignore the return value of this function; even without call frame
// information, the other debugging information could be perfectly
// useful.
info->LoadedSection(".debug_frame");
bool result =
LoadDwarfCFI<ObjectFileReader>(obj_file, header, ".debug_frame",
dwarf_cfi_section, false, 0, 0, big_endian,
module);
found_usable_info = found_usable_info || result;
}
// Linux C++ exception handling information can also provide
// unwinding data.
const Shdr eh_frame_section =
ObjectFileReader::FindSectionByName(".eh_frame", header);
if (eh_frame_section) {
// Pointers in .eh_frame data may be relative to the base addresses of
// certain sections. Provide those sections if present.
const Shdr got_section =
ObjectFileReader::FindSectionByName(".got", header);
const Shdr text_section =
ObjectFileReader::FindSectionByName(".text", header);
info->LoadedSection(".eh_frame");
// As above, ignore the return value of this function.
bool result =
LoadDwarfCFI<ObjectFileReader>(obj_file, header, ".eh_frame",
eh_frame_section, true,
got_section, text_section, big_endian, module);
found_usable_info = found_usable_info || result;
}
}
if (!found_debug_info_section) {
fprintf(stderr, "%s: file contains no debugging information"
" (no \".stab\" or \".debug_info\" sections)\n",
obj_file.c_str());
// Failed, but maybe there's a .gnu_debuglink section?
if (read_gnu_debug_link) {
const Shdr gnu_debuglink_section
= ObjectFileReader::FindSectionByName(".gnu_debuglink", header);
if (gnu_debuglink_section) {
if (!info->debug_dirs().empty()) {
const char* debuglink_contents = reinterpret_cast<const char *>
(ObjectFileReader::GetSectionPointer(header, gnu_debuglink_section));
string debuglink_file
= ReadDebugLink<ObjectFileReader>(debuglink_contents,
ObjectFileReader::GetSectionSize(header, gnu_debuglink_section),
obj_file, info->debug_dirs());
info->set_debuglink_file(debuglink_file);
} else {
fprintf(stderr, ".gnu_debuglink section found in '%s', "
"but no debug path specified.\n", obj_file.c_str());
}
} else {
fprintf(stderr, "%s does not contain a .gnu_debuglink section.\n",
obj_file.c_str());
}
} else {
if (options.symbol_data != ONLY_CFI) {
// The caller doesn't want to consult .gnu_debuglink.
// See if there are export symbols available.
bool result = ObjectFileReader::ExportedSymbolsToModule(header, module);
found_usable_info = found_usable_info || result;
}
// Return true if some usable information was found, since
// the caller doesn't want to use .gnu_debuglink.
return found_usable_info;
}
// No debug info was found, let the user try again with .gnu_debuglink
// if present.
return false;
}
return true;
}
// Return the non-directory portion of FILENAME: the portion after the
// last slash, or the whole filename if there are no slashes.
string BaseFileName(const string &filename) {
// Lots of copies! basename's behavior is less than ideal.
char *c_filename = strdup(filename.c_str());
string base = basename(c_filename);
free(c_filename);
return base;
}
template<typename ObjectFileReader>
bool ReadSymbolDataFromObjectFile(
const typename ObjectFileReader::ObjectFileBase header,
const string& obj_filename,
const std::vector<string>& debug_dirs,
const DumpOptions& options,
Module** out_module) {
typedef typename ObjectFileReader::Section Shdr;
*out_module = NULL;
string identifier = ObjectFileReader::FileIdentifierFromMappedFile(header);
if (identifier.empty()) {
fprintf(stderr, "%s: unable to generate file identifier\n",
obj_filename.c_str());
return false;
}
const char *architecture = ObjectFileReader::Architecture(header);
if (!architecture) {
return false;
}
// Figure out what endianness this file is.
bool big_endian;
if (!ObjectFileReader::Endianness(header, &big_endian))
return false;
string name = BaseFileName(obj_filename);
string os = "windows";
string id = identifier;
LoadSymbolsInfo<ObjectFileReader> info(debug_dirs);
scoped_ptr<Module> module(new Module(name, os, architecture, id));
if (!LoadSymbols<ObjectFileReader>(obj_filename, big_endian, header,
!debug_dirs.empty(), &info,
options, module.get())) {
const string debuglink_file = info.debuglink_file();
if (debuglink_file.empty())
return false;
// Load debuglink file.
fprintf(stderr, "Found debugging info in %s\n", debuglink_file.c_str());
MmapWrapper debug_map_wrapper;
typename ObjectFileReader::ObjectFileBase debug_header = NULL;
if (!LoadFile(debuglink_file, &debug_map_wrapper,
reinterpret_cast<const void**>(&debug_header)))
return false;
if (!ObjectFileReader::IsValid(debug_header)) {
fprintf(stderr, "Not a valid file: %s\n", debuglink_file.c_str());
return false;
}
// Sanity checks to make sure everything matches up.
const char *debug_architecture =
ObjectFileReader::Architecture(debug_header);
if (!debug_architecture) {
return false;
}
if (strcmp(architecture, debug_architecture)) {
fprintf(stderr, "%s with machine architecture %s does not match "
"%s with architecture %s\n",
debuglink_file.c_str(), debug_architecture,
obj_filename.c_str(), architecture);
return false;
}
bool debug_big_endian;
if (!ObjectFileReader::Endianness(debug_header, &debug_big_endian))
return false;
if (debug_big_endian != big_endian) {
fprintf(stderr, "%s and %s does not match in endianness\n",
obj_filename.c_str(), debuglink_file.c_str());
return false;
}
if (!LoadSymbols<ObjectFileReader>(debuglink_file, debug_big_endian,
debug_header, false, &info,
options, module.get())) {
return false;
}
}
*out_module = module.release();
return true;
}
} // namespace
#endif // COMMON_PECOFF_DUMP_SYMBOLS_INL_H

90
thirdparty/breakpad/common/pecoff/dump_symbols.cc vendored Normal file
View File

@@ -0,0 +1,90 @@
// Copyright (c) 2011 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.
#include "common/pecoff/dump_symbols.h"
#include "common/pecoff/pecoffutils.h"
#include "common/pecoff/dump_symbols-inl.h"
namespace google_breakpad {
// Not explicitly exported, but not static so it can be used in unit tests.
bool ReadSymbolDataInternal(const uint8_t* obj_file,
const string& obj_filename,
const std::vector<string>& debug_dirs,
const DumpOptions& options,
Module** module) {
if (!IsValidPeCoff(obj_file)) {
fprintf(stderr, "Not a valid PE/COFF file: %s\n", obj_filename.c_str());
return false;
}
int peclass = PeCoffClass(obj_file);
if (peclass == PE32) {
return ReadSymbolDataFromObjectFile<PeCoffClass32>(
reinterpret_cast<const PeCoffClass32::ObjectFileBase>(obj_file), obj_filename, debug_dirs,
options, module);
}
if (peclass == PE32PLUS) {
return ReadSymbolDataFromObjectFile<PeCoffClass64>(
reinterpret_cast<const PeCoffClass64::ObjectFileBase>(obj_file), obj_filename, debug_dirs,
options, module);
}
return false;
}
bool WriteSymbolFile(const string &obj_file,
const std::vector<string>& debug_dirs,
const DumpOptions& options,
std::ostream &sym_stream) {
Module* module;
if (!ReadSymbolData(obj_file, debug_dirs, options, &module))
return false;
bool result = module->Write(sym_stream, options.symbol_data);
delete module;
return result;
}
bool ReadSymbolData(const string& obj_file,
const std::vector<string>& debug_dirs,
const DumpOptions& options,
Module** module) {
MmapWrapper map_wrapper;
const void* pe_header = NULL;
if (!LoadFile(obj_file, &map_wrapper, &pe_header))
return false;
return ReadSymbolDataInternal(reinterpret_cast<const uint8_t*>(pe_header),
obj_file, debug_dirs, options, module);
}
} // namespace google_breakpad

80
thirdparty/breakpad/common/pecoff/dump_symbols.h vendored Normal file
View File

@@ -0,0 +1,80 @@
// -*- mode: c++ -*-
// Copyright (c) 2011, 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.
// dump_symbols.h: Read debugging information from a PECOFF file, and write
// it out as a Breakpad symbol file.
#ifndef COMMON_PECOFF_DUMP_SYMBOLS_H__
#define COMMON_PECOFF_DUMP_SYMBOLS_H__
#include <iostream>
#include <string>
#include <vector>
#include "common/symbol_data.h"
#include "common/using_std_string.h"
namespace google_breakpad {
class Module;
struct DumpOptions {
DumpOptions(SymbolData symbol_data, bool handle_inter_cu_refs)
: symbol_data(symbol_data),
handle_inter_cu_refs(handle_inter_cu_refs) {
}
SymbolData symbol_data;
bool handle_inter_cu_refs;
};
// Find all the debugging information in OBJ_FILE, an PECOFF executable
// or shared library, and write it to SYM_STREAM in the Breakpad symbol
// file format.
// If OBJ_FILE has been stripped but contains a .gnu_debuglink section,
// then look for the debug file in DEBUG_DIRS.
// SYMBOL_DATA allows limiting the type of symbol data written.
bool WriteSymbolFile(const string &obj_file,
const std::vector<string>& debug_dirs,
const DumpOptions& options,
std::ostream &sym_stream);
// As above, but simply return the debugging information in MODULE
// instead of writing it to a stream. The caller owns the resulting
// Module object and must delete it when finished.
bool ReadSymbolData(const string& obj_file,
const std::vector<string>& debug_dirs,
const DumpOptions& options,
Module** module);
} // namespace google_breakpad
#endif // COMMON_PECOFF_DUMP_SYMBOLS_H__

262
thirdparty/breakpad/common/pecoff/pecoff.h vendored Normal file
View File

@@ -0,0 +1,262 @@
// Copyright (c) 2014 Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// pecoff.h: PECOFF file format
//
#ifndef COMMON_PECOFF_PECOFF_H__
#define COMMON_PECOFF_PECOFF_H__
#include <stdint.h>
#define IMAGE_FILE_HEADER_OFFSET 0x3c
#define IMAGE_FILE_MAGIC 0x00004550 // "PE\0\0"
#define IMAGE_FILE_MACHINE_UNKNOWN 0x0000
#define IMAGE_FILE_MACHINE_ALPHA 0x0184
#define IMAGE_FILE_MACHINE_ALPHA64 0x0284
#define IMAGE_FILE_MACHINE_AM33 0x01d3
#define IMAGE_FILE_MACHINE_AMD64 0x8664
#define IMAGE_FILE_MACHINE_ARM 0x01c0
#define IMAGE_FILE_MACHINE_ARMV7 0x01c4
#define IMAGE_FILE_MACHINE_CEE 0xc0ee
#define IMAGE_FILE_MACHINE_CEF 0x0cef
#define IMAGE_FILE_MACHINE_EBC 0x0ebc
#define IMAGE_FILE_MACHINE_I386 0x014c
#define IMAGE_FILE_MACHINE_IA64 0x0200
#define IMAGE_FILE_MACHINE_M32R 0x9041
#define IMAGE_FILE_MACHINE_M68K 0x0268
#define IMAGE_FILE_MACHINE_MIPS16 0x0266
#define IMAGE_FILE_MACHINE_MIPSFPU 0x0366
#define IMAGE_FILE_MACHINE_MIPSFPU16 0x0466
#define IMAGE_FILE_MACHINE_POWERPC 0x01f0
#define IMAGE_FILE_MACHINE_POWERPCFP 0x01f1
#define IMAGE_FILE_MACHINE_R10000 0x0168
#define IMAGE_FILE_MACHINE_R3000 0x0162
#define IMAGE_FILE_MACHINE_R4000 0x0166
#define IMAGE_FILE_MACHINE_SH3 0x01a2
#define IMAGE_FILE_MACHINE_SH3DSP 0x01a3
#define IMAGE_FILE_MACHINE_SH3E 0x01a4
#define IMAGE_FILE_MACHINE_SH4 0x01a6
#define IMAGE_FILE_MACHINE_SH5 0x01a8
#define IMAGE_FILE_MACHINE_THUMB 0x01c2
#define IMAGE_FILE_MACHINE_TRICORE 0x0520
#define IMAGE_FILE_MACHINE_WCEMIPSV2 0x0169
#define IMAGE_FILE_MACHINE_AMD64 0x8664
struct PeHeader {
uint32_t mMagic; // IMAGE_FILE_MAGIC
uint16_t mMachine; // IMAGE_FILE_MACHINE_* values
uint16_t mNumberOfSections;
uint32_t mTimeDateStamp;
uint32_t mPointerToSymbolTable;
uint32_t mNumberOfSymbols;
uint16_t mSizeOfOptionalHeader;
uint16_t mCharacteristics;
};
enum PeMagic {
PE32 = 0x010b, // 32 bit
PE32PLUS = 0x020b, // 64 bit address space, 2GB image size limit
};
struct PeDataDirectory {
uint32_t mVirtualAddress;
uint32_t mSize;
};
struct Pe32OptionalHeader {
uint16_t mMagic; // PeMagic
uint8_t mMajorLinkerVersion;
uint8_t mMinorLinkerVersion;
uint32_t mSizeOfCode;
uint32_t mSizeOfInitializedData;
uint32_t mSizeOfUninitializedData;
uint32_t mAddressOfEntryPoint;
uint32_t mBaseOfCode;
uint32_t mBaseOfData;
uint32_t mImageBase;
uint32_t mSectionAlignment;
uint32_t mFileAlignment;
uint16_t mMajorOperatingSystemVersion;
uint16_t mMinorOperatingSystemVersion;
uint16_t mMajorImageVersion;
uint16_t mMinorImageVersion;
uint16_t mMajorSubsystemVersion;
uint16_t mMinorSubsystemVersion;
uint32_t mWin32VersionValue;
uint32_t mSizeOfImage;
uint32_t mSizeOfHeaders;
uint32_t mCheckSum;
uint16_t mSubsystem;
uint16_t mDllCharacteristics;
uint32_t mSizeOfStackReserve;
uint32_t mSizeOfStackCommit;
uint32_t mSizeOfHeapReserve;
uint32_t mSizeOfHeapCommit;
uint32_t mLoaderFlags;
uint32_t mNumberOfRvaAndSizes;
PeDataDirectory mDataDirectory[0];
};
struct Pe32PlusOptionalHeader {
uint16_t mMagic; // PeMagic
uint8_t mMajorLinkerVersion;
uint8_t mMinorLinkerVersion;
uint32_t mSizeOfCode;
uint32_t mSizeOfInitializedData;
uint32_t mSizeOfUninitializedData;
uint32_t mAddressOfEntryPoint;
uint32_t mBaseOfCode;
uint64_t mImageBase;
uint32_t mSectionAlignment;
uint32_t mFileAlignment;
uint16_t mMajorOperatingSystemVersion;
uint16_t mMinorOperatingSystemVersion;
uint16_t mMajorImageVersion;
uint16_t mMinorImageVersion;
uint16_t mMajorSubsystemVersion;
uint16_t mMinorSubsystemVersion;
uint32_t mWin32VersionValue;
uint32_t mSizeOfImage;
uint32_t mSizeOfHeaders;
uint32_t mCheckSum;
uint16_t mSubsystem;
uint16_t mDllCharacteristics;
uint64_t mSizeOfStackReserve;
uint64_t mSizeOfStackCommit;
uint64_t mSizeOfHeapReserve;
uint64_t mSizeOfHeapCommit;
uint32_t mLoaderFlags;
uint32_t mNumberOfRvaAndSizes;
PeDataDirectory mDataDirectory[0];
};
#define PE_EXPORT_TABLE 0
#define PE_IMPORT_TABLE 1
#define PE_RESOURCE_TABLE 2
#define PE_EXCEPTION_TABLE 3
#define PE_CERTIFICATE_TABLE 4
#define PE_BASE_RELOCATION_TABLE 5
#define PE_DEBUG_DATA 6
#define PE_ARCHITECTURE 7
#define PE_GLOBAL_PTR 8
#define PE_TLS_TABLE 9
#define PE_LOAD_CONFIG_TABLE 10
#define PE_BOUND_IMPORT_TABLE 11
#define PE_IMPORT_ADDRESS_TABLE 12
#define PE_DELAY_IMPORT_DESCRIPTOR 13
#define PE_CLR_RUNTIME_HEADER 14
struct PeDebugDirectory {
uint32_t mCharacteristics;
uint32_t mTimeDateStamp;
uint16_t mMajorVersion;
uint16_t mMinorVersion;
uint32_t mType;
uint32_t mSizeOfData;
uint32_t mAddressOfRawData;
uint32_t mPointerToRawData;
};
#define IMAGE_DEBUG_TYPE_UNKNOWN 0
#define IMAGE_DEBUG_TYPE_COFF 1
#define IMAGE_DEBUG_TYPE_CODEVIEW 2
#define IMAGE_DEBUG_TYPE_FPO 3
#define IMAGE_DEBUG_TYPE_MISC 4
#define IMAGE_DEBUG_TYPE_EXCEPTION 5
#define IMAGE_DEBUG_TYPE_FIXUP 6
#define IMAGE_DEBUG_TYPE_OMAP_TO_SRC 7
#define IMAGE_DEBUG_TYPE_OMAP_FROM_SRC 8
#define IMAGE_DEBUG_TYPE_BORLAND 9
#define IMAGE_DEBUG_TYPE_RESERVED10 10
#define IMAGE_DEBUG_TYPE_CLSID 11
struct CvInfoPbd70
{
uint32_t mCvSignature;
uint8_t mSignature[16];
uint32_t mAge;
uint8_t mPdbFileName[];
};
#define CODEVIEW_PDB70_CVSIGNATURE 0x53445352 // "RSDS"
#define CODEVIEW_PDB20_CVSIGNATURE 0x3031424e // "NB10"
#define CODEVIEW_CV50_CVSIGNATURE 0x3131424e // "NB11"
#define CODEVIEW_CV41_CVSIGNATURE 0x3930424e // “NB09"
struct PeSectionHeader {
char mName[8];
union {
uint32_t mPhysicalAddress;
uint32_t mVirtualSize;
} ;
uint32_t mVirtualAddress;
uint32_t mSizeOfRawData;
uint32_t mPointerToRawData;
uint32_t mPointerToRelocations;
uint32_t mPointerToLinenumbers;
uint16_t mNumberOfRelocations;
uint16_t mNumberOfLinenumbers;
uint32_t mCharacteristics;
};
struct __attribute__ ((__packed__)) PeSymbol
{
union {
char mName[8]; // Symbol Name
struct {
uint32_t mFirst4Bytes;
uint32_t mSecond4Bytes;
};
};
uint32_t mValue; // Value of Symbol
uint16_t mScNum; // Section Number
uint16_t mType; // Symbol Type
uint8_t mSClass; // Storage Class
uint8_t mNumAux; // Auxiliary Count
};
struct PeExportTable {
uint32_t mFlags;
uint32_t mTimeDateStamp;
uint16_t mMajorVersion;
uint16_t mMinorVErsion;
uint32_t mNameRVA;
uint32_t mOrdinalBase;
uint32_t mAddressTableEntries;
uint32_t mNumberofNamePointers;
uint32_t mExportAddressTableRVA;
uint32_t mNamePointerRVA;
uint32_t mOrdinalTableRVA;
};
#endif// COMMON_PECOFF_PECOFF_H__

91
thirdparty/breakpad/common/pecoff/pecoff_file_id.cc vendored Normal file
View File

@@ -0,0 +1,91 @@
// Copyright (c) 2006, 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.
//
// pecoff_file_id.cc: Return a unique identifier for a file
//
#include "common/pecoff/pecoff_file_id.h"
#include <string.h>
#include "common/pecoff/pecoffutils.h"
namespace google_breakpad {
// Attempt to locate a CodeView build-id section in a PECOFF binary
// and copy as many bytes of it as will fit into |identifier|.
static bool FindPeCoffBuildID(const uint8_t* mapped_base,
uint8_t identifier[kMDGUIDSize],
uint32_t *age) {
int peclass = PeCoffClass(mapped_base);
if (peclass == PE32)
return PeCoffClass32::GetBuildID(mapped_base, identifier, age);
if (peclass == PE32PLUS)
return PeCoffClass64::GetBuildID(mapped_base, identifier, age);
return false;
}
// Attempt to locate the .text section of a binary and generate
// a simple hash by XORing the first page worth of bytes into |identifier|.
static bool HashPeCoffTextSection(const uint8_t* mapped_base,
uint8_t identifier[kMDGUIDSize]) {
int peclass = PeCoffClass(mapped_base);
if (peclass == PE32)
return PeCoffClass32::HashTextSection(mapped_base, identifier);
if (peclass == PE32PLUS)
return PeCoffClass64::HashTextSection(mapped_base, identifier);
return false;
}
bool PeCoffFileID::PeCoffFileIdentifierFromMappedFile(const void* base,
uint8_t identifier[kMDGUIDSize],
uint32_t *age) {
*age = 0;
// Look for a build id first.
if (FindPeCoffBuildID(reinterpret_cast<const uint8_t *>(base), identifier,
age))
return true;
#if 1
// XXX: Fallback to a default debug_identifier.
memset(identifier, 0, kMDGUIDSize);
*age = 0;
return true;
#else
// Fall back on hashing the first page of the text section.
// (This is of questionable value as the Windows Minidump writer doesn't have
// this feature)
return HashPeCoffTextSection(reinterpret_cast<const uint8_t *>(base),
identifier);
#endif
}
} // namespace google_breakpad

52
thirdparty/breakpad/common/pecoff/pecoff_file_id.h vendored Normal file
View File

@@ -0,0 +1,52 @@
// Copyright (c) 2006, 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.
//
// pecoff_file_id.h: Return a unique identifier for a file
//
#ifndef COMMON_PECOFF_PECOFF_FILE_ID_H__
#define COMMON_PECOFF_PECOFF_FILE_ID_H__
#include <stddef.h>
#include <stdint.h>
namespace google_breakpad {
static const size_t kMDGUIDSize = 16;
class PeCoffFileID {
public:
static bool PeCoffFileIdentifierFromMappedFile(const void* base,
uint8_t identifier[kMDGUIDSize],
uint32_t* age);
};
} // namespace google_breakpad
#endif // COMMON_PECOFF_PECOFF_FILE_ID_H__

490
thirdparty/breakpad/common/pecoff/pecoffutils.cc vendored Normal file
View File

@@ -0,0 +1,490 @@
// Copyright (c) 2014 Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// pecoffutils.c: Utilities for dealing with PECOFF files
//
#include "common/pecoff/pecoffutils.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef _WIN32
#include <arpa/inet.h>
#endif
namespace google_breakpad {
bool IsValidPeCoff(const uint8_t* obj_base) {
// at offset 0x3c, find the offset to PE signature
const uint32_t* peOffsetPtr = reinterpret_cast<const uint32_t*>(obj_base +
IMAGE_FILE_HEADER_OFFSET);
// TODO: ideally we want to check that the offset is less than the size of the
// mapped file, but we don't have that information at the moment
//
// if (*peOffsetPtr > size) return FALSE;
// check PE signature
const PeHeader* peHeader = reinterpret_cast<const PeHeader*>(obj_base+*peOffsetPtr);
if (peHeader->mMagic != IMAGE_FILE_MAGIC)
return false;
return true;
}
int PeCoffClass(const uint8_t* obj_base) {
const uint32_t* peOffsetPtr = reinterpret_cast<const uint32_t*>(obj_base +
IMAGE_FILE_HEADER_OFFSET);
const PeHeader* peHeader = reinterpret_cast<const PeHeader*>(obj_base+*peOffsetPtr);
const uint16_t* peOptionalHeader = reinterpret_cast<const uint16_t*>
(reinterpret_cast<const uint8_t*>(peHeader) + sizeof(PeHeader));
// We need to read the magic before we know if this a Pe32OptionalHeader or
// Pe32PlusOptionalHeader, so we don't use those types here.
return *peOptionalHeader;
}
//
// Header information
//
template<typename PeCoffClassTraits>
const char* PeCoffObjectFileReader<PeCoffClassTraits>::Architecture(
ObjectFileBase obj_base) {
const PeHeader* peHeader = GetHeader(obj_base);
uint16_t arch = peHeader->mMachine;
switch (arch) {
case IMAGE_FILE_MACHINE_I386:
return "x86";
case IMAGE_FILE_MACHINE_ARM:
return "arm";
case IMAGE_FILE_MACHINE_MIPS16:
case IMAGE_FILE_MACHINE_MIPSFPU:
case IMAGE_FILE_MACHINE_MIPSFPU16:
case IMAGE_FILE_MACHINE_WCEMIPSV2:
return "mips";
case IMAGE_FILE_MACHINE_POWERPC:
case IMAGE_FILE_MACHINE_POWERPCFP:
return "ppc";
case IMAGE_FILE_MACHINE_AMD64:
return "x86_64";
default:
fprintf(stderr, "unrecognized machine architecture: %d\n",
peHeader->mMachine);
return NULL;
}
}
template<typename PeCoffClassTraits>
bool PeCoffObjectFileReader<PeCoffClassTraits>::Endianness(
ObjectFileBase obj_base,
bool* big_endian) {
// TODO: Not sure what big-endian PECOFF looks like: characteristics flag
// IMAGE_FILE_BYTES_REVERSED_HI and/or certain machine types are big-endian
*big_endian = false;
return true;
}
template<typename PeCoffClassTraits>
typename PeCoffObjectFileReader<PeCoffClassTraits>::Addr
PeCoffObjectFileReader<PeCoffClassTraits>::GetLoadingAddress(
ObjectFileBase obj_base) {
const PeOptionalHeader* peOptionalHeader = GetOptionalHeader(obj_base);
return peOptionalHeader->mImageBase;
}
//
// Section enumeration and location
//
template<typename PeCoffClassTraits>
int PeCoffObjectFileReader<PeCoffClassTraits>::GetNumberOfSections(
ObjectFileBase obj_base) {
const PeHeader* peHeader = GetHeader(obj_base);
return peHeader->mNumberOfSections;
}
template<typename PeCoffClassTraits>
const typename PeCoffObjectFileReader<PeCoffClassTraits>::Section
PeCoffObjectFileReader<PeCoffClassTraits>::FindSectionByIndex(
ObjectFileBase obj_base, int i) {
const PeSectionHeader* section_table = GetSectionTable(obj_base);
return reinterpret_cast<const Section>(&(section_table[i]));
}
template<typename PeCoffClassTraits>
const typename PeCoffObjectFileReader<PeCoffClassTraits>::Section
PeCoffObjectFileReader<PeCoffClassTraits>::FindSectionByName(
const char* section_name, ObjectFileBase obj_base) {
const PeHeader* peHeader = GetHeader(obj_base);
const PeSectionHeader* section_table = GetSectionTable(obj_base);
const char* string_table = GetStringTable(obj_base);
uint32_t string_table_length = *(reinterpret_cast<const uint32_t*>(string_table));
for (int s = 0; s < peHeader->mNumberOfSections; s++) {
const char* name = section_table[s].mName;
// look up long section names in string table
if (name[0] == '/') {
unsigned int offset = ::strtoul(section_table[s].mName+1, NULL, 10);
if (offset > string_table_length)
fprintf(stderr, "section name offset %d exceeds string table length",
offset);
else
name = string_table + offset;
}
if (::strcmp(section_name, name) == 0) {
return reinterpret_cast<const Section>(&(section_table[s]));
}
}
// nothing found
return NULL;
}
//
// Section information
//
template<typename PeCoffClassTraits>
const uint8_t*
PeCoffObjectFileReader<PeCoffClassTraits>::GetSectionPointer(
ObjectFileBase obj_base, Section section) {
return reinterpret_cast<const uint8_t*>(obj_base) + reinterpret_cast<const PeSectionHeader*>(section)->mPointerToRawData;
}
template<typename PeCoffClassTraits>
typename PeCoffObjectFileReader<PeCoffClassTraits>::Offset
PeCoffObjectFileReader<PeCoffClassTraits>::GetSectionSize(
ObjectFileBase obj_base, Section section) {
// There are mSizeOfRawData bytes of data for the section in the mapped image
// file. Return mVirtualSize if it's smaller.
// This doesn't handle the case where mVirtualSize is larger and the section
// should be zero padded, because we have nowhere to do that.
if ((reinterpret_cast<const PeSectionHeader*>(section)->mVirtualSize) <
(reinterpret_cast<const PeSectionHeader*>(section)->mSizeOfRawData))
return reinterpret_cast<const PeSectionHeader*>(section)->mVirtualSize;
return reinterpret_cast<const PeSectionHeader*>(section)->mSizeOfRawData;
}
template<typename PeCoffClassTraits>
typename PeCoffObjectFileReader<PeCoffClassTraits>::Offset
PeCoffObjectFileReader<PeCoffClassTraits>::GetSectionRVA(
ObjectFileBase obj_base, Section section) {
return reinterpret_cast<const PeSectionHeader*>(section)->mVirtualAddress;
}
template<typename PeCoffClassTraits>
const char* PeCoffObjectFileReader<PeCoffClassTraits>::GetSectionName(
ObjectFileBase obj_base,Section section) {
const char* string_table = GetStringTable(obj_base);
uint32_t string_table_length = *(reinterpret_cast<const uint32_t*>(string_table));
const char* name = reinterpret_cast<const PeSectionHeader*>(section)->mName;
// look up long section names in string table
if (name[0] == '/') {
unsigned int offset = ::strtoul(name+1, NULL, 10);
if (offset > string_table_length)
fprintf(stderr, "section name offset %d exceeds string table length",
offset);
else
name = string_table + offset;
}
return name;
}
//
//
//
template<class PeCoffClassTraits>
bool PeCoffObjectFileReader<PeCoffClassTraits>::ExportedSymbolsToModule(
ObjectFileBase obj_base, Module* module) {
// locate the export table, if present
const PeDataDirectory* data_directory_export_entry = GetDataDirectoryEntry(obj_base, PE_EXPORT_TABLE);
if (data_directory_export_entry && data_directory_export_entry->mSize != 0) {
const PeExportTable* export_table = reinterpret_cast<const PeExportTable*>(ConvertRVAToPointer(obj_base, data_directory_export_entry->mVirtualAddress));
const uint32_t* eat = reinterpret_cast<const uint32_t*>(ConvertRVAToPointer(obj_base, export_table->mExportAddressTableRVA));
const uint32_t* enpt = reinterpret_cast<const uint32_t*>(ConvertRVAToPointer(obj_base, export_table->mNamePointerRVA));
const uint16_t* eot = reinterpret_cast<const uint16_t*>(ConvertRVAToPointer(obj_base, export_table->mOrdinalTableRVA));
// process the export name pointer table
for (uint32_t i = 0; i < export_table->mNumberofNamePointers; i++) {
// look up the name for the export
uint32_t export_name_rva = enpt[i];
if (export_name_rva == 0)
continue;
const char* export_name = reinterpret_cast<const char*>(ConvertRVAToPointer(obj_base, export_name_rva));
// find the corresponding export address table entry
uint16_t export_ordinal = eot[i];
if ((export_ordinal < export_table->mOrdinalBase) ||
(export_ordinal >= (export_table->mOrdinalBase + export_table->mAddressTableEntries))) {
fprintf(stderr, "exported ordinal %d out of range for EAT!\n", export_ordinal);
continue;
}
uint32_t eat_index = export_ordinal - export_table->mOrdinalBase;
uint32_t export_rva = eat[eat_index];
// if the export's address lies inside the export table, it's a forwarded
// export, which we can ignore
if ((export_rva >= data_directory_export_entry->mVirtualAddress) &&
(export_rva < (data_directory_export_entry->mVirtualAddress + data_directory_export_entry->mSize)))
continue;
Module::Extern* ext = new Module::Extern;
ext->name = export_name;
ext->address = export_rva + GetLoadingAddress(obj_base);
module->AddExtern(ext);
}
return true;
}
// report if a COFF symbol table exists, but we don't use it (yet)
// According to the PECOFF spec. COFF debugging information is deprecated.
// We don't know of any tools which produce that and don't produce DWARF or
// MS CodeView debug information.
const PeHeader* peHeader = GetHeader(obj_base);
if (peHeader->mPointerToSymbolTable) {
fprintf(stderr, "COFF debug symbols present but are not implemented\n");
}
return false;
}
template<class PeCoffClassTraits>
string
PeCoffObjectFileReader<PeCoffClassTraits>::FileIdentifierFromMappedFile(
ObjectFileBase obj_file) {
uint8_t identifier[kMDGUIDSize];
uint32_t age;
if (!PeCoffFileID::PeCoffFileIdentifierFromMappedFile(obj_file, identifier, &age))
return "";
// Endian-ness swap to match dump processor expectation.
uint8_t identifier_swapped[kMDGUIDSize];
memcpy(identifier_swapped, identifier, kMDGUIDSize);
uint32_t* data1 = reinterpret_cast<uint32_t*>(identifier_swapped);
*data1 = htonl(*data1);
uint16_t* data2 = reinterpret_cast<uint16_t*>(identifier_swapped + 4);
*data2 = htons(*data2);
uint16_t* data3 = reinterpret_cast<uint16_t*>(identifier_swapped + 6);
*data3 = htons(*data3);
// Format the file identifier in IDENTIFIER as a UUID with the
// dashes removed.
char identifier_str[40];
int buffer_idx = 0;
for (int idx = 0; idx < kMDGUIDSize; ++idx) {
int hi = (identifier_swapped[idx] >> 4) & 0x0F;
int lo = (identifier_swapped[idx]) & 0x0F;
identifier_str[buffer_idx++] = (hi >= 10) ? 'A' + hi - 10 : '0' + hi;
identifier_str[buffer_idx++] = (lo >= 10) ? 'A' + lo - 10 : '0' + lo;
}
identifier_str[buffer_idx] = 0;
string id = identifier_str;
// Append age
char age_string[9];
snprintf(age_string, sizeof(age_string) / sizeof(age_string[0]), "%X", age);
id += age_string;
return id;
}
//
// Helper functions for PeCoffFileID
//
template<typename PeCoffClassTraits>
bool PeCoffObjectFileReader<PeCoffClassTraits>::GetBuildID(
ObjectFileBase obj_base,
uint8_t identifier[kMDGUIDSize],
uint32_t* age) {
// locate the debug directory, if present
const PeDataDirectory* data_directory_debug_entry = GetDataDirectoryEntry(obj_base, PE_DEBUG_DATA);
if (!data_directory_debug_entry)
return false;
uint32_t debug_directory_size = data_directory_debug_entry->mSize;
if (debug_directory_size == 0)
return false;
const PeDebugDirectory* debug_directory = reinterpret_cast<const PeDebugDirectory*>(ConvertRVAToPointer(obj_base, data_directory_debug_entry->mVirtualAddress));
if (debug_directory == NULL) {
fprintf(stderr, "No section containing the debug directory VMA could be found\n");
return false;
}
// search the debug directory for a codeview entry
for (int i = 0; i < debug_directory_size/sizeof(PeDebugDirectory); i++) {
if (debug_directory[i].mType == IMAGE_DEBUG_TYPE_CODEVIEW) {
// interpret the codeview record to get build-id
const CvInfoPbd70* codeview_record = reinterpret_cast<const CvInfoPbd70*>
(obj_base + debug_directory[i].mPointerToRawData);
if ((codeview_record->mCvSignature) == CODEVIEW_PDB70_CVSIGNATURE) {
memcpy(identifier, codeview_record->mSignature, kMDGUIDSize);
*age = codeview_record->mAge;
return true;
} else {
fprintf(stderr, "Unhandled codeview signature %x\n",
codeview_record->mCvSignature);
}
}
}
fprintf(stderr, "No codeview entry in debug directory\n");
return false;
}
template<typename PeCoffClassTraits>
bool PeCoffObjectFileReader<PeCoffClassTraits>::HashTextSection(
ObjectFileBase obj_base,
uint8_t identifier[kMDGUIDSize]) {
Section text_section;
Offset text_size;
if (!(text_section = FindSectionByName(".text", obj_base)) ||
((text_size = GetSectionSize(obj_base, text_section)) == 0))
return false;
memset(identifier, 0, kMDGUIDSize);
const uint8_t* ptr = GetSectionPointer(obj_base, text_section);
const uint8_t* ptr_end = ptr + std::min(text_size, 4096U);
while (ptr < ptr_end) {
for (unsigned i = 0; i < kMDGUIDSize; i++)
identifier[i] ^= ptr[i];
ptr += kMDGUIDSize;
}
return true;
}
//
// Private implementation helper functions
//
template<typename PeCoffClassTraits>
const PeHeader* PeCoffObjectFileReader<PeCoffClassTraits>::GetHeader(
ObjectFileBase obj_base) {
const uint32_t* peOffsetPtr = reinterpret_cast<const uint32_t*>(obj_base +
IMAGE_FILE_HEADER_OFFSET);
const PeHeader* peHeader = reinterpret_cast<const PeHeader*>(obj_base+*peOffsetPtr);
return peHeader;
}
template<typename PeCoffClassTraits>
const typename PeCoffObjectFileReader<PeCoffClassTraits>::PeOptionalHeader*
PeCoffObjectFileReader<PeCoffClassTraits>::GetOptionalHeader(
ObjectFileBase obj_base) {
const PeHeader* peHeader = GetHeader(obj_base);
PeOptionalHeader* peOptionalHeader = (PeOptionalHeader*) ((uint32_t*)peHeader + 6);
return peOptionalHeader;
}
template<typename PeCoffClassTraits>
const PeSectionHeader*
PeCoffObjectFileReader<PeCoffClassTraits>::GetSectionTable(
ObjectFileBase obj_base) {
const PeHeader* peHeader = GetHeader(obj_base);
const PeOptionalHeader* peOptionalHeader = GetOptionalHeader(obj_base);
// section table immediately follows optional header
const PeSectionHeader* section_table = reinterpret_cast<const PeSectionHeader*>
(reinterpret_cast<const uint8_t*>(peOptionalHeader) + peHeader->mSizeOfOptionalHeader);
return section_table;
}
template<typename PeCoffClassTraits>
const char* PeCoffObjectFileReader<PeCoffClassTraits>::GetStringTable(
ObjectFileBase obj_base) {
const PeHeader* peHeader = GetHeader(obj_base);
// string table immediately follows symbol table
uint32_t string_table_offset = peHeader->mPointerToSymbolTable + peHeader->mNumberOfSymbols*sizeof(PeSymbol);
const char* string_table = reinterpret_cast<const char*>(obj_base) + string_table_offset;
return string_table;
}
template<class PeCoffClassTraits>
const PeDataDirectory*
PeCoffObjectFileReader<PeCoffClassTraits>::GetDataDirectoryEntry(
ObjectFileBase obj_base, int entry) {
const PeOptionalHeader* peOptionalHeader = GetOptionalHeader(obj_base);
// the data directory immediately follows the optional header
const PeDataDirectory* data_directory = reinterpret_cast<const PeDataDirectory*>(&peOptionalHeader->mDataDirectory[0]);
uint32_t data_directory_size = peOptionalHeader->mNumberOfRvaAndSizes;
// locate the required directory entry, if present
if (data_directory_size < entry)
return NULL;
return &data_directory[entry];
}
template<typename PeCoffClassTraits>
const uint8_t*
PeCoffObjectFileReader<PeCoffClassTraits>::ConvertRVAToPointer(
ObjectFileBase obj_base,
Offset rva) {
// find which section contains the rva to compute it's mapped address
const PeSectionHeader* section_table = GetSectionTable(obj_base);
for (int s = 0; s < GetNumberOfSections(obj_base); s++) {
const PeSectionHeader* section = &(section_table[s]);
if ((rva >= section->mVirtualAddress) &&
(rva < (section->mVirtualAddress + section->mSizeOfRawData)))
{
uint32_t offset = rva - section->mVirtualAddress;
const uint8_t* pointer = GetSectionPointer(obj_base, (Section)section) + offset;
return pointer;
}
}
fprintf(stderr, "No section could be found containing RVA %x\n", rva);
return NULL;
}
// instantiation of templated classes
template class PeCoffObjectFileReader<PeCoffClass32Traits>;
template class PeCoffObjectFileReader<PeCoffClass64Traits>;
}

167
thirdparty/breakpad/common/pecoff/pecoffutils.h vendored Normal file
View File

@@ -0,0 +1,167 @@
// Copyright (c) 2014 Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// pecoffutils.h: Utilities for dealing with PECOFF files
//
#ifndef COMMON_PECOFF_PECOFFUTILS_H__
#define COMMON_PECOFF_PECOFFUTILS_H__
#include "common/pecoff/pecoff.h"
#include "common/pecoff/pecoff_file_id.h"
#include "common/module.h"
namespace google_breakpad {
bool IsValidPeCoff(const uint8_t* obj_file);
int PeCoffClass(const uint8_t* obj_file);
class PeCoffClass32Traits {
public:
typedef uint32_t Addr;
typedef Pe32OptionalHeader PeOptionalHeader;
static const int kClass = PE32;
static const size_t kAddrSize = 4;
};
class PeCoffClass64Traits {
public:
typedef uint64_t Addr;
typedef Pe32PlusOptionalHeader PeOptionalHeader;
static const int kClass = PE32PLUS;
static const size_t kAddrSize = 8;
};
// Offset isn't part of the traits as although PE32+ uses 64-bit address space,
// it still uses 32-bit RVAs and offsets
template <typename PeCoffClassTraits>
class PeCoffObjectFileReader {
public:
typedef const uint8_t* ObjectFileBase;
typedef const uint8_t* Section;
typedef uint32_t Offset;
typedef typename PeCoffClassTraits::Addr Addr;
static const int kClass = PeCoffClassTraits::kClass;
static const size_t kAddrSize = PeCoffClassTraits::kAddrSize;
static bool IsValid(ObjectFileBase obj_file) {
return IsValidPeCoff(obj_file);
};
//
// Header information
//
// Return the breakpad symbol file identifier for the architecture
static const char* Architecture(ObjectFileBase obj_base);
// Get the endianness. If it's invalid, return false.
static bool Endianness(ObjectFileBase obj_base, bool* big_endian);
// Find the preferred loading address of the binary.
static Addr GetLoadingAddress(ObjectFileBase obj_base);
//
// Section enumeration and location
//
static int GetNumberOfSections(ObjectFileBase obj_base);
static const Section FindSectionByIndex(ObjectFileBase obj_base, int i);
// Attempt to find a section named |section_name|
static const Section FindSectionByName(const char* section_name,
ObjectFileBase obj_base);
//
// Section information
//
// Convert a section into a pointer to the mapped address in the current
// process.
static const uint8_t* GetSectionPointer(ObjectFileBase obj_base,
Section section);
// Get the size of a section
static Offset GetSectionSize(ObjectFileBase obj_base, Section section);
// Get relative virtual address (RVA) of a section
static Offset GetSectionRVA(ObjectFileBase obj_base, Section section);
// Get name of a section
static const char* GetSectionName(ObjectFileBase obj_base,Section section);
// Find any linked section
static const Section FindLinkedSection(ObjectFileBase obj_base,
Section section) {
return 0; // PECOFF doesn't have the concept of linked sections
}
//
//
//
// Load symbols from the object file's exported symbol table
static bool ExportedSymbolsToModule(ObjectFileBase obj_base, Module* module);
// Return the identifier for the file mapped into memory.
// Return an empty string if the identifier could not be created
// for the file.
static string FileIdentifierFromMappedFile(ObjectFileBase obj_base);
//
// Helpers for PeCoffFileID
//
// Get the build-id
static bool GetBuildID(ObjectFileBase obj_base,
uint8_t identifier[kMDGUIDSize], uint32_t* age);
// Hash the text section
static bool HashTextSection(ObjectFileBase obj_base,
uint8_t identifier[kMDGUIDSize]);
private:
typedef typename PeCoffClassTraits::PeOptionalHeader PeOptionalHeader;
//
// Private implementation helper functions
//
static const PeHeader* GetHeader(ObjectFileBase obj_base);
static const PeOptionalHeader* GetOptionalHeader(ObjectFileBase obj_base);
static const PeSectionHeader* GetSectionTable(ObjectFileBase obj_base);
static const char* GetStringTable(ObjectFileBase obj_base);
static const PeDataDirectory* GetDataDirectoryEntry(ObjectFileBase obj_base,
int entry);
static const uint8_t* ConvertRVAToPointer(ObjectFileBase obj_base, Offset rva);
};
class PeCoffClass32 : public PeCoffObjectFileReader<PeCoffClass32Traits> { };
class PeCoffClass64 : public PeCoffObjectFileReader<PeCoffClass64Traits> { };
} // namespace google_breakpad
#endif // COMMON_PECOFF_PECOFFUTILS_H__