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
16namespace llvm {
17
18class AsmPrinter;
19class DbgVariable;
20class DwarfCompileUnit;
21class MachineInstr;
22class 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?
31class DebugLocStream {
32public:
33  struct List {
34    DwarfCompileUnit *CU;
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
47private:
48  SmallVector<List, 4> Lists;
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
58public:
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
73private:
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
105public:
106  BufferByteStreamer getStreamer() {
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  }
121  ArrayRef<std::string> getComments(const Entry &E) const {
122    size_t EI = getIndex(E);
123    return makeArrayRef(Comments)
124        .slice(Entries[EI].CommentOffset, getNumComments(EI));
125  }
126
127private:
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.
156class DebugLocStream::ListBuilder {
157  DebugLocStream &Locs;
158  AsmPrinter &Asm;
159  DbgVariable &V;
160  const MachineInstr &MI;
161  size_t ListIndex;
162  Optional<uint8_t> TagOffset;
163
164public:
165  ListBuilder(DebugLocStream &Locs, DwarfCompileUnit &CU, AsmPrinter &Asm,
166              DbgVariable &V, const MachineInstr &MI)
167      : Locs(Locs), Asm(Asm), V(V), MI(MI), ListIndex(Locs.startList(&CU)),
168        TagOffset(None) {}
169
170  void setTagOffset(uint8_t TO) {
171    TagOffset = TO;
172  }
173
174  /// Finalize the list.
175  ///
176  /// If the list is empty, delete it.  Otherwise, finalize it by creating a
177  /// temp symbol in \a Asm and setting up the \a DbgVariable.
178  ~ListBuilder();
179
180  DebugLocStream &getLocs() { return Locs; }
181};
182
183/// Builder for DebugLocStream entries.
184class DebugLocStream::EntryBuilder {
185  DebugLocStream &Locs;
186
187public:
188  EntryBuilder(ListBuilder &List, const MCSymbol *Begin, const MCSymbol *End)
189      : Locs(List.getLocs()) {
190    Locs.startEntry(Begin, End);
191  }
192
193  /// Finalize the entry, deleting it if it's empty.
194  ~EntryBuilder() { Locs.finalizeEntry(); }
195
196  BufferByteStreamer getStreamer() { return Locs.getStreamer(); }
197};
198
199} // namespace llvm
200
201#endif
202