1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
18 #include "DwarfAccelTable.h"
19 #include "DwarfCompileUnit.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/DIBuilder.h"
27 #include "llvm/DebugInfo.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/Module.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/ErrorHandling.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/MD5.h"
41 #include "llvm/Support/Path.h"
42 #include "llvm/Support/Timer.h"
43 #include "llvm/Support/ValueHandle.h"
44 #include "llvm/Target/TargetFrameLowering.h"
45 #include "llvm/Target/TargetLoweringObjectFile.h"
46 #include "llvm/Target/TargetMachine.h"
47 #include "llvm/Target/TargetOptions.h"
48 #include "llvm/Target/TargetRegisterInfo.h"
52 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
53 cl::desc("Disable debug info printing"));
55 static cl::opt<bool> UnknownLocations(
56 "use-unknown-locations", cl::Hidden,
57 cl::desc("Make an absence of debug location information explicit."),
61 GenerateDwarfPubNamesSection("generate-dwarf-pubnames", cl::Hidden,
63 cl::desc("Generate DWARF pubnames section"));
66 GenerateODRHash("generate-odr-hash", cl::Hidden,
67 cl::desc("Add an ODR hash to external type DIEs."),
78 static cl::opt<DefaultOnOff>
79 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
80 cl::desc("Output prototype dwarf accelerator tables."),
81 cl::values(clEnumVal(Default, "Default for platform"),
82 clEnumVal(Enable, "Enabled"),
83 clEnumVal(Disable, "Disabled"), clEnumValEnd),
86 static cl::opt<DefaultOnOff>
87 DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
88 cl::desc("Compatibility with Darwin gdb."),
89 cl::values(clEnumVal(Default, "Default for platform"),
90 clEnumVal(Enable, "Enabled"),
91 clEnumVal(Disable, "Disabled"), clEnumValEnd),
94 static cl::opt<DefaultOnOff>
95 SplitDwarf("split-dwarf", cl::Hidden,
96 cl::desc("Output prototype dwarf split debug info."),
97 cl::values(clEnumVal(Default, "Default for platform"),
98 clEnumVal(Enable, "Enabled"),
99 clEnumVal(Disable, "Disabled"), clEnumValEnd),
103 const char *const DWARFGroupName = "DWARF Emission";
104 const char *const DbgTimerName = "DWARF Debug Writer";
106 struct CompareFirst {
107 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
108 return lhs.first < rhs.first;
111 } // end anonymous namespace
113 //===----------------------------------------------------------------------===//
115 // Configuration values for initial hash set sizes (log2).
117 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
121 DIType DbgVariable::getType() const {
122 DIType Ty = Var.getType();
123 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
124 // addresses instead.
125 if (Var.isBlockByrefVariable()) {
126 /* Byref variables, in Blocks, are declared by the programmer as
127 "SomeType VarName;", but the compiler creates a
128 __Block_byref_x_VarName struct, and gives the variable VarName
129 either the struct, or a pointer to the struct, as its type. This
130 is necessary for various behind-the-scenes things the compiler
131 needs to do with by-reference variables in blocks.
133 However, as far as the original *programmer* is concerned, the
134 variable should still have type 'SomeType', as originally declared.
136 The following function dives into the __Block_byref_x_VarName
137 struct to find the original type of the variable. This will be
138 passed back to the code generating the type for the Debug
139 Information Entry for the variable 'VarName'. 'VarName' will then
140 have the original type 'SomeType' in its debug information.
142 The original type 'SomeType' will be the type of the field named
143 'VarName' inside the __Block_byref_x_VarName struct.
145 NOTE: In order for this to not completely fail on the debugger
146 side, the Debug Information Entry for the variable VarName needs to
147 have a DW_AT_location that tells the debugger how to unwind through
148 the pointers and __Block_byref_x_VarName struct to find the actual
149 value of the variable. The function addBlockByrefType does this. */
151 uint16_t tag = Ty.getTag();
153 if (tag == dwarf::DW_TAG_pointer_type) {
154 DIDerivedType DTy = DIDerivedType(Ty);
155 subType = DTy.getTypeDerivedFrom();
158 DICompositeType blockStruct = DICompositeType(subType);
159 DIArray Elements = blockStruct.getTypeArray();
161 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
162 DIDescriptor Element = Elements.getElement(i);
163 DIDerivedType DT = DIDerivedType(Element);
164 if (getName() == DT.getName())
165 return (DT.getTypeDerivedFrom());
171 } // end llvm namespace
173 /// Return Dwarf Version by checking module flags.
174 static unsigned getDwarfVersionFromModule(const Module *M) {
175 Value *Val = M->getModuleFlag("Dwarf Version");
177 return dwarf::DWARF_VERSION;
178 return cast<ConstantInt>(Val)->getZExtValue();
181 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
182 : Asm(A), MMI(Asm->MMI), FirstCU(0),
183 AbbreviationsSet(InitAbbreviationsSetSize),
184 SourceIdMap(DIEValueAllocator),
185 PrevLabel(NULL), GlobalCUIndexCount(0),
186 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
188 SkeletonAbbrevSet(InitAbbreviationsSetSize),
189 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
192 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
193 DwarfStrSectionSym = TextSectionSym = 0;
194 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
195 DwarfAddrSectionSym = 0;
196 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
197 FunctionBeginSym = FunctionEndSym = 0;
199 // Turn on accelerator tables and older gdb compatibility
201 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
202 if (DarwinGDBCompat == Default) {
204 IsDarwinGDBCompat = true;
206 IsDarwinGDBCompat = false;
208 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
210 if (DwarfAccelTables == Default) {
212 HasDwarfAccelTables = true;
214 HasDwarfAccelTables = false;
216 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
218 if (SplitDwarf == Default)
219 HasSplitDwarf = false;
221 HasSplitDwarf = SplitDwarf == Enable ? true : false;
223 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
226 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
230 DwarfDebug::~DwarfDebug() {
233 // Switch to the specified MCSection and emit an assembler
234 // temporary label to it if SymbolStem is specified.
235 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
236 const char *SymbolStem = 0) {
237 Asm->OutStreamer.SwitchSection(Section);
238 if (!SymbolStem) return 0;
240 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
241 Asm->OutStreamer.EmitLabel(TmpSym);
245 MCSymbol *DwarfUnits::getStringPoolSym() {
246 return Asm->GetTempSymbol(StringPref);
249 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
250 std::pair<MCSymbol*, unsigned> &Entry =
251 StringPool.GetOrCreateValue(Str).getValue();
252 if (Entry.first) return Entry.first;
254 Entry.second = NextStringPoolNumber++;
255 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
258 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
259 std::pair<MCSymbol*, unsigned> &Entry =
260 StringPool.GetOrCreateValue(Str).getValue();
261 if (Entry.first) return Entry.second;
263 Entry.second = NextStringPoolNumber++;
264 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
268 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
269 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
272 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
273 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
274 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
276 ++NextAddrPoolNumber;
277 return P.first->second;
280 // Define a unique number for the abbreviation.
282 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
283 // Check the set for priors.
284 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
286 // If it's newly added.
287 if (InSet == &Abbrev) {
288 // Add to abbreviation list.
289 Abbreviations->push_back(&Abbrev);
291 // Assign the vector position + 1 as its number.
292 Abbrev.setNumber(Abbreviations->size());
294 // Assign existing abbreviation number.
295 Abbrev.setNumber(InSet->getNumber());
299 static bool isObjCClass(StringRef Name) {
300 return Name.startswith("+") || Name.startswith("-");
303 static bool hasObjCCategory(StringRef Name) {
304 if (!isObjCClass(Name)) return false;
306 size_t pos = Name.find(')');
307 if (pos != std::string::npos) {
308 if (Name[pos+1] != ' ') return false;
314 static void getObjCClassCategory(StringRef In, StringRef &Class,
315 StringRef &Category) {
316 if (!hasObjCCategory(In)) {
317 Class = In.slice(In.find('[') + 1, In.find(' '));
322 Class = In.slice(In.find('[') + 1, In.find('('));
323 Category = In.slice(In.find('[') + 1, In.find(' '));
327 static StringRef getObjCMethodName(StringRef In) {
328 return In.slice(In.find(' ') + 1, In.find(']'));
331 // Add the various names to the Dwarf accelerator table names.
332 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
334 if (!SP.isDefinition()) return;
336 TheCU->addAccelName(SP.getName(), Die);
338 // If the linkage name is different than the name, go ahead and output
339 // that as well into the name table.
340 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
341 TheCU->addAccelName(SP.getLinkageName(), Die);
343 // If this is an Objective-C selector name add it to the ObjC accelerator
345 if (isObjCClass(SP.getName())) {
346 StringRef Class, Category;
347 getObjCClassCategory(SP.getName(), Class, Category);
348 TheCU->addAccelObjC(Class, Die);
350 TheCU->addAccelObjC(Category, Die);
351 // Also add the base method name to the name table.
352 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
356 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
357 // and DW_AT_high_pc attributes. If there are global variables in this
358 // scope then create and insert DIEs for these variables.
359 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
360 const MDNode *SPNode) {
361 DIE *SPDie = SPCU->getDIE(SPNode);
363 assert(SPDie && "Unable to find subprogram DIE!");
364 DISubprogram SP(SPNode);
366 // If we're updating an abstract DIE, then we will be adding the children and
367 // object pointer later on. But what we don't want to do is process the
368 // concrete DIE twice.
369 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
371 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
372 // Pick up abstract subprogram DIE.
373 SPDie = new DIE(dwarf::DW_TAG_subprogram);
374 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
376 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
377 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
381 DISubprogram SPDecl = SP.getFunctionDeclaration();
382 if (!SPDecl.isSubprogram()) {
383 // There is not any need to generate specification DIE for a function
384 // defined at compile unit level. If a function is defined inside another
385 // function then gdb prefers the definition at top level and but does not
386 // expect specification DIE in parent function. So avoid creating
387 // specification DIE for a function defined inside a function.
388 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
389 !SP.getContext().isFile() &&
390 !isSubprogramContext(SP.getContext())) {
391 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
394 DICompositeType SPTy = SP.getType();
395 DIArray Args = SPTy.getTypeArray();
396 uint16_t SPTag = SPTy.getTag();
397 if (SPTag == dwarf::DW_TAG_subroutine_type)
398 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
399 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
400 DIType ATy = DIType(Args.getElement(i));
401 SPCU->addType(Arg, ATy);
402 if (ATy.isArtificial())
403 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
404 if (ATy.isObjectPointer())
405 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
406 dwarf::DW_FORM_ref4, Arg);
407 SPDie->addChild(Arg);
409 DIE *SPDeclDie = SPDie;
410 SPDie = new DIE(dwarf::DW_TAG_subprogram);
411 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
412 dwarf::DW_FORM_ref4, SPDeclDie);
418 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
419 Asm->GetTempSymbol("func_begin",
420 Asm->getFunctionNumber()));
421 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
422 Asm->GetTempSymbol("func_end",
423 Asm->getFunctionNumber()));
424 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
425 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
426 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
428 // Add name to the name table, we do this here because we're guaranteed
429 // to have concrete versions of our DW_TAG_subprogram nodes.
430 addSubprogramNames(SPCU, SP, SPDie);
435 // Construct new DW_TAG_lexical_block for this scope and attach
436 // DW_AT_low_pc/DW_AT_high_pc labels.
437 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
438 LexicalScope *Scope) {
439 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
440 if (Scope->isAbstractScope())
443 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
447 // If we have multiple ranges, emit them into the range section.
448 if (Ranges.size() > 1) {
449 // .debug_range section has not been laid out yet. Emit offset in
450 // .debug_range as a uint, size 4, for now. emitDIE will handle
451 // DW_AT_ranges appropriately.
452 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
453 DebugRangeSymbols.size()
454 * Asm->getDataLayout().getPointerSize());
455 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
456 RE = Ranges.end(); RI != RE; ++RI) {
457 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
458 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
461 // Terminate the range list.
462 DebugRangeSymbols.push_back(NULL);
463 DebugRangeSymbols.push_back(NULL);
467 // Construct the address range for this DIE.
468 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
469 MCSymbol *Start = getLabelBeforeInsn(RI->first);
470 MCSymbol *End = getLabelAfterInsn(RI->second);
472 if (End == 0) return 0;
474 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
475 assert(End->isDefined() && "Invalid end label for an inlined scope!");
477 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
478 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
483 // This scope represents inlined body of a function. Construct DIE to
484 // represent this concrete inlined copy of the function.
485 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
486 LexicalScope *Scope) {
487 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
488 assert(Ranges.empty() == false &&
489 "LexicalScope does not have instruction markers!");
491 if (!Scope->getScopeNode())
493 DIScope DS(Scope->getScopeNode());
494 DISubprogram InlinedSP = getDISubprogram(DS);
495 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
497 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
501 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
502 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
503 dwarf::DW_FORM_ref4, OriginDIE);
505 if (Ranges.size() > 1) {
506 // .debug_range section has not been laid out yet. Emit offset in
507 // .debug_range as a uint, size 4, for now. emitDIE will handle
508 // DW_AT_ranges appropriately.
509 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
510 DebugRangeSymbols.size()
511 * Asm->getDataLayout().getPointerSize());
512 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
513 RE = Ranges.end(); RI != RE; ++RI) {
514 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
515 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
517 DebugRangeSymbols.push_back(NULL);
518 DebugRangeSymbols.push_back(NULL);
520 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
521 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
522 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
524 if (StartLabel == 0 || EndLabel == 0)
525 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
527 assert(StartLabel->isDefined() &&
528 "Invalid starting label for an inlined scope!");
529 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
531 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
532 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
535 InlinedSubprogramDIEs.insert(OriginDIE);
537 // Add the call site information to the DIE.
538 DILocation DL(Scope->getInlinedAt());
539 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
540 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
541 TheCU->getUniqueID()));
542 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
544 // Track the start label for this inlined function.
545 //.debug_inlined section specification does not clearly state how
546 // to emit inlined scopes that are split into multiple instruction ranges.
547 // For now, use the first instruction range and emit low_pc/high_pc pair and
548 // corresponding the .debug_inlined section entry for this pair.
549 if (Asm->MAI->doesDwarfUseInlineInfoSection()) {
550 MCSymbol *StartLabel = getLabelBeforeInsn(Ranges.begin()->first);
551 InlineInfoMap::iterator I = InlineInfo.find(InlinedSP);
553 if (I == InlineInfo.end()) {
554 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
555 InlinedSPNodes.push_back(InlinedSP);
557 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
560 // Add name to the name table, we do this here because we're guaranteed
561 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
562 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
567 // Construct a DIE for this scope.
568 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
569 if (!Scope || !Scope->getScopeNode())
572 DIScope DS(Scope->getScopeNode());
573 // Early return to avoid creating dangling variable|scope DIEs.
574 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
578 SmallVector<DIE *, 8> Children;
579 DIE *ObjectPointer = NULL;
581 // Collect arguments for current function.
582 if (LScopes.isCurrentFunctionScope(Scope))
583 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
584 if (DbgVariable *ArgDV = CurrentFnArguments[i])
586 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
587 Children.push_back(Arg);
588 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
591 // Collect lexical scope children first.
592 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
593 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
595 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
596 Children.push_back(Variable);
597 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
599 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
600 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
601 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
602 Children.push_back(Nested);
603 DIE *ScopeDIE = NULL;
604 if (Scope->getInlinedAt())
605 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
606 else if (DS.isSubprogram()) {
607 ProcessedSPNodes.insert(DS);
608 if (Scope->isAbstractScope()) {
609 ScopeDIE = TheCU->getDIE(DS);
610 // Note down abstract DIE.
612 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
615 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
618 // There is no need to emit empty lexical block DIE.
619 std::pair<ImportedEntityMap::const_iterator,
620 ImportedEntityMap::const_iterator> Range = std::equal_range(
621 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
622 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
624 if (Children.empty() && Range.first == Range.second)
626 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
627 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
629 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
632 if (!ScopeDIE) return NULL;
635 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
636 E = Children.end(); I != E; ++I)
637 ScopeDIE->addChild(*I);
639 if (DS.isSubprogram() && ObjectPointer != NULL)
640 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
641 dwarf::DW_FORM_ref4, ObjectPointer);
643 if (DS.isSubprogram())
644 TheCU->addPubTypes(DISubprogram(DS));
649 // Look up the source id with the given directory and source file names.
650 // If none currently exists, create a new id and insert it in the
651 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
653 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
654 StringRef DirName, unsigned CUID) {
655 // If we use .loc in assembly, we can't separate .file entries according to
656 // compile units. Thus all files will belong to the default compile unit.
657 if (Asm->TM.hasMCUseLoc() &&
658 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
661 // If FE did not provide a file name, then assume stdin.
662 if (FileName.empty())
663 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
665 // TODO: this might not belong here. See if we can factor this better.
666 if (DirName == CompilationDir)
669 // FileIDCUMap stores the current ID for the given compile unit.
670 unsigned SrcId = FileIDCUMap[CUID] + 1;
672 // We look up the CUID/file/dir by concatenating them with a zero byte.
673 SmallString<128> NamePair;
674 NamePair += utostr(CUID);
677 NamePair += '\0'; // Zero bytes are not allowed in paths.
678 NamePair += FileName;
680 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
681 if (Ent.getValue() != SrcId)
682 return Ent.getValue();
684 FileIDCUMap[CUID] = SrcId;
685 // Print out a .file directive to specify files for .loc directives.
686 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
691 // Create new CompileUnit for the given metadata node with tag
692 // DW_TAG_compile_unit.
693 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
694 DICompileUnit DIUnit(N);
695 StringRef FN = DIUnit.getFilename();
696 CompilationDir = DIUnit.getDirectory();
698 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
699 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
700 DIUnit.getLanguage(), Die, N, Asm,
703 FileIDCUMap[NewCU->getUniqueID()] = 0;
704 // Call this to emit a .file directive if it wasn't emitted for the source
705 // file this CU comes from yet.
706 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
708 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
709 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
710 DIUnit.getLanguage());
711 NewCU->addString(Die, dwarf::DW_AT_name, FN);
713 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
714 // into an entity. We're using 0 (or a NULL label) for this. For
715 // split dwarf it's in the skeleton CU so omit it here.
716 if (!useSplitDwarf())
717 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
719 // Define start line table label for each Compile Unit.
720 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
721 NewCU->getUniqueID());
722 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
723 NewCU->getUniqueID());
725 // Use a single line table if we are using .loc and generating assembly.
727 (Asm->TM.hasMCUseLoc() &&
728 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
729 (NewCU->getUniqueID() == 0);
731 // DW_AT_stmt_list is a offset of line number information for this
732 // compile unit in debug_line section. For split dwarf this is
733 // left in the skeleton CU and so not included.
734 // The line table entries are not always emitted in assembly, so it
735 // is not okay to use line_table_start here.
736 if (!useSplitDwarf()) {
737 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
738 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
740 Asm->GetTempSymbol("section_line") : LineTableStartSym);
741 else if (UseTheFirstCU)
742 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
744 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
745 LineTableStartSym, DwarfLineSectionSym);
748 // If we're using split dwarf the compilation dir is going to be in the
749 // skeleton CU and so we don't need to duplicate it here.
750 if (!useSplitDwarf() && !CompilationDir.empty())
751 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
752 if (DIUnit.isOptimized())
753 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
755 StringRef Flags = DIUnit.getFlags();
757 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
759 if (unsigned RVer = DIUnit.getRunTimeVersion())
760 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
761 dwarf::DW_FORM_data1, RVer);
766 InfoHolder.addUnit(NewCU);
768 CUMap.insert(std::make_pair(N, NewCU));
772 // Construct subprogram DIE.
773 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
775 CompileUnit *&CURef = SPMap[N];
781 if (!SP.isDefinition())
782 // This is a method declaration which will be handled while constructing
786 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
789 TheCU->insertDIE(N, SubprogramDie);
791 // Add to context owner.
792 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
794 // Expose as global, if requested.
795 if (GenerateDwarfPubNamesSection)
796 TheCU->addGlobalName(SP.getName(), SubprogramDie);
799 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
801 DIImportedEntity Module(N);
802 if (!Module.Verify())
804 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
805 constructImportedEntityDIE(TheCU, Module, D);
808 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
810 DIImportedEntity Module(N);
811 if (!Module.Verify())
813 return constructImportedEntityDIE(TheCU, Module, Context);
816 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
817 const DIImportedEntity &Module,
819 assert(Module.Verify() &&
820 "Use one of the MDNode * overloads to handle invalid metadata");
821 assert(Context && "Should always have a context for an imported_module");
822 DIE *IMDie = new DIE(Module.getTag());
823 TheCU->insertDIE(Module, IMDie);
825 DIDescriptor Entity = Module.getEntity();
826 if (Entity.isNameSpace())
827 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
828 else if (Entity.isSubprogram())
829 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
830 else if (Entity.isType())
831 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
833 EntityDie = TheCU->getDIE(Entity);
834 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
835 Module.getContext().getDirectory(),
836 TheCU->getUniqueID());
837 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
838 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
839 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
841 StringRef Name = Module.getName();
843 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
844 Context->addChild(IMDie);
847 // Emit all Dwarf sections that should come prior to the content. Create
848 // global DIEs and emit initial debug info sections. This is invoked by
849 // the target AsmPrinter.
850 void DwarfDebug::beginModule() {
851 if (DisableDebugInfoPrinting)
854 const Module *M = MMI->getModule();
856 // If module has named metadata anchors then use them, otherwise scan the
857 // module using debug info finder to collect debug info.
858 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
862 // Emit initial sections so we can reference labels later.
865 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
866 DICompileUnit CUNode(CU_Nodes->getOperand(i));
867 CompileUnit *CU = constructCompileUnit(CUNode);
868 DIArray ImportedEntities = CUNode.getImportedEntities();
869 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
870 ScopesWithImportedEntities.push_back(std::make_pair(
871 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
872 ImportedEntities.getElement(i)));
873 std::sort(ScopesWithImportedEntities.begin(),
874 ScopesWithImportedEntities.end(), CompareFirst());
875 DIArray GVs = CUNode.getGlobalVariables();
876 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
877 CU->createGlobalVariableDIE(GVs.getElement(i));
878 DIArray SPs = CUNode.getSubprograms();
879 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
880 constructSubprogramDIE(CU, SPs.getElement(i));
881 DIArray EnumTypes = CUNode.getEnumTypes();
882 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
883 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
884 DIArray RetainedTypes = CUNode.getRetainedTypes();
885 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
886 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
887 // Emit imported_modules last so that the relevant context is already
889 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
890 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
893 // Tell MMI that we have debug info.
894 MMI->setDebugInfoAvailability(true);
896 // Prime section data.
897 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
900 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
901 void DwarfDebug::computeInlinedDIEs() {
902 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
903 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
904 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
906 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
908 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
909 AE = AbstractSPDies.end(); AI != AE; ++AI) {
910 DIE *ISP = AI->second;
911 if (InlinedSubprogramDIEs.count(ISP))
913 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
917 // Collect info for variables that were optimized out.
918 void DwarfDebug::collectDeadVariables() {
919 const Module *M = MMI->getModule();
920 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
922 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
923 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
924 DICompileUnit TheCU(CU_Nodes->getOperand(i));
925 DIArray Subprograms = TheCU.getSubprograms();
926 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
927 DISubprogram SP(Subprograms.getElement(i));
928 if (ProcessedSPNodes.count(SP) != 0) continue;
929 if (!SP.isSubprogram()) continue;
930 if (!SP.isDefinition()) continue;
931 DIArray Variables = SP.getVariables();
932 if (Variables.getNumElements() == 0) continue;
934 LexicalScope *Scope =
935 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
936 DeadFnScopeMap[SP] = Scope;
938 // Construct subprogram DIE and add variables DIEs.
939 CompileUnit *SPCU = CUMap.lookup(TheCU);
940 assert(SPCU && "Unable to find Compile Unit!");
941 constructSubprogramDIE(SPCU, SP);
942 DIE *ScopeDIE = SPCU->getDIE(SP);
943 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
944 DIVariable DV(Variables.getElement(vi));
945 if (!DV.isVariable()) continue;
946 DbgVariable NewVar(DV, NULL);
947 if (DIE *VariableDIE =
948 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
949 ScopeDIE->addChild(VariableDIE);
954 DeleteContainerSeconds(DeadFnScopeMap);
957 // Type Signature [7.27] and ODR Hash code.
959 /// \brief Grabs the string in whichever attribute is passed in and returns
960 /// a reference to it. Returns "" if the attribute doesn't exist.
961 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
962 DIEValue *V = Die->findAttribute(Attr);
964 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
965 return S->getString();
967 return StringRef("");
970 /// Return true if the current DIE is contained within an anonymous namespace.
971 static bool isContainedInAnonNamespace(DIE *Die) {
972 DIE *Parent = Die->getParent();
975 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
976 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
978 Parent = Parent->getParent();
984 /// Test if the current CU language is C++ and that we have
985 /// a named type that is not contained in an anonymous namespace.
986 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
987 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
988 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
989 !isContainedInAnonNamespace(Die);
992 void DwarfDebug::finalizeModuleInfo() {
993 // Collect info for variables that were optimized out.
994 collectDeadVariables();
996 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
997 computeInlinedDIEs();
999 // Split out type units and conditionally add an ODR tag to the split
1001 // FIXME: Do type splitting.
1002 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1003 DIE *Die = TypeUnits[i];
1005 // If we've requested ODR hashes and it's applicable for an ODR hash then
1006 // add the ODR signature now.
1007 // FIXME: This should be added onto the type unit, not the type, but this
1008 // works as an intermediate stage.
1009 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1010 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1011 dwarf::DW_FORM_data8,
1012 Hash.computeDIEODRSignature(Die));
1015 // Handle anything that needs to be done on a per-cu basis.
1016 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1018 CUI != CUE; ++CUI) {
1019 CompileUnit *TheCU = CUI->second;
1020 // Emit DW_AT_containing_type attribute to connect types with their
1021 // vtable holding type.
1022 TheCU->constructContainingTypeDIEs();
1024 // If we're splitting the dwarf out now that we've got the entire
1025 // CU then construct a skeleton CU based upon it.
1026 if (useSplitDwarf()) {
1027 // This should be a unique identifier when we want to build .dwp files.
1028 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1029 dwarf::DW_FORM_data8, 0);
1030 // Now construct the skeleton CU associated.
1031 CompileUnit *SkCU = constructSkeletonCU(CUI->first);
1032 // This should be a unique identifier when we want to build .dwp files.
1033 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1034 dwarf::DW_FORM_data8, 0);
1038 // Compute DIE offsets and sizes.
1039 InfoHolder.computeSizeAndOffsets();
1040 if (useSplitDwarf())
1041 SkeletonHolder.computeSizeAndOffsets();
1044 void DwarfDebug::endSections() {
1045 // Standard sections final addresses.
1046 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1047 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1048 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1049 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1051 // End text sections.
1052 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1053 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1054 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1058 // Emit all Dwarf sections that should come after the content.
1059 void DwarfDebug::endModule() {
1061 if (!FirstCU) return;
1063 // End any existing sections.
1064 // TODO: Does this need to happen?
1067 // Finalize the debug info for the module.
1068 finalizeModuleInfo();
1070 if (!useSplitDwarf()) {
1071 // Emit all the DIEs into a debug info section.
1074 // Corresponding abbreviations into a abbrev section.
1075 emitAbbreviations();
1077 // Emit info into a debug loc section.
1080 // Emit info into a debug aranges section.
1083 // Emit info into a debug ranges section.
1086 // Emit info into a debug macinfo section.
1089 // Emit inline info.
1090 // TODO: When we don't need the option anymore we
1091 // can remove all of the code that this section
1093 if (useDarwinGDBCompat())
1094 emitDebugInlineInfo();
1096 // TODO: Fill this in for separated debug sections and separate
1097 // out information into new sections.
1099 // Emit the debug info section and compile units.
1103 // Corresponding abbreviations into a abbrev section.
1104 emitAbbreviations();
1105 emitDebugAbbrevDWO();
1107 // Emit info into a debug loc section.
1110 // Emit info into a debug aranges section.
1113 // Emit info into a debug ranges section.
1116 // Emit info into a debug macinfo section.
1119 // Emit DWO addresses.
1120 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1122 // Emit inline info.
1123 // TODO: When we don't need the option anymore we
1124 // can remove all of the code that this section
1126 if (useDarwinGDBCompat())
1127 emitDebugInlineInfo();
1130 // Emit info into the dwarf accelerator table sections.
1131 if (useDwarfAccelTables()) {
1134 emitAccelNamespaces();
1138 // Emit info into a debug pubnames section, if requested.
1139 if (GenerateDwarfPubNamesSection)
1140 emitDebugPubnames();
1142 // Emit info into a debug pubtypes section.
1143 // TODO: When we don't need the option anymore we can
1144 // remove all of the code that adds to the table.
1145 if (useDarwinGDBCompat())
1146 emitDebugPubTypes();
1148 // Finally emit string information into a string table.
1150 if (useSplitDwarf())
1155 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1156 E = CUMap.end(); I != E; ++I)
1159 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1160 E = SkeletonCUs.end(); I != E; ++I)
1163 // Reset these for the next Module if we have one.
1167 // Find abstract variable, if any, associated with Var.
1168 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1169 DebugLoc ScopeLoc) {
1170 LLVMContext &Ctx = DV->getContext();
1171 // More then one inlined variable corresponds to one abstract variable.
1172 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1173 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1175 return AbsDbgVariable;
1177 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1181 AbsDbgVariable = new DbgVariable(Var, NULL);
1182 addScopeVariable(Scope, AbsDbgVariable);
1183 AbstractVariables[Var] = AbsDbgVariable;
1184 return AbsDbgVariable;
1187 // If Var is a current function argument then add it to CurrentFnArguments list.
1188 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1189 DbgVariable *Var, LexicalScope *Scope) {
1190 if (!LScopes.isCurrentFunctionScope(Scope))
1192 DIVariable DV = Var->getVariable();
1193 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1195 unsigned ArgNo = DV.getArgNumber();
1199 size_t Size = CurrentFnArguments.size();
1201 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1202 // llvm::Function argument size is not good indicator of how many
1203 // arguments does the function have at source level.
1205 CurrentFnArguments.resize(ArgNo * 2);
1206 CurrentFnArguments[ArgNo - 1] = Var;
1210 // Collect variable information from side table maintained by MMI.
1212 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1213 SmallPtrSet<const MDNode *, 16> &Processed) {
1214 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1215 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1216 VE = VMap.end(); VI != VE; ++VI) {
1217 const MDNode *Var = VI->first;
1219 Processed.insert(Var);
1221 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1223 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1225 // If variable scope is not found then skip this variable.
1229 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1230 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1231 RegVar->setFrameIndex(VP.first);
1232 if (!addCurrentFnArgument(MF, RegVar, Scope))
1233 addScopeVariable(Scope, RegVar);
1235 AbsDbgVariable->setFrameIndex(VP.first);
1239 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1241 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1242 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1243 return MI->getNumOperands() == 3 &&
1244 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1245 (MI->getOperand(1).isImm() ||
1246 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1249 // Get .debug_loc entry for the instruction range starting at MI.
1250 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1251 const MCSymbol *FLabel,
1252 const MCSymbol *SLabel,
1253 const MachineInstr *MI) {
1254 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1256 assert(MI->getNumOperands() == 3);
1257 if (MI->getOperand(0).isReg()) {
1258 MachineLocation MLoc;
1259 // If the second operand is an immediate, this is a
1260 // register-indirect address.
1261 if (!MI->getOperand(1).isImm())
1262 MLoc.set(MI->getOperand(0).getReg());
1264 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1265 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1267 if (MI->getOperand(0).isImm())
1268 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1269 if (MI->getOperand(0).isFPImm())
1270 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1271 if (MI->getOperand(0).isCImm())
1272 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1274 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1277 // Find variables for each lexical scope.
1279 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1280 SmallPtrSet<const MDNode *, 16> &Processed) {
1282 // Grab the variable info that was squirreled away in the MMI side-table.
1283 collectVariableInfoFromMMITable(MF, Processed);
1285 for (SmallVectorImpl<const MDNode*>::const_iterator
1286 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1288 const MDNode *Var = *UVI;
1289 if (Processed.count(Var))
1292 // History contains relevant DBG_VALUE instructions for Var and instructions
1294 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1295 if (History.empty())
1297 const MachineInstr *MInsn = History.front();
1300 LexicalScope *Scope = NULL;
1301 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1302 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1303 Scope = LScopes.getCurrentFunctionScope();
1304 else if (MDNode *IA = DV.getInlinedAt())
1305 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1307 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1308 // If variable scope is not found then skip this variable.
1312 Processed.insert(DV);
1313 assert(MInsn->isDebugValue() && "History must begin with debug value");
1314 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1315 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1316 if (!addCurrentFnArgument(MF, RegVar, Scope))
1317 addScopeVariable(Scope, RegVar);
1319 AbsVar->setMInsn(MInsn);
1321 // Simplify ranges that are fully coalesced.
1322 if (History.size() <= 1 || (History.size() == 2 &&
1323 MInsn->isIdenticalTo(History.back()))) {
1324 RegVar->setMInsn(MInsn);
1328 // Handle multiple DBG_VALUE instructions describing one variable.
1329 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1331 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1332 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1333 const MachineInstr *Begin = *HI;
1334 assert(Begin->isDebugValue() && "Invalid History entry");
1336 // Check if DBG_VALUE is truncating a range.
1337 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1338 && !Begin->getOperand(0).getReg())
1341 // Compute the range for a register location.
1342 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1343 const MCSymbol *SLabel = 0;
1346 // If Begin is the last instruction in History then its value is valid
1347 // until the end of the function.
1348 SLabel = FunctionEndSym;
1350 const MachineInstr *End = HI[1];
1351 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1352 << "\t" << *Begin << "\t" << *End << "\n");
1353 if (End->isDebugValue())
1354 SLabel = getLabelBeforeInsn(End);
1356 // End is a normal instruction clobbering the range.
1357 SLabel = getLabelAfterInsn(End);
1358 assert(SLabel && "Forgot label after clobber instruction");
1363 // The value is valid until the next DBG_VALUE or clobber.
1364 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1367 DotDebugLocEntries.push_back(DotDebugLocEntry());
1370 // Collect info for variables that were optimized out.
1371 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1372 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1373 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1374 DIVariable DV(Variables.getElement(i));
1375 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1377 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1378 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1382 // Return Label preceding the instruction.
1383 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1384 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1385 assert(Label && "Didn't insert label before instruction");
1389 // Return Label immediately following the instruction.
1390 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1391 return LabelsAfterInsn.lookup(MI);
1394 // Process beginning of an instruction.
1395 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1396 // Check if source location changes, but ignore DBG_VALUE locations.
1397 if (!MI->isDebugValue()) {
1398 DebugLoc DL = MI->getDebugLoc();
1399 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1402 if (DL == PrologEndLoc) {
1403 Flags |= DWARF2_FLAG_PROLOGUE_END;
1404 PrologEndLoc = DebugLoc();
1406 if (PrologEndLoc.isUnknown())
1407 Flags |= DWARF2_FLAG_IS_STMT;
1409 if (!DL.isUnknown()) {
1410 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1411 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1413 recordSourceLine(0, 0, 0, 0);
1417 // Insert labels where requested.
1418 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1419 LabelsBeforeInsn.find(MI);
1422 if (I == LabelsBeforeInsn.end())
1425 // Label already assigned.
1430 PrevLabel = MMI->getContext().CreateTempSymbol();
1431 Asm->OutStreamer.EmitLabel(PrevLabel);
1433 I->second = PrevLabel;
1436 // Process end of an instruction.
1437 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1438 // Don't create a new label after DBG_VALUE instructions.
1439 // They don't generate code.
1440 if (!MI->isDebugValue())
1443 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1444 LabelsAfterInsn.find(MI);
1447 if (I == LabelsAfterInsn.end())
1450 // Label already assigned.
1454 // We need a label after this instruction.
1456 PrevLabel = MMI->getContext().CreateTempSymbol();
1457 Asm->OutStreamer.EmitLabel(PrevLabel);
1459 I->second = PrevLabel;
1462 // Each LexicalScope has first instruction and last instruction to mark
1463 // beginning and end of a scope respectively. Create an inverse map that list
1464 // scopes starts (and ends) with an instruction. One instruction may start (or
1465 // end) multiple scopes. Ignore scopes that are not reachable.
1466 void DwarfDebug::identifyScopeMarkers() {
1467 SmallVector<LexicalScope *, 4> WorkList;
1468 WorkList.push_back(LScopes.getCurrentFunctionScope());
1469 while (!WorkList.empty()) {
1470 LexicalScope *S = WorkList.pop_back_val();
1472 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1473 if (!Children.empty())
1474 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1475 SE = Children.end(); SI != SE; ++SI)
1476 WorkList.push_back(*SI);
1478 if (S->isAbstractScope())
1481 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1484 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1485 RE = Ranges.end(); RI != RE; ++RI) {
1486 assert(RI->first && "InsnRange does not have first instruction!");
1487 assert(RI->second && "InsnRange does not have second instruction!");
1488 requestLabelBeforeInsn(RI->first);
1489 requestLabelAfterInsn(RI->second);
1494 // Get MDNode for DebugLoc's scope.
1495 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1496 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1497 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1498 return DL.getScope(Ctx);
1501 // Walk up the scope chain of given debug loc and find line number info
1502 // for the function.
1503 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1504 const MDNode *Scope = getScopeNode(DL, Ctx);
1505 DISubprogram SP = getDISubprogram(Scope);
1506 if (SP.isSubprogram()) {
1507 // Check for number of operands since the compatibility is
1509 if (SP->getNumOperands() > 19)
1510 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1512 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1518 // Gather pre-function debug information. Assumes being called immediately
1519 // after the function entry point has been emitted.
1520 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1521 if (!MMI->hasDebugInfo()) return;
1522 LScopes.initialize(*MF);
1523 if (LScopes.empty()) return;
1524 identifyScopeMarkers();
1526 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1528 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1529 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1530 assert(TheCU && "Unable to find compile unit!");
1531 if (Asm->TM.hasMCUseLoc() &&
1532 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1533 // Use a single line table if we are using .loc and generating assembly.
1534 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1536 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1538 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1539 Asm->getFunctionNumber());
1540 // Assumes in correct section after the entry point.
1541 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1543 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1545 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1546 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1547 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1549 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1551 bool AtBlockEntry = true;
1552 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1554 const MachineInstr *MI = II;
1556 if (MI->isDebugValue()) {
1557 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1559 // Keep track of user variables.
1561 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1563 // Variable is in a register, we need to check for clobbers.
1564 if (isDbgValueInDefinedReg(MI))
1565 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1567 // Check the history of this variable.
1568 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1569 if (History.empty()) {
1570 UserVariables.push_back(Var);
1571 // The first mention of a function argument gets the FunctionBeginSym
1572 // label, so arguments are visible when breaking at function entry.
1574 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1575 DISubprogram(getDISubprogram(DV.getContext()))
1576 .describes(MF->getFunction()))
1577 LabelsBeforeInsn[MI] = FunctionBeginSym;
1579 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1580 const MachineInstr *Prev = History.back();
1581 if (Prev->isDebugValue()) {
1582 // Coalesce identical entries at the end of History.
1583 if (History.size() >= 2 &&
1584 Prev->isIdenticalTo(History[History.size() - 2])) {
1585 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1587 << "\t" << *History[History.size() - 2] << "\n");
1591 // Terminate old register assignments that don't reach MI;
1592 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1593 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1594 isDbgValueInDefinedReg(Prev)) {
1595 // Previous register assignment needs to terminate at the end of
1597 MachineBasicBlock::const_iterator LastMI =
1598 PrevMBB->getLastNonDebugInstr();
1599 if (LastMI == PrevMBB->end()) {
1600 // Drop DBG_VALUE for empty range.
1601 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1602 << "\t" << *Prev << "\n");
1604 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1605 // Terminate after LastMI.
1606 History.push_back(LastMI);
1610 History.push_back(MI);
1612 // Not a DBG_VALUE instruction.
1614 AtBlockEntry = false;
1616 // First known non-DBG_VALUE and non-frame setup location marks
1617 // the beginning of the function body.
1618 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1619 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1620 PrologEndLoc = MI->getDebugLoc();
1622 // Check if the instruction clobbers any registers with debug vars.
1623 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1624 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1625 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1627 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1628 AI.isValid(); ++AI) {
1630 const MDNode *Var = LiveUserVar[Reg];
1633 // Reg is now clobbered.
1634 LiveUserVar[Reg] = 0;
1636 // Was MD last defined by a DBG_VALUE referring to Reg?
1637 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1638 if (HistI == DbgValues.end())
1640 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1641 if (History.empty())
1643 const MachineInstr *Prev = History.back();
1644 // Sanity-check: Register assignments are terminated at the end of
1646 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1648 // Is the variable still in Reg?
1649 if (!isDbgValueInDefinedReg(Prev) ||
1650 Prev->getOperand(0).getReg() != Reg)
1652 // Var is clobbered. Make sure the next instruction gets a label.
1653 History.push_back(MI);
1660 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1662 SmallVectorImpl<const MachineInstr*> &History = I->second;
1663 if (History.empty())
1666 // Make sure the final register assignments are terminated.
1667 const MachineInstr *Prev = History.back();
1668 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1669 const MachineBasicBlock *PrevMBB = Prev->getParent();
1670 MachineBasicBlock::const_iterator LastMI =
1671 PrevMBB->getLastNonDebugInstr();
1672 if (LastMI == PrevMBB->end())
1673 // Drop DBG_VALUE for empty range.
1675 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1676 // Terminate after LastMI.
1677 History.push_back(LastMI);
1680 // Request labels for the full history.
1681 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1682 const MachineInstr *MI = History[i];
1683 if (MI->isDebugValue())
1684 requestLabelBeforeInsn(MI);
1686 requestLabelAfterInsn(MI);
1690 PrevInstLoc = DebugLoc();
1691 PrevLabel = FunctionBeginSym;
1693 // Record beginning of function.
1694 if (!PrologEndLoc.isUnknown()) {
1695 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1696 MF->getFunction()->getContext());
1697 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1698 FnStartDL.getScope(MF->getFunction()->getContext()),
1699 // We'd like to list the prologue as "not statements" but GDB behaves
1700 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1701 DWARF2_FLAG_IS_STMT);
1705 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1706 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1707 DIVariable DV = Var->getVariable();
1708 // Variables with positive arg numbers are parameters.
1709 if (unsigned ArgNum = DV.getArgNumber()) {
1710 // Keep all parameters in order at the start of the variable list to ensure
1711 // function types are correct (no out-of-order parameters)
1713 // This could be improved by only doing it for optimized builds (unoptimized
1714 // builds have the right order to begin with), searching from the back (this
1715 // would catch the unoptimized case quickly), or doing a binary search
1716 // rather than linear search.
1717 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1718 while (I != Vars.end()) {
1719 unsigned CurNum = (*I)->getVariable().getArgNumber();
1720 // A local (non-parameter) variable has been found, insert immediately
1724 // A later indexed parameter has been found, insert immediately before it.
1725 if (CurNum > ArgNum)
1729 Vars.insert(I, Var);
1733 Vars.push_back(Var);
1736 // Gather and emit post-function debug information.
1737 void DwarfDebug::endFunction(const MachineFunction *MF) {
1738 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1740 // Define end label for subprogram.
1741 FunctionEndSym = Asm->GetTempSymbol("func_end",
1742 Asm->getFunctionNumber());
1743 // Assumes in correct section after the entry point.
1744 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1745 // Set DwarfCompileUnitID in MCContext to default value.
1746 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1748 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1749 collectVariableInfo(MF, ProcessedVars);
1751 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1752 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1753 assert(TheCU && "Unable to find compile unit!");
1755 // Construct abstract scopes.
1756 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1757 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1758 LexicalScope *AScope = AList[i];
1759 DISubprogram SP(AScope->getScopeNode());
1760 if (SP.isSubprogram()) {
1761 // Collect info for variables that were optimized out.
1762 DIArray Variables = SP.getVariables();
1763 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1764 DIVariable DV(Variables.getElement(i));
1765 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1767 // Check that DbgVariable for DV wasn't created earlier, when
1768 // findAbstractVariable() was called for inlined instance of DV.
1769 LLVMContext &Ctx = DV->getContext();
1770 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1771 if (AbstractVariables.lookup(CleanDV))
1773 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1774 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1777 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1778 constructScopeDIE(TheCU, AScope);
1781 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1783 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1784 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1787 for (ScopeVariablesMap::iterator
1788 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1789 DeleteContainerPointers(I->second);
1790 ScopeVariables.clear();
1791 DeleteContainerPointers(CurrentFnArguments);
1792 UserVariables.clear();
1794 AbstractVariables.clear();
1795 LabelsBeforeInsn.clear();
1796 LabelsAfterInsn.clear();
1800 // Register a source line with debug info. Returns the unique label that was
1801 // emitted and which provides correspondence to the source line list.
1802 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1808 DIDescriptor Scope(S);
1810 if (Scope.isCompileUnit()) {
1811 DICompileUnit CU(S);
1812 Fn = CU.getFilename();
1813 Dir = CU.getDirectory();
1814 } else if (Scope.isFile()) {
1816 Fn = F.getFilename();
1817 Dir = F.getDirectory();
1818 } else if (Scope.isSubprogram()) {
1820 Fn = SP.getFilename();
1821 Dir = SP.getDirectory();
1822 } else if (Scope.isLexicalBlockFile()) {
1823 DILexicalBlockFile DBF(S);
1824 Fn = DBF.getFilename();
1825 Dir = DBF.getDirectory();
1826 } else if (Scope.isLexicalBlock()) {
1827 DILexicalBlock DB(S);
1828 Fn = DB.getFilename();
1829 Dir = DB.getDirectory();
1831 llvm_unreachable("Unexpected scope info");
1833 Src = getOrCreateSourceID(Fn, Dir,
1834 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1836 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1839 //===----------------------------------------------------------------------===//
1841 //===----------------------------------------------------------------------===//
1843 // Compute the size and offset of a DIE.
1845 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1846 // Get the children.
1847 const std::vector<DIE *> &Children = Die->getChildren();
1849 // Record the abbreviation.
1850 assignAbbrevNumber(Die->getAbbrev());
1852 // Get the abbreviation for this DIE.
1853 unsigned AbbrevNumber = Die->getAbbrevNumber();
1854 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1857 Die->setOffset(Offset);
1859 // Start the size with the size of abbreviation code.
1860 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1862 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1863 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1865 // Size the DIE attribute values.
1866 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1867 // Size attribute value.
1868 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1870 // Size the DIE children if any.
1871 if (!Children.empty()) {
1872 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1873 "Children flag not set");
1875 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1876 Offset = computeSizeAndOffset(Children[j], Offset);
1878 // End of children marker.
1879 Offset += sizeof(int8_t);
1882 Die->setSize(Offset - Die->getOffset());
1886 // Compute the size and offset of all the DIEs.
1887 void DwarfUnits::computeSizeAndOffsets() {
1888 // Offset from the beginning of debug info section.
1889 unsigned SecOffset = 0;
1890 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1891 E = CUs.end(); I != E; ++I) {
1892 (*I)->setDebugInfoOffset(SecOffset);
1894 sizeof(int32_t) + // Length of Compilation Unit Info
1895 sizeof(int16_t) + // DWARF version number
1896 sizeof(int32_t) + // Offset Into Abbrev. Section
1897 sizeof(int8_t); // Pointer Size (in bytes)
1899 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1900 SecOffset += EndOffset;
1904 // Emit initial Dwarf sections with a label at the start of each one.
1905 void DwarfDebug::emitSectionLabels() {
1906 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1908 // Dwarf sections base addresses.
1909 DwarfInfoSectionSym =
1910 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1911 DwarfAbbrevSectionSym =
1912 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1913 if (useSplitDwarf())
1914 DwarfAbbrevDWOSectionSym =
1915 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1916 "section_abbrev_dwo");
1917 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1919 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1920 emitSectionSym(Asm, MacroInfo);
1922 DwarfLineSectionSym =
1923 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1924 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1925 if (GenerateDwarfPubNamesSection)
1926 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1927 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1928 DwarfStrSectionSym =
1929 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1930 if (useSplitDwarf()) {
1931 DwarfStrDWOSectionSym =
1932 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1933 DwarfAddrSectionSym =
1934 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1936 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1939 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1940 "section_debug_loc");
1942 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1943 emitSectionSym(Asm, TLOF.getDataSection());
1946 // Recursively emits a debug information entry.
1947 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1948 // Get the abbreviation for this DIE.
1949 unsigned AbbrevNumber = Die->getAbbrevNumber();
1950 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1952 // Emit the code (index) for the abbreviation.
1953 if (Asm->isVerbose())
1954 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1955 Twine::utohexstr(Die->getOffset()) + ":0x" +
1956 Twine::utohexstr(Die->getSize()) + " " +
1957 dwarf::TagString(Abbrev->getTag()));
1958 Asm->EmitULEB128(AbbrevNumber);
1960 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1961 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1963 // Emit the DIE attribute values.
1964 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1965 unsigned Attr = AbbrevData[i].getAttribute();
1966 unsigned Form = AbbrevData[i].getForm();
1967 assert(Form && "Too many attributes for DIE (check abbreviation)");
1969 if (Asm->isVerbose())
1970 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1973 case dwarf::DW_AT_abstract_origin: {
1974 DIEEntry *E = cast<DIEEntry>(Values[i]);
1975 DIE *Origin = E->getEntry();
1976 unsigned Addr = Origin->getOffset();
1977 if (Form == dwarf::DW_FORM_ref_addr) {
1978 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1979 // section. Origin->getOffset() returns the offset from start of the
1981 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1982 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1984 Asm->OutStreamer.EmitIntValue(Addr,
1985 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
1988 case dwarf::DW_AT_ranges: {
1989 // DW_AT_range Value encodes offset in debug_range section.
1990 DIEInteger *V = cast<DIEInteger>(Values[i]);
1992 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1993 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1997 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1999 DwarfDebugRangeSectionSym,
2004 case dwarf::DW_AT_location: {
2005 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2006 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2007 Asm->EmitLabelReference(L->getValue(), 4);
2009 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2011 Values[i]->EmitValue(Asm, Form);
2015 case dwarf::DW_AT_accessibility: {
2016 if (Asm->isVerbose()) {
2017 DIEInteger *V = cast<DIEInteger>(Values[i]);
2018 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2020 Values[i]->EmitValue(Asm, Form);
2024 // Emit an attribute using the defined form.
2025 Values[i]->EmitValue(Asm, Form);
2030 // Emit the DIE children if any.
2031 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2032 const std::vector<DIE *> &Children = Die->getChildren();
2034 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2035 emitDIE(Children[j], Abbrevs);
2037 if (Asm->isVerbose())
2038 Asm->OutStreamer.AddComment("End Of Children Mark");
2043 // Emit the various dwarf units to the unit section USection with
2044 // the abbreviations going into ASection.
2045 void DwarfUnits::emitUnits(DwarfDebug *DD,
2046 const MCSection *USection,
2047 const MCSection *ASection,
2048 const MCSymbol *ASectionSym) {
2049 Asm->OutStreamer.SwitchSection(USection);
2050 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2051 E = CUs.end(); I != E; ++I) {
2052 CompileUnit *TheCU = *I;
2053 DIE *Die = TheCU->getCUDie();
2055 // Emit the compile units header.
2057 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2058 TheCU->getUniqueID()));
2060 // Emit size of content not including length itself
2061 unsigned ContentSize = Die->getSize() +
2062 sizeof(int16_t) + // DWARF version number
2063 sizeof(int32_t) + // Offset Into Abbrev. Section
2064 sizeof(int8_t); // Pointer Size (in bytes)
2066 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2067 Asm->EmitInt32(ContentSize);
2068 Asm->OutStreamer.AddComment("DWARF version number");
2069 Asm->EmitInt16(DD->getDwarfVersion());
2070 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2071 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2073 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2074 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2076 DD->emitDIE(Die, Abbreviations);
2077 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2078 TheCU->getUniqueID()));
2082 /// For a given compile unit DIE, returns offset from beginning of debug info.
2083 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2084 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2085 "Input DIE should be compile unit in getCUOffset.");
2086 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2088 CompileUnit *TheCU = *I;
2089 if (TheCU->getCUDie() == Die)
2090 return TheCU->getDebugInfoOffset();
2092 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2095 // Emit the debug info section.
2096 void DwarfDebug::emitDebugInfo() {
2097 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2099 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2100 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2101 DwarfAbbrevSectionSym);
2104 // Emit the abbreviation section.
2105 void DwarfDebug::emitAbbreviations() {
2106 if (!useSplitDwarf())
2107 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2110 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2113 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2114 std::vector<DIEAbbrev *> *Abbrevs) {
2115 // Check to see if it is worth the effort.
2116 if (!Abbrevs->empty()) {
2117 // Start the debug abbrev section.
2118 Asm->OutStreamer.SwitchSection(Section);
2120 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2121 Asm->OutStreamer.EmitLabel(Begin);
2123 // For each abbrevation.
2124 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2125 // Get abbreviation data
2126 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2128 // Emit the abbrevations code (base 1 index.)
2129 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2131 // Emit the abbreviations data.
2135 // Mark end of abbreviations.
2136 Asm->EmitULEB128(0, "EOM(3)");
2138 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2139 Asm->OutStreamer.EmitLabel(End);
2143 // Emit the last address of the section and the end of the line matrix.
2144 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2145 // Define last address of section.
2146 Asm->OutStreamer.AddComment("Extended Op");
2149 Asm->OutStreamer.AddComment("Op size");
2150 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2151 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2152 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2154 Asm->OutStreamer.AddComment("Section end label");
2156 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2157 Asm->getDataLayout().getPointerSize());
2159 // Mark end of matrix.
2160 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2166 // Emit visible names into a hashed accelerator table section.
2167 void DwarfDebug::emitAccelNames() {
2168 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2169 dwarf::DW_FORM_data4));
2170 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2171 E = CUMap.end(); I != E; ++I) {
2172 CompileUnit *TheCU = I->second;
2173 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2174 for (StringMap<std::vector<DIE*> >::const_iterator
2175 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2176 StringRef Name = GI->getKey();
2177 const std::vector<DIE *> &Entities = GI->second;
2178 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2179 DE = Entities.end(); DI != DE; ++DI)
2180 AT.AddName(Name, (*DI));
2184 AT.FinalizeTable(Asm, "Names");
2185 Asm->OutStreamer.SwitchSection(
2186 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2187 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2188 Asm->OutStreamer.EmitLabel(SectionBegin);
2190 // Emit the full data.
2191 AT.Emit(Asm, SectionBegin, &InfoHolder);
2194 // Emit objective C classes and categories into a hashed accelerator table
2196 void DwarfDebug::emitAccelObjC() {
2197 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2198 dwarf::DW_FORM_data4));
2199 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2200 E = CUMap.end(); I != E; ++I) {
2201 CompileUnit *TheCU = I->second;
2202 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2203 for (StringMap<std::vector<DIE*> >::const_iterator
2204 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2205 StringRef Name = GI->getKey();
2206 const std::vector<DIE *> &Entities = GI->second;
2207 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2208 DE = Entities.end(); DI != DE; ++DI)
2209 AT.AddName(Name, (*DI));
2213 AT.FinalizeTable(Asm, "ObjC");
2214 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2215 .getDwarfAccelObjCSection());
2216 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2217 Asm->OutStreamer.EmitLabel(SectionBegin);
2219 // Emit the full data.
2220 AT.Emit(Asm, SectionBegin, &InfoHolder);
2223 // Emit namespace dies into a hashed accelerator table.
2224 void DwarfDebug::emitAccelNamespaces() {
2225 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2226 dwarf::DW_FORM_data4));
2227 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2228 E = CUMap.end(); I != E; ++I) {
2229 CompileUnit *TheCU = I->second;
2230 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2231 for (StringMap<std::vector<DIE*> >::const_iterator
2232 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2233 StringRef Name = GI->getKey();
2234 const std::vector<DIE *> &Entities = GI->second;
2235 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2236 DE = Entities.end(); DI != DE; ++DI)
2237 AT.AddName(Name, (*DI));
2241 AT.FinalizeTable(Asm, "namespac");
2242 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2243 .getDwarfAccelNamespaceSection());
2244 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2245 Asm->OutStreamer.EmitLabel(SectionBegin);
2247 // Emit the full data.
2248 AT.Emit(Asm, SectionBegin, &InfoHolder);
2251 // Emit type dies into a hashed accelerator table.
2252 void DwarfDebug::emitAccelTypes() {
2253 std::vector<DwarfAccelTable::Atom> Atoms;
2254 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2255 dwarf::DW_FORM_data4));
2256 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2257 dwarf::DW_FORM_data2));
2258 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2259 dwarf::DW_FORM_data1));
2260 DwarfAccelTable AT(Atoms);
2261 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2262 E = CUMap.end(); I != E; ++I) {
2263 CompileUnit *TheCU = I->second;
2264 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2265 = TheCU->getAccelTypes();
2266 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2267 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2268 StringRef Name = GI->getKey();
2269 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2270 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2271 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2272 AT.AddName(Name, (*DI).first, (*DI).second);
2276 AT.FinalizeTable(Asm, "types");
2277 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2278 .getDwarfAccelTypesSection());
2279 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2280 Asm->OutStreamer.EmitLabel(SectionBegin);
2282 // Emit the full data.
2283 AT.Emit(Asm, SectionBegin, &InfoHolder);
2286 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2288 void DwarfDebug::emitDebugPubnames() {
2289 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2291 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2292 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2293 CompileUnit *TheCU = I->second;
2294 unsigned ID = TheCU->getUniqueID();
2296 if (TheCU->getGlobalNames().empty())
2299 // Start the dwarf pubnames section.
2300 Asm->OutStreamer.SwitchSection(
2301 Asm->getObjFileLowering().getDwarfPubNamesSection());
2303 Asm->OutStreamer.AddComment("Length of Public Names Info");
2304 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2305 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2307 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2309 Asm->OutStreamer.AddComment("DWARF Version");
2310 Asm->EmitInt16(DwarfVersion);
2312 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2313 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2314 DwarfInfoSectionSym);
2316 Asm->OutStreamer.AddComment("Compilation Unit Length");
2317 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2318 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2321 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2322 for (StringMap<DIE*>::const_iterator
2323 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2324 const char *Name = GI->getKeyData();
2325 const DIE *Entity = GI->second;
2327 Asm->OutStreamer.AddComment("DIE offset");
2328 Asm->EmitInt32(Entity->getOffset());
2330 if (Asm->isVerbose())
2331 Asm->OutStreamer.AddComment("External Name");
2332 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2335 Asm->OutStreamer.AddComment("End Mark");
2337 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2341 void DwarfDebug::emitDebugPubTypes() {
2342 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2343 E = CUMap.end(); I != E; ++I) {
2344 CompileUnit *TheCU = I->second;
2345 // Start the dwarf pubtypes section.
2346 Asm->OutStreamer.SwitchSection(
2347 Asm->getObjFileLowering().getDwarfPubTypesSection());
2348 Asm->OutStreamer.AddComment("Length of Public Types Info");
2349 Asm->EmitLabelDifference(
2350 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2351 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2353 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2354 TheCU->getUniqueID()));
2356 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2357 Asm->EmitInt16(DwarfVersion);
2359 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2360 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2361 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2362 TheCU->getUniqueID()),
2363 DwarfInfoSectionSym);
2365 Asm->OutStreamer.AddComment("Compilation Unit Length");
2366 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2367 TheCU->getUniqueID()),
2368 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2369 TheCU->getUniqueID()),
2372 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2373 for (StringMap<DIE*>::const_iterator
2374 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2375 const char *Name = GI->getKeyData();
2376 DIE *Entity = GI->second;
2378 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2379 Asm->EmitInt32(Entity->getOffset());
2381 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2382 // Emit the name with a terminating null byte.
2383 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2386 Asm->OutStreamer.AddComment("End Mark");
2388 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2389 TheCU->getUniqueID()));
2393 // Emit strings into a string section.
2394 void DwarfUnits::emitStrings(const MCSection *StrSection,
2395 const MCSection *OffsetSection = NULL,
2396 const MCSymbol *StrSecSym = NULL) {
2398 if (StringPool.empty()) return;
2400 // Start the dwarf str section.
2401 Asm->OutStreamer.SwitchSection(StrSection);
2403 // Get all of the string pool entries and put them in an array by their ID so
2404 // we can sort them.
2405 SmallVector<std::pair<unsigned,
2406 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2408 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2409 I = StringPool.begin(), E = StringPool.end();
2411 Entries.push_back(std::make_pair(I->second.second, &*I));
2413 array_pod_sort(Entries.begin(), Entries.end());
2415 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2416 // Emit a label for reference from debug information entries.
2417 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2419 // Emit the string itself with a terminating null byte.
2420 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2421 Entries[i].second->getKeyLength()+1));
2424 // If we've got an offset section go ahead and emit that now as well.
2425 if (OffsetSection) {
2426 Asm->OutStreamer.SwitchSection(OffsetSection);
2427 unsigned offset = 0;
2428 unsigned size = 4; // FIXME: DWARF64 is 8.
2429 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2430 Asm->OutStreamer.EmitIntValue(offset, size);
2431 offset += Entries[i].second->getKeyLength() + 1;
2436 // Emit strings into a string section.
2437 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2439 if (AddressPool.empty()) return;
2441 // Start the dwarf addr section.
2442 Asm->OutStreamer.SwitchSection(AddrSection);
2444 // Order the address pool entries by ID
2445 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2447 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2448 E = AddressPool.end();
2450 Entries[I->second] = I->first;
2452 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2453 // Emit an expression for reference from debug information entries.
2454 if (const MCExpr *Expr = Entries[i])
2455 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2457 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2462 // Emit visible names into a debug str section.
2463 void DwarfDebug::emitDebugStr() {
2464 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2465 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2468 // Emit locations into the debug loc section.
2469 void DwarfDebug::emitDebugLoc() {
2470 if (DotDebugLocEntries.empty())
2473 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2474 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2476 DotDebugLocEntry &Entry = *I;
2477 if (I + 1 != DotDebugLocEntries.end())
2481 // Start the dwarf loc section.
2482 Asm->OutStreamer.SwitchSection(
2483 Asm->getObjFileLowering().getDwarfLocSection());
2484 unsigned char Size = Asm->getDataLayout().getPointerSize();
2485 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2487 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2488 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2489 I != E; ++I, ++index) {
2490 DotDebugLocEntry &Entry = *I;
2491 if (Entry.isMerged()) continue;
2492 if (Entry.isEmpty()) {
2493 Asm->OutStreamer.EmitIntValue(0, Size);
2494 Asm->OutStreamer.EmitIntValue(0, Size);
2495 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2497 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2498 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2499 DIVariable DV(Entry.getVariable());
2500 Asm->OutStreamer.AddComment("Loc expr size");
2501 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2502 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2503 Asm->EmitLabelDifference(end, begin, 2);
2504 Asm->OutStreamer.EmitLabel(begin);
2505 if (Entry.isInt()) {
2506 DIBasicType BTy(DV.getType());
2508 (BTy.getEncoding() == dwarf::DW_ATE_signed
2509 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2510 Asm->OutStreamer.AddComment("DW_OP_consts");
2511 Asm->EmitInt8(dwarf::DW_OP_consts);
2512 Asm->EmitSLEB128(Entry.getInt());
2514 Asm->OutStreamer.AddComment("DW_OP_constu");
2515 Asm->EmitInt8(dwarf::DW_OP_constu);
2516 Asm->EmitULEB128(Entry.getInt());
2518 } else if (Entry.isLocation()) {
2519 MachineLocation Loc = Entry.getLoc();
2520 if (!DV.hasComplexAddress())
2522 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2524 // Complex address entry.
2525 unsigned N = DV.getNumAddrElements();
2527 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2528 if (Loc.getOffset()) {
2530 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2531 Asm->OutStreamer.AddComment("DW_OP_deref");
2532 Asm->EmitInt8(dwarf::DW_OP_deref);
2533 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2534 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2535 Asm->EmitSLEB128(DV.getAddrElement(1));
2537 // If first address element is OpPlus then emit
2538 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2539 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2540 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2544 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2547 // Emit remaining complex address elements.
2548 for (; i < N; ++i) {
2549 uint64_t Element = DV.getAddrElement(i);
2550 if (Element == DIBuilder::OpPlus) {
2551 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2552 Asm->EmitULEB128(DV.getAddrElement(++i));
2553 } else if (Element == DIBuilder::OpDeref) {
2555 Asm->EmitInt8(dwarf::DW_OP_deref);
2557 llvm_unreachable("unknown Opcode found in complex address");
2561 // else ... ignore constant fp. There is not any good way to
2562 // to represent them here in dwarf.
2563 Asm->OutStreamer.EmitLabel(end);
2568 // Emit visible names into a debug aranges section.
2569 void DwarfDebug::emitDebugARanges() {
2570 // Start the dwarf aranges section.
2571 Asm->OutStreamer.SwitchSection(
2572 Asm->getObjFileLowering().getDwarfARangesSection());
2575 // Emit visible names into a debug ranges section.
2576 void DwarfDebug::emitDebugRanges() {
2577 // Start the dwarf ranges section.
2578 Asm->OutStreamer.SwitchSection(
2579 Asm->getObjFileLowering().getDwarfRangesSection());
2580 unsigned char Size = Asm->getDataLayout().getPointerSize();
2581 for (SmallVectorImpl<const MCSymbol *>::iterator
2582 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2585 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2587 Asm->OutStreamer.EmitIntValue(0, Size);
2591 // Emit visible names into a debug macinfo section.
2592 void DwarfDebug::emitDebugMacInfo() {
2593 if (const MCSection *LineInfo =
2594 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2595 // Start the dwarf macinfo section.
2596 Asm->OutStreamer.SwitchSection(LineInfo);
2600 // Emit inline info using following format.
2602 // 1. length of section
2603 // 2. Dwarf version number
2606 // Entries (one "entry" for each function that was inlined):
2608 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2609 // otherwise offset into __debug_str for regular function name.
2610 // 2. offset into __debug_str section for regular function name.
2611 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2612 // instances for the function.
2614 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2615 // inlined instance; the die_offset points to the inlined_subroutine die in the
2616 // __debug_info section, and the low_pc is the starting address for the
2617 // inlining instance.
2618 void DwarfDebug::emitDebugInlineInfo() {
2619 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2625 Asm->OutStreamer.SwitchSection(
2626 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2628 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2629 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2630 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2632 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2634 Asm->OutStreamer.AddComment("Dwarf Version");
2635 Asm->EmitInt16(DwarfVersion);
2636 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2637 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2639 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2640 E = InlinedSPNodes.end(); I != E; ++I) {
2642 const MDNode *Node = *I;
2643 InlineInfoMap::iterator II = InlineInfo.find(Node);
2644 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2645 DISubprogram SP(Node);
2646 StringRef LName = SP.getLinkageName();
2647 StringRef Name = SP.getName();
2649 Asm->OutStreamer.AddComment("MIPS linkage name");
2651 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2652 DwarfStrSectionSym);
2654 Asm->EmitSectionOffset(
2655 InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2656 DwarfStrSectionSym);
2658 Asm->OutStreamer.AddComment("Function name");
2659 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2660 DwarfStrSectionSym);
2661 Asm->EmitULEB128(Labels.size(), "Inline count");
2663 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2664 LE = Labels.end(); LI != LE; ++LI) {
2665 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2666 Asm->EmitInt32(LI->second->getOffset());
2668 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2669 Asm->OutStreamer.EmitSymbolValue(LI->first,
2670 Asm->getDataLayout().getPointerSize());
2674 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2677 // DWARF5 Experimental Separate Dwarf emitters.
2679 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2680 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2681 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2682 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2683 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2684 DICompileUnit DIUnit(N);
2685 CompilationDir = DIUnit.getDirectory();
2687 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2688 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2689 DIUnit.getLanguage(), Die, N, Asm,
2690 this, &SkeletonHolder);
2692 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2693 DIUnit.getSplitDebugFilename());
2695 // Relocate to the beginning of the addr_base section, else 0 for the
2696 // beginning of the one for this compile unit.
2697 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2698 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2699 DwarfAddrSectionSym);
2701 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2702 dwarf::DW_FORM_sec_offset, 0);
2704 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2705 // into an entity. We're using 0, or a NULL label for this.
2706 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2708 // DW_AT_stmt_list is a offset of line number information for this
2709 // compile unit in debug_line section.
2710 // FIXME: Should handle multiple compile units.
2711 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2712 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2713 DwarfLineSectionSym);
2715 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2717 if (!CompilationDir.empty())
2718 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2720 SkeletonHolder.addUnit(NewCU);
2721 SkeletonCUs.push_back(NewCU);
2726 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2727 assert(useSplitDwarf() && "No split dwarf debug info?");
2728 emitAbbrevs(Section, &SkeletonAbbrevs);
2731 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2732 // compile units that would normally be in debug_info.
2733 void DwarfDebug::emitDebugInfoDWO() {
2734 assert(useSplitDwarf() && "No split dwarf debug info?");
2735 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2736 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2737 DwarfAbbrevDWOSectionSym);
2740 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2741 // abbreviations for the .debug_info.dwo section.
2742 void DwarfDebug::emitDebugAbbrevDWO() {
2743 assert(useSplitDwarf() && "No split dwarf?");
2744 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2748 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2749 // string section and is identical in format to traditional .debug_str
2751 void DwarfDebug::emitDebugStrDWO() {
2752 assert(useSplitDwarf() && "No split dwarf?");
2753 const MCSection *OffSec = Asm->getObjFileLowering()
2754 .getDwarfStrOffDWOSection();
2755 const MCSymbol *StrSym = DwarfStrSectionSym;
2756 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),