File: | include/llvm/CodeGen/DIE.h |
Warning: | line 641, column 5 Forming reference to null pointer |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Units ------------===// | |||
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 constructing a dwarf compile unit. | |||
11 | // | |||
12 | //===----------------------------------------------------------------------===// | |||
13 | ||||
14 | #include "DwarfCompileUnit.h" | |||
15 | #include "AddressPool.h" | |||
16 | #include "DwarfDebug.h" | |||
17 | #include "DwarfExpression.h" | |||
18 | #include "DwarfUnit.h" | |||
19 | #include "llvm/ADT/None.h" | |||
20 | #include "llvm/ADT/STLExtras.h" | |||
21 | #include "llvm/ADT/SmallVector.h" | |||
22 | #include "llvm/ADT/StringRef.h" | |||
23 | #include "llvm/BinaryFormat/Dwarf.h" | |||
24 | #include "llvm/CodeGen/AsmPrinter.h" | |||
25 | #include "llvm/CodeGen/DIE.h" | |||
26 | #include "llvm/CodeGen/LexicalScopes.h" | |||
27 | #include "llvm/CodeGen/MachineFunction.h" | |||
28 | #include "llvm/CodeGen/MachineInstr.h" | |||
29 | #include "llvm/CodeGen/MachineOperand.h" | |||
30 | #include "llvm/CodeGen/TargetFrameLowering.h" | |||
31 | #include "llvm/CodeGen/TargetRegisterInfo.h" | |||
32 | #include "llvm/CodeGen/TargetSubtargetInfo.h" | |||
33 | #include "llvm/IR/DataLayout.h" | |||
34 | #include "llvm/IR/DebugInfo.h" | |||
35 | #include "llvm/IR/DebugInfoMetadata.h" | |||
36 | #include "llvm/IR/GlobalVariable.h" | |||
37 | #include "llvm/MC/MCSection.h" | |||
38 | #include "llvm/MC/MCStreamer.h" | |||
39 | #include "llvm/MC/MCSymbol.h" | |||
40 | #include "llvm/MC/MachineLocation.h" | |||
41 | #include "llvm/Support/Casting.h" | |||
42 | #include "llvm/Target/TargetLoweringObjectFile.h" | |||
43 | #include "llvm/Target/TargetMachine.h" | |||
44 | #include "llvm/Target/TargetOptions.h" | |||
45 | #include <algorithm> | |||
46 | #include <cassert> | |||
47 | #include <cstdint> | |||
48 | #include <iterator> | |||
49 | #include <memory> | |||
50 | #include <string> | |||
51 | #include <utility> | |||
52 | ||||
53 | using namespace llvm; | |||
54 | ||||
55 | DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, | |||
56 | AsmPrinter *A, DwarfDebug *DW, | |||
57 | DwarfFile *DWU) | |||
58 | : DwarfUnit(dwarf::DW_TAG_compile_unit, Node, A, DW, DWU), UniqueID(UID) { | |||
59 | insertDIE(Node, &getUnitDie()); | |||
60 | MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin"); | |||
61 | } | |||
62 | ||||
63 | /// addLabelAddress - Add a dwarf label attribute data and value using | |||
64 | /// DW_FORM_addr or DW_FORM_GNU_addr_index. | |||
65 | void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute, | |||
66 | const MCSymbol *Label) { | |||
67 | // Don't use the address pool in non-fission or in the skeleton unit itself. | |||
68 | // FIXME: Once GDB supports this, it's probably worthwhile using the address | |||
69 | // pool from the skeleton - maybe even in non-fission (possibly fewer | |||
70 | // relocations by sharing them in the pool, but we have other ideas about how | |||
71 | // to reduce the number of relocations as well/instead). | |||
72 | if ((!DD->useSplitDwarf() || !Skeleton) && DD->getDwarfVersion() < 5) | |||
73 | return addLocalLabelAddress(Die, Attribute, Label); | |||
74 | ||||
75 | if (Label) | |||
76 | DD->addArangeLabel(SymbolCU(this, Label)); | |||
77 | ||||
78 | unsigned idx = DD->getAddressPool().getIndex(Label); | |||
79 | Die.addValue(DIEValueAllocator, Attribute, | |||
80 | DD->getDwarfVersion() >= 5 ? dwarf::DW_FORM_addrx | |||
81 | : dwarf::DW_FORM_GNU_addr_index, | |||
82 | DIEInteger(idx)); | |||
83 | } | |||
84 | ||||
85 | void DwarfCompileUnit::addLocalLabelAddress(DIE &Die, | |||
86 | dwarf::Attribute Attribute, | |||
87 | const MCSymbol *Label) { | |||
88 | if (Label) | |||
89 | DD->addArangeLabel(SymbolCU(this, Label)); | |||
90 | ||||
91 | if (Label) | |||
92 | Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr, | |||
93 | DIELabel(Label)); | |||
94 | else | |||
95 | Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr, | |||
96 | DIEInteger(0)); | |||
97 | } | |||
98 | ||||
99 | unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) { | |||
100 | // If we print assembly, we can't separate .file entries according to | |||
101 | // compile units. Thus all files will belong to the default compile unit. | |||
102 | ||||
103 | // FIXME: add a better feature test than hasRawTextSupport. Even better, | |||
104 | // extend .file to support this. | |||
105 | unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID(); | |||
106 | if (!File) | |||
107 | return Asm->OutStreamer->EmitDwarfFileDirective(0, "", "", nullptr, None, CUID); | |||
108 | return Asm->OutStreamer->EmitDwarfFileDirective( | |||
109 | 0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File), | |||
110 | File->getSource(), CUID); | |||
111 | } | |||
112 | ||||
113 | DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE( | |||
114 | const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) { | |||
115 | // Check for pre-existence. | |||
116 | if (DIE *Die = getDIE(GV)) | |||
117 | return Die; | |||
118 | ||||
119 | assert(GV)((GV) ? static_cast<void> (0) : __assert_fail ("GV", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 119, __PRETTY_FUNCTION__)); | |||
120 | ||||
121 | auto *GVContext = GV->getScope(); | |||
122 | auto *GTy = DD->resolve(GV->getType()); | |||
123 | ||||
124 | // Construct the context before querying for the existence of the DIE in | |||
125 | // case such construction creates the DIE. | |||
126 | DIE *ContextDIE = getOrCreateContextDIE(GVContext); | |||
127 | ||||
128 | // Add to map. | |||
129 | DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV); | |||
130 | DIScope *DeclContext; | |||
131 | if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) { | |||
132 | DeclContext = resolve(SDMDecl->getScope()); | |||
133 | assert(SDMDecl->isStaticMember() && "Expected static member decl")((SDMDecl->isStaticMember() && "Expected static member decl" ) ? static_cast<void> (0) : __assert_fail ("SDMDecl->isStaticMember() && \"Expected static member decl\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 133, __PRETTY_FUNCTION__)); | |||
134 | assert(GV->isDefinition())((GV->isDefinition()) ? static_cast<void> (0) : __assert_fail ("GV->isDefinition()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 134, __PRETTY_FUNCTION__)); | |||
135 | // We need the declaration DIE that is in the static member's class. | |||
136 | DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl); | |||
137 | addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE); | |||
138 | // If the global variable's type is different from the one in the class | |||
139 | // member type, assume that it's more specific and also emit it. | |||
140 | if (GTy != DD->resolve(SDMDecl->getBaseType())) | |||
141 | addType(*VariableDIE, GTy); | |||
142 | } else { | |||
143 | DeclContext = GV->getScope(); | |||
144 | // Add name and type. | |||
145 | addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName()); | |||
146 | addType(*VariableDIE, GTy); | |||
147 | ||||
148 | // Add scoping info. | |||
149 | if (!GV->isLocalToUnit()) | |||
150 | addFlag(*VariableDIE, dwarf::DW_AT_external); | |||
151 | ||||
152 | // Add line number info. | |||
153 | addSourceLine(*VariableDIE, GV); | |||
154 | } | |||
155 | ||||
156 | if (!GV->isDefinition()) | |||
157 | addFlag(*VariableDIE, dwarf::DW_AT_declaration); | |||
158 | else | |||
159 | addGlobalName(GV->getName(), *VariableDIE, DeclContext); | |||
160 | ||||
161 | if (uint32_t AlignInBytes = GV->getAlignInBytes()) | |||
162 | addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, | |||
163 | AlignInBytes); | |||
164 | ||||
165 | if (MDTuple *TP = GV->getTemplateParams()) | |||
166 | addTemplateParams(*VariableDIE, DINodeArray(TP)); | |||
167 | ||||
168 | // Add location. | |||
169 | bool addToAccelTable = false; | |||
170 | DIELoc *Loc = nullptr; | |||
171 | std::unique_ptr<DIEDwarfExpression> DwarfExpr; | |||
172 | for (const auto &GE : GlobalExprs) { | |||
173 | const GlobalVariable *Global = GE.Var; | |||
174 | const DIExpression *Expr = GE.Expr; | |||
175 | ||||
176 | // For compatibility with DWARF 3 and earlier, | |||
177 | // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes | |||
178 | // DW_AT_const_value(X). | |||
179 | if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) { | |||
180 | addToAccelTable = true; | |||
181 | addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1)); | |||
182 | break; | |||
183 | } | |||
184 | ||||
185 | // We cannot describe the location of dllimport'd variables: the | |||
186 | // computation of their address requires loads from the IAT. | |||
187 | if (Global && Global->hasDLLImportStorageClass()) | |||
188 | continue; | |||
189 | ||||
190 | // Nothing to describe without address or constant. | |||
191 | if (!Global && (!Expr || !Expr->isConstant())) | |||
192 | continue; | |||
193 | ||||
194 | if (Global && Global->isThreadLocal() && | |||
195 | !Asm->getObjFileLowering().supportDebugThreadLocalLocation()) | |||
196 | continue; | |||
197 | ||||
198 | if (!Loc) { | |||
199 | addToAccelTable = true; | |||
200 | Loc = new (DIEValueAllocator) DIELoc; | |||
201 | DwarfExpr = llvm::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc); | |||
202 | } | |||
203 | ||||
204 | if (Expr) | |||
205 | DwarfExpr->addFragmentOffset(Expr); | |||
206 | ||||
207 | if (Global) { | |||
208 | const MCSymbol *Sym = Asm->getSymbol(Global); | |||
209 | if (Global->isThreadLocal()) { | |||
210 | if (Asm->TM.useEmulatedTLS()) { | |||
211 | // TODO: add debug info for emulated thread local mode. | |||
212 | } else { | |||
213 | // FIXME: Make this work with -gsplit-dwarf. | |||
214 | unsigned PointerSize = Asm->getDataLayout().getPointerSize(); | |||
215 | assert((PointerSize == 4 || PointerSize == 8) &&(((PointerSize == 4 || PointerSize == 8) && "Add support for other sizes if necessary" ) ? static_cast<void> (0) : __assert_fail ("(PointerSize == 4 || PointerSize == 8) && \"Add support for other sizes if necessary\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 216, __PRETTY_FUNCTION__)) | |||
216 | "Add support for other sizes if necessary")(((PointerSize == 4 || PointerSize == 8) && "Add support for other sizes if necessary" ) ? static_cast<void> (0) : __assert_fail ("(PointerSize == 4 || PointerSize == 8) && \"Add support for other sizes if necessary\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 216, __PRETTY_FUNCTION__)); | |||
217 | // Based on GCC's support for TLS: | |||
218 | if (!DD->useSplitDwarf()) { | |||
219 | // 1) Start with a constNu of the appropriate pointer size | |||
220 | addUInt(*Loc, dwarf::DW_FORM_data1, | |||
221 | PointerSize == 4 ? dwarf::DW_OP_const4u | |||
222 | : dwarf::DW_OP_const8u); | |||
223 | // 2) containing the (relocated) offset of the TLS variable | |||
224 | // within the module's TLS block. | |||
225 | addExpr(*Loc, dwarf::DW_FORM_udata, | |||
226 | Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym)); | |||
227 | } else { | |||
228 | addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index); | |||
229 | addUInt(*Loc, dwarf::DW_FORM_udata, | |||
230 | DD->getAddressPool().getIndex(Sym, /* TLS */ true)); | |||
231 | } | |||
232 | // 3) followed by an OP to make the debugger do a TLS lookup. | |||
233 | addUInt(*Loc, dwarf::DW_FORM_data1, | |||
234 | DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address | |||
235 | : dwarf::DW_OP_form_tls_address); | |||
236 | } | |||
237 | } else { | |||
238 | DD->addArangeLabel(SymbolCU(this, Sym)); | |||
239 | addOpAddress(*Loc, Sym); | |||
240 | } | |||
241 | } | |||
242 | // Global variables attached to symbols are memory locations. | |||
243 | // It would be better if this were unconditional, but malformed input that | |||
244 | // mixes non-fragments and fragments for the same variable is too expensive | |||
245 | // to detect in the verifier. | |||
246 | if (DwarfExpr->isUnknownLocation()) | |||
247 | DwarfExpr->setMemoryLocationKind(); | |||
248 | DwarfExpr->addExpression(Expr); | |||
249 | } | |||
250 | if (Loc) | |||
251 | addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize()); | |||
252 | ||||
253 | if (DD->useAllLinkageNames()) | |||
254 | addLinkageName(*VariableDIE, GV->getLinkageName()); | |||
255 | ||||
256 | if (addToAccelTable) { | |||
257 | DD->addAccelName(*CUNode, GV->getName(), *VariableDIE); | |||
258 | ||||
259 | // If the linkage name is different than the name, go ahead and output | |||
260 | // that as well into the name table. | |||
261 | if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() && | |||
262 | DD->useAllLinkageNames()) | |||
263 | DD->addAccelName(*CUNode, GV->getLinkageName(), *VariableDIE); | |||
264 | } | |||
265 | ||||
266 | return VariableDIE; | |||
267 | } | |||
268 | ||||
269 | void DwarfCompileUnit::addRange(RangeSpan Range) { | |||
270 | bool SameAsPrevCU = this == DD->getPrevCU(); | |||
271 | DD->setPrevCU(this); | |||
272 | // If we have no current ranges just add the range and return, otherwise, | |||
273 | // check the current section and CU against the previous section and CU we | |||
274 | // emitted into and the subprogram was contained within. If these are the | |||
275 | // same then extend our current range, otherwise add this as a new range. | |||
276 | if (CURanges.empty() || !SameAsPrevCU || | |||
277 | (&CURanges.back().getEnd()->getSection() != | |||
278 | &Range.getEnd()->getSection())) { | |||
279 | CURanges.push_back(Range); | |||
280 | DD->addSectionLabel(Range.getStart()); | |||
281 | return; | |||
282 | } | |||
283 | ||||
284 | CURanges.back().setEnd(Range.getEnd()); | |||
285 | } | |||
286 | ||||
287 | void DwarfCompileUnit::initStmtList() { | |||
288 | if (CUNode->isDebugDirectivesOnly()) | |||
289 | return; | |||
290 | ||||
291 | // Define start line table label for each Compile Unit. | |||
292 | MCSymbol *LineTableStartSym; | |||
293 | const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); | |||
294 | if (DD->useSectionsAsReferences()) { | |||
295 | LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol(); | |||
296 | } else { | |||
297 | LineTableStartSym = | |||
298 | Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID()); | |||
299 | } | |||
300 | ||||
301 | // DW_AT_stmt_list is a offset of line number information for this | |||
302 | // compile unit in debug_line section. For split dwarf this is | |||
303 | // left in the skeleton CU and so not included. | |||
304 | // The line table entries are not always emitted in assembly, so it | |||
305 | // is not okay to use line_table_start here. | |||
306 | StmtListValue = | |||
307 | addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym, | |||
308 | TLOF.getDwarfLineSection()->getBeginSymbol()); | |||
309 | } | |||
310 | ||||
311 | void DwarfCompileUnit::applyStmtList(DIE &D) { | |||
312 | D.addValue(DIEValueAllocator, *StmtListValue); | |||
313 | } | |||
314 | ||||
315 | void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin, | |||
316 | const MCSymbol *End) { | |||
317 | assert(Begin && "Begin label should not be null!")((Begin && "Begin label should not be null!") ? static_cast <void> (0) : __assert_fail ("Begin && \"Begin label should not be null!\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 317, __PRETTY_FUNCTION__)); | |||
318 | assert(End && "End label should not be null!")((End && "End label should not be null!") ? static_cast <void> (0) : __assert_fail ("End && \"End label should not be null!\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 318, __PRETTY_FUNCTION__)); | |||
319 | assert(Begin->isDefined() && "Invalid starting label")((Begin->isDefined() && "Invalid starting label") ? static_cast<void> (0) : __assert_fail ("Begin->isDefined() && \"Invalid starting label\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 319, __PRETTY_FUNCTION__)); | |||
320 | assert(End->isDefined() && "Invalid end label")((End->isDefined() && "Invalid end label") ? static_cast <void> (0) : __assert_fail ("End->isDefined() && \"Invalid end label\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 320, __PRETTY_FUNCTION__)); | |||
321 | ||||
322 | addLabelAddress(D, dwarf::DW_AT_low_pc, Begin); | |||
323 | if (DD->getDwarfVersion() < 4) | |||
324 | addLabelAddress(D, dwarf::DW_AT_high_pc, End); | |||
325 | else | |||
326 | addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin); | |||
327 | } | |||
328 | ||||
329 | // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc | |||
330 | // and DW_AT_high_pc attributes. If there are global variables in this | |||
331 | // scope then create and insert DIEs for these variables. | |||
332 | DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) { | |||
333 | DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes()); | |||
334 | ||||
335 | attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd()); | |||
336 | if (DD->useAppleExtensionAttributes() && | |||
337 | !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim( | |||
338 | *DD->getCurrentFunction())) | |||
339 | addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr); | |||
340 | ||||
341 | // Only include DW_AT_frame_base in full debug info | |||
342 | if (!includeMinimalInlineScopes()) { | |||
343 | if (Asm->MF->getTarget().getTargetTriple().isNVPTX()) { | |||
344 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; | |||
345 | addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa); | |||
346 | addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc); | |||
347 | } else { | |||
348 | const TargetRegisterInfo *RI = Asm->MF->getSubtarget().getRegisterInfo(); | |||
349 | MachineLocation Location(RI->getFrameRegister(*Asm->MF)); | |||
350 | if (RI->isPhysicalRegister(Location.getReg())) | |||
351 | addAddress(*SPDie, dwarf::DW_AT_frame_base, Location); | |||
352 | } | |||
353 | } | |||
354 | ||||
355 | // Add name to the name table, we do this here because we're guaranteed | |||
356 | // to have concrete versions of our DW_TAG_subprogram nodes. | |||
357 | DD->addSubprogramNames(*CUNode, SP, *SPDie); | |||
358 | ||||
359 | return *SPDie; | |||
360 | } | |||
361 | ||||
362 | // Construct a DIE for this scope. | |||
363 | void DwarfCompileUnit::constructScopeDIE( | |||
364 | LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) { | |||
365 | if (!Scope || !Scope->getScopeNode()) | |||
366 | return; | |||
367 | ||||
368 | auto *DS = Scope->getScopeNode(); | |||
369 | ||||
370 | assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&(((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined " "subprograms") ? static_cast<void> (0) : __assert_fail ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 373, __PRETTY_FUNCTION__)) | |||
371 | "Only handle inlined subprograms here, use "(((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined " "subprograms") ? static_cast<void> (0) : __assert_fail ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 373, __PRETTY_FUNCTION__)) | |||
372 | "constructSubprogramScopeDIE for non-inlined "(((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined " "subprograms") ? static_cast<void> (0) : __assert_fail ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 373, __PRETTY_FUNCTION__)) | |||
373 | "subprograms")(((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined " "subprograms") ? static_cast<void> (0) : __assert_fail ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 373, __PRETTY_FUNCTION__)); | |||
374 | ||||
375 | SmallVector<DIE *, 8> Children; | |||
376 | ||||
377 | // We try to create the scope DIE first, then the children DIEs. This will | |||
378 | // avoid creating un-used children then removing them later when we find out | |||
379 | // the scope DIE is null. | |||
380 | DIE *ScopeDIE; | |||
381 | if (Scope->getParent() && isa<DISubprogram>(DS)) { | |||
382 | ScopeDIE = constructInlinedScopeDIE(Scope); | |||
383 | if (!ScopeDIE) | |||
384 | return; | |||
385 | // We create children when the scope DIE is not null. | |||
386 | createScopeChildrenDIE(Scope, Children); | |||
387 | } else { | |||
388 | // Early exit when we know the scope DIE is going to be null. | |||
389 | if (DD->isLexicalScopeDIENull(Scope)) | |||
390 | return; | |||
391 | ||||
392 | bool HasNonScopeChildren = false; | |||
393 | ||||
394 | // We create children here when we know the scope DIE is not going to be | |||
395 | // null and the children will be added to the scope DIE. | |||
396 | createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren); | |||
397 | ||||
398 | // If there are only other scopes as children, put them directly in the | |||
399 | // parent instead, as this scope would serve no purpose. | |||
400 | if (!HasNonScopeChildren) { | |||
401 | FinalChildren.insert(FinalChildren.end(), | |||
402 | std::make_move_iterator(Children.begin()), | |||
403 | std::make_move_iterator(Children.end())); | |||
404 | return; | |||
405 | } | |||
406 | ScopeDIE = constructLexicalScopeDIE(Scope); | |||
407 | assert(ScopeDIE && "Scope DIE should not be null.")((ScopeDIE && "Scope DIE should not be null.") ? static_cast <void> (0) : __assert_fail ("ScopeDIE && \"Scope DIE should not be null.\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 407, __PRETTY_FUNCTION__)); | |||
408 | } | |||
409 | ||||
410 | // Add children | |||
411 | for (auto &I : Children) | |||
412 | ScopeDIE->addChild(std::move(I)); | |||
413 | ||||
414 | FinalChildren.push_back(std::move(ScopeDIE)); | |||
415 | } | |||
416 | ||||
417 | void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE, | |||
418 | SmallVector<RangeSpan, 2> Range) { | |||
419 | const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); | |||
420 | ||||
421 | // Emit the offset into .debug_ranges or .debug_rnglists as a relocatable | |||
422 | // label. emitDIE() will handle emitting it appropriately. | |||
423 | const MCSymbol *RangeSectionSym = | |||
424 | DD->getDwarfVersion() >= 5 | |||
425 | ? TLOF.getDwarfRnglistsSection()->getBeginSymbol() | |||
426 | : TLOF.getDwarfRangesSection()->getBeginSymbol(); | |||
427 | ||||
428 | HasRangeLists = true; | |||
429 | ||||
430 | // Add the range list to the set of ranges to be emitted. | |||
431 | auto IndexAndList = | |||
432 | (DD->getDwarfVersion() < 5 && Skeleton ? Skeleton->DU : DU) | |||
433 | ->addRange(*(Skeleton ? Skeleton : this), std::move(Range)); | |||
434 | ||||
435 | uint32_t Index = IndexAndList.first; | |||
436 | auto &List = *IndexAndList.second; | |||
437 | ||||
438 | // Under fission, ranges are specified by constant offsets relative to the | |||
439 | // CU's DW_AT_GNU_ranges_base. | |||
440 | // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under | |||
441 | // fission until we support the forms using the .debug_addr section | |||
442 | // (DW_RLE_startx_endx etc.). | |||
443 | if (DD->getDwarfVersion() >= 5) | |||
444 | addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_rnglistx, Index); | |||
445 | else if (isDwoUnit()) | |||
446 | addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(), | |||
447 | RangeSectionSym); | |||
448 | else | |||
449 | addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(), | |||
450 | RangeSectionSym); | |||
451 | } | |||
452 | ||||
453 | void DwarfCompileUnit::attachRangesOrLowHighPC( | |||
454 | DIE &Die, SmallVector<RangeSpan, 2> Ranges) { | |||
455 | if (Ranges.size() == 1 || !DD->useRangesSection()) { | |||
456 | const RangeSpan &Front = Ranges.front(); | |||
457 | const RangeSpan &Back = Ranges.back(); | |||
458 | attachLowHighPC(Die, Front.getStart(), Back.getEnd()); | |||
459 | } else | |||
460 | addScopeRangeList(Die, std::move(Ranges)); | |||
461 | } | |||
462 | ||||
463 | void DwarfCompileUnit::attachRangesOrLowHighPC( | |||
464 | DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) { | |||
465 | SmallVector<RangeSpan, 2> List; | |||
466 | List.reserve(Ranges.size()); | |||
467 | for (const InsnRange &R : Ranges) | |||
468 | List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first), | |||
469 | DD->getLabelAfterInsn(R.second))); | |||
470 | attachRangesOrLowHighPC(Die, std::move(List)); | |||
471 | } | |||
472 | ||||
473 | // This scope represents inlined body of a function. Construct DIE to | |||
474 | // represent this concrete inlined copy of the function. | |||
475 | DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) { | |||
476 | assert(Scope->getScopeNode())((Scope->getScopeNode()) ? static_cast<void> (0) : __assert_fail ("Scope->getScopeNode()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 476, __PRETTY_FUNCTION__)); | |||
477 | auto *DS = Scope->getScopeNode(); | |||
478 | auto *InlinedSP = getDISubprogram(DS); | |||
479 | // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram | |||
480 | // was inlined from another compile unit. | |||
481 | DIE *OriginDIE = getAbstractSPDies()[InlinedSP]; | |||
482 | assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.")((OriginDIE && "Unable to find original DIE for an inlined subprogram." ) ? static_cast<void> (0) : __assert_fail ("OriginDIE && \"Unable to find original DIE for an inlined subprogram.\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 482, __PRETTY_FUNCTION__)); | |||
483 | ||||
484 | auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine); | |||
485 | addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE); | |||
486 | ||||
487 | attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges()); | |||
488 | ||||
489 | // Add the call site information to the DIE. | |||
490 | const DILocation *IA = Scope->getInlinedAt(); | |||
491 | addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None, | |||
492 | getOrCreateSourceID(IA->getFile())); | |||
493 | addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine()); | |||
494 | if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4) | |||
495 | addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None, | |||
496 | IA->getDiscriminator()); | |||
497 | ||||
498 | // Add name to the name table, we do this here because we're guaranteed | |||
499 | // to have concrete versions of our DW_TAG_inlined_subprogram nodes. | |||
500 | DD->addSubprogramNames(*CUNode, InlinedSP, *ScopeDIE); | |||
501 | ||||
502 | return ScopeDIE; | |||
503 | } | |||
504 | ||||
505 | // Construct new DW_TAG_lexical_block for this scope and attach | |||
506 | // DW_AT_low_pc/DW_AT_high_pc labels. | |||
507 | DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) { | |||
508 | if (DD->isLexicalScopeDIENull(Scope)) | |||
509 | return nullptr; | |||
510 | ||||
511 | auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block); | |||
512 | if (Scope->isAbstractScope()) | |||
513 | return ScopeDIE; | |||
514 | ||||
515 | attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges()); | |||
516 | ||||
517 | return ScopeDIE; | |||
518 | } | |||
519 | ||||
520 | /// constructVariableDIE - Construct a DIE for the given DbgVariable. | |||
521 | DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) { | |||
522 | auto D = constructVariableDIEImpl(DV, Abstract); | |||
523 | DV.setDIE(*D); | |||
524 | return D; | |||
525 | } | |||
526 | ||||
527 | DIE *DwarfCompileUnit::constructLabelDIE(DbgLabel &DL, | |||
528 | const LexicalScope &Scope) { | |||
529 | auto LabelDie = DIE::get(DIEValueAllocator, DL.getTag()); | |||
530 | insertDIE(DL.getLabel(), LabelDie); | |||
531 | DL.setDIE(*LabelDie); | |||
532 | ||||
533 | if (Scope.isAbstractScope()) | |||
534 | applyLabelAttributes(DL, *LabelDie); | |||
535 | ||||
536 | return LabelDie; | |||
537 | } | |||
538 | ||||
539 | DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV, | |||
540 | bool Abstract) { | |||
541 | // Define variable debug information entry. | |||
542 | auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag()); | |||
543 | insertDIE(DV.getVariable(), VariableDie); | |||
544 | ||||
545 | if (Abstract) { | |||
546 | applyVariableAttributes(DV, *VariableDie); | |||
547 | return VariableDie; | |||
548 | } | |||
549 | ||||
550 | // Add variable address. | |||
551 | ||||
552 | unsigned Offset = DV.getDebugLocListIndex(); | |||
553 | if (Offset != ~0U) { | |||
554 | addLocationList(*VariableDie, dwarf::DW_AT_location, Offset); | |||
555 | return VariableDie; | |||
556 | } | |||
557 | ||||
558 | // Check if variable is described by a DBG_VALUE instruction. | |||
559 | if (const MachineInstr *DVInsn = DV.getMInsn()) { | |||
560 | assert(DVInsn->getNumOperands() == 4)((DVInsn->getNumOperands() == 4) ? static_cast<void> (0) : __assert_fail ("DVInsn->getNumOperands() == 4", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 560, __PRETTY_FUNCTION__)); | |||
561 | if (DVInsn->getOperand(0).isReg()) { | |||
562 | auto RegOp = DVInsn->getOperand(0); | |||
563 | auto Op1 = DVInsn->getOperand(1); | |||
564 | // If the second operand is an immediate, this is an indirect value. | |||
565 | assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset")(((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset" ) ? static_cast<void> (0) : __assert_fail ("(!Op1.isImm() || (Op1.getImm() == 0)) && \"unexpected offset\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 565, __PRETTY_FUNCTION__)); | |||
566 | MachineLocation Location(RegOp.getReg(), Op1.isImm()); | |||
567 | addVariableAddress(DV, *VariableDie, Location); | |||
568 | } else if (DVInsn->getOperand(0).isImm()) { | |||
569 | // This variable is described by a single constant. | |||
570 | // Check whether it has a DIExpression. | |||
571 | auto *Expr = DV.getSingleExpression(); | |||
572 | if (Expr && Expr->getNumElements()) { | |||
573 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; | |||
574 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); | |||
575 | // If there is an expression, emit raw unsigned bytes. | |||
576 | DwarfExpr.addFragmentOffset(Expr); | |||
577 | DwarfExpr.addUnsignedConstant(DVInsn->getOperand(0).getImm()); | |||
578 | DwarfExpr.addExpression(Expr); | |||
579 | addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); | |||
580 | } else | |||
581 | addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType()); | |||
582 | } else if (DVInsn->getOperand(0).isFPImm()) | |||
583 | addConstantFPValue(*VariableDie, DVInsn->getOperand(0)); | |||
584 | else if (DVInsn->getOperand(0).isCImm()) | |||
585 | addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(), | |||
586 | DV.getType()); | |||
587 | ||||
588 | return VariableDie; | |||
589 | } | |||
590 | ||||
591 | // .. else use frame index. | |||
592 | if (!DV.hasFrameIndexExprs()) | |||
593 | return VariableDie; | |||
594 | ||||
595 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; | |||
596 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); | |||
597 | for (auto &Fragment : DV.getFrameIndexExprs()) { | |||
598 | unsigned FrameReg = 0; | |||
599 | const DIExpression *Expr = Fragment.Expr; | |||
600 | const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering(); | |||
601 | int Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg); | |||
602 | DwarfExpr.addFragmentOffset(Expr); | |||
603 | SmallVector<uint64_t, 8> Ops; | |||
604 | Ops.push_back(dwarf::DW_OP_plus_uconst); | |||
605 | Ops.push_back(Offset); | |||
606 | Ops.append(Expr->elements_begin(), Expr->elements_end()); | |||
607 | DIExpressionCursor Cursor(Ops); | |||
608 | DwarfExpr.setMemoryLocationKind(); | |||
609 | if (const MCSymbol *FrameSymbol = Asm->getFunctionFrameSymbol()) | |||
610 | addOpAddress(*Loc, FrameSymbol); | |||
611 | else | |||
612 | DwarfExpr.addMachineRegExpression( | |||
613 | *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg); | |||
614 | DwarfExpr.addExpression(std::move(Cursor)); | |||
615 | } | |||
616 | addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); | |||
617 | ||||
618 | return VariableDie; | |||
619 | } | |||
620 | ||||
621 | DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, | |||
622 | const LexicalScope &Scope, | |||
623 | DIE *&ObjectPointer) { | |||
624 | auto Var = constructVariableDIE(DV, Scope.isAbstractScope()); | |||
625 | if (DV.isObjectPointer()) | |||
626 | ObjectPointer = Var; | |||
627 | return Var; | |||
628 | } | |||
629 | ||||
630 | /// Return all DIVariables that appear in count: expressions. | |||
631 | static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) { | |||
632 | SmallVector<const DIVariable *, 2> Result; | |||
633 | auto *Array = dyn_cast<DICompositeType>(Var->getType()); | |||
634 | if (!Array || Array->getTag() != dwarf::DW_TAG_array_type) | |||
635 | return Result; | |||
636 | for (auto *El : Array->getElements()) { | |||
637 | if (auto *Subrange = dyn_cast<DISubrange>(El)) { | |||
638 | auto Count = Subrange->getCount(); | |||
639 | if (auto *Dependency = Count.dyn_cast<DIVariable *>()) | |||
640 | Result.push_back(Dependency); | |||
641 | } | |||
642 | } | |||
643 | return Result; | |||
644 | } | |||
645 | ||||
646 | /// Sort local variables so that variables appearing inside of helper | |||
647 | /// expressions come first. | |||
648 | static SmallVector<DbgVariable *, 8> | |||
649 | sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) { | |||
650 | SmallVector<DbgVariable *, 8> Result; | |||
651 | SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList; | |||
652 | // Map back from a DIVariable to its containing DbgVariable. | |||
653 | SmallDenseMap<const DILocalVariable *, DbgVariable *> DbgVar; | |||
654 | // Set of DbgVariables in Result. | |||
655 | SmallDenseSet<DbgVariable *, 8> Visited; | |||
656 | // For cycle detection. | |||
657 | SmallDenseSet<DbgVariable *, 8> Visiting; | |||
658 | ||||
659 | // Initialize the worklist and the DIVariable lookup table. | |||
660 | for (auto Var : reverse(Input)) { | |||
661 | DbgVar.insert({Var->getVariable(), Var}); | |||
662 | WorkList.push_back({Var, 0}); | |||
663 | } | |||
664 | ||||
665 | // Perform a stable topological sort by doing a DFS. | |||
666 | while (!WorkList.empty()) { | |||
667 | auto Item = WorkList.back(); | |||
668 | DbgVariable *Var = Item.getPointer(); | |||
669 | bool visitedAllDependencies = Item.getInt(); | |||
670 | WorkList.pop_back(); | |||
671 | ||||
672 | // Dependency is in a different lexical scope or a global. | |||
673 | if (!Var) | |||
674 | continue; | |||
675 | ||||
676 | // Already handled. | |||
677 | if (Visited.count(Var)) | |||
678 | continue; | |||
679 | ||||
680 | // Add to Result if all dependencies are visited. | |||
681 | if (visitedAllDependencies) { | |||
682 | Visited.insert(Var); | |||
683 | Result.push_back(Var); | |||
684 | continue; | |||
685 | } | |||
686 | ||||
687 | // Detect cycles. | |||
688 | auto Res = Visiting.insert(Var); | |||
689 | if (!Res.second) { | |||
690 | assert(false && "dependency cycle in local variables")((false && "dependency cycle in local variables") ? static_cast <void> (0) : __assert_fail ("false && \"dependency cycle in local variables\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 690, __PRETTY_FUNCTION__)); | |||
691 | return Result; | |||
692 | } | |||
693 | ||||
694 | // Push dependencies and this node onto the worklist, so that this node is | |||
695 | // visited again after all of its dependencies are handled. | |||
696 | WorkList.push_back({Var, 1}); | |||
697 | for (auto *Dependency : dependencies(Var)) { | |||
698 | auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency); | |||
699 | WorkList.push_back({DbgVar[Dep], 0}); | |||
700 | } | |||
701 | } | |||
702 | return Result; | |||
703 | } | |||
704 | ||||
705 | DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope, | |||
706 | SmallVectorImpl<DIE *> &Children, | |||
707 | bool *HasNonScopeChildren) { | |||
708 | assert(Children.empty())((Children.empty()) ? static_cast<void> (0) : __assert_fail ("Children.empty()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 708, __PRETTY_FUNCTION__)); | |||
709 | DIE *ObjectPointer = nullptr; | |||
710 | ||||
711 | // Emit function arguments (order is significant). | |||
712 | auto Vars = DU->getScopeVariables().lookup(Scope); | |||
713 | for (auto &DV : Vars.Args) | |||
714 | Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer)); | |||
715 | ||||
716 | // Emit local variables. | |||
717 | auto Locals = sortLocalVars(Vars.Locals); | |||
718 | for (DbgVariable *DV : Locals) | |||
719 | Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer)); | |||
720 | ||||
721 | // Skip imported directives in gmlt-like data. | |||
722 | if (!includeMinimalInlineScopes()) { | |||
723 | // There is no need to emit empty lexical block DIE. | |||
724 | for (const auto *IE : ImportedEntities[Scope->getScopeNode()]) | |||
725 | Children.push_back( | |||
726 | constructImportedEntityDIE(cast<DIImportedEntity>(IE))); | |||
727 | } | |||
728 | ||||
729 | if (HasNonScopeChildren) | |||
730 | *HasNonScopeChildren = !Children.empty(); | |||
731 | ||||
732 | for (DbgLabel *DL : DU->getScopeLabels().lookup(Scope)) | |||
733 | Children.push_back(constructLabelDIE(*DL, *Scope)); | |||
734 | ||||
735 | for (LexicalScope *LS : Scope->getChildren()) | |||
736 | constructScopeDIE(LS, Children); | |||
737 | ||||
738 | return ObjectPointer; | |||
739 | } | |||
740 | ||||
741 | DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub, | |||
742 | LexicalScope *Scope) { | |||
743 | DIE &ScopeDIE = updateSubprogramScopeDIE(Sub); | |||
744 | ||||
745 | if (Scope) { | |||
746 | assert(!Scope->getInlinedAt())((!Scope->getInlinedAt()) ? static_cast<void> (0) : __assert_fail ("!Scope->getInlinedAt()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 746, __PRETTY_FUNCTION__)); | |||
747 | assert(!Scope->isAbstractScope())((!Scope->isAbstractScope()) ? static_cast<void> (0) : __assert_fail ("!Scope->isAbstractScope()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 747, __PRETTY_FUNCTION__)); | |||
748 | // Collect lexical scope children first. | |||
749 | // ObjectPointer might be a local (non-argument) local variable if it's a | |||
750 | // block's synthetic this pointer. | |||
751 | if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE)) | |||
752 | addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer); | |||
753 | } | |||
754 | ||||
755 | // If this is a variadic function, add an unspecified parameter. | |||
756 | DITypeRefArray FnArgs = Sub->getType()->getTypeArray(); | |||
757 | ||||
758 | // If we have a single element of null, it is a function that returns void. | |||
759 | // If we have more than one elements and the last one is null, it is a | |||
760 | // variadic function. | |||
761 | if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] && | |||
762 | !includeMinimalInlineScopes()) | |||
763 | ScopeDIE.addChild( | |||
764 | DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters)); | |||
765 | ||||
766 | return ScopeDIE; | |||
767 | } | |||
768 | ||||
769 | DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope, | |||
770 | DIE &ScopeDIE) { | |||
771 | // We create children when the scope DIE is not null. | |||
772 | SmallVector<DIE *, 8> Children; | |||
773 | DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children); | |||
774 | ||||
775 | // Add children | |||
776 | for (auto &I : Children) | |||
777 | ScopeDIE.addChild(std::move(I)); | |||
778 | ||||
779 | return ObjectPointer; | |||
780 | } | |||
781 | ||||
782 | void DwarfCompileUnit::constructAbstractSubprogramScopeDIE( | |||
783 | LexicalScope *Scope) { | |||
784 | DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()]; | |||
785 | if (AbsDef) | |||
786 | return; | |||
787 | ||||
788 | auto *SP = cast<DISubprogram>(Scope->getScopeNode()); | |||
789 | ||||
790 | DIE *ContextDIE; | |||
791 | DwarfCompileUnit *ContextCU = this; | |||
792 | ||||
793 | if (includeMinimalInlineScopes()) | |||
794 | ContextDIE = &getUnitDie(); | |||
795 | // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with | |||
796 | // the important distinction that the debug node is not associated with the | |||
797 | // DIE (since the debug node will be associated with the concrete DIE, if | |||
798 | // any). It could be refactored to some common utility function. | |||
799 | else if (auto *SPDecl = SP->getDeclaration()) { | |||
800 | ContextDIE = &getUnitDie(); | |||
801 | getOrCreateSubprogramDIE(SPDecl); | |||
802 | } else { | |||
803 | ContextDIE = getOrCreateContextDIE(resolve(SP->getScope())); | |||
804 | // The scope may be shared with a subprogram that has already been | |||
805 | // constructed in another CU, in which case we need to construct this | |||
806 | // subprogram in the same CU. | |||
807 | ContextCU = DD->lookupCU(ContextDIE->getUnitDie()); | |||
808 | } | |||
809 | ||||
810 | // Passing null as the associated node because the abstract definition | |||
811 | // shouldn't be found by lookup. | |||
812 | AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr); | |||
813 | ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef); | |||
814 | ||||
815 | if (!ContextCU->includeMinimalInlineScopes()) | |||
816 | ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined); | |||
817 | if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef)) | |||
818 | ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer); | |||
819 | } | |||
820 | ||||
821 | DIE &DwarfCompileUnit::constructCallSiteEntryDIE(DIE &ScopeDIE, | |||
822 | const DISubprogram &CalleeSP, | |||
823 | bool IsTail, | |||
824 | const MCExpr *PCOffset) { | |||
825 | // Insert a call site entry DIE within ScopeDIE. | |||
826 | DIE &CallSiteDIE = | |||
827 | createAndAddDIE(dwarf::DW_TAG_call_site, ScopeDIE, nullptr); | |||
828 | ||||
829 | // For the purposes of showing tail call frames in backtraces, a key piece of | |||
830 | // information is DW_AT_call_origin, a pointer to the callee DIE. | |||
831 | DIE *CalleeDIE = getOrCreateSubprogramDIE(&CalleeSP); | |||
832 | assert(CalleeDIE && "Could not create DIE for call site entry origin")((CalleeDIE && "Could not create DIE for call site entry origin" ) ? static_cast<void> (0) : __assert_fail ("CalleeDIE && \"Could not create DIE for call site entry origin\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 832, __PRETTY_FUNCTION__)); | |||
833 | addDIEEntry(CallSiteDIE, dwarf::DW_AT_call_origin, *CalleeDIE); | |||
834 | ||||
835 | if (IsTail) { | |||
836 | // Attach DW_AT_call_tail_call to tail calls for standards compliance. | |||
837 | addFlag(CallSiteDIE, dwarf::DW_AT_call_tail_call); | |||
838 | } else { | |||
839 | // Attach the return PC to allow the debugger to disambiguate call paths | |||
840 | // from one function to another. | |||
841 | assert(PCOffset && "Missing return PC information for a call")((PCOffset && "Missing return PC information for a call" ) ? static_cast<void> (0) : __assert_fail ("PCOffset && \"Missing return PC information for a call\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 841, __PRETTY_FUNCTION__)); | |||
842 | addAddressExpr(CallSiteDIE, dwarf::DW_AT_call_return_pc, PCOffset); | |||
843 | } | |||
844 | return CallSiteDIE; | |||
845 | } | |||
846 | ||||
847 | DIE *DwarfCompileUnit::constructImportedEntityDIE( | |||
848 | const DIImportedEntity *Module) { | |||
849 | DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag()); | |||
850 | insertDIE(Module, IMDie); | |||
851 | DIE *EntityDie; | |||
852 | auto *Entity = resolve(Module->getEntity()); | |||
853 | if (auto *NS = dyn_cast<DINamespace>(Entity)) | |||
854 | EntityDie = getOrCreateNameSpace(NS); | |||
855 | else if (auto *M = dyn_cast<DIModule>(Entity)) | |||
856 | EntityDie = getOrCreateModule(M); | |||
857 | else if (auto *SP = dyn_cast<DISubprogram>(Entity)) | |||
858 | EntityDie = getOrCreateSubprogramDIE(SP); | |||
859 | else if (auto *T = dyn_cast<DIType>(Entity)) | |||
860 | EntityDie = getOrCreateTypeDIE(T); | |||
861 | else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity)) | |||
862 | EntityDie = getOrCreateGlobalVariableDIE(GV, {}); | |||
863 | else | |||
864 | EntityDie = getDIE(Entity); | |||
865 | assert(EntityDie)((EntityDie) ? static_cast<void> (0) : __assert_fail ("EntityDie" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 865, __PRETTY_FUNCTION__)); | |||
866 | addSourceLine(*IMDie, Module->getLine(), Module->getFile()); | |||
867 | addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie); | |||
868 | StringRef Name = Module->getName(); | |||
869 | if (!Name.empty()) | |||
870 | addString(*IMDie, dwarf::DW_AT_name, Name); | |||
871 | ||||
872 | return IMDie; | |||
873 | } | |||
874 | ||||
875 | void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) { | |||
876 | DIE *D = getDIE(SP); | |||
877 | if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) { | |||
878 | if (D) | |||
879 | // If this subprogram has an abstract definition, reference that | |||
880 | addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE); | |||
881 | } else { | |||
882 | assert(D || includeMinimalInlineScopes())((D || includeMinimalInlineScopes()) ? static_cast<void> (0) : __assert_fail ("D || includeMinimalInlineScopes()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 882, __PRETTY_FUNCTION__)); | |||
883 | if (D) | |||
884 | // And attach the attributes | |||
885 | applySubprogramAttributesToDefinition(SP, *D); | |||
886 | } | |||
887 | } | |||
888 | ||||
889 | void DwarfCompileUnit::finishEntityDefinition(const DbgEntity *Entity) { | |||
890 | DbgEntity *AbsEntity = getExistingAbstractEntity(Entity->getEntity()); | |||
891 | ||||
892 | auto *Die = Entity->getDIE(); | |||
893 | /// Label may be used to generate DW_AT_low_pc, so put it outside | |||
894 | /// if/else block. | |||
895 | const DbgLabel *Label = nullptr; | |||
896 | if (AbsEntity && AbsEntity->getDIE()) { | |||
| ||||
897 | addDIEEntry(*Die, dwarf::DW_AT_abstract_origin, *AbsEntity->getDIE()); | |||
898 | Label = dyn_cast<const DbgLabel>(Entity); | |||
899 | } else { | |||
900 | if (const DbgVariable *Var = dyn_cast<const DbgVariable>(Entity)) | |||
901 | applyVariableAttributes(*Var, *Die); | |||
902 | else if ((Label = dyn_cast<const DbgLabel>(Entity))) | |||
903 | applyLabelAttributes(*Label, *Die); | |||
904 | else | |||
905 | llvm_unreachable("DbgEntity must be DbgVariable or DbgLabel.")::llvm::llvm_unreachable_internal("DbgEntity must be DbgVariable or DbgLabel." , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 905); | |||
906 | } | |||
907 | ||||
908 | if (Label) | |||
909 | if (const auto *Sym = Label->getSymbol()) | |||
910 | addLabelAddress(*Die, dwarf::DW_AT_low_pc, Sym); | |||
911 | } | |||
912 | ||||
913 | DbgEntity *DwarfCompileUnit::getExistingAbstractEntity(const DINode *Node) { | |||
914 | auto &AbstractEntities = getAbstractEntities(); | |||
915 | auto I = AbstractEntities.find(Node); | |||
916 | if (I != AbstractEntities.end()) | |||
917 | return I->second.get(); | |||
918 | return nullptr; | |||
919 | } | |||
920 | ||||
921 | void DwarfCompileUnit::createAbstractEntity(const DINode *Node, | |||
922 | LexicalScope *Scope) { | |||
923 | assert(Scope && Scope->isAbstractScope())((Scope && Scope->isAbstractScope()) ? static_cast <void> (0) : __assert_fail ("Scope && Scope->isAbstractScope()" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 923, __PRETTY_FUNCTION__)); | |||
924 | auto &Entity = getAbstractEntities()[Node]; | |||
925 | if (isa<const DILocalVariable>(Node)) { | |||
926 | Entity = llvm::make_unique<DbgVariable>( | |||
927 | cast<const DILocalVariable>(Node), nullptr /* IA */);; | |||
928 | DU->addScopeVariable(Scope, cast<DbgVariable>(Entity.get())); | |||
929 | } else if (isa<const DILabel>(Node)) { | |||
930 | Entity = llvm::make_unique<DbgLabel>( | |||
931 | cast<const DILabel>(Node), nullptr /* IA */); | |||
932 | DU->addScopeLabel(Scope, cast<DbgLabel>(Entity.get())); | |||
933 | } | |||
934 | } | |||
935 | ||||
936 | void DwarfCompileUnit::emitHeader(bool UseOffsets) { | |||
937 | // Don't bother labeling the .dwo unit, as its offset isn't used. | |||
938 | if (!Skeleton && !DD->useSectionsAsReferences()) { | |||
939 | LabelBegin = Asm->createTempSymbol("cu_begin"); | |||
940 | Asm->OutStreamer->EmitLabel(LabelBegin); | |||
941 | } | |||
942 | ||||
943 | dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile | |||
944 | : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton | |||
945 | : dwarf::DW_UT_compile; | |||
946 | DwarfUnit::emitCommonHeader(UseOffsets, UT); | |||
947 | if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile) | |||
948 | Asm->emitInt64(getDWOId()); | |||
949 | } | |||
950 | ||||
951 | bool DwarfCompileUnit::hasDwarfPubSections() const { | |||
952 | switch (CUNode->getNameTableKind()) { | |||
953 | case DICompileUnit::DebugNameTableKind::None: | |||
954 | return false; | |||
955 | // Opting in to GNU Pubnames/types overrides the default to ensure these are | |||
956 | // generated for things like Gold's gdb_index generation. | |||
957 | case DICompileUnit::DebugNameTableKind::GNU: | |||
958 | return true; | |||
959 | case DICompileUnit::DebugNameTableKind::Default: | |||
960 | return DD->tuneForGDB() && !includeMinimalInlineScopes() && | |||
961 | !CUNode->isDebugDirectivesOnly(); | |||
962 | } | |||
963 | llvm_unreachable("Unhandled DICompileUnit::DebugNameTableKind enum")::llvm::llvm_unreachable_internal("Unhandled DICompileUnit::DebugNameTableKind enum" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 963); | |||
964 | } | |||
965 | ||||
966 | /// addGlobalName - Add a new global name to the compile unit. | |||
967 | void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die, | |||
968 | const DIScope *Context) { | |||
969 | if (!hasDwarfPubSections()) | |||
970 | return; | |||
971 | std::string FullName = getParentContextString(Context) + Name.str(); | |||
972 | GlobalNames[FullName] = &Die; | |||
973 | } | |||
974 | ||||
975 | void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name, | |||
976 | const DIScope *Context) { | |||
977 | if (!hasDwarfPubSections()) | |||
978 | return; | |||
979 | std::string FullName = getParentContextString(Context) + Name.str(); | |||
980 | // Insert, allowing the entry to remain as-is if it's already present | |||
981 | // This way the CU-level type DIE is preferred over the "can't describe this | |||
982 | // type as a unit offset because it's not really in the CU at all, it's only | |||
983 | // in a type unit" | |||
984 | GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie())); | |||
985 | } | |||
986 | ||||
987 | /// Add a new global type to the unit. | |||
988 | void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die, | |||
989 | const DIScope *Context) { | |||
990 | if (!hasDwarfPubSections()) | |||
991 | return; | |||
992 | std::string FullName = getParentContextString(Context) + Ty->getName().str(); | |||
993 | GlobalTypes[FullName] = &Die; | |||
994 | } | |||
995 | ||||
996 | void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty, | |||
997 | const DIScope *Context) { | |||
998 | if (!hasDwarfPubSections()) | |||
999 | return; | |||
1000 | std::string FullName = getParentContextString(Context) + Ty->getName().str(); | |||
1001 | // Insert, allowing the entry to remain as-is if it's already present | |||
1002 | // This way the CU-level type DIE is preferred over the "can't describe this | |||
1003 | // type as a unit offset because it's not really in the CU at all, it's only | |||
1004 | // in a type unit" | |||
1005 | GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie())); | |||
1006 | } | |||
1007 | ||||
1008 | /// addVariableAddress - Add DW_AT_location attribute for a | |||
1009 | /// DbgVariable based on provided MachineLocation. | |||
1010 | void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die, | |||
1011 | MachineLocation Location) { | |||
1012 | // addBlockByrefAddress is obsolete and will be removed soon. | |||
1013 | // The clang frontend always generates block byref variables with a | |||
1014 | // complex expression that encodes exactly what addBlockByrefAddress | |||
1015 | // would do. | |||
1016 | assert((!DV.isBlockByrefVariable() || DV.hasComplexAddress()) &&(((!DV.isBlockByrefVariable() || DV.hasComplexAddress()) && "block byref variable without a complex expression") ? static_cast <void> (0) : __assert_fail ("(!DV.isBlockByrefVariable() || DV.hasComplexAddress()) && \"block byref variable without a complex expression\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 1017, __PRETTY_FUNCTION__)) | |||
1017 | "block byref variable without a complex expression")(((!DV.isBlockByrefVariable() || DV.hasComplexAddress()) && "block byref variable without a complex expression") ? static_cast <void> (0) : __assert_fail ("(!DV.isBlockByrefVariable() || DV.hasComplexAddress()) && \"block byref variable without a complex expression\"" , "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 1017, __PRETTY_FUNCTION__)); | |||
1018 | if (DV.hasComplexAddress()) | |||
1019 | addComplexAddress(DV, Die, dwarf::DW_AT_location, Location); | |||
1020 | else | |||
1021 | addAddress(Die, dwarf::DW_AT_location, Location); | |||
1022 | } | |||
1023 | ||||
1024 | /// Add an address attribute to a die based on the location provided. | |||
1025 | void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute, | |||
1026 | const MachineLocation &Location) { | |||
1027 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; | |||
1028 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); | |||
1029 | if (Location.isIndirect()) | |||
1030 | DwarfExpr.setMemoryLocationKind(); | |||
1031 | ||||
1032 | DIExpressionCursor Cursor({}); | |||
1033 | const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); | |||
1034 | if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg())) | |||
1035 | return; | |||
1036 | DwarfExpr.addExpression(std::move(Cursor)); | |||
1037 | ||||
1038 | // Now attach the location information to the DIE. | |||
1039 | addBlock(Die, Attribute, DwarfExpr.finalize()); | |||
1040 | } | |||
1041 | ||||
1042 | /// Start with the address based on the location provided, and generate the | |||
1043 | /// DWARF information necessary to find the actual variable given the extra | |||
1044 | /// address information encoded in the DbgVariable, starting from the starting | |||
1045 | /// location. Add the DWARF information to the die. | |||
1046 | void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die, | |||
1047 | dwarf::Attribute Attribute, | |||
1048 | const MachineLocation &Location) { | |||
1049 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; | |||
1050 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); | |||
1051 | const DIExpression *DIExpr = DV.getSingleExpression(); | |||
1052 | DwarfExpr.addFragmentOffset(DIExpr); | |||
1053 | if (Location.isIndirect()) | |||
1054 | DwarfExpr.setMemoryLocationKind(); | |||
1055 | ||||
1056 | DIExpressionCursor Cursor(DIExpr); | |||
1057 | const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); | |||
1058 | if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg())) | |||
1059 | return; | |||
1060 | DwarfExpr.addExpression(std::move(Cursor)); | |||
1061 | ||||
1062 | // Now attach the location information to the DIE. | |||
1063 | addBlock(Die, Attribute, DwarfExpr.finalize()); | |||
1064 | } | |||
1065 | ||||
1066 | /// Add a Dwarf loclistptr attribute data and value. | |||
1067 | void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute, | |||
1068 | unsigned Index) { | |||
1069 | dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset | |||
1070 | : dwarf::DW_FORM_data4; | |||
1071 | Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index)); | |||
1072 | } | |||
1073 | ||||
1074 | void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var, | |||
1075 | DIE &VariableDie) { | |||
1076 | StringRef Name = Var.getName(); | |||
1077 | if (!Name.empty()) | |||
1078 | addString(VariableDie, dwarf::DW_AT_name, Name); | |||
1079 | const auto *DIVar = Var.getVariable(); | |||
1080 | if (DIVar) | |||
1081 | if (uint32_t AlignInBytes = DIVar->getAlignInBytes()) | |||
1082 | addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, | |||
1083 | AlignInBytes); | |||
1084 | ||||
1085 | addSourceLine(VariableDie, DIVar); | |||
1086 | addType(VariableDie, Var.getType()); | |||
1087 | if (Var.isArtificial()) | |||
1088 | addFlag(VariableDie, dwarf::DW_AT_artificial); | |||
1089 | } | |||
1090 | ||||
1091 | void DwarfCompileUnit::applyLabelAttributes(const DbgLabel &Label, | |||
1092 | DIE &LabelDie) { | |||
1093 | StringRef Name = Label.getName(); | |||
1094 | if (!Name.empty()) | |||
1095 | addString(LabelDie, dwarf::DW_AT_name, Name); | |||
1096 | const auto *DILabel = Label.getLabel(); | |||
1097 | addSourceLine(LabelDie, DILabel); | |||
1098 | } | |||
1099 | ||||
1100 | /// Add a Dwarf expression attribute data and value. | |||
1101 | void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form, | |||
1102 | const MCExpr *Expr) { | |||
1103 | Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr)); | |||
1104 | } | |||
1105 | ||||
1106 | void DwarfCompileUnit::addAddressExpr(DIE &Die, dwarf::Attribute Attribute, | |||
1107 | const MCExpr *Expr) { | |||
1108 | Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr, | |||
1109 | DIEExpr(Expr)); | |||
1110 | } | |||
1111 | ||||
1112 | void DwarfCompileUnit::applySubprogramAttributesToDefinition( | |||
1113 | const DISubprogram *SP, DIE &SPDie) { | |||
1114 | auto *SPDecl = SP->getDeclaration(); | |||
1115 | auto *Context = resolve(SPDecl ? SPDecl->getScope() : SP->getScope()); | |||
1116 | applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes()); | |||
1117 | addGlobalName(SP->getName(), SPDie, Context); | |||
1118 | } | |||
1119 | ||||
1120 | bool DwarfCompileUnit::isDwoUnit() const { | |||
1121 | return DD->useSplitDwarf() && Skeleton; | |||
1122 | } | |||
1123 | ||||
1124 | bool DwarfCompileUnit::includeMinimalInlineScopes() const { | |||
1125 | return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly || | |||
1126 | (DD->useSplitDwarf() && !Skeleton); | |||
1127 | } | |||
1128 | ||||
1129 | void DwarfCompileUnit::addAddrTableBase() { | |||
1130 | const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); | |||
1131 | MCSymbol *Label = DD->getAddressPool().getLabel(); | |||
1132 | addSectionLabel(getUnitDie(), | |||
1133 | getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base | |||
1134 | : dwarf::DW_AT_GNU_addr_base, | |||
1135 | Label, TLOF.getDwarfAddrSection()->getBeginSymbol()); | |||
1136 | } |
1 | //===- lib/CodeGen/DIE.h - DWARF Info Entries -------------------*- 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 | // Data structures for DWARF info entries. | |||
11 | // | |||
12 | //===----------------------------------------------------------------------===// | |||
13 | ||||
14 | #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H | |||
15 | #define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H | |||
16 | ||||
17 | #include "llvm/ADT/FoldingSet.h" | |||
18 | #include "llvm/ADT/PointerIntPair.h" | |||
19 | #include "llvm/ADT/PointerUnion.h" | |||
20 | #include "llvm/ADT/SmallVector.h" | |||
21 | #include "llvm/ADT/StringRef.h" | |||
22 | #include "llvm/ADT/iterator.h" | |||
23 | #include "llvm/ADT/iterator_range.h" | |||
24 | #include "llvm/BinaryFormat/Dwarf.h" | |||
25 | #include "llvm/CodeGen/DwarfStringPoolEntry.h" | |||
26 | #include "llvm/Support/AlignOf.h" | |||
27 | #include "llvm/Support/Allocator.h" | |||
28 | #include <cassert> | |||
29 | #include <cstddef> | |||
30 | #include <cstdint> | |||
31 | #include <iterator> | |||
32 | #include <new> | |||
33 | #include <type_traits> | |||
34 | #include <utility> | |||
35 | #include <vector> | |||
36 | ||||
37 | namespace llvm { | |||
38 | ||||
39 | class AsmPrinter; | |||
40 | class DIE; | |||
41 | class DIEUnit; | |||
42 | class MCExpr; | |||
43 | class MCSection; | |||
44 | class MCSymbol; | |||
45 | class raw_ostream; | |||
46 | ||||
47 | //===--------------------------------------------------------------------===// | |||
48 | /// Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation. | |||
49 | class DIEAbbrevData { | |||
50 | /// Dwarf attribute code. | |||
51 | dwarf::Attribute Attribute; | |||
52 | ||||
53 | /// Dwarf form code. | |||
54 | dwarf::Form Form; | |||
55 | ||||
56 | /// Dwarf attribute value for DW_FORM_implicit_const | |||
57 | int64_t Value = 0; | |||
58 | ||||
59 | public: | |||
60 | DIEAbbrevData(dwarf::Attribute A, dwarf::Form F) | |||
61 | : Attribute(A), Form(F) {} | |||
62 | DIEAbbrevData(dwarf::Attribute A, int64_t V) | |||
63 | : Attribute(A), Form(dwarf::DW_FORM_implicit_const), Value(V) {} | |||
64 | ||||
65 | /// Accessors. | |||
66 | /// @{ | |||
67 | dwarf::Attribute getAttribute() const { return Attribute; } | |||
68 | dwarf::Form getForm() const { return Form; } | |||
69 | int64_t getValue() const { return Value; } | |||
70 | /// @} | |||
71 | ||||
72 | /// Used to gather unique data for the abbreviation folding set. | |||
73 | void Profile(FoldingSetNodeID &ID) const; | |||
74 | }; | |||
75 | ||||
76 | //===--------------------------------------------------------------------===// | |||
77 | /// Dwarf abbreviation, describes the organization of a debug information | |||
78 | /// object. | |||
79 | class DIEAbbrev : public FoldingSetNode { | |||
80 | /// Unique number for node. | |||
81 | unsigned Number; | |||
82 | ||||
83 | /// Dwarf tag code. | |||
84 | dwarf::Tag Tag; | |||
85 | ||||
86 | /// Whether or not this node has children. | |||
87 | /// | |||
88 | /// This cheats a bit in all of the uses since the values in the standard | |||
89 | /// are 0 and 1 for no children and children respectively. | |||
90 | bool Children; | |||
91 | ||||
92 | /// Raw data bytes for abbreviation. | |||
93 | SmallVector<DIEAbbrevData, 12> Data; | |||
94 | ||||
95 | public: | |||
96 | DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C) {} | |||
97 | ||||
98 | /// Accessors. | |||
99 | /// @{ | |||
100 | dwarf::Tag getTag() const { return Tag; } | |||
101 | unsigned getNumber() const { return Number; } | |||
102 | bool hasChildren() const { return Children; } | |||
103 | const SmallVectorImpl<DIEAbbrevData> &getData() const { return Data; } | |||
104 | void setChildrenFlag(bool hasChild) { Children = hasChild; } | |||
105 | void setNumber(unsigned N) { Number = N; } | |||
106 | /// @} | |||
107 | ||||
108 | /// Adds another set of attribute information to the abbreviation. | |||
109 | void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form) { | |||
110 | Data.push_back(DIEAbbrevData(Attribute, Form)); | |||
111 | } | |||
112 | ||||
113 | /// Adds attribute with DW_FORM_implicit_const value | |||
114 | void AddImplicitConstAttribute(dwarf::Attribute Attribute, int64_t Value) { | |||
115 | Data.push_back(DIEAbbrevData(Attribute, Value)); | |||
116 | } | |||
117 | ||||
118 | /// Used to gather unique data for the abbreviation folding set. | |||
119 | void Profile(FoldingSetNodeID &ID) const; | |||
120 | ||||
121 | /// Print the abbreviation using the specified asm printer. | |||
122 | void Emit(const AsmPrinter *AP) const; | |||
123 | ||||
124 | void print(raw_ostream &O) const; | |||
125 | void dump() const; | |||
126 | }; | |||
127 | ||||
128 | //===--------------------------------------------------------------------===// | |||
129 | /// Helps unique DIEAbbrev objects and assigns abbreviation numbers. | |||
130 | /// | |||
131 | /// This class will unique the DIE abbreviations for a llvm::DIE object and | |||
132 | /// assign a unique abbreviation number to each unique DIEAbbrev object it | |||
133 | /// finds. The resulting collection of DIEAbbrev objects can then be emitted | |||
134 | /// into the .debug_abbrev section. | |||
135 | class DIEAbbrevSet { | |||
136 | /// The bump allocator to use when creating DIEAbbrev objects in the uniqued | |||
137 | /// storage container. | |||
138 | BumpPtrAllocator &Alloc; | |||
139 | /// FoldingSet that uniques the abbreviations. | |||
140 | FoldingSet<DIEAbbrev> AbbreviationsSet; | |||
141 | /// A list of all the unique abbreviations in use. | |||
142 | std::vector<DIEAbbrev *> Abbreviations; | |||
143 | ||||
144 | public: | |||
145 | DIEAbbrevSet(BumpPtrAllocator &A) : Alloc(A) {} | |||
146 | ~DIEAbbrevSet(); | |||
147 | ||||
148 | /// Generate the abbreviation declaration for a DIE and return a pointer to | |||
149 | /// the generated abbreviation. | |||
150 | /// | |||
151 | /// \param Die the debug info entry to generate the abbreviation for. | |||
152 | /// \returns A reference to the uniqued abbreviation declaration that is | |||
153 | /// owned by this class. | |||
154 | DIEAbbrev &uniqueAbbreviation(DIE &Die); | |||
155 | ||||
156 | /// Print all abbreviations using the specified asm printer. | |||
157 | void Emit(const AsmPrinter *AP, MCSection *Section) const; | |||
158 | }; | |||
159 | ||||
160 | //===--------------------------------------------------------------------===// | |||
161 | /// An integer value DIE. | |||
162 | /// | |||
163 | class DIEInteger { | |||
164 | uint64_t Integer; | |||
165 | ||||
166 | public: | |||
167 | explicit DIEInteger(uint64_t I) : Integer(I) {} | |||
168 | ||||
169 | /// Choose the best form for integer. | |||
170 | static dwarf::Form BestForm(bool IsSigned, uint64_t Int) { | |||
171 | if (IsSigned) { | |||
172 | const int64_t SignedInt = Int; | |||
173 | if ((char)Int == SignedInt) | |||
174 | return dwarf::DW_FORM_data1; | |||
175 | if ((short)Int == SignedInt) | |||
176 | return dwarf::DW_FORM_data2; | |||
177 | if ((int)Int == SignedInt) | |||
178 | return dwarf::DW_FORM_data4; | |||
179 | } else { | |||
180 | if ((unsigned char)Int == Int) | |||
181 | return dwarf::DW_FORM_data1; | |||
182 | if ((unsigned short)Int == Int) | |||
183 | return dwarf::DW_FORM_data2; | |||
184 | if ((unsigned int)Int == Int) | |||
185 | return dwarf::DW_FORM_data4; | |||
186 | } | |||
187 | return dwarf::DW_FORM_data8; | |||
188 | } | |||
189 | ||||
190 | uint64_t getValue() const { return Integer; } | |||
191 | void setValue(uint64_t Val) { Integer = Val; } | |||
192 | ||||
193 | void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const; | |||
194 | unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const; | |||
195 | ||||
196 | void print(raw_ostream &O) const; | |||
197 | }; | |||
198 | ||||
199 | //===--------------------------------------------------------------------===// | |||
200 | /// An expression DIE. | |||
201 | class DIEExpr { | |||
202 | const MCExpr *Expr; | |||
203 | ||||
204 | public: | |||
205 | explicit DIEExpr(const MCExpr *E) : Expr(E) {} | |||
206 | ||||
207 | /// Get MCExpr. | |||
208 | const MCExpr *getValue() const { return Expr; } | |||
209 | ||||
210 | void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const; | |||
211 | unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const; | |||
212 | ||||
213 | void print(raw_ostream &O) const; | |||
214 | }; | |||
215 | ||||
216 | //===--------------------------------------------------------------------===// | |||
217 | /// A label DIE. | |||
218 | class DIELabel { | |||
219 | const MCSymbol *Label; | |||
220 | ||||
221 | public: | |||
222 | explicit DIELabel(const MCSymbol *L) : Label(L) {} | |||
223 | ||||
224 | /// Get MCSymbol. | |||
225 | const MCSymbol *getValue() const { return Label; } | |||
226 | ||||
227 | void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const; | |||
228 | unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const; | |||
229 | ||||
230 | void print(raw_ostream &O) const; | |||
231 | }; | |||
232 | ||||
233 | //===--------------------------------------------------------------------===// | |||
234 | /// A simple label difference DIE. | |||
235 | /// | |||
236 | class DIEDelta { | |||
237 | const MCSymbol *LabelHi; | |||
238 | const MCSymbol *LabelLo; | |||
239 | ||||
240 | public: | |||
241 | DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {} | |||
242 | ||||
243 | void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const; | |||
244 | unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const; | |||
245 | ||||
246 | void print(raw_ostream &O) const; | |||
247 | }; | |||
248 | ||||
249 | //===--------------------------------------------------------------------===// | |||
250 | /// A container for string pool string values. | |||
251 | /// | |||
252 | /// This class is used with the DW_FORM_strp and DW_FORM_GNU_str_index forms. | |||
253 | class DIEString { | |||
254 | DwarfStringPoolEntryRef S; | |||
255 | ||||
256 | public: | |||
257 | DIEString(DwarfStringPoolEntryRef S) : S(S) {} | |||
258 | ||||
259 | /// Grab the string out of the object. | |||
260 | StringRef getString() const { return S.getString(); } | |||
261 | ||||
262 | void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const; | |||
263 | unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const; | |||
264 | ||||
265 | void print(raw_ostream &O) const; | |||
266 | }; | |||
267 | ||||
268 | //===--------------------------------------------------------------------===// | |||
269 | /// A container for inline string values. | |||
270 | /// | |||
271 | /// This class is used with the DW_FORM_string form. | |||
272 | class DIEInlineString { | |||
273 | StringRef S; | |||
274 | ||||
275 | public: | |||
276 | template <typename Allocator> | |||
277 | explicit DIEInlineString(StringRef Str, Allocator &A) : S(Str.copy(A)) {} | |||
278 | ||||
279 | ~DIEInlineString() = default; | |||
280 | ||||
281 | /// Grab the string out of the object. | |||
282 | StringRef getString() const { return S; } | |||
283 | ||||
284 | void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const; | |||
285 | unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const; | |||
286 | ||||
287 | void print(raw_ostream &O) const; | |||
288 | }; | |||
289 | ||||
290 | //===--------------------------------------------------------------------===// | |||
291 | /// A pointer to another debug information entry. An instance of this class can | |||
292 | /// also be used as a proxy for a debug information entry not yet defined | |||
293 | /// (ie. types.) | |||
294 | class DIEEntry { | |||
295 | DIE *Entry; | |||
296 | ||||
297 | public: | |||
298 | DIEEntry() = delete; | |||
299 | explicit DIEEntry(DIE &E) : Entry(&E) {} | |||
300 | ||||
301 | DIE &getEntry() const { return *Entry; } | |||
302 | ||||
303 | void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const; | |||
304 | unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const; | |||
305 | ||||
306 | void print(raw_ostream &O) const; | |||
307 | }; | |||
308 | ||||
309 | //===--------------------------------------------------------------------===// | |||
310 | /// Represents a pointer to a location list in the debug_loc | |||
311 | /// section. | |||
312 | class DIELocList { | |||
313 | /// Index into the .debug_loc vector. | |||
314 | size_t Index; | |||
315 | ||||
316 | public: | |||
317 | DIELocList(size_t I) : Index(I) {} | |||
318 | ||||
319 | /// Grab the current index out. | |||
320 | size_t getValue() const { return Index; } | |||
321 | ||||
322 | void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const; | |||
323 | unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const; | |||
324 | ||||
325 | void print(raw_ostream &O) const; | |||
326 | }; | |||
327 | ||||
328 | //===--------------------------------------------------------------------===// | |||
329 | /// A debug information entry value. Some of these roughly correlate | |||
330 | /// to DWARF attribute classes. | |||
331 | class DIEBlock; | |||
332 | class DIELoc; | |||
333 | class DIEValue { | |||
334 | public: | |||
335 | enum Type { | |||
336 | isNone, | |||
337 | #define HANDLE_DIEVALUE(T) is##T, | |||
338 | #include "llvm/CodeGen/DIEValue.def" | |||
339 | }; | |||
340 | ||||
341 | private: | |||
342 | /// Type of data stored in the value. | |||
343 | Type Ty = isNone; | |||
344 | dwarf::Attribute Attribute = (dwarf::Attribute)0; | |||
345 | dwarf::Form Form = (dwarf::Form)0; | |||
346 | ||||
347 | /// Storage for the value. | |||
348 | /// | |||
349 | /// All values that aren't standard layout (or are larger than 8 bytes) | |||
350 | /// should be stored by reference instead of by value. | |||
351 | using ValTy = AlignedCharArrayUnion<DIEInteger, DIEString, DIEExpr, DIELabel, | |||
352 | DIEDelta *, DIEEntry, DIEBlock *, | |||
353 | DIELoc *, DIELocList>; | |||
354 | ||||
355 | static_assert(sizeof(ValTy) <= sizeof(uint64_t) || | |||
356 | sizeof(ValTy) <= sizeof(void *), | |||
357 | "Expected all large types to be stored via pointer"); | |||
358 | ||||
359 | /// Underlying stored value. | |||
360 | ValTy Val; | |||
361 | ||||
362 | template <class T> void construct(T V) { | |||
363 | static_assert(std::is_standard_layout<T>::value || | |||
364 | std::is_pointer<T>::value, | |||
365 | "Expected standard layout or pointer"); | |||
366 | new (reinterpret_cast<void *>(Val.buffer)) T(V); | |||
367 | } | |||
368 | ||||
369 | template <class T> T *get() { return reinterpret_cast<T *>(Val.buffer); } | |||
370 | template <class T> const T *get() const { | |||
371 | return reinterpret_cast<const T *>(Val.buffer); | |||
372 | } | |||
373 | template <class T> void destruct() { get<T>()->~T(); } | |||
374 | ||||
375 | /// Destroy the underlying value. | |||
376 | /// | |||
377 | /// This should get optimized down to a no-op. We could skip it if we could | |||
378 | /// add a static assert on \a std::is_trivially_copyable(), but we currently | |||
379 | /// support versions of GCC that don't understand that. | |||
380 | void destroyVal() { | |||
381 | switch (Ty) { | |||
382 | case isNone: | |||
383 | return; | |||
384 | #define HANDLE_DIEVALUE_SMALL(T) \ | |||
385 | case is##T: \ | |||
386 | destruct<DIE##T>(); \ | |||
387 | return; | |||
388 | #define HANDLE_DIEVALUE_LARGE(T) \ | |||
389 | case is##T: \ | |||
390 | destruct<const DIE##T *>(); \ | |||
391 | return; | |||
392 | #include "llvm/CodeGen/DIEValue.def" | |||
393 | } | |||
394 | } | |||
395 | ||||
396 | /// Copy the underlying value. | |||
397 | /// | |||
398 | /// This should get optimized down to a simple copy. We need to actually | |||
399 | /// construct the value, rather than calling memcpy, to satisfy strict | |||
400 | /// aliasing rules. | |||
401 | void copyVal(const DIEValue &X) { | |||
402 | switch (Ty) { | |||
403 | case isNone: | |||
404 | return; | |||
405 | #define HANDLE_DIEVALUE_SMALL(T) \ | |||
406 | case is##T: \ | |||
407 | construct<DIE##T>(*X.get<DIE##T>()); \ | |||
408 | return; | |||
409 | #define HANDLE_DIEVALUE_LARGE(T) \ | |||
410 | case is##T: \ | |||
411 | construct<const DIE##T *>(*X.get<const DIE##T *>()); \ | |||
412 | return; | |||
413 | #include "llvm/CodeGen/DIEValue.def" | |||
414 | } | |||
415 | } | |||
416 | ||||
417 | public: | |||
418 | DIEValue() = default; | |||
419 | ||||
420 | DIEValue(const DIEValue &X) : Ty(X.Ty), Attribute(X.Attribute), Form(X.Form) { | |||
421 | copyVal(X); | |||
422 | } | |||
423 | ||||
424 | DIEValue &operator=(const DIEValue &X) { | |||
425 | destroyVal(); | |||
426 | Ty = X.Ty; | |||
427 | Attribute = X.Attribute; | |||
428 | Form = X.Form; | |||
429 | copyVal(X); | |||
430 | return *this; | |||
431 | } | |||
432 | ||||
433 | ~DIEValue() { destroyVal(); } | |||
434 | ||||
435 | #define HANDLE_DIEVALUE_SMALL(T) \ | |||
436 | DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T &V) \ | |||
437 | : Ty(is##T), Attribute(Attribute), Form(Form) { \ | |||
438 | construct<DIE##T>(V); \ | |||
439 | } | |||
440 | #define HANDLE_DIEVALUE_LARGE(T) \ | |||
441 | DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T *V) \ | |||
442 | : Ty(is##T), Attribute(Attribute), Form(Form) { \ | |||
443 | assert(V && "Expected valid value")((V && "Expected valid value") ? static_cast<void> (0) : __assert_fail ("V && \"Expected valid value\"" , "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h" , 443, __PRETTY_FUNCTION__)); \ | |||
444 | construct<const DIE##T *>(V); \ | |||
445 | } | |||
446 | #include "llvm/CodeGen/DIEValue.def" | |||
447 | ||||
448 | /// Accessors. | |||
449 | /// @{ | |||
450 | Type getType() const { return Ty; } | |||
451 | dwarf::Attribute getAttribute() const { return Attribute; } | |||
452 | dwarf::Form getForm() const { return Form; } | |||
453 | explicit operator bool() const { return Ty; } | |||
454 | /// @} | |||
455 | ||||
456 | #define HANDLE_DIEVALUE_SMALL(T) \ | |||
457 | const DIE##T &getDIE##T() const { \ | |||
458 | assert(getType() == is##T && "Expected " #T)((getType() == is##T && "Expected " #T) ? static_cast <void> (0) : __assert_fail ("getType() == is##T && \"Expected \" #T" , "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h" , 458, __PRETTY_FUNCTION__)); \ | |||
459 | return *get<DIE##T>(); \ | |||
460 | } | |||
461 | #define HANDLE_DIEVALUE_LARGE(T) \ | |||
462 | const DIE##T &getDIE##T() const { \ | |||
463 | assert(getType() == is##T && "Expected " #T)((getType() == is##T && "Expected " #T) ? static_cast <void> (0) : __assert_fail ("getType() == is##T && \"Expected \" #T" , "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h" , 463, __PRETTY_FUNCTION__)); \ | |||
464 | return **get<const DIE##T *>(); \ | |||
465 | } | |||
466 | #include "llvm/CodeGen/DIEValue.def" | |||
467 | ||||
468 | /// Emit value via the Dwarf writer. | |||
469 | void EmitValue(const AsmPrinter *AP) const; | |||
470 | ||||
471 | /// Return the size of a value in bytes. | |||
472 | unsigned SizeOf(const AsmPrinter *AP) const; | |||
473 | ||||
474 | void print(raw_ostream &O) const; | |||
475 | void dump() const; | |||
476 | }; | |||
477 | ||||
478 | struct IntrusiveBackListNode { | |||
479 | PointerIntPair<IntrusiveBackListNode *, 1> Next; | |||
480 | ||||
481 | IntrusiveBackListNode() : Next(this, true) {} | |||
482 | ||||
483 | IntrusiveBackListNode *getNext() const { | |||
484 | return Next.getInt() ? nullptr : Next.getPointer(); | |||
485 | } | |||
486 | }; | |||
487 | ||||
488 | struct IntrusiveBackListBase { | |||
489 | using Node = IntrusiveBackListNode; | |||
490 | ||||
491 | Node *Last = nullptr; | |||
492 | ||||
493 | bool empty() const { return !Last; } | |||
494 | ||||
495 | void push_back(Node &N) { | |||
496 | assert(N.Next.getPointer() == &N && "Expected unlinked node")((N.Next.getPointer() == &N && "Expected unlinked node" ) ? static_cast<void> (0) : __assert_fail ("N.Next.getPointer() == &N && \"Expected unlinked node\"" , "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h" , 496, __PRETTY_FUNCTION__)); | |||
497 | assert(N.Next.getInt() == true && "Expected unlinked node")((N.Next.getInt() == true && "Expected unlinked node" ) ? static_cast<void> (0) : __assert_fail ("N.Next.getInt() == true && \"Expected unlinked node\"" , "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h" , 497, __PRETTY_FUNCTION__)); | |||
498 | ||||
499 | if (Last) { | |||
500 | N.Next = Last->Next; | |||
501 | Last->Next.setPointerAndInt(&N, false); | |||
502 | } | |||
503 | Last = &N; | |||
504 | } | |||
505 | }; | |||
506 | ||||
507 | template <class T> class IntrusiveBackList : IntrusiveBackListBase { | |||
508 | public: | |||
509 | using IntrusiveBackListBase::empty; | |||
510 | ||||
511 | void push_back(T &N) { IntrusiveBackListBase::push_back(N); } | |||
512 | T &back() { return *static_cast<T *>(Last); } | |||
513 | const T &back() const { return *static_cast<T *>(Last); } | |||
514 | ||||
515 | class const_iterator; | |||
516 | class iterator | |||
517 | : public iterator_facade_base<iterator, std::forward_iterator_tag, T> { | |||
518 | friend class const_iterator; | |||
519 | ||||
520 | Node *N = nullptr; | |||
521 | ||||
522 | public: | |||
523 | iterator() = default; | |||
524 | explicit iterator(T *N) : N(N) {} | |||
525 | ||||
526 | iterator &operator++() { | |||
527 | N = N->getNext(); | |||
528 | return *this; | |||
529 | } | |||
530 | ||||
531 | explicit operator bool() const { return N; } | |||
532 | T &operator*() const { return *static_cast<T *>(N); } | |||
533 | ||||
534 | bool operator==(const iterator &X) const { return N == X.N; } | |||
535 | bool operator!=(const iterator &X) const { return N != X.N; } | |||
536 | }; | |||
537 | ||||
538 | class const_iterator | |||
539 | : public iterator_facade_base<const_iterator, std::forward_iterator_tag, | |||
540 | const T> { | |||
541 | const Node *N = nullptr; | |||
542 | ||||
543 | public: | |||
544 | const_iterator() = default; | |||
545 | // Placate MSVC by explicitly scoping 'iterator'. | |||
546 | const_iterator(typename IntrusiveBackList<T>::iterator X) : N(X.N) {} | |||
547 | explicit const_iterator(const T *N) : N(N) {} | |||
548 | ||||
549 | const_iterator &operator++() { | |||
550 | N = N->getNext(); | |||
551 | return *this; | |||
552 | } | |||
553 | ||||
554 | explicit operator bool() const { return N; } | |||
555 | const T &operator*() const { return *static_cast<const T *>(N); } | |||
556 | ||||
557 | bool operator==(const const_iterator &X) const { return N == X.N; } | |||
558 | bool operator!=(const const_iterator &X) const { return N != X.N; } | |||
559 | }; | |||
560 | ||||
561 | iterator begin() { | |||
562 | return Last ? iterator(static_cast<T *>(Last->Next.getPointer())) : end(); | |||
563 | } | |||
564 | const_iterator begin() const { | |||
565 | return const_cast<IntrusiveBackList *>(this)->begin(); | |||
566 | } | |||
567 | iterator end() { return iterator(); } | |||
568 | const_iterator end() const { return const_iterator(); } | |||
569 | ||||
570 | static iterator toIterator(T &N) { return iterator(&N); } | |||
571 | static const_iterator toIterator(const T &N) { return const_iterator(&N); } | |||
572 | }; | |||
573 | ||||
574 | /// A list of DIE values. | |||
575 | /// | |||
576 | /// This is a singly-linked list, but instead of reversing the order of | |||
577 | /// insertion, we keep a pointer to the back of the list so we can push in | |||
578 | /// order. | |||
579 | /// | |||
580 | /// There are two main reasons to choose a linked list over a customized | |||
581 | /// vector-like data structure. | |||
582 | /// | |||
583 | /// 1. For teardown efficiency, we want DIEs to be BumpPtrAllocated. Using a | |||
584 | /// linked list here makes this way easier to accomplish. | |||
585 | /// 2. Carrying an extra pointer per \a DIEValue isn't expensive. 45% of DIEs | |||
586 | /// have 2 or fewer values, and 90% have 5 or fewer. A vector would be | |||
587 | /// over-allocated by 50% on average anyway, the same cost as the | |||
588 | /// linked-list node. | |||
589 | class DIEValueList { | |||
590 | struct Node : IntrusiveBackListNode { | |||
591 | DIEValue V; | |||
592 | ||||
593 | explicit Node(DIEValue V) : V(V) {} | |||
594 | }; | |||
595 | ||||
596 | using ListTy = IntrusiveBackList<Node>; | |||
597 | ||||
598 | ListTy List; | |||
599 | ||||
600 | public: | |||
601 | class const_value_iterator; | |||
602 | class value_iterator | |||
603 | : public iterator_adaptor_base<value_iterator, ListTy::iterator, | |||
604 | std::forward_iterator_tag, DIEValue> { | |||
605 | friend class const_value_iterator; | |||
606 | ||||
607 | using iterator_adaptor = | |||
608 | iterator_adaptor_base<value_iterator, ListTy::iterator, | |||
609 | std::forward_iterator_tag, DIEValue>; | |||
610 | ||||
611 | public: | |||
612 | value_iterator() = default; | |||
613 | explicit value_iterator(ListTy::iterator X) : iterator_adaptor(X) {} | |||
614 | ||||
615 | explicit operator bool() const { return bool(wrapped()); } | |||
616 | DIEValue &operator*() const { return wrapped()->V; } | |||
617 | }; | |||
618 | ||||
619 | class const_value_iterator : public iterator_adaptor_base< | |||
620 | const_value_iterator, ListTy::const_iterator, | |||
621 | std::forward_iterator_tag, const DIEValue> { | |||
622 | using iterator_adaptor = | |||
623 | iterator_adaptor_base<const_value_iterator, ListTy::const_iterator, | |||
624 | std::forward_iterator_tag, const DIEValue>; | |||
625 | ||||
626 | public: | |||
627 | const_value_iterator() = default; | |||
628 | const_value_iterator(DIEValueList::value_iterator X) | |||
629 | : iterator_adaptor(X.wrapped()) {} | |||
630 | explicit const_value_iterator(ListTy::const_iterator X) | |||
631 | : iterator_adaptor(X) {} | |||
632 | ||||
633 | explicit operator bool() const { return bool(wrapped()); } | |||
634 | const DIEValue &operator*() const { return wrapped()->V; } | |||
635 | }; | |||
636 | ||||
637 | using value_range = iterator_range<value_iterator>; | |||
638 | using const_value_range = iterator_range<const_value_iterator>; | |||
639 | ||||
640 | value_iterator addValue(BumpPtrAllocator &Alloc, const DIEValue &V) { | |||
641 | List.push_back(*new (Alloc) Node(V)); | |||
| ||||
642 | return value_iterator(ListTy::toIterator(List.back())); | |||
643 | } | |||
644 | template <class T> | |||
645 | value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute, | |||
646 | dwarf::Form Form, T &&Value) { | |||
647 | return addValue(Alloc, DIEValue(Attribute, Form, std::forward<T>(Value))); | |||
648 | } | |||
649 | ||||
650 | value_range values() { | |||
651 | return make_range(value_iterator(List.begin()), value_iterator(List.end())); | |||
652 | } | |||
653 | const_value_range values() const { | |||
654 | return make_range(const_value_iterator(List.begin()), | |||
655 | const_value_iterator(List.end())); | |||
656 | } | |||
657 | }; | |||
658 | ||||
659 | //===--------------------------------------------------------------------===// | |||
660 | /// A structured debug information entry. Has an abbreviation which | |||
661 | /// describes its organization. | |||
662 | class DIE : IntrusiveBackListNode, public DIEValueList { | |||
663 | friend class IntrusiveBackList<DIE>; | |||
664 | friend class DIEUnit; | |||
665 | ||||
666 | /// Dwarf unit relative offset. | |||
667 | unsigned Offset = 0; | |||
668 | /// Size of instance + children. | |||
669 | unsigned Size = 0; | |||
670 | unsigned AbbrevNumber = ~0u; | |||
671 | /// Dwarf tag code. | |||
672 | dwarf::Tag Tag = (dwarf::Tag)0; | |||
673 | /// Set to true to force a DIE to emit an abbreviation that says it has | |||
674 | /// children even when it doesn't. This is used for unit testing purposes. | |||
675 | bool ForceChildren = false; | |||
676 | /// Children DIEs. | |||
677 | IntrusiveBackList<DIE> Children; | |||
678 | ||||
679 | /// The owner is either the parent DIE for children of other DIEs, or a | |||
680 | /// DIEUnit which contains this DIE as its unit DIE. | |||
681 | PointerUnion<DIE *, DIEUnit *> Owner; | |||
682 | ||||
683 | explicit DIE(dwarf::Tag Tag) : Tag(Tag) {} | |||
684 | ||||
685 | public: | |||
686 | DIE() = delete; | |||
687 | DIE(const DIE &RHS) = delete; | |||
688 | DIE(DIE &&RHS) = delete; | |||
689 | DIE &operator=(const DIE &RHS) = delete; | |||
690 | DIE &operator=(const DIE &&RHS) = delete; | |||
691 | ||||
692 | static DIE *get(BumpPtrAllocator &Alloc, dwarf::Tag Tag) { | |||
693 | return new (Alloc) DIE(Tag); | |||
694 | } | |||
695 | ||||
696 | // Accessors. | |||
697 | unsigned getAbbrevNumber() const { return AbbrevNumber; } | |||
698 | dwarf::Tag getTag() const { return Tag; } | |||
699 | /// Get the compile/type unit relative offset of this DIE. | |||
700 | unsigned getOffset() const { return Offset; } | |||
701 | unsigned getSize() const { return Size; } | |||
702 | bool hasChildren() const { return ForceChildren || !Children.empty(); } | |||
703 | void setForceChildren(bool B) { ForceChildren = B; } | |||
704 | ||||
705 | using child_iterator = IntrusiveBackList<DIE>::iterator; | |||
706 | using const_child_iterator = IntrusiveBackList<DIE>::const_iterator; | |||
707 | using child_range = iterator_range<child_iterator>; | |||
708 | using const_child_range = iterator_range<const_child_iterator>; | |||
709 | ||||
710 | child_range children() { | |||
711 | return make_range(Children.begin(), Children.end()); | |||
712 | } | |||
713 | const_child_range children() const { | |||
714 | return make_range(Children.begin(), Children.end()); | |||
715 | } | |||
716 | ||||
717 | DIE *getParent() const; | |||
718 | ||||
719 | /// Generate the abbreviation for this DIE. | |||
720 | /// | |||
721 | /// Calculate the abbreviation for this, which should be uniqued and | |||
722 | /// eventually used to call \a setAbbrevNumber(). | |||
723 | DIEAbbrev generateAbbrev() const; | |||
724 | ||||
725 | /// Set the abbreviation number for this DIE. | |||
726 | void setAbbrevNumber(unsigned I) { AbbrevNumber = I; } | |||
727 | ||||
728 | /// Get the absolute offset within the .debug_info or .debug_types section | |||
729 | /// for this DIE. | |||
730 | unsigned getDebugSectionOffset() const; | |||
731 | ||||
732 | /// Compute the offset of this DIE and all its children. | |||
733 | /// | |||
734 | /// This function gets called just before we are going to generate the debug | |||
735 | /// information and gives each DIE a chance to figure out its CU relative DIE | |||
736 | /// offset, unique its abbreviation and fill in the abbreviation code, and | |||
737 | /// return the unit offset that points to where the next DIE will be emitted | |||
738 | /// within the debug unit section. After this function has been called for all | |||
739 | /// DIE objects, the DWARF can be generated since all DIEs will be able to | |||
740 | /// properly refer to other DIE objects since all DIEs have calculated their | |||
741 | /// offsets. | |||
742 | /// | |||
743 | /// \param AP AsmPrinter to use when calculating sizes. | |||
744 | /// \param AbbrevSet the abbreviation used to unique DIE abbreviations. | |||
745 | /// \param CUOffset the compile/type unit relative offset in bytes. | |||
746 | /// \returns the offset for the DIE that follows this DIE within the | |||
747 | /// current compile/type unit. | |||
748 | unsigned computeOffsetsAndAbbrevs(const AsmPrinter *AP, | |||
749 | DIEAbbrevSet &AbbrevSet, unsigned CUOffset); | |||
750 | ||||
751 | /// Climb up the parent chain to get the compile unit or type unit DIE that | |||
752 | /// this DIE belongs to. | |||
753 | /// | |||
754 | /// \returns the compile or type unit DIE that owns this DIE, or NULL if | |||
755 | /// this DIE hasn't been added to a unit DIE. | |||
756 | const DIE *getUnitDie() const; | |||
757 | ||||
758 | /// Climb up the parent chain to get the compile unit or type unit that this | |||
759 | /// DIE belongs to. | |||
760 | /// | |||
761 | /// \returns the DIEUnit that represents the compile or type unit that owns | |||
762 | /// this DIE, or NULL if this DIE hasn't been added to a unit DIE. | |||
763 | const DIEUnit *getUnit() const; | |||
764 | ||||
765 | void setOffset(unsigned O) { Offset = O; } | |||
766 | void setSize(unsigned S) { Size = S; } | |||
767 | ||||
768 | /// Add a child to the DIE. | |||
769 | DIE &addChild(DIE *Child) { | |||
770 | assert(!Child->getParent() && "Child should be orphaned")((!Child->getParent() && "Child should be orphaned" ) ? static_cast<void> (0) : __assert_fail ("!Child->getParent() && \"Child should be orphaned\"" , "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h" , 770, __PRETTY_FUNCTION__)); | |||
771 | Child->Owner = this; | |||
772 | Children.push_back(*Child); | |||
773 | return Children.back(); | |||
774 | } | |||
775 | ||||
776 | /// Find a value in the DIE with the attribute given. | |||
777 | /// | |||
778 | /// Returns a default-constructed DIEValue (where \a DIEValue::getType() | |||
779 | /// gives \a DIEValue::isNone) if no such attribute exists. | |||
780 | DIEValue findAttribute(dwarf::Attribute Attribute) const; | |||
781 | ||||
782 | void print(raw_ostream &O, unsigned IndentCount = 0) const; | |||
783 | void dump() const; | |||
784 | }; | |||
785 | ||||
786 | //===--------------------------------------------------------------------===// | |||
787 | /// Represents a compile or type unit. | |||
788 | class DIEUnit { | |||
789 | /// The compile unit or type unit DIE. This variable must be an instance of | |||
790 | /// DIE so that we can calculate the DIEUnit from any DIE by traversing the | |||
791 | /// parent backchain and getting the Unit DIE, and then casting itself to a | |||
792 | /// DIEUnit. This allows us to be able to find the DIEUnit for any DIE without | |||
793 | /// having to store a pointer to the DIEUnit in each DIE instance. | |||
794 | DIE Die; | |||
795 | /// The section this unit will be emitted in. This may or may not be set to | |||
796 | /// a valid section depending on the client that is emitting DWARF. | |||
797 | MCSection *Section; | |||
798 | uint64_t Offset; /// .debug_info or .debug_types absolute section offset. | |||
799 | uint32_t Length; /// The length in bytes of all of the DIEs in this unit. | |||
800 | const uint16_t Version; /// The Dwarf version number for this unit. | |||
801 | const uint8_t AddrSize; /// The size in bytes of an address for this unit. | |||
802 | protected: | |||
803 | ~DIEUnit() = default; | |||
804 | ||||
805 | public: | |||
806 | DIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag); | |||
807 | DIEUnit(const DIEUnit &RHS) = delete; | |||
808 | DIEUnit(DIEUnit &&RHS) = delete; | |||
809 | void operator=(const DIEUnit &RHS) = delete; | |||
810 | void operator=(const DIEUnit &&RHS) = delete; | |||
811 | /// Set the section that this DIEUnit will be emitted into. | |||
812 | /// | |||
813 | /// This function is used by some clients to set the section. Not all clients | |||
814 | /// that emit DWARF use this section variable. | |||
815 | void setSection(MCSection *Section) { | |||
816 | assert(!this->Section)((!this->Section) ? static_cast<void> (0) : __assert_fail ("!this->Section", "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h" , 816, __PRETTY_FUNCTION__)); | |||
817 | this->Section = Section; | |||
818 | } | |||
819 | ||||
820 | virtual const MCSymbol *getCrossSectionRelativeBaseAddress() const { | |||
821 | return nullptr; | |||
822 | } | |||
823 | ||||
824 | /// Return the section that this DIEUnit will be emitted into. | |||
825 | /// | |||
826 | /// \returns Section pointer which can be NULL. | |||
827 | MCSection *getSection() const { return Section; } | |||
828 | void setDebugSectionOffset(unsigned O) { Offset = O; } | |||
829 | unsigned getDebugSectionOffset() const { return Offset; } | |||
830 | void setLength(uint64_t L) { Length = L; } | |||
831 | uint64_t getLength() const { return Length; } | |||
832 | uint16_t getDwarfVersion() const { return Version; } | |||
833 | uint16_t getAddressSize() const { return AddrSize; } | |||
834 | DIE &getUnitDie() { return Die; } | |||
835 | const DIE &getUnitDie() const { return Die; } | |||
836 | }; | |||
837 | ||||
838 | struct BasicDIEUnit final : DIEUnit { | |||
839 | BasicDIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag) | |||
840 | : DIEUnit(Version, AddrSize, UnitTag) {} | |||
841 | }; | |||
842 | ||||
843 | //===--------------------------------------------------------------------===// | |||
844 | /// DIELoc - Represents an expression location. | |||
845 | // | |||
846 | class DIELoc : public DIEValueList { | |||
847 | mutable unsigned Size = 0; // Size in bytes excluding size header. | |||
848 | ||||
849 | public: | |||
850 | DIELoc() = default; | |||
851 | ||||
852 | /// ComputeSize - Calculate the size of the location expression. | |||
853 | /// | |||
854 | unsigned ComputeSize(const AsmPrinter *AP) const; | |||
855 | ||||
856 | /// BestForm - Choose the best form for data. | |||
857 | /// | |||
858 | dwarf::Form BestForm(unsigned DwarfVersion) const { | |||
859 | if (DwarfVersion > 3) | |||
860 | return dwarf::DW_FORM_exprloc; | |||
861 | // Pre-DWARF4 location expressions were blocks and not exprloc. | |||
862 | if ((unsigned char)Size == Size) | |||
863 | return dwarf::DW_FORM_block1; | |||
864 | if ((unsigned short)Size == Size) | |||
865 | return dwarf::DW_FORM_block2; | |||
866 | if ((unsigned int)Size == Size) | |||
867 | return dwarf::DW_FORM_block4; | |||
868 | return dwarf::DW_FORM_block; | |||
869 | } | |||
870 | ||||
871 | void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const; | |||
872 | unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const; | |||
873 | ||||
874 | void print(raw_ostream &O) const; | |||
875 | }; | |||
876 | ||||
877 | //===--------------------------------------------------------------------===// | |||
878 | /// DIEBlock - Represents a block of values. | |||
879 | // | |||
880 | class DIEBlock : public DIEValueList { | |||
881 | mutable unsigned Size = 0; // Size in bytes excluding size header. | |||
882 | ||||
883 | public: | |||
884 | DIEBlock() = default; | |||
885 | ||||
886 | /// ComputeSize - Calculate the size of the location expression. | |||
887 | /// | |||
888 | unsigned ComputeSize(const AsmPrinter *AP) const; | |||
889 | ||||
890 | /// BestForm - Choose the best form for data. | |||
891 | /// | |||
892 | dwarf::Form BestForm() const { | |||
893 | if ((unsigned char)Size == Size) | |||
894 | return dwarf::DW_FORM_block1; | |||
895 | if ((unsigned short)Size == Size) | |||
896 | return dwarf::DW_FORM_block2; | |||
897 | if ((unsigned int)Size == Size) | |||
898 | return dwarf::DW_FORM_block4; | |||
899 | return dwarf::DW_FORM_block; | |||
900 | } | |||
901 | ||||
902 | void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const; | |||
903 | unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const; | |||
904 | ||||
905 | void print(raw_ostream &O) const; | |||
906 | }; | |||
907 | ||||
908 | } // end namespace llvm | |||
909 | ||||
910 | #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H |