1 //===--- lib/CodeGen/DebugLocStream.h - DWARF debug_loc stream --*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGLOCSTREAM_H
10 #define LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGLOCSTREAM_H
12 #include "ByteStreamer.h"
13 #include "llvm/ADT/ArrayRef.h"
14 #include "llvm/ADT/SmallVector.h"
20 class DwarfCompileUnit
;
24 /// Byte stream of .debug_loc entries.
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.
29 /// FIXME: Do we need all these temp symbols?
30 /// FIXME: Why not output directly to the output stream?
31 class DebugLocStream
{
35 MCSymbol
*Label
= nullptr;
37 List(DwarfCompileUnit
*CU
, size_t EntryOffset
)
38 : CU(CU
), EntryOffset(EntryOffset
) {}
41 const MCSymbol
*Begin
;
48 SmallVector
<List
, 4> Lists
;
49 SmallVector
<Entry
, 32> Entries
;
50 SmallString
<256> DWARFBytes
;
51 std::vector
<std::string
> Comments
;
54 /// Only verbose textual output needs comments. This will be set to
55 /// true for that case, and false otherwise.
56 bool GenerateComments
;
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 {
66 void setSym(MCSymbol
*Sym
) {
74 /// Start a new .debug_loc entry list.
76 /// Start a new .debug_loc entry list. Return the new list's index so it can
77 /// be retrieved later via \a getList().
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());
86 /// Finalize a .debug_loc entry list.
88 /// If there are no entries in this list, delete it outright. Otherwise,
89 /// create a label with \a Asm.
91 /// \return false iff the list is deleted.
92 bool finalizeList(AsmPrinter
&Asm
);
94 /// Start a new .debug_loc entry.
96 /// Until the next call, bytes added to the stream will be added to this
98 void startEntry(const MCSymbol
*BeginSym
, const MCSymbol
*EndSym
) {
99 Entries
.push_back({BeginSym
, EndSym
, DWARFBytes
.size(), Comments
.size()});
102 /// Finalize a .debug_loc entry, deleting if it's empty.
103 void finalizeEntry();
106 BufferByteStreamer
getStreamer() {
107 return BufferByteStreamer(DWARFBytes
, Comments
, GenerateComments
);
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
));
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
));
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
));
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();
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();
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
;
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
;
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
;
155 /// Builder for DebugLocStream lists.
156 class DebugLocStream::ListBuilder
{
157 DebugLocStream
&Locs
;
160 const MachineInstr
&MI
;
164 ListBuilder(DebugLocStream
&Locs
, DwarfCompileUnit
&CU
, AsmPrinter
&Asm
,
165 DbgVariable
&V
, const MachineInstr
&MI
)
166 : Locs(Locs
), Asm(Asm
), V(V
), MI(MI
), ListIndex(Locs
.startList(&CU
)) {}
168 /// Finalize the list.
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.
174 DebugLocStream
&getLocs() { return Locs
; }
177 /// Builder for DebugLocStream entries.
178 class DebugLocStream::EntryBuilder
{
179 DebugLocStream
&Locs
;
182 EntryBuilder(ListBuilder
&List
, const MCSymbol
*Begin
, const MCSymbol
*End
)
183 : Locs(List
.getLocs()) {
184 Locs
.startEntry(Begin
, End
);
187 /// Finalize the entry, deleting it if it's empty.
188 ~EntryBuilder() { Locs
.finalizeEntry(); }
190 BufferByteStreamer
getStreamer() { return Locs
.getStreamer(); }