contrib/llvm/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugLine.h

   1 //===-- DWARFDebugLine.h ----------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef SymbolFileDWARF_DWARFDebugLine_h_
  11 #define SymbolFileDWARF_DWARFDebugLine_h_
  12
  13 #include <map>
  14 #include <vector>
  15 #include <string>
  16
  17 #include "lldb/lldb-private.h"
  18
  19 #include "DWARFDefines.h"
  20
  21 class SymbolFileDWARF;
  22 class DWARFDebugInfoEntry;
  23
  24 //----------------------------------------------------------------------
  25 // DWARFDebugLine
  26 //----------------------------------------------------------------------
  27 class DWARFDebugLine
  28 {
  29 public:
  30     //------------------------------------------------------------------
  31     // FileNameEntry
  32     //------------------------------------------------------------------
  33     struct FileNameEntry
  34     {
  35         FileNameEntry() :
  36             name(),
  37             dir_idx(0),
  38             mod_time(0),
  39             length(0)
  40         {
  41         }
  42
  43         std::string     name;
  44         dw_sleb128_t    dir_idx;
  45         dw_sleb128_t    mod_time;
  46         dw_sleb128_t    length;
  47
  48     };
  49
  50     //------------------------------------------------------------------
  51     // Prologue
  52     //------------------------------------------------------------------
  53     struct Prologue
  54     {
  55
  56         Prologue() :
  57             total_length(0),
  58             version(0),
  59             prologue_length(0),
  60             min_inst_length(0),
  61             default_is_stmt(0),
  62             line_base(0),
  63             line_range(0),
  64             opcode_base(0),
  65             standard_opcode_lengths(),
  66             include_directories(),
  67             file_names()
  68         {
  69         }
  70
  71         typedef std::shared_ptr<Prologue> shared_ptr;
  72
  73         uint32_t    total_length;   // The size in bytes of the statement information for this compilation unit (not including the total_length field itself).
  74         uint16_t    version;        // Version identifier for the statement information format.
  75         uint32_t    prologue_length;// The number of bytes following the prologue_length field to the beginning of the first byte of the statement program itself.
  76         uint8_t     min_inst_length;// The size in bytes of the smallest target machine instruction. Statement program opcodes that alter the address register first multiply their operands by this value.
  77         uint8_t     default_is_stmt;// The initial value of theis_stmtregister.
  78         int8_t      line_base;      // This parameter affects the meaning of the special opcodes. See below.
  79         uint8_t     line_range;     // This parameter affects the meaning of the special opcodes. See below.
  80         uint8_t     opcode_base;    // The number assigned to the first special opcode.
  81         std::vector<uint8_t>            standard_opcode_lengths;
  82         std::vector<std::string>        include_directories;
  83         std::vector<FileNameEntry>      file_names;
  84
  85         // Length of the prologue in bytes
  86         uint32_t Length() const { return prologue_length + sizeof(total_length) + sizeof(version) + sizeof(prologue_length); }
  87         // Length of the line table data in bytes (not including the prologue)
  88         uint32_t StatementTableLength() const { return total_length + sizeof(total_length) - Length(); }
  89         int32_t MaxLineIncrementForSpecialOpcode() const { return line_base + (int8_t)line_range - 1; }
  90         bool IsValid() const;
  91 //      void Append(BinaryStreamBuf& buff) const;
  92         void Dump (lldb_private::Log *log);
  93         void Clear()
  94         {
  95             total_length = version = prologue_length = min_inst_length = line_base = line_range = opcode_base = 0;
  96             line_base = 0;
  97             standard_opcode_lengths.clear();
  98             include_directories.clear();
  99             file_names.clear();
 100         }
 101         bool GetFile(uint32_t file_idx, std::string& file, std::string& dir) const;
 102
 103     };
 104
 105     // Standard .debug_line state machine structure
 106     struct Row
 107     {
 108         typedef std::vector<Row>            collection;
 109         typedef collection::iterator        iterator;
 110         typedef collection::const_iterator  const_iterator;
 111
 112         Row(bool default_is_stmt = false);
 113         virtual ~Row() {}
 114         void PostAppend ();
 115         void Reset(bool default_is_stmt);
 116         void Dump(lldb_private::Log *log) const;
 117         static void Insert(Row::collection& state_coll, const Row& state);
 118         static void Dump(lldb_private::Log *log, const Row::collection& state_coll);
 119
 120         dw_addr_t   address;        // The program-counter value corresponding to a machine instruction generated by the compiler.
 121         uint32_t    line;           // An unsigned integer indicating a source line number. Lines are numbered beginning at 1. The compiler may emit the value 0 in cases where an instruction cannot be attributed to any source line.
 122         uint16_t    column;         // An unsigned integer indicating a column number within a source line. Columns are numbered beginning at 1. The value 0 is reserved to indicate that a statement begins at the 'left edge' of the line.
 123         uint16_t    file;           // An unsigned integer indicating the identity of the source file corresponding to a machine instruction.
 124         uint8_t     is_stmt:1,      // A boolean indicating that the current instruction is the beginning of a statement.
 125                     basic_block:1,  // A boolean indicating that the current instruction is the beginning of a basic block.
 126                     end_sequence:1, // A boolean indicating that the current address is that of the first byte after the end of a sequence of target machine instructions.
 127                     prologue_end:1, // A boolean indicating that the current address is one (of possibly many) where execution should be suspended for an entry breakpoint of a function.
 128                     epilogue_begin:1;// A boolean indicating that the current address is one (of possibly many) where execution should be suspended for an exit breakpoint of a function.
 129         uint32_t    isa;            // An unsigned integer whose value encodes the applicable instruction set architecture for the current instruction.
 130     };
 131
 132
 133     //------------------------------------------------------------------
 134     // LineTable
 135     //------------------------------------------------------------------
 136     struct LineTable
 137     {
 138         typedef std::shared_ptr<LineTable> shared_ptr;
 139
 140         LineTable() :
 141             prologue(),
 142             rows()
 143         {
 144         }
 145
 146         void AppendRow(const DWARFDebugLine::Row& state);
 147         void Clear()
 148         {
 149             prologue.reset();
 150             rows.clear();
 151         }
 152
 153         uint32_t LookupAddress(dw_addr_t address, dw_addr_t cu_high_pc) const;
 154         void Dump(lldb_private::Log *log) const;
 155
 156         Prologue::shared_ptr prologue;
 157         Row::collection rows;
 158     };
 159
 160     //------------------------------------------------------------------
 161     // State
 162     //------------------------------------------------------------------
 163     struct State : public Row
 164     {
 165         typedef void (*Callback)(dw_offset_t offset, const State& state, void* userData);
 166
 167         // Special row codes used when calling the callback
 168         enum
 169         {
 170             StartParsingLineTable = 0,
 171             DoneParsingLineTable = -1
 172         };
 173
 174         State (Prologue::shared_ptr& prologue_sp,
 175                lldb_private::Log *log,
 176                Callback callback,
 177                void* userData);
 178
 179         void
 180         AppendRowToMatrix (dw_offset_t offset);
 181
 182         void
 183         Finalize (dw_offset_t offset);
 184
 185         void
 186         Reset ();
 187
 188         Prologue::shared_ptr prologue;
 189         lldb_private::Log *log;
 190         Callback callback; // Callback function that gets called each time an entry is to be added to the matrix
 191         void* callbackUserData;
 192         int row; // The row number that starts at zero for the prologue, and increases for each row added to the matrix
 193     private:
 194         DISALLOW_COPY_AND_ASSIGN (State);
 195     };
 196
 197     static bool DumpOpcodes(lldb_private::Log *log, SymbolFileDWARF* dwarf2Data, dw_offset_t line_offset = DW_INVALID_OFFSET, uint32_t dump_flags = 0);   // If line_offset is invalid, dump everything
 198     static bool DumpLineTableRows(lldb_private::Log *log, SymbolFileDWARF* dwarf2Data, dw_offset_t line_offset = DW_INVALID_OFFSET);  // If line_offset is invalid, dump everything
 199     static bool ParseSupportFiles(const lldb::ModuleSP &module_sp, const lldb_private::DataExtractor& debug_line_data, const char *cu_comp_dir, dw_offset_t stmt_list, lldb_private::FileSpecList &support_files);
 200     static bool ParsePrologue(const lldb_private::DataExtractor& debug_line_data, lldb::offset_t* offset_ptr, Prologue* prologue);
 201     static bool ParseStatementTable(const lldb_private::DataExtractor& debug_line_data, lldb::offset_t* offset_ptr, State::Callback callback, void* userData);
 202     static dw_offset_t DumpStatementTable(lldb_private::Log *log, const lldb_private::DataExtractor& debug_line_data, const dw_offset_t line_offset);
 203     static dw_offset_t DumpStatementOpcodes(lldb_private::Log *log, const lldb_private::DataExtractor& debug_line_data, const dw_offset_t line_offset, uint32_t flags);
 204     static bool ParseStatementTable(const lldb_private::DataExtractor& debug_line_data, lldb::offset_t *offset_ptr, LineTable* line_table);
 205     static void Parse(const lldb_private::DataExtractor& debug_line_data, DWARFDebugLine::State::Callback callback, void* userData);
 206 //  static void AppendLineTableData(const DWARFDebugLine::Prologue* prologue, const DWARFDebugLine::Row::collection& state_coll, const uint32_t addr_size, BinaryStreamBuf &debug_line_data);
 207
 208     DWARFDebugLine() :
 209         m_lineTableMap()
 210     {
 211     }
 212
 213     void Parse(const lldb_private::DataExtractor& debug_line_data);
 214     void ParseIfNeeded(const lldb_private::DataExtractor& debug_line_data);
 215     LineTable::shared_ptr GetLineTable(const dw_offset_t offset) const;
 216
 217 protected:
 218     typedef std::map<dw_offset_t, LineTable::shared_ptr> LineTableMap;
 219     typedef LineTableMap::iterator LineTableIter;
 220     typedef LineTableMap::const_iterator LineTableConstIter;
 221
 222     LineTableMap m_lineTableMap;
 223 };
 224
 225 #endif  // SymbolFileDWARF_DWARFDebugLine_h_