1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
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 writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
18 #include "DwarfAccelTable.h"
19 #include "DwarfCompileUnit.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/DIBuilder.h"
27 #include "llvm/DebugInfo.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/Module.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/MD5.h"
42 #include "llvm/Support/Path.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/ValueHandle.h"
45 #include "llvm/Target/TargetFrameLowering.h"
46 #include "llvm/Target/TargetLoweringObjectFile.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include "llvm/Target/TargetOptions.h"
49 #include "llvm/Target/TargetRegisterInfo.h"
53 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
54 cl::desc("Disable debug info printing"));
56 static cl::opt<bool> UnknownLocations(
57 "use-unknown-locations", cl::Hidden,
58 cl::desc("Make an absence of debug location information explicit."),
62 GenerateODRHash("generate-odr-hash", cl::Hidden,
63 cl::desc("Add an ODR hash to external type DIEs."),
67 GenerateCUHash("generate-cu-hash", cl::Hidden,
68 cl::desc("Add the CU hash as the dwo_id."),
72 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
73 cl::desc("Generate GNU-style pubnames and pubtypes"),
84 static cl::opt<DefaultOnOff>
85 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
86 cl::desc("Output prototype dwarf accelerator tables."),
87 cl::values(clEnumVal(Default, "Default for platform"),
88 clEnumVal(Enable, "Enabled"),
89 clEnumVal(Disable, "Disabled"), clEnumValEnd),
92 static cl::opt<DefaultOnOff>
93 SplitDwarf("split-dwarf", cl::Hidden,
94 cl::desc("Output prototype dwarf split debug info."),
95 cl::values(clEnumVal(Default, "Default for platform"),
96 clEnumVal(Enable, "Enabled"),
97 clEnumVal(Disable, "Disabled"), clEnumValEnd),
100 static cl::opt<DefaultOnOff>
101 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
102 cl::desc("Generate DWARF pubnames and pubtypes sections"),
103 cl::values(clEnumVal(Default, "Default for platform"),
104 clEnumVal(Enable, "Enabled"),
105 clEnumVal(Disable, "Disabled"), clEnumValEnd),
108 static const char *const DWARFGroupName = "DWARF Emission";
109 static const char *const DbgTimerName = "DWARF Debug Writer";
111 //===----------------------------------------------------------------------===//
113 // Configuration values for initial hash set sizes (log2).
115 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
119 DIType DbgVariable::getType() const {
120 DIType Ty = Var.getType();
121 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
122 // addresses instead.
123 if (Var.isBlockByrefVariable()) {
124 /* Byref variables, in Blocks, are declared by the programmer as
125 "SomeType VarName;", but the compiler creates a
126 __Block_byref_x_VarName struct, and gives the variable VarName
127 either the struct, or a pointer to the struct, as its type. This
128 is necessary for various behind-the-scenes things the compiler
129 needs to do with by-reference variables in blocks.
131 However, as far as the original *programmer* is concerned, the
132 variable should still have type 'SomeType', as originally declared.
134 The following function dives into the __Block_byref_x_VarName
135 struct to find the original type of the variable. This will be
136 passed back to the code generating the type for the Debug
137 Information Entry for the variable 'VarName'. 'VarName' will then
138 have the original type 'SomeType' in its debug information.
140 The original type 'SomeType' will be the type of the field named
141 'VarName' inside the __Block_byref_x_VarName struct.
143 NOTE: In order for this to not completely fail on the debugger
144 side, the Debug Information Entry for the variable VarName needs to
145 have a DW_AT_location that tells the debugger how to unwind through
146 the pointers and __Block_byref_x_VarName struct to find the actual
147 value of the variable. The function addBlockByrefType does this. */
149 uint16_t tag = Ty.getTag();
151 if (tag == dwarf::DW_TAG_pointer_type)
152 subType = DIDerivedType(Ty).getTypeDerivedFrom();
154 DIArray Elements = DICompositeType(subType).getTypeArray();
155 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
156 DIDerivedType DT = DIDerivedType(Elements.getElement(i));
157 if (getName() == DT.getName())
158 return (DT.getTypeDerivedFrom());
164 } // end llvm namespace
166 /// Return Dwarf Version by checking module flags.
167 static unsigned getDwarfVersionFromModule(const Module *M) {
168 Value *Val = M->getModuleFlag("Dwarf Version");
170 return dwarf::DWARF_VERSION;
171 return cast<ConstantInt>(Val)->getZExtValue();
174 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
175 : Asm(A), MMI(Asm->MMI), FirstCU(0),
176 AbbreviationsSet(InitAbbreviationsSetSize),
177 SourceIdMap(DIEValueAllocator),
178 PrevLabel(NULL), GlobalCUIndexCount(0),
179 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
181 SkeletonAbbrevSet(InitAbbreviationsSetSize),
182 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
185 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
186 DwarfStrSectionSym = TextSectionSym = 0;
187 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
188 DwarfAddrSectionSym = 0;
189 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
190 FunctionBeginSym = FunctionEndSym = 0;
192 // Turn on accelerator tables and older gdb compatibility
193 // for Darwin by default, pubnames by default for non-Darwin,
194 // and handle split dwarf.
195 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
197 if (DwarfAccelTables == Default)
198 HasDwarfAccelTables = IsDarwin;
200 HasDwarfAccelTables = DwarfAccelTables == Enable;
202 if (SplitDwarf == Default)
203 HasSplitDwarf = false;
205 HasSplitDwarf = SplitDwarf == Enable;
207 if (DwarfPubSections == Default)
208 HasDwarfPubSections = !IsDarwin;
210 HasDwarfPubSections = DwarfPubSections == Enable;
212 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
215 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
219 DwarfDebug::~DwarfDebug() {
222 // Switch to the specified MCSection and emit an assembler
223 // temporary label to it if SymbolStem is specified.
224 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
225 const char *SymbolStem = 0) {
226 Asm->OutStreamer.SwitchSection(Section);
227 if (!SymbolStem) return 0;
229 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
230 Asm->OutStreamer.EmitLabel(TmpSym);
234 MCSymbol *DwarfUnits::getStringPoolSym() {
235 return Asm->GetTempSymbol(StringPref);
238 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
239 std::pair<MCSymbol*, unsigned> &Entry =
240 StringPool.GetOrCreateValue(Str).getValue();
241 if (Entry.first) return Entry.first;
243 Entry.second = NextStringPoolNumber++;
244 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
247 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
248 std::pair<MCSymbol*, unsigned> &Entry =
249 StringPool.GetOrCreateValue(Str).getValue();
250 if (Entry.first) return Entry.second;
252 Entry.second = NextStringPoolNumber++;
253 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
257 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
258 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
261 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
262 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
263 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
265 ++NextAddrPoolNumber;
266 return P.first->second;
269 // Define a unique number for the abbreviation.
271 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
272 // Check the set for priors.
273 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
275 // If it's newly added.
276 if (InSet == &Abbrev) {
277 // Add to abbreviation list.
278 Abbreviations->push_back(&Abbrev);
280 // Assign the vector position + 1 as its number.
281 Abbrev.setNumber(Abbreviations->size());
283 // Assign existing abbreviation number.
284 Abbrev.setNumber(InSet->getNumber());
288 static bool isObjCClass(StringRef Name) {
289 return Name.startswith("+") || Name.startswith("-");
292 static bool hasObjCCategory(StringRef Name) {
293 if (!isObjCClass(Name)) return false;
295 return Name.find(") ") != StringRef::npos;
298 static void getObjCClassCategory(StringRef In, StringRef &Class,
299 StringRef &Category) {
300 if (!hasObjCCategory(In)) {
301 Class = In.slice(In.find('[') + 1, In.find(' '));
306 Class = In.slice(In.find('[') + 1, In.find('('));
307 Category = In.slice(In.find('[') + 1, In.find(' '));
311 static StringRef getObjCMethodName(StringRef In) {
312 return In.slice(In.find(' ') + 1, In.find(']'));
315 // Add the various names to the Dwarf accelerator table names.
316 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
318 if (!SP.isDefinition()) return;
320 TheCU->addAccelName(SP.getName(), Die);
322 // If the linkage name is different than the name, go ahead and output
323 // that as well into the name table.
324 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
325 TheCU->addAccelName(SP.getLinkageName(), Die);
327 // If this is an Objective-C selector name add it to the ObjC accelerator
329 if (isObjCClass(SP.getName())) {
330 StringRef Class, Category;
331 getObjCClassCategory(SP.getName(), Class, Category);
332 TheCU->addAccelObjC(Class, Die);
334 TheCU->addAccelObjC(Category, Die);
335 // Also add the base method name to the name table.
336 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
340 /// isSubprogramContext - Return true if Context is either a subprogram
341 /// or another context nested inside a subprogram.
342 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
345 DIDescriptor D(Context);
346 if (D.isSubprogram())
349 return isSubprogramContext(resolve(DIType(Context).getContext()));
353 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
354 // and DW_AT_high_pc attributes. If there are global variables in this
355 // scope then create and insert DIEs for these variables.
356 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
357 const MDNode *SPNode) {
358 DIE *SPDie = SPCU->getDIE(SPNode);
360 assert(SPDie && "Unable to find subprogram DIE!");
361 DISubprogram SP(SPNode);
363 // If we're updating an abstract DIE, then we will be adding the children and
364 // object pointer later on. But what we don't want to do is process the
365 // concrete DIE twice.
366 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
368 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
369 // Pick up abstract subprogram DIE.
370 SPDie = new DIE(dwarf::DW_TAG_subprogram);
371 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
373 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
374 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
378 DISubprogram SPDecl = SP.getFunctionDeclaration();
379 if (!SPDecl.isSubprogram()) {
380 // There is not any need to generate specification DIE for a function
381 // defined at compile unit level. If a function is defined inside another
382 // function then gdb prefers the definition at top level and but does not
383 // expect specification DIE in parent function. So avoid creating
384 // specification DIE for a function defined inside a function.
385 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
386 !SP.getContext().isFile() &&
387 !isSubprogramContext(SP.getContext())) {
388 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
391 DICompositeType SPTy = SP.getType();
392 DIArray Args = SPTy.getTypeArray();
393 uint16_t SPTag = SPTy.getTag();
394 if (SPTag == dwarf::DW_TAG_subroutine_type)
395 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
396 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
397 DIType ATy = DIType(Args.getElement(i));
398 SPCU->addType(Arg, ATy);
399 if (ATy.isArtificial())
400 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
401 if (ATy.isObjectPointer())
402 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
403 dwarf::DW_FORM_ref4, Arg);
404 SPDie->addChild(Arg);
406 DIE *SPDeclDie = SPDie;
407 SPDie = new DIE(dwarf::DW_TAG_subprogram);
408 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
409 dwarf::DW_FORM_ref4, SPDeclDie);
415 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
416 Asm->GetTempSymbol("func_begin",
417 Asm->getFunctionNumber()));
418 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
419 Asm->GetTempSymbol("func_end",
420 Asm->getFunctionNumber()));
421 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
422 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
423 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
425 // Add name to the name table, we do this here because we're guaranteed
426 // to have concrete versions of our DW_TAG_subprogram nodes.
427 addSubprogramNames(SPCU, SP, SPDie);
432 /// Check whether we should create a DIE for the given Scope, return true
433 /// if we don't create a DIE (the corresponding DIE is null).
434 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
435 if (Scope->isAbstractScope())
438 // We don't create a DIE if there is no Range.
439 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
443 if (Ranges.size() > 1)
446 // We don't create a DIE if we have a single Range and the end label
448 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
449 MCSymbol *End = getLabelAfterInsn(RI->second);
453 // Construct new DW_TAG_lexical_block for this scope and attach
454 // DW_AT_low_pc/DW_AT_high_pc labels.
455 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
456 LexicalScope *Scope) {
457 if (isLexicalScopeDIENull(Scope))
460 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
461 if (Scope->isAbstractScope())
464 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
465 // If we have multiple ranges, emit them into the range section.
466 if (Ranges.size() > 1) {
467 // .debug_range section has not been laid out yet. Emit offset in
468 // .debug_range as a uint, size 4, for now. emitDIE will handle
469 // DW_AT_ranges appropriately.
470 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
471 DebugRangeSymbols.size()
472 * Asm->getDataLayout().getPointerSize());
473 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
474 RE = Ranges.end(); RI != RE; ++RI) {
475 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
476 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
479 // Terminate the range list.
480 DebugRangeSymbols.push_back(NULL);
481 DebugRangeSymbols.push_back(NULL);
485 // Construct the address range for this DIE.
486 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
487 MCSymbol *Start = getLabelBeforeInsn(RI->first);
488 MCSymbol *End = getLabelAfterInsn(RI->second);
489 assert(End && "End label should not be null!");
491 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
492 assert(End->isDefined() && "Invalid end label for an inlined scope!");
494 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
495 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
500 // This scope represents inlined body of a function. Construct DIE to
501 // represent this concrete inlined copy of the function.
502 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
503 LexicalScope *Scope) {
504 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
505 assert(Ranges.empty() == false &&
506 "LexicalScope does not have instruction markers!");
508 if (!Scope->getScopeNode())
510 DIScope DS(Scope->getScopeNode());
511 DISubprogram InlinedSP = getDISubprogram(DS);
512 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
514 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
518 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
519 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
520 dwarf::DW_FORM_ref4, OriginDIE);
522 if (Ranges.size() > 1) {
523 // .debug_range section has not been laid out yet. Emit offset in
524 // .debug_range as a uint, size 4, for now. emitDIE will handle
525 // DW_AT_ranges appropriately.
526 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
527 DebugRangeSymbols.size()
528 * Asm->getDataLayout().getPointerSize());
529 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
530 RE = Ranges.end(); RI != RE; ++RI) {
531 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
532 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
534 DebugRangeSymbols.push_back(NULL);
535 DebugRangeSymbols.push_back(NULL);
537 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
538 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
539 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
541 if (StartLabel == 0 || EndLabel == 0)
542 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
544 assert(StartLabel->isDefined() &&
545 "Invalid starting label for an inlined scope!");
546 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
548 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
549 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
552 InlinedSubprogramDIEs.insert(OriginDIE);
554 // Add the call site information to the DIE.
555 DILocation DL(Scope->getInlinedAt());
556 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
557 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
558 TheCU->getUniqueID()));
559 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
561 // Add name to the name table, we do this here because we're guaranteed
562 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
563 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
568 DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
569 SmallVectorImpl<DIE*> &Children) {
570 DIE *ObjectPointer = NULL;
572 // Collect arguments for current function.
573 if (LScopes.isCurrentFunctionScope(Scope))
574 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
575 if (DbgVariable *ArgDV = CurrentFnArguments[i])
577 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
578 Children.push_back(Arg);
579 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
582 // Collect lexical scope children first.
583 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
584 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
586 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
587 Children.push_back(Variable);
588 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
590 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
591 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
592 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
593 Children.push_back(Nested);
594 return ObjectPointer;
597 // Construct a DIE for this scope.
598 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
599 if (!Scope || !Scope->getScopeNode())
602 DIScope DS(Scope->getScopeNode());
604 SmallVector<DIE *, 8> Children;
605 DIE *ObjectPointer = NULL;
606 bool ChildrenCreated = false;
608 // We try to create the scope DIE first, then the children DIEs. This will
609 // avoid creating un-used children then removing them later when we find out
610 // the scope DIE is null.
611 DIE *ScopeDIE = NULL;
612 if (Scope->getInlinedAt())
613 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
614 else if (DS.isSubprogram()) {
615 ProcessedSPNodes.insert(DS);
616 if (Scope->isAbstractScope()) {
617 ScopeDIE = TheCU->getDIE(DS);
618 // Note down abstract DIE.
620 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
623 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
626 // Early exit when we know the scope DIE is going to be null.
627 if (isLexicalScopeDIENull(Scope))
630 // We create children here when we know the scope DIE is not going to be
631 // null and the children will be added to the scope DIE.
632 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
633 ChildrenCreated = true;
635 // There is no need to emit empty lexical block DIE.
636 std::pair<ImportedEntityMap::const_iterator,
637 ImportedEntityMap::const_iterator> Range = std::equal_range(
638 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
639 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
641 if (Children.empty() && Range.first == Range.second)
643 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
644 assert(ScopeDIE && "Scope DIE should not be null.");
645 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
647 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
651 assert(Children.empty() &&
652 "We create children only when the scope DIE is not null.");
655 if (!ChildrenCreated)
656 // We create children when the scope DIE is not null.
657 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
660 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
661 E = Children.end(); I != E; ++I)
662 ScopeDIE->addChild(*I);
664 if (DS.isSubprogram() && ObjectPointer != NULL)
665 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
666 dwarf::DW_FORM_ref4, ObjectPointer);
668 if (DS.isSubprogram())
669 TheCU->addPubTypes(DISubprogram(DS));
674 // Look up the source id with the given directory and source file names.
675 // If none currently exists, create a new id and insert it in the
676 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
678 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
679 StringRef DirName, unsigned CUID) {
680 // If we use .loc in assembly, we can't separate .file entries according to
681 // compile units. Thus all files will belong to the default compile unit.
682 if (Asm->TM.hasMCUseLoc() &&
683 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
686 // If FE did not provide a file name, then assume stdin.
687 if (FileName.empty())
688 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
690 // TODO: this might not belong here. See if we can factor this better.
691 if (DirName == CompilationDir)
694 // FileIDCUMap stores the current ID for the given compile unit.
695 unsigned SrcId = FileIDCUMap[CUID] + 1;
697 // We look up the CUID/file/dir by concatenating them with a zero byte.
698 SmallString<128> NamePair;
699 NamePair += utostr(CUID);
702 NamePair += '\0'; // Zero bytes are not allowed in paths.
703 NamePair += FileName;
705 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
706 if (Ent.getValue() != SrcId)
707 return Ent.getValue();
709 FileIDCUMap[CUID] = SrcId;
710 // Print out a .file directive to specify files for .loc directives.
711 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
716 // Create new CompileUnit for the given metadata node with tag
717 // DW_TAG_compile_unit.
718 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
719 DICompileUnit DIUnit(N);
720 StringRef FN = DIUnit.getFilename();
721 CompilationDir = DIUnit.getDirectory();
723 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
725 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder);
727 FileIDCUMap[NewCU->getUniqueID()] = 0;
728 // Call this to emit a .file directive if it wasn't emitted for the source
729 // file this CU comes from yet.
730 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
732 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
733 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
734 DIUnit.getLanguage());
735 NewCU->addString(Die, dwarf::DW_AT_name, FN);
737 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
738 // into an entity. We're using 0 (or a NULL label) for this. For
739 // split dwarf it's in the skeleton CU so omit it here.
740 if (!useSplitDwarf())
741 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
743 // Define start line table label for each Compile Unit.
744 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
745 NewCU->getUniqueID());
746 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
747 NewCU->getUniqueID());
749 // Use a single line table if we are using .loc and generating assembly.
751 (Asm->TM.hasMCUseLoc() &&
752 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
753 (NewCU->getUniqueID() == 0);
755 // DW_AT_stmt_list is a offset of line number information for this
756 // compile unit in debug_line section. For split dwarf this is
757 // left in the skeleton CU and so not included.
758 // The line table entries are not always emitted in assembly, so it
759 // is not okay to use line_table_start here.
760 if (!useSplitDwarf()) {
761 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
762 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
764 Asm->GetTempSymbol("section_line") : LineTableStartSym);
765 else if (UseTheFirstCU)
766 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
768 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
769 LineTableStartSym, DwarfLineSectionSym);
772 // If we're using split dwarf the compilation dir is going to be in the
773 // skeleton CU and so we don't need to duplicate it here.
774 if (!useSplitDwarf() && !CompilationDir.empty())
775 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
777 // Flag to let the linker know we have emitted new style pubnames. Only
778 // emit it here if we don't have a skeleton CU for split dwarf.
779 if (!useSplitDwarf() && GenerateGnuPubSections)
780 NewCU->addFlag(Die, dwarf::DW_AT_GNU_pubnames);
782 if (DIUnit.isOptimized())
783 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
785 StringRef Flags = DIUnit.getFlags();
787 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
789 if (unsigned RVer = DIUnit.getRunTimeVersion())
790 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
791 dwarf::DW_FORM_data1, RVer);
796 InfoHolder.addUnit(NewCU);
798 CUMap.insert(std::make_pair(N, NewCU));
802 // Construct subprogram DIE.
803 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
805 CompileUnit *&CURef = SPMap[N];
811 if (!SP.isDefinition())
812 // This is a method declaration which will be handled while constructing
816 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
819 TheCU->insertDIE(N, SubprogramDie);
821 // Add to context owner.
822 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
824 // Expose as a global name.
825 TheCU->addGlobalName(SP.getName(), SubprogramDie);
828 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
830 DIImportedEntity Module(N);
831 if (!Module.Verify())
833 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
834 constructImportedEntityDIE(TheCU, Module, D);
837 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
839 DIImportedEntity Module(N);
840 if (!Module.Verify())
842 return constructImportedEntityDIE(TheCU, Module, Context);
845 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
846 const DIImportedEntity &Module,
848 assert(Module.Verify() &&
849 "Use one of the MDNode * overloads to handle invalid metadata");
850 assert(Context && "Should always have a context for an imported_module");
851 DIE *IMDie = new DIE(Module.getTag());
852 TheCU->insertDIE(Module, IMDie);
854 DIDescriptor Entity = Module.getEntity();
855 if (Entity.isNameSpace())
856 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
857 else if (Entity.isSubprogram())
858 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
859 else if (Entity.isType())
860 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
862 EntityDie = TheCU->getDIE(Entity);
863 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
864 Module.getContext().getDirectory(),
865 TheCU->getUniqueID());
866 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
867 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
868 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
870 StringRef Name = Module.getName();
872 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
873 Context->addChild(IMDie);
876 // Emit all Dwarf sections that should come prior to the content. Create
877 // global DIEs and emit initial debug info sections. This is invoked by
878 // the target AsmPrinter.
879 void DwarfDebug::beginModule() {
880 if (DisableDebugInfoPrinting)
883 const Module *M = MMI->getModule();
885 // If module has named metadata anchors then use them, otherwise scan the
886 // module using debug info finder to collect debug info.
887 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
890 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
892 // Emit initial sections so we can reference labels later.
895 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
896 DICompileUnit CUNode(CU_Nodes->getOperand(i));
897 CompileUnit *CU = constructCompileUnit(CUNode);
898 DIArray ImportedEntities = CUNode.getImportedEntities();
899 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
900 ScopesWithImportedEntities.push_back(std::make_pair(
901 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
902 ImportedEntities.getElement(i)));
903 std::sort(ScopesWithImportedEntities.begin(),
904 ScopesWithImportedEntities.end(), less_first());
905 DIArray GVs = CUNode.getGlobalVariables();
906 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
907 CU->createGlobalVariableDIE(GVs.getElement(i));
908 DIArray SPs = CUNode.getSubprograms();
909 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
910 constructSubprogramDIE(CU, SPs.getElement(i));
911 DIArray EnumTypes = CUNode.getEnumTypes();
912 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
913 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
914 DIArray RetainedTypes = CUNode.getRetainedTypes();
915 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
916 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
917 // Emit imported_modules last so that the relevant context is already
919 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
920 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
923 // Tell MMI that we have debug info.
924 MMI->setDebugInfoAvailability(true);
926 // Prime section data.
927 SectionMap[Asm->getObjFileLowering().getTextSection()];
930 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
931 void DwarfDebug::computeInlinedDIEs() {
932 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
933 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
934 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
936 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
938 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
939 AE = AbstractSPDies.end(); AI != AE; ++AI) {
940 DIE *ISP = AI->second;
941 if (InlinedSubprogramDIEs.count(ISP))
943 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
947 // Collect info for variables that were optimized out.
948 void DwarfDebug::collectDeadVariables() {
949 const Module *M = MMI->getModule();
950 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
952 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
953 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
954 DICompileUnit TheCU(CU_Nodes->getOperand(i));
955 DIArray Subprograms = TheCU.getSubprograms();
956 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
957 DISubprogram SP(Subprograms.getElement(i));
958 if (ProcessedSPNodes.count(SP) != 0) continue;
959 if (!SP.isSubprogram()) continue;
960 if (!SP.isDefinition()) continue;
961 DIArray Variables = SP.getVariables();
962 if (Variables.getNumElements() == 0) continue;
964 LexicalScope *Scope =
965 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
966 DeadFnScopeMap[SP] = Scope;
968 // Construct subprogram DIE and add variables DIEs.
969 CompileUnit *SPCU = CUMap.lookup(TheCU);
970 assert(SPCU && "Unable to find Compile Unit!");
971 constructSubprogramDIE(SPCU, SP);
972 DIE *ScopeDIE = SPCU->getDIE(SP);
973 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
974 DIVariable DV(Variables.getElement(vi));
975 if (!DV.isVariable()) continue;
976 DbgVariable NewVar(DV, NULL);
977 if (DIE *VariableDIE =
978 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
979 ScopeDIE->addChild(VariableDIE);
984 DeleteContainerSeconds(DeadFnScopeMap);
987 // Type Signature [7.27] and ODR Hash code.
989 /// \brief Grabs the string in whichever attribute is passed in and returns
990 /// a reference to it. Returns "" if the attribute doesn't exist.
991 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
992 DIEValue *V = Die->findAttribute(Attr);
994 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
995 return S->getString();
997 return StringRef("");
1000 /// Return true if the current DIE is contained within an anonymous namespace.
1001 static bool isContainedInAnonNamespace(DIE *Die) {
1002 DIE *Parent = Die->getParent();
1005 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1006 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1008 Parent = Parent->getParent();
1014 /// Test if the current CU language is C++ and that we have
1015 /// a named type that is not contained in an anonymous namespace.
1016 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
1017 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1018 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1019 !isContainedInAnonNamespace(Die);
1022 void DwarfDebug::finalizeModuleInfo() {
1023 // Collect info for variables that were optimized out.
1024 collectDeadVariables();
1026 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1027 computeInlinedDIEs();
1029 // Split out type units and conditionally add an ODR tag to the split
1031 // FIXME: Do type splitting.
1032 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1033 DIE *Die = TypeUnits[i];
1035 // If we've requested ODR hashes and it's applicable for an ODR hash then
1036 // add the ODR signature now.
1037 // FIXME: This should be added onto the type unit, not the type, but this
1038 // works as an intermediate stage.
1039 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1040 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1041 dwarf::DW_FORM_data8,
1042 Hash.computeDIEODRSignature(Die));
1045 // Handle anything that needs to be done on a per-cu basis.
1046 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1048 CUI != CUE; ++CUI) {
1049 CompileUnit *TheCU = CUI->second;
1050 // Emit DW_AT_containing_type attribute to connect types with their
1051 // vtable holding type.
1052 TheCU->constructContainingTypeDIEs();
1054 // If we're splitting the dwarf out now that we've got the entire
1055 // CU then construct a skeleton CU based upon it.
1056 if (useSplitDwarf()) {
1058 if (GenerateCUHash) {
1060 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1062 // This should be a unique identifier when we want to build .dwp files.
1063 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1064 dwarf::DW_FORM_data8, ID);
1065 // Now construct the skeleton CU associated.
1066 CompileUnit *SkCU = constructSkeletonCU(TheCU);
1067 // This should be a unique identifier when we want to build .dwp files.
1068 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1069 dwarf::DW_FORM_data8, ID);
1073 // Compute DIE offsets and sizes.
1074 InfoHolder.computeSizeAndOffsets();
1075 if (useSplitDwarf())
1076 SkeletonHolder.computeSizeAndOffsets();
1079 void DwarfDebug::endSections() {
1080 // Filter labels by section.
1081 for (size_t n = 0; n < Labels.size(); n++) {
1082 const SymbolCU &SCU = Labels[n];
1083 if (SCU.Sym->isInSection()) {
1084 // Make a note of this symbol and it's section.
1085 const MCSection *Section = &SCU.Sym->getSection();
1086 if (!Section->getKind().isMetadata())
1087 SectionMap[Section].push_back(SCU);
1089 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1090 // appear in the output. This sucks as we rely on sections to build
1091 // arange spans. We can do it without, but it's icky.
1092 SectionMap[NULL].push_back(SCU);
1096 // Add terminating symbols for each section.
1097 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1099 const MCSection *Section = it->first;
1100 MCSymbol *Sym = NULL;
1103 Sym = Asm->GetTempSymbol(Section->getLabelEndName());
1104 Asm->OutStreamer.SwitchSection(Section);
1105 Asm->OutStreamer.EmitLabel(Sym);
1108 // Insert a final terminator.
1112 SectionMap[Section].push_back(Entry);
1116 // Emit all Dwarf sections that should come after the content.
1117 void DwarfDebug::endModule() {
1119 if (!FirstCU) return;
1121 // End any existing sections.
1122 // TODO: Does this need to happen?
1125 // Finalize the debug info for the module.
1126 finalizeModuleInfo();
1128 if (!useSplitDwarf()) {
1129 // Emit all the DIEs into a debug info section.
1132 // Corresponding abbreviations into a abbrev section.
1133 emitAbbreviations();
1135 // Emit info into a debug loc section.
1138 // Emit info into a debug aranges section.
1141 // Emit info into a debug ranges section.
1144 // Emit info into a debug macinfo section.
1148 // TODO: Fill this in for separated debug sections and separate
1149 // out information into new sections.
1151 // Emit the debug info section and compile units.
1155 // Corresponding abbreviations into a abbrev section.
1156 emitAbbreviations();
1157 emitDebugAbbrevDWO();
1159 // Emit info into a debug loc section.
1162 // Emit info into a debug aranges section.
1165 // Emit info into a debug ranges section.
1168 // Emit info into a debug macinfo section.
1171 // Emit DWO addresses.
1172 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1176 // Emit info into the dwarf accelerator table sections.
1177 if (useDwarfAccelTables()) {
1180 emitAccelNamespaces();
1184 // Emit the pubnames and pubtypes sections if requested.
1185 if (HasDwarfPubSections) {
1186 emitDebugPubNames(GenerateGnuPubSections);
1187 emitDebugPubTypes(GenerateGnuPubSections);
1190 // Finally emit string information into a string table.
1192 if (useSplitDwarf())
1197 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1198 E = CUMap.end(); I != E; ++I)
1201 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1202 E = SkeletonCUs.end(); I != E; ++I)
1205 // Reset these for the next Module if we have one.
1209 // Find abstract variable, if any, associated with Var.
1210 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1211 DebugLoc ScopeLoc) {
1212 LLVMContext &Ctx = DV->getContext();
1213 // More then one inlined variable corresponds to one abstract variable.
1214 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1215 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1217 return AbsDbgVariable;
1219 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1223 AbsDbgVariable = new DbgVariable(Var, NULL);
1224 addScopeVariable(Scope, AbsDbgVariable);
1225 AbstractVariables[Var] = AbsDbgVariable;
1226 return AbsDbgVariable;
1229 // If Var is a current function argument then add it to CurrentFnArguments list.
1230 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1231 DbgVariable *Var, LexicalScope *Scope) {
1232 if (!LScopes.isCurrentFunctionScope(Scope))
1234 DIVariable DV = Var->getVariable();
1235 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1237 unsigned ArgNo = DV.getArgNumber();
1241 size_t Size = CurrentFnArguments.size();
1243 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1244 // llvm::Function argument size is not good indicator of how many
1245 // arguments does the function have at source level.
1247 CurrentFnArguments.resize(ArgNo * 2);
1248 CurrentFnArguments[ArgNo - 1] = Var;
1252 // Collect variable information from side table maintained by MMI.
1254 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1255 SmallPtrSet<const MDNode *, 16> &Processed) {
1256 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1257 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1258 VE = VMap.end(); VI != VE; ++VI) {
1259 const MDNode *Var = VI->first;
1261 Processed.insert(Var);
1263 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1265 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1267 // If variable scope is not found then skip this variable.
1271 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1272 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1273 RegVar->setFrameIndex(VP.first);
1274 if (!addCurrentFnArgument(MF, RegVar, Scope))
1275 addScopeVariable(Scope, RegVar);
1277 AbsDbgVariable->setFrameIndex(VP.first);
1281 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1283 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1284 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1285 return MI->getNumOperands() == 3 &&
1286 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1287 (MI->getOperand(1).isImm() ||
1288 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1291 // Get .debug_loc entry for the instruction range starting at MI.
1292 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1293 const MCSymbol *FLabel,
1294 const MCSymbol *SLabel,
1295 const MachineInstr *MI) {
1296 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1298 assert(MI->getNumOperands() == 3);
1299 if (MI->getOperand(0).isReg()) {
1300 MachineLocation MLoc;
1301 // If the second operand is an immediate, this is a
1302 // register-indirect address.
1303 if (!MI->getOperand(1).isImm())
1304 MLoc.set(MI->getOperand(0).getReg());
1306 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1307 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1309 if (MI->getOperand(0).isImm())
1310 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1311 if (MI->getOperand(0).isFPImm())
1312 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1313 if (MI->getOperand(0).isCImm())
1314 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1316 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1319 // Find variables for each lexical scope.
1321 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1322 SmallPtrSet<const MDNode *, 16> &Processed) {
1324 // Grab the variable info that was squirreled away in the MMI side-table.
1325 collectVariableInfoFromMMITable(MF, Processed);
1327 for (SmallVectorImpl<const MDNode*>::const_iterator
1328 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1330 const MDNode *Var = *UVI;
1331 if (Processed.count(Var))
1334 // History contains relevant DBG_VALUE instructions for Var and instructions
1336 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1337 if (History.empty())
1339 const MachineInstr *MInsn = History.front();
1342 LexicalScope *Scope = NULL;
1343 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1344 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1345 Scope = LScopes.getCurrentFunctionScope();
1346 else if (MDNode *IA = DV.getInlinedAt())
1347 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1349 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1350 // If variable scope is not found then skip this variable.
1354 Processed.insert(DV);
1355 assert(MInsn->isDebugValue() && "History must begin with debug value");
1356 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1357 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1358 if (!addCurrentFnArgument(MF, RegVar, Scope))
1359 addScopeVariable(Scope, RegVar);
1361 AbsVar->setMInsn(MInsn);
1363 // Simplify ranges that are fully coalesced.
1364 if (History.size() <= 1 || (History.size() == 2 &&
1365 MInsn->isIdenticalTo(History.back()))) {
1366 RegVar->setMInsn(MInsn);
1370 // Handle multiple DBG_VALUE instructions describing one variable.
1371 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1373 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1374 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1375 const MachineInstr *Begin = *HI;
1376 assert(Begin->isDebugValue() && "Invalid History entry");
1378 // Check if DBG_VALUE is truncating a range.
1379 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1380 && !Begin->getOperand(0).getReg())
1383 // Compute the range for a register location.
1384 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1385 const MCSymbol *SLabel = 0;
1388 // If Begin is the last instruction in History then its value is valid
1389 // until the end of the function.
1390 SLabel = FunctionEndSym;
1392 const MachineInstr *End = HI[1];
1393 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1394 << "\t" << *Begin << "\t" << *End << "\n");
1395 if (End->isDebugValue())
1396 SLabel = getLabelBeforeInsn(End);
1398 // End is a normal instruction clobbering the range.
1399 SLabel = getLabelAfterInsn(End);
1400 assert(SLabel && "Forgot label after clobber instruction");
1405 // The value is valid until the next DBG_VALUE or clobber.
1406 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1409 DotDebugLocEntries.push_back(DotDebugLocEntry());
1412 // Collect info for variables that were optimized out.
1413 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1414 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1415 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1416 DIVariable DV(Variables.getElement(i));
1417 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1419 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1420 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1424 // Return Label preceding the instruction.
1425 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1426 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1427 assert(Label && "Didn't insert label before instruction");
1431 // Return Label immediately following the instruction.
1432 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1433 return LabelsAfterInsn.lookup(MI);
1436 // Process beginning of an instruction.
1437 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1438 // Check if source location changes, but ignore DBG_VALUE locations.
1439 if (!MI->isDebugValue()) {
1440 DebugLoc DL = MI->getDebugLoc();
1441 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1444 if (DL == PrologEndLoc) {
1445 Flags |= DWARF2_FLAG_PROLOGUE_END;
1446 PrologEndLoc = DebugLoc();
1448 if (PrologEndLoc.isUnknown())
1449 Flags |= DWARF2_FLAG_IS_STMT;
1451 if (!DL.isUnknown()) {
1452 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1453 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1455 recordSourceLine(0, 0, 0, 0);
1459 // Insert labels where requested.
1460 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1461 LabelsBeforeInsn.find(MI);
1464 if (I == LabelsBeforeInsn.end())
1467 // Label already assigned.
1472 PrevLabel = MMI->getContext().CreateTempSymbol();
1473 Asm->OutStreamer.EmitLabel(PrevLabel);
1475 I->second = PrevLabel;
1478 // Process end of an instruction.
1479 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1480 // Don't create a new label after DBG_VALUE instructions.
1481 // They don't generate code.
1482 if (!MI->isDebugValue())
1485 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1486 LabelsAfterInsn.find(MI);
1489 if (I == LabelsAfterInsn.end())
1492 // Label already assigned.
1496 // We need a label after this instruction.
1498 PrevLabel = MMI->getContext().CreateTempSymbol();
1499 Asm->OutStreamer.EmitLabel(PrevLabel);
1501 I->second = PrevLabel;
1504 // Each LexicalScope has first instruction and last instruction to mark
1505 // beginning and end of a scope respectively. Create an inverse map that list
1506 // scopes starts (and ends) with an instruction. One instruction may start (or
1507 // end) multiple scopes. Ignore scopes that are not reachable.
1508 void DwarfDebug::identifyScopeMarkers() {
1509 SmallVector<LexicalScope *, 4> WorkList;
1510 WorkList.push_back(LScopes.getCurrentFunctionScope());
1511 while (!WorkList.empty()) {
1512 LexicalScope *S = WorkList.pop_back_val();
1514 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1515 if (!Children.empty())
1516 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1517 SE = Children.end(); SI != SE; ++SI)
1518 WorkList.push_back(*SI);
1520 if (S->isAbstractScope())
1523 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1526 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1527 RE = Ranges.end(); RI != RE; ++RI) {
1528 assert(RI->first && "InsnRange does not have first instruction!");
1529 assert(RI->second && "InsnRange does not have second instruction!");
1530 requestLabelBeforeInsn(RI->first);
1531 requestLabelAfterInsn(RI->second);
1536 // Get MDNode for DebugLoc's scope.
1537 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1538 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1539 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1540 return DL.getScope(Ctx);
1543 // Walk up the scope chain of given debug loc and find line number info
1544 // for the function.
1545 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1546 const MDNode *Scope = getScopeNode(DL, Ctx);
1547 DISubprogram SP = getDISubprogram(Scope);
1548 if (SP.isSubprogram()) {
1549 // Check for number of operands since the compatibility is
1551 if (SP->getNumOperands() > 19)
1552 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1554 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1560 // Gather pre-function debug information. Assumes being called immediately
1561 // after the function entry point has been emitted.
1562 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1563 if (!MMI->hasDebugInfo()) return;
1564 LScopes.initialize(*MF);
1565 if (LScopes.empty()) return;
1566 identifyScopeMarkers();
1568 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1570 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1571 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1572 assert(TheCU && "Unable to find compile unit!");
1573 if (Asm->TM.hasMCUseLoc() &&
1574 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1575 // Use a single line table if we are using .loc and generating assembly.
1576 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1578 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1580 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1581 Asm->getFunctionNumber());
1582 // Assumes in correct section after the entry point.
1583 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1585 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1587 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1588 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1589 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1591 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1593 bool AtBlockEntry = true;
1594 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1596 const MachineInstr *MI = II;
1598 if (MI->isDebugValue()) {
1599 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1601 // Keep track of user variables.
1603 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1605 // Variable is in a register, we need to check for clobbers.
1606 if (isDbgValueInDefinedReg(MI))
1607 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1609 // Check the history of this variable.
1610 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1611 if (History.empty()) {
1612 UserVariables.push_back(Var);
1613 // The first mention of a function argument gets the FunctionBeginSym
1614 // label, so arguments are visible when breaking at function entry.
1616 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1617 DISubprogram(getDISubprogram(DV.getContext()))
1618 .describes(MF->getFunction()))
1619 LabelsBeforeInsn[MI] = FunctionBeginSym;
1621 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1622 const MachineInstr *Prev = History.back();
1623 if (Prev->isDebugValue()) {
1624 // Coalesce identical entries at the end of History.
1625 if (History.size() >= 2 &&
1626 Prev->isIdenticalTo(History[History.size() - 2])) {
1627 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1629 << "\t" << *History[History.size() - 2] << "\n");
1633 // Terminate old register assignments that don't reach MI;
1634 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1635 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1636 isDbgValueInDefinedReg(Prev)) {
1637 // Previous register assignment needs to terminate at the end of
1639 MachineBasicBlock::const_iterator LastMI =
1640 PrevMBB->getLastNonDebugInstr();
1641 if (LastMI == PrevMBB->end()) {
1642 // Drop DBG_VALUE for empty range.
1643 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1644 << "\t" << *Prev << "\n");
1646 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1647 // Terminate after LastMI.
1648 History.push_back(LastMI);
1652 History.push_back(MI);
1654 // Not a DBG_VALUE instruction.
1656 AtBlockEntry = false;
1658 // First known non-DBG_VALUE and non-frame setup location marks
1659 // the beginning of the function body.
1660 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1661 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1662 PrologEndLoc = MI->getDebugLoc();
1664 // Check if the instruction clobbers any registers with debug vars.
1665 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1666 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1667 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1669 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1670 AI.isValid(); ++AI) {
1672 const MDNode *Var = LiveUserVar[Reg];
1675 // Reg is now clobbered.
1676 LiveUserVar[Reg] = 0;
1678 // Was MD last defined by a DBG_VALUE referring to Reg?
1679 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1680 if (HistI == DbgValues.end())
1682 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1683 if (History.empty())
1685 const MachineInstr *Prev = History.back();
1686 // Sanity-check: Register assignments are terminated at the end of
1688 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1690 // Is the variable still in Reg?
1691 if (!isDbgValueInDefinedReg(Prev) ||
1692 Prev->getOperand(0).getReg() != Reg)
1694 // Var is clobbered. Make sure the next instruction gets a label.
1695 History.push_back(MI);
1702 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1704 SmallVectorImpl<const MachineInstr*> &History = I->second;
1705 if (History.empty())
1708 // Make sure the final register assignments are terminated.
1709 const MachineInstr *Prev = History.back();
1710 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1711 const MachineBasicBlock *PrevMBB = Prev->getParent();
1712 MachineBasicBlock::const_iterator LastMI =
1713 PrevMBB->getLastNonDebugInstr();
1714 if (LastMI == PrevMBB->end())
1715 // Drop DBG_VALUE for empty range.
1717 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1718 // Terminate after LastMI.
1719 History.push_back(LastMI);
1722 // Request labels for the full history.
1723 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1724 const MachineInstr *MI = History[i];
1725 if (MI->isDebugValue())
1726 requestLabelBeforeInsn(MI);
1728 requestLabelAfterInsn(MI);
1732 PrevInstLoc = DebugLoc();
1733 PrevLabel = FunctionBeginSym;
1735 // Record beginning of function.
1736 if (!PrologEndLoc.isUnknown()) {
1737 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1738 MF->getFunction()->getContext());
1739 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1740 FnStartDL.getScope(MF->getFunction()->getContext()),
1741 // We'd like to list the prologue as "not statements" but GDB behaves
1742 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1743 DWARF2_FLAG_IS_STMT);
1747 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1748 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1749 DIVariable DV = Var->getVariable();
1750 // Variables with positive arg numbers are parameters.
1751 if (unsigned ArgNum = DV.getArgNumber()) {
1752 // Keep all parameters in order at the start of the variable list to ensure
1753 // function types are correct (no out-of-order parameters)
1755 // This could be improved by only doing it for optimized builds (unoptimized
1756 // builds have the right order to begin with), searching from the back (this
1757 // would catch the unoptimized case quickly), or doing a binary search
1758 // rather than linear search.
1759 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1760 while (I != Vars.end()) {
1761 unsigned CurNum = (*I)->getVariable().getArgNumber();
1762 // A local (non-parameter) variable has been found, insert immediately
1766 // A later indexed parameter has been found, insert immediately before it.
1767 if (CurNum > ArgNum)
1771 Vars.insert(I, Var);
1775 Vars.push_back(Var);
1778 // Gather and emit post-function debug information.
1779 void DwarfDebug::endFunction(const MachineFunction *MF) {
1780 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1782 // Define end label for subprogram.
1783 FunctionEndSym = Asm->GetTempSymbol("func_end",
1784 Asm->getFunctionNumber());
1785 // Assumes in correct section after the entry point.
1786 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1787 // Set DwarfCompileUnitID in MCContext to default value.
1788 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1790 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1791 collectVariableInfo(MF, ProcessedVars);
1793 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1794 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1795 assert(TheCU && "Unable to find compile unit!");
1797 // Construct abstract scopes.
1798 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1799 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1800 LexicalScope *AScope = AList[i];
1801 DISubprogram SP(AScope->getScopeNode());
1802 if (SP.isSubprogram()) {
1803 // Collect info for variables that were optimized out.
1804 DIArray Variables = SP.getVariables();
1805 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1806 DIVariable DV(Variables.getElement(i));
1807 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1809 // Check that DbgVariable for DV wasn't created earlier, when
1810 // findAbstractVariable() was called for inlined instance of DV.
1811 LLVMContext &Ctx = DV->getContext();
1812 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1813 if (AbstractVariables.lookup(CleanDV))
1815 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1816 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1819 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1820 constructScopeDIE(TheCU, AScope);
1823 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1825 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1826 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1829 for (ScopeVariablesMap::iterator
1830 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1831 DeleteContainerPointers(I->second);
1832 ScopeVariables.clear();
1833 DeleteContainerPointers(CurrentFnArguments);
1834 UserVariables.clear();
1836 AbstractVariables.clear();
1837 LabelsBeforeInsn.clear();
1838 LabelsAfterInsn.clear();
1842 // Register a source line with debug info. Returns the unique label that was
1843 // emitted and which provides correspondence to the source line list.
1844 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1850 DIDescriptor Scope(S);
1852 if (Scope.isCompileUnit()) {
1853 DICompileUnit CU(S);
1854 Fn = CU.getFilename();
1855 Dir = CU.getDirectory();
1856 } else if (Scope.isFile()) {
1858 Fn = F.getFilename();
1859 Dir = F.getDirectory();
1860 } else if (Scope.isSubprogram()) {
1862 Fn = SP.getFilename();
1863 Dir = SP.getDirectory();
1864 } else if (Scope.isLexicalBlockFile()) {
1865 DILexicalBlockFile DBF(S);
1866 Fn = DBF.getFilename();
1867 Dir = DBF.getDirectory();
1868 } else if (Scope.isLexicalBlock()) {
1869 DILexicalBlock DB(S);
1870 Fn = DB.getFilename();
1871 Dir = DB.getDirectory();
1873 llvm_unreachable("Unexpected scope info");
1875 Src = getOrCreateSourceID(Fn, Dir,
1876 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1878 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1881 //===----------------------------------------------------------------------===//
1883 //===----------------------------------------------------------------------===//
1885 // Compute the size and offset of a DIE.
1887 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1888 // Get the children.
1889 const std::vector<DIE *> &Children = Die->getChildren();
1891 // Record the abbreviation.
1892 assignAbbrevNumber(Die->getAbbrev());
1894 // Get the abbreviation for this DIE.
1895 unsigned AbbrevNumber = Die->getAbbrevNumber();
1896 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1899 Die->setOffset(Offset);
1901 // Start the size with the size of abbreviation code.
1902 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1904 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1905 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1907 // Size the DIE attribute values.
1908 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1909 // Size attribute value.
1910 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1912 // Size the DIE children if any.
1913 if (!Children.empty()) {
1914 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1915 "Children flag not set");
1917 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1918 Offset = computeSizeAndOffset(Children[j], Offset);
1920 // End of children marker.
1921 Offset += sizeof(int8_t);
1924 Die->setSize(Offset - Die->getOffset());
1928 // Compute the size and offset of all the DIEs.
1929 void DwarfUnits::computeSizeAndOffsets() {
1930 // Offset from the beginning of debug info section.
1931 unsigned SecOffset = 0;
1932 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1933 E = CUs.end(); I != E; ++I) {
1934 (*I)->setDebugInfoOffset(SecOffset);
1936 sizeof(int32_t) + // Length of Compilation Unit Info
1937 sizeof(int16_t) + // DWARF version number
1938 sizeof(int32_t) + // Offset Into Abbrev. Section
1939 sizeof(int8_t); // Pointer Size (in bytes)
1941 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1942 SecOffset += EndOffset;
1946 // Emit initial Dwarf sections with a label at the start of each one.
1947 void DwarfDebug::emitSectionLabels() {
1948 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1950 // Dwarf sections base addresses.
1951 DwarfInfoSectionSym =
1952 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1953 DwarfAbbrevSectionSym =
1954 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1955 if (useSplitDwarf())
1956 DwarfAbbrevDWOSectionSym =
1957 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1958 "section_abbrev_dwo");
1959 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1961 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1962 emitSectionSym(Asm, MacroInfo);
1964 DwarfLineSectionSym =
1965 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1966 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1967 if (HasDwarfPubSections) {
1968 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1969 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1970 } else if (GenerateGnuPubSections) {
1971 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1972 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1975 DwarfStrSectionSym =
1976 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1977 if (useSplitDwarf()) {
1978 DwarfStrDWOSectionSym =
1979 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1980 DwarfAddrSectionSym =
1981 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1983 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1986 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1987 "section_debug_loc");
1989 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1990 emitSectionSym(Asm, TLOF.getDataSection());
1993 // Recursively emits a debug information entry.
1994 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1995 // Get the abbreviation for this DIE.
1996 unsigned AbbrevNumber = Die->getAbbrevNumber();
1997 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1999 // Emit the code (index) for the abbreviation.
2000 if (Asm->isVerbose())
2001 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2002 Twine::utohexstr(Die->getOffset()) + ":0x" +
2003 Twine::utohexstr(Die->getSize()) + " " +
2004 dwarf::TagString(Abbrev->getTag()));
2005 Asm->EmitULEB128(AbbrevNumber);
2007 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2008 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2010 // Emit the DIE attribute values.
2011 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2012 unsigned Attr = AbbrevData[i].getAttribute();
2013 unsigned Form = AbbrevData[i].getForm();
2014 assert(Form && "Too many attributes for DIE (check abbreviation)");
2016 if (Asm->isVerbose())
2017 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2020 case dwarf::DW_AT_abstract_origin: {
2021 DIEEntry *E = cast<DIEEntry>(Values[i]);
2022 DIE *Origin = E->getEntry();
2023 unsigned Addr = Origin->getOffset();
2024 if (Form == dwarf::DW_FORM_ref_addr) {
2025 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2026 // section. Origin->getOffset() returns the offset from start of the
2028 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2029 Addr += Holder.getCUOffset(Origin->getCompileUnit());
2031 Asm->OutStreamer.EmitIntValue(Addr,
2032 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
2035 case dwarf::DW_AT_ranges: {
2036 // DW_AT_range Value encodes offset in debug_range section.
2037 DIEInteger *V = cast<DIEInteger>(Values[i]);
2039 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2040 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2044 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2046 DwarfDebugRangeSectionSym,
2051 case dwarf::DW_AT_location: {
2052 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2053 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2054 Asm->EmitLabelReference(L->getValue(), 4);
2056 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2058 Values[i]->EmitValue(Asm, Form);
2062 case dwarf::DW_AT_accessibility: {
2063 if (Asm->isVerbose()) {
2064 DIEInteger *V = cast<DIEInteger>(Values[i]);
2065 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2067 Values[i]->EmitValue(Asm, Form);
2071 // Emit an attribute using the defined form.
2072 Values[i]->EmitValue(Asm, Form);
2077 // Emit the DIE children if any.
2078 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2079 const std::vector<DIE *> &Children = Die->getChildren();
2081 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2082 emitDIE(Children[j], Abbrevs);
2084 if (Asm->isVerbose())
2085 Asm->OutStreamer.AddComment("End Of Children Mark");
2090 // Emit the various dwarf units to the unit section USection with
2091 // the abbreviations going into ASection.
2092 void DwarfUnits::emitUnits(DwarfDebug *DD,
2093 const MCSection *USection,
2094 const MCSection *ASection,
2095 const MCSymbol *ASectionSym) {
2096 Asm->OutStreamer.SwitchSection(USection);
2097 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2098 E = CUs.end(); I != E; ++I) {
2099 CompileUnit *TheCU = *I;
2100 DIE *Die = TheCU->getCUDie();
2102 // Emit the compile units header.
2104 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2105 TheCU->getUniqueID()));
2107 // Emit size of content not including length itself
2108 unsigned ContentSize = Die->getSize() +
2109 sizeof(int16_t) + // DWARF version number
2110 sizeof(int32_t) + // Offset Into Abbrev. Section
2111 sizeof(int8_t); // Pointer Size (in bytes)
2113 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2114 Asm->EmitInt32(ContentSize);
2115 Asm->OutStreamer.AddComment("DWARF version number");
2116 Asm->EmitInt16(DD->getDwarfVersion());
2117 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2118 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2120 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2121 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2123 DD->emitDIE(Die, Abbreviations);
2124 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2125 TheCU->getUniqueID()));
2129 /// For a given compile unit DIE, returns offset from beginning of debug info.
2130 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2131 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2132 "Input DIE should be compile unit in getCUOffset.");
2133 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2135 CompileUnit *TheCU = *I;
2136 if (TheCU->getCUDie() == Die)
2137 return TheCU->getDebugInfoOffset();
2139 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2142 // Emit the debug info section.
2143 void DwarfDebug::emitDebugInfo() {
2144 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2146 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2147 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2148 DwarfAbbrevSectionSym);
2151 // Emit the abbreviation section.
2152 void DwarfDebug::emitAbbreviations() {
2153 if (!useSplitDwarf())
2154 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2157 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2160 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2161 std::vector<DIEAbbrev *> *Abbrevs) {
2162 // Check to see if it is worth the effort.
2163 if (!Abbrevs->empty()) {
2164 // Start the debug abbrev section.
2165 Asm->OutStreamer.SwitchSection(Section);
2167 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2168 Asm->OutStreamer.EmitLabel(Begin);
2170 // For each abbrevation.
2171 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2172 // Get abbreviation data
2173 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2175 // Emit the abbrevations code (base 1 index.)
2176 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2178 // Emit the abbreviations data.
2182 // Mark end of abbreviations.
2183 Asm->EmitULEB128(0, "EOM(3)");
2185 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2186 Asm->OutStreamer.EmitLabel(End);
2190 // Emit the last address of the section and the end of the line matrix.
2191 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2192 // Define last address of section.
2193 Asm->OutStreamer.AddComment("Extended Op");
2196 Asm->OutStreamer.AddComment("Op size");
2197 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2198 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2199 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2201 Asm->OutStreamer.AddComment("Section end label");
2203 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2204 Asm->getDataLayout().getPointerSize());
2206 // Mark end of matrix.
2207 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2213 // Emit visible names into a hashed accelerator table section.
2214 void DwarfDebug::emitAccelNames() {
2215 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2216 dwarf::DW_FORM_data4));
2217 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2218 E = CUMap.end(); I != E; ++I) {
2219 CompileUnit *TheCU = I->second;
2220 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2221 for (StringMap<std::vector<DIE*> >::const_iterator
2222 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2223 StringRef Name = GI->getKey();
2224 const std::vector<DIE *> &Entities = GI->second;
2225 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2226 DE = Entities.end(); DI != DE; ++DI)
2227 AT.AddName(Name, (*DI));
2231 AT.FinalizeTable(Asm, "Names");
2232 Asm->OutStreamer.SwitchSection(
2233 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2234 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2235 Asm->OutStreamer.EmitLabel(SectionBegin);
2237 // Emit the full data.
2238 AT.Emit(Asm, SectionBegin, &InfoHolder);
2241 // Emit objective C classes and categories into a hashed accelerator table
2243 void DwarfDebug::emitAccelObjC() {
2244 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2245 dwarf::DW_FORM_data4));
2246 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2247 E = CUMap.end(); I != E; ++I) {
2248 CompileUnit *TheCU = I->second;
2249 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2250 for (StringMap<std::vector<DIE*> >::const_iterator
2251 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2252 StringRef Name = GI->getKey();
2253 const std::vector<DIE *> &Entities = GI->second;
2254 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2255 DE = Entities.end(); DI != DE; ++DI)
2256 AT.AddName(Name, (*DI));
2260 AT.FinalizeTable(Asm, "ObjC");
2261 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2262 .getDwarfAccelObjCSection());
2263 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2264 Asm->OutStreamer.EmitLabel(SectionBegin);
2266 // Emit the full data.
2267 AT.Emit(Asm, SectionBegin, &InfoHolder);
2270 // Emit namespace dies into a hashed accelerator table.
2271 void DwarfDebug::emitAccelNamespaces() {
2272 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2273 dwarf::DW_FORM_data4));
2274 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2275 E = CUMap.end(); I != E; ++I) {
2276 CompileUnit *TheCU = I->second;
2277 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2278 for (StringMap<std::vector<DIE*> >::const_iterator
2279 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2280 StringRef Name = GI->getKey();
2281 const std::vector<DIE *> &Entities = GI->second;
2282 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2283 DE = Entities.end(); DI != DE; ++DI)
2284 AT.AddName(Name, (*DI));
2288 AT.FinalizeTable(Asm, "namespac");
2289 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2290 .getDwarfAccelNamespaceSection());
2291 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2292 Asm->OutStreamer.EmitLabel(SectionBegin);
2294 // Emit the full data.
2295 AT.Emit(Asm, SectionBegin, &InfoHolder);
2298 // Emit type dies into a hashed accelerator table.
2299 void DwarfDebug::emitAccelTypes() {
2300 std::vector<DwarfAccelTable::Atom> Atoms;
2301 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2302 dwarf::DW_FORM_data4));
2303 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2304 dwarf::DW_FORM_data2));
2305 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2306 dwarf::DW_FORM_data1));
2307 DwarfAccelTable AT(Atoms);
2308 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2309 E = CUMap.end(); I != E; ++I) {
2310 CompileUnit *TheCU = I->second;
2311 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2312 = TheCU->getAccelTypes();
2313 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2314 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2315 StringRef Name = GI->getKey();
2316 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2317 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2318 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2319 AT.AddName(Name, (*DI).first, (*DI).second);
2323 AT.FinalizeTable(Asm, "types");
2324 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2325 .getDwarfAccelTypesSection());
2326 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2327 Asm->OutStreamer.EmitLabel(SectionBegin);
2329 // Emit the full data.
2330 AT.Emit(Asm, SectionBegin, &InfoHolder);
2333 // Public name handling.
2334 // The format for the various pubnames:
2336 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2337 // for the DIE that is named.
2339 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2340 // into the CU and the index value is computed according to the type of value
2341 // for the DIE that is named.
2343 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2344 // it's the offset within the debug_info/debug_types dwo section, however, the
2345 // reference in the pubname header doesn't change.
2347 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2348 static dwarf::PubIndexEntryDescriptor computeIndexValue(CompileUnit *CU,
2350 dwarf::GDBIndexEntryLinkage IsStatic =
2351 Die->findAttribute(dwarf::DW_AT_external) ? dwarf::GIEL_EXTERNAL
2352 : dwarf::GIEL_STATIC;
2354 switch (Die->getTag()) {
2355 case dwarf::DW_TAG_class_type:
2356 case dwarf::DW_TAG_structure_type:
2357 case dwarf::DW_TAG_union_type:
2358 case dwarf::DW_TAG_enumeration_type:
2359 case dwarf::DW_TAG_typedef:
2360 case dwarf::DW_TAG_base_type:
2361 case dwarf::DW_TAG_subrange_type:
2362 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2363 case dwarf::DW_TAG_namespace:
2364 return dwarf::GIEK_TYPE;
2365 case dwarf::DW_TAG_subprogram:
2366 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, IsStatic);
2367 case dwarf::DW_TAG_constant:
2368 case dwarf::DW_TAG_variable:
2369 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, IsStatic);
2370 case dwarf::DW_TAG_enumerator:
2371 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2372 dwarf::GIEL_STATIC);
2374 return dwarf::GIEK_NONE;
2378 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2380 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2381 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2382 const MCSection *PSec =
2383 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2384 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2386 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2387 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2388 CompileUnit *TheCU = I->second;
2389 unsigned ID = TheCU->getUniqueID();
2391 if (TheCU->getGlobalNames().empty())
2394 // Start the dwarf pubnames section.
2395 Asm->OutStreamer.SwitchSection(PSec);
2398 Asm->OutStreamer.AddComment("Length of Public Names Info");
2399 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2400 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2402 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2404 Asm->OutStreamer.AddComment("DWARF Version");
2405 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2407 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2408 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2409 DwarfInfoSectionSym);
2411 Asm->OutStreamer.AddComment("Compilation Unit Length");
2412 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2413 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2416 // Emit the pubnames for this compilation unit.
2417 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2418 for (StringMap<DIE*>::const_iterator
2419 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2420 const char *Name = GI->getKeyData();
2421 DIE *Entity = GI->second;
2423 Asm->OutStreamer.AddComment("DIE offset");
2424 Asm->EmitInt32(Entity->getOffset());
2427 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2428 Asm->OutStreamer.AddComment(
2429 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2430 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2431 Asm->EmitInt8(Desc.toBits());
2434 if (Asm->isVerbose())
2435 Asm->OutStreamer.AddComment("External Name");
2436 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2439 Asm->OutStreamer.AddComment("End Mark");
2441 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2445 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2446 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2447 const MCSection *PSec = Asm->getObjFileLowering().getDwarfPubTypesSection();
2449 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2452 CompileUnit *TheCU = I->second;
2453 // Start the dwarf pubtypes section.
2454 Asm->OutStreamer.SwitchSection(PSec);
2455 Asm->OutStreamer.AddComment("Length of Public Types Info");
2456 Asm->EmitLabelDifference(
2457 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2458 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2460 Asm->OutStreamer.EmitLabel(
2461 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()));
2463 if (Asm->isVerbose())
2464 Asm->OutStreamer.AddComment("DWARF Version");
2465 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2467 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2468 Asm->EmitSectionOffset(
2469 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()),
2470 DwarfInfoSectionSym);
2472 Asm->OutStreamer.AddComment("Compilation Unit Length");
2473 Asm->EmitLabelDifference(
2474 Asm->GetTempSymbol(ISec->getLabelEndName(), TheCU->getUniqueID()),
2475 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()), 4);
2477 const StringMap<DIE *> &Globals = TheCU->getGlobalTypes();
2478 for (StringMap<DIE *>::const_iterator GI = Globals.begin(),
2481 const char *Name = GI->getKeyData();
2482 DIE *Entity = GI->second;
2484 if (Asm->isVerbose())
2485 Asm->OutStreamer.AddComment("DIE offset");
2486 Asm->EmitInt32(Entity->getOffset());
2489 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2490 Asm->OutStreamer.AddComment(
2491 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2492 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2493 Asm->EmitInt8(Desc.toBits());
2496 if (Asm->isVerbose())
2497 Asm->OutStreamer.AddComment("External Name");
2499 // Emit the name with a terminating null byte.
2500 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2503 Asm->OutStreamer.AddComment("End Mark");
2505 Asm->OutStreamer.EmitLabel(
2506 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()));
2510 // Emit strings into a string section.
2511 void DwarfUnits::emitStrings(const MCSection *StrSection,
2512 const MCSection *OffsetSection = NULL,
2513 const MCSymbol *StrSecSym = NULL) {
2515 if (StringPool.empty()) return;
2517 // Start the dwarf str section.
2518 Asm->OutStreamer.SwitchSection(StrSection);
2520 // Get all of the string pool entries and put them in an array by their ID so
2521 // we can sort them.
2522 SmallVector<std::pair<unsigned,
2523 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2525 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2526 I = StringPool.begin(), E = StringPool.end();
2528 Entries.push_back(std::make_pair(I->second.second, &*I));
2530 array_pod_sort(Entries.begin(), Entries.end());
2532 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2533 // Emit a label for reference from debug information entries.
2534 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2536 // Emit the string itself with a terminating null byte.
2537 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2538 Entries[i].second->getKeyLength()+1));
2541 // If we've got an offset section go ahead and emit that now as well.
2542 if (OffsetSection) {
2543 Asm->OutStreamer.SwitchSection(OffsetSection);
2544 unsigned offset = 0;
2545 unsigned size = 4; // FIXME: DWARF64 is 8.
2546 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2547 Asm->OutStreamer.EmitIntValue(offset, size);
2548 offset += Entries[i].second->getKeyLength() + 1;
2553 // Emit strings into a string section.
2554 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2556 if (AddressPool.empty()) return;
2558 // Start the dwarf addr section.
2559 Asm->OutStreamer.SwitchSection(AddrSection);
2561 // Order the address pool entries by ID
2562 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2564 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2565 E = AddressPool.end();
2567 Entries[I->second] = I->first;
2569 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2570 // Emit an expression for reference from debug information entries.
2571 if (const MCExpr *Expr = Entries[i])
2572 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2574 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2579 // Emit visible names into a debug str section.
2580 void DwarfDebug::emitDebugStr() {
2581 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2582 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2585 // Emit locations into the debug loc section.
2586 void DwarfDebug::emitDebugLoc() {
2587 if (DotDebugLocEntries.empty())
2590 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2591 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2593 DotDebugLocEntry &Entry = *I;
2594 if (I + 1 != DotDebugLocEntries.end())
2598 // Start the dwarf loc section.
2599 Asm->OutStreamer.SwitchSection(
2600 Asm->getObjFileLowering().getDwarfLocSection());
2601 unsigned char Size = Asm->getDataLayout().getPointerSize();
2602 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2604 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2605 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2606 I != E; ++I, ++index) {
2607 DotDebugLocEntry &Entry = *I;
2608 if (Entry.isMerged()) continue;
2609 if (Entry.isEmpty()) {
2610 Asm->OutStreamer.EmitIntValue(0, Size);
2611 Asm->OutStreamer.EmitIntValue(0, Size);
2612 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2614 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2615 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2616 DIVariable DV(Entry.getVariable());
2617 Asm->OutStreamer.AddComment("Loc expr size");
2618 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2619 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2620 Asm->EmitLabelDifference(end, begin, 2);
2621 Asm->OutStreamer.EmitLabel(begin);
2622 if (Entry.isInt()) {
2623 DIBasicType BTy(DV.getType());
2625 (BTy.getEncoding() == dwarf::DW_ATE_signed
2626 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2627 Asm->OutStreamer.AddComment("DW_OP_consts");
2628 Asm->EmitInt8(dwarf::DW_OP_consts);
2629 Asm->EmitSLEB128(Entry.getInt());
2631 Asm->OutStreamer.AddComment("DW_OP_constu");
2632 Asm->EmitInt8(dwarf::DW_OP_constu);
2633 Asm->EmitULEB128(Entry.getInt());
2635 } else if (Entry.isLocation()) {
2636 MachineLocation Loc = Entry.getLoc();
2637 if (!DV.hasComplexAddress())
2639 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2641 // Complex address entry.
2642 unsigned N = DV.getNumAddrElements();
2644 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2645 if (Loc.getOffset()) {
2647 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2648 Asm->OutStreamer.AddComment("DW_OP_deref");
2649 Asm->EmitInt8(dwarf::DW_OP_deref);
2650 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2651 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2652 Asm->EmitSLEB128(DV.getAddrElement(1));
2654 // If first address element is OpPlus then emit
2655 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2656 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2657 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2661 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2664 // Emit remaining complex address elements.
2665 for (; i < N; ++i) {
2666 uint64_t Element = DV.getAddrElement(i);
2667 if (Element == DIBuilder::OpPlus) {
2668 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2669 Asm->EmitULEB128(DV.getAddrElement(++i));
2670 } else if (Element == DIBuilder::OpDeref) {
2672 Asm->EmitInt8(dwarf::DW_OP_deref);
2674 llvm_unreachable("unknown Opcode found in complex address");
2678 // else ... ignore constant fp. There is not any good way to
2679 // to represent them here in dwarf.
2680 Asm->OutStreamer.EmitLabel(end);
2685 struct SymbolCUSorter {
2686 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2687 const MCStreamer &Streamer;
2689 bool operator() (const SymbolCU &A, const SymbolCU &B) {
2690 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2691 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2693 // Symbols with no order assigned should be placed at the end.
2694 // (e.g. section end labels)
2696 IA = (unsigned)(-1);
2698 IB = (unsigned)(-1);
2703 static bool SectionSort(const MCSection *A, const MCSection *B) {
2704 std::string LA = (A ? A->getLabelBeginName() : "");
2705 std::string LB = (B ? B->getLabelBeginName() : "");
2709 static bool CUSort(const CompileUnit *A, const CompileUnit *B) {
2710 return (A->getUniqueID() < B->getUniqueID());
2714 const MCSymbol *Start, *End;
2717 // Emit a debug aranges section, containing a CU lookup for any
2718 // address we can tie back to a CU.
2719 void DwarfDebug::emitDebugARanges() {
2720 // Start the dwarf aranges section.
2722 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2724 typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2728 // Build a list of sections used.
2729 std::vector<const MCSection *> Sections;
2730 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2732 const MCSection *Section = it->first;
2733 Sections.push_back(Section);
2736 // Sort the sections into order.
2737 // This is only done to ensure consistent output order across different runs.
2738 std::sort(Sections.begin(), Sections.end(), SectionSort);
2740 // Build a set of address spans, sorted by CU.
2741 for (size_t SecIdx=0;SecIdx<Sections.size();SecIdx++) {
2742 const MCSection *Section = Sections[SecIdx];
2743 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2744 if (List.size() < 2)
2747 // Sort the symbols by offset within the section.
2748 SymbolCUSorter sorter(Asm->OutStreamer);
2749 std::sort(List.begin(), List.end(), sorter);
2751 // If we have no section (e.g. common), just write out
2752 // individual spans for each symbol.
2753 if (Section == NULL) {
2754 for (size_t n = 0; n < List.size(); n++) {
2755 const SymbolCU &Cur = List[n];
2758 Span.Start = Cur.Sym;
2761 Spans[Cur.CU].push_back(Span);
2764 // Build spans between each label.
2765 const MCSymbol *StartSym = List[0].Sym;
2766 for (size_t n = 1; n < List.size(); n++) {
2767 const SymbolCU &Prev = List[n - 1];
2768 const SymbolCU &Cur = List[n];
2770 // Try and build the longest span we can within the same CU.
2771 if (Cur.CU != Prev.CU) {
2773 Span.Start = StartSym;
2775 Spans[Prev.CU].push_back(Span);
2782 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2783 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2785 // Build a list of CUs used.
2786 std::vector<CompileUnit *> CUs;
2787 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2788 CompileUnit *CU = it->first;
2792 // Sort the CU list (again, to ensure consistent output order).
2793 std::sort(CUs.begin(), CUs.end(), CUSort);
2795 // Emit an arange table for each CU we used.
2796 for (size_t CUIdx=0;CUIdx<CUs.size();CUIdx++) {
2797 CompileUnit *CU = CUs[CUIdx];
2798 std::vector<ArangeSpan> &List = Spans[CU];
2800 // Emit size of content not including length itself.
2801 unsigned ContentSize
2802 = sizeof(int16_t) // DWARF ARange version number
2803 + sizeof(int32_t) // Offset of CU in the .debug_info section
2804 + sizeof(int8_t) // Pointer Size (in bytes)
2805 + sizeof(int8_t); // Segment Size (in bytes)
2807 unsigned TupleSize = PtrSize * 2;
2809 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2810 unsigned Padding = 0;
2811 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2814 ContentSize += Padding;
2815 ContentSize += (List.size() + 1) * TupleSize;
2817 // For each compile unit, write the list of spans it covers.
2818 Asm->OutStreamer.AddComment("Length of ARange Set");
2819 Asm->EmitInt32(ContentSize);
2820 Asm->OutStreamer.AddComment("DWARF Arange version number");
2821 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2822 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2823 Asm->EmitSectionOffset(
2824 Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2825 DwarfInfoSectionSym);
2826 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2827 Asm->EmitInt8(PtrSize);
2828 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2831 for (unsigned n = 0; n < Padding; n++)
2832 Asm->EmitInt8(0xff);
2834 for (unsigned n = 0; n < List.size(); n++) {
2835 const ArangeSpan &Span = List[n];
2836 Asm->EmitLabelReference(Span.Start, PtrSize);
2838 // Calculate the size as being from the span start to it's end.
2839 // If we have no valid end symbol, then we just cover the first byte.
2840 // (this sucks, but I can't seem to figure out how to get the size)
2842 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2844 Asm->OutStreamer.EmitIntValue(1, PtrSize);
2847 Asm->OutStreamer.AddComment("ARange terminator");
2848 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2849 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2853 // Emit visible names into a debug ranges section.
2854 void DwarfDebug::emitDebugRanges() {
2855 // Start the dwarf ranges section.
2857 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2858 unsigned char Size = Asm->getDataLayout().getPointerSize();
2859 for (SmallVectorImpl<const MCSymbol *>::iterator
2860 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2863 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2865 Asm->OutStreamer.EmitIntValue(0, Size);
2869 // Emit visible names into a debug macinfo section.
2870 void DwarfDebug::emitDebugMacInfo() {
2871 if (const MCSection *LineInfo =
2872 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2873 // Start the dwarf macinfo section.
2874 Asm->OutStreamer.SwitchSection(LineInfo);
2878 // DWARF5 Experimental Separate Dwarf emitters.
2880 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2881 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2882 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2883 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2884 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2886 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2887 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2888 Asm, this, &SkeletonHolder);
2890 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2891 DICompileUnit(CU->getNode()).getSplitDebugFilename());
2893 // Relocate to the beginning of the addr_base section, else 0 for the
2894 // beginning of the one for this compile unit.
2895 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2896 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2897 DwarfAddrSectionSym);
2899 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2900 dwarf::DW_FORM_sec_offset, 0);
2902 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2903 // into an entity. We're using 0, or a NULL label for this.
2904 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2906 // DW_AT_stmt_list is a offset of line number information for this
2907 // compile unit in debug_line section.
2908 // FIXME: Should handle multiple compile units.
2909 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2910 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2911 DwarfLineSectionSym);
2913 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2915 if (!CompilationDir.empty())
2916 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2918 // Flag to let the linker know we have emitted new style pubnames.
2919 if (GenerateGnuPubSections)
2920 NewCU->addFlag(Die, dwarf::DW_AT_GNU_pubnames);
2922 SkeletonHolder.addUnit(NewCU);
2923 SkeletonCUs.push_back(NewCU);
2928 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2929 assert(useSplitDwarf() && "No split dwarf debug info?");
2930 emitAbbrevs(Section, &SkeletonAbbrevs);
2933 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2934 // compile units that would normally be in debug_info.
2935 void DwarfDebug::emitDebugInfoDWO() {
2936 assert(useSplitDwarf() && "No split dwarf debug info?");
2937 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2938 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2939 DwarfAbbrevDWOSectionSym);
2942 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2943 // abbreviations for the .debug_info.dwo section.
2944 void DwarfDebug::emitDebugAbbrevDWO() {
2945 assert(useSplitDwarf() && "No split dwarf?");
2946 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2950 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2951 // string section and is identical in format to traditional .debug_str
2953 void DwarfDebug::emitDebugStrDWO() {
2954 assert(useSplitDwarf() && "No split dwarf?");
2955 const MCSection *OffSec = Asm->getObjFileLowering()
2956 .getDwarfStrOffDWOSection();
2957 const MCSymbol *StrSym = DwarfStrSectionSym;
2958 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),