| From 6d7e6014d2bb1b0f883cdaeb8e13861ae0f57c7c Mon Sep 17 00:00:00 2001 |
| From: Jon Turney <jon.turney@dronecode.org.uk> |
| Date: Tue, 4 Feb 2014 00:57:13 +0000 |
| Subject: [PATCH 05/29] Add support for DWARF in PECOFF as used by Cygwin and |
| MinGW |
| |
| For cygwin and mingw targets, build a dump_syms tool which can read DWARF |
| symbols contained in a PE/COFF executable. |
| |
| I felt bad about making another copy of dump_symbols.cc, so this one has the |
| beginnings of being parameterized by an image file reader class, so we can apply |
| it to a pecoff-format image file reading class |
| |
| Write pecoff format image file reading class which |
| - knows how to read PE32 and PE32+ image files |
| - makes PECOFF file id by fetching from a CV record or by hashing |
| - can read PECOFF exports as a fallback if there is no DWARF information |
| |
| v2: |
| Don't include arpa/inet.h on MinGW |
| |
| v3: |
| Use AM_CPPFLAGS for NO_STABS_SUPPORT |
| |
| v4: |
| Fixes for -Werror=sign-compare errors arising due to signedness of size_t |
| Update use of Module::Extern() for change in r1415 |
| Fix EOT fallback to match reality rather than PE/COFF spec. |
| |
| v5: |
| Add needed include of winsock.h for htons etc. |
| |
| v6: |
| Update for char -> uint8_t changes in commit bc44efdc |
| |
| v7: |
| Update for "Add debug fission support" changes |
| |
| What's this? We now build elf_reader.cc into our COFF symbols dumping tool? |
| But why is that? Because dwarf2reader now contains an entirely separate ELF |
| reader, for reading .dwo/.dwp files... |
| |
| Signed-off-by: Jon Turney <jon.turney@dronecode.org.uk> |
| --- |
| Makefile.am | 30 ++ |
| configure.ac | 5 + |
| src/common/pecoff/dump_symbols-inl.h | 705 +++++++++++++++++++++++++ |
| src/common/pecoff/dump_symbols.cc | 90 ++++ |
| src/common/pecoff/dump_symbols.h | 80 +++ |
| src/common/pecoff/pecoff.h | 262 +++++++++ |
| src/common/pecoff/pecoff_file_id.cc | 83 +++ |
| src/common/pecoff/pecoff_file_id.h | 52 ++ |
| src/common/pecoff/pecoffutils.cc | 494 +++++++++++++++++ |
| src/common/pecoff/pecoffutils.h | 167 ++++++ |
| src/tools/windows/dump_syms_dwarf/dump_syms.cc | 88 +++ |
| 11 files changed, 2056 insertions(+) |
| create mode 100644 src/common/pecoff/dump_symbols-inl.h |
| create mode 100644 src/common/pecoff/dump_symbols.cc |
| create mode 100644 src/common/pecoff/dump_symbols.h |
| create mode 100644 src/common/pecoff/pecoff.h |
| create mode 100644 src/common/pecoff/pecoff_file_id.cc |
| create mode 100644 src/common/pecoff/pecoff_file_id.h |
| create mode 100644 src/common/pecoff/pecoffutils.cc |
| create mode 100644 src/common/pecoff/pecoffutils.h |
| create mode 100644 src/tools/windows/dump_syms_dwarf/dump_syms.cc |
| |
| diff --git a/Makefile.am b/Makefile.am |
| index fcff8ea7..8d816efc 100644 |
| --- a/Makefile.am |
| +++ b/Makefile.am |
| @@ -51,6 +51,11 @@ AM_CFLAGS += -fPIC |
| AM_CXXFLAGS += -fPIC |
| endif |
| |
| +if WINDOWS_HOST |
| +# don't have stab.h, don't build stabs support |
| +AM_CPPFLAGS += -DNO_STABS_SUPPORT |
| +endif |
| + |
| # Specify include paths for ac macros |
| ACLOCAL_AMFLAGS = -I m4 |
| |
| @@ -368,6 +373,12 @@ endif |
| endif |
| endif LINUX_HOST |
| |
| +if WINDOWS_HOST |
| +if !DISABLE_TOOLS |
| +bin_PROGRAMS += \ |
| + src/tools/windows/dump_syms_dwarf/dump_syms |
| +endif |
| +endif |
| |
| ## Tests |
| if !DISABLE_PROCESSOR |
| @@ -768,6 +779,25 @@ src_tools_linux_md2core_minidump_2_core_unittest_LDADD = \ |
| |
| endif LINUX_HOST |
| |
| +if WINDOWS_HOST |
| +if !DISABLE_TOOLS |
| +src_tools_windows_dump_syms_dwarf_dump_syms_SOURCES = \ |
| + src/common/dwarf_cfi_to_module.cc \ |
| + src/common/dwarf_cu_to_module.cc \ |
| + src/common/dwarf_line_to_module.cc \ |
| + src/common/language.cc \ |
| + src/common/module.cc \ |
| + src/common/dwarf/bytereader.cc \ |
| + src/common/dwarf/dwarf2diehandler.cc \ |
| + src/common/dwarf/dwarf2reader.cc \ |
| + src/common/dwarf/elf_reader.cc \ |
| + src/common/pecoff/dump_symbols.cc \ |
| + src/common/pecoff/pecoffutils.cc \ |
| + src/common/pecoff/pecoff_file_id.cc \ |
| + src/tools/windows/dump_syms_dwarf/dump_syms.cc |
| +endif |
| +endif |
| + |
| if !DISABLE_PROCESSOR |
| src_processor_address_map_unittest_SOURCES = \ |
| src/processor/address_map_unittest.cc |
| diff --git a/configure.ac b/configure.ac |
| index ec194ddd..4e92b291 100644 |
| --- a/configure.ac |
| +++ b/configure.ac |
| @@ -110,8 +110,13 @@ case $host in |
| *-*-linux* | *-android* ) |
| LINUX_HOST=true |
| ;; |
| + *-*-cygwin* ) |
| + WINDOWS_HOST=true |
| + ;; |
| esac |
| + |
| AM_CONDITIONAL(LINUX_HOST, test x$LINUX_HOST = xtrue) |
| +AM_CONDITIONAL(WINDOWS_HOST, test x$WINDOWS_HOST = xtrue) |
| |
| # Only use Android support headers when compiling for Android |
| case $host in |
| diff --git a/src/common/pecoff/dump_symbols-inl.h b/src/common/pecoff/dump_symbols-inl.h |
| new file mode 100644 |
| index 00000000..23955f6a |
| --- /dev/null |
| +++ b/src/common/pecoff/dump_symbols-inl.h |
| @@ -0,0 +1,705 @@ |
| +// 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> |
| +#include <sys/mman.h> |
| +#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); |
| + munmap(base_, size_); |
| + } |
| + } |
| + void set(void *mapped_address, size_t mapped_size) { |
| + is_set_ = true; |
| + base_ = mapped_address; |
| + size_ = mapped_size; |
| + } |
| + void release() { |
| + assert(is_set_); |
| + is_set_ = false; |
| + base_ = NULL; |
| + size_ = 0; |
| + } |
| + |
| + private: |
| + bool is_set_; |
| + void *base_; |
| + size_t size_; |
| +}; |
| + |
| +#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 uint8_t *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 uint8_t* contents = reinterpret_cast<const uint8_t *>(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 uint8_t*, 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(dwarf_filename, |
| + 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, ®ister_names)) { |
| + return false; |
| + } |
| + |
| + const dwarf2reader::Endianness endianness = big_endian ? |
| + dwarf2reader::ENDIANNESS_BIG : dwarf2reader::ENDIANNESS_LITTLE; |
| + |
| + // Find the call frame information and its size. |
| + const uint8_t* cfi = reinterpret_cast<const uint8_t *>(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; |
| + } |
| + void *obj_base = mmap(NULL, st.st_size, |
| + PROT_READ | PROT_WRITE, MAP_PRIVATE, obj_fd, 0); |
| + if (obj_base == MAP_FAILED) { |
| + fprintf(stderr, "Failed to mmap file '%s': %s\n", |
| + obj_file.c_str(), strerror(errno)); |
| + return false; |
| + } |
| + map_wrapper->set(obj_base, st.st_size); |
| + *header = obj_base; |
| + 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 §ion) { |
| + 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) { |
| + |
| + *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 |
| diff --git a/src/common/pecoff/dump_symbols.cc b/src/common/pecoff/dump_symbols.cc |
| new file mode 100644 |
| index 00000000..47be9408 |
| --- /dev/null |
| +++ b/src/common/pecoff/dump_symbols.cc |
| @@ -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 |
| diff --git a/src/common/pecoff/dump_symbols.h b/src/common/pecoff/dump_symbols.h |
| new file mode 100644 |
| index 00000000..675a4895 |
| --- /dev/null |
| +++ b/src/common/pecoff/dump_symbols.h |
| @@ -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__ |
| diff --git a/src/common/pecoff/pecoff.h b/src/common/pecoff/pecoff.h |
| new file mode 100644 |
| index 00000000..9ac32ef3 |
| --- /dev/null |
| +++ b/src/common/pecoff/pecoff.h |
| @@ -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__ |
| diff --git a/src/common/pecoff/pecoff_file_id.cc b/src/common/pecoff/pecoff_file_id.cc |
| new file mode 100644 |
| index 00000000..47c2763f |
| --- /dev/null |
| +++ b/src/common/pecoff/pecoff_file_id.cc |
| @@ -0,0 +1,83 @@ |
| +// 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 "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; |
| + |
| + // 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); |
| +} |
| + |
| +} // namespace google_breakpad |
| diff --git a/src/common/pecoff/pecoff_file_id.h b/src/common/pecoff/pecoff_file_id.h |
| new file mode 100644 |
| index 00000000..fd2ea103 |
| --- /dev/null |
| +++ b/src/common/pecoff/pecoff_file_id.h |
| @@ -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__ |
| diff --git a/src/common/pecoff/pecoffutils.cc b/src/common/pecoff/pecoffutils.cc |
| new file mode 100644 |
| index 00000000..f097cc61 |
| --- /dev/null |
| +++ b/src/common/pecoff/pecoffutils.cc |
| @@ -0,0 +1,494 @@ |
| +// 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> |
| +#else |
| +#include <winsock.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)); |
| + |
| + // get the corresponding ordinal |
| + // (the PE/COFF specification seems to claim that EOT entries are not |
| + // biased by ordinalbase, but that doesn't seem to match reality...) |
| + uint16_t export_ordinal = eot[i] + export_table->mOrdinalBase; |
| + 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; |
| + } |
| + |
| + // find the corresponding export address table entry |
| + 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(export_rva + GetLoadingAddress(obj_base)); |
| + ext->name = export_name; |
| + 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 (unsigned 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 (unsigned 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, unsigned 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>; |
| + |
| +} |
| diff --git a/src/common/pecoff/pecoffutils.h b/src/common/pecoff/pecoffutils.h |
| new file mode 100644 |
| index 00000000..3e2d7b34 |
| --- /dev/null |
| +++ b/src/common/pecoff/pecoffutils.h |
| @@ -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, |
| + unsigned 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__ |
| diff --git a/src/tools/windows/dump_syms_dwarf/dump_syms.cc b/src/tools/windows/dump_syms_dwarf/dump_syms.cc |
| new file mode 100644 |
| index 00000000..2d7f70a6 |
| --- /dev/null |
| +++ b/src/tools/windows/dump_syms_dwarf/dump_syms.cc |
| @@ -0,0 +1,88 @@ |
| +// 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 <stdio.h> |
| + |
| +#include <cstring> |
| +#include <iostream> |
| +#include <string> |
| +#include <vector> |
| + |
| +#include "common/pecoff/dump_symbols.h" |
| + |
| +using google_breakpad::WriteSymbolFile; |
| + |
| +int usage(const char* self) { |
| + fprintf(stderr, "Usage: %s [OPTION] <binary-with-dwarf-debugging-info> " |
| + "[directories-for-debug-file]\n\n", self); |
| + fprintf(stderr, "Options:\n"); |
| + fprintf(stderr, " -c Do not generate CFI section\n"); |
| + fprintf(stderr, " -r Do not handle inter-compilation unit references\n"); |
| + return 1; |
| +} |
| + |
| +int main(int argc, char **argv) { |
| + if (argc < 2) |
| + return usage(argv[0]); |
| + |
| + bool cfi = true; |
| + bool handle_inter_cu_refs = true; |
| + int arg_index = 1; |
| + while (arg_index < argc && strlen(argv[arg_index]) > 0 && |
| + argv[arg_index][0] == '-') { |
| + if (strcmp("-c", argv[arg_index]) == 0) { |
| + cfi = false; |
| + } else if (strcmp("-r", argv[arg_index]) == 0) { |
| + handle_inter_cu_refs = false; |
| + } else { |
| + return usage(argv[0]); |
| + } |
| + ++arg_index; |
| + } |
| + if (arg_index == argc) |
| + return usage(argv[0]); |
| + |
| + const char* binary; |
| + std::vector<string> debug_dirs; |
| + binary = argv[arg_index]; |
| + for (int debug_dir_index = arg_index + 1; |
| + debug_dir_index < argc; |
| + ++debug_dir_index) { |
| + debug_dirs.push_back(argv[debug_dir_index]); |
| + } |
| + |
| + SymbolData symbol_data = cfi ? ALL_SYMBOL_DATA : NO_CFI; |
| + google_breakpad::DumpOptions options(symbol_data, handle_inter_cu_refs); |
| + if (!WriteSymbolFile(binary, debug_dirs, options, std::cout)) { |
| + fprintf(stderr, "Failed to write symbol file.\n"); |
| + return 1; |
| + } |
| + |
| + return 0; |
| +} |
| -- |
| 2.15.0 |
| |
