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