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(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.
1062 // Our MD5 implementation always returns its results in little endian, swap
1063 // bytes appropriately.
1064 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
1066 // FIXME: This should be added onto the type unit, not the type, but this
1067 // works as an intermediate stage.
1068 CU->addUInt(Die, dwarf::DW_AT_GNU_odr_signature, dwarf::DW_FORM_data8,
1072 /// Return true if the current DIE is contained within an anonymous namespace.
1073 static bool isContainedInAnonNamespace(DIE *Die) {
1074 DIE *Parent = Die->getParent();
1077 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1078 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1080 Parent = Parent->getParent();
1086 void DwarfDebug::finalizeModuleInfo() {
1087 // Collect info for variables that were optimized out.
1088 collectDeadVariables();
1090 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1091 computeInlinedDIEs();
1093 // Emit DW_AT_containing_type attribute to connect types with their
1094 // vtable holding type.
1095 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1096 CUE = CUMap.end(); CUI != CUE; ++CUI) {
1097 CompileUnit *TheCU = CUI->second;
1098 TheCU->constructContainingTypeDIEs();
1101 // Split out type units and conditionally add an ODR tag to the split
1103 // FIXME: Do type splitting.
1104 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1106 DIE *Die = TypeUnits[i];
1107 // If we've requested ODR hashes, the current language is C++, the type is
1108 // named, and the type isn't located inside a C++ anonymous namespace then
1109 // add the ODR signature attribute now.
1110 if (GenerateODRHash &&
1111 CUMap.begin()->second->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1112 (getDIEStringAttr(Die, dwarf::DW_AT_name) != "") &&
1113 !isContainedInAnonNamespace(Die))
1114 addDIEODRSignature(Hash, CUMap.begin()->second, Die);
1117 // Compute DIE offsets and sizes.
1118 InfoHolder.computeSizeAndOffsets();
1119 if (useSplitDwarf())
1120 SkeletonHolder.computeSizeAndOffsets();
1123 void DwarfDebug::endSections() {
1124 // Standard sections final addresses.
1125 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1126 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1127 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1128 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1130 // End text sections.
1131 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1132 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1133 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1137 // Emit all Dwarf sections that should come after the content.
1138 void DwarfDebug::endModule() {
1140 if (!FirstCU) return;
1142 // End any existing sections.
1143 // TODO: Does this need to happen?
1146 // Finalize the debug info for the module.
1147 finalizeModuleInfo();
1149 if (!useSplitDwarf()) {
1150 // Emit all the DIEs into a debug info section.
1153 // Corresponding abbreviations into a abbrev section.
1154 emitAbbreviations();
1156 // Emit info into a debug loc section.
1159 // Emit info into a debug aranges section.
1162 // Emit info into a debug ranges section.
1165 // Emit info into a debug macinfo section.
1168 // Emit inline info.
1169 // TODO: When we don't need the option anymore we
1170 // can remove all of the code that this section
1172 if (useDarwinGDBCompat())
1173 emitDebugInlineInfo();
1175 // TODO: Fill this in for separated debug sections and separate
1176 // out information into new sections.
1178 // Emit the debug info section and compile units.
1182 // Corresponding abbreviations into a abbrev section.
1183 emitAbbreviations();
1184 emitDebugAbbrevDWO();
1186 // Emit info into a debug loc section.
1189 // Emit info into a debug aranges section.
1192 // Emit info into a debug ranges section.
1195 // Emit info into a debug macinfo section.
1198 // Emit DWO addresses.
1199 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1201 // Emit inline info.
1202 // TODO: When we don't need the option anymore we
1203 // can remove all of the code that this section
1205 if (useDarwinGDBCompat())
1206 emitDebugInlineInfo();
1209 // Emit info into the dwarf accelerator table sections.
1210 if (useDwarfAccelTables()) {
1213 emitAccelNamespaces();
1217 // Emit info into a debug pubnames section, if requested.
1218 if (GenerateDwarfPubNamesSection)
1219 emitDebugPubnames();
1221 // Emit info into a debug pubtypes section.
1222 // TODO: When we don't need the option anymore we can
1223 // remove all of the code that adds to the table.
1224 if (useDarwinGDBCompat())
1225 emitDebugPubTypes();
1227 // Finally emit string information into a string table.
1229 if (useSplitDwarf())
1234 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1235 E = CUMap.end(); I != E; ++I)
1238 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1239 E = SkeletonCUs.end(); I != E; ++I)
1242 // Reset these for the next Module if we have one.
1246 // Find abstract variable, if any, associated with Var.
1247 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1248 DebugLoc ScopeLoc) {
1249 LLVMContext &Ctx = DV->getContext();
1250 // More then one inlined variable corresponds to one abstract variable.
1251 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1252 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1254 return AbsDbgVariable;
1256 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1260 AbsDbgVariable = new DbgVariable(Var, NULL);
1261 addScopeVariable(Scope, AbsDbgVariable);
1262 AbstractVariables[Var] = AbsDbgVariable;
1263 return AbsDbgVariable;
1266 // If Var is a current function argument then add it to CurrentFnArguments list.
1267 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1268 DbgVariable *Var, LexicalScope *Scope) {
1269 if (!LScopes.isCurrentFunctionScope(Scope))
1271 DIVariable DV = Var->getVariable();
1272 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1274 unsigned ArgNo = DV.getArgNumber();
1278 size_t Size = CurrentFnArguments.size();
1280 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1281 // llvm::Function argument size is not good indicator of how many
1282 // arguments does the function have at source level.
1284 CurrentFnArguments.resize(ArgNo * 2);
1285 CurrentFnArguments[ArgNo - 1] = Var;
1289 // Collect variable information from side table maintained by MMI.
1291 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1292 SmallPtrSet<const MDNode *, 16> &Processed) {
1293 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1294 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1295 VE = VMap.end(); VI != VE; ++VI) {
1296 const MDNode *Var = VI->first;
1298 Processed.insert(Var);
1300 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1302 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1304 // If variable scope is not found then skip this variable.
1308 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1309 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1310 RegVar->setFrameIndex(VP.first);
1311 if (!addCurrentFnArgument(MF, RegVar, Scope))
1312 addScopeVariable(Scope, RegVar);
1314 AbsDbgVariable->setFrameIndex(VP.first);
1318 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1320 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1321 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1322 return MI->getNumOperands() == 3 &&
1323 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1324 (MI->getOperand(1).isImm() ||
1325 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1328 // Get .debug_loc entry for the instruction range starting at MI.
1329 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1330 const MCSymbol *FLabel,
1331 const MCSymbol *SLabel,
1332 const MachineInstr *MI) {
1333 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1335 assert(MI->getNumOperands() == 3);
1336 if (MI->getOperand(0).isReg()) {
1337 MachineLocation MLoc;
1338 // If the second operand is an immediate, this is a
1339 // register-indirect address.
1340 if (!MI->getOperand(1).isImm())
1341 MLoc.set(MI->getOperand(0).getReg());
1343 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1344 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1346 if (MI->getOperand(0).isImm())
1347 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1348 if (MI->getOperand(0).isFPImm())
1349 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1350 if (MI->getOperand(0).isCImm())
1351 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1353 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1356 // Find variables for each lexical scope.
1358 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1359 SmallPtrSet<const MDNode *, 16> &Processed) {
1361 // Grab the variable info that was squirreled away in the MMI side-table.
1362 collectVariableInfoFromMMITable(MF, Processed);
1364 for (SmallVectorImpl<const MDNode*>::const_iterator
1365 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1367 const MDNode *Var = *UVI;
1368 if (Processed.count(Var))
1371 // History contains relevant DBG_VALUE instructions for Var and instructions
1373 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1374 if (History.empty())
1376 const MachineInstr *MInsn = History.front();
1379 LexicalScope *Scope = NULL;
1380 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1381 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1382 Scope = LScopes.getCurrentFunctionScope();
1383 else if (MDNode *IA = DV.getInlinedAt())
1384 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1386 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1387 // If variable scope is not found then skip this variable.
1391 Processed.insert(DV);
1392 assert(MInsn->isDebugValue() && "History must begin with debug value");
1393 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1394 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1395 if (!addCurrentFnArgument(MF, RegVar, Scope))
1396 addScopeVariable(Scope, RegVar);
1398 AbsVar->setMInsn(MInsn);
1400 // Simplify ranges that are fully coalesced.
1401 if (History.size() <= 1 || (History.size() == 2 &&
1402 MInsn->isIdenticalTo(History.back()))) {
1403 RegVar->setMInsn(MInsn);
1407 // Handle multiple DBG_VALUE instructions describing one variable.
1408 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1410 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1411 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1412 const MachineInstr *Begin = *HI;
1413 assert(Begin->isDebugValue() && "Invalid History entry");
1415 // Check if DBG_VALUE is truncating a range.
1416 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1417 && !Begin->getOperand(0).getReg())
1420 // Compute the range for a register location.
1421 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1422 const MCSymbol *SLabel = 0;
1425 // If Begin is the last instruction in History then its value is valid
1426 // until the end of the function.
1427 SLabel = FunctionEndSym;
1429 const MachineInstr *End = HI[1];
1430 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1431 << "\t" << *Begin << "\t" << *End << "\n");
1432 if (End->isDebugValue())
1433 SLabel = getLabelBeforeInsn(End);
1435 // End is a normal instruction clobbering the range.
1436 SLabel = getLabelAfterInsn(End);
1437 assert(SLabel && "Forgot label after clobber instruction");
1442 // The value is valid until the next DBG_VALUE or clobber.
1443 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1446 DotDebugLocEntries.push_back(DotDebugLocEntry());
1449 // Collect info for variables that were optimized out.
1450 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1451 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1452 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1453 DIVariable DV(Variables.getElement(i));
1454 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1456 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1457 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1461 // Return Label preceding the instruction.
1462 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1463 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1464 assert(Label && "Didn't insert label before instruction");
1468 // Return Label immediately following the instruction.
1469 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1470 return LabelsAfterInsn.lookup(MI);
1473 // Process beginning of an instruction.
1474 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1475 // Check if source location changes, but ignore DBG_VALUE locations.
1476 if (!MI->isDebugValue()) {
1477 DebugLoc DL = MI->getDebugLoc();
1478 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1481 if (DL == PrologEndLoc) {
1482 Flags |= DWARF2_FLAG_PROLOGUE_END;
1483 PrologEndLoc = DebugLoc();
1485 if (PrologEndLoc.isUnknown())
1486 Flags |= DWARF2_FLAG_IS_STMT;
1488 if (!DL.isUnknown()) {
1489 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1490 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1492 recordSourceLine(0, 0, 0, 0);
1496 // Insert labels where requested.
1497 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1498 LabelsBeforeInsn.find(MI);
1501 if (I == LabelsBeforeInsn.end())
1504 // Label already assigned.
1509 PrevLabel = MMI->getContext().CreateTempSymbol();
1510 Asm->OutStreamer.EmitLabel(PrevLabel);
1512 I->second = PrevLabel;
1515 // Process end of an instruction.
1516 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1517 // Don't create a new label after DBG_VALUE instructions.
1518 // They don't generate code.
1519 if (!MI->isDebugValue())
1522 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1523 LabelsAfterInsn.find(MI);
1526 if (I == LabelsAfterInsn.end())
1529 // Label already assigned.
1533 // We need a label after this instruction.
1535 PrevLabel = MMI->getContext().CreateTempSymbol();
1536 Asm->OutStreamer.EmitLabel(PrevLabel);
1538 I->second = PrevLabel;
1541 // Each LexicalScope has first instruction and last instruction to mark
1542 // beginning and end of a scope respectively. Create an inverse map that list
1543 // scopes starts (and ends) with an instruction. One instruction may start (or
1544 // end) multiple scopes. Ignore scopes that are not reachable.
1545 void DwarfDebug::identifyScopeMarkers() {
1546 SmallVector<LexicalScope *, 4> WorkList;
1547 WorkList.push_back(LScopes.getCurrentFunctionScope());
1548 while (!WorkList.empty()) {
1549 LexicalScope *S = WorkList.pop_back_val();
1551 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1552 if (!Children.empty())
1553 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1554 SE = Children.end(); SI != SE; ++SI)
1555 WorkList.push_back(*SI);
1557 if (S->isAbstractScope())
1560 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1563 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1564 RE = Ranges.end(); RI != RE; ++RI) {
1565 assert(RI->first && "InsnRange does not have first instruction!");
1566 assert(RI->second && "InsnRange does not have second instruction!");
1567 requestLabelBeforeInsn(RI->first);
1568 requestLabelAfterInsn(RI->second);
1573 // Get MDNode for DebugLoc's scope.
1574 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1575 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1576 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1577 return DL.getScope(Ctx);
1580 // Walk up the scope chain of given debug loc and find line number info
1581 // for the function.
1582 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1583 const MDNode *Scope = getScopeNode(DL, Ctx);
1584 DISubprogram SP = getDISubprogram(Scope);
1585 if (SP.isSubprogram()) {
1586 // Check for number of operands since the compatibility is
1588 if (SP->getNumOperands() > 19)
1589 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1591 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1597 // Gather pre-function debug information. Assumes being called immediately
1598 // after the function entry point has been emitted.
1599 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1600 if (!MMI->hasDebugInfo()) return;
1601 LScopes.initialize(*MF);
1602 if (LScopes.empty()) return;
1603 identifyScopeMarkers();
1605 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1607 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1608 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1609 assert(TheCU && "Unable to find compile unit!");
1610 if (Asm->TM.hasMCUseLoc() &&
1611 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1612 // Use a single line table if we are using .loc and generating assembly.
1613 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1615 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1617 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1618 Asm->getFunctionNumber());
1619 // Assumes in correct section after the entry point.
1620 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1622 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1624 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1625 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1626 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1628 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1630 bool AtBlockEntry = true;
1631 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1633 const MachineInstr *MI = II;
1635 if (MI->isDebugValue()) {
1636 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1638 // Keep track of user variables.
1640 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1642 // Variable is in a register, we need to check for clobbers.
1643 if (isDbgValueInDefinedReg(MI))
1644 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1646 // Check the history of this variable.
1647 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1648 if (History.empty()) {
1649 UserVariables.push_back(Var);
1650 // The first mention of a function argument gets the FunctionBeginSym
1651 // label, so arguments are visible when breaking at function entry.
1653 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1654 DISubprogram(getDISubprogram(DV.getContext()))
1655 .describes(MF->getFunction()))
1656 LabelsBeforeInsn[MI] = FunctionBeginSym;
1658 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1659 const MachineInstr *Prev = History.back();
1660 if (Prev->isDebugValue()) {
1661 // Coalesce identical entries at the end of History.
1662 if (History.size() >= 2 &&
1663 Prev->isIdenticalTo(History[History.size() - 2])) {
1664 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1666 << "\t" << *History[History.size() - 2] << "\n");
1670 // Terminate old register assignments that don't reach MI;
1671 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1672 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1673 isDbgValueInDefinedReg(Prev)) {
1674 // Previous register assignment needs to terminate at the end of
1676 MachineBasicBlock::const_iterator LastMI =
1677 PrevMBB->getLastNonDebugInstr();
1678 if (LastMI == PrevMBB->end()) {
1679 // Drop DBG_VALUE for empty range.
1680 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1681 << "\t" << *Prev << "\n");
1683 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1684 // Terminate after LastMI.
1685 History.push_back(LastMI);
1689 History.push_back(MI);
1691 // Not a DBG_VALUE instruction.
1693 AtBlockEntry = false;
1695 // First known non-DBG_VALUE and non-frame setup location marks
1696 // the beginning of the function body.
1697 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1698 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1699 PrologEndLoc = MI->getDebugLoc();
1701 // Check if the instruction clobbers any registers with debug vars.
1702 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1703 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1704 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1706 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1707 AI.isValid(); ++AI) {
1709 const MDNode *Var = LiveUserVar[Reg];
1712 // Reg is now clobbered.
1713 LiveUserVar[Reg] = 0;
1715 // Was MD last defined by a DBG_VALUE referring to Reg?
1716 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1717 if (HistI == DbgValues.end())
1719 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1720 if (History.empty())
1722 const MachineInstr *Prev = History.back();
1723 // Sanity-check: Register assignments are terminated at the end of
1725 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1727 // Is the variable still in Reg?
1728 if (!isDbgValueInDefinedReg(Prev) ||
1729 Prev->getOperand(0).getReg() != Reg)
1731 // Var is clobbered. Make sure the next instruction gets a label.
1732 History.push_back(MI);
1739 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1741 SmallVectorImpl<const MachineInstr*> &History = I->second;
1742 if (History.empty())
1745 // Make sure the final register assignments are terminated.
1746 const MachineInstr *Prev = History.back();
1747 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1748 const MachineBasicBlock *PrevMBB = Prev->getParent();
1749 MachineBasicBlock::const_iterator LastMI =
1750 PrevMBB->getLastNonDebugInstr();
1751 if (LastMI == PrevMBB->end())
1752 // Drop DBG_VALUE for empty range.
1754 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1755 // Terminate after LastMI.
1756 History.push_back(LastMI);
1759 // Request labels for the full history.
1760 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1761 const MachineInstr *MI = History[i];
1762 if (MI->isDebugValue())
1763 requestLabelBeforeInsn(MI);
1765 requestLabelAfterInsn(MI);
1769 PrevInstLoc = DebugLoc();
1770 PrevLabel = FunctionBeginSym;
1772 // Record beginning of function.
1773 if (!PrologEndLoc.isUnknown()) {
1774 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1775 MF->getFunction()->getContext());
1776 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1777 FnStartDL.getScope(MF->getFunction()->getContext()),
1778 // We'd like to list the prologue as "not statements" but GDB behaves
1779 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1780 DWARF2_FLAG_IS_STMT);
1784 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1785 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1786 DIVariable DV = Var->getVariable();
1787 // Variables with positive arg numbers are parameters.
1788 if (unsigned ArgNum = DV.getArgNumber()) {
1789 // Keep all parameters in order at the start of the variable list to ensure
1790 // function types are correct (no out-of-order parameters)
1792 // This could be improved by only doing it for optimized builds (unoptimized
1793 // builds have the right order to begin with), searching from the back (this
1794 // would catch the unoptimized case quickly), or doing a binary search
1795 // rather than linear search.
1796 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1797 while (I != Vars.end()) {
1798 unsigned CurNum = (*I)->getVariable().getArgNumber();
1799 // A local (non-parameter) variable has been found, insert immediately
1803 // A later indexed parameter has been found, insert immediately before it.
1804 if (CurNum > ArgNum)
1808 Vars.insert(I, Var);
1812 Vars.push_back(Var);
1815 // Gather and emit post-function debug information.
1816 void DwarfDebug::endFunction(const MachineFunction *MF) {
1817 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1819 // Define end label for subprogram.
1820 FunctionEndSym = Asm->GetTempSymbol("func_end",
1821 Asm->getFunctionNumber());
1822 // Assumes in correct section after the entry point.
1823 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1824 // Set DwarfCompileUnitID in MCContext to default value.
1825 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1827 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1828 collectVariableInfo(MF, ProcessedVars);
1830 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1831 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1832 assert(TheCU && "Unable to find compile unit!");
1834 // Construct abstract scopes.
1835 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1836 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1837 LexicalScope *AScope = AList[i];
1838 DISubprogram SP(AScope->getScopeNode());
1839 if (SP.isSubprogram()) {
1840 // Collect info for variables that were optimized out.
1841 DIArray Variables = SP.getVariables();
1842 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1843 DIVariable DV(Variables.getElement(i));
1844 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1846 // Check that DbgVariable for DV wasn't created earlier, when
1847 // findAbstractVariable() was called for inlined instance of DV.
1848 LLVMContext &Ctx = DV->getContext();
1849 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1850 if (AbstractVariables.lookup(CleanDV))
1852 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1853 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1856 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1857 constructScopeDIE(TheCU, AScope);
1860 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1862 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1863 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1866 for (ScopeVariablesMap::iterator
1867 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1868 DeleteContainerPointers(I->second);
1869 ScopeVariables.clear();
1870 DeleteContainerPointers(CurrentFnArguments);
1871 UserVariables.clear();
1873 AbstractVariables.clear();
1874 LabelsBeforeInsn.clear();
1875 LabelsAfterInsn.clear();
1879 // Register a source line with debug info. Returns the unique label that was
1880 // emitted and which provides correspondence to the source line list.
1881 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1887 DIDescriptor Scope(S);
1889 if (Scope.isCompileUnit()) {
1890 DICompileUnit CU(S);
1891 Fn = CU.getFilename();
1892 Dir = CU.getDirectory();
1893 } else if (Scope.isFile()) {
1895 Fn = F.getFilename();
1896 Dir = F.getDirectory();
1897 } else if (Scope.isSubprogram()) {
1899 Fn = SP.getFilename();
1900 Dir = SP.getDirectory();
1901 } else if (Scope.isLexicalBlockFile()) {
1902 DILexicalBlockFile DBF(S);
1903 Fn = DBF.getFilename();
1904 Dir = DBF.getDirectory();
1905 } else if (Scope.isLexicalBlock()) {
1906 DILexicalBlock DB(S);
1907 Fn = DB.getFilename();
1908 Dir = DB.getDirectory();
1910 llvm_unreachable("Unexpected scope info");
1912 Src = getOrCreateSourceID(Fn, Dir,
1913 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1915 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1918 //===----------------------------------------------------------------------===//
1920 //===----------------------------------------------------------------------===//
1922 // Compute the size and offset of a DIE.
1924 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1925 // Get the children.
1926 const std::vector<DIE *> &Children = Die->getChildren();
1928 // Record the abbreviation.
1929 assignAbbrevNumber(Die->getAbbrev());
1931 // Get the abbreviation for this DIE.
1932 unsigned AbbrevNumber = Die->getAbbrevNumber();
1933 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1936 Die->setOffset(Offset);
1938 // Start the size with the size of abbreviation code.
1939 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1941 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1942 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1944 // Size the DIE attribute values.
1945 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1946 // Size attribute value.
1947 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1949 // Size the DIE children if any.
1950 if (!Children.empty()) {
1951 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1952 "Children flag not set");
1954 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1955 Offset = computeSizeAndOffset(Children[j], Offset);
1957 // End of children marker.
1958 Offset += sizeof(int8_t);
1961 Die->setSize(Offset - Die->getOffset());
1965 // Compute the size and offset of all the DIEs.
1966 void DwarfUnits::computeSizeAndOffsets() {
1967 // Offset from the beginning of debug info section.
1968 unsigned SecOffset = 0;
1969 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1970 E = CUs.end(); I != E; ++I) {
1971 (*I)->setDebugInfoOffset(SecOffset);
1973 sizeof(int32_t) + // Length of Compilation Unit Info
1974 sizeof(int16_t) + // DWARF version number
1975 sizeof(int32_t) + // Offset Into Abbrev. Section
1976 sizeof(int8_t); // Pointer Size (in bytes)
1978 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1979 SecOffset += EndOffset;
1983 // Emit initial Dwarf sections with a label at the start of each one.
1984 void DwarfDebug::emitSectionLabels() {
1985 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1987 // Dwarf sections base addresses.
1988 DwarfInfoSectionSym =
1989 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1990 DwarfAbbrevSectionSym =
1991 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1992 if (useSplitDwarf())
1993 DwarfAbbrevDWOSectionSym =
1994 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1995 "section_abbrev_dwo");
1996 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1998 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1999 emitSectionSym(Asm, MacroInfo);
2001 DwarfLineSectionSym =
2002 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2003 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2004 if (GenerateDwarfPubNamesSection)
2005 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2006 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2007 DwarfStrSectionSym =
2008 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2009 if (useSplitDwarf()) {
2010 DwarfStrDWOSectionSym =
2011 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2012 DwarfAddrSectionSym =
2013 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2015 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2018 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
2019 "section_debug_loc");
2021 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2022 emitSectionSym(Asm, TLOF.getDataSection());
2025 // Recursively emits a debug information entry.
2026 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
2027 // Get the abbreviation for this DIE.
2028 unsigned AbbrevNumber = Die->getAbbrevNumber();
2029 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
2031 // Emit the code (index) for the abbreviation.
2032 if (Asm->isVerbose())
2033 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2034 Twine::utohexstr(Die->getOffset()) + ":0x" +
2035 Twine::utohexstr(Die->getSize()) + " " +
2036 dwarf::TagString(Abbrev->getTag()));
2037 Asm->EmitULEB128(AbbrevNumber);
2039 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2040 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2042 // Emit the DIE attribute values.
2043 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2044 unsigned Attr = AbbrevData[i].getAttribute();
2045 unsigned Form = AbbrevData[i].getForm();
2046 assert(Form && "Too many attributes for DIE (check abbreviation)");
2048 if (Asm->isVerbose())
2049 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2052 case dwarf::DW_AT_abstract_origin: {
2053 DIEEntry *E = cast<DIEEntry>(Values[i]);
2054 DIE *Origin = E->getEntry();
2055 unsigned Addr = Origin->getOffset();
2056 if (Form == dwarf::DW_FORM_ref_addr) {
2057 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2058 // section. Origin->getOffset() returns the offset from start of the
2060 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2061 Addr += Holder.getCUOffset(Origin->getCompileUnit());
2063 Asm->OutStreamer.EmitIntValue(Addr,
2064 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
2067 case dwarf::DW_AT_ranges: {
2068 // DW_AT_range Value encodes offset in debug_range section.
2069 DIEInteger *V = cast<DIEInteger>(Values[i]);
2071 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2072 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2076 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2078 DwarfDebugRangeSectionSym,
2083 case dwarf::DW_AT_location: {
2084 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2085 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2086 Asm->EmitLabelReference(L->getValue(), 4);
2088 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2090 Values[i]->EmitValue(Asm, Form);
2094 case dwarf::DW_AT_accessibility: {
2095 if (Asm->isVerbose()) {
2096 DIEInteger *V = cast<DIEInteger>(Values[i]);
2097 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2099 Values[i]->EmitValue(Asm, Form);
2103 // Emit an attribute using the defined form.
2104 Values[i]->EmitValue(Asm, Form);
2109 // Emit the DIE children if any.
2110 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2111 const std::vector<DIE *> &Children = Die->getChildren();
2113 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2114 emitDIE(Children[j], Abbrevs);
2116 if (Asm->isVerbose())
2117 Asm->OutStreamer.AddComment("End Of Children Mark");
2122 // Emit the various dwarf units to the unit section USection with
2123 // the abbreviations going into ASection.
2124 void DwarfUnits::emitUnits(DwarfDebug *DD,
2125 const MCSection *USection,
2126 const MCSection *ASection,
2127 const MCSymbol *ASectionSym) {
2128 Asm->OutStreamer.SwitchSection(USection);
2129 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2130 E = CUs.end(); I != E; ++I) {
2131 CompileUnit *TheCU = *I;
2132 DIE *Die = TheCU->getCUDie();
2134 // Emit the compile units header.
2136 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2137 TheCU->getUniqueID()));
2139 // Emit size of content not including length itself
2140 unsigned ContentSize = Die->getSize() +
2141 sizeof(int16_t) + // DWARF version number
2142 sizeof(int32_t) + // Offset Into Abbrev. Section
2143 sizeof(int8_t); // Pointer Size (in bytes)
2145 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2146 Asm->EmitInt32(ContentSize);
2147 Asm->OutStreamer.AddComment("DWARF version number");
2148 Asm->EmitInt16(DD->getDwarfVersion());
2149 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2150 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2152 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2153 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2155 DD->emitDIE(Die, Abbreviations);
2156 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2157 TheCU->getUniqueID()));
2161 /// For a given compile unit DIE, returns offset from beginning of debug info.
2162 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2163 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2164 "Input DIE should be compile unit in getCUOffset.");
2165 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2166 E = CUs.end(); I != E; ++I) {
2167 CompileUnit *TheCU = *I;
2168 if (TheCU->getCUDie() == Die)
2169 return TheCU->getDebugInfoOffset();
2171 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2174 // Emit the debug info section.
2175 void DwarfDebug::emitDebugInfo() {
2176 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2178 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2179 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2180 DwarfAbbrevSectionSym);
2183 // Emit the abbreviation section.
2184 void DwarfDebug::emitAbbreviations() {
2185 if (!useSplitDwarf())
2186 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2189 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2192 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2193 std::vector<DIEAbbrev *> *Abbrevs) {
2194 // Check to see if it is worth the effort.
2195 if (!Abbrevs->empty()) {
2196 // Start the debug abbrev section.
2197 Asm->OutStreamer.SwitchSection(Section);
2199 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2200 Asm->OutStreamer.EmitLabel(Begin);
2202 // For each abbrevation.
2203 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2204 // Get abbreviation data
2205 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2207 // Emit the abbrevations code (base 1 index.)
2208 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2210 // Emit the abbreviations data.
2214 // Mark end of abbreviations.
2215 Asm->EmitULEB128(0, "EOM(3)");
2217 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2218 Asm->OutStreamer.EmitLabel(End);
2222 // Emit the last address of the section and the end of the line matrix.
2223 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2224 // Define last address of section.
2225 Asm->OutStreamer.AddComment("Extended Op");
2228 Asm->OutStreamer.AddComment("Op size");
2229 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2230 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2231 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2233 Asm->OutStreamer.AddComment("Section end label");
2235 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2236 Asm->getDataLayout().getPointerSize());
2238 // Mark end of matrix.
2239 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2245 // Emit visible names into a hashed accelerator table section.
2246 void DwarfDebug::emitAccelNames() {
2247 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2248 dwarf::DW_FORM_data4));
2249 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2250 E = CUMap.end(); I != E; ++I) {
2251 CompileUnit *TheCU = I->second;
2252 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2253 for (StringMap<std::vector<DIE*> >::const_iterator
2254 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2255 StringRef Name = GI->getKey();
2256 const std::vector<DIE *> &Entities = GI->second;
2257 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2258 DE = Entities.end(); DI != DE; ++DI)
2259 AT.AddName(Name, (*DI));
2263 AT.FinalizeTable(Asm, "Names");
2264 Asm->OutStreamer.SwitchSection(
2265 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2266 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2267 Asm->OutStreamer.EmitLabel(SectionBegin);
2269 // Emit the full data.
2270 AT.Emit(Asm, SectionBegin, &InfoHolder);
2273 // Emit objective C classes and categories into a hashed accelerator table
2275 void DwarfDebug::emitAccelObjC() {
2276 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2277 dwarf::DW_FORM_data4));
2278 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2279 E = CUMap.end(); I != E; ++I) {
2280 CompileUnit *TheCU = I->second;
2281 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2282 for (StringMap<std::vector<DIE*> >::const_iterator
2283 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2284 StringRef Name = GI->getKey();
2285 const std::vector<DIE *> &Entities = GI->second;
2286 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2287 DE = Entities.end(); DI != DE; ++DI)
2288 AT.AddName(Name, (*DI));
2292 AT.FinalizeTable(Asm, "ObjC");
2293 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2294 .getDwarfAccelObjCSection());
2295 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2296 Asm->OutStreamer.EmitLabel(SectionBegin);
2298 // Emit the full data.
2299 AT.Emit(Asm, SectionBegin, &InfoHolder);
2302 // Emit namespace dies into a hashed accelerator table.
2303 void DwarfDebug::emitAccelNamespaces() {
2304 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2305 dwarf::DW_FORM_data4));
2306 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2307 E = CUMap.end(); I != E; ++I) {
2308 CompileUnit *TheCU = I->second;
2309 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2310 for (StringMap<std::vector<DIE*> >::const_iterator
2311 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2312 StringRef Name = GI->getKey();
2313 const std::vector<DIE *> &Entities = GI->second;
2314 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2315 DE = Entities.end(); DI != DE; ++DI)
2316 AT.AddName(Name, (*DI));
2320 AT.FinalizeTable(Asm, "namespac");
2321 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2322 .getDwarfAccelNamespaceSection());
2323 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2324 Asm->OutStreamer.EmitLabel(SectionBegin);
2326 // Emit the full data.
2327 AT.Emit(Asm, SectionBegin, &InfoHolder);
2330 // Emit type dies into a hashed accelerator table.
2331 void DwarfDebug::emitAccelTypes() {
2332 std::vector<DwarfAccelTable::Atom> Atoms;
2333 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2334 dwarf::DW_FORM_data4));
2335 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2336 dwarf::DW_FORM_data2));
2337 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2338 dwarf::DW_FORM_data1));
2339 DwarfAccelTable AT(Atoms);
2340 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2341 E = CUMap.end(); I != E; ++I) {
2342 CompileUnit *TheCU = I->second;
2343 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2344 = TheCU->getAccelTypes();
2345 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2346 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2347 StringRef Name = GI->getKey();
2348 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2349 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2350 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2351 AT.AddName(Name, (*DI).first, (*DI).second);
2355 AT.FinalizeTable(Asm, "types");
2356 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2357 .getDwarfAccelTypesSection());
2358 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2359 Asm->OutStreamer.EmitLabel(SectionBegin);
2361 // Emit the full data.
2362 AT.Emit(Asm, SectionBegin, &InfoHolder);
2365 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2367 void DwarfDebug::emitDebugPubnames() {
2368 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2370 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2371 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2372 CompileUnit *TheCU = I->second;
2373 unsigned ID = TheCU->getUniqueID();
2375 if (TheCU->getGlobalNames().empty())
2378 // Start the dwarf pubnames section.
2379 Asm->OutStreamer.SwitchSection(
2380 Asm->getObjFileLowering().getDwarfPubNamesSection());
2382 Asm->OutStreamer.AddComment("Length of Public Names Info");
2383 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2384 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2386 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2388 Asm->OutStreamer.AddComment("DWARF Version");
2389 Asm->EmitInt16(DwarfVersion);
2391 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2392 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2393 DwarfInfoSectionSym);
2395 Asm->OutStreamer.AddComment("Compilation Unit Length");
2396 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2397 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2400 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2401 for (StringMap<DIE*>::const_iterator
2402 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2403 const char *Name = GI->getKeyData();
2404 const DIE *Entity = GI->second;
2406 Asm->OutStreamer.AddComment("DIE offset");
2407 Asm->EmitInt32(Entity->getOffset());
2409 if (Asm->isVerbose())
2410 Asm->OutStreamer.AddComment("External Name");
2411 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2414 Asm->OutStreamer.AddComment("End Mark");
2416 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2420 void DwarfDebug::emitDebugPubTypes() {
2421 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2422 E = CUMap.end(); I != E; ++I) {
2423 CompileUnit *TheCU = I->second;
2424 // Start the dwarf pubtypes section.
2425 Asm->OutStreamer.SwitchSection(
2426 Asm->getObjFileLowering().getDwarfPubTypesSection());
2427 Asm->OutStreamer.AddComment("Length of Public Types Info");
2428 Asm->EmitLabelDifference(
2429 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2430 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2432 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2433 TheCU->getUniqueID()));
2435 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2436 Asm->EmitInt16(DwarfVersion);
2438 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2439 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2440 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2441 TheCU->getUniqueID()),
2442 DwarfInfoSectionSym);
2444 Asm->OutStreamer.AddComment("Compilation Unit Length");
2445 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2446 TheCU->getUniqueID()),
2447 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2448 TheCU->getUniqueID()),
2451 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2452 for (StringMap<DIE*>::const_iterator
2453 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2454 const char *Name = GI->getKeyData();
2455 DIE *Entity = GI->second;
2457 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2458 Asm->EmitInt32(Entity->getOffset());
2460 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2461 // Emit the name with a terminating null byte.
2462 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2465 Asm->OutStreamer.AddComment("End Mark");
2467 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2468 TheCU->getUniqueID()));
2472 // Emit strings into a string section.
2473 void DwarfUnits::emitStrings(const MCSection *StrSection,
2474 const MCSection *OffsetSection = NULL,
2475 const MCSymbol *StrSecSym = NULL) {
2477 if (StringPool.empty()) return;
2479 // Start the dwarf str section.
2480 Asm->OutStreamer.SwitchSection(StrSection);
2482 // Get all of the string pool entries and put them in an array by their ID so
2483 // we can sort them.
2484 SmallVector<std::pair<unsigned,
2485 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2487 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2488 I = StringPool.begin(), E = StringPool.end();
2490 Entries.push_back(std::make_pair(I->second.second, &*I));
2492 array_pod_sort(Entries.begin(), Entries.end());
2494 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2495 // Emit a label for reference from debug information entries.
2496 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2498 // Emit the string itself with a terminating null byte.
2499 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2500 Entries[i].second->getKeyLength()+1));
2503 // If we've got an offset section go ahead and emit that now as well.
2504 if (OffsetSection) {
2505 Asm->OutStreamer.SwitchSection(OffsetSection);
2506 unsigned offset = 0;
2507 unsigned size = 4; // FIXME: DWARF64 is 8.
2508 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2509 Asm->OutStreamer.EmitIntValue(offset, size);
2510 offset += Entries[i].second->getKeyLength() + 1;
2515 // Emit strings into a string section.
2516 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2518 if (AddressPool.empty()) return;
2520 // Start the dwarf addr section.
2521 Asm->OutStreamer.SwitchSection(AddrSection);
2523 // Order the address pool entries by ID
2524 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2526 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2527 E = AddressPool.end();
2529 Entries[I->second] = I->first;
2531 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2532 // Emit an expression for reference from debug information entries.
2533 if (const MCExpr *Expr = Entries[i])
2534 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2536 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2541 // Emit visible names into a debug str section.
2542 void DwarfDebug::emitDebugStr() {
2543 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2544 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2547 // Emit locations into the debug loc section.
2548 void DwarfDebug::emitDebugLoc() {
2549 if (DotDebugLocEntries.empty())
2552 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2553 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2555 DotDebugLocEntry &Entry = *I;
2556 if (I + 1 != DotDebugLocEntries.end())
2560 // Start the dwarf loc section.
2561 Asm->OutStreamer.SwitchSection(
2562 Asm->getObjFileLowering().getDwarfLocSection());
2563 unsigned char Size = Asm->getDataLayout().getPointerSize();
2564 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2566 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2567 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2568 I != E; ++I, ++index) {
2569 DotDebugLocEntry &Entry = *I;
2570 if (Entry.isMerged()) continue;
2571 if (Entry.isEmpty()) {
2572 Asm->OutStreamer.EmitIntValue(0, Size);
2573 Asm->OutStreamer.EmitIntValue(0, Size);
2574 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2576 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2577 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2578 DIVariable DV(Entry.getVariable());
2579 Asm->OutStreamer.AddComment("Loc expr size");
2580 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2581 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2582 Asm->EmitLabelDifference(end, begin, 2);
2583 Asm->OutStreamer.EmitLabel(begin);
2584 if (Entry.isInt()) {
2585 DIBasicType BTy(DV.getType());
2587 (BTy.getEncoding() == dwarf::DW_ATE_signed
2588 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2589 Asm->OutStreamer.AddComment("DW_OP_consts");
2590 Asm->EmitInt8(dwarf::DW_OP_consts);
2591 Asm->EmitSLEB128(Entry.getInt());
2593 Asm->OutStreamer.AddComment("DW_OP_constu");
2594 Asm->EmitInt8(dwarf::DW_OP_constu);
2595 Asm->EmitULEB128(Entry.getInt());
2597 } else if (Entry.isLocation()) {
2598 MachineLocation Loc = Entry.getLoc();
2599 if (!DV.hasComplexAddress())
2601 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2603 // Complex address entry.
2604 unsigned N = DV.getNumAddrElements();
2606 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2607 if (Loc.getOffset()) {
2609 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2610 Asm->OutStreamer.AddComment("DW_OP_deref");
2611 Asm->EmitInt8(dwarf::DW_OP_deref);
2612 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2613 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2614 Asm->EmitSLEB128(DV.getAddrElement(1));
2616 // If first address element is OpPlus then emit
2617 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2618 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2619 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2623 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2626 // Emit remaining complex address elements.
2627 for (; i < N; ++i) {
2628 uint64_t Element = DV.getAddrElement(i);
2629 if (Element == DIBuilder::OpPlus) {
2630 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2631 Asm->EmitULEB128(DV.getAddrElement(++i));
2632 } else if (Element == DIBuilder::OpDeref) {
2634 Asm->EmitInt8(dwarf::DW_OP_deref);
2636 llvm_unreachable("unknown Opcode found in complex address");
2640 // else ... ignore constant fp. There is not any good way to
2641 // to represent them here in dwarf.
2642 Asm->OutStreamer.EmitLabel(end);
2647 // Emit visible names into a debug aranges section.
2648 void DwarfDebug::emitDebugARanges() {
2649 // Start the dwarf aranges section.
2650 Asm->OutStreamer.SwitchSection(
2651 Asm->getObjFileLowering().getDwarfARangesSection());
2654 // Emit visible names into a debug ranges section.
2655 void DwarfDebug::emitDebugRanges() {
2656 // Start the dwarf ranges section.
2657 Asm->OutStreamer.SwitchSection(
2658 Asm->getObjFileLowering().getDwarfRangesSection());
2659 unsigned char Size = Asm->getDataLayout().getPointerSize();
2660 for (SmallVectorImpl<const MCSymbol *>::iterator
2661 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2664 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2666 Asm->OutStreamer.EmitIntValue(0, Size);
2670 // Emit visible names into a debug macinfo section.
2671 void DwarfDebug::emitDebugMacInfo() {
2672 if (const MCSection *LineInfo =
2673 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2674 // Start the dwarf macinfo section.
2675 Asm->OutStreamer.SwitchSection(LineInfo);
2679 // Emit inline info using following format.
2681 // 1. length of section
2682 // 2. Dwarf version number
2685 // Entries (one "entry" for each function that was inlined):
2687 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2688 // otherwise offset into __debug_str for regular function name.
2689 // 2. offset into __debug_str section for regular function name.
2690 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2691 // instances for the function.
2693 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2694 // inlined instance; the die_offset points to the inlined_subroutine die in the
2695 // __debug_info section, and the low_pc is the starting address for the
2696 // inlining instance.
2697 void DwarfDebug::emitDebugInlineInfo() {
2698 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2704 Asm->OutStreamer.SwitchSection(
2705 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2707 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2708 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2709 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2711 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2713 Asm->OutStreamer.AddComment("Dwarf Version");
2714 Asm->EmitInt16(DwarfVersion);
2715 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2716 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2718 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2719 E = InlinedSPNodes.end(); I != E; ++I) {
2721 const MDNode *Node = *I;
2722 InlineInfoMap::iterator II = InlineInfo.find(Node);
2723 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2724 DISubprogram SP(Node);
2725 StringRef LName = SP.getLinkageName();
2726 StringRef Name = SP.getName();
2728 Asm->OutStreamer.AddComment("MIPS linkage name");
2730 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2731 DwarfStrSectionSym);
2733 Asm->EmitSectionOffset(
2734 InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2735 DwarfStrSectionSym);
2737 Asm->OutStreamer.AddComment("Function name");
2738 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2739 DwarfStrSectionSym);
2740 Asm->EmitULEB128(Labels.size(), "Inline count");
2742 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2743 LE = Labels.end(); LI != LE; ++LI) {
2744 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2745 Asm->EmitInt32(LI->second->getOffset());
2747 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2748 Asm->OutStreamer.EmitSymbolValue(LI->first,
2749 Asm->getDataLayout().getPointerSize());
2753 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2756 // DWARF5 Experimental Separate Dwarf emitters.
2758 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2759 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2760 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2761 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2762 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2763 DICompileUnit DIUnit(N);
2764 CompilationDir = DIUnit.getDirectory();
2766 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2767 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2768 DIUnit.getLanguage(), Die, N, Asm,
2769 this, &SkeletonHolder);
2771 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2772 DIUnit.getSplitDebugFilename());
2774 // This should be a unique identifier when we want to build .dwp files.
2775 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2777 // Relocate to the beginning of the addr_base section, else 0 for the
2778 // beginning of the one for this compile unit.
2779 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2780 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2781 DwarfAddrSectionSym);
2783 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2784 dwarf::DW_FORM_sec_offset, 0);
2786 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2787 // into an entity. We're using 0, or a NULL label for this.
2788 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2790 // DW_AT_stmt_list is a offset of line number information for this
2791 // compile unit in debug_line section.
2792 // FIXME: Should handle multiple compile units.
2793 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2794 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2795 DwarfLineSectionSym);
2797 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2799 if (!CompilationDir.empty())
2800 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2802 SkeletonHolder.addUnit(NewCU);
2803 SkeletonCUs.push_back(NewCU);
2808 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2809 assert(useSplitDwarf() && "No split dwarf debug info?");
2810 emitAbbrevs(Section, &SkeletonAbbrevs);
2813 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2814 // compile units that would normally be in debug_info.
2815 void DwarfDebug::emitDebugInfoDWO() {
2816 assert(useSplitDwarf() && "No split dwarf debug info?");
2817 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2818 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2819 DwarfAbbrevDWOSectionSym);
2822 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2823 // abbreviations for the .debug_info.dwo section.
2824 void DwarfDebug::emitDebugAbbrevDWO() {
2825 assert(useSplitDwarf() && "No split dwarf?");
2826 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2830 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2831 // string section and is identical in format to traditional .debug_str
2833 void DwarfDebug::emitDebugStrDWO() {
2834 assert(useSplitDwarf() && "No split dwarf?");
2835 const MCSection *OffSec = Asm->getObjFileLowering()
2836 .getDwarfStrOffDWOSection();
2837 const MCSymbol *StrSym = DwarfStrSectionSym;
2838 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),