Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/CodeGen/AsmPrinter/DebugLocStream.h
Line
Count
Source (jump to first uncovered line)
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?
31
class DebugLocStream {
32
public:
33
  struct List {
34
    DwarfCompileUnit *CU;
35
    MCSymbol *Label = nullptr;
36
    size_t EntryOffset;
37
    List(DwarfCompileUnit *CU, size_t EntryOffset)
38
503
        : CU(CU), EntryOffset(EntryOffset) {}
39
  };
40
  struct Entry {
41
    const MCSymbol *BeginSym;
42
    const MCSymbol *EndSym;
43
    size_t ByteOffset;
44
    size_t CommentOffset;
45
    Entry(const MCSymbol *BeginSym, const MCSymbol *EndSym, size_t ByteOffset,
46
          size_t CommentOffset)
47
        : BeginSym(BeginSym), EndSym(EndSym), ByteOffset(ByteOffset),
48
667
          CommentOffset(CommentOffset) {}
49
  };
50
51
private:
52
  SmallVector<List, 4> Lists;
53
  SmallVector<Entry, 32> Entries;
54
  SmallString<256> DWARFBytes;
55
  SmallVector<std::string, 32> Comments;
56
57
  /// Only verbose textual output needs comments.  This will be set to
58
  /// true for that case, and false otherwise.
59
  bool GenerateComments;
60
61
public:
62
35.7k
  DebugLocStream(bool GenerateComments) : GenerateComments(GenerateComments) { }
63
0
  size_t getNumLists() const { return Lists.size(); }
64
422
  const List &getList(size_t LI) const { return Lists[LI]; }
65
3.46k
  ArrayRef<List> getLists() const { return Lists; }
66
67
  class ListBuilder;
68
  class EntryBuilder;
69
70
private:
71
  /// Start a new .debug_loc entry list.
72
  ///
73
  /// Start a new .debug_loc entry list.  Return the new list's index so it can
74
  /// be retrieved later via \a getList().
75
  ///
76
  /// Until the next call, \a startEntry() will add entries to this list.
77
503
  size_t startList(DwarfCompileUnit *CU) {
78
503
    size_t LI = Lists.size();
79
503
    Lists.emplace_back(CU, Entries.size());
80
503
    return LI;
81
503
  }
82
83
  /// Finalize a .debug_loc entry list.
84
  ///
85
  /// If there are no entries in this list, delete it outright.  Otherwise,
86
  /// create a label with \a Asm.
87
  ///
88
  /// \return false iff the list is deleted.
89
  bool finalizeList(AsmPrinter &Asm);
90
91
  /// Start a new .debug_loc entry.
92
  ///
93
  /// Until the next call, bytes added to the stream will be added to this
94
  /// entry.
95
667
  void startEntry(const MCSymbol *BeginSym, const MCSymbol *EndSym) {
96
667
    Entries.emplace_back(BeginSym, EndSym, DWARFBytes.size(), Comments.size());
97
667
  }
98
99
  /// Finalize a .debug_loc entry, deleting if it's empty.
100
  void finalizeEntry();
101
102
public:
103
667
  BufferByteStreamer getStreamer() {
104
667
    return BufferByteStreamer(DWARFBytes, Comments, GenerateComments);
105
667
  }
106
107
422
  ArrayRef<Entry> getEntries(const List &L) const {
108
422
    size_t LI = getIndex(L);
109
422
    return makeArrayRef(Entries)
110
422
        .slice(Lists[LI].EntryOffset, getNumEntries(LI));
111
422
  }
112
113
2.54k
  ArrayRef<char> getBytes(const Entry &E) const {
114
2.54k
    size_t EI = getIndex(E);
115
2.54k
    return makeArrayRef(DWARFBytes.begin(), DWARFBytes.end())
116
2.54k
        .slice(Entries[EI].ByteOffset, getNumBytes(EI));
117
2.54k
  }
118
646
  ArrayRef<std::string> getComments(const Entry &E) const {
119
646
    size_t EI = getIndex(E);
120
646
    return makeArrayRef(Comments)
121
646
        .slice(Entries[EI].CommentOffset, getNumComments(EI));
122
646
  }
123
124
private:
125
422
  size_t getIndex(const List &L) const {
126
422
    assert(&Lists.front() <= &L && &L <= &Lists.back() &&
127
422
           "Expected valid list");
128
422
    return &L - &Lists.front();
129
422
  }
130
3.19k
  size_t getIndex(const Entry &E) const {
131
3.19k
    assert(&Entries.front() <= &E && &E <= &Entries.back() &&
132
3.19k
           "Expected valid entry");
133
3.19k
    return &E - &Entries.front();
134
3.19k
  }
135
422
  size_t getNumEntries(size_t LI) const {
136
422
    if (LI + 1 == Lists.size())
137
198
      return Entries.size() - Lists[LI].EntryOffset;
138
224
    return Lists[LI + 1].EntryOffset - Lists[LI].EntryOffset;
139
224
  }
140
2.54k
  size_t getNumBytes(size_t EI) const {
141
2.54k
    if (EI + 1 == Entries.size())
142
777
      return DWARFBytes.size() - Entries[EI].ByteOffset;
143
1.77k
    return Entries[EI + 1].ByteOffset - Entries[EI].ByteOffset;
144
1.77k
  }
145
646
  size_t getNumComments(size_t EI) const {
146
646
    if (EI + 1 == Entries.size())
147
197
      return Comments.size() - Entries[EI].CommentOffset;
148
449
    return Entries[EI + 1].CommentOffset - Entries[EI].CommentOffset;
149
449
  }
150
};
151
152
/// Builder for DebugLocStream lists.
153
class DebugLocStream::ListBuilder {
154
  DebugLocStream &Locs;
155
  AsmPrinter &Asm;
156
  DbgVariable &V;
157
  const MachineInstr &MI;
158
  size_t ListIndex;
159
160
public:
161
  ListBuilder(DebugLocStream &Locs, DwarfCompileUnit &CU, AsmPrinter &Asm,
162
              DbgVariable &V, const MachineInstr &MI)
163
503
      : Locs(Locs), Asm(Asm), V(V), MI(MI), ListIndex(Locs.startList(&CU)) {}
164
165
  /// Finalize the list.
166
  ///
167
  /// If the list is empty, delete it.  Otherwise, finalize it by creating a
168
  /// temp symbol in \a Asm and setting up the \a DbgVariable.
169
  ~ListBuilder();
170
171
667
  DebugLocStream &getLocs() { return Locs; }
172
};
173
174
/// Builder for DebugLocStream entries.
175
class DebugLocStream::EntryBuilder {
176
  DebugLocStream &Locs;
177
178
public:
179
  EntryBuilder(ListBuilder &List, const MCSymbol *Begin, const MCSymbol *End)
180
667
      : Locs(List.getLocs()) {
181
667
    Locs.startEntry(Begin, End);
182
667
  }
183
184
  /// Finalize the entry, deleting it if it's empty.
185
667
  ~EntryBuilder() { Locs.finalizeEntry(); }
186
187
667
  BufferByteStreamer getStreamer() { return Locs.getStreamer(); }
188
};
189
190
} // namespace llvm
191
192
#endif