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

--1:000000000000
+:db5ba2a5f52f
+// -*- mode: c++ -*-
+// Copyright (c) 2010 Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
+// The DwarfLineToModule class accepts line number information from a
+// DWARF parser and adds it to a google_breakpad::Module. The Module
+// can write that data out as a Breakpad symbol file.
+#ifndef COMMON_LINUX_DWARF_LINE_TO_MODULE_H
+#define COMMON_LINUX_DWARF_LINE_TO_MODULE_H
+#include <string>
+#include "common/module.h"
+#include "common/dwarf/dwarf2reader.h"
+#include "common/using_std_string.h"
+namespace google_breakpad {
+// A class for producing a vector of google_breakpad::Module::Line
+// instances from parsed DWARF line number data.
+//
+// An instance of this class can be provided as a handler to a
+// dwarf2reader::LineInfo DWARF line number information parser. The
+// handler accepts source location information from the parser and
+// uses it to produce a vector of google_breakpad::Module::Line
+// objects, referring to google_breakpad::Module::File objects added
+// to a particular google_breakpad::Module.
+//
+// GNU toolchain omitted sections support:
+// ======================================
+//
+// Given the right options, the GNU toolchain will omit unreferenced
+// functions from the final executable. Unfortunately, when it does so, it
+// does not remove the associated portions of the DWARF line number
+// program; instead, it gives the DW_LNE_set_address instructions referring
+// to the now-deleted code addresses of zero. Given this input, the DWARF
+// line parser will call AddLine with a series of lines starting at address
+// zero. For example, here is the output from 'readelf -wl' for a program
+// with four functions, the first three of which have been omitted:
+//
+//   Line Number Statements:
+//    Extended opcode 2: set Address to 0x0
+//    Advance Line by 14 to 15
+//    Copy
+//    Special opcode 48: advance Address by 3 to 0x3 and Line by 1 to 16
+//    Special opcode 119: advance Address by 8 to 0xb and Line by 2 to 18
+//    Advance PC by 2 to 0xd
+//    Extended opcode 1: End of Sequence
+//
+//    Extended opcode 2: set Address to 0x0
+//    Advance Line by 14 to 15
+//    Copy
+//    Special opcode 48: advance Address by 3 to 0x3 and Line by 1 to 16
+//    Special opcode 119: advance Address by 8 to 0xb and Line by 2 to 18
+//    Advance PC by 2 to 0xd
+//    Extended opcode 1: End of Sequence
+//
+//    Extended opcode 2: set Address to 0x0
+//    Advance Line by 19 to 20
+//    Copy
+//    Special opcode 48: advance Address by 3 to 0x3 and Line by 1 to 21
+//    Special opcode 76: advance Address by 5 to 0x8 and Line by 1 to 22
+//    Advance PC by 2 to 0xa
+//    Extended opcode 1: End of Sequence
+//
+//    Extended opcode 2: set Address to 0x80483a4
+//    Advance Line by 23 to 24
+//    Copy
+//    Special opcode 202: advance Address by 14 to 0x80483b2 and Line by 1 to 25
+//    Special opcode 76: advance Address by 5 to 0x80483b7 and Line by 1 to 26
+//    Advance PC by 6 to 0x80483bd
+//    Extended opcode 1: End of Sequence
+//
+// Instead of collecting runs of lines describing code that is not there,
+// we try to recognize and drop them. Since the linker doesn't explicitly
+// distinguish references to dropped sections from genuine references to
+// code at address zero, we must use a heuristic. We have chosen:
+//
+// - If a line starts at address zero, omit it. (On the platforms
+//   breakpad targets, it is extremely unlikely that there will be code
+//   at address zero.)
+//
+// - If a line starts immediately after an omitted line, omit it too.
+class DwarfLineToModule: public dwarf2reader::LineInfoHandler {
+public:
+// As the DWARF line info parser passes us line records, add source
+// files to MODULE, and add all lines to the end of LINES. LINES
+// need not be empty. If the parser hands us a zero-length line, we
+// omit it. If the parser hands us a line that extends beyond the
+// end of the address space, we clip it. It's up to our client to
+// sort out which lines belong to which functions; we don't add them
+// to any particular function in MODULE ourselves.
+DwarfLineToModule(Module *module, const string& compilation_dir,
+vector<Module::Line> *lines)
+: module_(module),
+compilation_dir_(compilation_dir),
+lines_(lines),
+highest_file_number_(-1),
+omitted_line_end_(0),
+warned_bad_file_number_(false),
+warned_bad_directory_number_(false) { }
+~DwarfLineToModule() { }
+void DefineDir(const string &name, uint32 dir_num);
+void DefineFile(const string &name, int32 file_num,
+uint32 dir_num, uint64 mod_time,
+uint64 length);
+void AddLine(uint64 address, uint64 length,
+uint32 file_num, uint32 line_num, uint32 column_num);
+private:
+typedef std::map<uint32, string> DirectoryTable;
+typedef std::map<uint32, Module::File *> FileTable;
+// The module we're contributing debugging info to. Owned by our
+// client.
+Module *module_;
+// The compilation directory for the current compilation unit whose
+// lines are being accumulated.
+string compilation_dir_;
+// The vector of lines we're accumulating. Owned by our client.
+//
+// In a Module, as in a breakpad symbol file, lines belong to
+// specific functions, but DWARF simply assigns lines to addresses;
+// one must infer the line/function relationship using the
+// functions' beginning and ending addresses. So we can't add these
+// to the appropriate function from module_ until we've read the
+// function info as well. Instead, we accumulate lines here, and let
+// whoever constructed this sort it all out.
+vector<Module::Line> *lines_;
+// A table mapping directory numbers to paths.
+DirectoryTable directories_;
+// A table mapping file numbers to Module::File pointers.
+FileTable files_;
+// The highest file number we've seen so far, or -1 if we've seen
+// none.  Used for dynamically defined file numbers.
+int32 highest_file_number_;
+// This is the ending address of the last line we omitted, or zero if we
+// didn't omit the previous line. It is zero before we have received any
+// AddLine calls.
+uint64 omitted_line_end_;
+// True if we've warned about:
+bool warned_bad_file_number_; // bad file numbers
+bool warned_bad_directory_number_; // bad directory numbers
+};
+} // namespace google_breakpad
+#endif // COMMON_LINUX_DWARF_LINE_TO_MODULE_H

The Tor Browser / file comparison

comparison: toolkit/crashreporter/google-breakpad/src/common/dwarf_line_to_module.h

toolkit/crashreporter/google-breakpad/src/common/dwarf_line_to_module.h