// -*- 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, vector<Module::Line> *lines) : module_(module), 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 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