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"
17 #include "DwarfAccelTable.h"
18 #include "DwarfCompileUnit.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/DIBuilder.h"
26 #include "llvm/DebugInfo.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DataLayout.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/MC/MCAsmInfo.h"
32 #include "llvm/MC/MCSection.h"
33 #include "llvm/MC/MCStreamer.h"
34 #include "llvm/MC/MCSymbol.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/FormattedStream.h"
39 #include "llvm/Support/MD5.h"
40 #include "llvm/Support/Path.h"
41 #include "llvm/Support/Timer.h"
42 #include "llvm/Support/ValueHandle.h"
43 #include "llvm/Target/TargetFrameLowering.h"
44 #include "llvm/Target/TargetLoweringObjectFile.h"
45 #include "llvm/Target/TargetMachine.h"
46 #include "llvm/Target/TargetOptions.h"
47 #include "llvm/Target/TargetRegisterInfo.h"
51 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
52 cl::desc("Disable debug info printing"));
54 static cl::opt<bool> UnknownLocations(
55 "use-unknown-locations", cl::Hidden,
56 cl::desc("Make an absence of debug location information explicit."),
60 GenerateDwarfPubNamesSection("generate-dwarf-pubnames", cl::Hidden,
62 cl::desc("Generate DWARF pubnames section"));
65 GenerateODRHash("generate-odr-hash", cl::Hidden,
66 cl::desc("Add an ODR hash to external type DIEs."),
77 static cl::opt<DefaultOnOff>
78 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
79 cl::desc("Output prototype dwarf accelerator tables."),
80 cl::values(clEnumVal(Default, "Default for platform"),
81 clEnumVal(Enable, "Enabled"),
82 clEnumVal(Disable, "Disabled"), clEnumValEnd),
85 static cl::opt<DefaultOnOff>
86 DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
87 cl::desc("Compatibility with Darwin gdb."),
88 cl::values(clEnumVal(Default, "Default for platform"),
89 clEnumVal(Enable, "Enabled"),
90 clEnumVal(Disable, "Disabled"), clEnumValEnd),
93 static cl::opt<DefaultOnOff>
94 SplitDwarf("split-dwarf", cl::Hidden,
95 cl::desc("Output prototype dwarf split debug info."),
96 cl::values(clEnumVal(Default, "Default for platform"),
97 clEnumVal(Enable, "Enabled"),
98 clEnumVal(Disable, "Disabled"), clEnumValEnd),
102 const char *const DWARFGroupName = "DWARF Emission";
103 const char *const DbgTimerName = "DWARF Debug Writer";
105 struct CompareFirst {
106 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
107 return lhs.first < rhs.first;
110 } // end anonymous namespace
112 //===----------------------------------------------------------------------===//
114 // Configuration values for initial hash set sizes (log2).
116 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
120 DIType DbgVariable::getType() const {
121 DIType Ty = Var.getType();
122 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
123 // addresses instead.
124 if (Var.isBlockByrefVariable()) {
125 /* Byref variables, in Blocks, are declared by the programmer as
126 "SomeType VarName;", but the compiler creates a
127 __Block_byref_x_VarName struct, and gives the variable VarName
128 either the struct, or a pointer to the struct, as its type. This
129 is necessary for various behind-the-scenes things the compiler
130 needs to do with by-reference variables in blocks.
132 However, as far as the original *programmer* is concerned, the
133 variable should still have type 'SomeType', as originally declared.
135 The following function dives into the __Block_byref_x_VarName
136 struct to find the original type of the variable. This will be
137 passed back to the code generating the type for the Debug
138 Information Entry for the variable 'VarName'. 'VarName' will then
139 have the original type 'SomeType' in its debug information.
141 The original type 'SomeType' will be the type of the field named
142 'VarName' inside the __Block_byref_x_VarName struct.
144 NOTE: In order for this to not completely fail on the debugger
145 side, the Debug Information Entry for the variable VarName needs to
146 have a DW_AT_location that tells the debugger how to unwind through
147 the pointers and __Block_byref_x_VarName struct to find the actual
148 value of the variable. The function addBlockByrefType does this. */
150 unsigned tag = Ty.getTag();
152 if (tag == dwarf::DW_TAG_pointer_type) {
153 DIDerivedType DTy = DIDerivedType(Ty);
154 subType = DTy.getTypeDerivedFrom();
157 DICompositeType blockStruct = DICompositeType(subType);
158 DIArray Elements = blockStruct.getTypeArray();
160 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
161 DIDescriptor Element = Elements.getElement(i);
162 DIDerivedType DT = DIDerivedType(Element);
163 if (getName() == DT.getName())
164 return (DT.getTypeDerivedFrom());
170 } // end llvm namespace
172 /// Return Dwarf Version by checking module flags.
173 static unsigned getDwarfVersionFromModule(const Module *M) {
174 Value *Val = M->getModuleFlag("Dwarf Version");
176 return dwarf::DWARF_VERSION;
177 return cast<ConstantInt>(Val)->getZExtValue();
180 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
181 : Asm(A), MMI(Asm->MMI), FirstCU(0),
182 AbbreviationsSet(InitAbbreviationsSetSize),
183 SourceIdMap(DIEValueAllocator),
184 PrevLabel(NULL), GlobalCUIndexCount(0),
185 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
187 SkeletonAbbrevSet(InitAbbreviationsSetSize),
188 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
191 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
192 DwarfStrSectionSym = TextSectionSym = 0;
193 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
194 DwarfAddrSectionSym = 0;
195 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
196 FunctionBeginSym = FunctionEndSym = 0;
198 // Turn on accelerator tables and older gdb compatibility
200 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
201 if (DarwinGDBCompat == Default) {
203 IsDarwinGDBCompat = true;
205 IsDarwinGDBCompat = false;
207 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
209 if (DwarfAccelTables == Default) {
211 HasDwarfAccelTables = true;
213 HasDwarfAccelTables = false;
215 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
217 if (SplitDwarf == Default)
218 HasSplitDwarf = false;
220 HasSplitDwarf = SplitDwarf == Enable ? true : false;
222 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
225 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
229 DwarfDebug::~DwarfDebug() {
232 // Switch to the specified MCSection and emit an assembler
233 // temporary label to it if SymbolStem is specified.
234 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
235 const char *SymbolStem = 0) {
236 Asm->OutStreamer.SwitchSection(Section);
237 if (!SymbolStem) return 0;
239 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
240 Asm->OutStreamer.EmitLabel(TmpSym);
244 MCSymbol *DwarfUnits::getStringPoolSym() {
245 return Asm->GetTempSymbol(StringPref);
248 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
249 std::pair<MCSymbol*, unsigned> &Entry =
250 StringPool.GetOrCreateValue(Str).getValue();
251 if (Entry.first) return Entry.first;
253 Entry.second = NextStringPoolNumber++;
254 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
257 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
258 std::pair<MCSymbol*, unsigned> &Entry =
259 StringPool.GetOrCreateValue(Str).getValue();
260 if (Entry.first) return Entry.second;
262 Entry.second = NextStringPoolNumber++;
263 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
267 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
268 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
271 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
272 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
273 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
275 ++NextAddrPoolNumber;
276 return P.first->second;
279 // Define a unique number for the abbreviation.
281 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
282 // Check the set for priors.
283 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
285 // If it's newly added.
286 if (InSet == &Abbrev) {
287 // Add to abbreviation list.
288 Abbreviations->push_back(&Abbrev);
290 // Assign the vector position + 1 as its number.
291 Abbrev.setNumber(Abbreviations->size());
293 // Assign existing abbreviation number.
294 Abbrev.setNumber(InSet->getNumber());
298 static bool isObjCClass(StringRef Name) {
299 return Name.startswith("+") || Name.startswith("-");
302 static bool hasObjCCategory(StringRef Name) {
303 if (!isObjCClass(Name)) return false;
305 size_t pos = Name.find(')');
306 if (pos != std::string::npos) {
307 if (Name[pos+1] != ' ') return false;
313 static void getObjCClassCategory(StringRef In, StringRef &Class,
314 StringRef &Category) {
315 if (!hasObjCCategory(In)) {
316 Class = In.slice(In.find('[') + 1, In.find(' '));
321 Class = In.slice(In.find('[') + 1, In.find('('));
322 Category = In.slice(In.find('[') + 1, In.find(' '));
326 static StringRef getObjCMethodName(StringRef In) {
327 return In.slice(In.find(' ') + 1, In.find(']'));
330 // Add the various names to the Dwarf accelerator table names.
331 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
333 if (!SP.isDefinition()) return;
335 TheCU->addAccelName(SP.getName(), Die);
337 // If the linkage name is different than the name, go ahead and output
338 // that as well into the name table.
339 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
340 TheCU->addAccelName(SP.getLinkageName(), Die);
342 // If this is an Objective-C selector name add it to the ObjC accelerator
344 if (isObjCClass(SP.getName())) {
345 StringRef Class, Category;
346 getObjCClassCategory(SP.getName(), Class, Category);
347 TheCU->addAccelObjC(Class, Die);
349 TheCU->addAccelObjC(Category, Die);
350 // Also add the base method name to the name table.
351 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
355 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
356 // and DW_AT_high_pc attributes. If there are global variables in this
357 // scope then create and insert DIEs for these variables.
358 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
359 const MDNode *SPNode) {
360 DIE *SPDie = SPCU->getDIE(SPNode);
362 assert(SPDie && "Unable to find subprogram DIE!");
363 DISubprogram SP(SPNode);
365 // If we're updating an abstract DIE, then we will be adding the children and
366 // object pointer later on. But what we don't want to do is process the
367 // concrete DIE twice.
368 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
370 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
371 // Pick up abstract subprogram DIE.
372 SPDie = new DIE(dwarf::DW_TAG_subprogram);
373 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
375 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
376 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
380 DISubprogram SPDecl = SP.getFunctionDeclaration();
381 if (!SPDecl.isSubprogram()) {
382 // There is not any need to generate specification DIE for a function
383 // defined at compile unit level. If a function is defined inside another
384 // function then gdb prefers the definition at top level and but does not
385 // expect specification DIE in parent function. So avoid creating
386 // specification DIE for a function defined inside a function.
387 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
388 !SP.getContext().isFile() &&
389 !isSubprogramContext(SP.getContext())) {
390 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
393 DICompositeType SPTy = SP.getType();
394 DIArray Args = SPTy.getTypeArray();
395 unsigned SPTag = SPTy.getTag();
396 if (SPTag == dwarf::DW_TAG_subroutine_type)
397 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
398 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
399 DIType ATy = DIType(Args.getElement(i));
400 SPCU->addType(Arg, ATy);
401 if (ATy.isArtificial())
402 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
403 if (ATy.isObjectPointer())
404 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
405 dwarf::DW_FORM_ref4, Arg);
406 SPDie->addChild(Arg);
408 DIE *SPDeclDie = SPDie;
409 SPDie = new DIE(dwarf::DW_TAG_subprogram);
410 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
411 dwarf::DW_FORM_ref4, SPDeclDie);
417 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
418 Asm->GetTempSymbol("func_begin",
419 Asm->getFunctionNumber()));
420 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
421 Asm->GetTempSymbol("func_end",
422 Asm->getFunctionNumber()));
423 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
424 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
425 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
427 // Add name to the name table, we do this here because we're guaranteed
428 // to have concrete versions of our DW_TAG_subprogram nodes.
429 addSubprogramNames(SPCU, SP, SPDie);
434 // Construct new DW_TAG_lexical_block for this scope and attach
435 // DW_AT_low_pc/DW_AT_high_pc labels.
436 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
437 LexicalScope *Scope) {
438 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
439 if (Scope->isAbstractScope())
442 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
446 // If we have multiple ranges, emit them into the range section.
447 if (Ranges.size() > 1) {
448 // .debug_range section has not been laid out yet. Emit offset in
449 // .debug_range as a uint, size 4, for now. emitDIE will handle
450 // DW_AT_ranges appropriately.
451 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
452 DebugRangeSymbols.size()
453 * Asm->getDataLayout().getPointerSize());
454 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
455 RE = Ranges.end(); RI != RE; ++RI) {
456 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
457 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
460 // Terminate the range list.
461 DebugRangeSymbols.push_back(NULL);
462 DebugRangeSymbols.push_back(NULL);
466 // Construct the address range for this DIE.
467 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
468 MCSymbol *Start = getLabelBeforeInsn(RI->first);
469 MCSymbol *End = getLabelAfterInsn(RI->second);
471 if (End == 0) return 0;
473 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
474 assert(End->isDefined() && "Invalid end label for an inlined scope!");
476 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
477 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
482 // This scope represents inlined body of a function. Construct DIE to
483 // represent this concrete inlined copy of the function.
484 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
485 LexicalScope *Scope) {
486 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
487 assert(Ranges.empty() == false &&
488 "LexicalScope does not have instruction markers!");
490 if (!Scope->getScopeNode())
492 DIScope DS(Scope->getScopeNode());
493 DISubprogram InlinedSP = getDISubprogram(DS);
494 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
496 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
500 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
501 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
502 dwarf::DW_FORM_ref4, OriginDIE);
504 if (Ranges.size() > 1) {
505 // .debug_range section has not been laid out yet. Emit offset in
506 // .debug_range as a uint, size 4, for now. emitDIE will handle
507 // DW_AT_ranges appropriately.
508 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
509 DebugRangeSymbols.size()
510 * Asm->getDataLayout().getPointerSize());
511 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
512 RE = Ranges.end(); RI != RE; ++RI) {
513 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
514 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
516 DebugRangeSymbols.push_back(NULL);
517 DebugRangeSymbols.push_back(NULL);
519 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
520 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
521 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
523 if (StartLabel == 0 || EndLabel == 0)
524 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
526 assert(StartLabel->isDefined() &&
527 "Invalid starting label for an inlined scope!");
528 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
530 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
531 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
534 InlinedSubprogramDIEs.insert(OriginDIE);
536 // Add the call site information to the DIE.
537 DILocation DL(Scope->getInlinedAt());
538 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
539 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
540 TheCU->getUniqueID()));
541 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
543 // Track the start label for this inlined function.
544 //.debug_inlined section specification does not clearly state how
545 // to emit inlined scopes that are split into multiple instruction ranges.
546 // For now, use the first instruction range and emit low_pc/high_pc pair and
547 // corresponding the .debug_inlined section entry for this pair.
548 if (Asm->MAI->doesDwarfUseInlineInfoSection()) {
549 MCSymbol *StartLabel = getLabelBeforeInsn(Ranges.begin()->first);
550 InlineInfoMap::iterator I = InlineInfo.find(InlinedSP);
552 if (I == InlineInfo.end()) {
553 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
554 InlinedSPNodes.push_back(InlinedSP);
556 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
559 // Add name to the name table, we do this here because we're guaranteed
560 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
561 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
566 // Construct a DIE for this scope.
567 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
568 if (!Scope || !Scope->getScopeNode())
571 DIScope DS(Scope->getScopeNode());
572 // Early return to avoid creating dangling variable|scope DIEs.
573 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
577 SmallVector<DIE *, 8> Children;
578 DIE *ObjectPointer = NULL;
580 // Collect arguments for current function.
581 if (LScopes.isCurrentFunctionScope(Scope))
582 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
583 if (DbgVariable *ArgDV = CurrentFnArguments[i])
585 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
586 Children.push_back(Arg);
587 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
590 // Collect lexical scope children first.
591 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
592 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
594 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
595 Children.push_back(Variable);
596 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
598 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
599 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
600 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
601 Children.push_back(Nested);
602 DIE *ScopeDIE = NULL;
603 if (Scope->getInlinedAt())
604 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
605 else if (DS.isSubprogram()) {
606 ProcessedSPNodes.insert(DS);
607 if (Scope->isAbstractScope()) {
608 ScopeDIE = TheCU->getDIE(DS);
609 // Note down abstract DIE.
611 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
614 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
617 // There is no need to emit empty lexical block DIE.
618 std::pair<ImportedEntityMap::const_iterator,
619 ImportedEntityMap::const_iterator> Range = std::equal_range(
620 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
621 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
623 if (Children.empty() && Range.first == Range.second)
625 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
626 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
628 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
631 if (!ScopeDIE) return NULL;
634 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
635 E = Children.end(); I != E; ++I)
636 ScopeDIE->addChild(*I);
638 if (DS.isSubprogram() && ObjectPointer != NULL)
639 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
640 dwarf::DW_FORM_ref4, ObjectPointer);
642 if (DS.isSubprogram())
643 TheCU->addPubTypes(DISubprogram(DS));
648 // Look up the source id with the given directory and source file names.
649 // If none currently exists, create a new id and insert it in the
650 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
652 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
653 StringRef DirName, unsigned CUID) {
654 // If we use .loc in assembly, we can't separate .file entries according to
655 // compile units. Thus all files will belong to the default compile unit.
656 if (Asm->TM.hasMCUseLoc() &&
657 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
660 // If FE did not provide a file name, then assume stdin.
661 if (FileName.empty())
662 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
664 // TODO: this might not belong here. See if we can factor this better.
665 if (DirName == CompilationDir)
668 // FileIDCUMap stores the current ID for the given compile unit.
669 unsigned SrcId = FileIDCUMap[CUID] + 1;
671 // We look up the CUID/file/dir by concatenating them with a zero byte.
672 SmallString<128> NamePair;
673 NamePair += utostr(CUID);
676 NamePair += '\0'; // Zero bytes are not allowed in paths.
677 NamePair += FileName;
679 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
680 if (Ent.getValue() != SrcId)
681 return Ent.getValue();
683 FileIDCUMap[CUID] = SrcId;
684 // Print out a .file directive to specify files for .loc directives.
685 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
690 // Create new CompileUnit for the given metadata node with tag
691 // DW_TAG_compile_unit.
692 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
693 DICompileUnit DIUnit(N);
694 StringRef FN = DIUnit.getFilename();
695 CompilationDir = DIUnit.getDirectory();
697 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
698 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
699 DIUnit.getLanguage(), Die, N, Asm,
702 FileIDCUMap[NewCU->getUniqueID()] = 0;
703 // Call this to emit a .file directive if it wasn't emitted for the source
704 // file this CU comes from yet.
705 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
707 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
708 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
709 DIUnit.getLanguage());
710 NewCU->addString(Die, dwarf::DW_AT_name, FN);
712 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
713 // into an entity. We're using 0 (or a NULL label) for this. For
714 // split dwarf it's in the skeleton CU so omit it here.
715 if (!useSplitDwarf())
716 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
718 // Define start line table label for each Compile Unit.
719 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
720 NewCU->getUniqueID());
721 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
722 NewCU->getUniqueID());
724 // Use a single line table if we are using .loc and generating assembly.
726 (Asm->TM.hasMCUseLoc() &&
727 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
728 (NewCU->getUniqueID() == 0);
730 // DW_AT_stmt_list is a offset of line number information for this
731 // compile unit in debug_line section. For split dwarf this is
732 // left in the skeleton CU and so not included.
733 // The line table entries are not always emitted in assembly, so it
734 // is not okay to use line_table_start here.
735 if (!useSplitDwarf()) {
736 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
737 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
739 Asm->GetTempSymbol("section_line") : LineTableStartSym);
740 else if (UseTheFirstCU)
741 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
743 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
744 LineTableStartSym, DwarfLineSectionSym);
747 // If we're using split dwarf the compilation dir is going to be in the
748 // skeleton CU and so we don't need to duplicate it here.
749 if (!useSplitDwarf() && !CompilationDir.empty())
750 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
751 if (DIUnit.isOptimized())
752 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
754 StringRef Flags = DIUnit.getFlags();
756 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
758 if (unsigned RVer = DIUnit.getRunTimeVersion())
759 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
760 dwarf::DW_FORM_data1, RVer);
765 InfoHolder.addUnit(NewCU);
767 CUMap.insert(std::make_pair(N, NewCU));
771 // Construct subprogram DIE.
772 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
774 CompileUnit *&CURef = SPMap[N];
780 if (!SP.isDefinition())
781 // This is a method declaration which will be handled while constructing
785 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
788 TheCU->insertDIE(N, SubprogramDie);
790 // Add to context owner.
791 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
793 // Expose as global, if requested.
794 if (GenerateDwarfPubNamesSection)
795 TheCU->addGlobalName(SP.getName(), SubprogramDie);
798 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
800 DIImportedEntity Module(N);
801 if (!Module.Verify())
803 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
804 constructImportedEntityDIE(TheCU, Module, D);
807 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
809 DIImportedEntity Module(N);
810 if (!Module.Verify())
812 return constructImportedEntityDIE(TheCU, Module, Context);
815 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
816 const DIImportedEntity &Module,
818 assert(Module.Verify() &&
819 "Use one of the MDNode * overloads to handle invalid metadata");
820 assert(Context && "Should always have a context for an imported_module");
821 DIE *IMDie = new DIE(Module.getTag());
822 TheCU->insertDIE(Module, IMDie);
824 DIDescriptor Entity = Module.getEntity();
825 if (Entity.isNameSpace())
826 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
827 else if (Entity.isSubprogram())
828 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
829 else if (Entity.isType())
830 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
832 EntityDie = TheCU->getDIE(Entity);
833 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
834 Module.getContext().getDirectory(),
835 TheCU->getUniqueID());
836 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
837 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
838 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
840 StringRef Name = Module.getName();
842 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
843 Context->addChild(IMDie);
846 // Emit all Dwarf sections that should come prior to the content. Create
847 // global DIEs and emit initial debug info sections. This is invoked by
848 // the target AsmPrinter.
849 void DwarfDebug::beginModule() {
850 if (DisableDebugInfoPrinting)
853 const Module *M = MMI->getModule();
855 // If module has named metadata anchors then use them, otherwise scan the
856 // module using debug info finder to collect debug info.
857 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
861 // Emit initial sections so we can reference labels later.
864 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
865 DICompileUnit CUNode(CU_Nodes->getOperand(i));
866 CompileUnit *CU = constructCompileUnit(CUNode);
867 DIArray ImportedEntities = CUNode.getImportedEntities();
868 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
869 ScopesWithImportedEntities.push_back(std::make_pair(
870 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
871 ImportedEntities.getElement(i)));
872 std::sort(ScopesWithImportedEntities.begin(),
873 ScopesWithImportedEntities.end(), CompareFirst());
874 DIArray GVs = CUNode.getGlobalVariables();
875 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
876 CU->createGlobalVariableDIE(GVs.getElement(i));
877 DIArray SPs = CUNode.getSubprograms();
878 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
879 constructSubprogramDIE(CU, SPs.getElement(i));
880 DIArray EnumTypes = CUNode.getEnumTypes();
881 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
882 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
883 DIArray RetainedTypes = CUNode.getRetainedTypes();
884 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
885 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
886 // Emit imported_modules last so that the relevant context is already
888 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
889 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
890 // If we're splitting the dwarf out now that we've got the entire
891 // CU then construct a skeleton CU based upon it.
892 if (useSplitDwarf()) {
893 // This should be a unique identifier when we want to build .dwp files.
894 CU->addUInt(CU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
895 dwarf::DW_FORM_data8, 0);
896 // Now construct the skeleton CU associated.
897 constructSkeletonCU(CUNode);
901 // Tell MMI that we have debug info.
902 MMI->setDebugInfoAvailability(true);
904 // Prime section data.
905 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
908 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
909 void DwarfDebug::computeInlinedDIEs() {
910 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
911 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
912 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
914 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
916 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
917 AE = AbstractSPDies.end(); AI != AE; ++AI) {
918 DIE *ISP = AI->second;
919 if (InlinedSubprogramDIEs.count(ISP))
921 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
925 // Collect info for variables that were optimized out.
926 void DwarfDebug::collectDeadVariables() {
927 const Module *M = MMI->getModule();
928 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
930 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
931 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
932 DICompileUnit TheCU(CU_Nodes->getOperand(i));
933 DIArray Subprograms = TheCU.getSubprograms();
934 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
935 DISubprogram SP(Subprograms.getElement(i));
936 if (ProcessedSPNodes.count(SP) != 0) continue;
937 if (!SP.isSubprogram()) continue;
938 if (!SP.isDefinition()) continue;
939 DIArray Variables = SP.getVariables();
940 if (Variables.getNumElements() == 0) continue;
942 LexicalScope *Scope =
943 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
944 DeadFnScopeMap[SP] = Scope;
946 // Construct subprogram DIE and add variables DIEs.
947 CompileUnit *SPCU = CUMap.lookup(TheCU);
948 assert(SPCU && "Unable to find Compile Unit!");
949 constructSubprogramDIE(SPCU, SP);
950 DIE *ScopeDIE = SPCU->getDIE(SP);
951 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
952 DIVariable DV(Variables.getElement(vi));
953 if (!DV.isVariable()) continue;
954 DbgVariable *NewVar = new DbgVariable(DV, NULL);
955 if (DIE *VariableDIE =
956 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
957 ScopeDIE->addChild(VariableDIE);
962 DeleteContainerSeconds(DeadFnScopeMap);
965 // Type Signature computation code.
966 typedef ArrayRef<uint8_t> HashValue;
968 /// \brief Grabs the string in whichever attribute is passed in and returns
969 /// a reference to it.
970 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
971 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
972 const DIEAbbrev &Abbrevs = Die->getAbbrev();
974 // Iterate through all the attributes until we find the one we're
975 // looking for, if we can't find it return an empty string.
976 for (size_t i = 0; i < Values.size(); ++i) {
977 if (Abbrevs.getData()[i].getAttribute() == Attr) {
978 DIEValue *V = Values[i];
979 assert(isa<DIEString>(V) && "String requested. Not a string.");
980 DIEString *S = cast<DIEString>(V);
981 return S->getString();
984 return StringRef("");
987 /// \brief Adds the string in \p Str to the hash in \p Hash. This also hashes
988 /// a trailing NULL with the string.
989 static void addStringToHash(MD5 &Hash, StringRef Str) {
990 DEBUG(dbgs() << "Adding string " << Str << " to hash.\n");
991 HashValue SVal((const uint8_t *)Str.data(), Str.size());
992 const uint8_t NB = '\0';
993 HashValue NBVal((const uint8_t *)&NB, 1);
998 // FIXME: These are copied and only slightly modified out of LEB128.h.
1000 /// \brief Adds the unsigned in \p N to the hash in \p Hash. This also encodes
1001 /// the unsigned as a ULEB128.
1002 static void addULEB128ToHash(MD5 &Hash, uint64_t Value) {
1003 DEBUG(dbgs() << "Adding ULEB128 " << Value << " to hash.\n");
1005 uint8_t Byte = Value & 0x7f;
1008 Byte |= 0x80; // Mark this byte to show that more bytes will follow.
1010 } while (Value != 0);
1013 /// \brief Including \p Parent adds the context of Parent to \p Hash.
1014 static void addParentContextToHash(MD5 &Hash, DIE *Parent) {
1015 unsigned Tag = Parent->getTag();
1017 DEBUG(dbgs() << "Adding parent context to hash...\n");
1019 // For each surrounding type or namespace...
1020 if (Tag != dwarf::DW_TAG_namespace && Tag != dwarf::DW_TAG_class_type &&
1021 Tag != dwarf::DW_TAG_structure_type)
1024 // ... beginning with the outermost such construct...
1025 if (Parent->getParent() != NULL)
1026 addParentContextToHash(Hash, Parent->getParent());
1028 // Append the letter "C" to the sequence.
1029 addULEB128ToHash(Hash, 'C');
1031 // Followed by the DWARF tag of the construct.
1032 addULEB128ToHash(Hash, Parent->getTag());
1034 // Then the name, taken from the DW_AT_name attribute.
1035 StringRef Name = getDIEStringAttr(Parent, dwarf::DW_AT_name);
1037 addStringToHash(Hash, Name);
1040 /// This is based on the type signature computation given in section 7.27 of the
1041 /// DWARF4 standard. It is the md5 hash of a flattened description of the DIE.
1042 static void addDIEODRSignature(MD5 &Hash, CompileUnit *CU, DIE *Die) {
1044 // Add the contexts to the hash.
1045 DIE *Parent = Die->getParent();
1047 addParentContextToHash(Hash, Parent);
1049 // Add the current DIE information.
1051 // Add the DWARF tag of the DIE.
1052 addULEB128ToHash(Hash, Die->getTag());
1054 // Add the name of the type to the hash.
1055 addStringToHash(Hash, getDIEStringAttr(Die, dwarf::DW_AT_name));
1057 // Now get the result.
1058 MD5::MD5Result Result;
1061 // ... take the least significant 8 bytes and store those as the attribute.
1063 memcpy(&Signature, &Result[8], 8);
1065 // FIXME: This should be added onto the type unit, not the type, but this
1066 // works as an intermediate stage.
1067 CU->addUInt(Die, dwarf::DW_AT_GNU_odr_signature, dwarf::DW_FORM_data8,
1071 /// Return true if the current DIE is contained within an anonymous namespace.
1072 static bool isContainedInAnonNamespace(DIE *Die) {
1073 DIE *Parent = Die->getParent();
1076 if (Die->getTag() == dwarf::DW_TAG_namespace &&
1077 getDIEStringAttr(Die, dwarf::DW_AT_name) == "")
1079 Parent = Parent->getParent();
1085 void DwarfDebug::finalizeModuleInfo() {
1086 // Collect info for variables that were optimized out.
1087 collectDeadVariables();
1089 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1090 computeInlinedDIEs();
1092 // Emit DW_AT_containing_type attribute to connect types with their
1093 // vtable holding type.
1094 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1095 CUE = CUMap.end(); CUI != CUE; ++CUI) {
1096 CompileUnit *TheCU = CUI->second;
1097 TheCU->constructContainingTypeDIEs();
1100 // For types that we'd like to move to type units or ODR check go ahead
1101 // and either move the types out or add the ODR attribute now.
1102 // FIXME: Do type splitting.
1103 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1105 DIE *Die = TypeUnits[i];
1106 // If we're in C++ and we want to generate the hash then go ahead and do
1108 if (GenerateODRHash &&
1109 CUMap.begin()->second->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1110 !isContainedInAnonNamespace(Die))
1111 addDIEODRSignature(Hash, CUMap.begin()->second, Die);
1114 // Compute DIE offsets and sizes.
1115 InfoHolder.computeSizeAndOffsets();
1116 if (useSplitDwarf())
1117 SkeletonHolder.computeSizeAndOffsets();
1120 void DwarfDebug::endSections() {
1121 // Standard sections final addresses.
1122 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1123 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1124 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1125 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1127 // End text sections.
1128 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1129 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1130 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1134 // Emit all Dwarf sections that should come after the content.
1135 void DwarfDebug::endModule() {
1137 if (!FirstCU) return;
1139 // End any existing sections.
1140 // TODO: Does this need to happen?
1143 // Finalize the debug info for the module.
1144 finalizeModuleInfo();
1146 if (!useSplitDwarf()) {
1147 // Emit all the DIEs into a debug info section.
1150 // Corresponding abbreviations into a abbrev section.
1151 emitAbbreviations();
1153 // Emit info into a debug loc section.
1156 // Emit info into a debug aranges section.
1159 // Emit info into a debug ranges section.
1162 // Emit info into a debug macinfo section.
1165 // Emit inline info.
1166 // TODO: When we don't need the option anymore we
1167 // can remove all of the code that this section
1169 if (useDarwinGDBCompat())
1170 emitDebugInlineInfo();
1172 // TODO: Fill this in for separated debug sections and separate
1173 // out information into new sections.
1175 // Emit the debug info section and compile units.
1179 // Corresponding abbreviations into a abbrev section.
1180 emitAbbreviations();
1181 emitDebugAbbrevDWO();
1183 // Emit info into a debug loc section.
1186 // Emit info into a debug aranges section.
1189 // Emit info into a debug ranges section.
1192 // Emit info into a debug macinfo section.
1195 // Emit DWO addresses.
1196 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1198 // Emit inline info.
1199 // TODO: When we don't need the option anymore we
1200 // can remove all of the code that this section
1202 if (useDarwinGDBCompat())
1203 emitDebugInlineInfo();
1206 // Emit info into the dwarf accelerator table sections.
1207 if (useDwarfAccelTables()) {
1210 emitAccelNamespaces();
1214 // Emit info into a debug pubnames section, if requested.
1215 if (GenerateDwarfPubNamesSection)
1216 emitDebugPubnames();
1218 // Emit info into a debug pubtypes section.
1219 // TODO: When we don't need the option anymore we can
1220 // remove all of the code that adds to the table.
1221 if (useDarwinGDBCompat())
1222 emitDebugPubTypes();
1224 // Finally emit string information into a string table.
1226 if (useSplitDwarf())
1231 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1232 E = CUMap.end(); I != E; ++I)
1235 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1236 E = SkeletonCUs.end(); I != E; ++I)
1239 // Reset these for the next Module if we have one.
1243 // Find abstract variable, if any, associated with Var.
1244 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1245 DebugLoc ScopeLoc) {
1246 LLVMContext &Ctx = DV->getContext();
1247 // More then one inlined variable corresponds to one abstract variable.
1248 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1249 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1251 return AbsDbgVariable;
1253 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1257 AbsDbgVariable = new DbgVariable(Var, NULL);
1258 addScopeVariable(Scope, AbsDbgVariable);
1259 AbstractVariables[Var] = AbsDbgVariable;
1260 return AbsDbgVariable;
1263 // If Var is a current function argument then add it to CurrentFnArguments list.
1264 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1265 DbgVariable *Var, LexicalScope *Scope) {
1266 if (!LScopes.isCurrentFunctionScope(Scope))
1268 DIVariable DV = Var->getVariable();
1269 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1271 unsigned ArgNo = DV.getArgNumber();
1275 size_t Size = CurrentFnArguments.size();
1277 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1278 // llvm::Function argument size is not good indicator of how many
1279 // arguments does the function have at source level.
1281 CurrentFnArguments.resize(ArgNo * 2);
1282 CurrentFnArguments[ArgNo - 1] = Var;
1286 // Collect variable information from side table maintained by MMI.
1288 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1289 SmallPtrSet<const MDNode *, 16> &Processed) {
1290 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1291 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1292 VE = VMap.end(); VI != VE; ++VI) {
1293 const MDNode *Var = VI->first;
1295 Processed.insert(Var);
1297 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1299 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1301 // If variable scope is not found then skip this variable.
1305 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1306 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1307 RegVar->setFrameIndex(VP.first);
1308 if (!addCurrentFnArgument(MF, RegVar, Scope))
1309 addScopeVariable(Scope, RegVar);
1311 AbsDbgVariable->setFrameIndex(VP.first);
1315 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1317 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1318 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1319 return MI->getNumOperands() == 3 &&
1320 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1321 (MI->getOperand(1).isImm() ||
1322 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1325 // Get .debug_loc entry for the instruction range starting at MI.
1326 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1327 const MCSymbol *FLabel,
1328 const MCSymbol *SLabel,
1329 const MachineInstr *MI) {
1330 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1332 assert(MI->getNumOperands() == 3);
1333 if (MI->getOperand(0).isReg()) {
1334 MachineLocation MLoc;
1335 // If the second operand is an immediate, this is a
1336 // register-indirect address.
1337 if (!MI->getOperand(1).isImm())
1338 MLoc.set(MI->getOperand(0).getReg());
1340 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1341 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1343 if (MI->getOperand(0).isImm())
1344 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1345 if (MI->getOperand(0).isFPImm())
1346 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1347 if (MI->getOperand(0).isCImm())
1348 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1350 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1353 // Find variables for each lexical scope.
1355 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1356 SmallPtrSet<const MDNode *, 16> &Processed) {
1358 // Grab the variable info that was squirreled away in the MMI side-table.
1359 collectVariableInfoFromMMITable(MF, Processed);
1361 for (SmallVectorImpl<const MDNode*>::const_iterator
1362 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1364 const MDNode *Var = *UVI;
1365 if (Processed.count(Var))
1368 // History contains relevant DBG_VALUE instructions for Var and instructions
1370 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1371 if (History.empty())
1373 const MachineInstr *MInsn = History.front();
1376 LexicalScope *Scope = NULL;
1377 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1378 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1379 Scope = LScopes.getCurrentFunctionScope();
1380 else if (MDNode *IA = DV.getInlinedAt())
1381 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1383 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1384 // If variable scope is not found then skip this variable.
1388 Processed.insert(DV);
1389 assert(MInsn->isDebugValue() && "History must begin with debug value");
1390 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1391 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1392 if (!addCurrentFnArgument(MF, RegVar, Scope))
1393 addScopeVariable(Scope, RegVar);
1395 AbsVar->setMInsn(MInsn);
1397 // Simplify ranges that are fully coalesced.
1398 if (History.size() <= 1 || (History.size() == 2 &&
1399 MInsn->isIdenticalTo(History.back()))) {
1400 RegVar->setMInsn(MInsn);
1404 // Handle multiple DBG_VALUE instructions describing one variable.
1405 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1407 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1408 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1409 const MachineInstr *Begin = *HI;
1410 assert(Begin->isDebugValue() && "Invalid History entry");
1412 // Check if DBG_VALUE is truncating a range.
1413 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1414 && !Begin->getOperand(0).getReg())
1417 // Compute the range for a register location.
1418 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1419 const MCSymbol *SLabel = 0;
1422 // If Begin is the last instruction in History then its value is valid
1423 // until the end of the function.
1424 SLabel = FunctionEndSym;
1426 const MachineInstr *End = HI[1];
1427 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1428 << "\t" << *Begin << "\t" << *End << "\n");
1429 if (End->isDebugValue())
1430 SLabel = getLabelBeforeInsn(End);
1432 // End is a normal instruction clobbering the range.
1433 SLabel = getLabelAfterInsn(End);
1434 assert(SLabel && "Forgot label after clobber instruction");
1439 // The value is valid until the next DBG_VALUE or clobber.
1440 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1443 DotDebugLocEntries.push_back(DotDebugLocEntry());
1446 // Collect info for variables that were optimized out.
1447 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1448 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1449 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1450 DIVariable DV(Variables.getElement(i));
1451 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1453 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1454 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1458 // Return Label preceding the instruction.
1459 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1460 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1461 assert(Label && "Didn't insert label before instruction");
1465 // Return Label immediately following the instruction.
1466 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1467 return LabelsAfterInsn.lookup(MI);
1470 // Process beginning of an instruction.
1471 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1472 // Check if source location changes, but ignore DBG_VALUE locations.
1473 if (!MI->isDebugValue()) {
1474 DebugLoc DL = MI->getDebugLoc();
1475 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1478 if (DL == PrologEndLoc) {
1479 Flags |= DWARF2_FLAG_PROLOGUE_END;
1480 PrologEndLoc = DebugLoc();
1482 if (PrologEndLoc.isUnknown())
1483 Flags |= DWARF2_FLAG_IS_STMT;
1485 if (!DL.isUnknown()) {
1486 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1487 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1489 recordSourceLine(0, 0, 0, 0);
1493 // Insert labels where requested.
1494 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1495 LabelsBeforeInsn.find(MI);
1498 if (I == LabelsBeforeInsn.end())
1501 // Label already assigned.
1506 PrevLabel = MMI->getContext().CreateTempSymbol();
1507 Asm->OutStreamer.EmitLabel(PrevLabel);
1509 I->second = PrevLabel;
1512 // Process end of an instruction.
1513 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1514 // Don't create a new label after DBG_VALUE instructions.
1515 // They don't generate code.
1516 if (!MI->isDebugValue())
1519 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1520 LabelsAfterInsn.find(MI);
1523 if (I == LabelsAfterInsn.end())
1526 // Label already assigned.
1530 // We need a label after this instruction.
1532 PrevLabel = MMI->getContext().CreateTempSymbol();
1533 Asm->OutStreamer.EmitLabel(PrevLabel);
1535 I->second = PrevLabel;
1538 // Each LexicalScope has first instruction and last instruction to mark
1539 // beginning and end of a scope respectively. Create an inverse map that list
1540 // scopes starts (and ends) with an instruction. One instruction may start (or
1541 // end) multiple scopes. Ignore scopes that are not reachable.
1542 void DwarfDebug::identifyScopeMarkers() {
1543 SmallVector<LexicalScope *, 4> WorkList;
1544 WorkList.push_back(LScopes.getCurrentFunctionScope());
1545 while (!WorkList.empty()) {
1546 LexicalScope *S = WorkList.pop_back_val();
1548 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1549 if (!Children.empty())
1550 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1551 SE = Children.end(); SI != SE; ++SI)
1552 WorkList.push_back(*SI);
1554 if (S->isAbstractScope())
1557 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1560 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1561 RE = Ranges.end(); RI != RE; ++RI) {
1562 assert(RI->first && "InsnRange does not have first instruction!");
1563 assert(RI->second && "InsnRange does not have second instruction!");
1564 requestLabelBeforeInsn(RI->first);
1565 requestLabelAfterInsn(RI->second);
1570 // Get MDNode for DebugLoc's scope.
1571 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1572 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1573 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1574 return DL.getScope(Ctx);
1577 // Walk up the scope chain of given debug loc and find line number info
1578 // for the function.
1579 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1580 const MDNode *Scope = getScopeNode(DL, Ctx);
1581 DISubprogram SP = getDISubprogram(Scope);
1582 if (SP.isSubprogram()) {
1583 // Check for number of operands since the compatibility is
1585 if (SP->getNumOperands() > 19)
1586 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1588 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1594 // Gather pre-function debug information. Assumes being called immediately
1595 // after the function entry point has been emitted.
1596 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1597 if (!MMI->hasDebugInfo()) return;
1598 LScopes.initialize(*MF);
1599 if (LScopes.empty()) return;
1600 identifyScopeMarkers();
1602 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1604 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1605 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1606 assert(TheCU && "Unable to find compile unit!");
1607 if (Asm->TM.hasMCUseLoc() &&
1608 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1609 // Use a single line table if we are using .loc and generating assembly.
1610 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1612 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1614 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1615 Asm->getFunctionNumber());
1616 // Assumes in correct section after the entry point.
1617 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1619 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1621 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1622 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1623 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1625 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1627 bool AtBlockEntry = true;
1628 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1630 const MachineInstr *MI = II;
1632 if (MI->isDebugValue()) {
1633 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1635 // Keep track of user variables.
1637 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1639 // Variable is in a register, we need to check for clobbers.
1640 if (isDbgValueInDefinedReg(MI))
1641 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1643 // Check the history of this variable.
1644 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1645 if (History.empty()) {
1646 UserVariables.push_back(Var);
1647 // The first mention of a function argument gets the FunctionBeginSym
1648 // label, so arguments are visible when breaking at function entry.
1650 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1651 DISubprogram(getDISubprogram(DV.getContext()))
1652 .describes(MF->getFunction()))
1653 LabelsBeforeInsn[MI] = FunctionBeginSym;
1655 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1656 const MachineInstr *Prev = History.back();
1657 if (Prev->isDebugValue()) {
1658 // Coalesce identical entries at the end of History.
1659 if (History.size() >= 2 &&
1660 Prev->isIdenticalTo(History[History.size() - 2])) {
1661 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1663 << "\t" << *History[History.size() - 2] << "\n");
1667 // Terminate old register assignments that don't reach MI;
1668 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1669 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1670 isDbgValueInDefinedReg(Prev)) {
1671 // Previous register assignment needs to terminate at the end of
1673 MachineBasicBlock::const_iterator LastMI =
1674 PrevMBB->getLastNonDebugInstr();
1675 if (LastMI == PrevMBB->end()) {
1676 // Drop DBG_VALUE for empty range.
1677 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1678 << "\t" << *Prev << "\n");
1680 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1681 // Terminate after LastMI.
1682 History.push_back(LastMI);
1686 History.push_back(MI);
1688 // Not a DBG_VALUE instruction.
1690 AtBlockEntry = false;
1692 // First known non-DBG_VALUE and non-frame setup location marks
1693 // the beginning of the function body.
1694 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1695 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1696 PrologEndLoc = MI->getDebugLoc();
1698 // Check if the instruction clobbers any registers with debug vars.
1699 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1700 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1701 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1703 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1704 AI.isValid(); ++AI) {
1706 const MDNode *Var = LiveUserVar[Reg];
1709 // Reg is now clobbered.
1710 LiveUserVar[Reg] = 0;
1712 // Was MD last defined by a DBG_VALUE referring to Reg?
1713 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1714 if (HistI == DbgValues.end())
1716 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1717 if (History.empty())
1719 const MachineInstr *Prev = History.back();
1720 // Sanity-check: Register assignments are terminated at the end of
1722 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1724 // Is the variable still in Reg?
1725 if (!isDbgValueInDefinedReg(Prev) ||
1726 Prev->getOperand(0).getReg() != Reg)
1728 // Var is clobbered. Make sure the next instruction gets a label.
1729 History.push_back(MI);
1736 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1738 SmallVectorImpl<const MachineInstr*> &History = I->second;
1739 if (History.empty())
1742 // Make sure the final register assignments are terminated.
1743 const MachineInstr *Prev = History.back();
1744 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1745 const MachineBasicBlock *PrevMBB = Prev->getParent();
1746 MachineBasicBlock::const_iterator LastMI =
1747 PrevMBB->getLastNonDebugInstr();
1748 if (LastMI == PrevMBB->end())
1749 // Drop DBG_VALUE for empty range.
1751 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1752 // Terminate after LastMI.
1753 History.push_back(LastMI);
1756 // Request labels for the full history.
1757 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1758 const MachineInstr *MI = History[i];
1759 if (MI->isDebugValue())
1760 requestLabelBeforeInsn(MI);
1762 requestLabelAfterInsn(MI);
1766 PrevInstLoc = DebugLoc();
1767 PrevLabel = FunctionBeginSym;
1769 // Record beginning of function.
1770 if (!PrologEndLoc.isUnknown()) {
1771 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1772 MF->getFunction()->getContext());
1773 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1774 FnStartDL.getScope(MF->getFunction()->getContext()),
1775 // We'd like to list the prologue as "not statements" but GDB behaves
1776 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1777 DWARF2_FLAG_IS_STMT);
1781 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1782 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1783 DIVariable DV = Var->getVariable();
1784 // Variables with positive arg numbers are parameters.
1785 if (unsigned ArgNum = DV.getArgNumber()) {
1786 // Keep all parameters in order at the start of the variable list to ensure
1787 // function types are correct (no out-of-order parameters)
1789 // This could be improved by only doing it for optimized builds (unoptimized
1790 // builds have the right order to begin with), searching from the back (this
1791 // would catch the unoptimized case quickly), or doing a binary search
1792 // rather than linear search.
1793 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1794 while (I != Vars.end()) {
1795 unsigned CurNum = (*I)->getVariable().getArgNumber();
1796 // A local (non-parameter) variable has been found, insert immediately
1800 // A later indexed parameter has been found, insert immediately before it.
1801 if (CurNum > ArgNum)
1805 Vars.insert(I, Var);
1809 Vars.push_back(Var);
1812 // Gather and emit post-function debug information.
1813 void DwarfDebug::endFunction(const MachineFunction *MF) {
1814 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1816 // Define end label for subprogram.
1817 FunctionEndSym = Asm->GetTempSymbol("func_end",
1818 Asm->getFunctionNumber());
1819 // Assumes in correct section after the entry point.
1820 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1821 // Set DwarfCompileUnitID in MCContext to default value.
1822 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1824 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1825 collectVariableInfo(MF, ProcessedVars);
1827 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1828 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1829 assert(TheCU && "Unable to find compile unit!");
1831 // Construct abstract scopes.
1832 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1833 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1834 LexicalScope *AScope = AList[i];
1835 DISubprogram SP(AScope->getScopeNode());
1836 if (SP.isSubprogram()) {
1837 // Collect info for variables that were optimized out.
1838 DIArray Variables = SP.getVariables();
1839 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1840 DIVariable DV(Variables.getElement(i));
1841 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1843 // Check that DbgVariable for DV wasn't created earlier, when
1844 // findAbstractVariable() was called for inlined instance of DV.
1845 LLVMContext &Ctx = DV->getContext();
1846 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1847 if (AbstractVariables.lookup(CleanDV))
1849 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1850 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1853 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1854 constructScopeDIE(TheCU, AScope);
1857 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1859 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1860 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1863 for (ScopeVariablesMap::iterator
1864 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1865 DeleteContainerPointers(I->second);
1866 ScopeVariables.clear();
1867 DeleteContainerPointers(CurrentFnArguments);
1868 UserVariables.clear();
1870 AbstractVariables.clear();
1871 LabelsBeforeInsn.clear();
1872 LabelsAfterInsn.clear();
1876 // Register a source line with debug info. Returns the unique label that was
1877 // emitted and which provides correspondence to the source line list.
1878 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1884 DIDescriptor Scope(S);
1886 if (Scope.isCompileUnit()) {
1887 DICompileUnit CU(S);
1888 Fn = CU.getFilename();
1889 Dir = CU.getDirectory();
1890 } else if (Scope.isFile()) {
1892 Fn = F.getFilename();
1893 Dir = F.getDirectory();
1894 } else if (Scope.isSubprogram()) {
1896 Fn = SP.getFilename();
1897 Dir = SP.getDirectory();
1898 } else if (Scope.isLexicalBlockFile()) {
1899 DILexicalBlockFile DBF(S);
1900 Fn = DBF.getFilename();
1901 Dir = DBF.getDirectory();
1902 } else if (Scope.isLexicalBlock()) {
1903 DILexicalBlock DB(S);
1904 Fn = DB.getFilename();
1905 Dir = DB.getDirectory();
1907 llvm_unreachable("Unexpected scope info");
1909 Src = getOrCreateSourceID(Fn, Dir,
1910 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1912 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1915 //===----------------------------------------------------------------------===//
1917 //===----------------------------------------------------------------------===//
1919 // Compute the size and offset of a DIE.
1921 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1922 // Get the children.
1923 const std::vector<DIE *> &Children = Die->getChildren();
1925 // Record the abbreviation.
1926 assignAbbrevNumber(Die->getAbbrev());
1928 // Get the abbreviation for this DIE.
1929 unsigned AbbrevNumber = Die->getAbbrevNumber();
1930 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1933 Die->setOffset(Offset);
1935 // Start the size with the size of abbreviation code.
1936 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1938 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1939 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1941 // Size the DIE attribute values.
1942 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1943 // Size attribute value.
1944 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1946 // Size the DIE children if any.
1947 if (!Children.empty()) {
1948 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1949 "Children flag not set");
1951 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1952 Offset = computeSizeAndOffset(Children[j], Offset);
1954 // End of children marker.
1955 Offset += sizeof(int8_t);
1958 Die->setSize(Offset - Die->getOffset());
1962 // Compute the size and offset of all the DIEs.
1963 void DwarfUnits::computeSizeAndOffsets() {
1964 // Offset from the beginning of debug info section.
1965 unsigned SecOffset = 0;
1966 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1967 E = CUs.end(); I != E; ++I) {
1968 (*I)->setDebugInfoOffset(SecOffset);
1970 sizeof(int32_t) + // Length of Compilation Unit Info
1971 sizeof(int16_t) + // DWARF version number
1972 sizeof(int32_t) + // Offset Into Abbrev. Section
1973 sizeof(int8_t); // Pointer Size (in bytes)
1975 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1976 SecOffset += EndOffset;
1980 // Emit initial Dwarf sections with a label at the start of each one.
1981 void DwarfDebug::emitSectionLabels() {
1982 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1984 // Dwarf sections base addresses.
1985 DwarfInfoSectionSym =
1986 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1987 DwarfAbbrevSectionSym =
1988 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1989 if (useSplitDwarf())
1990 DwarfAbbrevDWOSectionSym =
1991 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1992 "section_abbrev_dwo");
1993 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1995 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1996 emitSectionSym(Asm, MacroInfo);
1998 DwarfLineSectionSym =
1999 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2000 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2001 if (GenerateDwarfPubNamesSection)
2002 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2003 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2004 DwarfStrSectionSym =
2005 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2006 if (useSplitDwarf()) {
2007 DwarfStrDWOSectionSym =
2008 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2009 DwarfAddrSectionSym =
2010 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2012 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2015 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
2016 "section_debug_loc");
2018 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2019 emitSectionSym(Asm, TLOF.getDataSection());
2022 // Recursively emits a debug information entry.
2023 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
2024 // Get the abbreviation for this DIE.
2025 unsigned AbbrevNumber = Die->getAbbrevNumber();
2026 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
2028 // Emit the code (index) for the abbreviation.
2029 if (Asm->isVerbose())
2030 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2031 Twine::utohexstr(Die->getOffset()) + ":0x" +
2032 Twine::utohexstr(Die->getSize()) + " " +
2033 dwarf::TagString(Abbrev->getTag()));
2034 Asm->EmitULEB128(AbbrevNumber);
2036 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2037 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2039 // Emit the DIE attribute values.
2040 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2041 unsigned Attr = AbbrevData[i].getAttribute();
2042 unsigned Form = AbbrevData[i].getForm();
2043 assert(Form && "Too many attributes for DIE (check abbreviation)");
2045 if (Asm->isVerbose())
2046 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2049 case dwarf::DW_AT_abstract_origin: {
2050 DIEEntry *E = cast<DIEEntry>(Values[i]);
2051 DIE *Origin = E->getEntry();
2052 unsigned Addr = Origin->getOffset();
2053 if (Form == dwarf::DW_FORM_ref_addr) {
2054 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2055 // section. Origin->getOffset() returns the offset from start of the
2057 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2058 Addr += Holder.getCUOffset(Origin->getCompileUnit());
2060 Asm->OutStreamer.EmitIntValue(Addr,
2061 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
2064 case dwarf::DW_AT_ranges: {
2065 // DW_AT_range Value encodes offset in debug_range section.
2066 DIEInteger *V = cast<DIEInteger>(Values[i]);
2068 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2069 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2073 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2075 DwarfDebugRangeSectionSym,
2080 case dwarf::DW_AT_location: {
2081 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2082 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2083 Asm->EmitLabelReference(L->getValue(), 4);
2085 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2087 Values[i]->EmitValue(Asm, Form);
2091 case dwarf::DW_AT_accessibility: {
2092 if (Asm->isVerbose()) {
2093 DIEInteger *V = cast<DIEInteger>(Values[i]);
2094 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2096 Values[i]->EmitValue(Asm, Form);
2100 // Emit an attribute using the defined form.
2101 Values[i]->EmitValue(Asm, Form);
2106 // Emit the DIE children if any.
2107 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2108 const std::vector<DIE *> &Children = Die->getChildren();
2110 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2111 emitDIE(Children[j], Abbrevs);
2113 if (Asm->isVerbose())
2114 Asm->OutStreamer.AddComment("End Of Children Mark");
2119 // Emit the various dwarf units to the unit section USection with
2120 // the abbreviations going into ASection.
2121 void DwarfUnits::emitUnits(DwarfDebug *DD,
2122 const MCSection *USection,
2123 const MCSection *ASection,
2124 const MCSymbol *ASectionSym) {
2125 Asm->OutStreamer.SwitchSection(USection);
2126 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2127 E = CUs.end(); I != E; ++I) {
2128 CompileUnit *TheCU = *I;
2129 DIE *Die = TheCU->getCUDie();
2131 // Emit the compile units header.
2133 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2134 TheCU->getUniqueID()));
2136 // Emit size of content not including length itself
2137 unsigned ContentSize = Die->getSize() +
2138 sizeof(int16_t) + // DWARF version number
2139 sizeof(int32_t) + // Offset Into Abbrev. Section
2140 sizeof(int8_t); // Pointer Size (in bytes)
2142 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2143 Asm->EmitInt32(ContentSize);
2144 Asm->OutStreamer.AddComment("DWARF version number");
2145 Asm->EmitInt16(DD->getDwarfVersion());
2146 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2147 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2149 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2150 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2152 DD->emitDIE(Die, Abbreviations);
2153 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2154 TheCU->getUniqueID()));
2158 /// For a given compile unit DIE, returns offset from beginning of debug info.
2159 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2160 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2161 "Input DIE should be compile unit in getCUOffset.");
2162 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2163 E = CUs.end(); I != E; ++I) {
2164 CompileUnit *TheCU = *I;
2165 if (TheCU->getCUDie() == Die)
2166 return TheCU->getDebugInfoOffset();
2168 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2171 // Emit the debug info section.
2172 void DwarfDebug::emitDebugInfo() {
2173 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2175 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2176 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2177 DwarfAbbrevSectionSym);
2180 // Emit the abbreviation section.
2181 void DwarfDebug::emitAbbreviations() {
2182 if (!useSplitDwarf())
2183 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2186 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2189 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2190 std::vector<DIEAbbrev *> *Abbrevs) {
2191 // Check to see if it is worth the effort.
2192 if (!Abbrevs->empty()) {
2193 // Start the debug abbrev section.
2194 Asm->OutStreamer.SwitchSection(Section);
2196 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2197 Asm->OutStreamer.EmitLabel(Begin);
2199 // For each abbrevation.
2200 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2201 // Get abbreviation data
2202 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2204 // Emit the abbrevations code (base 1 index.)
2205 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2207 // Emit the abbreviations data.
2211 // Mark end of abbreviations.
2212 Asm->EmitULEB128(0, "EOM(3)");
2214 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2215 Asm->OutStreamer.EmitLabel(End);
2219 // Emit the last address of the section and the end of the line matrix.
2220 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2221 // Define last address of section.
2222 Asm->OutStreamer.AddComment("Extended Op");
2225 Asm->OutStreamer.AddComment("Op size");
2226 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2227 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2228 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2230 Asm->OutStreamer.AddComment("Section end label");
2232 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2233 Asm->getDataLayout().getPointerSize());
2235 // Mark end of matrix.
2236 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2242 // Emit visible names into a hashed accelerator table section.
2243 void DwarfDebug::emitAccelNames() {
2244 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2245 dwarf::DW_FORM_data4));
2246 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2247 E = CUMap.end(); I != E; ++I) {
2248 CompileUnit *TheCU = I->second;
2249 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2250 for (StringMap<std::vector<DIE*> >::const_iterator
2251 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2252 StringRef Name = GI->getKey();
2253 const std::vector<DIE *> &Entities = GI->second;
2254 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2255 DE = Entities.end(); DI != DE; ++DI)
2256 AT.AddName(Name, (*DI));
2260 AT.FinalizeTable(Asm, "Names");
2261 Asm->OutStreamer.SwitchSection(
2262 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2263 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2264 Asm->OutStreamer.EmitLabel(SectionBegin);
2266 // Emit the full data.
2267 AT.Emit(Asm, SectionBegin, &InfoHolder);
2270 // Emit objective C classes and categories into a hashed accelerator table
2272 void DwarfDebug::emitAccelObjC() {
2273 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2274 dwarf::DW_FORM_data4));
2275 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2276 E = CUMap.end(); I != E; ++I) {
2277 CompileUnit *TheCU = I->second;
2278 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2279 for (StringMap<std::vector<DIE*> >::const_iterator
2280 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2281 StringRef Name = GI->getKey();
2282 const std::vector<DIE *> &Entities = GI->second;
2283 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2284 DE = Entities.end(); DI != DE; ++DI)
2285 AT.AddName(Name, (*DI));
2289 AT.FinalizeTable(Asm, "ObjC");
2290 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2291 .getDwarfAccelObjCSection());
2292 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2293 Asm->OutStreamer.EmitLabel(SectionBegin);
2295 // Emit the full data.
2296 AT.Emit(Asm, SectionBegin, &InfoHolder);
2299 // Emit namespace dies into a hashed accelerator table.
2300 void DwarfDebug::emitAccelNamespaces() {
2301 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2302 dwarf::DW_FORM_data4));
2303 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2304 E = CUMap.end(); I != E; ++I) {
2305 CompileUnit *TheCU = I->second;
2306 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2307 for (StringMap<std::vector<DIE*> >::const_iterator
2308 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2309 StringRef Name = GI->getKey();
2310 const std::vector<DIE *> &Entities = GI->second;
2311 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2312 DE = Entities.end(); DI != DE; ++DI)
2313 AT.AddName(Name, (*DI));
2317 AT.FinalizeTable(Asm, "namespac");
2318 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2319 .getDwarfAccelNamespaceSection());
2320 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2321 Asm->OutStreamer.EmitLabel(SectionBegin);
2323 // Emit the full data.
2324 AT.Emit(Asm, SectionBegin, &InfoHolder);
2327 // Emit type dies into a hashed accelerator table.
2328 void DwarfDebug::emitAccelTypes() {
2329 std::vector<DwarfAccelTable::Atom> Atoms;
2330 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2331 dwarf::DW_FORM_data4));
2332 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2333 dwarf::DW_FORM_data2));
2334 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2335 dwarf::DW_FORM_data1));
2336 DwarfAccelTable AT(Atoms);
2337 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2338 E = CUMap.end(); I != E; ++I) {
2339 CompileUnit *TheCU = I->second;
2340 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2341 = TheCU->getAccelTypes();
2342 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2343 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2344 StringRef Name = GI->getKey();
2345 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2346 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2347 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2348 AT.AddName(Name, (*DI).first, (*DI).second);
2352 AT.FinalizeTable(Asm, "types");
2353 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2354 .getDwarfAccelTypesSection());
2355 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2356 Asm->OutStreamer.EmitLabel(SectionBegin);
2358 // Emit the full data.
2359 AT.Emit(Asm, SectionBegin, &InfoHolder);
2362 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2364 void DwarfDebug::emitDebugPubnames() {
2365 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2367 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2368 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2369 CompileUnit *TheCU = I->second;
2370 unsigned ID = TheCU->getUniqueID();
2372 if (TheCU->getGlobalNames().empty())
2375 // Start the dwarf pubnames section.
2376 Asm->OutStreamer.SwitchSection(
2377 Asm->getObjFileLowering().getDwarfPubNamesSection());
2379 Asm->OutStreamer.AddComment("Length of Public Names Info");
2380 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2381 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2383 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2385 Asm->OutStreamer.AddComment("DWARF Version");
2386 Asm->EmitInt16(DwarfVersion);
2388 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2389 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2390 DwarfInfoSectionSym);
2392 Asm->OutStreamer.AddComment("Compilation Unit Length");
2393 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2394 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2397 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2398 for (StringMap<DIE*>::const_iterator
2399 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2400 const char *Name = GI->getKeyData();
2401 const DIE *Entity = GI->second;
2403 Asm->OutStreamer.AddComment("DIE offset");
2404 Asm->EmitInt32(Entity->getOffset());
2406 if (Asm->isVerbose())
2407 Asm->OutStreamer.AddComment("External Name");
2408 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2411 Asm->OutStreamer.AddComment("End Mark");
2413 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2417 void DwarfDebug::emitDebugPubTypes() {
2418 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2419 E = CUMap.end(); I != E; ++I) {
2420 CompileUnit *TheCU = I->second;
2421 // Start the dwarf pubtypes section.
2422 Asm->OutStreamer.SwitchSection(
2423 Asm->getObjFileLowering().getDwarfPubTypesSection());
2424 Asm->OutStreamer.AddComment("Length of Public Types Info");
2425 Asm->EmitLabelDifference(
2426 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2427 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2429 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2430 TheCU->getUniqueID()));
2432 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2433 Asm->EmitInt16(DwarfVersion);
2435 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2436 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2437 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2438 TheCU->getUniqueID()),
2439 DwarfInfoSectionSym);
2441 Asm->OutStreamer.AddComment("Compilation Unit Length");
2442 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2443 TheCU->getUniqueID()),
2444 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2445 TheCU->getUniqueID()),
2448 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2449 for (StringMap<DIE*>::const_iterator
2450 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2451 const char *Name = GI->getKeyData();
2452 DIE *Entity = GI->second;
2454 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2455 Asm->EmitInt32(Entity->getOffset());
2457 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2458 // Emit the name with a terminating null byte.
2459 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2462 Asm->OutStreamer.AddComment("End Mark");
2464 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2465 TheCU->getUniqueID()));
2469 // Emit strings into a string section.
2470 void DwarfUnits::emitStrings(const MCSection *StrSection,
2471 const MCSection *OffsetSection = NULL,
2472 const MCSymbol *StrSecSym = NULL) {
2474 if (StringPool.empty()) return;
2476 // Start the dwarf str section.
2477 Asm->OutStreamer.SwitchSection(StrSection);
2479 // Get all of the string pool entries and put them in an array by their ID so
2480 // we can sort them.
2481 SmallVector<std::pair<unsigned,
2482 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2484 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2485 I = StringPool.begin(), E = StringPool.end();
2487 Entries.push_back(std::make_pair(I->second.second, &*I));
2489 array_pod_sort(Entries.begin(), Entries.end());
2491 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2492 // Emit a label for reference from debug information entries.
2493 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2495 // Emit the string itself with a terminating null byte.
2496 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2497 Entries[i].second->getKeyLength()+1));
2500 // If we've got an offset section go ahead and emit that now as well.
2501 if (OffsetSection) {
2502 Asm->OutStreamer.SwitchSection(OffsetSection);
2503 unsigned offset = 0;
2504 unsigned size = 4; // FIXME: DWARF64 is 8.
2505 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2506 Asm->OutStreamer.EmitIntValue(offset, size);
2507 offset += Entries[i].second->getKeyLength() + 1;
2512 // Emit strings into a string section.
2513 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2515 if (AddressPool.empty()) return;
2517 // Start the dwarf addr section.
2518 Asm->OutStreamer.SwitchSection(AddrSection);
2520 // Order the address pool entries by ID
2521 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2523 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2524 E = AddressPool.end();
2526 Entries[I->second] = I->first;
2528 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2529 // Emit an expression for reference from debug information entries.
2530 if (const MCExpr *Expr = Entries[i])
2531 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2533 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2538 // Emit visible names into a debug str section.
2539 void DwarfDebug::emitDebugStr() {
2540 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2541 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2544 // Emit locations into the debug loc section.
2545 void DwarfDebug::emitDebugLoc() {
2546 if (DotDebugLocEntries.empty())
2549 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2550 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2552 DotDebugLocEntry &Entry = *I;
2553 if (I + 1 != DotDebugLocEntries.end())
2557 // Start the dwarf loc section.
2558 Asm->OutStreamer.SwitchSection(
2559 Asm->getObjFileLowering().getDwarfLocSection());
2560 unsigned char Size = Asm->getDataLayout().getPointerSize();
2561 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2563 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2564 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2565 I != E; ++I, ++index) {
2566 DotDebugLocEntry &Entry = *I;
2567 if (Entry.isMerged()) continue;
2568 if (Entry.isEmpty()) {
2569 Asm->OutStreamer.EmitIntValue(0, Size);
2570 Asm->OutStreamer.EmitIntValue(0, Size);
2571 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2573 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2574 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2575 DIVariable DV(Entry.getVariable());
2576 Asm->OutStreamer.AddComment("Loc expr size");
2577 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2578 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2579 Asm->EmitLabelDifference(end, begin, 2);
2580 Asm->OutStreamer.EmitLabel(begin);
2581 if (Entry.isInt()) {
2582 DIBasicType BTy(DV.getType());
2584 (BTy.getEncoding() == dwarf::DW_ATE_signed
2585 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2586 Asm->OutStreamer.AddComment("DW_OP_consts");
2587 Asm->EmitInt8(dwarf::DW_OP_consts);
2588 Asm->EmitSLEB128(Entry.getInt());
2590 Asm->OutStreamer.AddComment("DW_OP_constu");
2591 Asm->EmitInt8(dwarf::DW_OP_constu);
2592 Asm->EmitULEB128(Entry.getInt());
2594 } else if (Entry.isLocation()) {
2595 MachineLocation Loc = Entry.getLoc();
2596 if (!DV.hasComplexAddress())
2598 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2600 // Complex address entry.
2601 unsigned N = DV.getNumAddrElements();
2603 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2604 if (Loc.getOffset()) {
2606 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2607 Asm->OutStreamer.AddComment("DW_OP_deref");
2608 Asm->EmitInt8(dwarf::DW_OP_deref);
2609 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2610 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2611 Asm->EmitSLEB128(DV.getAddrElement(1));
2613 // If first address element is OpPlus then emit
2614 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2615 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2616 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2620 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2623 // Emit remaining complex address elements.
2624 for (; i < N; ++i) {
2625 uint64_t Element = DV.getAddrElement(i);
2626 if (Element == DIBuilder::OpPlus) {
2627 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2628 Asm->EmitULEB128(DV.getAddrElement(++i));
2629 } else if (Element == DIBuilder::OpDeref) {
2631 Asm->EmitInt8(dwarf::DW_OP_deref);
2633 llvm_unreachable("unknown Opcode found in complex address");
2637 // else ... ignore constant fp. There is not any good way to
2638 // to represent them here in dwarf.
2639 Asm->OutStreamer.EmitLabel(end);
2644 // Emit visible names into a debug aranges section.
2645 void DwarfDebug::emitDebugARanges() {
2646 // Start the dwarf aranges section.
2647 Asm->OutStreamer.SwitchSection(
2648 Asm->getObjFileLowering().getDwarfARangesSection());
2651 // Emit visible names into a debug ranges section.
2652 void DwarfDebug::emitDebugRanges() {
2653 // Start the dwarf ranges section.
2654 Asm->OutStreamer.SwitchSection(
2655 Asm->getObjFileLowering().getDwarfRangesSection());
2656 unsigned char Size = Asm->getDataLayout().getPointerSize();
2657 for (SmallVectorImpl<const MCSymbol *>::iterator
2658 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2661 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2663 Asm->OutStreamer.EmitIntValue(0, Size);
2667 // Emit visible names into a debug macinfo section.
2668 void DwarfDebug::emitDebugMacInfo() {
2669 if (const MCSection *LineInfo =
2670 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2671 // Start the dwarf macinfo section.
2672 Asm->OutStreamer.SwitchSection(LineInfo);
2676 // Emit inline info using following format.
2678 // 1. length of section
2679 // 2. Dwarf version number
2682 // Entries (one "entry" for each function that was inlined):
2684 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2685 // otherwise offset into __debug_str for regular function name.
2686 // 2. offset into __debug_str section for regular function name.
2687 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2688 // instances for the function.
2690 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2691 // inlined instance; the die_offset points to the inlined_subroutine die in the
2692 // __debug_info section, and the low_pc is the starting address for the
2693 // inlining instance.
2694 void DwarfDebug::emitDebugInlineInfo() {
2695 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2701 Asm->OutStreamer.SwitchSection(
2702 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2704 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2705 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2706 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2708 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2710 Asm->OutStreamer.AddComment("Dwarf Version");
2711 Asm->EmitInt16(DwarfVersion);
2712 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2713 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2715 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2716 E = InlinedSPNodes.end(); I != E; ++I) {
2718 const MDNode *Node = *I;
2719 InlineInfoMap::iterator II = InlineInfo.find(Node);
2720 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2721 DISubprogram SP(Node);
2722 StringRef LName = SP.getLinkageName();
2723 StringRef Name = SP.getName();
2725 Asm->OutStreamer.AddComment("MIPS linkage name");
2727 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2728 DwarfStrSectionSym);
2730 Asm->EmitSectionOffset(
2731 InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2732 DwarfStrSectionSym);
2734 Asm->OutStreamer.AddComment("Function name");
2735 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2736 DwarfStrSectionSym);
2737 Asm->EmitULEB128(Labels.size(), "Inline count");
2739 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2740 LE = Labels.end(); LI != LE; ++LI) {
2741 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2742 Asm->EmitInt32(LI->second->getOffset());
2744 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2745 Asm->OutStreamer.EmitSymbolValue(LI->first,
2746 Asm->getDataLayout().getPointerSize());
2750 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2753 // DWARF5 Experimental Separate Dwarf emitters.
2755 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2756 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2757 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2758 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2759 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2760 DICompileUnit DIUnit(N);
2761 CompilationDir = DIUnit.getDirectory();
2763 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2764 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2765 DIUnit.getLanguage(), Die, N, Asm,
2766 this, &SkeletonHolder);
2768 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2769 DIUnit.getSplitDebugFilename());
2771 // This should be a unique identifier when we want to build .dwp files.
2772 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2774 // Relocate to the beginning of the addr_base section, else 0 for the
2775 // beginning of the one for this compile unit.
2776 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2777 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2778 DwarfAddrSectionSym);
2780 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2781 dwarf::DW_FORM_sec_offset, 0);
2783 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2784 // into an entity. We're using 0, or a NULL label for this.
2785 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2787 // DW_AT_stmt_list is a offset of line number information for this
2788 // compile unit in debug_line section.
2789 // FIXME: Should handle multiple compile units.
2790 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2791 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2792 DwarfLineSectionSym);
2794 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2796 if (!CompilationDir.empty())
2797 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2799 SkeletonHolder.addUnit(NewCU);
2800 SkeletonCUs.push_back(NewCU);
2805 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2806 assert(useSplitDwarf() && "No split dwarf debug info?");
2807 emitAbbrevs(Section, &SkeletonAbbrevs);
2810 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2811 // compile units that would normally be in debug_info.
2812 void DwarfDebug::emitDebugInfoDWO() {
2813 assert(useSplitDwarf() && "No split dwarf debug info?");
2814 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2815 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2816 DwarfAbbrevDWOSectionSym);
2819 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2820 // abbreviations for the .debug_info.dwo section.
2821 void DwarfDebug::emitDebugAbbrevDWO() {
2822 assert(useSplitDwarf() && "No split dwarf?");
2823 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2827 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2828 // string section and is identical in format to traditional .debug_str
2830 void DwarfDebug::emitDebugStrDWO() {
2831 assert(useSplitDwarf() && "No split dwarf?");
2832 const MCSection *OffSec = Asm->getObjFileLowering()
2833 .getDwarfStrOffDWOSection();
2834 const MCSymbol *StrSym = DwarfStrSectionSym;
2835 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),