File: | lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp |
Warning: | line 952, column 22 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) | |||
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, dwarf::DW_FORM_GNU_addr_index, | |||
80 | DIEInteger(idx)); | |||
81 | } | |||
82 | ||||
83 | void DwarfCompileUnit::addLocalLabelAddress(DIE &Die, | |||
84 | dwarf::Attribute Attribute, | |||
85 | const MCSymbol *Label) { | |||
86 | if (Label) | |||
87 | DD->addArangeLabel(SymbolCU(this, Label)); | |||
88 | ||||
89 | if (Label) | |||
90 | Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr, | |||
91 | DIELabel(Label)); | |||
92 | else | |||
93 | Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr, | |||
94 | DIEInteger(0)); | |||
95 | } | |||
96 | ||||
97 | unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) { | |||
98 | // If we print assembly, we can't separate .file entries according to | |||
99 | // compile units. Thus all files will belong to the default compile unit. | |||
100 | ||||
101 | // FIXME: add a better feature test than hasRawTextSupport. Even better, | |||
102 | // extend .file to support this. | |||
103 | unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID(); | |||
104 | if (!File) | |||
105 | return Asm->OutStreamer->EmitDwarfFileDirective(0, "", "", nullptr, None, CUID); | |||
106 | return Asm->OutStreamer->EmitDwarfFileDirective( | |||
107 | 0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File), | |||
108 | File->getSource(), CUID); | |||
109 | } | |||
110 | ||||
111 | DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE( | |||
112 | const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) { | |||
113 | // Check for pre-existence. | |||
114 | if (DIE *Die = getDIE(GV)) | |||
115 | return Die; | |||
116 | ||||
117 | assert(GV)(static_cast <bool> (GV) ? void (0) : __assert_fail ("GV" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 117, __extension__ __PRETTY_FUNCTION__)); | |||
118 | ||||
119 | auto *GVContext = GV->getScope(); | |||
120 | auto *GTy = DD->resolve(GV->getType()); | |||
121 | ||||
122 | // Construct the context before querying for the existence of the DIE in | |||
123 | // case such construction creates the DIE. | |||
124 | DIE *ContextDIE = getOrCreateContextDIE(GVContext); | |||
125 | ||||
126 | // Add to map. | |||
127 | DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV); | |||
128 | DIScope *DeclContext; | |||
129 | if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) { | |||
130 | DeclContext = resolve(SDMDecl->getScope()); | |||
131 | assert(SDMDecl->isStaticMember() && "Expected static member decl")(static_cast <bool> (SDMDecl->isStaticMember() && "Expected static member decl") ? void (0) : __assert_fail ("SDMDecl->isStaticMember() && \"Expected static member decl\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 131, __extension__ __PRETTY_FUNCTION__)); | |||
132 | assert(GV->isDefinition())(static_cast <bool> (GV->isDefinition()) ? void (0) : __assert_fail ("GV->isDefinition()", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 132, __extension__ __PRETTY_FUNCTION__)); | |||
133 | // We need the declaration DIE that is in the static member's class. | |||
134 | DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl); | |||
135 | addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE); | |||
136 | // If the global variable's type is different from the one in the class | |||
137 | // member type, assume that it's more specific and also emit it. | |||
138 | if (GTy != DD->resolve(SDMDecl->getBaseType())) | |||
139 | addType(*VariableDIE, GTy); | |||
140 | } else { | |||
141 | DeclContext = GV->getScope(); | |||
142 | // Add name and type. | |||
143 | addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName()); | |||
144 | addType(*VariableDIE, GTy); | |||
145 | ||||
146 | // Add scoping info. | |||
147 | if (!GV->isLocalToUnit()) | |||
148 | addFlag(*VariableDIE, dwarf::DW_AT_external); | |||
149 | ||||
150 | // Add line number info. | |||
151 | addSourceLine(*VariableDIE, GV); | |||
152 | } | |||
153 | ||||
154 | if (!GV->isDefinition()) | |||
155 | addFlag(*VariableDIE, dwarf::DW_AT_declaration); | |||
156 | else | |||
157 | addGlobalName(GV->getName(), *VariableDIE, DeclContext); | |||
158 | ||||
159 | if (uint32_t AlignInBytes = GV->getAlignInBytes()) | |||
160 | addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, | |||
161 | AlignInBytes); | |||
162 | ||||
163 | // Add location. | |||
164 | bool addToAccelTable = false; | |||
165 | DIELoc *Loc = nullptr; | |||
166 | std::unique_ptr<DIEDwarfExpression> DwarfExpr; | |||
167 | for (const auto &GE : GlobalExprs) { | |||
168 | const GlobalVariable *Global = GE.Var; | |||
169 | const DIExpression *Expr = GE.Expr; | |||
170 | ||||
171 | // For compatibility with DWARF 3 and earlier, | |||
172 | // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes | |||
173 | // DW_AT_const_value(X). | |||
174 | if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) { | |||
175 | addToAccelTable = true; | |||
176 | addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1)); | |||
177 | break; | |||
178 | } | |||
179 | ||||
180 | // We cannot describe the location of dllimport'd variables: the | |||
181 | // computation of their address requires loads from the IAT. | |||
182 | if (Global && Global->hasDLLImportStorageClass()) | |||
183 | continue; | |||
184 | ||||
185 | // Nothing to describe without address or constant. | |||
186 | if (!Global && (!Expr || !Expr->isConstant())) | |||
187 | continue; | |||
188 | ||||
189 | if (!Loc) { | |||
190 | addToAccelTable = true; | |||
191 | Loc = new (DIEValueAllocator) DIELoc; | |||
192 | DwarfExpr = llvm::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc); | |||
193 | } | |||
194 | ||||
195 | if (Expr) | |||
196 | DwarfExpr->addFragmentOffset(Expr); | |||
197 | ||||
198 | if (Global) { | |||
199 | const MCSymbol *Sym = Asm->getSymbol(Global); | |||
200 | if (Global->isThreadLocal()) { | |||
201 | if (Asm->TM.useEmulatedTLS()) { | |||
202 | // TODO: add debug info for emulated thread local mode. | |||
203 | } else { | |||
204 | // FIXME: Make this work with -gsplit-dwarf. | |||
205 | unsigned PointerSize = Asm->getDataLayout().getPointerSize(); | |||
206 | assert((PointerSize == 4 || PointerSize == 8) &&(static_cast <bool> ((PointerSize == 4 || PointerSize == 8) && "Add support for other sizes if necessary") ? void (0) : __assert_fail ("(PointerSize == 4 || PointerSize == 8) && \"Add support for other sizes if necessary\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 207, __extension__ __PRETTY_FUNCTION__)) | |||
207 | "Add support for other sizes if necessary")(static_cast <bool> ((PointerSize == 4 || PointerSize == 8) && "Add support for other sizes if necessary") ? void (0) : __assert_fail ("(PointerSize == 4 || PointerSize == 8) && \"Add support for other sizes if necessary\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 207, __extension__ __PRETTY_FUNCTION__)); | |||
208 | // Based on GCC's support for TLS: | |||
209 | if (!DD->useSplitDwarf()) { | |||
210 | // 1) Start with a constNu of the appropriate pointer size | |||
211 | addUInt(*Loc, dwarf::DW_FORM_data1, | |||
212 | PointerSize == 4 ? dwarf::DW_OP_const4u | |||
213 | : dwarf::DW_OP_const8u); | |||
214 | // 2) containing the (relocated) offset of the TLS variable | |||
215 | // within the module's TLS block. | |||
216 | addExpr(*Loc, dwarf::DW_FORM_udata, | |||
217 | Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym)); | |||
218 | } else { | |||
219 | addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index); | |||
220 | addUInt(*Loc, dwarf::DW_FORM_udata, | |||
221 | DD->getAddressPool().getIndex(Sym, /* TLS */ true)); | |||
222 | } | |||
223 | // 3) followed by an OP to make the debugger do a TLS lookup. | |||
224 | addUInt(*Loc, dwarf::DW_FORM_data1, | |||
225 | DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address | |||
226 | : dwarf::DW_OP_form_tls_address); | |||
227 | } | |||
228 | } else { | |||
229 | DD->addArangeLabel(SymbolCU(this, Sym)); | |||
230 | addOpAddress(*Loc, Sym); | |||
231 | } | |||
232 | } | |||
233 | // Global variables attached to symbols are memory locations. | |||
234 | // It would be better if this were unconditional, but malformed input that | |||
235 | // mixes non-fragments and fragments for the same variable is too expensive | |||
236 | // to detect in the verifier. | |||
237 | if (DwarfExpr->isUnknownLocation()) | |||
238 | DwarfExpr->setMemoryLocationKind(); | |||
239 | DwarfExpr->addExpression(Expr); | |||
240 | } | |||
241 | if (Loc) | |||
242 | addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize()); | |||
243 | ||||
244 | if (DD->useAllLinkageNames()) | |||
245 | addLinkageName(*VariableDIE, GV->getLinkageName()); | |||
246 | ||||
247 | if (addToAccelTable) { | |||
248 | DD->addAccelName(GV->getName(), *VariableDIE); | |||
249 | ||||
250 | // If the linkage name is different than the name, go ahead and output | |||
251 | // that as well into the name table. | |||
252 | if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() && | |||
253 | DD->useAllLinkageNames()) | |||
254 | DD->addAccelName(GV->getLinkageName(), *VariableDIE); | |||
255 | } | |||
256 | ||||
257 | return VariableDIE; | |||
258 | } | |||
259 | ||||
260 | void DwarfCompileUnit::addRange(RangeSpan Range) { | |||
261 | bool SameAsPrevCU = this == DD->getPrevCU(); | |||
262 | DD->setPrevCU(this); | |||
263 | // If we have no current ranges just add the range and return, otherwise, | |||
264 | // check the current section and CU against the previous section and CU we | |||
265 | // emitted into and the subprogram was contained within. If these are the | |||
266 | // same then extend our current range, otherwise add this as a new range. | |||
267 | if (CURanges.empty() || !SameAsPrevCU || | |||
268 | (&CURanges.back().getEnd()->getSection() != | |||
269 | &Range.getEnd()->getSection())) { | |||
270 | CURanges.push_back(Range); | |||
271 | return; | |||
272 | } | |||
273 | ||||
274 | CURanges.back().setEnd(Range.getEnd()); | |||
275 | } | |||
276 | ||||
277 | void DwarfCompileUnit::initStmtList() { | |||
278 | // Define start line table label for each Compile Unit. | |||
279 | MCSymbol *LineTableStartSym; | |||
280 | const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); | |||
281 | if (DD->useSectionsAsReferences()) { | |||
282 | LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol(); | |||
283 | } else { | |||
284 | LineTableStartSym = | |||
285 | Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID()); | |||
286 | } | |||
287 | ||||
288 | // DW_AT_stmt_list is a offset of line number information for this | |||
289 | // compile unit in debug_line section. For split dwarf this is | |||
290 | // left in the skeleton CU and so not included. | |||
291 | // The line table entries are not always emitted in assembly, so it | |||
292 | // is not okay to use line_table_start here. | |||
293 | StmtListValue = | |||
294 | addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym, | |||
295 | TLOF.getDwarfLineSection()->getBeginSymbol()); | |||
296 | } | |||
297 | ||||
298 | void DwarfCompileUnit::applyStmtList(DIE &D) { | |||
299 | D.addValue(DIEValueAllocator, *StmtListValue); | |||
300 | } | |||
301 | ||||
302 | void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin, | |||
303 | const MCSymbol *End) { | |||
304 | assert(Begin && "Begin label should not be null!")(static_cast <bool> (Begin && "Begin label should not be null!" ) ? void (0) : __assert_fail ("Begin && \"Begin label should not be null!\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 304, __extension__ __PRETTY_FUNCTION__)); | |||
305 | assert(End && "End label should not be null!")(static_cast <bool> (End && "End label should not be null!" ) ? void (0) : __assert_fail ("End && \"End label should not be null!\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 305, __extension__ __PRETTY_FUNCTION__)); | |||
306 | assert(Begin->isDefined() && "Invalid starting label")(static_cast <bool> (Begin->isDefined() && "Invalid starting label" ) ? void (0) : __assert_fail ("Begin->isDefined() && \"Invalid starting label\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 306, __extension__ __PRETTY_FUNCTION__)); | |||
307 | assert(End->isDefined() && "Invalid end label")(static_cast <bool> (End->isDefined() && "Invalid end label" ) ? void (0) : __assert_fail ("End->isDefined() && \"Invalid end label\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 307, __extension__ __PRETTY_FUNCTION__)); | |||
308 | ||||
309 | addLabelAddress(D, dwarf::DW_AT_low_pc, Begin); | |||
310 | if (DD->getDwarfVersion() < 4) | |||
311 | addLabelAddress(D, dwarf::DW_AT_high_pc, End); | |||
312 | else | |||
313 | addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin); | |||
314 | } | |||
315 | ||||
316 | // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc | |||
317 | // and DW_AT_high_pc attributes. If there are global variables in this | |||
318 | // scope then create and insert DIEs for these variables. | |||
319 | DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) { | |||
320 | DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes()); | |||
321 | ||||
322 | attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd()); | |||
323 | if (DD->useAppleExtensionAttributes() && | |||
324 | !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim( | |||
325 | *DD->getCurrentFunction())) | |||
326 | addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr); | |||
327 | ||||
328 | // Only include DW_AT_frame_base in full debug info | |||
329 | if (!includeMinimalInlineScopes()) { | |||
330 | if (Asm->MF->getTarget().getTargetTriple().isNVPTX()) { | |||
331 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; | |||
332 | addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa); | |||
333 | addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc); | |||
334 | } else { | |||
335 | const TargetRegisterInfo *RI = Asm->MF->getSubtarget().getRegisterInfo(); | |||
336 | MachineLocation Location(RI->getFrameRegister(*Asm->MF)); | |||
337 | if (RI->isPhysicalRegister(Location.getReg())) | |||
338 | addAddress(*SPDie, dwarf::DW_AT_frame_base, Location); | |||
339 | } | |||
340 | } | |||
341 | ||||
342 | // Add name to the name table, we do this here because we're guaranteed | |||
343 | // to have concrete versions of our DW_TAG_subprogram nodes. | |||
344 | DD->addSubprogramNames(SP, *SPDie); | |||
345 | ||||
346 | return *SPDie; | |||
347 | } | |||
348 | ||||
349 | // Construct a DIE for this scope. | |||
350 | void DwarfCompileUnit::constructScopeDIE( | |||
351 | LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) { | |||
352 | if (!Scope || !Scope->getScopeNode()) | |||
353 | return; | |||
354 | ||||
355 | auto *DS = Scope->getScopeNode(); | |||
356 | ||||
357 | assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&(static_cast <bool> ((Scope->getInlinedAt() || !isa< DISubprogram>(DS)) && "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined " "subprograms" ) ? void (0) : __assert_fail ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 360, __extension__ __PRETTY_FUNCTION__)) | |||
358 | "Only handle inlined subprograms here, use "(static_cast <bool> ((Scope->getInlinedAt() || !isa< DISubprogram>(DS)) && "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined " "subprograms" ) ? void (0) : __assert_fail ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 360, __extension__ __PRETTY_FUNCTION__)) | |||
359 | "constructSubprogramScopeDIE for non-inlined "(static_cast <bool> ((Scope->getInlinedAt() || !isa< DISubprogram>(DS)) && "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined " "subprograms" ) ? void (0) : __assert_fail ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 360, __extension__ __PRETTY_FUNCTION__)) | |||
360 | "subprograms")(static_cast <bool> ((Scope->getInlinedAt() || !isa< DISubprogram>(DS)) && "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined " "subprograms" ) ? void (0) : __assert_fail ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 360, __extension__ __PRETTY_FUNCTION__)); | |||
361 | ||||
362 | SmallVector<DIE *, 8> Children; | |||
363 | ||||
364 | // We try to create the scope DIE first, then the children DIEs. This will | |||
365 | // avoid creating un-used children then removing them later when we find out | |||
366 | // the scope DIE is null. | |||
367 | DIE *ScopeDIE; | |||
368 | if (Scope->getParent() && isa<DISubprogram>(DS)) { | |||
369 | ScopeDIE = constructInlinedScopeDIE(Scope); | |||
370 | if (!ScopeDIE) | |||
371 | return; | |||
372 | // We create children when the scope DIE is not null. | |||
373 | createScopeChildrenDIE(Scope, Children); | |||
374 | } else { | |||
375 | // Early exit when we know the scope DIE is going to be null. | |||
376 | if (DD->isLexicalScopeDIENull(Scope)) | |||
377 | return; | |||
378 | ||||
379 | bool HasNonScopeChildren = false; | |||
380 | ||||
381 | // We create children here when we know the scope DIE is not going to be | |||
382 | // null and the children will be added to the scope DIE. | |||
383 | createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren); | |||
384 | ||||
385 | // If there are only other scopes as children, put them directly in the | |||
386 | // parent instead, as this scope would serve no purpose. | |||
387 | if (!HasNonScopeChildren) { | |||
388 | FinalChildren.insert(FinalChildren.end(), | |||
389 | std::make_move_iterator(Children.begin()), | |||
390 | std::make_move_iterator(Children.end())); | |||
391 | return; | |||
392 | } | |||
393 | ScopeDIE = constructLexicalScopeDIE(Scope); | |||
394 | assert(ScopeDIE && "Scope DIE should not be null.")(static_cast <bool> (ScopeDIE && "Scope DIE should not be null." ) ? void (0) : __assert_fail ("ScopeDIE && \"Scope DIE should not be null.\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 394, __extension__ __PRETTY_FUNCTION__)); | |||
395 | } | |||
396 | ||||
397 | // Add children | |||
398 | for (auto &I : Children) | |||
399 | ScopeDIE->addChild(std::move(I)); | |||
400 | ||||
401 | FinalChildren.push_back(std::move(ScopeDIE)); | |||
402 | } | |||
403 | ||||
404 | void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE, | |||
405 | SmallVector<RangeSpan, 2> Range) { | |||
406 | const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); | |||
407 | ||||
408 | // Emit the offset into .debug_ranges or .debug_rnglists as a relocatable | |||
409 | // label. emitDIE() will handle emitting it appropriately. | |||
410 | const MCSymbol *RangeSectionSym = | |||
411 | DD->getDwarfVersion() >= 5 | |||
412 | ? TLOF.getDwarfRnglistsSection()->getBeginSymbol() | |||
413 | : TLOF.getDwarfRangesSection()->getBeginSymbol(); | |||
414 | ||||
415 | RangeSpanList List(Asm->createTempSymbol("debug_ranges"), std::move(Range)); | |||
416 | ||||
417 | // Under fission, ranges are specified by constant offsets relative to the | |||
418 | // CU's DW_AT_GNU_ranges_base. | |||
419 | // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under | |||
420 | // fission until we support the forms using the .debug_addr section | |||
421 | // (DW_RLE_startx_endx etc.). | |||
422 | if (isDwoUnit()) { | |||
423 | if (DD->getDwarfVersion() < 5) | |||
424 | addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(), | |||
425 | RangeSectionSym); | |||
426 | } else { | |||
427 | addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(), | |||
428 | RangeSectionSym); | |||
429 | } | |||
430 | ||||
431 | // Add the range list to the set of ranges to be emitted. | |||
432 | (Skeleton ? Skeleton : this)->CURangeLists.push_back(std::move(List)); | |||
433 | } | |||
434 | ||||
435 | void DwarfCompileUnit::attachRangesOrLowHighPC( | |||
436 | DIE &Die, SmallVector<RangeSpan, 2> Ranges) { | |||
437 | if (Ranges.size() == 1 || !DD->useRangesSection()) { | |||
438 | const RangeSpan &Front = Ranges.front(); | |||
439 | const RangeSpan &Back = Ranges.back(); | |||
440 | attachLowHighPC(Die, Front.getStart(), Back.getEnd()); | |||
441 | } else | |||
442 | addScopeRangeList(Die, std::move(Ranges)); | |||
443 | } | |||
444 | ||||
445 | void DwarfCompileUnit::attachRangesOrLowHighPC( | |||
446 | DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) { | |||
447 | SmallVector<RangeSpan, 2> List; | |||
448 | List.reserve(Ranges.size()); | |||
449 | for (const InsnRange &R : Ranges) | |||
450 | List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first), | |||
451 | DD->getLabelAfterInsn(R.second))); | |||
452 | attachRangesOrLowHighPC(Die, std::move(List)); | |||
453 | } | |||
454 | ||||
455 | // This scope represents inlined body of a function. Construct DIE to | |||
456 | // represent this concrete inlined copy of the function. | |||
457 | DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) { | |||
458 | assert(Scope->getScopeNode())(static_cast <bool> (Scope->getScopeNode()) ? void ( 0) : __assert_fail ("Scope->getScopeNode()", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 458, __extension__ __PRETTY_FUNCTION__)); | |||
459 | auto *DS = Scope->getScopeNode(); | |||
460 | auto *InlinedSP = getDISubprogram(DS); | |||
461 | // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram | |||
462 | // was inlined from another compile unit. | |||
463 | DIE *OriginDIE = getAbstractSPDies()[InlinedSP]; | |||
464 | assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.")(static_cast <bool> (OriginDIE && "Unable to find original DIE for an inlined subprogram." ) ? void (0) : __assert_fail ("OriginDIE && \"Unable to find original DIE for an inlined subprogram.\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 464, __extension__ __PRETTY_FUNCTION__)); | |||
465 | ||||
466 | auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine); | |||
467 | addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE); | |||
468 | ||||
469 | attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges()); | |||
470 | ||||
471 | // Add the call site information to the DIE. | |||
472 | const DILocation *IA = Scope->getInlinedAt(); | |||
473 | addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None, | |||
474 | getOrCreateSourceID(IA->getFile())); | |||
475 | addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine()); | |||
476 | if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4) | |||
477 | addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None, | |||
478 | IA->getDiscriminator()); | |||
479 | ||||
480 | // Add name to the name table, we do this here because we're guaranteed | |||
481 | // to have concrete versions of our DW_TAG_inlined_subprogram nodes. | |||
482 | DD->addSubprogramNames(InlinedSP, *ScopeDIE); | |||
483 | ||||
484 | return ScopeDIE; | |||
485 | } | |||
486 | ||||
487 | // Construct new DW_TAG_lexical_block for this scope and attach | |||
488 | // DW_AT_low_pc/DW_AT_high_pc labels. | |||
489 | DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) { | |||
490 | if (DD->isLexicalScopeDIENull(Scope)) | |||
491 | return nullptr; | |||
492 | ||||
493 | auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block); | |||
494 | if (Scope->isAbstractScope()) | |||
495 | return ScopeDIE; | |||
496 | ||||
497 | attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges()); | |||
498 | ||||
499 | return ScopeDIE; | |||
500 | } | |||
501 | ||||
502 | /// constructVariableDIE - Construct a DIE for the given DbgVariable. | |||
503 | DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) { | |||
504 | auto D = constructVariableDIEImpl(DV, Abstract); | |||
505 | DV.setDIE(*D); | |||
506 | return D; | |||
507 | } | |||
508 | ||||
509 | DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV, | |||
510 | bool Abstract) { | |||
511 | // Define variable debug information entry. | |||
512 | auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag()); | |||
513 | insertDIE(DV.getVariable(), VariableDie); | |||
514 | ||||
515 | if (Abstract) { | |||
516 | applyVariableAttributes(DV, *VariableDie); | |||
517 | return VariableDie; | |||
518 | } | |||
519 | ||||
520 | // Add variable address. | |||
521 | ||||
522 | unsigned Offset = DV.getDebugLocListIndex(); | |||
523 | if (Offset != ~0U) { | |||
524 | addLocationList(*VariableDie, dwarf::DW_AT_location, Offset); | |||
525 | return VariableDie; | |||
526 | } | |||
527 | ||||
528 | // Check if variable is described by a DBG_VALUE instruction. | |||
529 | if (const MachineInstr *DVInsn = DV.getMInsn()) { | |||
530 | assert(DVInsn->getNumOperands() == 4)(static_cast <bool> (DVInsn->getNumOperands() == 4) ? void (0) : __assert_fail ("DVInsn->getNumOperands() == 4" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 530, __extension__ __PRETTY_FUNCTION__)); | |||
531 | if (DVInsn->getOperand(0).isReg()) { | |||
532 | auto RegOp = DVInsn->getOperand(0); | |||
533 | auto Op1 = DVInsn->getOperand(1); | |||
534 | // If the second operand is an immediate, this is an indirect value. | |||
535 | assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset")(static_cast <bool> ((!Op1.isImm() || (Op1.getImm() == 0 )) && "unexpected offset") ? void (0) : __assert_fail ("(!Op1.isImm() || (Op1.getImm() == 0)) && \"unexpected offset\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 535, __extension__ __PRETTY_FUNCTION__)); | |||
536 | MachineLocation Location(RegOp.getReg(), Op1.isImm()); | |||
537 | addVariableAddress(DV, *VariableDie, Location); | |||
538 | } else if (DVInsn->getOperand(0).isImm()) { | |||
539 | // This variable is described by a single constant. | |||
540 | // Check whether it has a DIExpression. | |||
541 | auto *Expr = DV.getSingleExpression(); | |||
542 | if (Expr && Expr->getNumElements()) { | |||
543 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; | |||
544 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); | |||
545 | // If there is an expression, emit raw unsigned bytes. | |||
546 | DwarfExpr.addFragmentOffset(Expr); | |||
547 | DwarfExpr.addUnsignedConstant(DVInsn->getOperand(0).getImm()); | |||
548 | DwarfExpr.addExpression(Expr); | |||
549 | addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); | |||
550 | } else | |||
551 | addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType()); | |||
552 | } else if (DVInsn->getOperand(0).isFPImm()) | |||
553 | addConstantFPValue(*VariableDie, DVInsn->getOperand(0)); | |||
554 | else if (DVInsn->getOperand(0).isCImm()) | |||
555 | addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(), | |||
556 | DV.getType()); | |||
557 | ||||
558 | return VariableDie; | |||
559 | } | |||
560 | ||||
561 | // .. else use frame index. | |||
562 | if (!DV.hasFrameIndexExprs()) | |||
563 | return VariableDie; | |||
564 | ||||
565 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; | |||
566 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); | |||
567 | for (auto &Fragment : DV.getFrameIndexExprs()) { | |||
568 | unsigned FrameReg = 0; | |||
569 | const DIExpression *Expr = Fragment.Expr; | |||
570 | const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering(); | |||
571 | int Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg); | |||
572 | DwarfExpr.addFragmentOffset(Expr); | |||
573 | SmallVector<uint64_t, 8> Ops; | |||
574 | Ops.push_back(dwarf::DW_OP_plus_uconst); | |||
575 | Ops.push_back(Offset); | |||
576 | Ops.append(Expr->elements_begin(), Expr->elements_end()); | |||
577 | DIExpressionCursor Cursor(Ops); | |||
578 | DwarfExpr.setMemoryLocationKind(); | |||
579 | if (const MCSymbol *FrameSymbol = Asm->getFunctionFrameSymbol()) | |||
580 | addOpAddress(*Loc, FrameSymbol); | |||
581 | else | |||
582 | DwarfExpr.addMachineRegExpression( | |||
583 | *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg); | |||
584 | DwarfExpr.addExpression(std::move(Cursor)); | |||
585 | } | |||
586 | addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); | |||
587 | ||||
588 | return VariableDie; | |||
589 | } | |||
590 | ||||
591 | DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, | |||
592 | const LexicalScope &Scope, | |||
593 | DIE *&ObjectPointer) { | |||
594 | auto Var = constructVariableDIE(DV, Scope.isAbstractScope()); | |||
595 | if (DV.isObjectPointer()) | |||
596 | ObjectPointer = Var; | |||
597 | return Var; | |||
598 | } | |||
599 | ||||
600 | /// Return all DIVariables that appear in count: expressions. | |||
601 | static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) { | |||
602 | SmallVector<const DIVariable *, 2> Result; | |||
603 | auto *Array = dyn_cast<DICompositeType>(Var->getType()); | |||
604 | if (!Array || Array->getTag() != dwarf::DW_TAG_array_type) | |||
605 | return Result; | |||
606 | for (auto *El : Array->getElements()) { | |||
607 | if (auto *Subrange = dyn_cast<DISubrange>(El)) { | |||
608 | auto Count = Subrange->getCount(); | |||
609 | if (auto *Dependency = Count.dyn_cast<DIVariable *>()) | |||
610 | Result.push_back(Dependency); | |||
611 | } | |||
612 | } | |||
613 | return Result; | |||
614 | } | |||
615 | ||||
616 | /// Sort local variables so that variables appearing inside of helper | |||
617 | /// expressions come first. | |||
618 | static SmallVector<DbgVariable *, 8> | |||
619 | sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) { | |||
620 | SmallVector<DbgVariable *, 8> Result; | |||
621 | SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList; | |||
622 | // Map back from a DIVariable to its containing DbgVariable. | |||
623 | SmallDenseMap<const DILocalVariable *, DbgVariable *> DbgVar; | |||
624 | // Set of DbgVariables in Result. | |||
625 | SmallDenseSet<DbgVariable *, 8> Visited; | |||
626 | // For cycle detection. | |||
627 | SmallDenseSet<DbgVariable *, 8> Visiting; | |||
628 | ||||
629 | // Initialize the worklist and the DIVariable lookup table. | |||
630 | for (auto Var : reverse(Input)) { | |||
631 | DbgVar.insert({Var->getVariable(), Var}); | |||
632 | WorkList.push_back({Var, 0}); | |||
633 | } | |||
634 | ||||
635 | // Perform a stable topological sort by doing a DFS. | |||
636 | while (!WorkList.empty()) { | |||
637 | auto Item = WorkList.back(); | |||
638 | DbgVariable *Var = Item.getPointer(); | |||
639 | bool visitedAllDependencies = Item.getInt(); | |||
640 | WorkList.pop_back(); | |||
641 | ||||
642 | // Dependency is in a different lexical scope or a global. | |||
643 | if (!Var) | |||
644 | continue; | |||
645 | ||||
646 | // Already handled. | |||
647 | if (Visited.count(Var)) | |||
648 | continue; | |||
649 | ||||
650 | // Add to Result if all dependencies are visited. | |||
651 | if (visitedAllDependencies) { | |||
652 | Visited.insert(Var); | |||
653 | Result.push_back(Var); | |||
654 | continue; | |||
655 | } | |||
656 | ||||
657 | // Detect cycles. | |||
658 | auto Res = Visiting.insert(Var); | |||
659 | if (!Res.second) { | |||
660 | assert(false && "dependency cycle in local variables")(static_cast <bool> (false && "dependency cycle in local variables" ) ? void (0) : __assert_fail ("false && \"dependency cycle in local variables\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 660, __extension__ __PRETTY_FUNCTION__)); | |||
661 | return Result; | |||
662 | } | |||
663 | ||||
664 | // Push dependencies and this node onto the worklist, so that this node is | |||
665 | // visited again after all of its dependencies are handled. | |||
666 | WorkList.push_back({Var, 1}); | |||
667 | for (auto *Dependency : dependencies(Var)) { | |||
668 | auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency); | |||
669 | WorkList.push_back({DbgVar[Dep], 0}); | |||
670 | } | |||
671 | } | |||
672 | return Result; | |||
673 | } | |||
674 | ||||
675 | DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope, | |||
676 | SmallVectorImpl<DIE *> &Children, | |||
677 | bool *HasNonScopeChildren) { | |||
678 | assert(Children.empty())(static_cast <bool> (Children.empty()) ? void (0) : __assert_fail ("Children.empty()", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 678, __extension__ __PRETTY_FUNCTION__)); | |||
679 | DIE *ObjectPointer = nullptr; | |||
680 | ||||
681 | // Emit function arguments (order is significant). | |||
682 | auto Vars = DU->getScopeVariables().lookup(Scope); | |||
683 | for (auto &DV : Vars.Args) | |||
684 | Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer)); | |||
685 | ||||
686 | // Emit local variables. | |||
687 | auto Locals = sortLocalVars(Vars.Locals); | |||
688 | for (DbgVariable *DV : Locals) | |||
689 | Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer)); | |||
690 | ||||
691 | // Skip imported directives in gmlt-like data. | |||
692 | if (!includeMinimalInlineScopes()) { | |||
693 | // There is no need to emit empty lexical block DIE. | |||
694 | for (const auto *IE : ImportedEntities[Scope->getScopeNode()]) | |||
695 | Children.push_back( | |||
696 | constructImportedEntityDIE(cast<DIImportedEntity>(IE))); | |||
697 | } | |||
698 | ||||
699 | if (HasNonScopeChildren) | |||
700 | *HasNonScopeChildren = !Children.empty(); | |||
701 | ||||
702 | for (LexicalScope *LS : Scope->getChildren()) | |||
703 | constructScopeDIE(LS, Children); | |||
704 | ||||
705 | return ObjectPointer; | |||
706 | } | |||
707 | ||||
708 | void DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope) { | |||
709 | DIE &ScopeDIE = updateSubprogramScopeDIE(Sub); | |||
| ||||
710 | ||||
711 | if (Scope) { | |||
712 | assert(!Scope->getInlinedAt())(static_cast <bool> (!Scope->getInlinedAt()) ? void ( 0) : __assert_fail ("!Scope->getInlinedAt()", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 712, __extension__ __PRETTY_FUNCTION__)); | |||
713 | assert(!Scope->isAbstractScope())(static_cast <bool> (!Scope->isAbstractScope()) ? void (0) : __assert_fail ("!Scope->isAbstractScope()", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 713, __extension__ __PRETTY_FUNCTION__)); | |||
714 | // Collect lexical scope children first. | |||
715 | // ObjectPointer might be a local (non-argument) local variable if it's a | |||
716 | // block's synthetic this pointer. | |||
717 | if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE)) | |||
718 | addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer); | |||
719 | } | |||
720 | ||||
721 | // If this is a variadic function, add an unspecified parameter. | |||
722 | DITypeRefArray FnArgs = Sub->getType()->getTypeArray(); | |||
723 | ||||
724 | // If we have a single element of null, it is a function that returns void. | |||
725 | // If we have more than one elements and the last one is null, it is a | |||
726 | // variadic function. | |||
727 | if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] && | |||
728 | !includeMinimalInlineScopes()) | |||
729 | ScopeDIE.addChild( | |||
730 | DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters)); | |||
731 | } | |||
732 | ||||
733 | DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope, | |||
734 | DIE &ScopeDIE) { | |||
735 | // We create children when the scope DIE is not null. | |||
736 | SmallVector<DIE *, 8> Children; | |||
737 | DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children); | |||
738 | ||||
739 | // Add children | |||
740 | for (auto &I : Children) | |||
741 | ScopeDIE.addChild(std::move(I)); | |||
742 | ||||
743 | return ObjectPointer; | |||
744 | } | |||
745 | ||||
746 | void DwarfCompileUnit::constructAbstractSubprogramScopeDIE( | |||
747 | LexicalScope *Scope) { | |||
748 | DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()]; | |||
749 | if (AbsDef) | |||
750 | return; | |||
751 | ||||
752 | auto *SP = cast<DISubprogram>(Scope->getScopeNode()); | |||
753 | ||||
754 | DIE *ContextDIE; | |||
755 | DwarfCompileUnit *ContextCU = this; | |||
756 | ||||
757 | if (includeMinimalInlineScopes()) | |||
758 | ContextDIE = &getUnitDie(); | |||
759 | // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with | |||
760 | // the important distinction that the debug node is not associated with the | |||
761 | // DIE (since the debug node will be associated with the concrete DIE, if | |||
762 | // any). It could be refactored to some common utility function. | |||
763 | else if (auto *SPDecl = SP->getDeclaration()) { | |||
764 | ContextDIE = &getUnitDie(); | |||
765 | getOrCreateSubprogramDIE(SPDecl); | |||
766 | } else { | |||
767 | ContextDIE = getOrCreateContextDIE(resolve(SP->getScope())); | |||
768 | // The scope may be shared with a subprogram that has already been | |||
769 | // constructed in another CU, in which case we need to construct this | |||
770 | // subprogram in the same CU. | |||
771 | ContextCU = DD->lookupCU(ContextDIE->getUnitDie()); | |||
772 | } | |||
773 | ||||
774 | // Passing null as the associated node because the abstract definition | |||
775 | // shouldn't be found by lookup. | |||
776 | AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr); | |||
777 | ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef); | |||
778 | ||||
779 | if (!ContextCU->includeMinimalInlineScopes()) | |||
780 | ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined); | |||
781 | if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef)) | |||
782 | ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer); | |||
783 | } | |||
784 | ||||
785 | DIE *DwarfCompileUnit::constructImportedEntityDIE( | |||
786 | const DIImportedEntity *Module) { | |||
787 | DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag()); | |||
788 | insertDIE(Module, IMDie); | |||
789 | DIE *EntityDie; | |||
790 | auto *Entity = resolve(Module->getEntity()); | |||
791 | if (auto *NS = dyn_cast<DINamespace>(Entity)) | |||
792 | EntityDie = getOrCreateNameSpace(NS); | |||
793 | else if (auto *M = dyn_cast<DIModule>(Entity)) | |||
794 | EntityDie = getOrCreateModule(M); | |||
795 | else if (auto *SP = dyn_cast<DISubprogram>(Entity)) | |||
796 | EntityDie = getOrCreateSubprogramDIE(SP); | |||
797 | else if (auto *T = dyn_cast<DIType>(Entity)) | |||
798 | EntityDie = getOrCreateTypeDIE(T); | |||
799 | else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity)) | |||
800 | EntityDie = getOrCreateGlobalVariableDIE(GV, {}); | |||
801 | else | |||
802 | EntityDie = getDIE(Entity); | |||
803 | assert(EntityDie)(static_cast <bool> (EntityDie) ? void (0) : __assert_fail ("EntityDie", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 803, __extension__ __PRETTY_FUNCTION__)); | |||
804 | addSourceLine(*IMDie, Module->getLine(), Module->getFile()); | |||
805 | addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie); | |||
806 | StringRef Name = Module->getName(); | |||
807 | if (!Name.empty()) | |||
808 | addString(*IMDie, dwarf::DW_AT_name, Name); | |||
809 | ||||
810 | return IMDie; | |||
811 | } | |||
812 | ||||
813 | void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) { | |||
814 | DIE *D = getDIE(SP); | |||
815 | if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) { | |||
816 | if (D) | |||
817 | // If this subprogram has an abstract definition, reference that | |||
818 | addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE); | |||
819 | } else { | |||
820 | assert(D || includeMinimalInlineScopes())(static_cast <bool> (D || includeMinimalInlineScopes()) ? void (0) : __assert_fail ("D || includeMinimalInlineScopes()" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 820, __extension__ __PRETTY_FUNCTION__)); | |||
821 | if (D) | |||
822 | // And attach the attributes | |||
823 | applySubprogramAttributesToDefinition(SP, *D); | |||
824 | } | |||
825 | } | |||
826 | ||||
827 | void DwarfCompileUnit::finishVariableDefinition(const DbgVariable &Var) { | |||
828 | DbgVariable *AbsVar = getExistingAbstractVariable( | |||
829 | InlinedVariable(Var.getVariable(), Var.getInlinedAt())); | |||
830 | auto *VariableDie = Var.getDIE(); | |||
831 | if (AbsVar && AbsVar->getDIE()) { | |||
832 | addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin, | |||
833 | *AbsVar->getDIE()); | |||
834 | } else | |||
835 | applyVariableAttributes(Var, *VariableDie); | |||
836 | } | |||
837 | ||||
838 | DbgVariable *DwarfCompileUnit::getExistingAbstractVariable(InlinedVariable IV) { | |||
839 | const DILocalVariable *Cleansed; | |||
840 | return getExistingAbstractVariable(IV, Cleansed); | |||
841 | } | |||
842 | ||||
843 | // Find abstract variable, if any, associated with Var. | |||
844 | DbgVariable *DwarfCompileUnit::getExistingAbstractVariable( | |||
845 | InlinedVariable IV, const DILocalVariable *&Cleansed) { | |||
846 | // More then one inlined variable corresponds to one abstract variable. | |||
847 | Cleansed = IV.first; | |||
848 | auto &AbstractVariables = getAbstractVariables(); | |||
849 | auto I = AbstractVariables.find(Cleansed); | |||
850 | if (I != AbstractVariables.end()) | |||
851 | return I->second.get(); | |||
852 | return nullptr; | |||
853 | } | |||
854 | ||||
855 | void DwarfCompileUnit::createAbstractVariable(const DILocalVariable *Var, | |||
856 | LexicalScope *Scope) { | |||
857 | assert(Scope && Scope->isAbstractScope())(static_cast <bool> (Scope && Scope->isAbstractScope ()) ? void (0) : __assert_fail ("Scope && Scope->isAbstractScope()" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 857, __extension__ __PRETTY_FUNCTION__)); | |||
858 | auto AbsDbgVariable = llvm::make_unique<DbgVariable>(Var, /* IA */ nullptr); | |||
859 | DU->addScopeVariable(Scope, AbsDbgVariable.get()); | |||
860 | getAbstractVariables()[Var] = std::move(AbsDbgVariable); | |||
861 | } | |||
862 | ||||
863 | void DwarfCompileUnit::emitHeader(bool UseOffsets) { | |||
864 | // Don't bother labeling the .dwo unit, as its offset isn't used. | |||
865 | if (!Skeleton && !DD->useSectionsAsReferences()) { | |||
866 | LabelBegin = Asm->createTempSymbol("cu_begin"); | |||
867 | Asm->OutStreamer->EmitLabel(LabelBegin); | |||
868 | } | |||
869 | ||||
870 | dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile | |||
871 | : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton | |||
872 | : dwarf::DW_UT_compile; | |||
873 | DwarfUnit::emitCommonHeader(UseOffsets, UT); | |||
874 | if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile) | |||
875 | Asm->emitInt64(getDWOId()); | |||
876 | } | |||
877 | ||||
878 | bool DwarfCompileUnit::hasDwarfPubSections() const { | |||
879 | // Opting in to GNU Pubnames/types overrides the default to ensure these are | |||
880 | // generated for things like Gold's gdb_index generation. | |||
881 | if (CUNode->getGnuPubnames()) | |||
882 | return true; | |||
883 | ||||
884 | return DD->tuneForGDB() && DD->usePubSections() && | |||
885 | !includeMinimalInlineScopes(); | |||
886 | } | |||
887 | ||||
888 | /// addGlobalName - Add a new global name to the compile unit. | |||
889 | void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die, | |||
890 | const DIScope *Context) { | |||
891 | if (!hasDwarfPubSections()) | |||
892 | return; | |||
893 | std::string FullName = getParentContextString(Context) + Name.str(); | |||
894 | GlobalNames[FullName] = &Die; | |||
895 | } | |||
896 | ||||
897 | void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name, | |||
898 | const DIScope *Context) { | |||
899 | if (!hasDwarfPubSections()) | |||
900 | return; | |||
901 | std::string FullName = getParentContextString(Context) + Name.str(); | |||
902 | // Insert, allowing the entry to remain as-is if it's already present | |||
903 | // This way the CU-level type DIE is preferred over the "can't describe this | |||
904 | // type as a unit offset because it's not really in the CU at all, it's only | |||
905 | // in a type unit" | |||
906 | GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie())); | |||
907 | } | |||
908 | ||||
909 | /// Add a new global type to the unit. | |||
910 | void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die, | |||
911 | const DIScope *Context) { | |||
912 | if (!hasDwarfPubSections()) | |||
913 | return; | |||
914 | std::string FullName = getParentContextString(Context) + Ty->getName().str(); | |||
915 | GlobalTypes[FullName] = &Die; | |||
916 | } | |||
917 | ||||
918 | void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty, | |||
919 | const DIScope *Context) { | |||
920 | if (!hasDwarfPubSections()) | |||
921 | return; | |||
922 | std::string FullName = getParentContextString(Context) + Ty->getName().str(); | |||
923 | // Insert, allowing the entry to remain as-is if it's already present | |||
924 | // This way the CU-level type DIE is preferred over the "can't describe this | |||
925 | // type as a unit offset because it's not really in the CU at all, it's only | |||
926 | // in a type unit" | |||
927 | GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie())); | |||
928 | } | |||
929 | ||||
930 | /// addVariableAddress - Add DW_AT_location attribute for a | |||
931 | /// DbgVariable based on provided MachineLocation. | |||
932 | void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die, | |||
933 | MachineLocation Location) { | |||
934 | // addBlockByrefAddress is obsolete and will be removed soon. | |||
935 | // The clang frontend always generates block byref variables with a | |||
936 | // complex expression that encodes exactly what addBlockByrefAddress | |||
937 | // would do. | |||
938 | assert((!DV.isBlockByrefVariable() || DV.hasComplexAddress()) &&(static_cast <bool> ((!DV.isBlockByrefVariable() || DV. hasComplexAddress()) && "block byref variable without a complex expression" ) ? void (0) : __assert_fail ("(!DV.isBlockByrefVariable() || DV.hasComplexAddress()) && \"block byref variable without a complex expression\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 939, __extension__ __PRETTY_FUNCTION__)) | |||
939 | "block byref variable without a complex expression")(static_cast <bool> ((!DV.isBlockByrefVariable() || DV. hasComplexAddress()) && "block byref variable without a complex expression" ) ? void (0) : __assert_fail ("(!DV.isBlockByrefVariable() || DV.hasComplexAddress()) && \"block byref variable without a complex expression\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp" , 939, __extension__ __PRETTY_FUNCTION__)); | |||
940 | if (DV.hasComplexAddress()) | |||
941 | addComplexAddress(DV, Die, dwarf::DW_AT_location, Location); | |||
942 | else if (DV.isBlockByrefVariable()) | |||
943 | addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location); | |||
944 | else | |||
945 | addAddress(Die, dwarf::DW_AT_location, Location); | |||
946 | } | |||
947 | ||||
948 | /// Add an address attribute to a die based on the location provided. | |||
949 | void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute, | |||
950 | const MachineLocation &Location) { | |||
951 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; | |||
952 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); | |||
| ||||
953 | if (Location.isIndirect()) | |||
954 | DwarfExpr.setMemoryLocationKind(); | |||
955 | ||||
956 | DIExpressionCursor Cursor({}); | |||
957 | const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); | |||
958 | if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg())) | |||
959 | return; | |||
960 | DwarfExpr.addExpression(std::move(Cursor)); | |||
961 | ||||
962 | // Now attach the location information to the DIE. | |||
963 | addBlock(Die, Attribute, DwarfExpr.finalize()); | |||
964 | } | |||
965 | ||||
966 | /// Start with the address based on the location provided, and generate the | |||
967 | /// DWARF information necessary to find the actual variable given the extra | |||
968 | /// address information encoded in the DbgVariable, starting from the starting | |||
969 | /// location. Add the DWARF information to the die. | |||
970 | void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die, | |||
971 | dwarf::Attribute Attribute, | |||
972 | const MachineLocation &Location) { | |||
973 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; | |||
974 | DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); | |||
975 | const DIExpression *DIExpr = DV.getSingleExpression(); | |||
976 | DwarfExpr.addFragmentOffset(DIExpr); | |||
977 | if (Location.isIndirect()) | |||
978 | DwarfExpr.setMemoryLocationKind(); | |||
979 | ||||
980 | DIExpressionCursor Cursor(DIExpr); | |||
981 | const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); | |||
982 | if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg())) | |||
983 | return; | |||
984 | DwarfExpr.addExpression(std::move(Cursor)); | |||
985 | ||||
986 | // Now attach the location information to the DIE. | |||
987 | addBlock(Die, Attribute, DwarfExpr.finalize()); | |||
988 | } | |||
989 | ||||
990 | /// Add a Dwarf loclistptr attribute data and value. | |||
991 | void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute, | |||
992 | unsigned Index) { | |||
993 | dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset | |||
994 | : dwarf::DW_FORM_data4; | |||
995 | Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index)); | |||
996 | } | |||
997 | ||||
998 | void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var, | |||
999 | DIE &VariableDie) { | |||
1000 | StringRef Name = Var.getName(); | |||
1001 | if (!Name.empty()) | |||
1002 | addString(VariableDie, dwarf::DW_AT_name, Name); | |||
1003 | const auto *DIVar = Var.getVariable(); | |||
1004 | if (DIVar) | |||
1005 | if (uint32_t AlignInBytes = DIVar->getAlignInBytes()) | |||
1006 | addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, | |||
1007 | AlignInBytes); | |||
1008 | ||||
1009 | addSourceLine(VariableDie, DIVar); | |||
1010 | addType(VariableDie, Var.getType()); | |||
1011 | if (Var.isArtificial()) | |||
1012 | addFlag(VariableDie, dwarf::DW_AT_artificial); | |||
1013 | } | |||
1014 | ||||
1015 | /// Add a Dwarf expression attribute data and value. | |||
1016 | void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form, | |||
1017 | const MCExpr *Expr) { | |||
1018 | Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr)); | |||
1019 | } | |||
1020 | ||||
1021 | void DwarfCompileUnit::applySubprogramAttributesToDefinition( | |||
1022 | const DISubprogram *SP, DIE &SPDie) { | |||
1023 | auto *SPDecl = SP->getDeclaration(); | |||
1024 | auto *Context = resolve(SPDecl ? SPDecl->getScope() : SP->getScope()); | |||
1025 | applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes()); | |||
1026 | addGlobalName(SP->getName(), SPDie, Context); | |||
1027 | } | |||
1028 | ||||
1029 | bool DwarfCompileUnit::isDwoUnit() const { | |||
1030 | return DD->useSplitDwarf() && Skeleton; | |||
1031 | } | |||
1032 | ||||
1033 | bool DwarfCompileUnit::includeMinimalInlineScopes() const { | |||
1034 | return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly || | |||
1035 | (DD->useSplitDwarf() && !Skeleton); | |||
1036 | } |