Line data    Source code

       1             : //===- DWARFDebugLoc.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 LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H
      11             : #define LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H
      12             : 
      13             : #include "llvm/ADT/Optional.h"
      14             : #include "llvm/ADT/SmallVector.h"
      15             : #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
      16             : #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
      17             : #include <cstdint>
      18             : 
      19             : namespace llvm {
      20             : class DWARFUnit;
      21             : class MCRegisterInfo;
      22             : class raw_ostream;
      23             : 
      24         223 : class DWARFDebugLoc {
      25             : public:
      26             :   /// A single location within a location list.
      27        1924 :   struct Entry {
      28             :     /// The beginning address of the instruction range.
      29             :     uint64_t Begin;
      30             :     /// The ending address of the instruction range.
      31             :     uint64_t End;
      32             :     /// The location of the variable within the specified range.
      33             :     SmallVector<char, 4> Loc;
      34             :   };
      35             : 
      36             :   /// A list of locations that contain one variable.
      37        1037 :   struct LocationList {
      38             :     /// The beginning offset where this location list is stored in the debug_loc
      39             :     /// section.
      40             :     unsigned Offset;
      41             :     /// All the locations in which the variable is stored.
      42             :     SmallVector<Entry, 2> Entries;
      43             :     /// Dump this list on OS.
      44             :     void dump(raw_ostream &OS, bool IsLittleEndian, unsigned AddressSize,
      45             :               const MCRegisterInfo *MRI, uint64_t BaseAddress,
      46             :               unsigned Indent) const;
      47             :   };
      48             : 
      49             : private:
      50             :   using LocationLists = SmallVector<LocationList, 4>;
      51             : 
      52             :   /// A list of all the variables in the debug_loc section, each one describing
      53             :   /// the locations in which the variable is stored.
      54             :   LocationLists Locations;
      55             : 
      56             :   unsigned AddressSize;
      57             : 
      58             :   bool IsLittleEndian;
      59             : 
      60             : public:
      61             :   /// Print the location lists found within the debug_loc section.
      62             :   void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo,
      63             :             Optional<uint64_t> Offset) const;
      64             : 
      65             :   /// Parse the debug_loc section accessible via the 'data' parameter using the
      66             :   /// address size also given in 'data' to interpret the address ranges.
      67             :   void parse(const DWARFDataExtractor &data);
      68             : 
      69             :   /// Return the location list at the given offset or nullptr.
      70             :   LocationList const *getLocationListAtOffset(uint64_t Offset) const;
      71             : 
      72             :   Optional<LocationList> parseOneLocationList(DWARFDataExtractor Data,
      73             :                                               uint32_t *Offset);
      74             : };
      75             : 
      76           3 : class DWARFDebugLocDWO {
      77             : public:
      78          76 :   struct Entry {
      79             :     uint64_t Start;
      80             :     uint32_t Length;
      81             :     SmallVector<char, 4> Loc;
      82             :   };
      83             : 
      84          45 :   struct LocationList {
      85             :     unsigned Offset;
      86             :     SmallVector<Entry, 2> Entries;
      87             :     void dump(raw_ostream &OS, bool IsLittleEndian, unsigned AddressSize,
      88             :               const MCRegisterInfo *RegInfo, unsigned Indent) const;
      89             :   };
      90             : 
      91             : private:
      92             :   using LocationLists = SmallVector<LocationList, 4>;
      93             : 
      94             :   LocationLists Locations;
      95             : 
      96             :   unsigned AddressSize;
      97             : 
      98             :   bool IsLittleEndian;
      99             : 
     100             : public:
     101             :   void parse(DataExtractor data);
     102             :   void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo,
     103             :             Optional<uint64_t> Offset) const;
     104             : 
     105             :   /// Return the location list at the given offset or nullptr.
     106             :   LocationList const *getLocationListAtOffset(uint64_t Offset) const;
     107             : 
     108             :   static Optional<LocationList> parseOneLocationList(DataExtractor Data,
     109             :                                                      uint32_t *Offset);
     110             : };
     111             : 
     112             : } // end namespace llvm
     113             : 
     114             : #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H