LCOV - app.info - toolkit/crashreporter/google-breakpad/src/common/dwarf/dwarf2reader.h

LCOV - code coverage report
| Current view: | directory - toolkit/crashreporter/google-breakpad/src/common/dwarf - dwarf2reader.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 47 | 24 | 51.1 %
| Date: | 2012-04-07 | Functions: | 34 | 15 | 44.1 %

           1                 : // -*- mode: C++ -*-
           2                 :
           3                 : // Copyright (c) 2010 Google Inc. All Rights Reserved.
           4                 : //
           5                 : // Redistribution and use in source and binary forms, with or without
           6                 : // modification, are permitted provided that the following conditions are
           7                 : // met:
           8                 : //
           9                 : //     * Redistributions of source code must retain the above copyright
          10                 : // notice, this list of conditions and the following disclaimer.
          11                 : //     * Redistributions in binary form must reproduce the above
          12                 : // copyright notice, this list of conditions and the following disclaimer
          13                 : // in the documentation and/or other materials provided with the
          14                 : // distribution.
          15                 : //     * Neither the name of Google Inc. nor the names of its
          16                 : // contributors may be used to endorse or promote products derived from
          17                 : // this software without specific prior written permission.
          18                 : //
          19                 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
          20                 : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
          21                 : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
          22                 : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
          23                 : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
          24                 : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
          25                 : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
          26                 : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
          27                 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
          28                 : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
          29                 : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
          30                 :
          31                 : // CFI reader author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
          32                 :
          33                 : // This file contains definitions related to the DWARF2/3 reader and
          34                 : // it's handler interfaces.
          35                 : // The DWARF2/3 specification can be found at
          36                 : // http://dwarf.freestandards.org and should be considered required
          37                 : // reading if you wish to modify the implementation.
          38                 : // Only a cursory attempt is made to explain terminology that is
          39                 : // used here, as it is much better explained in the standard documents
          40                 : #ifndef COMMON_DWARF_DWARF2READER_H__
          41                 : #define COMMON_DWARF_DWARF2READER_H__
          42                 :
          43                 : #include <list>
          44                 : #include <map>
          45                 : #include <string>
          46                 : #include <utility>
          47                 : #include <vector>
          48                 :
          49                 : #include "common/dwarf/bytereader.h"
          50                 : #include "common/dwarf/dwarf2enums.h"
          51                 : #include "common/dwarf/types.h"
          52                 :
          53                 : using namespace std;
          54                 :
          55                 : namespace dwarf2reader {
          56                 : struct LineStateMachine;
          57                 : class Dwarf2Handler;
          58                 : class LineInfoHandler;
          59                 :
          60                 : // This maps from a string naming a section to a pair containing a
          61                 : // the data for the section, and the size of the section.
          62                 : typedef map<string, pair<const char*, uint64> > SectionMap;
          63                 : typedef list<pair<enum DwarfAttribute, enum DwarfForm> > AttributeList;
          64                 : typedef AttributeList::iterator AttributeIterator;
          65                 : typedef AttributeList::const_iterator ConstAttributeIterator;
          66                 :
          67                 : struct LineInfoHeader {
          68                 :   uint64 total_length;
          69                 :   uint16 version;
          70                 :   uint64 prologue_length;
          71                 :   uint8 min_insn_length; // insn stands for instructin
          72                 :   bool default_is_stmt; // stmt stands for statement
          73                 :   int8 line_base;
          74                 :   uint8 line_range;
          75                 :   uint8 opcode_base;
          76                 :   // Use a pointer so that signalsafe_addr2line is able to use this structure
          77                 :   // without heap allocation problem.
          78                 :   vector<unsigned char> *std_opcode_lengths;
          79                 : };
          80                 :
          81                 : class LineInfo {
          82                 :  public:
          83                 :
          84                 :   // Initializes a .debug_line reader. Buffer and buffer length point
          85                 :   // to the beginning and length of the line information to read.
          86                 :   // Reader is a ByteReader class that has the endianness set
          87                 :   // properly.
          88                 :   LineInfo(const char* buffer_, uint64 buffer_length,
          89                 :            ByteReader* reader, LineInfoHandler* handler);
          90                 :
          91            4845 :   virtual ~LineInfo() {
          92            4845 :     if (header_.std_opcode_lengths) {
          93            4845 :       delete header_.std_opcode_lengths;
          94                 :     }
          95            4845 :   }
          96                 :
          97                 :   // Start processing line info, and calling callbacks in the handler.
          98                 :   // Consumes the line number information for a single compilation unit.
          99                 :   // Returns the number of bytes processed.
         100                 :   uint64 Start();
         101                 :
         102                 :   // Process a single line info opcode at START using the state
         103                 :   // machine at LSM.  Return true if we should define a line using the
         104                 :   // current state of the line state machine.  Place the length of the
         105                 :   // opcode in LEN.
         106                 :   // If LSM_PASSES_PC is non-NULL, this function also checks if the lsm
         107                 :   // passes the address of PC. In other words, LSM_PASSES_PC will be
         108                 :   // set to true, if the following condition is met.
         109                 :   //
         110                 :   // lsm's old address < PC <= lsm's new address
         111                 :   static bool ProcessOneOpcode(ByteReader* reader,
         112                 :                                LineInfoHandler* handler,
         113                 :                                const struct LineInfoHeader &header,
         114                 :                                const char* start,
         115                 :                                struct LineStateMachine* lsm,
         116                 :                                size_t* len,
         117                 :                                uintptr pc,
         118                 :                                bool *lsm_passes_pc);
         119                 :
         120                 :  private:
         121                 :   // Reads the DWARF2/3 header for this line info.
         122                 :   void ReadHeader();
         123                 :
         124                 :   // Reads the DWARF2/3 line information
         125                 :   void ReadLines();
         126                 :
         127                 :   // The associated handler to call processing functions in
         128                 :   LineInfoHandler* handler_;
         129                 :
         130                 :   // The associated ByteReader that handles endianness issues for us
         131                 :   ByteReader* reader_;
         132                 :
         133                 :   // A DWARF2/3 line info header.  This is not the same size as
         134                 :   // in the actual file, as the one in the file may have a 32 bit or
         135                 :   // 64 bit lengths
         136                 :
         137                 :   struct LineInfoHeader header_;
         138                 :
         139                 :   // buffer is the buffer for our line info, starting at exactly where
         140                 :   // the line info to read is.  after_header is the place right after
         141                 :   // the end of the line information header.
         142                 :   const char* buffer_;
         143                 :   uint64 buffer_length_;
         144                 :   const char* after_header_;
         145                 : };
         146                 :
         147                 : // This class is the main interface between the line info reader and
         148                 : // the client.  The virtual functions inside this get called for
         149                 : // interesting events that happen during line info reading.  The
         150                 : // default implementation does nothing
         151                 :
         152                 : class LineInfoHandler {
         153                 :  public:
         154            4845 :   LineInfoHandler() { }
         155                 :
         156            4845 :   virtual ~LineInfoHandler() { }
         157                 :
         158                 :   // Called when we define a directory.  NAME is the directory name,
         159                 :   // DIR_NUM is the directory number
         160               0 :   virtual void DefineDir(const string& name, uint32 dir_num) { }
         161                 :
         162                 :   // Called when we define a filename. NAME is the filename, FILE_NUM
         163                 :   // is the file number which is -1 if the file index is the next
         164                 :   // index after the last numbered index (this happens when files are
         165                 :   // dynamically defined by the line program), DIR_NUM is the
         166                 :   // directory index for the directory name of this file, MOD_TIME is
         167                 :   // the modification time of the file, and LENGTH is the length of
         168                 :   // the file
         169               0 :   virtual void DefineFile(const string& name, int32 file_num,
         170                 :                           uint32 dir_num, uint64 mod_time,
         171               0 :                           uint64 length) { }
         172                 :
         173                 :   // Called when the line info reader has a new line, address pair
         174                 :   // ready for us. ADDRESS is the address of the code, LENGTH is the
         175                 :   // length of its machine code in bytes, FILE_NUM is the file number
         176                 :   // containing the code, LINE_NUM is the line number in that file for
         177                 :   // the code, and COLUMN_NUM is the column number the code starts at,
         178                 :   // if we know it (0 otherwise).
         179               0 :   virtual void AddLine(uint64 address, uint64 length,
         180               0 :                        uint32 file_num, uint32 line_num, uint32 column_num) { }
         181                 : };
         182                 :
         183                 : // The base of DWARF2/3 debug info is a DIE (Debugging Information
         184                 : // Entry.
         185                 : // DWARF groups DIE's into a tree and calls the root of this tree a
         186                 : // "compilation unit".  Most of the time, there is one compilation
         187                 : // unit in the .debug_info section for each file that had debug info
         188                 : // generated.
         189                 : // Each DIE consists of
         190                 :
         191                 : // 1. a tag specifying a thing that is being described (ie
         192                 : // DW_TAG_subprogram for functions, DW_TAG_variable for variables, etc
         193                 : // 2. attributes (such as DW_AT_location for location in memory,
         194                 : // DW_AT_name for name), and data for each attribute.
         195                 : // 3. A flag saying whether the DIE has children or not
         196                 :
         197                 : // In order to gain some amount of compression, the format of
         198                 : // each DIE (tag name, attributes and data forms for the attributes)
         199                 : // are stored in a separate table called the "abbreviation table".
         200                 : // This is done because a large number of DIEs have the exact same tag
         201                 : // and list of attributes, but different data for those attributes.
         202                 : // As a result, the .debug_info section is just a stream of data, and
         203                 : // requires reading of the .debug_abbrev section to say what the data
         204                 : // means.
         205                 :
         206                 : // As a warning to the user, it should be noted that the reason for
         207                 : // using absolute offsets from the beginning of .debug_info is that
         208                 : // DWARF2/3 supports referencing DIE's from other DIE's by their offset
         209                 : // from either the current compilation unit start, *or* the beginning
         210                 : // of the .debug_info section.  This means it is possible to reference
         211                 : // a DIE in one compilation unit from a DIE in another compilation
         212                 : // unit.  This style of reference is usually used to eliminate
         213                 : // duplicated information that occurs across compilation
         214                 : // units, such as base types, etc.  GCC 3.4+ support this with
         215                 : // -feliminate-dwarf2-dups.  Other toolchains will sometimes do
         216                 : // duplicate elimination in the linker.
         217                 :
         218                 : class CompilationUnit {
         219                 :  public:
         220                 :
         221                 :   // Initialize a compilation unit.  This requires a map of sections,
         222                 :   // the offset of this compilation unit in the .debug_info section, a
         223                 :   // ByteReader, and a Dwarf2Handler class to call callbacks in.
         224                 :   CompilationUnit(const SectionMap& sections, uint64 offset,
         225                 :                   ByteReader* reader, Dwarf2Handler* handler);
         226            4895 :   virtual ~CompilationUnit() {
         227            4895 :     if (abbrevs_) delete abbrevs_;
         228            4895 :   }
         229                 :
         230                 :   // Begin reading a Dwarf2 compilation unit, and calling the
         231                 :   // callbacks in the Dwarf2Handler
         232                 :
         233                 :   // Return the full length of the compilation unit, including
         234                 :   // headers. This plus the starting offset passed to the constructor
         235                 :   // is the offset of the end of the compilation unit --- and the
         236                 :   // start of the next compilation unit, if there is one.
         237                 :   uint64 Start();
         238                 :
         239                 :  private:
         240                 :
         241                 :   // This struct represents a single DWARF2/3 abbreviation
         242                 :   // The abbreviation tells how to read a DWARF2/3 DIE, and consist of a
         243                 :   // tag and a list of attributes, as well as the data form of each attribute.
         244         1849892 :   struct Abbrev {
         245                 :     uint64 number;
         246                 :     enum DwarfTag tag;
         247                 :     bool has_children;
         248                 :     AttributeList attributes;
         249                 :   };
         250                 :
         251                 :   // A DWARF2/3 compilation unit header.  This is not the same size as
         252                 :   // in the actual file, as the one in the file may have a 32 bit or
         253                 :   // 64 bit length.
         254                 :   struct CompilationUnitHeader {
         255                 :     uint64 length;
         256                 :     uint16 version;
         257                 :     uint64 abbrev_offset;
         258                 :     uint8 address_size;
         259                 :   } header_;
         260                 :
         261                 :   // Reads the DWARF2/3 header for this compilation unit.
         262                 :   void ReadHeader();
         263                 :
         264                 :   // Reads the DWARF2/3 abbreviations for this compilation unit
         265                 :   void ReadAbbrevs();
         266                 :
         267                 :   // Processes a single DIE for this compilation unit and return a new
         268                 :   // pointer just past the end of it
         269                 :   const char* ProcessDIE(uint64 dieoffset,
         270                 :                                   const char* start,
         271                 :                                   const Abbrev& abbrev);
         272                 :
         273                 :   // Processes a single attribute and return a new pointer just past the
         274                 :   // end of it
         275                 :   const char* ProcessAttribute(uint64 dieoffset,
         276                 :                                         const char* start,
         277                 :                                         enum DwarfAttribute attr,
         278                 :                                         enum DwarfForm form);
         279                 :
         280                 :   // Processes all DIEs for this compilation unit
         281                 :   void ProcessDIEs();
         282                 :
         283                 :   // Skips the die with attributes specified in ABBREV starting at
         284                 :   // START, and return the new place to position the stream to.
         285                 :   const char* SkipDIE(const char* start,
         286                 :                                const Abbrev& abbrev);
         287                 :
         288                 :   // Skips the attribute starting at START, with FORM, and return the
         289                 :   // new place to position the stream to.
         290                 :   const char* SkipAttribute(const char* start,
         291                 :                                      enum DwarfForm form);
         292                 :
         293                 :   // Offset from section start is the offset of this compilation unit
         294                 :   // from the beginning of the .debug_info section.
         295                 :   uint64 offset_from_section_start_;
         296                 :
         297                 :   // buffer is the buffer for our CU, starting at .debug_info + offset
         298                 :   // passed in from constructor.
         299                 :   // after_header points to right after the compilation unit header.
         300                 :   const char* buffer_;
         301                 :   uint64 buffer_length_;
         302                 :   const char* after_header_;
         303                 :
         304                 :   // The associated ByteReader that handles endianness issues for us
         305                 :   ByteReader* reader_;
         306                 :
         307                 :   // The map of sections in our file to buffers containing their data
         308                 :   const SectionMap& sections_;
         309                 :
         310                 :   // The associated handler to call processing functions in
         311                 :   Dwarf2Handler* handler_;
         312                 :
         313                 :   // Set of DWARF2/3 abbreviations for this compilation unit.  Indexed
         314                 :   // by abbreviation number, which means that abbrevs_[0] is not
         315                 :   // valid.
         316                 :   vector<Abbrev>* abbrevs_;
         317                 :
         318                 :   // String section buffer and length, if we have a string section.
         319                 :   // This is here to avoid doing a section lookup for strings in
         320                 :   // ProcessAttribute, which is in the hot path for DWARF2 reading.
         321                 :   const char* string_buffer_;
         322                 :   uint64 string_buffer_length_;
         323                 : };
         324                 :
         325                 : // This class is the main interface between the reader and the
         326                 : // client.  The virtual functions inside this get called for
         327                 : // interesting events that happen during DWARF2 reading.
         328                 : // The default implementation skips everything.
         329                 :
         330                 : class Dwarf2Handler {
         331                 :  public:
         332            4895 :   Dwarf2Handler() { }
         333                 :
         334            4895 :   virtual ~Dwarf2Handler() { }
         335                 :
         336                 :   // Start to process a compilation unit at OFFSET from the beginning of the
         337                 :   // .debug_info section. Return false if you would like to skip this
         338                 :   // compilation unit.
         339               0 :   virtual bool StartCompilationUnit(uint64 offset, uint8 address_size,
         340                 :                                     uint8 offset_size, uint64 cu_length,
         341               0 :                                     uint8 dwarf_version) { return false; }
         342                 :
         343                 :   // Start to process a DIE at OFFSET from the beginning of the .debug_info
         344                 :   // section. Return false if you would like to skip this DIE.
         345               0 :   virtual bool StartDIE(uint64 offset, enum DwarfTag tag,
         346               0 :                         const AttributeList& attrs) { return false; }
         347                 :
         348                 :   // Called when we have an attribute with unsigned data to give to our
         349                 :   // handler. The attribute is for the DIE at OFFSET from the beginning of the
         350                 :   // .debug_info section. Its name is ATTR, its form is FORM, and its value is
         351                 :   // DATA.
         352               0 :   virtual void ProcessAttributeUnsigned(uint64 offset,
         353                 :                                         enum DwarfAttribute attr,
         354                 :                                         enum DwarfForm form,
         355               0 :                                         uint64 data) { }
         356                 :
         357                 :   // Called when we have an attribute with signed data to give to our handler.
         358                 :   // The attribute is for the DIE at OFFSET from the beginning of the
         359                 :   // .debug_info section. Its name is ATTR, its form is FORM, and its value is
         360                 :   // DATA.
         361               0 :   virtual void ProcessAttributeSigned(uint64 offset,
         362                 :                                       enum DwarfAttribute attr,
         363                 :                                       enum DwarfForm form,
         364               0 :                                       int64 data) { }
         365                 :
         366                 :   // Called when we have an attribute whose value is a reference to
         367                 :   // another DIE. The attribute belongs to the DIE at OFFSET from the
         368                 :   // beginning of the .debug_info section. Its name is ATTR, its form
         369                 :   // is FORM, and the offset of the DIE being referred to from the
         370                 :   // beginning of the .debug_info section is DATA.
         371               0 :   virtual void ProcessAttributeReference(uint64 offset,
         372                 :                                          enum DwarfAttribute attr,
         373                 :                                          enum DwarfForm form,
         374               0 :                                          uint64 data) { }
         375                 :
         376                 :   // Called when we have an attribute with a buffer of data to give to our
         377                 :   // handler. The attribute is for the DIE at OFFSET from the beginning of the
         378                 :   // .debug_info section. Its name is ATTR, its form is FORM, DATA points to
         379                 :   // the buffer's contents, and its length in bytes is LENGTH. The buffer is
         380                 :   // owned by the caller, not the callee, and may not persist for very long.
         381                 :   // If you want the data to be available later, it needs to be copied.
         382               0 :   virtual void ProcessAttributeBuffer(uint64 offset,
         383                 :                                       enum DwarfAttribute attr,
         384                 :                                       enum DwarfForm form,
         385                 :                                       const char* data,
         386               0 :                                       uint64 len) { }
         387                 :
         388                 :   // Called when we have an attribute with string data to give to our handler.
         389                 :   // The attribute is for the DIE at OFFSET from the beginning of the
         390                 :   // .debug_info section. Its name is ATTR, its form is FORM, and its value is
         391                 :   // DATA.
         392               0 :   virtual void ProcessAttributeString(uint64 offset,
         393                 :                                       enum DwarfAttribute attr,
         394                 :                                       enum DwarfForm form,
         395               0 :                                       const string& data) { }
         396                 :
         397                 :   // Called when we have an attribute whose value is the 64-bit signature
         398                 :   // of a type unit in the .debug_types section. OFFSET is the offset of
         399                 :   // the DIE whose attribute we're reporting. ATTR and FORM are the
         400                 :   // attribute's name and form. SIGNATURE is the type unit's signature.
         401               0 :   virtual void ProcessAttributeSignature(uint64 offset,
         402                 :                                          enum DwarfAttribute attr,
         403                 :                                          enum DwarfForm form,
         404               0 :                                          uint64 signature) { }
         405                 :
         406                 :   // Called when finished processing the DIE at OFFSET.
         407                 :   // Because DWARF2/3 specifies a tree of DIEs, you may get starts
         408                 :   // before ends of the previous DIE, as we process children before
         409                 :   // ending the parent.
         410               0 :   virtual void EndDIE(uint64 offset) { }
         411                 :
         412                 : };
         413                 :
         414                 : // This class is a reader for DWARF's Call Frame Information.  CFI
         415                 : // describes how to unwind stack frames --- even for functions that do
         416                 : // not follow fixed conventions for saving registers, whose frame size
         417                 : // varies as they execute, etc.
         418                 : //
         419                 : // CFI describes, at each machine instruction, how to compute the
         420                 : // stack frame's base address, how to find the return address, and
         421                 : // where to find the saved values of the caller's registers (if the
         422                 : // callee has stashed them somewhere to free up the registers for its
         423                 : // own use).
         424                 : //
         425                 : // For example, suppose we have a function whose machine code looks
         426                 : // like this (imagine an assembly language that looks like C, for a
         427                 : // machine with 32-bit registers, and a stack that grows towards lower
         428                 : // addresses):
         429                 : //
         430                 : // func:                                ; entry point; return address at sp
         431                 : // func+0:      sp = sp - 16            ; allocate space for stack frame
         432                 : // func+1:      sp[12] = r0             ; save r0 at sp+12
         433                 : // ...                                  ; other code, not frame-related
         434                 : // func+10:     sp -= 4; *sp = x        ; push some x on the stack
         435                 : // ...                                  ; other code, not frame-related
         436                 : // func+20:     r0 = sp[16]             ; restore saved r0
         437                 : // func+21:     sp += 20                ; pop whole stack frame
         438                 : // func+22:     pc = *sp; sp += 4       ; pop return address and jump to it
         439                 : //
         440                 : // DWARF CFI is (a very compressed representation of) a table with a
         441                 : // row for each machine instruction address and a column for each
         442                 : // register showing how to restore it, if possible.
         443                 : //
         444                 : // A special column named "CFA", for "Canonical Frame Address", tells how
         445                 : // to compute the base address of the frame; registers' entries may
         446                 : // refer to the CFA in describing where the registers are saved.
         447                 : //
         448                 : // Another special column, named "RA", represents the return address.
         449                 : //
         450                 : // For example, here is a complete (uncompressed) table describing the
         451                 : // function above:
         452                 : //
         453                 : //     insn      cfa    r0      r1 ...  ra
         454                 : //     =======================================
         455                 : //     func+0:   sp                     cfa[0]
         456                 : //     func+1:   sp+16                  cfa[0]
         457                 : //     func+2:   sp+16  cfa[-4]         cfa[0]
         458                 : //     func+11:  sp+20  cfa[-4]         cfa[0]
         459                 : //     func+21:  sp+20                  cfa[0]
         460                 : //     func+22:  sp                     cfa[0]
         461                 : //
         462                 : // Some things to note here:
         463                 : //
         464                 : // - Each row describes the state of affairs *before* executing the
         465                 : //   instruction at the given address.  Thus, the row for func+0
         466                 : //   describes the state before we allocate the stack frame.  In the
         467                 : //   next row, the formula for computing the CFA has changed,
         468                 : //   reflecting that allocation.
         469                 : //
         470                 : // - The other entries are written in terms of the CFA; this allows
         471                 : //   them to remain unchanged as the stack pointer gets bumped around.
         472                 : //   For example, the rule for recovering the return address (the "ra"
         473                 : //   column) remains unchanged throughout the function, even as the
         474                 : //   stack pointer takes on three different offsets from the return
         475                 : //   address.
         476                 : //
         477                 : // - Although we haven't shown it, most calling conventions designate
         478                 : //   "callee-saves" and "caller-saves" registers. The callee must
         479                 : //   preserve the values of callee-saves registers; if it uses them,
         480                 : //   it must save their original values somewhere, and restore them
         481                 : //   before it returns. In contrast, the callee is free to trash
         482                 : //   caller-saves registers; if the callee uses these, it will
         483                 : //   probably not bother to save them anywhere, and the CFI will
         484                 : //   probably mark their values as "unrecoverable".
         485                 : //
         486                 : //   (However, since the caller cannot assume the callee was going to
         487                 : //   save them, caller-saves registers are probably dead in the caller
         488                 : //   anyway, so compilers usually don't generate CFA for caller-saves
         489                 : //   registers.)
         490                 : //
         491                 : // - Exactly where the CFA points is a matter of convention that
         492                 : //   depends on the architecture and ABI in use. In the example, the
         493                 : //   CFA is the value the stack pointer had upon entry to the
         494                 : //   function, pointing at the saved return address. But on the x86,
         495                 : //   the call frame information generated by GCC follows the
         496                 : //   convention that the CFA is the address *after* the saved return
         497                 : //   address.
         498                 : //
         499                 : //   But by definition, the CFA remains constant throughout the
         500                 : //   lifetime of the frame. This makes it a useful value for other
         501                 : //   columns to refer to. It is also gives debuggers a useful handle
         502                 : //   for identifying a frame.
         503                 : //
         504                 : // If you look at the table above, you'll notice that a given entry is
         505                 : // often the same as the one immediately above it: most instructions
         506                 : // change only one or two aspects of the stack frame, if they affect
         507                 : // it at all. The DWARF format takes advantage of this fact, and
         508                 : // reduces the size of the data by mentioning only the addresses and
         509                 : // columns at which changes take place. So for the above, DWARF CFI
         510                 : // data would only actually mention the following:
         511                 : //
         512                 : //     insn      cfa    r0      r1 ...  ra
         513                 : //     =======================================
         514                 : //     func+0:   sp                     cfa[0]
         515                 : //     func+1:   sp+16
         516                 : //     func+2:          cfa[-4]
         517                 : //     func+11:  sp+20
         518                 : //     func+21:         r0
         519                 : //     func+22:  sp
         520                 : //
         521                 : // In fact, this is the way the parser reports CFI to the consumer: as
         522                 : // a series of statements of the form, "At address X, column Y changed
         523                 : // to Z," and related conventions for describing the initial state.
         524                 : //
         525                 : // Naturally, it would be impractical to have to scan the entire
         526                 : // program's CFI, noting changes as we go, just to recover the
         527                 : // unwinding rules in effect at one particular instruction. To avoid
         528                 : // this, CFI data is grouped into "entries", each of which covers a
         529                 : // specified range of addresses and begins with a complete statement
         530                 : // of the rules for all recoverable registers at that starting
         531                 : // address. Each entry typically covers a single function.
         532                 : //
         533                 : // Thus, to compute the contents of a given row of the table --- that
         534                 : // is, rules for recovering the CFA, RA, and registers at a given
         535                 : // instruction --- the consumer should find the entry that covers that
         536                 : // instruction's address, start with the initial state supplied at the
         537                 : // beginning of the entry, and work forward until it has processed all
         538                 : // the changes up to and including those for the present instruction.
         539                 : //
         540                 : // There are seven kinds of rules that can appear in an entry of the
         541                 : // table:
         542                 : //
         543                 : // - "undefined": The given register is not preserved by the callee;
         544                 : //   its value cannot be recovered.
         545                 : //
         546                 : // - "same value": This register has the same value it did in the callee.
         547                 : //
         548                 : // - offset(N): The register is saved at offset N from the CFA.
         549                 : //
         550                 : // - val_offset(N): The value the register had in the caller is the
         551                 : //   CFA plus offset N. (This is usually only useful for describing
         552                 : //   the stack pointer.)
         553                 : //
         554                 : // - register(R): The register's value was saved in another register R.
         555                 : //
         556                 : // - expression(E): Evaluating the DWARF expression E using the
         557                 : //   current frame's registers' values yields the address at which the
         558                 : //   register was saved.
         559                 : //
         560                 : // - val_expression(E): Evaluating the DWARF expression E using the
         561                 : //   current frame's registers' values yields the value the register
         562                 : //   had in the caller.
         563                 :
         564                 : class CallFrameInfo {
         565                 :  public:
         566                 :   // The different kinds of entries one finds in CFI. Used internally,
         567                 :   // and for error reporting.
         568                 :   enum EntryKind { kUnknown, kCIE, kFDE, kTerminator };
         569                 :
         570                 :   // The handler class to which the parser hands the parsed call frame
         571                 :   // information.  Defined below.
         572                 :   class Handler;
         573                 :
         574                 :   // A reporter class, which CallFrameInfo uses to report errors
         575                 :   // encountered while parsing call frame information.  Defined below.
         576                 :   class Reporter;
         577                 :
         578                 :   // Create a DWARF CFI parser. BUFFER points to the contents of the
         579                 :   // .debug_frame section to parse; BUFFER_LENGTH is its length in bytes.
         580                 :   // REPORTER is an error reporter the parser should use to report
         581                 :   // problems. READER is a ByteReader instance that has the endianness and
         582                 :   // address size set properly. Report the data we find to HANDLER.
         583                 :   //
         584                 :   // This class can also parse Linux C++ exception handling data, as found
         585                 :   // in '.eh_frame' sections. This data is a variant of DWARF CFI that is
         586                 :   // placed in loadable segments so that it is present in the program's
         587                 :   // address space, and is interpreted by the C++ runtime to search the
         588                 :   // call stack for a handler interested in the exception being thrown,
         589                 :   // actually pop the frames, and find cleanup code to run.
         590                 :   //
         591                 :   // There are two differences between the call frame information described
         592                 :   // in the DWARF standard and the exception handling data Linux places in
         593                 :   // the .eh_frame section:
         594                 :   //
         595                 :   // - Exception handling data uses uses a different format for call frame
         596                 :   //   information entry headers. The distinguished CIE id, the way FDEs
         597                 :   //   refer to their CIEs, and the way the end of the series of entries is
         598                 :   //   determined are all slightly different.
         599                 :   //
         600                 :   //   If the constructor's EH_FRAME argument is true, then the
         601                 :   //   CallFrameInfo parses the entry headers as Linux C++ exception
         602                 :   //   handling data. If EH_FRAME is false or omitted, the CallFrameInfo
         603                 :   //   parses standard DWARF call frame information.
         604                 :   //
         605                 :   // - Linux C++ exception handling data uses CIE augmentation strings
         606                 :   //   beginning with 'z' to specify the presence of additional data after
         607                 :   //   the CIE and FDE headers and special encodings used for addresses in
         608                 :   //   frame description entries.
         609                 :   //
         610                 :   //   CallFrameInfo can handle 'z' augmentations in either DWARF CFI or
         611                 :   //   exception handling data if you have supplied READER with the base
         612                 :   //   addresses needed to interpret the pointer encodings that 'z'
         613                 :   //   augmentations can specify. See the ByteReader interface for details
         614                 :   //   about the base addresses. See the CallFrameInfo::Handler interface
         615                 :   //   for details about the additional information one might find in
         616                 :   //   'z'-augmented data.
         617                 :   //
         618                 :   // Thus:
         619                 :   //
         620                 :   // - If you are parsing standard DWARF CFI, as found in a .debug_frame
         621                 :   //   section, you should pass false for the EH_FRAME argument, or omit
         622                 :   //   it, and you need not worry about providing READER with the
         623                 :   //   additional base addresses.
         624                 :   //
         625                 :   // - If you want to parse Linux C++ exception handling data from a
         626                 :   //   .eh_frame section, you should pass EH_FRAME as true, and call
         627                 :   //   READER's Set*Base member functions before calling our Start method.
         628                 :   //
         629                 :   // - If you want to parse DWARF CFI that uses the 'z' augmentations
         630                 :   //   (although I don't think any toolchain ever emits such data), you
         631                 :   //   could pass false for EH_FRAME, but call READER's Set*Base members.
         632                 :   //
         633                 :   // The extensions the Linux C++ ABI makes to DWARF for exception
         634                 :   // handling are described here, rather poorly:
         635                 :   // http://refspecs.linux-foundation.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/dwarfext.html
         636                 :   // http://refspecs.linux-foundation.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
         637                 :   //
         638                 :   // The mechanics of C++ exception handling, personality routines,
         639                 :   // and language-specific data areas are described here, rather nicely:
         640                 :   // http://www.codesourcery.com/public/cxx-abi/abi-eh.html
         641             248 :   CallFrameInfo(const char *buffer, size_t buffer_length,
         642                 :                 ByteReader *reader, Handler *handler, Reporter *reporter,
         643                 :                 bool eh_frame = false)
         644                 :       : buffer_(buffer), buffer_length_(buffer_length),
         645                 :         reader_(reader), handler_(handler), reporter_(reporter),
         646             248 :         eh_frame_(eh_frame) { }
         647                 :
         648             248 :   ~CallFrameInfo() { }
         649                 :
         650                 :   // Parse the entries in BUFFER, reporting what we find to HANDLER.
         651                 :   // Return true if we reach the end of the section successfully, or
         652                 :   // false if we encounter an error.
         653                 :   bool Start();
         654                 :
         655                 :   // Return the textual name of KIND. For error reporting.
         656                 :   static const char *KindName(EntryKind kind);
         657                 :
         658                 :  private:
         659                 :
         660                 :   struct CIE;
         661                 :
         662                 :   // A CFI entry, either an FDE or a CIE.
         663                 :   struct Entry {
         664                 :     // The starting offset of the entry in the section, for error
         665                 :     // reporting.
         666                 :     size_t offset;
         667                 :
         668                 :     // The start of this entry in the buffer.
         669                 :     const char *start;
         670                 :
         671                 :     // Which kind of entry this is.
         672                 :     //
         673                 :     // We want to be able to use this for error reporting even while we're
         674                 :     // in the midst of parsing. Error reporting code may assume that kind,
         675                 :     // offset, and start fields are valid, although kind may be kUnknown.
         676                 :     EntryKind kind;
         677                 :
         678                 :     // The end of this entry's common prologue (initial length and id), and
         679                 :     // the start of this entry's kind-specific fields.
         680                 :     const char *fields;
         681                 :
         682                 :     // The start of this entry's instructions.
         683                 :     const char *instructions;
         684                 :
         685                 :     // The address past the entry's last byte in the buffer. (Note that
         686                 :     // since offset points to the entry's initial length field, and the
         687                 :     // length field is the number of bytes after that field, this is not
         688                 :     // simply buffer_ + offset + length.)
         689                 :     const char *end;
         690                 :
         691                 :     // For both DWARF CFI and .eh_frame sections, this is the CIE id in a
         692                 :     // CIE, and the offset of the associated CIE in an FDE.
         693                 :     uint64 id;
         694                 :
         695                 :     // The CIE that applies to this entry, if we've parsed it. If this is a
         696                 :     // CIE, then this field points to this structure.
         697                 :     CIE *cie;
         698                 :   };
         699                 :
         700                 :   // A common information entry (CIE).
         701                 :   struct CIE: public Entry {
         702                 :     uint8 version;                      // CFI data version number
         703                 :     string augmentation;                // vendor format extension markers
         704                 :     uint64 code_alignment_factor;       // scale for code address adjustments
         705                 :     int data_alignment_factor;          // scale for stack pointer adjustments
         706                 :     unsigned return_address_register;   // which register holds the return addr
         707                 :
         708                 :     // True if this CIE includes Linux C++ ABI 'z' augmentation data.
         709                 :     bool has_z_augmentation;
         710                 :
         711                 :     // Parsed 'z' augmentation data. These are meaningful only if
         712                 :     // has_z_augmentation is true.
         713                 :     bool has_z_lsda;                    // The 'z' augmentation included 'L'.
         714                 :     bool has_z_personality;             // The 'z' augmentation included 'P'.
         715                 :     bool has_z_signal_frame;            // The 'z' augmentation included 'S'.
         716                 :
         717                 :     // If has_z_lsda is true, this is the encoding to be used for language-
         718                 :     // specific data area pointers in FDEs.
         719                 :     DwarfPointerEncoding lsda_encoding;
         720                 :
         721                 :     // If has_z_personality is true, this is the encoding used for the
         722                 :     // personality routine pointer in the augmentation data.
         723                 :     DwarfPointerEncoding personality_encoding;
         724                 :
         725                 :     // If has_z_personality is true, this is the address of the personality
         726                 :     // routine --- or, if personality_encoding & DW_EH_PE_indirect, the
         727                 :     // address where the personality routine's address is stored.
         728                 :     uint64 personality_address;
         729                 :
         730                 :     // This is the encoding used for addresses in the FDE header and
         731                 :     // in DW_CFA_set_loc instructions. This is always valid, whether
         732                 :     // or not we saw a 'z' augmentation string; its default value is
         733                 :     // DW_EH_PE_absptr, which is what normal DWARF CFI uses.
         734                 :     DwarfPointerEncoding pointer_encoding;
         735                 :   };
         736                 :
         737                 :   // A frame description entry (FDE).
         738                 :   struct FDE: public Entry {
         739                 :     uint64 address;                     // start address of described code
         740                 :     uint64 size;                        // size of described code, in bytes
         741                 :
         742                 :     // If cie->has_z_lsda is true, then this is the language-specific data
         743                 :     // area's address --- or its address's address, if cie->lsda_encoding
         744                 :     // has the DW_EH_PE_indirect bit set.
         745                 :     uint64 lsda_address;
         746                 :   };
         747                 :
         748                 :   // Internal use.
         749                 :   class Rule;
         750                 :   class UndefinedRule;
         751                 :   class SameValueRule;
         752                 :   class OffsetRule;
         753                 :   class ValOffsetRule;
         754                 :   class RegisterRule;
         755                 :   class ExpressionRule;
         756                 :   class ValExpressionRule;
         757                 :   class RuleMap;
         758                 :   class State;
         759                 :
         760                 :   // Parse the initial length and id of a CFI entry, either a CIE, an FDE,
         761                 :   // or a .eh_frame end-of-data mark. CURSOR points to the beginning of the
         762                 :   // data to parse. On success, populate ENTRY as appropriate, and return
         763                 :   // true. On failure, report the problem, and return false. Even if we
         764                 :   // return false, set ENTRY->end to the first byte after the entry if we
         765                 :   // were able to figure that out, or NULL if we weren't.
         766                 :   bool ReadEntryPrologue(const char *cursor, Entry *entry);
         767                 :
         768                 :   // Parse the fields of a CIE after the entry prologue, including any 'z'
         769                 :   // augmentation data. Assume that the 'Entry' fields of CIE are
         770                 :   // populated; use CIE->fields and CIE->end as the start and limit for
         771                 :   // parsing. On success, populate the rest of *CIE, and return true; on
         772                 :   // failure, report the problem and return false.
         773                 :   bool ReadCIEFields(CIE *cie);
         774                 :
         775                 :   // Parse the fields of an FDE after the entry prologue, including any 'z'
         776                 :   // augmentation data. Assume that the 'Entry' fields of *FDE are
         777                 :   // initialized; use FDE->fields and FDE->end as the start and limit for
         778                 :   // parsing. Assume that FDE->cie is fully initialized. On success,
         779                 :   // populate the rest of *FDE, and return true; on failure, report the
         780                 :   // problem and return false.
         781                 :   bool ReadFDEFields(FDE *fde);
         782                 :
         783                 :   // Report that ENTRY is incomplete, and return false. This is just a
         784                 :   // trivial wrapper for invoking reporter_->Incomplete; it provides a
         785                 :   // little brevity.
         786                 :   bool ReportIncomplete(Entry *entry);
         787                 :
         788                 :   // Return true if ENCODING has the DW_EH_PE_indirect bit set.
         789                 :   static bool IsIndirectEncoding(DwarfPointerEncoding encoding) {
         790                 :     return encoding & DW_EH_PE_indirect;
         791                 :   }
         792                 :
         793                 :   // The contents of the DWARF .debug_info section we're parsing.
         794                 :   const char *buffer_;
         795                 :   size_t buffer_length_;
         796                 :
         797                 :   // For reading multi-byte values with the appropriate endianness.
         798                 :   ByteReader *reader_;
         799                 :
         800                 :   // The handler to which we should report the data we find.
         801                 :   Handler *handler_;
         802                 :
         803                 :   // For reporting problems in the info we're parsing.
         804                 :   Reporter *reporter_;
         805                 :
         806                 :   // True if we are processing .eh_frame-format data.
         807                 :   bool eh_frame_;
         808                 : };
         809                 :
         810                 : // The handler class for CallFrameInfo.  The a CFI parser calls the
         811                 : // member functions of a handler object to report the data it finds.
         812                 : class CallFrameInfo::Handler {
         813                 :  public:
         814                 :   // The pseudo-register number for the canonical frame address.
         815                 :   enum { kCFARegister = -1 };
         816                 :
         817             248 :   Handler() { }
         818             248 :   virtual ~Handler() { }
         819                 :
         820                 :   // The parser has found CFI for the machine code at ADDRESS,
         821                 :   // extending for LENGTH bytes. OFFSET is the offset of the frame
         822                 :   // description entry in the section, for use in error messages.
         823                 :   // VERSION is the version number of the CFI format. AUGMENTATION is
         824                 :   // a string describing any producer-specific extensions present in
         825                 :   // the data. RETURN_ADDRESS is the number of the register that holds
         826                 :   // the address to which the function should return.
         827                 :   //
         828                 :   // Entry should return true to process this CFI, or false to skip to
         829                 :   // the next entry.
         830                 :   //
         831                 :   // The parser invokes Entry for each Frame Description Entry (FDE)
         832                 :   // it finds.  The parser doesn't report Common Information Entries
         833                 :   // to the handler explicitly; instead, if the handler elects to
         834                 :   // process a given FDE, the parser reiterates the appropriate CIE's
         835                 :   // contents at the beginning of the FDE's rules.
         836                 :   virtual bool Entry(size_t offset, uint64 address, uint64 length,
         837                 :                      uint8 version, const string &augmentation,
         838                 :                      unsigned return_address) = 0;
         839                 :
         840                 :   // When the Entry function returns true, the parser calls these
         841                 :   // handler functions repeatedly to describe the rules for recovering
         842                 :   // registers at each instruction in the given range of machine code.
         843                 :   // Immediately after a call to Entry, the handler should assume that
         844                 :   // the rule for each callee-saves register is "unchanged" --- that
         845                 :   // is, that the register still has the value it had in the caller.
         846                 :   //
         847                 :   // If a *Rule function returns true, we continue processing this entry's
         848                 :   // instructions. If a *Rule function returns false, we stop evaluating
         849                 :   // instructions, and skip to the next entry. Either way, we call End
         850                 :   // before going on to the next entry.
         851                 :   //
         852                 :   // In all of these functions, if the REG parameter is kCFARegister, then
         853                 :   // the rule describes how to find the canonical frame address.
         854                 :   // kCFARegister may be passed as a BASE_REGISTER argument, meaning that
         855                 :   // the canonical frame address should be used as the base address for the
         856                 :   // computation. All other REG values will be positive.
         857                 :
         858                 :   // At ADDRESS, register REG's value is not recoverable.
         859                 :   virtual bool UndefinedRule(uint64 address, int reg) = 0;
         860                 :
         861                 :   // At ADDRESS, register REG's value is the same as that it had in
         862                 :   // the caller.
         863                 :   virtual bool SameValueRule(uint64 address, int reg) = 0;
         864                 :
         865                 :   // At ADDRESS, register REG has been saved at offset OFFSET from
         866                 :   // BASE_REGISTER.
         867                 :   virtual bool OffsetRule(uint64 address, int reg,
         868                 :                           int base_register, long offset) = 0;
         869                 :
         870                 :   // At ADDRESS, the caller's value of register REG is the current
         871                 :   // value of BASE_REGISTER plus OFFSET. (This rule doesn't provide an
         872                 :   // address at which the register's value is saved.)
         873                 :   virtual bool ValOffsetRule(uint64 address, int reg,
         874                 :                              int base_register, long offset) = 0;
         875                 :
         876                 :   // At ADDRESS, register REG has been saved in BASE_REGISTER. This differs
         877                 :   // from ValOffsetRule(ADDRESS, REG, BASE_REGISTER, 0), in that
         878                 :   // BASE_REGISTER is the "home" for REG's saved value: if you want to
         879                 :   // assign to a variable whose home is REG in the calling frame, you
         880                 :   // should put the value in BASE_REGISTER.
         881                 :   virtual bool RegisterRule(uint64 address, int reg, int base_register) = 0;
         882                 :
         883                 :   // At ADDRESS, the DWARF expression EXPRESSION yields the address at
         884                 :   // which REG was saved.
         885                 :   virtual bool ExpressionRule(uint64 address, int reg,
         886                 :                               const string &expression) = 0;
         887                 :
         888                 :   // At ADDRESS, the DWARF expression EXPRESSION yields the caller's
         889                 :   // value for REG. (This rule doesn't provide an address at which the
         890                 :   // register's value is saved.)
         891                 :   virtual bool ValExpressionRule(uint64 address, int reg,
         892                 :                                  const string &expression) = 0;
         893                 :
         894                 :   // Indicate that the rules for the address range reported by the
         895                 :   // last call to Entry are complete.  End should return true if
         896                 :   // everything is okay, or false if an error has occurred and parsing
         897                 :   // should stop.
         898                 :   virtual bool End() = 0;
         899                 :
         900                 :   // Handler functions for Linux C++ exception handling data. These are
         901                 :   // only called if the data includes 'z' augmentation strings.
         902                 :
         903                 :   // The Linux C++ ABI uses an extension of the DWARF CFI format to
         904                 :   // walk the stack to propagate exceptions from the throw to the
         905                 :   // appropriate catch, and do the appropriate cleanups along the way.
         906                 :   // CFI entries used for exception handling have two additional data
         907                 :   // associated with them:
         908                 :   //
         909                 :   // - The "language-specific data area" describes which exception
         910                 :   //   types the function has 'catch' clauses for, and indicates how
         911                 :   //   to go about re-entering the function at the appropriate catch
         912                 :   //   clause. If the exception is not caught, it describes the
         913                 :   //   destructors that must run before the frame is popped.
         914                 :   //
         915                 :   // - The "personality routine" is responsible for interpreting the
         916                 :   //   language-specific data area's contents, and deciding whether
         917                 :   //   the exception should continue to propagate down the stack,
         918                 :   //   perhaps after doing some cleanup for this frame, or whether the
         919                 :   //   exception will be caught here.
         920                 :   //
         921                 :   // In principle, the language-specific data area is opaque to
         922                 :   // everybody but the personality routine. In practice, these values
         923                 :   // may be useful or interesting to readers with extra context, and
         924                 :   // we have to at least skip them anyway, so we might as well report
         925                 :   // them to the handler.
         926                 :
         927                 :   // This entry's exception handling personality routine's address is
         928                 :   // ADDRESS. If INDIRECT is true, then ADDRESS is the address at
         929                 :   // which the routine's address is stored. The default definition for
         930                 :   // this handler function simply returns true, allowing parsing of
         931                 :   // the entry to continue.
         932           40016 :   virtual bool PersonalityRoutine(uint64 address, bool indirect) {
         933           40016 :     return true;
         934                 :   }
         935                 :
         936                 :   // This entry's language-specific data area (LSDA) is located at
         937                 :   // ADDRESS. If INDIRECT is true, then ADDRESS is the address at
         938                 :   // which the area's address is stored. The default definition for
         939                 :   // this handler function simply returns true, allowing parsing of
         940                 :   // the entry to continue.
         941           40016 :   virtual bool LanguageSpecificDataArea(uint64 address, bool indirect) {
         942           40016 :     return true;
         943                 :   }
         944                 :
         945                 :   // This entry describes a signal trampoline --- this frame is the
         946                 :   // caller of a signal handler. The default definition for this
         947                 :   // handler function simply returns true, allowing parsing of the
         948                 :   // entry to continue.
         949                 :   //
         950                 :   // The best description of the rationale for and meaning of signal
         951                 :   // trampoline CFI entries seems to be in the GCC bug database:
         952                 :   // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=26208
         953               0 :   virtual bool SignalHandler() { return true; }
         954                 : };
         955                 :
         956                 : // The CallFrameInfo class makes calls on an instance of this class to
         957                 : // report errors or warn about problems in the data it is parsing. The
         958                 : // default definitions of these methods print a message to stderr, but
         959                 : // you can make a derived class that overrides them.
         960                 : class CallFrameInfo::Reporter {
         961                 :  public:
         962                 :   // Create an error reporter which attributes troubles to the section
         963                 :   // named SECTION in FILENAME.
         964                 :   //
         965                 :   // Normally SECTION would be .debug_frame, but the Mac puts CFI data
         966                 :   // in a Mach-O section named __debug_frame. If we support
         967                 :   // Linux-style exception handling data, we could be reading an
         968                 :   // .eh_frame section.
         969             248 :   Reporter(const string &filename,
         970                 :            const string &section = ".debug_frame")
         971             248 :       : filename_(filename), section_(section) { }
         972             248 :   virtual ~Reporter() { }
         973                 :
         974                 :   // The CFI entry at OFFSET ends too early to be well-formed. KIND
         975                 :   // indicates what kind of entry it is; KIND can be kUnknown if we
         976                 :   // haven't parsed enough of the entry to tell yet.
         977                 :   virtual void Incomplete(uint64 offset, CallFrameInfo::EntryKind kind);
         978                 :
         979                 :   // The .eh_frame data has a four-byte zero at OFFSET where the next
         980                 :   // entry's length would be; this is a terminator. However, the buffer
         981                 :   // length as given to the CallFrameInfo constructor says there should be
         982                 :   // more data.
         983                 :   virtual void EarlyEHTerminator(uint64 offset);
         984                 :
         985                 :   // The FDE at OFFSET refers to the CIE at CIE_OFFSET, but the
         986                 :   // section is not that large.
         987                 :   virtual void CIEPointerOutOfRange(uint64 offset, uint64 cie_offset);
         988                 :
         989                 :   // The FDE at OFFSET refers to the CIE at CIE_OFFSET, but the entry
         990                 :   // there is not a CIE.
         991                 :   virtual void BadCIEId(uint64 offset, uint64 cie_offset);
         992                 :
         993                 :   // The FDE at OFFSET refers to a CIE with version number VERSION,
         994                 :   // which we don't recognize. We cannot parse DWARF CFI if it uses
         995                 :   // a version number we don't recognize.
         996                 :   virtual void UnrecognizedVersion(uint64 offset, int version);
         997                 :
         998                 :   // The FDE at OFFSET refers to a CIE with augmentation AUGMENTATION,
         999                 :   // which we don't recognize. We cannot parse DWARF CFI if it uses
        1000                 :   // augmentations we don't recognize.
        1001                 :   virtual void UnrecognizedAugmentation(uint64 offset,
        1002                 :                                         const string &augmentation);
        1003                 :
        1004                 :   // The pointer encoding ENCODING, specified by the CIE at OFFSET, is not
        1005                 :   // a valid encoding.
        1006                 :   virtual void InvalidPointerEncoding(uint64 offset, uint8 encoding);
        1007                 :
        1008                 :   // The pointer encoding ENCODING, specified by the CIE at OFFSET, depends
        1009                 :   // on a base address which has not been supplied.
        1010                 :   virtual void UnusablePointerEncoding(uint64 offset, uint8 encoding);
        1011                 :
        1012                 :   // The CIE at OFFSET contains a DW_CFA_restore instruction at
        1013                 :   // INSN_OFFSET, which may not appear in a CIE.
        1014                 :   virtual void RestoreInCIE(uint64 offset, uint64 insn_offset);
        1015                 :
        1016                 :   // The entry at OFFSET, of kind KIND, has an unrecognized
        1017                 :   // instruction at INSN_OFFSET.
        1018                 :   virtual void BadInstruction(uint64 offset, CallFrameInfo::EntryKind kind,
        1019                 :                               uint64 insn_offset);
        1020                 :
        1021                 :   // The instruction at INSN_OFFSET in the entry at OFFSET, of kind
        1022                 :   // KIND, establishes a rule that cites the CFA, but we have not
        1023                 :   // established a CFA rule yet.
        1024                 :   virtual void NoCFARule(uint64 offset, CallFrameInfo::EntryKind kind,
        1025                 :                          uint64 insn_offset);
        1026                 :
        1027                 :   // The instruction at INSN_OFFSET in the entry at OFFSET, of kind
        1028                 :   // KIND, is a DW_CFA_restore_state instruction, but the stack of
        1029                 :   // saved states is empty.
        1030                 :   virtual void EmptyStateStack(uint64 offset, CallFrameInfo::EntryKind kind,
        1031                 :                                uint64 insn_offset);
        1032                 :
        1033                 :   // The DW_CFA_remember_state instruction at INSN_OFFSET in the entry
        1034                 :   // at OFFSET, of kind KIND, would restore a state that has no CFA
        1035                 :   // rule, whereas the current state does have a CFA rule. This is
        1036                 :   // bogus input, which the CallFrameInfo::Handler interface doesn't
        1037                 :   // (and shouldn't) have any way to report.
        1038                 :   virtual void ClearingCFARule(uint64 offset, CallFrameInfo::EntryKind kind,
        1039                 :                                uint64 insn_offset);
        1040                 :
        1041                 :  protected:
        1042                 :   // The name of the file whose CFI we're reading.
        1043                 :   string filename_;
        1044                 :
        1045                 :   // The name of the CFI section in that file.
        1046                 :   string section_;
        1047                 : };
        1048                 :
        1049                 : }  // namespace dwarf2reader
        1050                 :
        1051                 : #endif  // UTIL_DEBUGINFO_DWARF2READER_H__

Generated by: LCOV version 1.7