LCOV - code coverage report
Current view: top level - include/llvm/DebugInfo/DWARF - DWARFContext.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 25 25 100.0 %
Date: 2018-07-13 00:08:38 Functions: 6 6 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- DWARFContext.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_DWARFCONTEXT_H
      11             : #define LLVM_DEBUGINFO_DWARF_DWARFCONTEXT_H
      12             : 
      13             : #include "llvm/ADT/MapVector.h"
      14             : #include "llvm/ADT/SmallString.h"
      15             : #include "llvm/ADT/SmallVector.h"
      16             : #include "llvm/ADT/StringMap.h"
      17             : #include "llvm/ADT/StringRef.h"
      18             : #include "llvm/ADT/iterator_range.h"
      19             : #include "llvm/DebugInfo/DIContext.h"
      20             : #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
      21             : #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
      22             : #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
      23             : #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
      24             : #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
      25             : #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
      26             : #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
      27             : #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
      28             : #include "llvm/DebugInfo/DWARF/DWARFDie.h"
      29             : #include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
      30             : #include "llvm/DebugInfo/DWARF/DWARFObject.h"
      31             : #include "llvm/DebugInfo/DWARF/DWARFSection.h"
      32             : #include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h"
      33             : #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
      34             : #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
      35             : #include "llvm/Object/Binary.h"
      36             : #include "llvm/Object/ObjectFile.h"
      37             : #include "llvm/Support/DataExtractor.h"
      38             : #include "llvm/Support/Error.h"
      39             : #include "llvm/Support/Host.h"
      40             : #include <cstdint>
      41             : #include <deque>
      42             : #include <map>
      43             : #include <memory>
      44             : 
      45             : namespace llvm {
      46             : 
      47             : class MCRegisterInfo;
      48             : class MemoryBuffer;
      49             : class raw_ostream;
      50             : 
      51             : /// Used as a return value for a error callback passed to DWARF context.
      52             : /// Callback should return Halt if client application wants to stop
      53             : /// object parsing, or should return Continue otherwise.
      54             : enum class ErrorPolicy { Halt, Continue };
      55             : 
      56             : /// DWARFContext
      57             : /// This data structure is the top level entity that deals with dwarf debug
      58             : /// information parsing. The actual data is supplied through DWARFObj.
      59       10075 : class DWARFContext : public DIContext {
      60             :   DWARFUnitSection<DWARFCompileUnit> CUs;
      61             :   std::deque<DWARFUnitSection<DWARFTypeUnit>> TUs;
      62             :   std::unique_ptr<DWARFUnitIndex> CUIndex;
      63             :   std::unique_ptr<DWARFGdbIndex> GdbIndex;
      64             :   std::unique_ptr<DWARFUnitIndex> TUIndex;
      65             :   std::unique_ptr<DWARFDebugAbbrev> Abbrev;
      66             :   std::unique_ptr<DWARFDebugLoc> Loc;
      67             :   std::unique_ptr<DWARFDebugAranges> Aranges;
      68             :   std::unique_ptr<DWARFDebugLine> Line;
      69             :   std::unique_ptr<DWARFDebugFrame> DebugFrame;
      70             :   std::unique_ptr<DWARFDebugFrame> EHFrame;
      71             :   std::unique_ptr<DWARFDebugMacro> Macro;
      72             :   std::unique_ptr<DWARFDebugNames> Names;
      73             :   std::unique_ptr<AppleAcceleratorTable> AppleNames;
      74             :   std::unique_ptr<AppleAcceleratorTable> AppleTypes;
      75             :   std::unique_ptr<AppleAcceleratorTable> AppleNamespaces;
      76             :   std::unique_ptr<AppleAcceleratorTable> AppleObjC;
      77             : 
      78             :   DWARFUnitSection<DWARFCompileUnit> DWOCUs;
      79             :   std::deque<DWARFUnitSection<DWARFTypeUnit>> DWOTUs;
      80             :   std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO;
      81             :   std::unique_ptr<DWARFDebugLocDWO> LocDWO;
      82             : 
      83             :   /// The maximum DWARF version of all units.
      84             :   unsigned MaxVersion = 0;
      85             : 
      86          38 :   struct DWOFile {
      87             :     object::OwningBinary<object::ObjectFile> File;
      88             :     std::unique_ptr<DWARFContext> Context;
      89             :   };
      90             :   StringMap<std::weak_ptr<DWOFile>> DWOFiles;
      91             :   std::weak_ptr<DWOFile> DWP;
      92             :   bool CheckedForDWP = false;
      93             :   std::string DWPName;
      94             : 
      95             :   std::unique_ptr<MCRegisterInfo> RegInfo;
      96             : 
      97             :   /// Read compile units from the debug_info section (if necessary)
      98             :   /// and store them in CUs.
      99             :   void parseCompileUnits();
     100             : 
     101             :   /// Read type units from the debug_types sections (if necessary)
     102             :   /// and store them in TUs.
     103             :   void parseTypeUnits();
     104             : 
     105             :   /// Read compile units from the debug_info.dwo section (if necessary)
     106             :   /// and store them in DWOCUs.
     107             :   void parseDWOCompileUnits();
     108             : 
     109             :   /// Read type units from the debug_types.dwo section (if necessary)
     110             :   /// and store them in DWOTUs.
     111             :   void parseDWOTypeUnits();
     112             : 
     113             : protected:
     114             :   std::unique_ptr<const DWARFObject> DObj;
     115             : 
     116             : public:
     117             :   DWARFContext(std::unique_ptr<const DWARFObject> DObj,
     118             :                std::string DWPName = "");
     119             :   ~DWARFContext();
     120             : 
     121             :   DWARFContext(DWARFContext &) = delete;
     122             :   DWARFContext &operator=(DWARFContext &) = delete;
     123             : 
     124             :   const DWARFObject &getDWARFObj() const { return *DObj; }
     125             : 
     126             :   static bool classof(const DIContext *DICtx) {
     127         950 :     return DICtx->getKind() == CK_DWARF;
     128             :   }
     129             : 
     130             :   /// Dump a textual representation to \p OS. If any \p DumpOffsets are present,
     131             :   /// dump only the record at the specified offset.
     132             :   void dump(raw_ostream &OS, DIDumpOptions DumpOpts,
     133             :             std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets);
     134             : 
     135          10 :   void dump(raw_ostream &OS, DIDumpOptions DumpOpts) override {
     136             :     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets;
     137          10 :     dump(OS, DumpOpts, DumpOffsets);
     138          10 :   }
     139             : 
     140             :   bool verify(raw_ostream &OS, DIDumpOptions DumpOpts = {}) override;
     141             : 
     142             :   using cu_iterator_range = DWARFUnitSection<DWARFCompileUnit>::iterator_range;
     143             :   using tu_iterator_range = DWARFUnitSection<DWARFTypeUnit>::iterator_range;
     144             :   using tu_section_iterator_range = iterator_range<decltype(TUs)::iterator>;
     145             : 
     146             :   /// Get compile units in this context.
     147             :   cu_iterator_range compile_units() {
     148        1667 :     parseCompileUnits();
     149             :     return cu_iterator_range(CUs.begin(), CUs.end());
     150             :   }
     151             : 
     152             :   /// Get type units in this context.
     153             :   tu_section_iterator_range type_unit_sections() {
     154         245 :     parseTypeUnits();
     155             :     return tu_section_iterator_range(TUs.begin(), TUs.end());
     156             :   }
     157             : 
     158             :   /// Get compile units in the DWO context.
     159             :   cu_iterator_range dwo_compile_units() {
     160         728 :     parseDWOCompileUnits();
     161             :     return cu_iterator_range(DWOCUs.begin(), DWOCUs.end());
     162             :   }
     163             : 
     164             :   /// Get type units in the DWO context.
     165             :   tu_section_iterator_range dwo_type_unit_sections() {
     166          53 :     parseDWOTypeUnits();
     167             :     return tu_section_iterator_range(DWOTUs.begin(), DWOTUs.end());
     168             :   }
     169             : 
     170             :   /// Get the number of compile units in this context.
     171             :   unsigned getNumCompileUnits() {
     172         269 :     parseCompileUnits();
     173         106 :     return CUs.size();
     174             :   }
     175             : 
     176             :   /// Get the number of compile units in this context.
     177         192 :   unsigned getNumTypeUnits() {
     178         192 :     parseTypeUnits();
     179         192 :     return TUs.size();
     180             :   }
     181             : 
     182             :   /// Get the number of compile units in the DWO context.
     183             :   unsigned getNumDWOCompileUnits() {
     184             :     parseDWOCompileUnits();
     185             :     return DWOCUs.size();
     186             :   }
     187             : 
     188             :   /// Get the number of compile units in the DWO context.
     189         198 :   unsigned getNumDWOTypeUnits() {
     190         198 :     parseDWOTypeUnits();
     191         198 :     return DWOTUs.size();
     192             :   }
     193             : 
     194             :   /// Get the compile unit at the specified index for this compile unit.
     195             :   DWARFCompileUnit *getCompileUnitAtIndex(unsigned index) {
     196          96 :     parseCompileUnits();
     197             :     return CUs[index].get();
     198             :   }
     199             : 
     200             :   /// Get the compile unit at the specified index for the DWO compile units.
     201             :   DWARFCompileUnit *getDWOCompileUnitAtIndex(unsigned index) {
     202             :     parseDWOCompileUnits();
     203             :     return DWOCUs[index].get();
     204             :   }
     205             : 
     206             :   DWARFCompileUnit *getDWOCompileUnitForHash(uint64_t Hash);
     207             : 
     208             :   /// Return the compile unit that includes an offset (relative to .debug_info).
     209             :   DWARFCompileUnit *getCompileUnitForOffset(uint32_t Offset);
     210             : 
     211             :   /// Get a DIE given an exact offset.
     212             :   DWARFDie getDIEForOffset(uint32_t Offset);
     213             : 
     214             :   unsigned getMaxVersion() const { return MaxVersion; }
     215             : 
     216             :   void setMaxVersionIfGreater(unsigned Version) {
     217        5125 :     if (Version > MaxVersion)
     218        1095 :       MaxVersion = Version;
     219             :   }
     220             : 
     221             :   const DWARFUnitIndex &getCUIndex();
     222             :   DWARFGdbIndex &getGdbIndex();
     223             :   const DWARFUnitIndex &getTUIndex();
     224             : 
     225             :   /// Get a pointer to the parsed DebugAbbrev object.
     226             :   const DWARFDebugAbbrev *getDebugAbbrev();
     227             : 
     228             :   /// Get a pointer to the parsed DebugLoc object.
     229             :   const DWARFDebugLoc *getDebugLoc();
     230             : 
     231             :   /// Get a pointer to the parsed dwo abbreviations object.
     232             :   const DWARFDebugAbbrev *getDebugAbbrevDWO();
     233             : 
     234             :   /// Get a pointer to the parsed DebugLoc object.
     235             :   const DWARFDebugLocDWO *getDebugLocDWO();
     236             : 
     237             :   /// Get a pointer to the parsed DebugAranges object.
     238             :   const DWARFDebugAranges *getDebugAranges();
     239             : 
     240             :   /// Get a pointer to the parsed frame information object.
     241             :   const DWARFDebugFrame *getDebugFrame();
     242             : 
     243             :   /// Get a pointer to the parsed eh frame information object.
     244             :   const DWARFDebugFrame *getEHFrame();
     245             : 
     246             :   /// Get a pointer to the parsed DebugMacro object.
     247             :   const DWARFDebugMacro *getDebugMacro();
     248             : 
     249             :   /// Get a reference to the parsed accelerator table object.
     250             :   const DWARFDebugNames &getDebugNames();
     251             : 
     252             :   /// Get a reference to the parsed accelerator table object.
     253             :   const AppleAcceleratorTable &getAppleNames();
     254             : 
     255             :   /// Get a reference to the parsed accelerator table object.
     256             :   const AppleAcceleratorTable &getAppleTypes();
     257             : 
     258             :   /// Get a reference to the parsed accelerator table object.
     259             :   const AppleAcceleratorTable &getAppleNamespaces();
     260             : 
     261             :   /// Get a reference to the parsed accelerator table object.
     262             :   const AppleAcceleratorTable &getAppleObjC();
     263             : 
     264             :   /// Get a pointer to a parsed line table corresponding to a compile unit.
     265             :   /// Report any parsing issues as warnings on stderr.
     266             :   const DWARFDebugLine::LineTable *getLineTableForUnit(DWARFUnit *U);
     267             : 
     268             :   /// Get a pointer to a parsed line table corresponding to a compile unit.
     269             :   /// Report any recoverable parsing problems using the callback.
     270             :   Expected<const DWARFDebugLine::LineTable *>
     271             :   getLineTableForUnit(DWARFUnit *U,
     272             :                       std::function<void(Error)> RecoverableErrorCallback);
     273             : 
     274             :   DataExtractor getStringExtractor() const {
     275           2 :     return DataExtractor(DObj->getStringSection(), false, 0);
     276             :   }
     277             :   DataExtractor getLineStringExtractor() const {
     278         164 :     return DataExtractor(DObj->getLineStringSection(), false, 0);
     279             :   }
     280             : 
     281             :   /// Wraps the returned DIEs for a given address.
     282             :   struct DIEsForAddress {
     283             :     DWARFCompileUnit *CompileUnit = nullptr;
     284             :     DWARFDie FunctionDIE;
     285             :     DWARFDie BlockDIE;
     286             :     explicit operator bool() const { return CompileUnit != nullptr; }
     287             :   };
     288             : 
     289             :   /// Get the compilation unit, the function DIE and lexical block DIE for the
     290             :   /// given address where applicable.
     291             :   DIEsForAddress getDIEsForAddress(uint64_t Address);
     292             : 
     293             :   DILineInfo getLineInfoForAddress(uint64_t Address,
     294             :       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
     295             :   DILineInfoTable getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
     296             :       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
     297             :   DIInliningInfo getInliningInfoForAddress(uint64_t Address,
     298             :       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
     299             : 
     300        9403 :   bool isLittleEndian() const { return DObj->isLittleEndian(); }
     301             :   static bool isSupportedVersion(unsigned version) {
     302        5233 :     return version == 2 || version == 3 || version == 4 || version == 5;
     303             :   }
     304             : 
     305             :   std::shared_ptr<DWARFContext> getDWOContext(StringRef AbsolutePath);
     306             : 
     307             :   const MCRegisterInfo *getRegisterInfo() const { return RegInfo.get(); }
     308             : 
     309             :   /// Function used to handle default error reporting policy. Prints a error
     310             :   /// message and returns Continue, so DWARF context ignores the error.
     311             :   static ErrorPolicy defaultErrorHandler(Error E);
     312             :   static std::unique_ptr<DWARFContext>
     313             :   create(const object::ObjectFile &Obj, const LoadedObjectInfo *L = nullptr,
     314             :          function_ref<ErrorPolicy(Error)> HandleError = defaultErrorHandler,
     315             :          std::string DWPName = "");
     316             : 
     317             :   static std::unique_ptr<DWARFContext>
     318             :   create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
     319             :          uint8_t AddrSize, bool isLittleEndian = sys::IsLittleEndianHost);
     320             : 
     321             :   /// Loads register info for the architecture of the provided object file.
     322             :   /// Improves readability of dumped DWARF expressions. Requires the caller to
     323             :   /// have initialized the relevant target descriptions.
     324             :   Error loadRegisterInfo(const object::ObjectFile &Obj);
     325             : 
     326             : private:
     327             :   /// Return the compile unit which contains instruction with provided
     328             :   /// address.
     329             :   DWARFCompileUnit *getCompileUnitForAddress(uint64_t Address);
     330             : };
     331             : 
     332             : } // end namespace llvm
     333             : 
     334             : #endif // LLVM_DEBUGINFO_DWARF_DWARFCONTEXT_H

Generated by: LCOV version 1.13