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.insert(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 // Standard sections final addresses.
1081 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1082 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1083 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1084 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1086 // End text sections.
1087 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1088 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1089 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1093 // Emit all Dwarf sections that should come after the content.
1094 void DwarfDebug::endModule() {
1096 if (!FirstCU) return;
1098 // End any existing sections.
1099 // TODO: Does this need to happen?
1102 // Finalize the debug info for the module.
1103 finalizeModuleInfo();
1105 if (!useSplitDwarf()) {
1106 // Emit all the DIEs into a debug info section.
1109 // Corresponding abbreviations into a abbrev section.
1110 emitAbbreviations();
1112 // Emit info into a debug loc section.
1115 // Emit info into a debug aranges section.
1118 // Emit info into a debug ranges section.
1121 // Emit info into a debug macinfo section.
1125 // TODO: Fill this in for separated debug sections and separate
1126 // out information into new sections.
1128 // Emit the debug info section and compile units.
1132 // Corresponding abbreviations into a abbrev section.
1133 emitAbbreviations();
1134 emitDebugAbbrevDWO();
1136 // Emit info into a debug loc section.
1139 // Emit info into a debug aranges section.
1142 // Emit info into a debug ranges section.
1145 // Emit info into a debug macinfo section.
1148 // Emit DWO addresses.
1149 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1153 // Emit info into the dwarf accelerator table sections.
1154 if (useDwarfAccelTables()) {
1157 emitAccelNamespaces();
1161 // Emit the pubnames and pubtypes sections if requested.
1162 if (HasDwarfPubSections) {
1163 emitDebugPubNames(GenerateGnuPubSections ? true : false);
1164 emitDebugPubTypes(GenerateGnuPubSections ? true : false);
1167 // Finally emit string information into a string table.
1169 if (useSplitDwarf())
1174 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1175 E = CUMap.end(); I != E; ++I)
1178 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1179 E = SkeletonCUs.end(); I != E; ++I)
1182 // Reset these for the next Module if we have one.
1186 // Find abstract variable, if any, associated with Var.
1187 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1188 DebugLoc ScopeLoc) {
1189 LLVMContext &Ctx = DV->getContext();
1190 // More then one inlined variable corresponds to one abstract variable.
1191 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1192 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1194 return AbsDbgVariable;
1196 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1200 AbsDbgVariable = new DbgVariable(Var, NULL);
1201 addScopeVariable(Scope, AbsDbgVariable);
1202 AbstractVariables[Var] = AbsDbgVariable;
1203 return AbsDbgVariable;
1206 // If Var is a current function argument then add it to CurrentFnArguments list.
1207 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1208 DbgVariable *Var, LexicalScope *Scope) {
1209 if (!LScopes.isCurrentFunctionScope(Scope))
1211 DIVariable DV = Var->getVariable();
1212 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1214 unsigned ArgNo = DV.getArgNumber();
1218 size_t Size = CurrentFnArguments.size();
1220 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1221 // llvm::Function argument size is not good indicator of how many
1222 // arguments does the function have at source level.
1224 CurrentFnArguments.resize(ArgNo * 2);
1225 CurrentFnArguments[ArgNo - 1] = Var;
1229 // Collect variable information from side table maintained by MMI.
1231 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1232 SmallPtrSet<const MDNode *, 16> &Processed) {
1233 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1234 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1235 VE = VMap.end(); VI != VE; ++VI) {
1236 const MDNode *Var = VI->first;
1238 Processed.insert(Var);
1240 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1242 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1244 // If variable scope is not found then skip this variable.
1248 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1249 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1250 RegVar->setFrameIndex(VP.first);
1251 if (!addCurrentFnArgument(MF, RegVar, Scope))
1252 addScopeVariable(Scope, RegVar);
1254 AbsDbgVariable->setFrameIndex(VP.first);
1258 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1260 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1261 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1262 return MI->getNumOperands() == 3 &&
1263 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1264 (MI->getOperand(1).isImm() ||
1265 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1268 // Get .debug_loc entry for the instruction range starting at MI.
1269 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1270 const MCSymbol *FLabel,
1271 const MCSymbol *SLabel,
1272 const MachineInstr *MI) {
1273 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1275 assert(MI->getNumOperands() == 3);
1276 if (MI->getOperand(0).isReg()) {
1277 MachineLocation MLoc;
1278 // If the second operand is an immediate, this is a
1279 // register-indirect address.
1280 if (!MI->getOperand(1).isImm())
1281 MLoc.set(MI->getOperand(0).getReg());
1283 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1284 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1286 if (MI->getOperand(0).isImm())
1287 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1288 if (MI->getOperand(0).isFPImm())
1289 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1290 if (MI->getOperand(0).isCImm())
1291 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1293 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1296 // Find variables for each lexical scope.
1298 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1299 SmallPtrSet<const MDNode *, 16> &Processed) {
1301 // Grab the variable info that was squirreled away in the MMI side-table.
1302 collectVariableInfoFromMMITable(MF, Processed);
1304 for (SmallVectorImpl<const MDNode*>::const_iterator
1305 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1307 const MDNode *Var = *UVI;
1308 if (Processed.count(Var))
1311 // History contains relevant DBG_VALUE instructions for Var and instructions
1313 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1314 if (History.empty())
1316 const MachineInstr *MInsn = History.front();
1319 LexicalScope *Scope = NULL;
1320 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1321 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1322 Scope = LScopes.getCurrentFunctionScope();
1323 else if (MDNode *IA = DV.getInlinedAt())
1324 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1326 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1327 // If variable scope is not found then skip this variable.
1331 Processed.insert(DV);
1332 assert(MInsn->isDebugValue() && "History must begin with debug value");
1333 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1334 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1335 if (!addCurrentFnArgument(MF, RegVar, Scope))
1336 addScopeVariable(Scope, RegVar);
1338 AbsVar->setMInsn(MInsn);
1340 // Simplify ranges that are fully coalesced.
1341 if (History.size() <= 1 || (History.size() == 2 &&
1342 MInsn->isIdenticalTo(History.back()))) {
1343 RegVar->setMInsn(MInsn);
1347 // Handle multiple DBG_VALUE instructions describing one variable.
1348 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1350 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1351 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1352 const MachineInstr *Begin = *HI;
1353 assert(Begin->isDebugValue() && "Invalid History entry");
1355 // Check if DBG_VALUE is truncating a range.
1356 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1357 && !Begin->getOperand(0).getReg())
1360 // Compute the range for a register location.
1361 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1362 const MCSymbol *SLabel = 0;
1365 // If Begin is the last instruction in History then its value is valid
1366 // until the end of the function.
1367 SLabel = FunctionEndSym;
1369 const MachineInstr *End = HI[1];
1370 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1371 << "\t" << *Begin << "\t" << *End << "\n");
1372 if (End->isDebugValue())
1373 SLabel = getLabelBeforeInsn(End);
1375 // End is a normal instruction clobbering the range.
1376 SLabel = getLabelAfterInsn(End);
1377 assert(SLabel && "Forgot label after clobber instruction");
1382 // The value is valid until the next DBG_VALUE or clobber.
1383 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1386 DotDebugLocEntries.push_back(DotDebugLocEntry());
1389 // Collect info for variables that were optimized out.
1390 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1391 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1392 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1393 DIVariable DV(Variables.getElement(i));
1394 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1396 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1397 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1401 // Return Label preceding the instruction.
1402 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1403 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1404 assert(Label && "Didn't insert label before instruction");
1408 // Return Label immediately following the instruction.
1409 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1410 return LabelsAfterInsn.lookup(MI);
1413 // Process beginning of an instruction.
1414 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1415 // Check if source location changes, but ignore DBG_VALUE locations.
1416 if (!MI->isDebugValue()) {
1417 DebugLoc DL = MI->getDebugLoc();
1418 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1421 if (DL == PrologEndLoc) {
1422 Flags |= DWARF2_FLAG_PROLOGUE_END;
1423 PrologEndLoc = DebugLoc();
1425 if (PrologEndLoc.isUnknown())
1426 Flags |= DWARF2_FLAG_IS_STMT;
1428 if (!DL.isUnknown()) {
1429 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1430 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1432 recordSourceLine(0, 0, 0, 0);
1436 // Insert labels where requested.
1437 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1438 LabelsBeforeInsn.find(MI);
1441 if (I == LabelsBeforeInsn.end())
1444 // Label already assigned.
1449 PrevLabel = MMI->getContext().CreateTempSymbol();
1450 Asm->OutStreamer.EmitLabel(PrevLabel);
1452 I->second = PrevLabel;
1455 // Process end of an instruction.
1456 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1457 // Don't create a new label after DBG_VALUE instructions.
1458 // They don't generate code.
1459 if (!MI->isDebugValue())
1462 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1463 LabelsAfterInsn.find(MI);
1466 if (I == LabelsAfterInsn.end())
1469 // Label already assigned.
1473 // We need a label after this instruction.
1475 PrevLabel = MMI->getContext().CreateTempSymbol();
1476 Asm->OutStreamer.EmitLabel(PrevLabel);
1478 I->second = PrevLabel;
1481 // Each LexicalScope has first instruction and last instruction to mark
1482 // beginning and end of a scope respectively. Create an inverse map that list
1483 // scopes starts (and ends) with an instruction. One instruction may start (or
1484 // end) multiple scopes. Ignore scopes that are not reachable.
1485 void DwarfDebug::identifyScopeMarkers() {
1486 SmallVector<LexicalScope *, 4> WorkList;
1487 WorkList.push_back(LScopes.getCurrentFunctionScope());
1488 while (!WorkList.empty()) {
1489 LexicalScope *S = WorkList.pop_back_val();
1491 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1492 if (!Children.empty())
1493 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1494 SE = Children.end(); SI != SE; ++SI)
1495 WorkList.push_back(*SI);
1497 if (S->isAbstractScope())
1500 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1503 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1504 RE = Ranges.end(); RI != RE; ++RI) {
1505 assert(RI->first && "InsnRange does not have first instruction!");
1506 assert(RI->second && "InsnRange does not have second instruction!");
1507 requestLabelBeforeInsn(RI->first);
1508 requestLabelAfterInsn(RI->second);
1513 // Get MDNode for DebugLoc's scope.
1514 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1515 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1516 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1517 return DL.getScope(Ctx);
1520 // Walk up the scope chain of given debug loc and find line number info
1521 // for the function.
1522 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1523 const MDNode *Scope = getScopeNode(DL, Ctx);
1524 DISubprogram SP = getDISubprogram(Scope);
1525 if (SP.isSubprogram()) {
1526 // Check for number of operands since the compatibility is
1528 if (SP->getNumOperands() > 19)
1529 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1531 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1537 // Gather pre-function debug information. Assumes being called immediately
1538 // after the function entry point has been emitted.
1539 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1540 if (!MMI->hasDebugInfo()) return;
1541 LScopes.initialize(*MF);
1542 if (LScopes.empty()) return;
1543 identifyScopeMarkers();
1545 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1547 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1548 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1549 assert(TheCU && "Unable to find compile unit!");
1550 if (Asm->TM.hasMCUseLoc() &&
1551 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1552 // Use a single line table if we are using .loc and generating assembly.
1553 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1555 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1557 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1558 Asm->getFunctionNumber());
1559 // Assumes in correct section after the entry point.
1560 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1562 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1564 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1565 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1566 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1568 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1570 bool AtBlockEntry = true;
1571 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1573 const MachineInstr *MI = II;
1575 if (MI->isDebugValue()) {
1576 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1578 // Keep track of user variables.
1580 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1582 // Variable is in a register, we need to check for clobbers.
1583 if (isDbgValueInDefinedReg(MI))
1584 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1586 // Check the history of this variable.
1587 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1588 if (History.empty()) {
1589 UserVariables.push_back(Var);
1590 // The first mention of a function argument gets the FunctionBeginSym
1591 // label, so arguments are visible when breaking at function entry.
1593 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1594 DISubprogram(getDISubprogram(DV.getContext()))
1595 .describes(MF->getFunction()))
1596 LabelsBeforeInsn[MI] = FunctionBeginSym;
1598 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1599 const MachineInstr *Prev = History.back();
1600 if (Prev->isDebugValue()) {
1601 // Coalesce identical entries at the end of History.
1602 if (History.size() >= 2 &&
1603 Prev->isIdenticalTo(History[History.size() - 2])) {
1604 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1606 << "\t" << *History[History.size() - 2] << "\n");
1610 // Terminate old register assignments that don't reach MI;
1611 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1612 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1613 isDbgValueInDefinedReg(Prev)) {
1614 // Previous register assignment needs to terminate at the end of
1616 MachineBasicBlock::const_iterator LastMI =
1617 PrevMBB->getLastNonDebugInstr();
1618 if (LastMI == PrevMBB->end()) {
1619 // Drop DBG_VALUE for empty range.
1620 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1621 << "\t" << *Prev << "\n");
1623 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1624 // Terminate after LastMI.
1625 History.push_back(LastMI);
1629 History.push_back(MI);
1631 // Not a DBG_VALUE instruction.
1633 AtBlockEntry = false;
1635 // First known non-DBG_VALUE and non-frame setup location marks
1636 // the beginning of the function body.
1637 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1638 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1639 PrologEndLoc = MI->getDebugLoc();
1641 // Check if the instruction clobbers any registers with debug vars.
1642 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1643 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1644 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1646 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1647 AI.isValid(); ++AI) {
1649 const MDNode *Var = LiveUserVar[Reg];
1652 // Reg is now clobbered.
1653 LiveUserVar[Reg] = 0;
1655 // Was MD last defined by a DBG_VALUE referring to Reg?
1656 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1657 if (HistI == DbgValues.end())
1659 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1660 if (History.empty())
1662 const MachineInstr *Prev = History.back();
1663 // Sanity-check: Register assignments are terminated at the end of
1665 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1667 // Is the variable still in Reg?
1668 if (!isDbgValueInDefinedReg(Prev) ||
1669 Prev->getOperand(0).getReg() != Reg)
1671 // Var is clobbered. Make sure the next instruction gets a label.
1672 History.push_back(MI);
1679 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1681 SmallVectorImpl<const MachineInstr*> &History = I->second;
1682 if (History.empty())
1685 // Make sure the final register assignments are terminated.
1686 const MachineInstr *Prev = History.back();
1687 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1688 const MachineBasicBlock *PrevMBB = Prev->getParent();
1689 MachineBasicBlock::const_iterator LastMI =
1690 PrevMBB->getLastNonDebugInstr();
1691 if (LastMI == PrevMBB->end())
1692 // Drop DBG_VALUE for empty range.
1694 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1695 // Terminate after LastMI.
1696 History.push_back(LastMI);
1699 // Request labels for the full history.
1700 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1701 const MachineInstr *MI = History[i];
1702 if (MI->isDebugValue())
1703 requestLabelBeforeInsn(MI);
1705 requestLabelAfterInsn(MI);
1709 PrevInstLoc = DebugLoc();
1710 PrevLabel = FunctionBeginSym;
1712 // Record beginning of function.
1713 if (!PrologEndLoc.isUnknown()) {
1714 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1715 MF->getFunction()->getContext());
1716 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1717 FnStartDL.getScope(MF->getFunction()->getContext()),
1718 // We'd like to list the prologue as "not statements" but GDB behaves
1719 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1720 DWARF2_FLAG_IS_STMT);
1724 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1725 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1726 DIVariable DV = Var->getVariable();
1727 // Variables with positive arg numbers are parameters.
1728 if (unsigned ArgNum = DV.getArgNumber()) {
1729 // Keep all parameters in order at the start of the variable list to ensure
1730 // function types are correct (no out-of-order parameters)
1732 // This could be improved by only doing it for optimized builds (unoptimized
1733 // builds have the right order to begin with), searching from the back (this
1734 // would catch the unoptimized case quickly), or doing a binary search
1735 // rather than linear search.
1736 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1737 while (I != Vars.end()) {
1738 unsigned CurNum = (*I)->getVariable().getArgNumber();
1739 // A local (non-parameter) variable has been found, insert immediately
1743 // A later indexed parameter has been found, insert immediately before it.
1744 if (CurNum > ArgNum)
1748 Vars.insert(I, Var);
1752 Vars.push_back(Var);
1755 // Gather and emit post-function debug information.
1756 void DwarfDebug::endFunction(const MachineFunction *MF) {
1757 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1759 // Define end label for subprogram.
1760 FunctionEndSym = Asm->GetTempSymbol("func_end",
1761 Asm->getFunctionNumber());
1762 // Assumes in correct section after the entry point.
1763 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1764 // Set DwarfCompileUnitID in MCContext to default value.
1765 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1767 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1768 collectVariableInfo(MF, ProcessedVars);
1770 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1771 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1772 assert(TheCU && "Unable to find compile unit!");
1774 // Construct abstract scopes.
1775 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1776 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1777 LexicalScope *AScope = AList[i];
1778 DISubprogram SP(AScope->getScopeNode());
1779 if (SP.isSubprogram()) {
1780 // Collect info for variables that were optimized out.
1781 DIArray Variables = SP.getVariables();
1782 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1783 DIVariable DV(Variables.getElement(i));
1784 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1786 // Check that DbgVariable for DV wasn't created earlier, when
1787 // findAbstractVariable() was called for inlined instance of DV.
1788 LLVMContext &Ctx = DV->getContext();
1789 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1790 if (AbstractVariables.lookup(CleanDV))
1792 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1793 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1796 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1797 constructScopeDIE(TheCU, AScope);
1800 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1802 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1803 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1806 for (ScopeVariablesMap::iterator
1807 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1808 DeleteContainerPointers(I->second);
1809 ScopeVariables.clear();
1810 DeleteContainerPointers(CurrentFnArguments);
1811 UserVariables.clear();
1813 AbstractVariables.clear();
1814 LabelsBeforeInsn.clear();
1815 LabelsAfterInsn.clear();
1819 // Register a source line with debug info. Returns the unique label that was
1820 // emitted and which provides correspondence to the source line list.
1821 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1827 DIDescriptor Scope(S);
1829 if (Scope.isCompileUnit()) {
1830 DICompileUnit CU(S);
1831 Fn = CU.getFilename();
1832 Dir = CU.getDirectory();
1833 } else if (Scope.isFile()) {
1835 Fn = F.getFilename();
1836 Dir = F.getDirectory();
1837 } else if (Scope.isSubprogram()) {
1839 Fn = SP.getFilename();
1840 Dir = SP.getDirectory();
1841 } else if (Scope.isLexicalBlockFile()) {
1842 DILexicalBlockFile DBF(S);
1843 Fn = DBF.getFilename();
1844 Dir = DBF.getDirectory();
1845 } else if (Scope.isLexicalBlock()) {
1846 DILexicalBlock DB(S);
1847 Fn = DB.getFilename();
1848 Dir = DB.getDirectory();
1850 llvm_unreachable("Unexpected scope info");
1852 Src = getOrCreateSourceID(Fn, Dir,
1853 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1855 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1858 //===----------------------------------------------------------------------===//
1860 //===----------------------------------------------------------------------===//
1862 // Compute the size and offset of a DIE.
1864 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1865 // Get the children.
1866 const std::vector<DIE *> &Children = Die->getChildren();
1868 // Record the abbreviation.
1869 assignAbbrevNumber(Die->getAbbrev());
1871 // Get the abbreviation for this DIE.
1872 unsigned AbbrevNumber = Die->getAbbrevNumber();
1873 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1876 Die->setOffset(Offset);
1878 // Start the size with the size of abbreviation code.
1879 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1881 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1882 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1884 // Size the DIE attribute values.
1885 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1886 // Size attribute value.
1887 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1889 // Size the DIE children if any.
1890 if (!Children.empty()) {
1891 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1892 "Children flag not set");
1894 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1895 Offset = computeSizeAndOffset(Children[j], Offset);
1897 // End of children marker.
1898 Offset += sizeof(int8_t);
1901 Die->setSize(Offset - Die->getOffset());
1905 // Compute the size and offset of all the DIEs.
1906 void DwarfUnits::computeSizeAndOffsets() {
1907 // Offset from the beginning of debug info section.
1908 unsigned SecOffset = 0;
1909 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1910 E = CUs.end(); I != E; ++I) {
1911 (*I)->setDebugInfoOffset(SecOffset);
1913 sizeof(int32_t) + // Length of Compilation Unit Info
1914 sizeof(int16_t) + // DWARF version number
1915 sizeof(int32_t) + // Offset Into Abbrev. Section
1916 sizeof(int8_t); // Pointer Size (in bytes)
1918 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1919 SecOffset += EndOffset;
1923 // Emit initial Dwarf sections with a label at the start of each one.
1924 void DwarfDebug::emitSectionLabels() {
1925 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1927 // Dwarf sections base addresses.
1928 DwarfInfoSectionSym =
1929 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1930 DwarfAbbrevSectionSym =
1931 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1932 if (useSplitDwarf())
1933 DwarfAbbrevDWOSectionSym =
1934 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1935 "section_abbrev_dwo");
1936 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1938 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1939 emitSectionSym(Asm, MacroInfo);
1941 DwarfLineSectionSym =
1942 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1943 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1944 if (HasDwarfPubSections) {
1945 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1946 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1947 } else if (GenerateGnuPubSections) {
1948 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1949 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1952 DwarfStrSectionSym =
1953 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1954 if (useSplitDwarf()) {
1955 DwarfStrDWOSectionSym =
1956 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1957 DwarfAddrSectionSym =
1958 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1960 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1963 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1964 "section_debug_loc");
1966 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1967 emitSectionSym(Asm, TLOF.getDataSection());
1970 // Recursively emits a debug information entry.
1971 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1972 // Get the abbreviation for this DIE.
1973 unsigned AbbrevNumber = Die->getAbbrevNumber();
1974 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1976 // Emit the code (index) for the abbreviation.
1977 if (Asm->isVerbose())
1978 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1979 Twine::utohexstr(Die->getOffset()) + ":0x" +
1980 Twine::utohexstr(Die->getSize()) + " " +
1981 dwarf::TagString(Abbrev->getTag()));
1982 Asm->EmitULEB128(AbbrevNumber);
1984 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1985 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1987 // Emit the DIE attribute values.
1988 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1989 unsigned Attr = AbbrevData[i].getAttribute();
1990 unsigned Form = AbbrevData[i].getForm();
1991 assert(Form && "Too many attributes for DIE (check abbreviation)");
1993 if (Asm->isVerbose())
1994 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1997 case dwarf::DW_AT_abstract_origin: {
1998 DIEEntry *E = cast<DIEEntry>(Values[i]);
1999 DIE *Origin = E->getEntry();
2000 unsigned Addr = Origin->getOffset();
2001 if (Form == dwarf::DW_FORM_ref_addr) {
2002 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2003 // section. Origin->getOffset() returns the offset from start of the
2005 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2006 Addr += Holder.getCUOffset(Origin->getCompileUnit());
2008 Asm->OutStreamer.EmitIntValue(Addr,
2009 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
2012 case dwarf::DW_AT_ranges: {
2013 // DW_AT_range Value encodes offset in debug_range section.
2014 DIEInteger *V = cast<DIEInteger>(Values[i]);
2016 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2017 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2021 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2023 DwarfDebugRangeSectionSym,
2028 case dwarf::DW_AT_location: {
2029 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2030 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2031 Asm->EmitLabelReference(L->getValue(), 4);
2033 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2035 Values[i]->EmitValue(Asm, Form);
2039 case dwarf::DW_AT_accessibility: {
2040 if (Asm->isVerbose()) {
2041 DIEInteger *V = cast<DIEInteger>(Values[i]);
2042 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2044 Values[i]->EmitValue(Asm, Form);
2048 // Emit an attribute using the defined form.
2049 Values[i]->EmitValue(Asm, Form);
2054 // Emit the DIE children if any.
2055 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2056 const std::vector<DIE *> &Children = Die->getChildren();
2058 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2059 emitDIE(Children[j], Abbrevs);
2061 if (Asm->isVerbose())
2062 Asm->OutStreamer.AddComment("End Of Children Mark");
2067 // Emit the various dwarf units to the unit section USection with
2068 // the abbreviations going into ASection.
2069 void DwarfUnits::emitUnits(DwarfDebug *DD,
2070 const MCSection *USection,
2071 const MCSection *ASection,
2072 const MCSymbol *ASectionSym) {
2073 Asm->OutStreamer.SwitchSection(USection);
2074 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2075 E = CUs.end(); I != E; ++I) {
2076 CompileUnit *TheCU = *I;
2077 DIE *Die = TheCU->getCUDie();
2079 // Emit the compile units header.
2081 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2082 TheCU->getUniqueID()));
2084 // Emit size of content not including length itself
2085 unsigned ContentSize = Die->getSize() +
2086 sizeof(int16_t) + // DWARF version number
2087 sizeof(int32_t) + // Offset Into Abbrev. Section
2088 sizeof(int8_t); // Pointer Size (in bytes)
2090 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2091 Asm->EmitInt32(ContentSize);
2092 Asm->OutStreamer.AddComment("DWARF version number");
2093 Asm->EmitInt16(DD->getDwarfVersion());
2094 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2095 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2097 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2098 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2100 DD->emitDIE(Die, Abbreviations);
2101 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2102 TheCU->getUniqueID()));
2106 /// For a given compile unit DIE, returns offset from beginning of debug info.
2107 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2108 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2109 "Input DIE should be compile unit in getCUOffset.");
2110 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2112 CompileUnit *TheCU = *I;
2113 if (TheCU->getCUDie() == Die)
2114 return TheCU->getDebugInfoOffset();
2116 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2119 // Emit the debug info section.
2120 void DwarfDebug::emitDebugInfo() {
2121 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2123 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2124 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2125 DwarfAbbrevSectionSym);
2128 // Emit the abbreviation section.
2129 void DwarfDebug::emitAbbreviations() {
2130 if (!useSplitDwarf())
2131 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2134 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2137 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2138 std::vector<DIEAbbrev *> *Abbrevs) {
2139 // Check to see if it is worth the effort.
2140 if (!Abbrevs->empty()) {
2141 // Start the debug abbrev section.
2142 Asm->OutStreamer.SwitchSection(Section);
2144 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2145 Asm->OutStreamer.EmitLabel(Begin);
2147 // For each abbrevation.
2148 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2149 // Get abbreviation data
2150 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2152 // Emit the abbrevations code (base 1 index.)
2153 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2155 // Emit the abbreviations data.
2159 // Mark end of abbreviations.
2160 Asm->EmitULEB128(0, "EOM(3)");
2162 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2163 Asm->OutStreamer.EmitLabel(End);
2167 // Emit the last address of the section and the end of the line matrix.
2168 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2169 // Define last address of section.
2170 Asm->OutStreamer.AddComment("Extended Op");
2173 Asm->OutStreamer.AddComment("Op size");
2174 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2175 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2176 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2178 Asm->OutStreamer.AddComment("Section end label");
2180 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2181 Asm->getDataLayout().getPointerSize());
2183 // Mark end of matrix.
2184 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2190 // Emit visible names into a hashed accelerator table section.
2191 void DwarfDebug::emitAccelNames() {
2192 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2193 dwarf::DW_FORM_data4));
2194 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2195 E = CUMap.end(); I != E; ++I) {
2196 CompileUnit *TheCU = I->second;
2197 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2198 for (StringMap<std::vector<DIE*> >::const_iterator
2199 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2200 StringRef Name = GI->getKey();
2201 const std::vector<DIE *> &Entities = GI->second;
2202 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2203 DE = Entities.end(); DI != DE; ++DI)
2204 AT.AddName(Name, (*DI));
2208 AT.FinalizeTable(Asm, "Names");
2209 Asm->OutStreamer.SwitchSection(
2210 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2211 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2212 Asm->OutStreamer.EmitLabel(SectionBegin);
2214 // Emit the full data.
2215 AT.Emit(Asm, SectionBegin, &InfoHolder);
2218 // Emit objective C classes and categories into a hashed accelerator table
2220 void DwarfDebug::emitAccelObjC() {
2221 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2222 dwarf::DW_FORM_data4));
2223 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2224 E = CUMap.end(); I != E; ++I) {
2225 CompileUnit *TheCU = I->second;
2226 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2227 for (StringMap<std::vector<DIE*> >::const_iterator
2228 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2229 StringRef Name = GI->getKey();
2230 const std::vector<DIE *> &Entities = GI->second;
2231 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2232 DE = Entities.end(); DI != DE; ++DI)
2233 AT.AddName(Name, (*DI));
2237 AT.FinalizeTable(Asm, "ObjC");
2238 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2239 .getDwarfAccelObjCSection());
2240 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2241 Asm->OutStreamer.EmitLabel(SectionBegin);
2243 // Emit the full data.
2244 AT.Emit(Asm, SectionBegin, &InfoHolder);
2247 // Emit namespace dies into a hashed accelerator table.
2248 void DwarfDebug::emitAccelNamespaces() {
2249 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2250 dwarf::DW_FORM_data4));
2251 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2252 E = CUMap.end(); I != E; ++I) {
2253 CompileUnit *TheCU = I->second;
2254 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2255 for (StringMap<std::vector<DIE*> >::const_iterator
2256 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2257 StringRef Name = GI->getKey();
2258 const std::vector<DIE *> &Entities = GI->second;
2259 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2260 DE = Entities.end(); DI != DE; ++DI)
2261 AT.AddName(Name, (*DI));
2265 AT.FinalizeTable(Asm, "namespac");
2266 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2267 .getDwarfAccelNamespaceSection());
2268 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2269 Asm->OutStreamer.EmitLabel(SectionBegin);
2271 // Emit the full data.
2272 AT.Emit(Asm, SectionBegin, &InfoHolder);
2275 // Emit type dies into a hashed accelerator table.
2276 void DwarfDebug::emitAccelTypes() {
2277 std::vector<DwarfAccelTable::Atom> Atoms;
2278 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2279 dwarf::DW_FORM_data4));
2280 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2281 dwarf::DW_FORM_data2));
2282 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2283 dwarf::DW_FORM_data1));
2284 DwarfAccelTable AT(Atoms);
2285 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2286 E = CUMap.end(); I != E; ++I) {
2287 CompileUnit *TheCU = I->second;
2288 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2289 = TheCU->getAccelTypes();
2290 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2291 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2292 StringRef Name = GI->getKey();
2293 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2294 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2295 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2296 AT.AddName(Name, (*DI).first, (*DI).second);
2300 AT.FinalizeTable(Asm, "types");
2301 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2302 .getDwarfAccelTypesSection());
2303 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2304 Asm->OutStreamer.EmitLabel(SectionBegin);
2306 // Emit the full data.
2307 AT.Emit(Asm, SectionBegin, &InfoHolder);
2310 // Public name handling.
2311 // The format for the various pubnames:
2313 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2314 // for the DIE that is named.
2316 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2317 // into the CU and the index value is computed according to the type of value
2318 // for the DIE that is named.
2320 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2321 // it's the offset within the debug_info/debug_types dwo section, however, the
2322 // reference in the pubname header doesn't change.
2324 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2325 static uint8_t computeIndexValue(CompileUnit *CU, DIE *Die) {
2326 #define UPDATE_VALUE(CURRENT, VALUE) \
2328 (CURRENT) |= (((VALUE) & dwarf::GDB_INDEX_SYMBOL_KIND_MASK) \
2329 << dwarf::GDB_INDEX_SYMBOL_KIND_SHIFT); \
2332 #define UPDATE_STATIC(CURRENT, IS_STATIC) \
2334 (CURRENT) |= (((IS_STATIC) & dwarf::GDB_INDEX_SYMBOL_STATIC_MASK) \
2335 << dwarf::GDB_INDEX_SYMBOL_STATIC_SHIFT); \
2338 // Compute the Attributes for the Die.
2339 uint32_t Value = dwarf::GDB_INDEX_SYMBOL_KIND_NONE;
2341 Die->findAttribute(dwarf::DW_AT_external) != NULL ? true : false;
2343 switch (Die->getTag()) {
2344 case dwarf::DW_TAG_class_type:
2345 case dwarf::DW_TAG_structure_type:
2346 case dwarf::DW_TAG_union_type:
2347 case dwarf::DW_TAG_enumeration_type:
2348 case dwarf::DW_TAG_typedef:
2349 case dwarf::DW_TAG_base_type:
2350 case dwarf::DW_TAG_subrange_type:
2351 UPDATE_VALUE(Value, dwarf::GDB_INDEX_SYMBOL_KIND_TYPE);
2352 UPDATE_STATIC(Value, 1);
2354 case dwarf::DW_TAG_namespace:
2355 UPDATE_VALUE(Value, dwarf::GDB_INDEX_SYMBOL_KIND_TYPE);
2357 case dwarf::DW_TAG_subprogram:
2358 UPDATE_VALUE(Value, dwarf::GDB_INDEX_SYMBOL_KIND_FUNCTION);
2359 UPDATE_STATIC(Value, !External);
2361 case dwarf::DW_TAG_constant:
2362 case dwarf::DW_TAG_variable:
2363 UPDATE_VALUE(Value, dwarf::GDB_INDEX_SYMBOL_KIND_VARIABLE);
2364 UPDATE_STATIC(Value, !External);
2366 case dwarf::DW_TAG_enumerator:
2367 UPDATE_VALUE(Value, dwarf::GDB_INDEX_SYMBOL_KIND_VARIABLE);
2368 UPDATE_STATIC(Value, 1);
2373 // We don't need to add the CU into the bitmask for two reasons:
2374 // a) the pubnames/pubtypes sections are per-cpu, and
2375 // b) the linker wouldn't understand it anyhow.
2376 // so go ahead and make it 1 byte by shifting it down.
2377 return Value >> dwarf::GDB_INDEX_CU_BITSIZE;
2380 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2382 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2383 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2384 const MCSection *PSec =
2385 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2386 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2388 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2389 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2390 CompileUnit *TheCU = I->second;
2391 unsigned ID = TheCU->getUniqueID();
2393 if (TheCU->getGlobalNames().empty())
2396 // Start the dwarf pubnames section.
2397 Asm->OutStreamer.SwitchSection(PSec);
2400 Asm->OutStreamer.AddComment("Length of Public Names Info");
2401 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2402 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2404 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2406 Asm->OutStreamer.AddComment("DWARF Version");
2407 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2409 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2410 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2411 DwarfInfoSectionSym);
2413 Asm->OutStreamer.AddComment("Compilation Unit Length");
2414 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2415 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2418 // Emit the pubnames for this compilation unit.
2419 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2420 for (StringMap<DIE*>::const_iterator
2421 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2422 const char *Name = GI->getKeyData();
2423 DIE *Entity = GI->second;
2425 Asm->OutStreamer.AddComment("DIE offset");
2426 Asm->EmitInt32(Entity->getOffset());
2429 Asm->OutStreamer.AddComment("Index value");
2430 Asm->EmitInt8(computeIndexValue(TheCU, Entity));
2433 if (Asm->isVerbose())
2434 Asm->OutStreamer.AddComment("External Name");
2435 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2438 Asm->OutStreamer.AddComment("End Mark");
2440 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2444 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2445 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2446 const MCSection *PSec = Asm->getObjFileLowering().getDwarfPubTypesSection();
2448 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2451 CompileUnit *TheCU = I->second;
2452 // Start the dwarf pubtypes section.
2453 Asm->OutStreamer.SwitchSection(PSec);
2454 Asm->OutStreamer.AddComment("Length of Public Types Info");
2455 Asm->EmitLabelDifference(
2456 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2457 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2459 Asm->OutStreamer.EmitLabel(
2460 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()));
2462 if (Asm->isVerbose())
2463 Asm->OutStreamer.AddComment("DWARF Version");
2464 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2466 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2467 Asm->EmitSectionOffset(
2468 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()),
2469 DwarfInfoSectionSym);
2471 Asm->OutStreamer.AddComment("Compilation Unit Length");
2472 Asm->EmitLabelDifference(
2473 Asm->GetTempSymbol(ISec->getLabelEndName(), TheCU->getUniqueID()),
2474 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()), 4);
2476 const StringMap<DIE *> &Globals = TheCU->getGlobalTypes();
2477 for (StringMap<DIE *>::const_iterator GI = Globals.begin(),
2480 const char *Name = GI->getKeyData();
2481 DIE *Entity = GI->second;
2483 if (Asm->isVerbose())
2484 Asm->OutStreamer.AddComment("DIE offset");
2485 Asm->EmitInt32(Entity->getOffset());
2488 Asm->OutStreamer.AddComment("Index value");
2489 Asm->EmitInt8(computeIndexValue(TheCU, Entity));
2492 if (Asm->isVerbose())
2493 Asm->OutStreamer.AddComment("External Name");
2495 // Emit the name with a terminating null byte.
2496 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2499 Asm->OutStreamer.AddComment("End Mark");
2501 Asm->OutStreamer.EmitLabel(
2502 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()));
2506 // Emit strings into a string section.
2507 void DwarfUnits::emitStrings(const MCSection *StrSection,
2508 const MCSection *OffsetSection = NULL,
2509 const MCSymbol *StrSecSym = NULL) {
2511 if (StringPool.empty()) return;
2513 // Start the dwarf str section.
2514 Asm->OutStreamer.SwitchSection(StrSection);
2516 // Get all of the string pool entries and put them in an array by their ID so
2517 // we can sort them.
2518 SmallVector<std::pair<unsigned,
2519 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2521 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2522 I = StringPool.begin(), E = StringPool.end();
2524 Entries.push_back(std::make_pair(I->second.second, &*I));
2526 array_pod_sort(Entries.begin(), Entries.end());
2528 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2529 // Emit a label for reference from debug information entries.
2530 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2532 // Emit the string itself with a terminating null byte.
2533 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2534 Entries[i].second->getKeyLength()+1));
2537 // If we've got an offset section go ahead and emit that now as well.
2538 if (OffsetSection) {
2539 Asm->OutStreamer.SwitchSection(OffsetSection);
2540 unsigned offset = 0;
2541 unsigned size = 4; // FIXME: DWARF64 is 8.
2542 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2543 Asm->OutStreamer.EmitIntValue(offset, size);
2544 offset += Entries[i].second->getKeyLength() + 1;
2549 // Emit strings into a string section.
2550 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2552 if (AddressPool.empty()) return;
2554 // Start the dwarf addr section.
2555 Asm->OutStreamer.SwitchSection(AddrSection);
2557 // Order the address pool entries by ID
2558 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2560 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2561 E = AddressPool.end();
2563 Entries[I->second] = I->first;
2565 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2566 // Emit an expression for reference from debug information entries.
2567 if (const MCExpr *Expr = Entries[i])
2568 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2570 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2575 // Emit visible names into a debug str section.
2576 void DwarfDebug::emitDebugStr() {
2577 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2578 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2581 // Emit locations into the debug loc section.
2582 void DwarfDebug::emitDebugLoc() {
2583 if (DotDebugLocEntries.empty())
2586 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2587 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2589 DotDebugLocEntry &Entry = *I;
2590 if (I + 1 != DotDebugLocEntries.end())
2594 // Start the dwarf loc section.
2595 Asm->OutStreamer.SwitchSection(
2596 Asm->getObjFileLowering().getDwarfLocSection());
2597 unsigned char Size = Asm->getDataLayout().getPointerSize();
2598 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2600 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2601 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2602 I != E; ++I, ++index) {
2603 DotDebugLocEntry &Entry = *I;
2604 if (Entry.isMerged()) continue;
2605 if (Entry.isEmpty()) {
2606 Asm->OutStreamer.EmitIntValue(0, Size);
2607 Asm->OutStreamer.EmitIntValue(0, Size);
2608 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2610 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2611 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2612 DIVariable DV(Entry.getVariable());
2613 Asm->OutStreamer.AddComment("Loc expr size");
2614 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2615 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2616 Asm->EmitLabelDifference(end, begin, 2);
2617 Asm->OutStreamer.EmitLabel(begin);
2618 if (Entry.isInt()) {
2619 DIBasicType BTy(DV.getType());
2621 (BTy.getEncoding() == dwarf::DW_ATE_signed
2622 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2623 Asm->OutStreamer.AddComment("DW_OP_consts");
2624 Asm->EmitInt8(dwarf::DW_OP_consts);
2625 Asm->EmitSLEB128(Entry.getInt());
2627 Asm->OutStreamer.AddComment("DW_OP_constu");
2628 Asm->EmitInt8(dwarf::DW_OP_constu);
2629 Asm->EmitULEB128(Entry.getInt());
2631 } else if (Entry.isLocation()) {
2632 MachineLocation Loc = Entry.getLoc();
2633 if (!DV.hasComplexAddress())
2635 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2637 // Complex address entry.
2638 unsigned N = DV.getNumAddrElements();
2640 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2641 if (Loc.getOffset()) {
2643 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2644 Asm->OutStreamer.AddComment("DW_OP_deref");
2645 Asm->EmitInt8(dwarf::DW_OP_deref);
2646 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2647 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2648 Asm->EmitSLEB128(DV.getAddrElement(1));
2650 // If first address element is OpPlus then emit
2651 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2652 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2653 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2657 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2660 // Emit remaining complex address elements.
2661 for (; i < N; ++i) {
2662 uint64_t Element = DV.getAddrElement(i);
2663 if (Element == DIBuilder::OpPlus) {
2664 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2665 Asm->EmitULEB128(DV.getAddrElement(++i));
2666 } else if (Element == DIBuilder::OpDeref) {
2668 Asm->EmitInt8(dwarf::DW_OP_deref);
2670 llvm_unreachable("unknown Opcode found in complex address");
2674 // else ... ignore constant fp. There is not any good way to
2675 // to represent them here in dwarf.
2676 Asm->OutStreamer.EmitLabel(end);
2681 // Emit visible names into a debug aranges section.
2682 void DwarfDebug::emitDebugARanges() {
2683 // Start the dwarf aranges section.
2685 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2688 // Emit visible names into a debug ranges section.
2689 void DwarfDebug::emitDebugRanges() {
2690 // Start the dwarf ranges section.
2692 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2693 unsigned char Size = Asm->getDataLayout().getPointerSize();
2694 for (SmallVectorImpl<const MCSymbol *>::iterator
2695 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2698 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2700 Asm->OutStreamer.EmitIntValue(0, Size);
2704 // Emit visible names into a debug macinfo section.
2705 void DwarfDebug::emitDebugMacInfo() {
2706 if (const MCSection *LineInfo =
2707 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2708 // Start the dwarf macinfo section.
2709 Asm->OutStreamer.SwitchSection(LineInfo);
2713 // DWARF5 Experimental Separate Dwarf emitters.
2715 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2716 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2717 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2718 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2719 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2721 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2722 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2723 Asm, this, &SkeletonHolder);
2725 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2726 DICompileUnit(CU->getNode()).getSplitDebugFilename());
2728 // Relocate to the beginning of the addr_base section, else 0 for the
2729 // beginning of the one for this compile unit.
2730 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2731 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2732 DwarfAddrSectionSym);
2734 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2735 dwarf::DW_FORM_sec_offset, 0);
2737 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2738 // into an entity. We're using 0, or a NULL label for this.
2739 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2741 // DW_AT_stmt_list is a offset of line number information for this
2742 // compile unit in debug_line section.
2743 // FIXME: Should handle multiple compile units.
2744 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2745 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2746 DwarfLineSectionSym);
2748 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2750 if (!CompilationDir.empty())
2751 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2753 // Flag to let the linker know we have emitted new style pubnames.
2754 if (GenerateGnuPubSections)
2755 NewCU->addFlag(Die, dwarf::DW_AT_GNU_pubnames);
2757 SkeletonHolder.addUnit(NewCU);
2758 SkeletonCUs.push_back(NewCU);
2763 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2764 assert(useSplitDwarf() && "No split dwarf debug info?");
2765 emitAbbrevs(Section, &SkeletonAbbrevs);
2768 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2769 // compile units that would normally be in debug_info.
2770 void DwarfDebug::emitDebugInfoDWO() {
2771 assert(useSplitDwarf() && "No split dwarf debug info?");
2772 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2773 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2774 DwarfAbbrevDWOSectionSym);
2777 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2778 // abbreviations for the .debug_info.dwo section.
2779 void DwarfDebug::emitDebugAbbrevDWO() {
2780 assert(useSplitDwarf() && "No split dwarf?");
2781 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2785 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2786 // string section and is identical in format to traditional .debug_str
2788 void DwarfDebug::emitDebugStrDWO() {
2789 assert(useSplitDwarf() && "No split dwarf?");
2790 const MCSection *OffSec = Asm->getObjFileLowering()
2791 .getDwarfStrOffDWOSection();
2792 const MCSymbol *StrSym = DwarfStrSectionSym;
2793 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),