LCOV - code coverage report
Current view: top level - lib/CodeGen/AsmPrinter - DebugLocStream.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 44 44 100.0 %
Date: 2017-09-14 15:23:50 Functions: 8 8 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===--- lib/CodeGen/DebugLocStream.h - DWARF debug_loc stream --*- 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_LIB_CODEGEN_ASMPRINTER_DEBUGLOCSTREAM_H
      11             : #define LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGLOCSTREAM_H
      12             : 
      13             : #include "ByteStreamer.h"
      14             : #include "llvm/ADT/ArrayRef.h"
      15             : #include "llvm/ADT/SmallVector.h"
      16             : 
      17             : namespace llvm {
      18             : 
      19             : class AsmPrinter;
      20             : class DbgVariable;
      21             : class DwarfCompileUnit;
      22             : class MachineInstr;
      23             : class MCSymbol;
      24             : 
      25             : /// \brief Byte stream of .debug_loc entries.
      26             : ///
      27             : /// Stores a unified stream of .debug_loc entries.  There's \a List for each
      28             : /// variable/inlined-at pair, and an \a Entry for each \a DebugLocEntry.
      29             : ///
      30             : /// FIXME: Do we need all these temp symbols?
      31             : /// FIXME: Why not output directly to the output stream?
      32       81890 : class DebugLocStream {
      33             : public:
      34             :   struct List {
      35             :     DwarfCompileUnit *CU;
      36             :     MCSymbol *Label = nullptr;
      37             :     size_t EntryOffset;
      38             :     List(DwarfCompileUnit *CU, size_t EntryOffset)
      39        8790 :         : CU(CU), EntryOffset(EntryOffset) {}
      40             :   };
      41             :   struct Entry {
      42             :     const MCSymbol *BeginSym;
      43             :     const MCSymbol *EndSym;
      44             :     size_t ByteOffset;
      45             :     size_t CommentOffset;
      46             :     Entry(const MCSymbol *BeginSym, const MCSymbol *EndSym, size_t ByteOffset,
      47             :           size_t CommentOffset)
      48       12721 :         : BeginSym(BeginSym), EndSym(EndSym), ByteOffset(ByteOffset),
      49       12721 :           CommentOffset(CommentOffset) {}
      50             :   };
      51             : 
      52             : private:
      53             :   SmallVector<List, 4> Lists;
      54             :   SmallVector<Entry, 32> Entries;
      55             :   SmallString<256> DWARFBytes;
      56             :   SmallVector<std::string, 32> Comments;
      57             : 
      58             :   /// \brief Only verbose textual output needs comments.  This will be set to
      59             :   /// true for that case, and false otherwise.
      60             :   bool GenerateComments;
      61             : 
      62             : public:
      63       82370 :   DebugLocStream(bool GenerateComments) : GenerateComments(GenerateComments) { }
      64             :   size_t getNumLists() const { return Lists.size(); }
      65       17522 :   const List &getList(size_t LI) const { return Lists[LI]; }
      66        1750 :   ArrayRef<List> getLists() const { return Lists; }
      67             : 
      68             :   class ListBuilder;
      69             :   class EntryBuilder;
      70             : 
      71             : private:
      72             :   /// \brief Start a new .debug_loc entry list.
      73             :   ///
      74             :   /// Start a new .debug_loc entry list.  Return the new list's index so it can
      75             :   /// be retrieved later via \a getList().
      76             :   ///
      77             :   /// Until the next call, \a startEntry() will add entries to this list.
      78             :   size_t startList(DwarfCompileUnit *CU) {
      79       17580 :     size_t LI = Lists.size();
      80       17580 :     Lists.emplace_back(CU, Entries.size());
      81             :     return LI;
      82             :   }
      83             : 
      84             :   /// Finalize a .debug_loc entry list.
      85             :   ///
      86             :   /// If there are no entries in this list, delete it outright.  Otherwise,
      87             :   /// create a label with \a Asm.
      88             :   ///
      89             :   /// \return false iff the list is deleted.
      90             :   bool finalizeList(AsmPrinter &Asm);
      91             : 
      92             :   /// \brief Start a new .debug_loc entry.
      93             :   ///
      94             :   /// Until the next call, bytes added to the stream will be added to this
      95             :   /// entry.
      96       12721 :   void startEntry(const MCSymbol *BeginSym, const MCSymbol *EndSym) {
      97       38163 :     Entries.emplace_back(BeginSym, EndSym, DWARFBytes.size(), Comments.size());
      98       12721 :   }
      99             : 
     100             :   /// Finalize a .debug_loc entry, deleting if it's empty.
     101             :   void finalizeEntry();
     102             : 
     103             : public:
     104             :   BufferByteStreamer getStreamer() {
     105       25442 :     return BufferByteStreamer(DWARFBytes, Comments, GenerateComments);
     106             :   }
     107             : 
     108        8761 :   ArrayRef<Entry> getEntries(const List &L) const {
     109        8761 :     size_t LI = getIndex(L);
     110       17522 :     return makeArrayRef(Entries)
     111       26283 :         .slice(Lists[LI].EntryOffset, getNumEntries(LI));
     112             :   }
     113             : 
     114             :   ArrayRef<char> getBytes(const Entry &E) const {
     115       25432 :     size_t EI = getIndex(E);
     116      101728 :     return makeArrayRef(DWARFBytes.begin(), DWARFBytes.end())
     117       76296 :         .slice(Entries[EI].ByteOffset, getNumBytes(EI));
     118             :   }
     119       12717 :   ArrayRef<std::string> getComments(const Entry &E) const {
     120       12717 :     size_t EI = getIndex(E);
     121       25434 :     return makeArrayRef(Comments)
     122       38151 :         .slice(Entries[EI].CommentOffset, getNumComments(EI));
     123             :   }
     124             : 
     125             : private:
     126             :   size_t getIndex(const List &L) const {
     127             :     assert(&Lists.front() <= &L && &L <= &Lists.back() &&
     128             :            "Expected valid list");
     129       17522 :     return &L - &Lists.front();
     130             :   }
     131             :   size_t getIndex(const Entry &E) const {
     132             :     assert(&Entries.front() <= &E && &E <= &Entries.back() &&
     133             :            "Expected valid entry");
     134       76298 :     return &E - &Entries.front();
     135             :   }
     136        8761 :   size_t getNumEntries(size_t LI) const {
     137       17522 :     if (LI + 1 == Lists.size())
     138         459 :       return Entries.size() - Lists[LI].EntryOffset;
     139       25824 :     return Lists[LI + 1].EntryOffset - Lists[LI].EntryOffset;
     140             :   }
     141       25432 :   size_t getNumBytes(size_t EI) const {
     142       50864 :     if (EI + 1 == Entries.size())
     143         915 :       return DWARFBytes.size() - Entries[EI].ByteOffset;
     144       75381 :     return Entries[EI + 1].ByteOffset - Entries[EI].ByteOffset;
     145             :   }
     146       12717 :   size_t getNumComments(size_t EI) const {
     147       25434 :     if (EI + 1 == Entries.size())
     148         459 :       return Comments.size() - Entries[EI].CommentOffset;
     149       37692 :     return Entries[EI + 1].CommentOffset - Entries[EI].CommentOffset;
     150             :   }
     151             : };
     152             : 
     153             : /// Builder for DebugLocStream lists.
     154             : class DebugLocStream::ListBuilder {
     155             :   DebugLocStream &Locs;
     156             :   AsmPrinter &Asm;
     157             :   DbgVariable &V;
     158             :   const MachineInstr &MI;
     159             :   size_t ListIndex;
     160             : 
     161             : public:
     162        8790 :   ListBuilder(DebugLocStream &Locs, DwarfCompileUnit &CU, AsmPrinter &Asm,
     163             :               DbgVariable &V, const MachineInstr &MI)
     164       17580 :       : Locs(Locs), Asm(Asm), V(V), MI(MI), ListIndex(Locs.startList(&CU)) {}
     165             : 
     166             :   /// Finalize the list.
     167             :   ///
     168             :   /// If the list is empty, delete it.  Otherwise, finalize it by creating a
     169             :   /// temp symbol in \a Asm and setting up the \a DbgVariable.
     170             :   ~ListBuilder();
     171             : 
     172             :   DebugLocStream &getLocs() { return Locs; }
     173             : };
     174             : 
     175             : /// Builder for DebugLocStream entries.
     176             : class DebugLocStream::EntryBuilder {
     177             :   DebugLocStream &Locs;
     178             : 
     179             : public:
     180             :   EntryBuilder(ListBuilder &List, const MCSymbol *Begin, const MCSymbol *End)
     181       12721 :       : Locs(List.getLocs()) {
     182       12721 :     Locs.startEntry(Begin, End);
     183             :   }
     184             : 
     185             :   /// Finalize the entry, deleting it if it's empty.
     186       12721 :   ~EntryBuilder() { Locs.finalizeEntry(); }
     187             : 
     188       25442 :   BufferByteStreamer getStreamer() { return Locs.getStreamer(); }
     189             : };
     190             : 
     191             : } // namespace llvm
     192             : 
     193             : #endif

Generated by: LCOV version 1.13