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