LLVM  10.0.0svn
DebugLocStream.h
Go to the documentation of this file.
1 //===--- lib/CodeGen/DebugLocStream.h - DWARF debug_loc stream --*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGLOCSTREAM_H
10 #define LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGLOCSTREAM_H
11 
12 #include "ByteStreamer.h"
13 #include "llvm/ADT/ArrayRef.h"
14 #include "llvm/ADT/SmallVector.h"
15 
16 namespace llvm {
17 
18 class AsmPrinter;
19 class DbgVariable;
20 class DwarfCompileUnit;
21 class MachineInstr;
22 class MCSymbol;
23 
24 /// Byte stream of .debug_loc entries.
25 ///
26 /// Stores a unified stream of .debug_loc entries. There's \a List for each
27 /// variable/inlined-at pair, and an \a Entry for each \a DebugLocEntry.
28 ///
29 /// FIXME: Do we need all these temp symbols?
30 /// FIXME: Why not output directly to the output stream?
32 public:
33  struct List {
35  MCSymbol *Label = nullptr;
36  size_t EntryOffset;
37  List(DwarfCompileUnit *CU, size_t EntryOffset)
38  : CU(CU), EntryOffset(EntryOffset) {}
39  };
40  struct Entry {
41  const MCSymbol *Begin;
42  const MCSymbol *End;
43  size_t ByteOffset;
44  size_t CommentOffset;
45  };
46 
47 private:
49  SmallVector<Entry, 32> Entries;
50  SmallString<256> DWARFBytes;
51  std::vector<std::string> Comments;
52  MCSymbol *Sym;
53 
54  /// Only verbose textual output needs comments. This will be set to
55  /// true for that case, and false otherwise.
56  bool GenerateComments;
57 
58 public:
59  DebugLocStream(bool GenerateComments) : GenerateComments(GenerateComments) { }
60  size_t getNumLists() const { return Lists.size(); }
61  const List &getList(size_t LI) const { return Lists[LI]; }
62  ArrayRef<List> getLists() const { return Lists; }
63  MCSymbol *getSym() const {
64  return Sym;
65  }
66  void setSym(MCSymbol *Sym) {
67  this->Sym = Sym;
68  }
69 
70  class ListBuilder;
71  class EntryBuilder;
72 
73 private:
74  /// Start a new .debug_loc entry list.
75  ///
76  /// Start a new .debug_loc entry list. Return the new list's index so it can
77  /// be retrieved later via \a getList().
78  ///
79  /// Until the next call, \a startEntry() will add entries to this list.
80  size_t startList(DwarfCompileUnit *CU) {
81  size_t LI = Lists.size();
82  Lists.emplace_back(CU, Entries.size());
83  return LI;
84  }
85 
86  /// Finalize a .debug_loc entry list.
87  ///
88  /// If there are no entries in this list, delete it outright. Otherwise,
89  /// create a label with \a Asm.
90  ///
91  /// \return false iff the list is deleted.
92  bool finalizeList(AsmPrinter &Asm);
93 
94  /// Start a new .debug_loc entry.
95  ///
96  /// Until the next call, bytes added to the stream will be added to this
97  /// entry.
98  void startEntry(const MCSymbol *BeginSym, const MCSymbol *EndSym) {
99  Entries.push_back({BeginSym, EndSym, DWARFBytes.size(), Comments.size()});
100  }
101 
102  /// Finalize a .debug_loc entry, deleting if it's empty.
103  void finalizeEntry();
104 
105 public:
107  return BufferByteStreamer(DWARFBytes, Comments, GenerateComments);
108  }
109 
110  ArrayRef<Entry> getEntries(const List &L) const {
111  size_t LI = getIndex(L);
112  return makeArrayRef(Entries)
113  .slice(Lists[LI].EntryOffset, getNumEntries(LI));
114  }
115 
116  ArrayRef<char> getBytes(const Entry &E) const {
117  size_t EI = getIndex(E);
118  return makeArrayRef(DWARFBytes.begin(), DWARFBytes.end())
119  .slice(Entries[EI].ByteOffset, getNumBytes(EI));
120  }
122  size_t EI = getIndex(E);
123  return makeArrayRef(Comments)
124  .slice(Entries[EI].CommentOffset, getNumComments(EI));
125  }
126 
127 private:
128  size_t getIndex(const List &L) const {
129  assert(&Lists.front() <= &L && &L <= &Lists.back() &&
130  "Expected valid list");
131  return &L - &Lists.front();
132  }
133  size_t getIndex(const Entry &E) const {
134  assert(&Entries.front() <= &E && &E <= &Entries.back() &&
135  "Expected valid entry");
136  return &E - &Entries.front();
137  }
138  size_t getNumEntries(size_t LI) const {
139  if (LI + 1 == Lists.size())
140  return Entries.size() - Lists[LI].EntryOffset;
141  return Lists[LI + 1].EntryOffset - Lists[LI].EntryOffset;
142  }
143  size_t getNumBytes(size_t EI) const {
144  if (EI + 1 == Entries.size())
145  return DWARFBytes.size() - Entries[EI].ByteOffset;
146  return Entries[EI + 1].ByteOffset - Entries[EI].ByteOffset;
147  }
148  size_t getNumComments(size_t EI) const {
149  if (EI + 1 == Entries.size())
150  return Comments.size() - Entries[EI].CommentOffset;
151  return Entries[EI + 1].CommentOffset - Entries[EI].CommentOffset;
152  }
153 };
154 
155 /// Builder for DebugLocStream lists.
157  DebugLocStream &Locs;
158  AsmPrinter &Asm;
159  DbgVariable &V;
160  const MachineInstr &MI;
161  size_t ListIndex;
162 
163 public:
165  DbgVariable &V, const MachineInstr &MI)
166  : Locs(Locs), Asm(Asm), V(V), MI(MI), ListIndex(Locs.startList(&CU)) {}
167 
168  /// Finalize the list.
169  ///
170  /// If the list is empty, delete it. Otherwise, finalize it by creating a
171  /// temp symbol in \a Asm and setting up the \a DbgVariable.
172  ~ListBuilder();
173 
174  DebugLocStream &getLocs() { return Locs; }
175 };
176 
177 /// Builder for DebugLocStream entries.
179  DebugLocStream &Locs;
180 
181 public:
182  EntryBuilder(ListBuilder &List, const MCSymbol *Begin, const MCSymbol *End)
183  : Locs(List.getLocs()) {
184  Locs.startEntry(Begin, End);
185  }
186 
187  /// Finalize the entry, deleting it if it's empty.
188  ~EntryBuilder() { Locs.finalizeEntry(); }
189 
191 };
192 
193 } // namespace llvm
194 
195 #endif
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:641
Builder for DebugLocStream lists.
EntryBuilder(ListBuilder &List, const MCSymbol *Begin, const MCSymbol *End)
This class represents lattice values for constants.
Definition: AllocatorList.h:23
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
ListBuilder(DebugLocStream &Locs, DwarfCompileUnit &CU, AsmPrinter &Asm, DbgVariable &V, const MachineInstr &MI)
DebugLocStream(bool GenerateComments)
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
This class is used to track local variable information.
Definition: DwarfDebug.h:118
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
BufferByteStreamer getStreamer()
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
ArrayRef< char > getBytes(const Entry &E) const
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
ArrayRef< Entry > getEntries(const List &L) const
size_t size() const
Definition: SmallVector.h:52
MCSymbol * getSym() const
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
~EntryBuilder()
Finalize the entry, deleting it if it&#39;s empty.
static const SCEV * getNumBytes(const SCEV *BECount, Type *IntPtr, unsigned StoreSize, Loop *CurLoop, const DataLayout *DL, ScalarEvolution *SE)
Compute the number of bytes as a SCEV from the backedge taken count.
const List & getList(size_t LI) const
ArrayRef< std::string > getComments(const Entry &E) const
void setSym(MCSymbol *Sym)
DwarfCompileUnit * CU
Representation of each machine instruction.
Definition: MachineInstr.h:63
size_t getNumLists() const
List(DwarfCompileUnit *CU, size_t EntryOffset)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
IRTranslator LLVM IR MI
Byte stream of .debug_loc entries.
Builder for DebugLocStream entries.
ArrayRef< List > getLists() const