1 //===- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Units ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for constructing a dwarf compile unit.
12 //===----------------------------------------------------------------------===//
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"
55 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node,
56 AsmPrinter *A, DwarfDebug *DW,
58 : DwarfUnit(dwarf::DW_TAG_compile_unit, Node, A, DW, DWU), UniqueID(UID) {
59 insertDIE(Node, &getUnitDie());
60 MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin");
63 /// addLabelAddress - Add a dwarf label attribute data and value using
64 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
65 void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
66 const MCSymbol *Label) {
67 // Don't use the address pool in non-fission or in the skeleton unit itself.
68 // FIXME: Once GDB supports this, it's probably worthwhile using the address
69 // pool from the skeleton - maybe even in non-fission (possibly fewer
70 // relocations by sharing them in the pool, but we have other ideas about how
71 // to reduce the number of relocations as well/instead).
72 if ((!DD->useSplitDwarf() || !Skeleton) && DD->getDwarfVersion() < 5)
73 return addLocalLabelAddress(Die, Attribute, Label);
76 DD->addArangeLabel(SymbolCU(this, Label));
78 unsigned idx = DD->getAddressPool().getIndex(Label);
79 Die.addValue(DIEValueAllocator, Attribute,
80 DD->getDwarfVersion() >= 5 ? dwarf::DW_FORM_addrx
81 : dwarf::DW_FORM_GNU_addr_index,
85 void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
86 dwarf::Attribute Attribute,
87 const MCSymbol *Label) {
89 DD->addArangeLabel(SymbolCU(this, Label));
92 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
95 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
99 unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
100 // If we print assembly, we can't separate .file entries according to
101 // compile units. Thus all files will belong to the default compile unit.
103 // FIXME: add a better feature test than hasRawTextSupport. Even better,
104 // extend .file to support this.
105 unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID();
107 return Asm->OutStreamer->EmitDwarfFileDirective(0, "", "", nullptr, None, CUID);
108 return Asm->OutStreamer->EmitDwarfFileDirective(
109 0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File),
110 File->getSource(), CUID);
113 DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
114 const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
115 // Check for pre-existence.
116 if (DIE *Die = getDIE(GV))
121 auto *GVContext = GV->getScope();
122 auto *GTy = DD->resolve(GV->getType());
124 // Construct the context before querying for the existence of the DIE in
125 // case such construction creates the DIE.
126 DIE *ContextDIE = getOrCreateContextDIE(GVContext);
129 DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV);
130 DIScope *DeclContext;
131 if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
132 DeclContext = resolve(SDMDecl->getScope());
133 assert(SDMDecl->isStaticMember() && "Expected static member decl");
134 assert(GV->isDefinition());
135 // We need the declaration DIE that is in the static member's class.
136 DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
137 addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE);
138 // If the global variable's type is different from the one in the class
139 // member type, assume that it's more specific and also emit it.
140 if (GTy != DD->resolve(SDMDecl->getBaseType()))
141 addType(*VariableDIE, GTy);
143 DeclContext = GV->getScope();
144 // Add name and type.
145 addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName());
146 addType(*VariableDIE, GTy);
149 if (!GV->isLocalToUnit())
150 addFlag(*VariableDIE, dwarf::DW_AT_external);
152 // Add line number info.
153 addSourceLine(*VariableDIE, GV);
156 if (!GV->isDefinition())
157 addFlag(*VariableDIE, dwarf::DW_AT_declaration);
159 addGlobalName(GV->getName(), *VariableDIE, DeclContext);
161 if (uint32_t AlignInBytes = GV->getAlignInBytes())
162 addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
165 if (MDTuple *TP = GV->getTemplateParams())
166 addTemplateParams(*VariableDIE, DINodeArray(TP));
169 bool addToAccelTable = false;
170 DIELoc *Loc = nullptr;
171 std::unique_ptr<DIEDwarfExpression> DwarfExpr;
172 for (const auto &GE : GlobalExprs) {
173 const GlobalVariable *Global = GE.Var;
174 const DIExpression *Expr = GE.Expr;
176 // For compatibility with DWARF 3 and earlier,
177 // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes
178 // DW_AT_const_value(X).
179 if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {
180 addToAccelTable = true;
181 addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1));
185 // We cannot describe the location of dllimport'd variables: the
186 // computation of their address requires loads from the IAT.
187 if (Global && Global->hasDLLImportStorageClass())
190 // Nothing to describe without address or constant.
191 if (!Global && (!Expr || !Expr->isConstant()))
194 if (Global && Global->isThreadLocal() &&
195 !Asm->getObjFileLowering().supportDebugThreadLocalLocation())
199 addToAccelTable = true;
200 Loc = new (DIEValueAllocator) DIELoc;
201 DwarfExpr = llvm::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc);
205 DwarfExpr->addFragmentOffset(Expr);
208 const MCSymbol *Sym = Asm->getSymbol(Global);
209 if (Global->isThreadLocal()) {
210 if (Asm->TM.useEmulatedTLS()) {
211 // TODO: add debug info for emulated thread local mode.
213 // FIXME: Make this work with -gsplit-dwarf.
214 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
215 assert((PointerSize == 4 || PointerSize == 8) &&
216 "Add support for other sizes if necessary");
217 // Based on GCC's support for TLS:
218 if (!DD->useSplitDwarf()) {
219 // 1) Start with a constNu of the appropriate pointer size
220 addUInt(*Loc, dwarf::DW_FORM_data1,
221 PointerSize == 4 ? dwarf::DW_OP_const4u
222 : dwarf::DW_OP_const8u);
223 // 2) containing the (relocated) offset of the TLS variable
224 // within the module's TLS block.
225 addExpr(*Loc, dwarf::DW_FORM_udata,
226 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
228 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
229 addUInt(*Loc, dwarf::DW_FORM_udata,
230 DD->getAddressPool().getIndex(Sym, /* TLS */ true));
232 // 3) followed by an OP to make the debugger do a TLS lookup.
233 addUInt(*Loc, dwarf::DW_FORM_data1,
234 DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address
235 : dwarf::DW_OP_form_tls_address);
238 DD->addArangeLabel(SymbolCU(this, Sym));
239 addOpAddress(*Loc, Sym);
242 // Global variables attached to symbols are memory locations.
243 // It would be better if this were unconditional, but malformed input that
244 // mixes non-fragments and fragments for the same variable is too expensive
245 // to detect in the verifier.
246 if (DwarfExpr->isUnknownLocation())
247 DwarfExpr->setMemoryLocationKind();
248 DwarfExpr->addExpression(Expr);
251 addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize());
253 if (DD->useAllLinkageNames())
254 addLinkageName(*VariableDIE, GV->getLinkageName());
256 if (addToAccelTable) {
257 DD->addAccelName(*CUNode, GV->getName(), *VariableDIE);
259 // If the linkage name is different than the name, go ahead and output
260 // that as well into the name table.
261 if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() &&
262 DD->useAllLinkageNames())
263 DD->addAccelName(*CUNode, GV->getLinkageName(), *VariableDIE);
269 void DwarfCompileUnit::addRange(RangeSpan Range) {
270 bool SameAsPrevCU = this == DD->getPrevCU();
272 // If we have no current ranges just add the range and return, otherwise,
273 // check the current section and CU against the previous section and CU we
274 // emitted into and the subprogram was contained within. If these are the
275 // same then extend our current range, otherwise add this as a new range.
276 if (CURanges.empty() || !SameAsPrevCU ||
277 (&CURanges.back().getEnd()->getSection() !=
278 &Range.getEnd()->getSection())) {
279 CURanges.push_back(Range);
280 DD->addSectionLabel(Range.getStart());
284 CURanges.back().setEnd(Range.getEnd());
287 void DwarfCompileUnit::initStmtList() {
288 if (CUNode->isDebugDirectivesOnly())
291 // Define start line table label for each Compile Unit.
292 MCSymbol *LineTableStartSym;
293 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
294 if (DD->useSectionsAsReferences()) {
295 LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol();
298 Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());
301 // DW_AT_stmt_list is a offset of line number information for this
302 // compile unit in debug_line section. For split dwarf this is
303 // left in the skeleton CU and so not included.
304 // The line table entries are not always emitted in assembly, so it
305 // is not okay to use line_table_start here.
307 addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym,
308 TLOF.getDwarfLineSection()->getBeginSymbol());
311 void DwarfCompileUnit::applyStmtList(DIE &D) {
312 D.addValue(DIEValueAllocator, *StmtListValue);
315 void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
316 const MCSymbol *End) {
317 assert(Begin && "Begin label should not be null!");
318 assert(End && "End label should not be null!");
319 assert(Begin->isDefined() && "Invalid starting label");
320 assert(End->isDefined() && "Invalid end label");
322 addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
323 if (DD->getDwarfVersion() < 4)
324 addLabelAddress(D, dwarf::DW_AT_high_pc, End);
326 addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
329 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
330 // and DW_AT_high_pc attributes. If there are global variables in this
331 // scope then create and insert DIEs for these variables.
332 DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
333 DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
335 attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd());
336 if (DD->useAppleExtensionAttributes() &&
337 !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim(
338 *DD->getCurrentFunction()))
339 addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);
341 // Only include DW_AT_frame_base in full debug info
342 if (!includeMinimalInlineScopes()) {
343 if (Asm->MF->getTarget().getTargetTriple().isNVPTX()) {
344 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
345 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa);
346 addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc);
348 const TargetRegisterInfo *RI = Asm->MF->getSubtarget().getRegisterInfo();
349 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
350 if (RI->isPhysicalRegister(Location.getReg()))
351 addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
355 // Add name to the name table, we do this here because we're guaranteed
356 // to have concrete versions of our DW_TAG_subprogram nodes.
357 DD->addSubprogramNames(*CUNode, SP, *SPDie);
362 // Construct a DIE for this scope.
363 void DwarfCompileUnit::constructScopeDIE(
364 LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) {
365 if (!Scope || !Scope->getScopeNode())
368 auto *DS = Scope->getScopeNode();
370 assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
371 "Only handle inlined subprograms here, use "
372 "constructSubprogramScopeDIE for non-inlined "
375 SmallVector<DIE *, 8> Children;
377 // We try to create the scope DIE first, then the children DIEs. This will
378 // avoid creating un-used children then removing them later when we find out
379 // the scope DIE is null.
381 if (Scope->getParent() && isa<DISubprogram>(DS)) {
382 ScopeDIE = constructInlinedScopeDIE(Scope);
385 // We create children when the scope DIE is not null.
386 createScopeChildrenDIE(Scope, Children);
388 // Early exit when we know the scope DIE is going to be null.
389 if (DD->isLexicalScopeDIENull(Scope))
392 bool HasNonScopeChildren = false;
394 // We create children here when we know the scope DIE is not going to be
395 // null and the children will be added to the scope DIE.
396 createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren);
398 // If there are only other scopes as children, put them directly in the
399 // parent instead, as this scope would serve no purpose.
400 if (!HasNonScopeChildren) {
401 FinalChildren.insert(FinalChildren.end(),
402 std::make_move_iterator(Children.begin()),
403 std::make_move_iterator(Children.end()));
406 ScopeDIE = constructLexicalScopeDIE(Scope);
407 assert(ScopeDIE && "Scope DIE should not be null.");
411 for (auto &I : Children)
412 ScopeDIE->addChild(std::move(I));
414 FinalChildren.push_back(std::move(ScopeDIE));
417 void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
418 SmallVector<RangeSpan, 2> Range) {
419 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
421 // Emit the offset into .debug_ranges or .debug_rnglists as a relocatable
422 // label. emitDIE() will handle emitting it appropriately.
423 const MCSymbol *RangeSectionSym =
424 DD->getDwarfVersion() >= 5
425 ? TLOF.getDwarfRnglistsSection()->getBeginSymbol()
426 : TLOF.getDwarfRangesSection()->getBeginSymbol();
428 HasRangeLists = true;
430 // Add the range list to the set of ranges to be emitted.
432 (DD->getDwarfVersion() < 5 && Skeleton ? Skeleton->DU : DU)
433 ->addRange(*(Skeleton ? Skeleton : this), std::move(Range));
435 uint32_t Index = IndexAndList.first;
436 auto &List = *IndexAndList.second;
438 // Under fission, ranges are specified by constant offsets relative to the
439 // CU's DW_AT_GNU_ranges_base.
440 // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under
441 // fission until we support the forms using the .debug_addr section
442 // (DW_RLE_startx_endx etc.).
443 if (DD->getDwarfVersion() >= 5)
444 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_rnglistx, Index);
445 else if (isDwoUnit())
446 addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
449 addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
453 void DwarfCompileUnit::attachRangesOrLowHighPC(
454 DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
455 if (Ranges.size() == 1 || !DD->useRangesSection()) {
456 const RangeSpan &Front = Ranges.front();
457 const RangeSpan &Back = Ranges.back();
458 attachLowHighPC(Die, Front.getStart(), Back.getEnd());
460 addScopeRangeList(Die, std::move(Ranges));
463 void DwarfCompileUnit::attachRangesOrLowHighPC(
464 DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
465 SmallVector<RangeSpan, 2> List;
466 List.reserve(Ranges.size());
467 for (const InsnRange &R : Ranges)
468 List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first),
469 DD->getLabelAfterInsn(R.second)));
470 attachRangesOrLowHighPC(Die, std::move(List));
473 // This scope represents inlined body of a function. Construct DIE to
474 // represent this concrete inlined copy of the function.
475 DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
476 assert(Scope->getScopeNode());
477 auto *DS = Scope->getScopeNode();
478 auto *InlinedSP = getDISubprogram(DS);
479 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
480 // was inlined from another compile unit.
481 DIE *OriginDIE = getAbstractSPDies()[InlinedSP];
482 assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
484 auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine);
485 addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
487 attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
489 // Add the call site information to the DIE.
490 const DILocation *IA = Scope->getInlinedAt();
491 addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
492 getOrCreateSourceID(IA->getFile()));
493 addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine());
494 if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4)
495 addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None,
496 IA->getDiscriminator());
498 // Add name to the name table, we do this here because we're guaranteed
499 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
500 DD->addSubprogramNames(*CUNode, InlinedSP, *ScopeDIE);
505 // Construct new DW_TAG_lexical_block for this scope and attach
506 // DW_AT_low_pc/DW_AT_high_pc labels.
507 DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) {
508 if (DD->isLexicalScopeDIENull(Scope))
511 auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block);
512 if (Scope->isAbstractScope())
515 attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
520 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
521 DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) {
522 auto D = constructVariableDIEImpl(DV, Abstract);
527 DIE *DwarfCompileUnit::constructLabelDIE(DbgLabel &DL,
528 const LexicalScope &Scope) {
529 auto LabelDie = DIE::get(DIEValueAllocator, DL.getTag());
530 insertDIE(DL.getLabel(), LabelDie);
531 DL.setDIE(*LabelDie);
533 if (Scope.isAbstractScope())
534 applyLabelAttributes(DL, *LabelDie);
539 DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
541 // Define variable debug information entry.
542 auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag());
543 insertDIE(DV.getVariable(), VariableDie);
546 applyVariableAttributes(DV, *VariableDie);
550 // Add variable address.
552 unsigned Offset = DV.getDebugLocListIndex();
554 addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
558 // Check if variable is described by a DBG_VALUE instruction.
559 if (const MachineInstr *DVInsn = DV.getMInsn()) {
560 assert(DVInsn->getNumOperands() == 4);
561 if (DVInsn->getOperand(0).isReg()) {
562 auto RegOp = DVInsn->getOperand(0);
563 auto Op1 = DVInsn->getOperand(1);
564 // If the second operand is an immediate, this is an indirect value.
565 assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset");
566 MachineLocation Location(RegOp.getReg(), Op1.isImm());
567 addVariableAddress(DV, *VariableDie, Location);
568 } else if (DVInsn->getOperand(0).isImm()) {
569 // This variable is described by a single constant.
570 // Check whether it has a DIExpression.
571 auto *Expr = DV.getSingleExpression();
572 if (Expr && Expr->getNumElements()) {
573 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
574 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
575 // If there is an expression, emit raw unsigned bytes.
576 DwarfExpr.addFragmentOffset(Expr);
577 DwarfExpr.addUnsignedConstant(DVInsn->getOperand(0).getImm());
578 DwarfExpr.addExpression(Expr);
579 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
581 addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
582 } else if (DVInsn->getOperand(0).isFPImm())
583 addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
584 else if (DVInsn->getOperand(0).isCImm())
585 addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
591 // .. else use frame index.
592 if (!DV.hasFrameIndexExprs())
595 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
596 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
597 for (auto &Fragment : DV.getFrameIndexExprs()) {
598 unsigned FrameReg = 0;
599 const DIExpression *Expr = Fragment.Expr;
600 const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
601 int Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg);
602 DwarfExpr.addFragmentOffset(Expr);
603 SmallVector<uint64_t, 8> Ops;
604 Ops.push_back(dwarf::DW_OP_plus_uconst);
605 Ops.push_back(Offset);
606 Ops.append(Expr->elements_begin(), Expr->elements_end());
607 DIExpressionCursor Cursor(Ops);
608 DwarfExpr.setMemoryLocationKind();
609 if (const MCSymbol *FrameSymbol = Asm->getFunctionFrameSymbol())
610 addOpAddress(*Loc, FrameSymbol);
612 DwarfExpr.addMachineRegExpression(
613 *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg);
614 DwarfExpr.addExpression(std::move(Cursor));
616 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
621 DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
622 const LexicalScope &Scope,
623 DIE *&ObjectPointer) {
624 auto Var = constructVariableDIE(DV, Scope.isAbstractScope());
625 if (DV.isObjectPointer())
630 /// Return all DIVariables that appear in count: expressions.
631 static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) {
632 SmallVector<const DIVariable *, 2> Result;
633 auto *Array = dyn_cast<DICompositeType>(Var->getType());
634 if (!Array || Array->getTag() != dwarf::DW_TAG_array_type)
636 for (auto *El : Array->getElements()) {
637 if (auto *Subrange = dyn_cast<DISubrange>(El)) {
638 auto Count = Subrange->getCount();
639 if (auto *Dependency = Count.dyn_cast<DIVariable *>())
640 Result.push_back(Dependency);
646 /// Sort local variables so that variables appearing inside of helper
647 /// expressions come first.
648 static SmallVector<DbgVariable *, 8>
649 sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) {
650 SmallVector<DbgVariable *, 8> Result;
651 SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList;
652 // Map back from a DIVariable to its containing DbgVariable.
653 SmallDenseMap<const DILocalVariable *, DbgVariable *> DbgVar;
654 // Set of DbgVariables in Result.
655 SmallDenseSet<DbgVariable *, 8> Visited;
656 // For cycle detection.
657 SmallDenseSet<DbgVariable *, 8> Visiting;
659 // Initialize the worklist and the DIVariable lookup table.
660 for (auto Var : reverse(Input)) {
661 DbgVar.insert({Var->getVariable(), Var});
662 WorkList.push_back({Var, 0});
665 // Perform a stable topological sort by doing a DFS.
666 while (!WorkList.empty()) {
667 auto Item = WorkList.back();
668 DbgVariable *Var = Item.getPointer();
669 bool visitedAllDependencies = Item.getInt();
672 // Dependency is in a different lexical scope or a global.
677 if (Visited.count(Var))
680 // Add to Result if all dependencies are visited.
681 if (visitedAllDependencies) {
683 Result.push_back(Var);
688 auto Res = Visiting.insert(Var);
690 assert(false && "dependency cycle in local variables");
694 // Push dependencies and this node onto the worklist, so that this node is
695 // visited again after all of its dependencies are handled.
696 WorkList.push_back({Var, 1});
697 for (auto *Dependency : dependencies(Var)) {
698 auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency);
699 WorkList.push_back({DbgVar[Dep], 0});
705 DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope,
706 SmallVectorImpl<DIE *> &Children,
707 bool *HasNonScopeChildren) {
708 assert(Children.empty());
709 DIE *ObjectPointer = nullptr;
711 // Emit function arguments (order is significant).
712 auto Vars = DU->getScopeVariables().lookup(Scope);
713 for (auto &DV : Vars.Args)
714 Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer));
716 // Emit local variables.
717 auto Locals = sortLocalVars(Vars.Locals);
718 for (DbgVariable *DV : Locals)
719 Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));
721 // Skip imported directives in gmlt-like data.
722 if (!includeMinimalInlineScopes()) {
723 // There is no need to emit empty lexical block DIE.
724 for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
726 constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
729 if (HasNonScopeChildren)
730 *HasNonScopeChildren = !Children.empty();
732 for (DbgLabel *DL : DU->getScopeLabels().lookup(Scope))
733 Children.push_back(constructLabelDIE(*DL, *Scope));
735 for (LexicalScope *LS : Scope->getChildren())
736 constructScopeDIE(LS, Children);
738 return ObjectPointer;
741 DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub,
742 LexicalScope *Scope) {
743 DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
746 assert(!Scope->getInlinedAt());
747 assert(!Scope->isAbstractScope());
748 // Collect lexical scope children first.
749 // ObjectPointer might be a local (non-argument) local variable if it's a
750 // block's synthetic this pointer.
751 if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
752 addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
755 // If this is a variadic function, add an unspecified parameter.
756 DITypeRefArray FnArgs = Sub->getType()->getTypeArray();
758 // If we have a single element of null, it is a function that returns void.
759 // If we have more than one elements and the last one is null, it is a
760 // variadic function.
761 if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] &&
762 !includeMinimalInlineScopes())
764 DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters));
769 DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
771 // We create children when the scope DIE is not null.
772 SmallVector<DIE *, 8> Children;
773 DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);
776 for (auto &I : Children)
777 ScopeDIE.addChild(std::move(I));
779 return ObjectPointer;
782 void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
783 LexicalScope *Scope) {
784 DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()];
788 auto *SP = cast<DISubprogram>(Scope->getScopeNode());
791 DwarfCompileUnit *ContextCU = this;
793 if (includeMinimalInlineScopes())
794 ContextDIE = &getUnitDie();
795 // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
796 // the important distinction that the debug node is not associated with the
797 // DIE (since the debug node will be associated with the concrete DIE, if
798 // any). It could be refactored to some common utility function.
799 else if (auto *SPDecl = SP->getDeclaration()) {
800 ContextDIE = &getUnitDie();
801 getOrCreateSubprogramDIE(SPDecl);
803 ContextDIE = getOrCreateContextDIE(resolve(SP->getScope()));
804 // The scope may be shared with a subprogram that has already been
805 // constructed in another CU, in which case we need to construct this
806 // subprogram in the same CU.
807 ContextCU = DD->lookupCU(ContextDIE->getUnitDie());
810 // Passing null as the associated node because the abstract definition
811 // shouldn't be found by lookup.
812 AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr);
813 ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef);
815 if (!ContextCU->includeMinimalInlineScopes())
816 ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
817 if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef))
818 ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
821 DIE &DwarfCompileUnit::constructCallSiteEntryDIE(DIE &ScopeDIE,
822 const DISubprogram &CalleeSP,
824 const MCExpr *PCOffset) {
825 // Insert a call site entry DIE within ScopeDIE.
827 createAndAddDIE(dwarf::DW_TAG_call_site, ScopeDIE, nullptr);
829 // For the purposes of showing tail call frames in backtraces, a key piece of
830 // information is DW_AT_call_origin, a pointer to the callee DIE.
831 DIE *CalleeDIE = getOrCreateSubprogramDIE(&CalleeSP);
832 assert(CalleeDIE && "Could not create DIE for call site entry origin");
833 addDIEEntry(CallSiteDIE, dwarf::DW_AT_call_origin, *CalleeDIE);
836 // Attach DW_AT_call_tail_call to tail calls for standards compliance.
837 addFlag(CallSiteDIE, dwarf::DW_AT_call_tail_call);
839 // Attach the return PC to allow the debugger to disambiguate call paths
840 // from one function to another.
841 assert(PCOffset && "Missing return PC information for a call");
842 addAddressExpr(CallSiteDIE, dwarf::DW_AT_call_return_pc, PCOffset);
847 DIE *DwarfCompileUnit::constructImportedEntityDIE(
848 const DIImportedEntity *Module) {
849 DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag());
850 insertDIE(Module, IMDie);
852 auto *Entity = resolve(Module->getEntity());
853 if (auto *NS = dyn_cast<DINamespace>(Entity))
854 EntityDie = getOrCreateNameSpace(NS);
855 else if (auto *M = dyn_cast<DIModule>(Entity))
856 EntityDie = getOrCreateModule(M);
857 else if (auto *SP = dyn_cast<DISubprogram>(Entity))
858 EntityDie = getOrCreateSubprogramDIE(SP);
859 else if (auto *T = dyn_cast<DIType>(Entity))
860 EntityDie = getOrCreateTypeDIE(T);
861 else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity))
862 EntityDie = getOrCreateGlobalVariableDIE(GV, {});
864 EntityDie = getDIE(Entity);
866 addSourceLine(*IMDie, Module->getLine(), Module->getFile());
867 addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
868 StringRef Name = Module->getName();
870 addString(*IMDie, dwarf::DW_AT_name, Name);
875 void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
877 if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) {
879 // If this subprogram has an abstract definition, reference that
880 addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
882 assert(D || includeMinimalInlineScopes());
884 // And attach the attributes
885 applySubprogramAttributesToDefinition(SP, *D);
889 void DwarfCompileUnit::finishEntityDefinition(const DbgEntity *Entity) {
890 DbgEntity *AbsEntity = getExistingAbstractEntity(Entity->getEntity());
892 auto *Die = Entity->getDIE();
893 /// Label may be used to generate DW_AT_low_pc, so put it outside
895 const DbgLabel *Label = nullptr;
896 if (AbsEntity && AbsEntity->getDIE()) {
897 addDIEEntry(*Die, dwarf::DW_AT_abstract_origin, *AbsEntity->getDIE());
898 Label = dyn_cast<const DbgLabel>(Entity);
900 if (const DbgVariable *Var = dyn_cast<const DbgVariable>(Entity))
901 applyVariableAttributes(*Var, *Die);
902 else if ((Label = dyn_cast<const DbgLabel>(Entity)))
903 applyLabelAttributes(*Label, *Die);
905 llvm_unreachable("DbgEntity must be DbgVariable or DbgLabel.");
909 if (const auto *Sym = Label->getSymbol())
910 addLabelAddress(*Die, dwarf::DW_AT_low_pc, Sym);
913 DbgEntity *DwarfCompileUnit::getExistingAbstractEntity(const DINode *Node) {
914 auto &AbstractEntities = getAbstractEntities();
915 auto I = AbstractEntities.find(Node);
916 if (I != AbstractEntities.end())
917 return I->second.get();
921 void DwarfCompileUnit::createAbstractEntity(const DINode *Node,
922 LexicalScope *Scope) {
923 assert(Scope && Scope->isAbstractScope());
924 auto &Entity = getAbstractEntities()[Node];
925 if (isa<const DILocalVariable>(Node)) {
926 Entity = llvm::make_unique<DbgVariable>(
927 cast<const DILocalVariable>(Node), nullptr /* IA */);;
928 DU->addScopeVariable(Scope, cast<DbgVariable>(Entity.get()));
929 } else if (isa<const DILabel>(Node)) {
930 Entity = llvm::make_unique<DbgLabel>(
931 cast<const DILabel>(Node), nullptr /* IA */);
932 DU->addScopeLabel(Scope, cast<DbgLabel>(Entity.get()));
936 void DwarfCompileUnit::emitHeader(bool UseOffsets) {
937 // Don't bother labeling the .dwo unit, as its offset isn't used.
938 if (!Skeleton && !DD->useSectionsAsReferences()) {
939 LabelBegin = Asm->createTempSymbol("cu_begin");
940 Asm->OutStreamer->EmitLabel(LabelBegin);
943 dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile
944 : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton
945 : dwarf::DW_UT_compile;
946 DwarfUnit::emitCommonHeader(UseOffsets, UT);
947 if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile)
948 Asm->emitInt64(getDWOId());
951 bool DwarfCompileUnit::hasDwarfPubSections() const {
952 switch (CUNode->getNameTableKind()) {
953 case DICompileUnit::DebugNameTableKind::None:
955 // Opting in to GNU Pubnames/types overrides the default to ensure these are
956 // generated for things like Gold's gdb_index generation.
957 case DICompileUnit::DebugNameTableKind::GNU:
959 case DICompileUnit::DebugNameTableKind::Default:
960 return DD->tuneForGDB() && !includeMinimalInlineScopes() &&
961 !CUNode->isDebugDirectivesOnly();
963 llvm_unreachable("Unhandled DICompileUnit::DebugNameTableKind enum");
966 /// addGlobalName - Add a new global name to the compile unit.
967 void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die,
968 const DIScope *Context) {
969 if (!hasDwarfPubSections())
971 std::string FullName = getParentContextString(Context) + Name.str();
972 GlobalNames[FullName] = &Die;
975 void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name,
976 const DIScope *Context) {
977 if (!hasDwarfPubSections())
979 std::string FullName = getParentContextString(Context) + Name.str();
980 // Insert, allowing the entry to remain as-is if it's already present
981 // This way the CU-level type DIE is preferred over the "can't describe this
982 // type as a unit offset because it's not really in the CU at all, it's only
984 GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie()));
987 /// Add a new global type to the unit.
988 void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die,
989 const DIScope *Context) {
990 if (!hasDwarfPubSections())
992 std::string FullName = getParentContextString(Context) + Ty->getName().str();
993 GlobalTypes[FullName] = &Die;
996 void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty,
997 const DIScope *Context) {
998 if (!hasDwarfPubSections())
1000 std::string FullName = getParentContextString(Context) + Ty->getName().str();
1001 // Insert, allowing the entry to remain as-is if it's already present
1002 // This way the CU-level type DIE is preferred over the "can't describe this
1003 // type as a unit offset because it's not really in the CU at all, it's only
1005 GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie()));
1008 /// addVariableAddress - Add DW_AT_location attribute for a
1009 /// DbgVariable based on provided MachineLocation.
1010 void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
1011 MachineLocation Location) {
1012 // addBlockByrefAddress is obsolete and will be removed soon.
1013 // The clang frontend always generates block byref variables with a
1014 // complex expression that encodes exactly what addBlockByrefAddress
1016 assert((!DV.isBlockByrefVariable() || DV.hasComplexAddress()) &&
1017 "block byref variable without a complex expression");
1018 if (DV.hasComplexAddress())
1019 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
1021 addAddress(Die, dwarf::DW_AT_location, Location);
1024 /// Add an address attribute to a die based on the location provided.
1025 void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
1026 const MachineLocation &Location) {
1027 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1028 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
1029 if (Location.isIndirect())
1030 DwarfExpr.setMemoryLocationKind();
1032 DIExpressionCursor Cursor({});
1033 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
1034 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
1036 DwarfExpr.addExpression(std::move(Cursor));
1038 // Now attach the location information to the DIE.
1039 addBlock(Die, Attribute, DwarfExpr.finalize());
1042 /// Start with the address based on the location provided, and generate the
1043 /// DWARF information necessary to find the actual variable given the extra
1044 /// address information encoded in the DbgVariable, starting from the starting
1045 /// location. Add the DWARF information to the die.
1046 void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
1047 dwarf::Attribute Attribute,
1048 const MachineLocation &Location) {
1049 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1050 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
1051 const DIExpression *DIExpr = DV.getSingleExpression();
1052 DwarfExpr.addFragmentOffset(DIExpr);
1053 if (Location.isIndirect())
1054 DwarfExpr.setMemoryLocationKind();
1056 DIExpressionCursor Cursor(DIExpr);
1057 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
1058 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
1060 DwarfExpr.addExpression(std::move(Cursor));
1062 // Now attach the location information to the DIE.
1063 addBlock(Die, Attribute, DwarfExpr.finalize());
1066 /// Add a Dwarf loclistptr attribute data and value.
1067 void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
1069 dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
1070 : dwarf::DW_FORM_data4;
1071 Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index));
1074 void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
1076 StringRef Name = Var.getName();
1078 addString(VariableDie, dwarf::DW_AT_name, Name);
1079 const auto *DIVar = Var.getVariable();
1081 if (uint32_t AlignInBytes = DIVar->getAlignInBytes())
1082 addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1085 addSourceLine(VariableDie, DIVar);
1086 addType(VariableDie, Var.getType());
1087 if (Var.isArtificial())
1088 addFlag(VariableDie, dwarf::DW_AT_artificial);
1091 void DwarfCompileUnit::applyLabelAttributes(const DbgLabel &Label,
1093 StringRef Name = Label.getName();
1095 addString(LabelDie, dwarf::DW_AT_name, Name);
1096 const auto *DILabel = Label.getLabel();
1097 addSourceLine(LabelDie, DILabel);
1100 /// Add a Dwarf expression attribute data and value.
1101 void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form,
1102 const MCExpr *Expr) {
1103 Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr));
1106 void DwarfCompileUnit::addAddressExpr(DIE &Die, dwarf::Attribute Attribute,
1107 const MCExpr *Expr) {
1108 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
1112 void DwarfCompileUnit::applySubprogramAttributesToDefinition(
1113 const DISubprogram *SP, DIE &SPDie) {
1114 auto *SPDecl = SP->getDeclaration();
1115 auto *Context = resolve(SPDecl ? SPDecl->getScope() : SP->getScope());
1116 applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes());
1117 addGlobalName(SP->getName(), SPDie, Context);
1120 bool DwarfCompileUnit::isDwoUnit() const {
1121 return DD->useSplitDwarf() && Skeleton;
1124 bool DwarfCompileUnit::includeMinimalInlineScopes() const {
1125 return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly ||
1126 (DD->useSplitDwarf() && !Skeleton);
1129 void DwarfCompileUnit::addAddrTableBase() {
1130 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1131 MCSymbol *Label = DD->getAddressPool().getLabel();
1132 addSectionLabel(getUnitDie(),
1133 getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base
1134 : dwarf::DW_AT_GNU_addr_base,
1135 Label, TLOF.getDwarfAddrSection()->getBeginSymbol());