| // -*- 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 "common/linux/module.h" |
| #include "common/dwarf/dwarf2reader.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 std::string &name, uint32 dir_num); |
| void DefineFile(const std::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, std::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 |