| // 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. |
| |
| |
| // This file contains the definitions for a DWARF2/3 information |
| // collector that uses the DWARF2/3 reader interface to build a mapping |
| // of addresses to files, lines, and functions. |
| |
| #ifndef COMMON_DWARF_FUNCTIONINFO_H__ |
| #define COMMON_DWARF_FUNCTIONINFO_H__ |
| |
| #include <map> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "common/dwarf/dwarf2reader.h" |
| #include "common/using_std_string.h" |
| |
| |
| namespace dwarf2reader { |
| |
| struct FunctionInfo { |
| // Name of the function |
| string name; |
| // Mangled name of the function |
| string mangled_name; |
| // File containing this function |
| string file; |
| // Line number for start of function. |
| uint32 line; |
| // Beginning address for this function |
| uint64 lowpc; |
| // End address for this function. |
| uint64 highpc; |
| // Ranges offset |
| uint64 ranges; |
| }; |
| |
| struct SourceFileInfo { |
| // Name of the source file name |
| string name; |
| // Low address of source file name |
| uint64 lowpc; |
| }; |
| |
| typedef std::map<uint64, FunctionInfo*> FunctionMap; |
| typedef std::map<uint64, std::pair<string, uint32> > LineMap; |
| |
| // This class is a basic line info handler that fills in the dirs, |
| // file, and linemap passed into it with the data produced from the |
| // LineInfoHandler. |
| class CULineInfoHandler: public LineInfoHandler { |
| public: |
| |
| // |
| CULineInfoHandler(std::vector<SourceFileInfo>* files, |
| std::vector<string>* dirs, |
| LineMap* linemap); |
| virtual ~CULineInfoHandler() { } |
| |
| // Called when we define a directory. We just place NAME into dirs_ |
| // at position DIR_NUM. |
| virtual void DefineDir(const string& name, uint32 dir_num); |
| |
| // Called when we define a filename. We just place |
| // concat(dirs_[DIR_NUM], NAME) into files_ at position FILE_NUM. |
| virtual void DefineFile(const string& name, int32 file_num, |
| uint32 dir_num, uint64 mod_time, uint64 length); |
| |
| |
| // Called when the line info reader has a new line, address pair |
| // ready for us. ADDRESS is the address of the code, LENGTH is the |
| // length of its machine code in bytes, FILE_NUM is the file number |
| // containing the code, LINE_NUM is the line number in that file for |
| // the code, and COLUMN_NUM is the column number the code starts at, |
| // if we know it (0 otherwise). |
| virtual void AddLine(uint64 address, uint64 length, |
| uint32 file_num, uint32 line_num, uint32 column_num); |
| |
| private: |
| LineMap* linemap_; |
| std::vector<SourceFileInfo>* files_; |
| std::vector<string>* dirs_; |
| }; |
| |
| class CUFunctionInfoHandler: public Dwarf2Handler { |
| public: |
| CUFunctionInfoHandler(std::vector<SourceFileInfo>* files, |
| std::vector<string>* dirs, |
| LineMap* linemap, |
| FunctionMap* offset_to_funcinfo, |
| FunctionMap* address_to_funcinfo, |
| CULineInfoHandler* linehandler, |
| const SectionMap& sections, |
| ByteReader* reader) |
| : files_(files), dirs_(dirs), linemap_(linemap), |
| offset_to_funcinfo_(offset_to_funcinfo), |
| address_to_funcinfo_(address_to_funcinfo), |
| linehandler_(linehandler), sections_(sections), |
| reader_(reader), current_function_info_(NULL) { } |
| |
| virtual ~CUFunctionInfoHandler() { } |
| |
| // Start to process a compilation unit at OFFSET from the beginning of the |
| // .debug_info section. We want to see all compilation units, so we |
| // always return true. |
| |
| virtual bool StartCompilationUnit(uint64 offset, uint8 address_size, |
| uint8 offset_size, uint64 cu_length, |
| uint8 dwarf_version); |
| |
| // Start to process a DIE at OFFSET from the beginning of the |
| // .debug_info section. We only care about function related DIE's. |
| virtual bool StartDIE(uint64 offset, enum DwarfTag tag); |
| |
| // Called when we have an attribute with unsigned data to give to |
| // our handler. The attribute is for the DIE at OFFSET from the |
| // beginning of the .debug_info section, has a name of ATTR, a form of |
| // FORM, and the actual data of the attribute is in DATA. |
| virtual void ProcessAttributeUnsigned(uint64 offset, |
| enum DwarfAttribute attr, |
| enum DwarfForm form, |
| uint64 data); |
| |
| // Called when we have an attribute with a DIE reference to give to |
| // our handler. The attribute is for the DIE at OFFSET from the |
| // beginning of the .debug_info section, has a name of ATTR, a form of |
| // FORM, and the offset of the referenced DIE from the start of the |
| // .debug_info section is in DATA. |
| virtual void ProcessAttributeReference(uint64 offset, |
| enum DwarfAttribute attr, |
| enum DwarfForm form, |
| uint64 data); |
| |
| // Called when we have an attribute with string data to give to |
| // our handler. The attribute is for the DIE at OFFSET from the |
| // beginning of the .debug_info section, has a name of ATTR, a form of |
| // FORM, and the actual data of the attribute is in DATA. |
| virtual void ProcessAttributeString(uint64 offset, |
| enum DwarfAttribute attr, |
| enum DwarfForm form, |
| const string& data); |
| |
| // Called when finished processing the DIE at OFFSET. |
| // Because DWARF2/3 specifies a tree of DIEs, you may get starts |
| // before ends of the previous DIE, as we process children before |
| // ending the parent. |
| virtual void EndDIE(uint64 offset); |
| |
| private: |
| std::vector<SourceFileInfo>* files_; |
| std::vector<string>* dirs_; |
| LineMap* linemap_; |
| FunctionMap* offset_to_funcinfo_; |
| FunctionMap* address_to_funcinfo_; |
| CULineInfoHandler* linehandler_; |
| const SectionMap& sections_; |
| ByteReader* reader_; |
| FunctionInfo* current_function_info_; |
| uint64 current_compilation_unit_offset_; |
| }; |
| |
| } // namespace dwarf2reader |
| #endif // COMMON_DWARF_FUNCTIONINFO_H__ |