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 uint16_t 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 uint16_t 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 [7.27] 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. Returns "" if the attribute doesn't exist.
970 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
971 DIEValue *V = Die->findAttribute(Attr);
973 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
974 return S->getString();
976 return StringRef("");
979 /// \brief Adds the string in \p Str to the hash in \p Hash. This also hashes
980 /// a trailing NULL with the string.
981 static void addStringToHash(MD5 &Hash, StringRef Str) {
982 DEBUG(dbgs() << "Adding string " << Str << " to hash.\n");
984 Hash.update(makeArrayRef((uint8_t)'\0'));
987 // FIXME: These are copied and only slightly modified out of LEB128.h.
989 /// \brief Adds the unsigned in \p N to the hash in \p Hash. This also encodes
990 /// the unsigned as a ULEB128.
991 static void addULEB128ToHash(MD5 &Hash, uint64_t Value) {
992 DEBUG(dbgs() << "Adding ULEB128 " << Value << " to hash.\n");
994 uint8_t Byte = Value & 0x7f;
997 Byte |= 0x80; // Mark this byte to show that more bytes will follow.
999 } while (Value != 0);
1002 /// \brief Including \p Parent adds the context of Parent to \p Hash.
1003 static void addParentContextToHash(MD5 &Hash, DIE *Parent) {
1005 DEBUG(dbgs() << "Adding parent context to hash...\n");
1007 // [7.27.2] For each surrounding type or namespace beginning with the
1008 // outermost such construct...
1009 SmallVector<DIE *, 1> Parents;
1010 while (Parent->getTag() != dwarf::DW_TAG_compile_unit) {
1011 Parents.push_back(Parent);
1012 Parent = Parent->getParent();
1015 // Reverse iterate over our list to go from the outermost construct to the
1017 for (SmallVectorImpl<DIE *>::reverse_iterator I = Parents.rbegin(),
1022 // ... Append the letter "C" to the sequence...
1023 addULEB128ToHash(Hash, 'C');
1025 // ... Followed by the DWARF tag of the construct...
1026 addULEB128ToHash(Hash, Die->getTag());
1028 // ... Then the name, taken from the DW_AT_name attribute.
1029 StringRef Name = getDIEStringAttr(Die, dwarf::DW_AT_name);
1030 DEBUG(dbgs() << "... adding context: " << Name << "\n");
1032 addStringToHash(Hash, Name);
1036 /// This is based on the type signature computation given in section 7.27 of the
1037 /// DWARF4 standard. It is the md5 hash of a flattened description of the DIE with
1038 /// the exception that we are hashing only the context and the name of the type.
1039 static void addDIEODRSignature(MD5 &Hash, CompileUnit *CU, DIE *Die) {
1041 // Add the contexts to the hash. We won't be computing the ODR hash for
1042 // function local types so it's safe to use the generic context hashing
1044 // FIXME: If we figure out how to account for linkage in some way we could
1045 // actually do this with a slight modification to the parent hash algorithm.
1046 DIE *Parent = Die->getParent();
1048 addParentContextToHash(Hash, Parent);
1050 // Add the current DIE information.
1052 // Add the DWARF tag of the DIE.
1053 addULEB128ToHash(Hash, Die->getTag());
1055 // Add the name of the type to the hash.
1056 addStringToHash(Hash, getDIEStringAttr(Die, dwarf::DW_AT_name));
1058 // Now get the result.
1059 MD5::MD5Result Result;
1062 // ... take the least significant 8 bytes and store those as the attribute.
1063 // Our MD5 implementation always returns its results in little endian, swap
1064 // bytes appropriately.
1065 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
1067 // FIXME: This should be added onto the type unit, not the type, but this
1068 // works as an intermediate stage.
1069 CU->addUInt(Die, dwarf::DW_AT_GNU_odr_signature, dwarf::DW_FORM_data8,
1073 /// Return true if the current DIE is contained within an anonymous namespace.
1074 static bool isContainedInAnonNamespace(DIE *Die) {
1075 DIE *Parent = Die->getParent();
1078 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1079 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1081 Parent = Parent->getParent();
1087 /// Test if the current CU language is C++ and that we have
1088 /// a named type that is not contained in an anonymous namespace.
1089 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
1090 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1091 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1092 !isContainedInAnonNamespace(Die);
1095 void DwarfDebug::finalizeModuleInfo() {
1096 // Collect info for variables that were optimized out.
1097 collectDeadVariables();
1099 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1100 computeInlinedDIEs();
1102 // Emit DW_AT_containing_type attribute to connect types with their
1103 // vtable holding type.
1104 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1105 CUE = CUMap.end(); CUI != CUE; ++CUI) {
1106 CompileUnit *TheCU = CUI->second;
1107 TheCU->constructContainingTypeDIEs();
1110 // Split out type units and conditionally add an ODR tag to the split
1112 // FIXME: Do type splitting.
1113 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1115 DIE *Die = TypeUnits[i];
1116 // If we've requested ODR hashes and it's applicable for an ODR hash then
1117 // add the ODR signature now.
1118 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1119 addDIEODRSignature(Hash, CUMap.begin()->second, Die);
1122 // Compute DIE offsets and sizes.
1123 InfoHolder.computeSizeAndOffsets();
1124 if (useSplitDwarf())
1125 SkeletonHolder.computeSizeAndOffsets();
1128 void DwarfDebug::endSections() {
1129 // Standard sections final addresses.
1130 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1131 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1132 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1133 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1135 // End text sections.
1136 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1137 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1138 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1142 // Emit all Dwarf sections that should come after the content.
1143 void DwarfDebug::endModule() {
1145 if (!FirstCU) return;
1147 // End any existing sections.
1148 // TODO: Does this need to happen?
1151 // Finalize the debug info for the module.
1152 finalizeModuleInfo();
1154 if (!useSplitDwarf()) {
1155 // Emit all the DIEs into a debug info section.
1158 // Corresponding abbreviations into a abbrev section.
1159 emitAbbreviations();
1161 // Emit info into a debug loc section.
1164 // Emit info into a debug aranges section.
1167 // Emit info into a debug ranges section.
1170 // Emit info into a debug macinfo section.
1173 // Emit inline info.
1174 // TODO: When we don't need the option anymore we
1175 // can remove all of the code that this section
1177 if (useDarwinGDBCompat())
1178 emitDebugInlineInfo();
1180 // TODO: Fill this in for separated debug sections and separate
1181 // out information into new sections.
1183 // Emit the debug info section and compile units.
1187 // Corresponding abbreviations into a abbrev section.
1188 emitAbbreviations();
1189 emitDebugAbbrevDWO();
1191 // Emit info into a debug loc section.
1194 // Emit info into a debug aranges section.
1197 // Emit info into a debug ranges section.
1200 // Emit info into a debug macinfo section.
1203 // Emit DWO addresses.
1204 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1206 // Emit inline info.
1207 // TODO: When we don't need the option anymore we
1208 // can remove all of the code that this section
1210 if (useDarwinGDBCompat())
1211 emitDebugInlineInfo();
1214 // Emit info into the dwarf accelerator table sections.
1215 if (useDwarfAccelTables()) {
1218 emitAccelNamespaces();
1222 // Emit info into a debug pubnames section, if requested.
1223 if (GenerateDwarfPubNamesSection)
1224 emitDebugPubnames();
1226 // Emit info into a debug pubtypes section.
1227 // TODO: When we don't need the option anymore we can
1228 // remove all of the code that adds to the table.
1229 if (useDarwinGDBCompat())
1230 emitDebugPubTypes();
1232 // Finally emit string information into a string table.
1234 if (useSplitDwarf())
1239 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1240 E = CUMap.end(); I != E; ++I)
1243 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1244 E = SkeletonCUs.end(); I != E; ++I)
1247 // Reset these for the next Module if we have one.
1251 // Find abstract variable, if any, associated with Var.
1252 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1253 DebugLoc ScopeLoc) {
1254 LLVMContext &Ctx = DV->getContext();
1255 // More then one inlined variable corresponds to one abstract variable.
1256 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1257 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1259 return AbsDbgVariable;
1261 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1265 AbsDbgVariable = new DbgVariable(Var, NULL);
1266 addScopeVariable(Scope, AbsDbgVariable);
1267 AbstractVariables[Var] = AbsDbgVariable;
1268 return AbsDbgVariable;
1271 // If Var is a current function argument then add it to CurrentFnArguments list.
1272 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1273 DbgVariable *Var, LexicalScope *Scope) {
1274 if (!LScopes.isCurrentFunctionScope(Scope))
1276 DIVariable DV = Var->getVariable();
1277 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1279 unsigned ArgNo = DV.getArgNumber();
1283 size_t Size = CurrentFnArguments.size();
1285 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1286 // llvm::Function argument size is not good indicator of how many
1287 // arguments does the function have at source level.
1289 CurrentFnArguments.resize(ArgNo * 2);
1290 CurrentFnArguments[ArgNo - 1] = Var;
1294 // Collect variable information from side table maintained by MMI.
1296 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1297 SmallPtrSet<const MDNode *, 16> &Processed) {
1298 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1299 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1300 VE = VMap.end(); VI != VE; ++VI) {
1301 const MDNode *Var = VI->first;
1303 Processed.insert(Var);
1305 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1307 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1309 // If variable scope is not found then skip this variable.
1313 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1314 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1315 RegVar->setFrameIndex(VP.first);
1316 if (!addCurrentFnArgument(MF, RegVar, Scope))
1317 addScopeVariable(Scope, RegVar);
1319 AbsDbgVariable->setFrameIndex(VP.first);
1323 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1325 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1326 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1327 return MI->getNumOperands() == 3 &&
1328 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1329 (MI->getOperand(1).isImm() ||
1330 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1333 // Get .debug_loc entry for the instruction range starting at MI.
1334 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1335 const MCSymbol *FLabel,
1336 const MCSymbol *SLabel,
1337 const MachineInstr *MI) {
1338 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1340 assert(MI->getNumOperands() == 3);
1341 if (MI->getOperand(0).isReg()) {
1342 MachineLocation MLoc;
1343 // If the second operand is an immediate, this is a
1344 // register-indirect address.
1345 if (!MI->getOperand(1).isImm())
1346 MLoc.set(MI->getOperand(0).getReg());
1348 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1349 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1351 if (MI->getOperand(0).isImm())
1352 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1353 if (MI->getOperand(0).isFPImm())
1354 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1355 if (MI->getOperand(0).isCImm())
1356 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1358 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1361 // Find variables for each lexical scope.
1363 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1364 SmallPtrSet<const MDNode *, 16> &Processed) {
1366 // Grab the variable info that was squirreled away in the MMI side-table.
1367 collectVariableInfoFromMMITable(MF, Processed);
1369 for (SmallVectorImpl<const MDNode*>::const_iterator
1370 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1372 const MDNode *Var = *UVI;
1373 if (Processed.count(Var))
1376 // History contains relevant DBG_VALUE instructions for Var and instructions
1378 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1379 if (History.empty())
1381 const MachineInstr *MInsn = History.front();
1384 LexicalScope *Scope = NULL;
1385 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1386 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1387 Scope = LScopes.getCurrentFunctionScope();
1388 else if (MDNode *IA = DV.getInlinedAt())
1389 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1391 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1392 // If variable scope is not found then skip this variable.
1396 Processed.insert(DV);
1397 assert(MInsn->isDebugValue() && "History must begin with debug value");
1398 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1399 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1400 if (!addCurrentFnArgument(MF, RegVar, Scope))
1401 addScopeVariable(Scope, RegVar);
1403 AbsVar->setMInsn(MInsn);
1405 // Simplify ranges that are fully coalesced.
1406 if (History.size() <= 1 || (History.size() == 2 &&
1407 MInsn->isIdenticalTo(History.back()))) {
1408 RegVar->setMInsn(MInsn);
1412 // Handle multiple DBG_VALUE instructions describing one variable.
1413 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1415 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1416 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1417 const MachineInstr *Begin = *HI;
1418 assert(Begin->isDebugValue() && "Invalid History entry");
1420 // Check if DBG_VALUE is truncating a range.
1421 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1422 && !Begin->getOperand(0).getReg())
1425 // Compute the range for a register location.
1426 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1427 const MCSymbol *SLabel = 0;
1430 // If Begin is the last instruction in History then its value is valid
1431 // until the end of the function.
1432 SLabel = FunctionEndSym;
1434 const MachineInstr *End = HI[1];
1435 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1436 << "\t" << *Begin << "\t" << *End << "\n");
1437 if (End->isDebugValue())
1438 SLabel = getLabelBeforeInsn(End);
1440 // End is a normal instruction clobbering the range.
1441 SLabel = getLabelAfterInsn(End);
1442 assert(SLabel && "Forgot label after clobber instruction");
1447 // The value is valid until the next DBG_VALUE or clobber.
1448 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1451 DotDebugLocEntries.push_back(DotDebugLocEntry());
1454 // Collect info for variables that were optimized out.
1455 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1456 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1457 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1458 DIVariable DV(Variables.getElement(i));
1459 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1461 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1462 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1466 // Return Label preceding the instruction.
1467 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1468 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1469 assert(Label && "Didn't insert label before instruction");
1473 // Return Label immediately following the instruction.
1474 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1475 return LabelsAfterInsn.lookup(MI);
1478 // Process beginning of an instruction.
1479 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1480 // Check if source location changes, but ignore DBG_VALUE locations.
1481 if (!MI->isDebugValue()) {
1482 DebugLoc DL = MI->getDebugLoc();
1483 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1486 if (DL == PrologEndLoc) {
1487 Flags |= DWARF2_FLAG_PROLOGUE_END;
1488 PrologEndLoc = DebugLoc();
1490 if (PrologEndLoc.isUnknown())
1491 Flags |= DWARF2_FLAG_IS_STMT;
1493 if (!DL.isUnknown()) {
1494 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1495 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1497 recordSourceLine(0, 0, 0, 0);
1501 // Insert labels where requested.
1502 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1503 LabelsBeforeInsn.find(MI);
1506 if (I == LabelsBeforeInsn.end())
1509 // Label already assigned.
1514 PrevLabel = MMI->getContext().CreateTempSymbol();
1515 Asm->OutStreamer.EmitLabel(PrevLabel);
1517 I->second = PrevLabel;
1520 // Process end of an instruction.
1521 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1522 // Don't create a new label after DBG_VALUE instructions.
1523 // They don't generate code.
1524 if (!MI->isDebugValue())
1527 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1528 LabelsAfterInsn.find(MI);
1531 if (I == LabelsAfterInsn.end())
1534 // Label already assigned.
1538 // We need a label after this instruction.
1540 PrevLabel = MMI->getContext().CreateTempSymbol();
1541 Asm->OutStreamer.EmitLabel(PrevLabel);
1543 I->second = PrevLabel;
1546 // Each LexicalScope has first instruction and last instruction to mark
1547 // beginning and end of a scope respectively. Create an inverse map that list
1548 // scopes starts (and ends) with an instruction. One instruction may start (or
1549 // end) multiple scopes. Ignore scopes that are not reachable.
1550 void DwarfDebug::identifyScopeMarkers() {
1551 SmallVector<LexicalScope *, 4> WorkList;
1552 WorkList.push_back(LScopes.getCurrentFunctionScope());
1553 while (!WorkList.empty()) {
1554 LexicalScope *S = WorkList.pop_back_val();
1556 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1557 if (!Children.empty())
1558 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1559 SE = Children.end(); SI != SE; ++SI)
1560 WorkList.push_back(*SI);
1562 if (S->isAbstractScope())
1565 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1568 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1569 RE = Ranges.end(); RI != RE; ++RI) {
1570 assert(RI->first && "InsnRange does not have first instruction!");
1571 assert(RI->second && "InsnRange does not have second instruction!");
1572 requestLabelBeforeInsn(RI->first);
1573 requestLabelAfterInsn(RI->second);
1578 // Get MDNode for DebugLoc's scope.
1579 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1580 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1581 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1582 return DL.getScope(Ctx);
1585 // Walk up the scope chain of given debug loc and find line number info
1586 // for the function.
1587 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1588 const MDNode *Scope = getScopeNode(DL, Ctx);
1589 DISubprogram SP = getDISubprogram(Scope);
1590 if (SP.isSubprogram()) {
1591 // Check for number of operands since the compatibility is
1593 if (SP->getNumOperands() > 19)
1594 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1596 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1602 // Gather pre-function debug information. Assumes being called immediately
1603 // after the function entry point has been emitted.
1604 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1605 if (!MMI->hasDebugInfo()) return;
1606 LScopes.initialize(*MF);
1607 if (LScopes.empty()) return;
1608 identifyScopeMarkers();
1610 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1612 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1613 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1614 assert(TheCU && "Unable to find compile unit!");
1615 if (Asm->TM.hasMCUseLoc() &&
1616 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1617 // Use a single line table if we are using .loc and generating assembly.
1618 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1620 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1622 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1623 Asm->getFunctionNumber());
1624 // Assumes in correct section after the entry point.
1625 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1627 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1629 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1630 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1631 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1633 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1635 bool AtBlockEntry = true;
1636 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1638 const MachineInstr *MI = II;
1640 if (MI->isDebugValue()) {
1641 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1643 // Keep track of user variables.
1645 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1647 // Variable is in a register, we need to check for clobbers.
1648 if (isDbgValueInDefinedReg(MI))
1649 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1651 // Check the history of this variable.
1652 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1653 if (History.empty()) {
1654 UserVariables.push_back(Var);
1655 // The first mention of a function argument gets the FunctionBeginSym
1656 // label, so arguments are visible when breaking at function entry.
1658 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1659 DISubprogram(getDISubprogram(DV.getContext()))
1660 .describes(MF->getFunction()))
1661 LabelsBeforeInsn[MI] = FunctionBeginSym;
1663 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1664 const MachineInstr *Prev = History.back();
1665 if (Prev->isDebugValue()) {
1666 // Coalesce identical entries at the end of History.
1667 if (History.size() >= 2 &&
1668 Prev->isIdenticalTo(History[History.size() - 2])) {
1669 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1671 << "\t" << *History[History.size() - 2] << "\n");
1675 // Terminate old register assignments that don't reach MI;
1676 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1677 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1678 isDbgValueInDefinedReg(Prev)) {
1679 // Previous register assignment needs to terminate at the end of
1681 MachineBasicBlock::const_iterator LastMI =
1682 PrevMBB->getLastNonDebugInstr();
1683 if (LastMI == PrevMBB->end()) {
1684 // Drop DBG_VALUE for empty range.
1685 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1686 << "\t" << *Prev << "\n");
1688 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1689 // Terminate after LastMI.
1690 History.push_back(LastMI);
1694 History.push_back(MI);
1696 // Not a DBG_VALUE instruction.
1698 AtBlockEntry = false;
1700 // First known non-DBG_VALUE and non-frame setup location marks
1701 // the beginning of the function body.
1702 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1703 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1704 PrologEndLoc = MI->getDebugLoc();
1706 // Check if the instruction clobbers any registers with debug vars.
1707 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1708 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1709 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1711 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1712 AI.isValid(); ++AI) {
1714 const MDNode *Var = LiveUserVar[Reg];
1717 // Reg is now clobbered.
1718 LiveUserVar[Reg] = 0;
1720 // Was MD last defined by a DBG_VALUE referring to Reg?
1721 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1722 if (HistI == DbgValues.end())
1724 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1725 if (History.empty())
1727 const MachineInstr *Prev = History.back();
1728 // Sanity-check: Register assignments are terminated at the end of
1730 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1732 // Is the variable still in Reg?
1733 if (!isDbgValueInDefinedReg(Prev) ||
1734 Prev->getOperand(0).getReg() != Reg)
1736 // Var is clobbered. Make sure the next instruction gets a label.
1737 History.push_back(MI);
1744 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1746 SmallVectorImpl<const MachineInstr*> &History = I->second;
1747 if (History.empty())
1750 // Make sure the final register assignments are terminated.
1751 const MachineInstr *Prev = History.back();
1752 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1753 const MachineBasicBlock *PrevMBB = Prev->getParent();
1754 MachineBasicBlock::const_iterator LastMI =
1755 PrevMBB->getLastNonDebugInstr();
1756 if (LastMI == PrevMBB->end())
1757 // Drop DBG_VALUE for empty range.
1759 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1760 // Terminate after LastMI.
1761 History.push_back(LastMI);
1764 // Request labels for the full history.
1765 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1766 const MachineInstr *MI = History[i];
1767 if (MI->isDebugValue())
1768 requestLabelBeforeInsn(MI);
1770 requestLabelAfterInsn(MI);
1774 PrevInstLoc = DebugLoc();
1775 PrevLabel = FunctionBeginSym;
1777 // Record beginning of function.
1778 if (!PrologEndLoc.isUnknown()) {
1779 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1780 MF->getFunction()->getContext());
1781 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1782 FnStartDL.getScope(MF->getFunction()->getContext()),
1783 // We'd like to list the prologue as "not statements" but GDB behaves
1784 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1785 DWARF2_FLAG_IS_STMT);
1789 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1790 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1791 DIVariable DV = Var->getVariable();
1792 // Variables with positive arg numbers are parameters.
1793 if (unsigned ArgNum = DV.getArgNumber()) {
1794 // Keep all parameters in order at the start of the variable list to ensure
1795 // function types are correct (no out-of-order parameters)
1797 // This could be improved by only doing it for optimized builds (unoptimized
1798 // builds have the right order to begin with), searching from the back (this
1799 // would catch the unoptimized case quickly), or doing a binary search
1800 // rather than linear search.
1801 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1802 while (I != Vars.end()) {
1803 unsigned CurNum = (*I)->getVariable().getArgNumber();
1804 // A local (non-parameter) variable has been found, insert immediately
1808 // A later indexed parameter has been found, insert immediately before it.
1809 if (CurNum > ArgNum)
1813 Vars.insert(I, Var);
1817 Vars.push_back(Var);
1820 // Gather and emit post-function debug information.
1821 void DwarfDebug::endFunction(const MachineFunction *MF) {
1822 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1824 // Define end label for subprogram.
1825 FunctionEndSym = Asm->GetTempSymbol("func_end",
1826 Asm->getFunctionNumber());
1827 // Assumes in correct section after the entry point.
1828 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1829 // Set DwarfCompileUnitID in MCContext to default value.
1830 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1832 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1833 collectVariableInfo(MF, ProcessedVars);
1835 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1836 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1837 assert(TheCU && "Unable to find compile unit!");
1839 // Construct abstract scopes.
1840 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1841 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1842 LexicalScope *AScope = AList[i];
1843 DISubprogram SP(AScope->getScopeNode());
1844 if (SP.isSubprogram()) {
1845 // Collect info for variables that were optimized out.
1846 DIArray Variables = SP.getVariables();
1847 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1848 DIVariable DV(Variables.getElement(i));
1849 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1851 // Check that DbgVariable for DV wasn't created earlier, when
1852 // findAbstractVariable() was called for inlined instance of DV.
1853 LLVMContext &Ctx = DV->getContext();
1854 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1855 if (AbstractVariables.lookup(CleanDV))
1857 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1858 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1861 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1862 constructScopeDIE(TheCU, AScope);
1865 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1867 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1868 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1871 for (ScopeVariablesMap::iterator
1872 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1873 DeleteContainerPointers(I->second);
1874 ScopeVariables.clear();
1875 DeleteContainerPointers(CurrentFnArguments);
1876 UserVariables.clear();
1878 AbstractVariables.clear();
1879 LabelsBeforeInsn.clear();
1880 LabelsAfterInsn.clear();
1884 // Register a source line with debug info. Returns the unique label that was
1885 // emitted and which provides correspondence to the source line list.
1886 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1892 DIDescriptor Scope(S);
1894 if (Scope.isCompileUnit()) {
1895 DICompileUnit CU(S);
1896 Fn = CU.getFilename();
1897 Dir = CU.getDirectory();
1898 } else if (Scope.isFile()) {
1900 Fn = F.getFilename();
1901 Dir = F.getDirectory();
1902 } else if (Scope.isSubprogram()) {
1904 Fn = SP.getFilename();
1905 Dir = SP.getDirectory();
1906 } else if (Scope.isLexicalBlockFile()) {
1907 DILexicalBlockFile DBF(S);
1908 Fn = DBF.getFilename();
1909 Dir = DBF.getDirectory();
1910 } else if (Scope.isLexicalBlock()) {
1911 DILexicalBlock DB(S);
1912 Fn = DB.getFilename();
1913 Dir = DB.getDirectory();
1915 llvm_unreachable("Unexpected scope info");
1917 Src = getOrCreateSourceID(Fn, Dir,
1918 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1920 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1923 //===----------------------------------------------------------------------===//
1925 //===----------------------------------------------------------------------===//
1927 // Compute the size and offset of a DIE.
1929 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1930 // Get the children.
1931 const std::vector<DIE *> &Children = Die->getChildren();
1933 // Record the abbreviation.
1934 assignAbbrevNumber(Die->getAbbrev());
1936 // Get the abbreviation for this DIE.
1937 unsigned AbbrevNumber = Die->getAbbrevNumber();
1938 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1941 Die->setOffset(Offset);
1943 // Start the size with the size of abbreviation code.
1944 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1946 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1947 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1949 // Size the DIE attribute values.
1950 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1951 // Size attribute value.
1952 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1954 // Size the DIE children if any.
1955 if (!Children.empty()) {
1956 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1957 "Children flag not set");
1959 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1960 Offset = computeSizeAndOffset(Children[j], Offset);
1962 // End of children marker.
1963 Offset += sizeof(int8_t);
1966 Die->setSize(Offset - Die->getOffset());
1970 // Compute the size and offset of all the DIEs.
1971 void DwarfUnits::computeSizeAndOffsets() {
1972 // Offset from the beginning of debug info section.
1973 unsigned SecOffset = 0;
1974 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1975 E = CUs.end(); I != E; ++I) {
1976 (*I)->setDebugInfoOffset(SecOffset);
1978 sizeof(int32_t) + // Length of Compilation Unit Info
1979 sizeof(int16_t) + // DWARF version number
1980 sizeof(int32_t) + // Offset Into Abbrev. Section
1981 sizeof(int8_t); // Pointer Size (in bytes)
1983 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1984 SecOffset += EndOffset;
1988 // Emit initial Dwarf sections with a label at the start of each one.
1989 void DwarfDebug::emitSectionLabels() {
1990 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1992 // Dwarf sections base addresses.
1993 DwarfInfoSectionSym =
1994 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1995 DwarfAbbrevSectionSym =
1996 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1997 if (useSplitDwarf())
1998 DwarfAbbrevDWOSectionSym =
1999 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
2000 "section_abbrev_dwo");
2001 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
2003 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2004 emitSectionSym(Asm, MacroInfo);
2006 DwarfLineSectionSym =
2007 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2008 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2009 if (GenerateDwarfPubNamesSection)
2010 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2011 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2012 DwarfStrSectionSym =
2013 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2014 if (useSplitDwarf()) {
2015 DwarfStrDWOSectionSym =
2016 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2017 DwarfAddrSectionSym =
2018 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2020 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2023 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
2024 "section_debug_loc");
2026 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2027 emitSectionSym(Asm, TLOF.getDataSection());
2030 // Recursively emits a debug information entry.
2031 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
2032 // Get the abbreviation for this DIE.
2033 unsigned AbbrevNumber = Die->getAbbrevNumber();
2034 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
2036 // Emit the code (index) for the abbreviation.
2037 if (Asm->isVerbose())
2038 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2039 Twine::utohexstr(Die->getOffset()) + ":0x" +
2040 Twine::utohexstr(Die->getSize()) + " " +
2041 dwarf::TagString(Abbrev->getTag()));
2042 Asm->EmitULEB128(AbbrevNumber);
2044 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2045 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2047 // Emit the DIE attribute values.
2048 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2049 unsigned Attr = AbbrevData[i].getAttribute();
2050 unsigned Form = AbbrevData[i].getForm();
2051 assert(Form && "Too many attributes for DIE (check abbreviation)");
2053 if (Asm->isVerbose())
2054 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2057 case dwarf::DW_AT_abstract_origin: {
2058 DIEEntry *E = cast<DIEEntry>(Values[i]);
2059 DIE *Origin = E->getEntry();
2060 unsigned Addr = Origin->getOffset();
2061 if (Form == dwarf::DW_FORM_ref_addr) {
2062 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2063 // section. Origin->getOffset() returns the offset from start of the
2065 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2066 Addr += Holder.getCUOffset(Origin->getCompileUnit());
2068 Asm->OutStreamer.EmitIntValue(Addr,
2069 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
2072 case dwarf::DW_AT_ranges: {
2073 // DW_AT_range Value encodes offset in debug_range section.
2074 DIEInteger *V = cast<DIEInteger>(Values[i]);
2076 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2077 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2081 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2083 DwarfDebugRangeSectionSym,
2088 case dwarf::DW_AT_location: {
2089 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2090 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2091 Asm->EmitLabelReference(L->getValue(), 4);
2093 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2095 Values[i]->EmitValue(Asm, Form);
2099 case dwarf::DW_AT_accessibility: {
2100 if (Asm->isVerbose()) {
2101 DIEInteger *V = cast<DIEInteger>(Values[i]);
2102 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2104 Values[i]->EmitValue(Asm, Form);
2108 // Emit an attribute using the defined form.
2109 Values[i]->EmitValue(Asm, Form);
2114 // Emit the DIE children if any.
2115 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2116 const std::vector<DIE *> &Children = Die->getChildren();
2118 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2119 emitDIE(Children[j], Abbrevs);
2121 if (Asm->isVerbose())
2122 Asm->OutStreamer.AddComment("End Of Children Mark");
2127 // Emit the various dwarf units to the unit section USection with
2128 // the abbreviations going into ASection.
2129 void DwarfUnits::emitUnits(DwarfDebug *DD,
2130 const MCSection *USection,
2131 const MCSection *ASection,
2132 const MCSymbol *ASectionSym) {
2133 Asm->OutStreamer.SwitchSection(USection);
2134 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2135 E = CUs.end(); I != E; ++I) {
2136 CompileUnit *TheCU = *I;
2137 DIE *Die = TheCU->getCUDie();
2139 // Emit the compile units header.
2141 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2142 TheCU->getUniqueID()));
2144 // Emit size of content not including length itself
2145 unsigned ContentSize = Die->getSize() +
2146 sizeof(int16_t) + // DWARF version number
2147 sizeof(int32_t) + // Offset Into Abbrev. Section
2148 sizeof(int8_t); // Pointer Size (in bytes)
2150 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2151 Asm->EmitInt32(ContentSize);
2152 Asm->OutStreamer.AddComment("DWARF version number");
2153 Asm->EmitInt16(DD->getDwarfVersion());
2154 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2155 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2157 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2158 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2160 DD->emitDIE(Die, Abbreviations);
2161 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2162 TheCU->getUniqueID()));
2166 /// For a given compile unit DIE, returns offset from beginning of debug info.
2167 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2168 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2169 "Input DIE should be compile unit in getCUOffset.");
2170 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2172 CompileUnit *TheCU = *I;
2173 if (TheCU->getCUDie() == Die)
2174 return TheCU->getDebugInfoOffset();
2176 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2179 // Emit the debug info section.
2180 void DwarfDebug::emitDebugInfo() {
2181 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2183 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2184 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2185 DwarfAbbrevSectionSym);
2188 // Emit the abbreviation section.
2189 void DwarfDebug::emitAbbreviations() {
2190 if (!useSplitDwarf())
2191 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2194 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2197 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2198 std::vector<DIEAbbrev *> *Abbrevs) {
2199 // Check to see if it is worth the effort.
2200 if (!Abbrevs->empty()) {
2201 // Start the debug abbrev section.
2202 Asm->OutStreamer.SwitchSection(Section);
2204 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2205 Asm->OutStreamer.EmitLabel(Begin);
2207 // For each abbrevation.
2208 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2209 // Get abbreviation data
2210 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2212 // Emit the abbrevations code (base 1 index.)
2213 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2215 // Emit the abbreviations data.
2219 // Mark end of abbreviations.
2220 Asm->EmitULEB128(0, "EOM(3)");
2222 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2223 Asm->OutStreamer.EmitLabel(End);
2227 // Emit the last address of the section and the end of the line matrix.
2228 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2229 // Define last address of section.
2230 Asm->OutStreamer.AddComment("Extended Op");
2233 Asm->OutStreamer.AddComment("Op size");
2234 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2235 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2236 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2238 Asm->OutStreamer.AddComment("Section end label");
2240 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2241 Asm->getDataLayout().getPointerSize());
2243 // Mark end of matrix.
2244 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2250 // Emit visible names into a hashed accelerator table section.
2251 void DwarfDebug::emitAccelNames() {
2252 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2253 dwarf::DW_FORM_data4));
2254 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2255 E = CUMap.end(); I != E; ++I) {
2256 CompileUnit *TheCU = I->second;
2257 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2258 for (StringMap<std::vector<DIE*> >::const_iterator
2259 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2260 StringRef Name = GI->getKey();
2261 const std::vector<DIE *> &Entities = GI->second;
2262 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2263 DE = Entities.end(); DI != DE; ++DI)
2264 AT.AddName(Name, (*DI));
2268 AT.FinalizeTable(Asm, "Names");
2269 Asm->OutStreamer.SwitchSection(
2270 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2271 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2272 Asm->OutStreamer.EmitLabel(SectionBegin);
2274 // Emit the full data.
2275 AT.Emit(Asm, SectionBegin, &InfoHolder);
2278 // Emit objective C classes and categories into a hashed accelerator table
2280 void DwarfDebug::emitAccelObjC() {
2281 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2282 dwarf::DW_FORM_data4));
2283 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2284 E = CUMap.end(); I != E; ++I) {
2285 CompileUnit *TheCU = I->second;
2286 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2287 for (StringMap<std::vector<DIE*> >::const_iterator
2288 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2289 StringRef Name = GI->getKey();
2290 const std::vector<DIE *> &Entities = GI->second;
2291 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2292 DE = Entities.end(); DI != DE; ++DI)
2293 AT.AddName(Name, (*DI));
2297 AT.FinalizeTable(Asm, "ObjC");
2298 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2299 .getDwarfAccelObjCSection());
2300 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2301 Asm->OutStreamer.EmitLabel(SectionBegin);
2303 // Emit the full data.
2304 AT.Emit(Asm, SectionBegin, &InfoHolder);
2307 // Emit namespace dies into a hashed accelerator table.
2308 void DwarfDebug::emitAccelNamespaces() {
2309 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2310 dwarf::DW_FORM_data4));
2311 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2312 E = CUMap.end(); I != E; ++I) {
2313 CompileUnit *TheCU = I->second;
2314 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2315 for (StringMap<std::vector<DIE*> >::const_iterator
2316 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2317 StringRef Name = GI->getKey();
2318 const std::vector<DIE *> &Entities = GI->second;
2319 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2320 DE = Entities.end(); DI != DE; ++DI)
2321 AT.AddName(Name, (*DI));
2325 AT.FinalizeTable(Asm, "namespac");
2326 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2327 .getDwarfAccelNamespaceSection());
2328 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2329 Asm->OutStreamer.EmitLabel(SectionBegin);
2331 // Emit the full data.
2332 AT.Emit(Asm, SectionBegin, &InfoHolder);
2335 // Emit type dies into a hashed accelerator table.
2336 void DwarfDebug::emitAccelTypes() {
2337 std::vector<DwarfAccelTable::Atom> Atoms;
2338 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2339 dwarf::DW_FORM_data4));
2340 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2341 dwarf::DW_FORM_data2));
2342 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2343 dwarf::DW_FORM_data1));
2344 DwarfAccelTable AT(Atoms);
2345 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2346 E = CUMap.end(); I != E; ++I) {
2347 CompileUnit *TheCU = I->second;
2348 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2349 = TheCU->getAccelTypes();
2350 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2351 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2352 StringRef Name = GI->getKey();
2353 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2354 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2355 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2356 AT.AddName(Name, (*DI).first, (*DI).second);
2360 AT.FinalizeTable(Asm, "types");
2361 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2362 .getDwarfAccelTypesSection());
2363 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2364 Asm->OutStreamer.EmitLabel(SectionBegin);
2366 // Emit the full data.
2367 AT.Emit(Asm, SectionBegin, &InfoHolder);
2370 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2372 void DwarfDebug::emitDebugPubnames() {
2373 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2375 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2376 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2377 CompileUnit *TheCU = I->second;
2378 unsigned ID = TheCU->getUniqueID();
2380 if (TheCU->getGlobalNames().empty())
2383 // Start the dwarf pubnames section.
2384 Asm->OutStreamer.SwitchSection(
2385 Asm->getObjFileLowering().getDwarfPubNamesSection());
2387 Asm->OutStreamer.AddComment("Length of Public Names Info");
2388 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2389 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2391 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2393 Asm->OutStreamer.AddComment("DWARF Version");
2394 Asm->EmitInt16(DwarfVersion);
2396 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2397 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2398 DwarfInfoSectionSym);
2400 Asm->OutStreamer.AddComment("Compilation Unit Length");
2401 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2402 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2405 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2406 for (StringMap<DIE*>::const_iterator
2407 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2408 const char *Name = GI->getKeyData();
2409 const DIE *Entity = GI->second;
2411 Asm->OutStreamer.AddComment("DIE offset");
2412 Asm->EmitInt32(Entity->getOffset());
2414 if (Asm->isVerbose())
2415 Asm->OutStreamer.AddComment("External Name");
2416 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2419 Asm->OutStreamer.AddComment("End Mark");
2421 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2425 void DwarfDebug::emitDebugPubTypes() {
2426 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2427 E = CUMap.end(); I != E; ++I) {
2428 CompileUnit *TheCU = I->second;
2429 // Start the dwarf pubtypes section.
2430 Asm->OutStreamer.SwitchSection(
2431 Asm->getObjFileLowering().getDwarfPubTypesSection());
2432 Asm->OutStreamer.AddComment("Length of Public Types Info");
2433 Asm->EmitLabelDifference(
2434 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2435 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2437 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2438 TheCU->getUniqueID()));
2440 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2441 Asm->EmitInt16(DwarfVersion);
2443 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2444 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2445 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2446 TheCU->getUniqueID()),
2447 DwarfInfoSectionSym);
2449 Asm->OutStreamer.AddComment("Compilation Unit Length");
2450 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2451 TheCU->getUniqueID()),
2452 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2453 TheCU->getUniqueID()),
2456 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2457 for (StringMap<DIE*>::const_iterator
2458 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2459 const char *Name = GI->getKeyData();
2460 DIE *Entity = GI->second;
2462 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2463 Asm->EmitInt32(Entity->getOffset());
2465 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2466 // Emit the name with a terminating null byte.
2467 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2470 Asm->OutStreamer.AddComment("End Mark");
2472 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2473 TheCU->getUniqueID()));
2477 // Emit strings into a string section.
2478 void DwarfUnits::emitStrings(const MCSection *StrSection,
2479 const MCSection *OffsetSection = NULL,
2480 const MCSymbol *StrSecSym = NULL) {
2482 if (StringPool.empty()) return;
2484 // Start the dwarf str section.
2485 Asm->OutStreamer.SwitchSection(StrSection);
2487 // Get all of the string pool entries and put them in an array by their ID so
2488 // we can sort them.
2489 SmallVector<std::pair<unsigned,
2490 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2492 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2493 I = StringPool.begin(), E = StringPool.end();
2495 Entries.push_back(std::make_pair(I->second.second, &*I));
2497 array_pod_sort(Entries.begin(), Entries.end());
2499 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2500 // Emit a label for reference from debug information entries.
2501 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2503 // Emit the string itself with a terminating null byte.
2504 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2505 Entries[i].second->getKeyLength()+1));
2508 // If we've got an offset section go ahead and emit that now as well.
2509 if (OffsetSection) {
2510 Asm->OutStreamer.SwitchSection(OffsetSection);
2511 unsigned offset = 0;
2512 unsigned size = 4; // FIXME: DWARF64 is 8.
2513 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2514 Asm->OutStreamer.EmitIntValue(offset, size);
2515 offset += Entries[i].second->getKeyLength() + 1;
2520 // Emit strings into a string section.
2521 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2523 if (AddressPool.empty()) return;
2525 // Start the dwarf addr section.
2526 Asm->OutStreamer.SwitchSection(AddrSection);
2528 // Order the address pool entries by ID
2529 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2531 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2532 E = AddressPool.end();
2534 Entries[I->second] = I->first;
2536 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2537 // Emit an expression for reference from debug information entries.
2538 if (const MCExpr *Expr = Entries[i])
2539 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2541 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2546 // Emit visible names into a debug str section.
2547 void DwarfDebug::emitDebugStr() {
2548 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2549 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2552 // Emit locations into the debug loc section.
2553 void DwarfDebug::emitDebugLoc() {
2554 if (DotDebugLocEntries.empty())
2557 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2558 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2560 DotDebugLocEntry &Entry = *I;
2561 if (I + 1 != DotDebugLocEntries.end())
2565 // Start the dwarf loc section.
2566 Asm->OutStreamer.SwitchSection(
2567 Asm->getObjFileLowering().getDwarfLocSection());
2568 unsigned char Size = Asm->getDataLayout().getPointerSize();
2569 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2571 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2572 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2573 I != E; ++I, ++index) {
2574 DotDebugLocEntry &Entry = *I;
2575 if (Entry.isMerged()) continue;
2576 if (Entry.isEmpty()) {
2577 Asm->OutStreamer.EmitIntValue(0, Size);
2578 Asm->OutStreamer.EmitIntValue(0, Size);
2579 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2581 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2582 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2583 DIVariable DV(Entry.getVariable());
2584 Asm->OutStreamer.AddComment("Loc expr size");
2585 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2586 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2587 Asm->EmitLabelDifference(end, begin, 2);
2588 Asm->OutStreamer.EmitLabel(begin);
2589 if (Entry.isInt()) {
2590 DIBasicType BTy(DV.getType());
2592 (BTy.getEncoding() == dwarf::DW_ATE_signed
2593 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2594 Asm->OutStreamer.AddComment("DW_OP_consts");
2595 Asm->EmitInt8(dwarf::DW_OP_consts);
2596 Asm->EmitSLEB128(Entry.getInt());
2598 Asm->OutStreamer.AddComment("DW_OP_constu");
2599 Asm->EmitInt8(dwarf::DW_OP_constu);
2600 Asm->EmitULEB128(Entry.getInt());
2602 } else if (Entry.isLocation()) {
2603 MachineLocation Loc = Entry.getLoc();
2604 if (!DV.hasComplexAddress())
2606 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2608 // Complex address entry.
2609 unsigned N = DV.getNumAddrElements();
2611 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2612 if (Loc.getOffset()) {
2614 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2615 Asm->OutStreamer.AddComment("DW_OP_deref");
2616 Asm->EmitInt8(dwarf::DW_OP_deref);
2617 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2618 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2619 Asm->EmitSLEB128(DV.getAddrElement(1));
2621 // If first address element is OpPlus then emit
2622 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2623 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2624 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2628 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2631 // Emit remaining complex address elements.
2632 for (; i < N; ++i) {
2633 uint64_t Element = DV.getAddrElement(i);
2634 if (Element == DIBuilder::OpPlus) {
2635 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2636 Asm->EmitULEB128(DV.getAddrElement(++i));
2637 } else if (Element == DIBuilder::OpDeref) {
2639 Asm->EmitInt8(dwarf::DW_OP_deref);
2641 llvm_unreachable("unknown Opcode found in complex address");
2645 // else ... ignore constant fp. There is not any good way to
2646 // to represent them here in dwarf.
2647 Asm->OutStreamer.EmitLabel(end);
2652 // Emit visible names into a debug aranges section.
2653 void DwarfDebug::emitDebugARanges() {
2654 // Start the dwarf aranges section.
2655 Asm->OutStreamer.SwitchSection(
2656 Asm->getObjFileLowering().getDwarfARangesSection());
2659 // Emit visible names into a debug ranges section.
2660 void DwarfDebug::emitDebugRanges() {
2661 // Start the dwarf ranges section.
2662 Asm->OutStreamer.SwitchSection(
2663 Asm->getObjFileLowering().getDwarfRangesSection());
2664 unsigned char Size = Asm->getDataLayout().getPointerSize();
2665 for (SmallVectorImpl<const MCSymbol *>::iterator
2666 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2669 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2671 Asm->OutStreamer.EmitIntValue(0, Size);
2675 // Emit visible names into a debug macinfo section.
2676 void DwarfDebug::emitDebugMacInfo() {
2677 if (const MCSection *LineInfo =
2678 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2679 // Start the dwarf macinfo section.
2680 Asm->OutStreamer.SwitchSection(LineInfo);
2684 // Emit inline info using following format.
2686 // 1. length of section
2687 // 2. Dwarf version number
2690 // Entries (one "entry" for each function that was inlined):
2692 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2693 // otherwise offset into __debug_str for regular function name.
2694 // 2. offset into __debug_str section for regular function name.
2695 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2696 // instances for the function.
2698 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2699 // inlined instance; the die_offset points to the inlined_subroutine die in the
2700 // __debug_info section, and the low_pc is the starting address for the
2701 // inlining instance.
2702 void DwarfDebug::emitDebugInlineInfo() {
2703 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2709 Asm->OutStreamer.SwitchSection(
2710 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2712 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2713 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2714 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2716 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2718 Asm->OutStreamer.AddComment("Dwarf Version");
2719 Asm->EmitInt16(DwarfVersion);
2720 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2721 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2723 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2724 E = InlinedSPNodes.end(); I != E; ++I) {
2726 const MDNode *Node = *I;
2727 InlineInfoMap::iterator II = InlineInfo.find(Node);
2728 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2729 DISubprogram SP(Node);
2730 StringRef LName = SP.getLinkageName();
2731 StringRef Name = SP.getName();
2733 Asm->OutStreamer.AddComment("MIPS linkage name");
2735 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2736 DwarfStrSectionSym);
2738 Asm->EmitSectionOffset(
2739 InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2740 DwarfStrSectionSym);
2742 Asm->OutStreamer.AddComment("Function name");
2743 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2744 DwarfStrSectionSym);
2745 Asm->EmitULEB128(Labels.size(), "Inline count");
2747 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2748 LE = Labels.end(); LI != LE; ++LI) {
2749 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2750 Asm->EmitInt32(LI->second->getOffset());
2752 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2753 Asm->OutStreamer.EmitSymbolValue(LI->first,
2754 Asm->getDataLayout().getPointerSize());
2758 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2761 // DWARF5 Experimental Separate Dwarf emitters.
2763 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2764 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2765 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2766 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2767 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2768 DICompileUnit DIUnit(N);
2769 CompilationDir = DIUnit.getDirectory();
2771 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2772 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2773 DIUnit.getLanguage(), Die, N, Asm,
2774 this, &SkeletonHolder);
2776 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2777 DIUnit.getSplitDebugFilename());
2779 // This should be a unique identifier when we want to build .dwp files.
2780 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2782 // Relocate to the beginning of the addr_base section, else 0 for the
2783 // beginning of the one for this compile unit.
2784 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2785 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2786 DwarfAddrSectionSym);
2788 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2789 dwarf::DW_FORM_sec_offset, 0);
2791 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2792 // into an entity. We're using 0, or a NULL label for this.
2793 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2795 // DW_AT_stmt_list is a offset of line number information for this
2796 // compile unit in debug_line section.
2797 // FIXME: Should handle multiple compile units.
2798 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2799 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2800 DwarfLineSectionSym);
2802 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2804 if (!CompilationDir.empty())
2805 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2807 SkeletonHolder.addUnit(NewCU);
2808 SkeletonCUs.push_back(NewCU);
2813 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2814 assert(useSplitDwarf() && "No split dwarf debug info?");
2815 emitAbbrevs(Section, &SkeletonAbbrevs);
2818 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2819 // compile units that would normally be in debug_info.
2820 void DwarfDebug::emitDebugInfoDWO() {
2821 assert(useSplitDwarf() && "No split dwarf debug info?");
2822 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2823 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2824 DwarfAbbrevDWOSectionSym);
2827 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2828 // abbreviations for the .debug_info.dwo section.
2829 void DwarfDebug::emitDebugAbbrevDWO() {
2830 assert(useSplitDwarf() && "No split dwarf?");
2831 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2835 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2836 // string section and is identical in format to traditional .debug_str
2838 void DwarfDebug::emitDebugStrDWO() {
2839 assert(useSplitDwarf() && "No split dwarf?");
2840 const MCSection *OffSec = Asm->getObjFileLowering()
2841 .getDwarfStrOffDWOSection();
2842 const MCSymbol *StrSym = DwarfStrSectionSym;
2843 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),