Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/CodeGen/AsmPrinter/DwarfFile.h
Line
Count
Source
1
//===- llvm/CodeGen/DwarfFile.h - Dwarf Debug Framework ---------*- 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_DWARFFILE_H
10
#define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFFILE_H
11
12
#include "DwarfStringPool.h"
13
#include "llvm/ADT/DenseMap.h"
14
#include "llvm/ADT/SmallVector.h"
15
#include "llvm/ADT/StringRef.h"
16
#include "llvm/CodeGen/DIE.h"
17
#include "llvm/IR/Metadata.h"
18
#include "llvm/Support/Allocator.h"
19
#include <map>
20
#include <memory>
21
#include <utility>
22
23
namespace llvm {
24
25
class AsmPrinter;
26
class DbgEntity;
27
class DbgVariable;
28
class DbgLabel;
29
class DwarfCompileUnit;
30
class DwarfUnit;
31
class LexicalScope;
32
class MCSection;
33
34
// Data structure to hold a range for range lists.
35
class RangeSpan {
36
public:
37
396k
  RangeSpan(MCSymbol *S, MCSymbol *E) : Start(S), End(E) {}
38
506k
  const MCSymbol *getStart() const { return Start; }
39
462k
  const MCSymbol *getEnd() const { return End; }
40
33.0k
  void setEnd(const MCSymbol *E) { End = E; }
41
42
private:
43
  const MCSymbol *Start, *End;
44
};
45
46
class RangeSpanList {
47
private:
48
  // Index for locating within the debug_range section this particular span.
49
  MCSymbol *RangeSym;
50
  const DwarfCompileUnit *CU;
51
  // List of ranges.
52
  SmallVector<RangeSpan, 2> Ranges;
53
54
public:
55
  RangeSpanList(MCSymbol *Sym, const DwarfCompileUnit &CU,
56
                SmallVector<RangeSpan, 2> Ranges)
57
56.9k
      : RangeSym(Sym), CU(&CU), Ranges(std::move(Ranges)) {}
58
113k
  MCSymbol *getSym() const { return RangeSym; }
59
56.9k
  const DwarfCompileUnit &getCU() const { return *CU; }
60
56.9k
  const SmallVectorImpl<RangeSpan> &getRanges() const { return Ranges; }
61
};
62
63
class DwarfFile {
64
  // Target of Dwarf emission, used for sizing of abbreviations.
65
  AsmPrinter *Asm;
66
67
  BumpPtrAllocator AbbrevAllocator;
68
69
  // Used to uniquely define abbreviations.
70
  DIEAbbrevSet Abbrevs;
71
72
  // A pointer to all units in the section.
73
  SmallVector<std::unique_ptr<DwarfCompileUnit>, 1> CUs;
74
75
  DwarfStringPool StrPool;
76
77
  // List of range lists for a given compile unit, separate from the ranges for
78
  // the CU itself.
79
  SmallVector<RangeSpanList, 1> CURangeLists;
80
81
  /// DWARF v5: The symbol that designates the start of the contribution to
82
  /// the string offsets table. The contribution is shared by all units.
83
  MCSymbol *StringOffsetsStartSym = nullptr;
84
85
  /// DWARF v5: The symbol that designates the base of the range list table.
86
  /// The table is shared by all units.
87
  MCSymbol *RnglistsTableBaseSym = nullptr;
88
89
  /// DWARF v5: The symbol that designates the base of the locations list table.
90
  /// The table is shared by all units.
91
  MCSymbol *LoclistsTableBaseSym = nullptr;
92
93
  /// The variables of a lexical scope.
94
  struct ScopeVars {
95
    /// We need to sort Args by ArgNo and check for duplicates. This could also
96
    /// be implemented as a list or vector + std::lower_bound().
97
    std::map<unsigned, DbgVariable *> Args;
98
    SmallVector<DbgVariable *, 8> Locals;
99
  };
100
  /// Collection of DbgVariables of each lexical scope.
101
  DenseMap<LexicalScope *, ScopeVars> ScopeVariables;
102
103
  /// Collection of DbgLabels of each lexical scope.
104
  using LabelList = SmallVector<DbgLabel *, 4>;
105
  DenseMap<LexicalScope *, LabelList> ScopeLabels;
106
107
  // Collection of abstract subprogram DIEs.
108
  DenseMap<const MDNode *, DIE *> AbstractSPDies;
109
  DenseMap<const DINode *, std::unique_ptr<DbgEntity>> AbstractEntities;
110
111
  /// Maps MDNodes for type system with the corresponding DIEs. These DIEs can
112
  /// be shared across CUs, that is why we keep the map here instead
113
  /// of in DwarfCompileUnit.
114
  DenseMap<const MDNode *, DIE *> DITypeNodeToDieMap;
115
116
public:
117
  DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA);
118
119
970k
  const SmallVectorImpl<std::unique_ptr<DwarfCompileUnit>> &getUnits() {
120
970k
    return CUs;
121
970k
  }
122
123
  std::pair<uint32_t, RangeSpanList *> addRange(const DwarfCompileUnit &CU,
124
                                                SmallVector<RangeSpan, 2> R);
125
126
  /// getRangeLists - Get the vector of range lists.
127
3.57k
  const SmallVectorImpl<RangeSpanList> &getRangeLists() const {
128
3.57k
    return CURangeLists;
129
3.57k
  }
130
131
  /// Compute the size and offset of a DIE given an incoming Offset.
132
  unsigned computeSizeAndOffset(DIE &Die, unsigned Offset);
133
134
  /// Compute the size and offset of all the DIEs.
135
  void computeSizeAndOffsets();
136
137
  /// Compute the size and offset of all the DIEs in the given unit.
138
  /// \returns The size of the root DIE.
139
  unsigned computeSizeAndOffsetsForUnit(DwarfUnit *TheU);
140
141
  /// Add a unit to the list of CUs.
142
  void addUnit(std::unique_ptr<DwarfCompileUnit> U);
143
144
  /// Emit all of the units to the section listed with the given
145
  /// abbreviation section.
146
  void emitUnits(bool UseOffsets);
147
148
  /// Emit the given unit to its section.
149
  void emitUnit(DwarfUnit *TheU, bool UseOffsets);
150
151
  /// Emit a set of abbreviations to the specific section.
152
  void emitAbbrevs(MCSection *);
153
154
  /// Emit all of the strings to the section given. If OffsetSection is
155
  /// non-null, emit a table of string offsets to it. If UseRelativeOffsets
156
  /// is false, emit absolute offsets to the strings. Otherwise, emit
157
  /// relocatable references to the strings if they are supported by the target.
158
  void emitStrings(MCSection *StrSection, MCSection *OffsetSection = nullptr,
159
                   bool UseRelativeOffsets = false);
160
161
  /// Returns the string pool.
162
419k
  DwarfStringPool &getStringPool() { return StrPool; }
163
164
132
  MCSymbol *getStringOffsetsStartSym() const { return StringOffsetsStartSym; }
165
55
  void setStringOffsetsStartSym(MCSymbol *Sym) { StringOffsetsStartSym = Sym; }
166
167
23
  MCSymbol *getRnglistsTableBaseSym() const { return RnglistsTableBaseSym; }
168
62
  void setRnglistsTableBaseSym(MCSymbol *Sym) { RnglistsTableBaseSym = Sym; }
169
170
12
  MCSymbol *getLoclistsTableBaseSym() const { return LoclistsTableBaseSym; }
171
55
  void setLoclistsTableBaseSym(MCSymbol *Sym) { LoclistsTableBaseSym = Sym; }
172
173
  /// \returns false if the variable was merged with a previous one.
174
  bool addScopeVariable(LexicalScope *LS, DbgVariable *Var);
175
176
  void addScopeLabel(LexicalScope *LS, DbgLabel *Label);
177
178
408k
  DenseMap<LexicalScope *, ScopeVars> &getScopeVariables() {
179
408k
    return ScopeVariables;
180
408k
  }
181
182
408k
  DenseMap<LexicalScope *, LabelList> &getScopeLabels() {
183
408k
    return ScopeLabels;
184
408k
  }
185
186
480k
  DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
187
480k
    return AbstractSPDies;
188
480k
  }
189
190
2.53k
  DenseMap<const DINode *, std::unique_ptr<DbgEntity>> &getAbstractEntities() {
191
2.53k
    return AbstractEntities;
192
2.53k
  }
193
194
3.19k
  void insertDIE(const MDNode *TypeMD, DIE *Die) {
195
3.19k
    DITypeNodeToDieMap.insert(std::make_pair(TypeMD, Die));
196
3.19k
  }
197
198
6.86k
  DIE *getDIE(const MDNode *TypeMD) {
199
6.86k
    return DITypeNodeToDieMap.lookup(TypeMD);
200
6.86k
  }
201
};
202
203
} // end namespace llvm
204
205
#endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFFILE_H