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