Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.h
Line
Count
Source (jump to first uncovered line)
1
//===-- llvm/CodeGen/DwarfUnit.h - Dwarf Compile Unit ---*- 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
// This file contains support for writing dwarf compile unit.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFUNIT_H
14
#define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFUNIT_H
15
16
#include "DwarfDebug.h"
17
#include "llvm/ADT/DenseMap.h"
18
#include "llvm/ADT/Optional.h"
19
#include "llvm/ADT/StringMap.h"
20
#include "llvm/CodeGen/AsmPrinter.h"
21
#include "llvm/CodeGen/DIE.h"
22
#include "llvm/IR/DIBuilder.h"
23
#include "llvm/IR/DebugInfo.h"
24
#include "llvm/MC/MCDwarf.h"
25
#include "llvm/MC/MCExpr.h"
26
#include "llvm/MC/MCSection.h"
27
28
namespace llvm {
29
30
class MachineLocation;
31
class MachineOperand;
32
class ConstantInt;
33
class ConstantFP;
34
class DbgVariable;
35
class DwarfCompileUnit;
36
37
//===----------------------------------------------------------------------===//
38
/// This dwarf writer support class manages information associated with a
39
/// source file.
40
class DwarfUnit : public DIEUnit {
41
protected:
42
  /// MDNode for the compile unit.
43
  const DICompileUnit *CUNode;
44
45
  // All DIEValues are allocated through this allocator.
46
  BumpPtrAllocator DIEValueAllocator;
47
48
  /// Target of Dwarf emission.
49
  AsmPrinter *Asm;
50
51
  /// Emitted at the end of the CU and used to compute the CU Length field.
52
  MCSymbol *EndLabel = nullptr;
53
54
  // Holders for some common dwarf information.
55
  DwarfDebug *DD;
56
  DwarfFile *DU;
57
58
  /// An anonymous type for index type.  Owned by DIEUnit.
59
  DIE *IndexTyDie;
60
61
  /// Tracks the mapping of unit level debug information variables to debug
62
  /// information entries.
63
  DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
64
65
  /// A list of all the DIEBlocks in use.
66
  std::vector<DIEBlock *> DIEBlocks;
67
68
  /// A list of all the DIELocs in use.
69
  std::vector<DIELoc *> DIELocs;
70
71
  /// This map is used to keep track of subprogram DIEs that need
72
  /// DW_AT_containing_type attribute. This attribute points to a DIE that
73
  /// corresponds to the MDNode mapped with the subprogram DIE.
74
  DenseMap<DIE *, const DINode *> ContainingTypeMap;
75
76
  DwarfUnit(dwarf::Tag, const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW,
77
            DwarfFile *DWU);
78
79
  bool applySubprogramDefinitionAttributes(const DISubprogram *SP, DIE &SPDie);
80
81
  bool shareAcrossDWOCUs() const;
82
  bool isShareableAcrossCUs(const DINode *D) const;
83
84
public:
85
  // Accessors.
86
0
  AsmPrinter* getAsmPrinter() const { return Asm; }
87
2.75k
  MCSymbol *getEndLabel() const { return EndLabel; }
88
90.7k
  uint16_t getLanguage() const { return CUNode->getSourceLanguage(); }
89
782k
  const DICompileUnit *getCUNode() const { return CUNode; }
90
91
108
  uint16_t getDwarfVersion() const { return DD->getDwarfVersion(); }
92
93
  /// Return true if this compile unit has something to write out.
94
0
  bool hasContent() const { return getUnitDie().hasChildren(); }
95
96
  /// Get string containing language specific context for a global name.
97
  ///
98
  /// Walks the metadata parent chain in a language specific manner (using the
99
  /// compile unit language) and returns it as a string. This is done at the
100
  /// metadata level because DIEs may not currently have been added to the
101
  /// parent context and walking the DIEs looking for names is more expensive
102
  /// than walking the metadata.
103
  std::string getParentContextString(const DIScope *Context) const;
104
105
  /// Add a new global name to the compile unit.
106
  virtual void addGlobalName(StringRef Name, const DIE &Die,
107
                             const DIScope *Context) = 0;
108
109
  /// Add a new global type to the compile unit.
110
  virtual void addGlobalType(const DIType *Ty, const DIE &Die,
111
                             const DIScope *Context) = 0;
112
113
  /// Returns the DIE map slot for the specified debug variable.
114
  ///
115
  /// We delegate the request to DwarfDebug when the MDNode can be part of the
116
  /// type system, since DIEs for the type system can be shared across CUs and
117
  /// the mappings are kept in DwarfDebug.
118
  DIE *getDIE(const DINode *D) const;
119
120
  /// Returns a fresh newly allocated DIELoc.
121
23
  DIELoc *getDIELoc() { return new (DIEValueAllocator) DIELoc; }
122
123
  /// Insert DIE into the map.
124
  ///
125
  /// We delegate the request to DwarfDebug when the MDNode can be part of the
126
  /// type system, since DIEs for the type system can be shared across CUs and
127
  /// the mappings are kept in DwarfDebug.
128
  void insertDIE(const DINode *Desc, DIE *D);
129
130
  /// Add a flag that is true to the DIE.
131
  void addFlag(DIE &Die, dwarf::Attribute Attribute);
132
133
  /// Add an unsigned integer attribute data and value.
134
  void addUInt(DIEValueList &Die, dwarf::Attribute Attribute,
135
               Optional<dwarf::Form> Form, uint64_t Integer);
136
137
  void addUInt(DIEValueList &Block, dwarf::Form Form, uint64_t Integer);
138
139
  /// Add an signed integer attribute data and value.
140
  void addSInt(DIEValueList &Die, dwarf::Attribute Attribute,
141
               Optional<dwarf::Form> Form, int64_t Integer);
142
143
  void addSInt(DIELoc &Die, Optional<dwarf::Form> Form, int64_t Integer);
144
145
  /// Add a string attribute data and value.
146
  ///
147
  /// We always emit a reference to the string pool instead of immediate
148
  /// strings so that DIEs have more predictable sizes. In the case of split
149
  /// dwarf we emit an index into another table which gets us the static offset
150
  /// into the string table.
151
  void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str);
152
153
  /// Add a Dwarf label attribute data and value.
154
  DIEValueList::value_iterator addLabel(DIEValueList &Die,
155
                                        dwarf::Attribute Attribute,
156
                                        dwarf::Form Form,
157
                                        const MCSymbol *Label);
158
159
  void addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label);
160
161
  /// Add an offset into a section attribute data and value.
162
  void addSectionOffset(DIE &Die, dwarf::Attribute Attribute, uint64_t Integer);
163
164
  /// Add a dwarf op address data and value using the form given and an
165
  /// op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
166
  void addOpAddress(DIELoc &Die, const MCSymbol *Sym);
167
168
  /// Add a label delta attribute data and value.
169
  void addLabelDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi,
170
                     const MCSymbol *Lo);
171
172
  /// Add a DIE attribute data and value.
173
  void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry);
174
175
  /// Add a DIE attribute data and value.
176
  void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIEEntry Entry);
177
178
  /// Add a type's DW_AT_signature and set the  declaration flag.
179
  void addDIETypeSignature(DIE &Die, uint64_t Signature);
180
181
  /// Add block data.
182
  void addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc);
183
184
  /// Add block data.
185
  void addBlock(DIE &Die, dwarf::Attribute Attribute, DIEBlock *Block);
186
187
  /// Add location information to specified debug information entry.
188
  void addSourceLine(DIE &Die, unsigned Line, const DIFile *File);
189
  void addSourceLine(DIE &Die, const DILocalVariable *V);
190
  void addSourceLine(DIE &Die, const DIGlobalVariable *G);
191
  void addSourceLine(DIE &Die, const DISubprogram *SP);
192
  void addSourceLine(DIE &Die, const DILabel *L);
193
  void addSourceLine(DIE &Die, const DIType *Ty);
194
  void addSourceLine(DIE &Die, const DIObjCProperty *Ty);
195
196
  /// Add constant value entry in variable DIE.
197
  void addConstantValue(DIE &Die, const MachineOperand &MO, const DIType *Ty);
198
  void addConstantValue(DIE &Die, const ConstantInt *CI, const DIType *Ty);
199
  void addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty);
200
  void addConstantValue(DIE &Die, const APInt &Val, bool Unsigned);
201
  void addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty);
202
  void addConstantValue(DIE &Die, bool Unsigned, uint64_t Val);
203
204
  /// Add constant value entry in variable DIE.
205
  void addConstantFPValue(DIE &Die, const MachineOperand &MO);
206
  void addConstantFPValue(DIE &Die, const ConstantFP *CFP);
207
208
  /// Add a linkage name, if it isn't empty.
209
  void addLinkageName(DIE &Die, StringRef LinkageName);
210
211
  /// Add template parameters in buffer.
212
  void addTemplateParams(DIE &Buffer, DINodeArray TParams);
213
214
  /// Add thrown types.
215
  void addThrownTypes(DIE &Die, DINodeArray ThrownTypes);
216
217
  // FIXME: Should be reformulated in terms of addComplexAddress.
218
  /// Start with the address based on the location provided, and generate the
219
  /// DWARF information necessary to find the actual Block variable (navigating
220
  /// the Block struct) based on the starting location.  Add the DWARF
221
  /// information to the die.  Obsolete, please use addComplexAddress instead.
222
  void addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
223
                            dwarf::Attribute Attribute,
224
                            const MachineLocation &Location);
225
226
  /// Add a new type attribute to the specified entity.
227
  ///
228
  /// This takes and attribute parameter because DW_AT_friend attributes are
229
  /// also type references.
230
  void addType(DIE &Entity, const DIType *Ty,
231
               dwarf::Attribute Attribute = dwarf::DW_AT_type);
232
233
  DIE *getOrCreateNameSpace(const DINamespace *NS);
234
  DIE *getOrCreateModule(const DIModule *M);
235
  DIE *getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal = false);
236
237
  void applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
238
                                 bool SkipSPAttributes = false);
239
240
  /// Creates type DIE with specific context.
241
  DIE *createTypeDIE(const DIScope *Context, DIE &ContextDIE, const DIType *Ty);
242
243
  /// Find existing DIE or create new DIE for the given type.
244
  DIE *getOrCreateTypeDIE(const MDNode *TyNode);
245
246
  /// Get context owner's DIE.
247
  DIE *getOrCreateContextDIE(const DIScope *Context);
248
249
  /// Construct DIEs for types that contain vtables.
250
  void constructContainingTypeDIEs();
251
252
  /// Construct function argument DIEs.
253
  void constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args);
254
255
  /// Create a DIE with the given Tag, add the DIE to its parent, and
256
  /// call insertDIE if MD is not null.
257
  DIE &createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N = nullptr);
258
259
206k
  bool useSegmentedStringOffsetsTable() const {
260
206k
    return DD->useSegmentedStringOffsetsTable();
261
206k
  }
262
263
  /// Compute the size of a header for this unit, not including the initial
264
  /// length field.
265
6.25k
  virtual unsigned getHeaderSize() const {
266
6.25k
    return sizeof(int16_t) + // DWARF version number
267
6.25k
           sizeof(int32_t) + // Offset Into Abbrev. Section
268
6.25k
           sizeof(int8_t) +  // Pointer Size (in bytes)
269
6.25k
           (DD->getDwarfVersion() >= 5 ? 
sizeof(int8_t)87
270
6.25k
                                       : 
06.17k
); // DWARF v5 unit type
271
6.25k
  }
272
273
  /// Emit the header for this unit, not including the initial length field.
274
  virtual void emitHeader(bool UseOffsets) = 0;
275
276
  /// Add the DW_AT_str_offsets_base attribute to the unit DIE.
277
  void addStringOffsetsStart();
278
279
  /// Add the DW_AT_rnglists_base attribute to the unit DIE.
280
  void addRnglistsBase();
281
282
  /// Add the DW_AT_loclists_base attribute to the unit DIE.
283
  void addLoclistsBase();
284
285
  virtual DwarfCompileUnit &getCU() = 0;
286
287
  void constructTypeDIE(DIE &Buffer, const DICompositeType *CTy);
288
289
  /// addSectionDelta - Add a label delta attribute data and value.
290
  DIE::value_iterator addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
291
                                      const MCSymbol *Hi, const MCSymbol *Lo);
292
293
  /// Add a Dwarf section label attribute data and value.
294
  DIE::value_iterator addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
295
                                      const MCSymbol *Label,
296
                                      const MCSymbol *Sec);
297
298
  /// If the \p File has an MD5 checksum, return it as an MD5Result
299
  /// allocated in the MCContext.
300
  Optional<MD5::MD5Result> getMD5AsBytes(const DIFile *File) const;
301
302
  /// Get context owner's DIE.
303
  DIE *createTypeDIE(const DICompositeType *Ty);
304
305
protected:
306
  ~DwarfUnit();
307
308
  /// Create new static data member DIE.
309
  DIE *getOrCreateStaticMemberDIE(const DIDerivedType *DT);
310
311
  /// Look up the source ID for the given file. If none currently exists,
312
  /// create a new ID and insert it in the line table.
313
  virtual unsigned getOrCreateSourceID(const DIFile *File) = 0;
314
315
  /// Emit the common part of the header for this unit.
316
  void emitCommonHeader(bool UseOffsets, dwarf::UnitType UT);
317
318
private:
319
  void constructTypeDIE(DIE &Buffer, const DIBasicType *BTy);
320
  void constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy);
321
  void constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy);
322
  void constructSubrangeDIE(DIE &Buffer, const DISubrange *SR, DIE *IndexTy);
323
  void constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy);
324
  void constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy);
325
  DIE &constructMemberDIE(DIE &Buffer, const DIDerivedType *DT);
326
  void constructTemplateTypeParameterDIE(DIE &Buffer,
327
                                         const DITemplateTypeParameter *TP);
328
  void constructTemplateValueParameterDIE(DIE &Buffer,
329
                                          const DITemplateValueParameter *TVP);
330
331
  /// Return the default lower bound for an array.
332
  ///
333
  /// If the DWARF version doesn't handle the language, return -1.
334
  int64_t getDefaultLowerBound() const;
335
336
  /// Get an anonymous type for index type.
337
  DIE *getIndexTyDie();
338
339
  /// Set D as anonymous type for index which can be reused later.
340
0
  void setIndexTyDie(DIE *D) { IndexTyDie = D; }
341
342
  virtual void finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) = 0;
343
344
  /// If this is a named finished type then include it in the list of types for
345
  /// the accelerator tables.
346
  void updateAcceleratorTables(const DIScope *Context, const DIType *Ty,
347
                               const DIE &TyDIE);
348
349
  virtual bool isDwoUnit() const = 0;
350
  const MCSymbol *getCrossSectionRelativeBaseAddress() const override;
351
};
352
353
class DwarfTypeUnit final : public DwarfUnit {
354
  uint64_t TypeSignature;
355
  const DIE *Ty;
356
  DwarfCompileUnit &CU;
357
  MCDwarfDwoLineTable *SplitLineTable;
358
  bool UsedLineTable = false;
359
360
  unsigned getOrCreateSourceID(const DIFile *File) override;
361
  void finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) override;
362
  bool isDwoUnit() const override;
363
364
public:
365
  DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A, DwarfDebug *DW,
366
                DwarfFile *DWU, MCDwarfDwoLineTable *SplitLineTable = nullptr);
367
368
47
  void setTypeSignature(uint64_t Signature) { TypeSignature = Signature; }
369
47
  void setType(const DIE *Ty) { this->Ty = Ty; }
370
371
  /// Emit the header for this unit, not including the initial length field.
372
  void emitHeader(bool UseOffsets) override;
373
36
  unsigned getHeaderSize() const override {
374
36
    return DwarfUnit::getHeaderSize() + sizeof(uint64_t) + // Type Signature
375
36
           sizeof(uint32_t);                               // Type DIE Offset
376
36
  }
377
  void addGlobalName(StringRef Name, const DIE &Die,
378
                     const DIScope *Context) override;
379
  void addGlobalType(const DIType *Ty, const DIE &Die,
380
                     const DIScope *Context) override;
381
152
  DwarfCompileUnit &getCU() override { return CU; }
382
};
383
} // end llvm namespace
384
#endif