Remove unused parameter
[oota-llvm.git] / lib / CodeGen / AsmPrinter / DwarfDebug.h
1 //===-- llvm/CodeGen/DwarfDebug.h - Dwarf Debug Framework ------*- C++ -*--===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for writing dwarf debug info into asm files.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H
15 #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H
16
17 #include "DwarfFile.h"
18 #include "AsmPrinterHandler.h"
19 #include "DIE.h"
20 #include "DbgValueHistoryCalculator.h"
21 #include "DebugLocEntry.h"
22 #include "DebugLocList.h"
23 #include "DwarfAccelTable.h"
24 #include "llvm/ADT/DenseMap.h"
25 #include "llvm/ADT/MapVector.h"
26 #include "llvm/ADT/SmallPtrSet.h"
27 #include "llvm/ADT/StringMap.h"
28 #include "llvm/ADT/FoldingSet.h"
29 #include "llvm/CodeGen/LexicalScopes.h"
30 #include "llvm/CodeGen/MachineInstr.h"
31 #include "llvm/IR/DebugInfo.h"
32 #include "llvm/IR/DebugLoc.h"
33 #include "llvm/MC/MachineLocation.h"
34 #include "llvm/MC/MCDwarf.h"
35 #include "llvm/Support/Allocator.h"
36
37 #include <memory>
38
39 namespace llvm {
40
41 class AsmPrinter;
42 class ByteStreamer;
43 class ConstantInt;
44 class ConstantFP;
45 class DwarfCompileUnit;
46 class DwarfDebug;
47 class DwarfTypeUnit;
48 class DwarfUnit;
49 class MachineModuleInfo;
50
51 //===----------------------------------------------------------------------===//
52 /// \brief This class is used to record source line correspondence.
53 class SrcLineInfo {
54   unsigned Line;     // Source line number.
55   unsigned Column;   // Source column.
56   unsigned SourceID; // Source ID number.
57   MCSymbol *Label;   // Label in code ID number.
58 public:
59   SrcLineInfo(unsigned L, unsigned C, unsigned S, MCSymbol *label)
60       : Line(L), Column(C), SourceID(S), Label(label) {}
61
62   // Accessors
63   unsigned getLine() const { return Line; }
64   unsigned getColumn() const { return Column; }
65   unsigned getSourceID() const { return SourceID; }
66   MCSymbol *getLabel() const { return Label; }
67 };
68
69 //===----------------------------------------------------------------------===//
70 /// \brief This class is used to track local variable information.
71 class DbgVariable {
72   DIVariable Var;             // Variable Descriptor.
73   DIExpression Expr;          // Complex address location expression.
74   DIE *TheDIE;                // Variable DIE.
75   unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
76   const MachineInstr *MInsn;  // DBG_VALUE instruction of the variable.
77   int FrameIndex;
78   DwarfDebug *DD;
79
80 public:
81   /// Construct a DbgVariable from a DIVariable.
82   DbgVariable(DIVariable V, DIExpression E, DwarfDebug *DD)
83       : Var(V), Expr(E), TheDIE(nullptr), DotDebugLocOffset(~0U),
84         MInsn(nullptr), FrameIndex(~0), DD(DD) {
85     assert(Var.Verify() && Expr.Verify());
86   }
87
88   /// Construct a DbgVariable from a DEBUG_VALUE.
89   /// AbstractVar may be NULL.
90   DbgVariable(const MachineInstr *DbgValue, DwarfDebug *DD)
91       : Var(DbgValue->getDebugVariable()), Expr(DbgValue->getDebugExpression()),
92         TheDIE(nullptr), DotDebugLocOffset(~0U), MInsn(DbgValue),
93         FrameIndex(~0), DD(DD) {}
94
95   // Accessors.
96   DIVariable getVariable() const { return Var; }
97   DIExpression getExpression() const { return Expr; }
98   void setDIE(DIE &D) { TheDIE = &D; }
99   DIE *getDIE() const { return TheDIE; }
100   void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
101   unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
102   StringRef getName() const { return Var.getName(); }
103   const MachineInstr *getMInsn() const { return MInsn; }
104   int getFrameIndex() const { return FrameIndex; }
105   void setFrameIndex(int FI) { FrameIndex = FI; }
106   // Translate tag to proper Dwarf tag.
107   dwarf::Tag getTag() const {
108     if (Var.getTag() == dwarf::DW_TAG_arg_variable)
109       return dwarf::DW_TAG_formal_parameter;
110
111     return dwarf::DW_TAG_variable;
112   }
113   /// \brief Return true if DbgVariable is artificial.
114   bool isArtificial() const {
115     if (Var.isArtificial())
116       return true;
117     if (getType().isArtificial())
118       return true;
119     return false;
120   }
121
122   bool isObjectPointer() const {
123     if (Var.isObjectPointer())
124       return true;
125     if (getType().isObjectPointer())
126       return true;
127     return false;
128   }
129
130   bool variableHasComplexAddress() const {
131     assert(Var.isVariable() && "Invalid complex DbgVariable!");
132     return Expr.getNumElements() > 0;
133   }
134   bool isBlockByrefVariable() const;
135   unsigned getNumAddrElements() const {
136     assert(Var.isVariable() && "Invalid complex DbgVariable!");
137     return Expr.getNumElements();
138   }
139   uint64_t getAddrElement(unsigned i) const { return Expr.getElement(i); }
140   DIType getType() const;
141
142 private:
143   /// resolve - Look in the DwarfDebug map for the MDNode that
144   /// corresponds to the reference.
145   template <typename T> T resolve(DIRef<T> Ref) const;
146 };
147
148
149 /// \brief Helper used to pair up a symbol and its DWARF compile unit.
150 struct SymbolCU {
151   SymbolCU(DwarfCompileUnit *CU, const MCSymbol *Sym) : Sym(Sym), CU(CU) {}
152   const MCSymbol *Sym;
153   DwarfCompileUnit *CU;
154 };
155
156 /// \brief Collects and handles dwarf debug information.
157 class DwarfDebug : public AsmPrinterHandler {
158   // Target of Dwarf emission.
159   AsmPrinter *Asm;
160
161   // Collected machine module information.
162   MachineModuleInfo *MMI;
163
164   // All DIEValues are allocated through this allocator.
165   BumpPtrAllocator DIEValueAllocator;
166
167   // Handle to the compile unit used for the inline extension handling,
168   // this is just so that the DIEValue allocator has a place to store
169   // the particular elements.
170   // FIXME: Store these off of DwarfDebug instead?
171   DwarfCompileUnit *FirstCU;
172
173   // Maps MDNode with its corresponding DwarfCompileUnit.
174   MapVector<const MDNode *, DwarfCompileUnit *> CUMap;
175
176   // Maps subprogram MDNode with its corresponding DwarfCompileUnit.
177   DenseMap<const MDNode *, DwarfCompileUnit *> SPMap;
178
179   // Maps a CU DIE with its corresponding DwarfCompileUnit.
180   DenseMap<const DIE *, DwarfCompileUnit *> CUDieMap;
181
182   /// Maps MDNodes for type system with the corresponding DIEs. These DIEs can
183   /// be shared across CUs, that is why we keep the map here instead
184   /// of in DwarfCompileUnit.
185   DenseMap<const MDNode *, DIE *> MDTypeNodeToDieMap;
186
187   // List of all labels used in aranges generation.
188   std::vector<SymbolCU> ArangeLabels;
189
190   // Size of each symbol emitted (for those symbols that have a specific size).
191   DenseMap<const MCSymbol *, uint64_t> SymSize;
192
193   // Provides a unique id per text section.
194   typedef DenseMap<const MCSection *, SmallVector<SymbolCU, 8> > SectionMapType;
195   SectionMapType SectionMap;
196
197   // List of arguments for current function.
198   SmallVector<DbgVariable *, 8> CurrentFnArguments;
199
200   LexicalScopes LScopes;
201
202   // Collection of abstract subprogram DIEs.
203   DenseMap<const MDNode *, DIE *> AbstractSPDies;
204
205   // Collection of dbg variables of a scope.
206   typedef DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >
207   ScopeVariablesMap;
208   ScopeVariablesMap ScopeVariables;
209
210   // Collection of abstract variables.
211   DenseMap<const MDNode *, std::unique_ptr<DbgVariable>> AbstractVariables;
212   SmallVector<std::unique_ptr<DbgVariable>, 64> ConcreteVariables;
213
214   // Collection of DebugLocEntry. Stored in a linked list so that DIELocLists
215   // can refer to them in spite of insertions into this list.
216   SmallVector<DebugLocList, 4> DotDebugLocEntries;
217
218   // This is a collection of subprogram MDNodes that are processed to
219   // create DIEs.
220   SmallPtrSet<const MDNode *, 16> ProcessedSPNodes;
221
222   // Maps instruction with label emitted before instruction.
223   DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn;
224
225   // Maps instruction with label emitted after instruction.
226   DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn;
227
228   // History of DBG_VALUE and clobber instructions for each user variable.
229   // Variables are listed in order of appearance.
230   DbgValueHistoryMap DbgValues;
231
232   // Previous instruction's location information. This is used to determine
233   // label location to indicate scope boundries in dwarf debug info.
234   DebugLoc PrevInstLoc;
235   MCSymbol *PrevLabel;
236
237   // This location indicates end of function prologue and beginning of function
238   // body.
239   DebugLoc PrologEndLoc;
240
241   // If nonnull, stores the current machine function we're processing.
242   const MachineFunction *CurFn;
243
244   // If nonnull, stores the current machine instruction we're processing.
245   const MachineInstr *CurMI;
246
247   // If nonnull, stores the CU in which the previous subprogram was contained.
248   const DwarfCompileUnit *PrevCU;
249
250   // Section Symbols: these are assembler temporary labels that are emitted at
251   // the beginning of each supported dwarf section.  These are used to form
252   // section offsets and are created by EmitSectionLabels.
253   MCSymbol *DwarfInfoSectionSym, *DwarfAbbrevSectionSym;
254   MCSymbol *DwarfStrSectionSym, *TextSectionSym, *DwarfDebugRangeSectionSym;
255   MCSymbol *DwarfDebugLocSectionSym, *DwarfLineSectionSym, *DwarfAddrSectionSym;
256   MCSymbol *FunctionBeginSym, *FunctionEndSym;
257   MCSymbol *DwarfInfoDWOSectionSym, *DwarfAbbrevDWOSectionSym;
258   MCSymbol *DwarfTypesDWOSectionSym;
259   MCSymbol *DwarfStrDWOSectionSym;
260   MCSymbol *DwarfGnuPubNamesSectionSym, *DwarfGnuPubTypesSectionSym;
261
262   // As an optimization, there is no need to emit an entry in the directory
263   // table for the same directory as DW_AT_comp_dir.
264   StringRef CompilationDir;
265
266   // Counter for assigning globally unique IDs for ranges.
267   unsigned GlobalRangeCount;
268
269   // Holder for the file specific debug information.
270   DwarfFile InfoHolder;
271
272   // Holders for the various debug information flags that we might need to
273   // have exposed. See accessor functions below for description.
274
275   // Holder for imported entities.
276   typedef SmallVector<std::pair<const MDNode *, const MDNode *>, 32>
277   ImportedEntityMap;
278   ImportedEntityMap ScopesWithImportedEntities;
279
280   // Map from MDNodes for user-defined types to the type units that describe
281   // them.
282   DenseMap<const MDNode *, const DwarfTypeUnit *> DwarfTypeUnits;
283
284   SmallVector<std::pair<std::unique_ptr<DwarfTypeUnit>, DICompositeType>, 1> TypeUnitsUnderConstruction;
285
286   // Whether to emit the pubnames/pubtypes sections.
287   bool HasDwarfPubSections;
288
289   // Whether or not to use AT_ranges for compilation units.
290   bool HasCURanges;
291
292   // Whether we emitted a function into a section other than the default
293   // text.
294   bool UsedNonDefaultText;
295
296   // Version of dwarf we're emitting.
297   unsigned DwarfVersion;
298
299   // Maps from a type identifier to the actual MDNode.
300   DITypeIdentifierMap TypeIdentifierMap;
301
302   // DWARF5 Experimental Options
303   bool HasDwarfAccelTables;
304   bool HasSplitDwarf;
305
306   // Separated Dwarf Variables
307   // In general these will all be for bits that are left in the
308   // original object file, rather than things that are meant
309   // to be in the .dwo sections.
310
311   // Holder for the skeleton information.
312   DwarfFile SkeletonHolder;
313
314   /// Store file names for type units under fission in a line table header that
315   /// will be emitted into debug_line.dwo.
316   // FIXME: replace this with a map from comp_dir to table so that we can emit
317   // multiple tables during LTO each of which uses directory 0, referencing the
318   // comp_dir of all the type units that use it.
319   MCDwarfDwoLineTable SplitTypeUnitFileTable;
320
321   // True iff there are multiple CUs in this module.
322   bool SingleCU;
323   bool IsDarwin;
324
325   AddressPool AddrPool;
326
327   DwarfAccelTable AccelNames;
328   DwarfAccelTable AccelObjC;
329   DwarfAccelTable AccelNamespace;
330   DwarfAccelTable AccelTypes;
331
332   DenseMap<const Function *, DISubprogram> FunctionDIs;
333
334   MCDwarfDwoLineTable *getDwoLineTable(const DwarfCompileUnit &);
335
336   void addScopeVariable(LexicalScope *LS, DbgVariable *Var);
337
338   const SmallVectorImpl<std::unique_ptr<DwarfUnit>> &getUnits() {
339     return InfoHolder.getUnits();
340   }
341
342   /// \brief Find abstract variable associated with Var.
343   DbgVariable *getExistingAbstractVariable(const DIVariable &DV,
344                                            DIVariable &Cleansed);
345   DbgVariable *getExistingAbstractVariable(const DIVariable &DV);
346   void createAbstractVariable(const DIVariable &DV, LexicalScope *Scope);
347   void ensureAbstractVariableIsCreated(const DIVariable &Var,
348                                        const MDNode *Scope);
349   void ensureAbstractVariableIsCreatedIfScoped(const DIVariable &Var,
350                                                const MDNode *Scope);
351
352   /// \brief Construct a DIE for this abstract scope.
353   void constructAbstractSubprogramScopeDIE(LexicalScope *Scope);
354
355   /// \brief Emit initial Dwarf sections with a label at the start of each one.
356   void emitSectionLabels();
357
358   /// \brief Compute the size and offset of a DIE given an incoming Offset.
359   unsigned computeSizeAndOffset(DIE *Die, unsigned Offset);
360
361   /// \brief Compute the size and offset of all the DIEs.
362   void computeSizeAndOffsets();
363
364   /// \brief Collect info for variables that were optimized out.
365   void collectDeadVariables();
366
367   void finishVariableDefinitions();
368
369   void finishSubprogramDefinitions();
370
371   /// \brief Finish off debug information after all functions have been
372   /// processed.
373   void finalizeModuleInfo();
374
375   /// \brief Emit labels to close any remaining sections that have been left
376   /// open.
377   void endSections();
378
379   /// \brief Emit the debug info section.
380   void emitDebugInfo();
381
382   /// \brief Emit the abbreviation section.
383   void emitAbbreviations();
384
385   /// \brief Emit the last address of the section and the end of
386   /// the line matrix.
387   void emitEndOfLineMatrix(unsigned SectionEnd);
388
389   /// \brief Emit a specified accelerator table.
390   void emitAccel(DwarfAccelTable &Accel, const MCSection *Section,
391                  StringRef TableName, StringRef SymName);
392
393   /// \brief Emit visible names into a hashed accelerator table section.
394   void emitAccelNames();
395
396   /// \brief Emit objective C classes and categories into a hashed
397   /// accelerator table section.
398   void emitAccelObjC();
399
400   /// \brief Emit namespace dies into a hashed accelerator table.
401   void emitAccelNamespaces();
402
403   /// \brief Emit type dies into a hashed accelerator table.
404   void emitAccelTypes();
405
406   /// \brief Emit visible names into a debug pubnames section.
407   /// \param GnuStyle determines whether or not we want to emit
408   /// additional information into the table ala newer gcc for gdb
409   /// index.
410   void emitDebugPubNames(bool GnuStyle = false);
411
412   /// \brief Emit visible types into a debug pubtypes section.
413   /// \param GnuStyle determines whether or not we want to emit
414   /// additional information into the table ala newer gcc for gdb
415   /// index.
416   void emitDebugPubTypes(bool GnuStyle = false);
417
418   void
419   emitDebugPubSection(bool GnuStyle, const MCSection *PSec, StringRef Name,
420                       const StringMap<const DIE *> &(DwarfUnit::*Accessor)()
421                       const);
422
423   /// \brief Emit visible names into a debug str section.
424   void emitDebugStr();
425
426   /// \brief Emit visible names into a debug loc section.
427   void emitDebugLoc();
428
429   /// \brief Emit visible names into a debug loc dwo section.
430   void emitDebugLocDWO();
431
432   /// \brief Emit visible names into a debug aranges section.
433   void emitDebugARanges();
434
435   /// \brief Emit visible names into a debug ranges section.
436   void emitDebugRanges();
437
438   /// \brief Emit inline info using custom format.
439   void emitDebugInlineInfo();
440
441   /// DWARF 5 Experimental Split Dwarf Emitters
442
443   /// \brief Initialize common features of skeleton units.
444   void initSkeletonUnit(const DwarfUnit &U, DIE &Die,
445                         std::unique_ptr<DwarfUnit> NewU);
446
447   /// \brief Construct the split debug info compile unit for the debug info
448   /// section.
449   DwarfCompileUnit &constructSkeletonCU(const DwarfCompileUnit &CU);
450
451   /// \brief Construct the split debug info compile unit for the debug info
452   /// section.
453   DwarfTypeUnit &constructSkeletonTU(DwarfTypeUnit &TU);
454
455   /// \brief Emit the debug info dwo section.
456   void emitDebugInfoDWO();
457
458   /// \brief Emit the debug abbrev dwo section.
459   void emitDebugAbbrevDWO();
460
461   /// \brief Emit the debug line dwo section.
462   void emitDebugLineDWO();
463
464   /// \brief Emit the debug str dwo section.
465   void emitDebugStrDWO();
466
467   /// Flags to let the linker know we have emitted new style pubnames. Only
468   /// emit it here if we don't have a skeleton CU for split dwarf.
469   void addGnuPubAttributes(DwarfUnit &U, DIE &D) const;
470
471   /// \brief Create new DwarfCompileUnit for the given metadata node with tag
472   /// DW_TAG_compile_unit.
473   DwarfCompileUnit &constructDwarfCompileUnit(DICompileUnit DIUnit);
474
475   /// \brief Construct imported_module or imported_declaration DIE.
476   void constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
477                                         const MDNode *N);
478
479   /// \brief Register a source line with debug info. Returns the unique
480   /// label that was emitted and which provides correspondence to the
481   /// source line list.
482   void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope,
483                         unsigned Flags);
484
485   /// \brief Indentify instructions that are marking the beginning of or
486   /// ending of a scope.
487   void identifyScopeMarkers();
488
489   /// \brief If Var is an current function argument that add it in
490   /// CurrentFnArguments list.
491   bool addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope);
492
493   /// \brief Populate LexicalScope entries with variables' info.
494   void collectVariableInfo(SmallPtrSetImpl<const MDNode *> &ProcessedVars);
495
496   /// \brief Build the location list for all DBG_VALUEs in the
497   /// function that describe the same variable.
498   void buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
499                          const DbgValueHistoryMap::InstrRanges &Ranges);
500
501   /// \brief Collect variable information from the side table maintained
502   /// by MMI.
503   void collectVariableInfoFromMMITable(SmallPtrSetImpl<const MDNode *> &P);
504
505   /// \brief Ensure that a label will be emitted before MI.
506   void requestLabelBeforeInsn(const MachineInstr *MI) {
507     LabelsBeforeInsn.insert(std::make_pair(MI, nullptr));
508   }
509
510   /// \brief Ensure that a label will be emitted after MI.
511   void requestLabelAfterInsn(const MachineInstr *MI) {
512     LabelsAfterInsn.insert(std::make_pair(MI, nullptr));
513   }
514
515 public:
516   //===--------------------------------------------------------------------===//
517   // Main entry points.
518   //
519   DwarfDebug(AsmPrinter *A, Module *M);
520
521   ~DwarfDebug() override;
522
523   void insertDIE(const MDNode *TypeMD, DIE *Die) {
524     MDTypeNodeToDieMap.insert(std::make_pair(TypeMD, Die));
525   }
526   DIE *getDIE(const MDNode *TypeMD) {
527     return MDTypeNodeToDieMap.lookup(TypeMD);
528   }
529
530   /// \brief Emit all Dwarf sections that should come prior to the
531   /// content.
532   void beginModule();
533
534   /// \brief Emit all Dwarf sections that should come after the content.
535   void endModule() override;
536
537   /// \brief Gather pre-function debug information.
538   void beginFunction(const MachineFunction *MF) override;
539
540   /// \brief Gather and emit post-function debug information.
541   void endFunction(const MachineFunction *MF) override;
542
543   /// \brief Process beginning of an instruction.
544   void beginInstruction(const MachineInstr *MI) override;
545
546   /// \brief Process end of an instruction.
547   void endInstruction() override;
548
549   /// \brief Add a DIE to the set of types that we're going to pull into
550   /// type units.
551   void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier,
552                             DIE &Die, DICompositeType CTy);
553
554   /// \brief Add a label so that arange data can be generated for it.
555   void addArangeLabel(SymbolCU SCU) { ArangeLabels.push_back(SCU); }
556
557   /// \brief For symbols that have a size designated (e.g. common symbols),
558   /// this tracks that size.
559   void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {
560     SymSize[Sym] = Size;
561   }
562
563   /// \brief Recursively Emits a debug information entry.
564   void emitDIE(DIE &Die);
565
566   // Experimental DWARF5 features.
567
568   /// \brief Returns whether or not to emit tables that dwarf consumers can
569   /// use to accelerate lookup.
570   bool useDwarfAccelTables() const { return HasDwarfAccelTables; }
571
572   /// \brief Returns whether or not to change the current debug info for the
573   /// split dwarf proposal support.
574   bool useSplitDwarf() const { return HasSplitDwarf; }
575
576   /// Returns the Dwarf Version.
577   unsigned getDwarfVersion() const { return DwarfVersion; }
578
579   /// Returns the section symbol for the .debug_loc section.
580   MCSymbol *getDebugLocSym() const { return DwarfDebugLocSectionSym; }
581
582   /// Returns the section symbol for the .debug_str section.
583   MCSymbol *getDebugStrSym() const { return DwarfStrSectionSym; }
584
585   /// Returns the section symbol for the .debug_ranges section.
586   MCSymbol *getRangeSectionSym() const { return DwarfDebugRangeSectionSym; }
587
588   /// Returns the previous CU that was being updated
589   const DwarfCompileUnit *getPrevCU() const { return PrevCU; }
590   void setPrevCU(const DwarfCompileUnit *PrevCU) { this->PrevCU = PrevCU; }
591
592   /// Returns the entries for the .debug_loc section.
593   const SmallVectorImpl<DebugLocList> &
594   getDebugLocEntries() const {
595     return DotDebugLocEntries;
596   }
597
598   /// \brief Emit an entry for the debug loc section. This can be used to
599   /// handle an entry that's going to be emitted into the debug loc section.
600   void emitDebugLocEntry(ByteStreamer &Streamer, const DebugLocEntry &Entry);
601   /// \brief emit a single value for the debug loc section.
602   void emitDebugLocValue(ByteStreamer &Streamer,
603                          const DebugLocEntry::Value &Value);
604   /// Emits an optimal (=sorted) sequence of DW_OP_pieces.
605   void emitLocPieces(ByteStreamer &Streamer,
606                      const DITypeIdentifierMap &Map,
607                      ArrayRef<DebugLocEntry::Value> Values);
608
609   /// Emit the location for a debug loc entry, including the size header.
610   void emitDebugLocEntryLocation(const DebugLocEntry &Entry);
611
612   /// Find the MDNode for the given reference.
613   template <typename T> T resolve(DIRef<T> Ref) const {
614     return Ref.resolve(TypeIdentifierMap);
615   }
616
617   /// \brief Return the TypeIdentifierMap.
618   const DITypeIdentifierMap &getTypeIdentifierMap() const {
619     return TypeIdentifierMap;
620   }
621
622   /// Find the DwarfCompileUnit for the given CU Die.
623   DwarfCompileUnit *lookupUnit(const DIE *CU) const {
624     return CUDieMap.lookup(CU);
625   }
626   /// isSubprogramContext - Return true if Context is either a subprogram
627   /// or another context nested inside a subprogram.
628   bool isSubprogramContext(const MDNode *Context);
629
630   void addSubprogramNames(DISubprogram SP, DIE &Die);
631
632   AddressPool &getAddressPool() { return AddrPool; }
633
634   void addAccelName(StringRef Name, const DIE &Die);
635
636   void addAccelObjC(StringRef Name, const DIE &Die);
637
638   void addAccelNamespace(StringRef Name, const DIE &Die);
639
640   void addAccelType(StringRef Name, const DIE &Die, char Flags);
641
642   const MachineFunction *getCurrentFunction() const { return CurFn; }
643   const MCSymbol *getFunctionBeginSym() const { return FunctionBeginSym; }
644   const MCSymbol *getFunctionEndSym() const { return FunctionEndSym; }
645
646   iterator_range<ImportedEntityMap::const_iterator>
647   findImportedEntitiesForScope(const MDNode *Scope) const {
648     return make_range(std::equal_range(
649         ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
650         std::pair<const MDNode *, const MDNode *>(Scope, nullptr),
651         less_first()));
652   }
653
654   /// \brief A helper function to check whether the DIE for a given Scope is
655   /// going to be null.
656   bool isLexicalScopeDIENull(LexicalScope *Scope);
657
658   /// \brief Return Label preceding the instruction.
659   MCSymbol *getLabelBeforeInsn(const MachineInstr *MI);
660
661   /// \brief Return Label immediately following the instruction.
662   MCSymbol *getLabelAfterInsn(const MachineInstr *MI);
663
664   // FIXME: Consider rolling ranges up into DwarfDebug since we use a single
665   // range_base anyway, so there's no need to keep them as separate per-CU range
666   // lists. (though one day we might end up with a range.dwo section, in which
667   // case it'd go to DwarfFile)
668   unsigned getNextRangeNumber() { return GlobalRangeCount++; }
669
670   // FIXME: Sink these functions down into DwarfFile/Dwarf*Unit.
671
672   DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
673     return AbstractSPDies;
674   }
675
676   ScopeVariablesMap &getScopeVariables() { return ScopeVariables; }
677
678   SmallPtrSet<const MDNode *, 16> &getProcessedSPNodes() {
679     return ProcessedSPNodes;
680   }
681
682   SmallVector<DbgVariable *, 8> &getCurrentFnArguments() {
683     return CurrentFnArguments;
684   }
685 };
686 } // End of namespace llvm
687
688 #endif