The Tor Browser: comparison toolkit/crashreporter/google-breakpad/src/common/mac/dump

--1:000000000000
+:9a9d8774b951
+// -*- 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.
+// Author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
+// dump_syms.mm: Create a symbol file for use with minidumps
+#include "common/mac/dump_syms.h"
+#include <Foundation/Foundation.h>
+#include <mach-o/arch.h>
+#include <mach-o/fat.h>
+#include <stdio.h>
+#include <ostream>
+#include <string>
+#include <vector>
+#include "common/dwarf/bytereader-inl.h"
+#include "common/dwarf/dwarf2reader.h"
+#include "common/dwarf_cfi_to_module.h"
+#include "common/dwarf_cu_to_module.h"
+#include "common/dwarf_line_to_module.h"
+#include "common/mac/file_id.h"
+#include "common/mac/arch_utilities.h"
+#include "common/mac/macho_reader.h"
+#include "common/module.h"
+#include "common/scoped_ptr.h"
+#include "common/stabs_reader.h"
+#include "common/stabs_to_module.h"
+#include "common/symbol_data.h"
+#ifndef CPU_TYPE_ARM
+#define CPU_TYPE_ARM (static_cast<cpu_type_t>(12))
+#endif //  CPU_TYPE_ARM
+using dwarf2reader::ByteReader;
+using google_breakpad::DwarfCUToModule;
+using google_breakpad::DwarfLineToModule;
+using google_breakpad::FileID;
+using google_breakpad::mach_o::FatReader;
+using google_breakpad::mach_o::Section;
+using google_breakpad::mach_o::Segment;
+using google_breakpad::Module;
+using google_breakpad::StabsReader;
+using google_breakpad::StabsToModule;
+using google_breakpad::scoped_ptr;
+using std::make_pair;
+using std::pair;
+using std::string;
+using std::vector;
+namespace google_breakpad {
+bool DumpSymbols::Read(NSString *filename) {
+if (![[NSFileManager defaultManager] fileExistsAtPath:filename]) {
+fprintf(stderr, "Object file does not exist: %s\n",
+[filename fileSystemRepresentation]);
+return false;
+}
+input_pathname_ = [filename retain];
+// Does this filename refer to a dSYM bundle?
+NSBundle *bundle = [NSBundle bundleWithPath:input_pathname_];
+if (bundle) {
+// Filenames referring to bundles usually have names of the form
+// "<basename>.dSYM"; however, if the user has specified a wrapper
+// suffix (the WRAPPER_SUFFIX and WRAPPER_EXTENSION build settings),
+// then the name may have the form "<basename>.<extension>.dSYM". In
+// either case, the resource name for the file containing the DWARF
+// info within the bundle is <basename>.
+//
+// Since there's no way to tell how much to strip off, remove one
+// extension at a time, and use the first one that
+// pathForResource:ofType:inDirectory likes.
+NSString *base_name = [input_pathname_ lastPathComponent];
+NSString *dwarf_resource;
+do {
+NSString *new_base_name = [base_name stringByDeletingPathExtension];
+// If stringByDeletingPathExtension returned the name unchanged, then
+// there's nothing more for us to strip off --- lose.
+if ([new_base_name isEqualToString:base_name]) {
+fprintf(stderr, "Unable to find DWARF-bearing file in bundle: %s\n",
+[input_pathname_ fileSystemRepresentation]);
+return false;
+}
+// Take the shortened result as our new base_name.
+base_name = new_base_name;
+// Try to find a DWARF resource in the bundle under the new base_name.
+dwarf_resource = [bundle pathForResource:base_name
+ofType:nil inDirectory:@"DWARF"];
+} while (!dwarf_resource);
+object_filename_ = [dwarf_resource retain];
+} else {
+object_filename_ = [input_pathname_ retain];
+}
+// Read the file's contents into memory.
+//
+// The documentation for dataWithContentsOfMappedFile says:
+//
+//     Because of file mapping restrictions, this method should only be
+//     used if the file is guaranteed to exist for the duration of the
+//     data object’s existence. It is generally safer to use the
+//     dataWithContentsOfFile: method.
+//
+// I gather this means that OS X doesn't have (or at least, that method
+// doesn't use) a form of mapping like Linux's MAP_PRIVATE, where the
+// process appears to get its own copy of the data, and changes to the
+// file don't affect memory and vice versa).
+NSError *error;
+contents_ = [NSData dataWithContentsOfFile:object_filename_
+options:0
+error:&error];
+if (!contents_) {
+fprintf(stderr, "Error reading object file: %s: %s\n",
+[object_filename_ fileSystemRepresentation],
+[[error localizedDescription] UTF8String]);
+return false;
+}
+[contents_ retain];
+// Get the list of object files present in the file.
+FatReader::Reporter fat_reporter([object_filename_
+fileSystemRepresentation]);
+FatReader fat_reader(&fat_reporter);
+if (!fat_reader.Read(reinterpret_cast<const uint8_t *>([contents_ bytes]),
+[contents_ length])) {
+return false;
+}
+// Get our own copy of fat_reader's object file list.
+size_t object_files_count;
+const struct fat_arch *object_files =
+fat_reader.object_files(&object_files_count);
+if (object_files_count == 0) {
+fprintf(stderr, "Fat binary file contains *no* architectures: %s\n",
+[object_filename_ fileSystemRepresentation]);
+return false;
+}
+object_files_.resize(object_files_count);
+memcpy(&object_files_[0], object_files,
+sizeof(struct fat_arch) * object_files_count);
+return true;
+}
+bool DumpSymbols::SetArchitecture(cpu_type_t cpu_type,
+cpu_subtype_t cpu_subtype) {
+// Find the best match for the architecture the user requested.
+const struct fat_arch *best_match
+= NXFindBestFatArch(cpu_type, cpu_subtype, &object_files_[0],
+static_cast<uint32_t>(object_files_.size()));
+if (!best_match) return false;
+// Record the selected object file.
+selected_object_file_ = best_match;
+return true;
+}
+bool DumpSymbols::SetArchitecture(const std::string &arch_name) {
+bool arch_set = false;
+const NXArchInfo *arch_info =
+google_breakpad::BreakpadGetArchInfoFromName(arch_name.c_str());
+if (arch_info) {
+arch_set = SetArchitecture(arch_info->cputype, arch_info->cpusubtype);
+}
+return arch_set;
+}
+string DumpSymbols::Identifier() {
+FileID file_id([object_filename_ fileSystemRepresentation]);
+unsigned char identifier_bytes[16];
+cpu_type_t cpu_type = selected_object_file_->cputype;
+cpu_subtype_t cpu_subtype = selected_object_file_->cpusubtype;
+if (!file_id.MachoIdentifier(cpu_type, cpu_subtype, identifier_bytes)) {
+fprintf(stderr, "Unable to calculate UUID of mach-o binary %s!\n",
+[object_filename_ fileSystemRepresentation]);
+return "";
+}
+char identifier_string[40];
+FileID::ConvertIdentifierToString(identifier_bytes, identifier_string,
+sizeof(identifier_string));
+string compacted(identifier_string);
+for(size_t i = compacted.find('-'); i != string::npos;
+i = compacted.find('-', i))
+compacted.erase(i, 1);
+return compacted;
+}
+// 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 DumpSymbols::DumperLineToModule:
+public DwarfCUToModule::LineToModuleHandler {
+public:
+// Create a line-to-module converter using BYTE_READER.
+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, 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_;  // WEAK
+};
+bool DumpSymbols::ReadDwarf(google_breakpad::Module *module,
+const mach_o::Reader &macho_reader,
+const mach_o::SectionMap &dwarf_sections) const {
+// Build a byte reader of the appropriate endianness.
+ByteReader byte_reader(macho_reader.big_endian()
+? dwarf2reader::ENDIANNESS_BIG
+: dwarf2reader::ENDIANNESS_LITTLE);
+// Construct a context for this file.
+DwarfCUToModule::FileContext file_context(selected_object_name_,
+module);
+// Build a dwarf2reader::SectionMap from our mach_o::SectionMap.
+for (mach_o::SectionMap::const_iterator it = dwarf_sections.begin();
+it != dwarf_sections.end(); it++) {
+file_context.section_map[it->first] =
+make_pair(reinterpret_cast<const char *>(it->second.contents.start),
+it->second.contents.Size());
+}
+// Find the __debug_info section.
+std::pair<const char *, uint64> debug_info_section
+= file_context.section_map["__debug_info"];
+// There had better be a __debug_info section!
+if (!debug_info_section.first) {
+fprintf(stderr, "%s: __DWARF segment of file has no __debug_info section\n",
+selected_object_name_.c_str());
+return false;
+}
+// Build a line-to-module loader for the root handler to use.
+DumperLineToModule line_to_module(&byte_reader);
+// Walk the __debug_info section, one compilation unit at a time.
+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
+// debug info.
+DwarfCUToModule::WarningReporter reporter(selected_object_name_,
+offset);
+DwarfCUToModule root_handler(&file_context, &line_to_module, &reporter);
+// Make a Dwarf2Handler that drives our DIEHandler.
+dwarf2reader::DIEDispatcher die_dispatcher(&root_handler);
+// Make a DWARF parser for the compilation unit at OFFSET.
+dwarf2reader::CompilationUnit dwarf_reader(file_context.section_map,
+offset,
+&byte_reader,
+&die_dispatcher);
+// Process the entire compilation unit; get the offset of the next.
+offset += dwarf_reader.Start();
+}
+return true;
+}
+bool DumpSymbols::ReadCFI(google_breakpad::Module *module,
+const mach_o::Reader &macho_reader,
+const mach_o::Section &section,
+bool eh_frame) const {
+// Find the appropriate set of register names for this file's
+// architecture.
+vector<const UniqueString*> register_names;
+switch (macho_reader.cpu_type()) {
+case CPU_TYPE_X86:
+register_names = DwarfCFIToModule::RegisterNames::I386();
+break;
+case CPU_TYPE_X86_64:
+register_names = DwarfCFIToModule::RegisterNames::X86_64();
+break;
+case CPU_TYPE_ARM:
+register_names = DwarfCFIToModule::RegisterNames::ARM();
+break;
+default: {
+const NXArchInfo *arch = google_breakpad::BreakpadGetArchInfoFromCpuType(
+macho_reader.cpu_type(), macho_reader.cpu_subtype());
+fprintf(stderr, "%s: cannot convert DWARF call frame information for ",
+selected_object_name_.c_str());
+if (arch)
+fprintf(stderr, "architecture '%s'", arch->name);
+else
+fprintf(stderr, "architecture %d,%d",
+macho_reader.cpu_type(), macho_reader.cpu_subtype());
+fprintf(stderr, " to Breakpad symbol file: no register name table\n");
+return false;
+}
+}
+// Find the call frame information and its size.
+const char *cfi = reinterpret_cast<const char *>(section.contents.start);
+size_t cfi_size = section.contents.Size();
+// Plug together the parser, handler, and their entourages.
+DwarfCFIToModule::Reporter module_reporter(selected_object_name_,
+section.section_name);
+DwarfCFIToModule handler(module, register_names, &module_reporter);
+dwarf2reader::ByteReader byte_reader(macho_reader.big_endian() ?
+dwarf2reader::ENDIANNESS_BIG :
+dwarf2reader::ENDIANNESS_LITTLE);
+byte_reader.SetAddressSize(macho_reader.bits_64() ? 8 : 4);
+// At the moment, according to folks at Apple and some cursory
+// investigation, Mac OS X only uses DW_EH_PE_pcrel-based pointers, so
+// this is the only base address the CFI parser will need.
+byte_reader.SetCFIDataBase(section.address, cfi);
+dwarf2reader::CallFrameInfo::Reporter dwarf_reporter(selected_object_name_,
+section.section_name);
+dwarf2reader::CallFrameInfo parser(cfi, cfi_size,
+&byte_reader, &handler, &dwarf_reporter,
+eh_frame);
+parser.Start();
+return true;
+}
+// A LoadCommandHandler that loads whatever debugging data it finds into a
+// Module.
+class DumpSymbols::LoadCommandDumper:
+public mach_o::Reader::LoadCommandHandler {
+public:
+// Create a load command dumper handling load commands from READER's
+// file, and adding data to MODULE.
+LoadCommandDumper(const DumpSymbols &dumper,
+google_breakpad::Module *module,
+const mach_o::Reader &reader,
+SymbolData symbol_data)
+: dumper_(dumper),
+module_(module),
+reader_(reader),
+symbol_data_(symbol_data) { }
+bool SegmentCommand(const mach_o::Segment &segment);
+bool SymtabCommand(const ByteBuffer &entries, const ByteBuffer &strings);
+private:
+const DumpSymbols &dumper_;
+google_breakpad::Module *module_;  // WEAK
+const mach_o::Reader &reader_;
+const SymbolData symbol_data_;
+};
+bool DumpSymbols::LoadCommandDumper::SegmentCommand(const Segment &segment) {
+mach_o::SectionMap section_map;
+if (!reader_.MapSegmentSections(segment, &section_map))
+return false;
+if (segment.name == "__TEXT" && symbol_data_ != NO_CFI) {
+module_->SetLoadAddress(segment.vmaddr);
+mach_o::SectionMap::const_iterator eh_frame =
+section_map.find("__eh_frame");
+if (eh_frame != section_map.end()) {
+// If there is a problem reading this, don't treat it as a fatal error.
+dumper_.ReadCFI(module_, reader_, eh_frame->second, true);
+}
+return true;
+}
+if (segment.name == "__DWARF") {
+if (symbol_data_ != ONLY_CFI) {
+if (!dumper_.ReadDwarf(module_, reader_, section_map))
+return false;
+}
+if (symbol_data_ != NO_CFI) {
+mach_o::SectionMap::const_iterator debug_frame
+= section_map.find("__debug_frame");
+if (debug_frame != section_map.end()) {
+// If there is a problem reading this, don't treat it as a fatal error.
+dumper_.ReadCFI(module_, reader_, debug_frame->second, false);
+}
+}
+}
+return true;
+}
+bool DumpSymbols::LoadCommandDumper::SymtabCommand(const ByteBuffer &entries,
+const ByteBuffer &strings) {
+StabsToModule stabs_to_module(module_);
+// Mac OS X STABS are never "unitized", and the size of the 'value' field
+// matches the address size of the executable.
+StabsReader stabs_reader(entries.start, entries.Size(),
+strings.start, strings.Size(),
+reader_.big_endian(),
+reader_.bits_64() ? 8 : 4,
+true,
+&stabs_to_module);
+if (!stabs_reader.Process())
+return false;
+stabs_to_module.Finalize();
+return true;
+}
+bool DumpSymbols::ReadSymbolData(Module** out_module) {
+// Select an object file, if SetArchitecture hasn't been called to set one
+// explicitly.
+if (!selected_object_file_) {
+// If there's only one architecture, that's the one.
+if (object_files_.size() == 1)
+selected_object_file_ = &object_files_[0];
+else {
+// Look for an object file whose architecture matches our own.
+const NXArchInfo *local_arch = NXGetLocalArchInfo();
+if (!SetArchitecture(local_arch->cputype, local_arch->cpusubtype)) {
+fprintf(stderr, "%s: object file contains more than one"
+" architecture, none of which match the current"
+" architecture; specify an architecture explicitly"
+" with '-a ARCH' to resolve the ambiguity\n",
+[object_filename_ fileSystemRepresentation]);
+return false;
+}
+}
+}
+assert(selected_object_file_);
+// Find the name of the selected file's architecture, to appear in
+// the MODULE record and in error messages.
+const NXArchInfo *selected_arch_info =
+google_breakpad::BreakpadGetArchInfoFromCpuType(
+selected_object_file_->cputype, selected_object_file_->cpusubtype);
+const char *selected_arch_name = selected_arch_info->name;
+if (strcmp(selected_arch_name, "i386") == 0)
+selected_arch_name = "x86";
+// Produce a name to use in error messages that includes the
+// filename, and the architecture, if there is more than one.
+selected_object_name_ = [object_filename_ UTF8String];
+if (object_files_.size() > 1) {
+selected_object_name_ += ", architecture ";
+selected_object_name_ + selected_arch_name;
+}
+// Compute a module name, to appear in the MODULE record.
+NSString *module_name = [object_filename_ lastPathComponent];
+// Choose an identifier string, to appear in the MODULE record.
+string identifier = Identifier();
+if (identifier.empty())
+return false;
+identifier += "0";
+// Create a module to hold the debugging information.
+scoped_ptr<Module> module(new Module([module_name UTF8String],
+"mac",
+selected_arch_name,
+identifier));
+// Parse the selected object file.
+mach_o::Reader::Reporter reporter(selected_object_name_);
+mach_o::Reader reader(&reporter);
+if (!reader.Read(reinterpret_cast<const uint8_t *>([contents_ bytes])
++ selected_object_file_->offset,
+selected_object_file_->size,
+selected_object_file_->cputype,
+selected_object_file_->cpusubtype))
+return false;
+// Walk its load commands, and deal with whatever is there.
+LoadCommandDumper load_command_dumper(*this, module.get(), reader,
+symbol_data_);
+if (!reader.WalkLoadCommands(&load_command_dumper))
+return false;
+*out_module = module.release();
+return true;
+}
+bool DumpSymbols::WriteSymbolFile(std::ostream &stream) {
+Module* module = NULL;
+if (ReadSymbolData(&module) && module) {
+bool res = module->Write(stream, symbol_data_);
+delete module;
+return res;
+}
+return false;
+}
+}  // namespace google_breakpad

The Tor Browser / file comparison

comparison: toolkit/crashreporter/google-breakpad/src/common/mac/dump_syms.mm

toolkit/crashreporter/google-breakpad/src/common/mac/dump_syms.mm