1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "DwarfAccelTable.h"
18 #include "DwarfCompileUnit.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/DIBuilder.h"
26 #include "llvm/DebugInfo.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DataLayout.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/MC/MCAsmInfo.h"
32 #include "llvm/MC/MCSection.h"
33 #include "llvm/MC/MCStreamer.h"
34 #include "llvm/MC/MCSymbol.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/FormattedStream.h"
39 #include "llvm/Support/Path.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/Support/ValueHandle.h"
42 #include "llvm/Target/TargetFrameLowering.h"
43 #include "llvm/Target/TargetLoweringObjectFile.h"
44 #include "llvm/Target/TargetMachine.h"
45 #include "llvm/Target/TargetOptions.h"
46 #include "llvm/Target/TargetRegisterInfo.h"
49 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
51 cl::desc("Disable debug info printing"));
53 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
54 cl::desc("Make an absence of debug location information explicit."),
57 static cl::opt<bool> GenerateDwarfPubNamesSection("generate-dwarf-pubnames",
58 cl::Hidden, cl::init(false),
59 cl::desc("Generate DWARF pubnames section"));
63 Default, Enable, Disable
67 static cl::opt<DefaultOnOff> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
68 cl::desc("Output prototype dwarf accelerator tables."),
70 clEnumVal(Default, "Default for platform"),
71 clEnumVal(Enable, "Enabled"),
72 clEnumVal(Disable, "Disabled"),
76 static cl::opt<DefaultOnOff> DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
77 cl::desc("Compatibility with Darwin gdb."),
79 clEnumVal(Default, "Default for platform"),
80 clEnumVal(Enable, "Enabled"),
81 clEnumVal(Disable, "Disabled"),
85 static cl::opt<DefaultOnOff> SplitDwarf("split-dwarf", cl::Hidden,
86 cl::desc("Output prototype dwarf split debug info."),
88 clEnumVal(Default, "Default for platform"),
89 clEnumVal(Enable, "Enabled"),
90 clEnumVal(Disable, "Disabled"),
95 const char *DWARFGroupName = "DWARF Emission";
96 const char *DbgTimerName = "DWARF Debug Writer";
99 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
100 return lhs.first < rhs.first;
103 } // end anonymous namespace
105 //===----------------------------------------------------------------------===//
107 // Configuration values for initial hash set sizes (log2).
109 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
113 DIType DbgVariable::getType() const {
114 DIType Ty = Var.getType();
115 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
116 // addresses instead.
117 if (Var.isBlockByrefVariable()) {
118 /* Byref variables, in Blocks, are declared by the programmer as
119 "SomeType VarName;", but the compiler creates a
120 __Block_byref_x_VarName struct, and gives the variable VarName
121 either the struct, or a pointer to the struct, as its type. This
122 is necessary for various behind-the-scenes things the compiler
123 needs to do with by-reference variables in blocks.
125 However, as far as the original *programmer* is concerned, the
126 variable should still have type 'SomeType', as originally declared.
128 The following function dives into the __Block_byref_x_VarName
129 struct to find the original type of the variable. This will be
130 passed back to the code generating the type for the Debug
131 Information Entry for the variable 'VarName'. 'VarName' will then
132 have the original type 'SomeType' in its debug information.
134 The original type 'SomeType' will be the type of the field named
135 'VarName' inside the __Block_byref_x_VarName struct.
137 NOTE: In order for this to not completely fail on the debugger
138 side, the Debug Information Entry for the variable VarName needs to
139 have a DW_AT_location that tells the debugger how to unwind through
140 the pointers and __Block_byref_x_VarName struct to find the actual
141 value of the variable. The function addBlockByrefType does this. */
143 unsigned tag = Ty.getTag();
145 if (tag == dwarf::DW_TAG_pointer_type) {
146 DIDerivedType DTy = DIDerivedType(Ty);
147 subType = DTy.getTypeDerivedFrom();
150 DICompositeType blockStruct = DICompositeType(subType);
151 DIArray Elements = blockStruct.getTypeArray();
153 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
154 DIDescriptor Element = Elements.getElement(i);
155 DIDerivedType DT = DIDerivedType(Element);
156 if (getName() == DT.getName())
157 return (DT.getTypeDerivedFrom());
163 } // end llvm namespace
165 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
166 : Asm(A), MMI(Asm->MMI), FirstCU(0),
167 AbbreviationsSet(InitAbbreviationsSetSize),
168 SourceIdMap(DIEValueAllocator),
169 PrevLabel(NULL), GlobalCUIndexCount(0),
170 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
172 SkeletonAbbrevSet(InitAbbreviationsSetSize),
173 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
176 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
177 DwarfStrSectionSym = TextSectionSym = 0;
178 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
179 DwarfAddrSectionSym = 0;
180 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
181 FunctionBeginSym = FunctionEndSym = 0;
183 // Turn on accelerator tables and older gdb compatibility
185 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
186 if (DarwinGDBCompat == Default) {
188 IsDarwinGDBCompat = true;
190 IsDarwinGDBCompat = false;
192 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
194 if (DwarfAccelTables == Default) {
196 HasDwarfAccelTables = true;
198 HasDwarfAccelTables = false;
200 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
202 if (SplitDwarf == Default)
203 HasSplitDwarf = false;
205 HasSplitDwarf = SplitDwarf == Enable ? true : false;
208 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
212 DwarfDebug::~DwarfDebug() {
215 // Switch to the specified MCSection and emit an assembler
216 // temporary label to it if SymbolStem is specified.
217 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
218 const char *SymbolStem = 0) {
219 Asm->OutStreamer.SwitchSection(Section);
220 if (!SymbolStem) return 0;
222 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
223 Asm->OutStreamer.EmitLabel(TmpSym);
227 MCSymbol *DwarfUnits::getStringPoolSym() {
228 return Asm->GetTempSymbol(StringPref);
231 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
232 std::pair<MCSymbol*, unsigned> &Entry =
233 StringPool.GetOrCreateValue(Str).getValue();
234 if (Entry.first) return Entry.first;
236 Entry.second = NextStringPoolNumber++;
237 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
240 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
241 std::pair<MCSymbol*, unsigned> &Entry =
242 StringPool.GetOrCreateValue(Str).getValue();
243 if (Entry.first) return Entry.second;
245 Entry.second = NextStringPoolNumber++;
246 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
250 unsigned DwarfUnits::getAddrPoolIndex(MCSymbol *Sym) {
251 std::pair<MCSymbol*, unsigned> &Entry = AddressPool[Sym];
252 if (Entry.first) return Entry.second;
254 Entry.second = NextAddrPoolNumber++;
259 // Define a unique number for the abbreviation.
261 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
262 // Profile the node so that we can make it unique.
266 // Check the set for priors.
267 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
269 // If it's newly added.
270 if (InSet == &Abbrev) {
271 // Add to abbreviation list.
272 Abbreviations->push_back(&Abbrev);
274 // Assign the vector position + 1 as its number.
275 Abbrev.setNumber(Abbreviations->size());
277 // Assign existing abbreviation number.
278 Abbrev.setNumber(InSet->getNumber());
282 // If special LLVM prefix that is used to inform the asm
283 // printer to not emit usual symbol prefix before the symbol name is used then
284 // return linkage name after skipping this special LLVM prefix.
285 static StringRef getRealLinkageName(StringRef LinkageName) {
287 if (LinkageName.startswith(StringRef(&One, 1)))
288 return LinkageName.substr(1);
292 static bool isObjCClass(StringRef Name) {
293 return Name.startswith("+") || Name.startswith("-");
296 static bool hasObjCCategory(StringRef Name) {
297 if (!isObjCClass(Name)) return false;
299 size_t pos = Name.find(')');
300 if (pos != std::string::npos) {
301 if (Name[pos+1] != ' ') return false;
307 static void getObjCClassCategory(StringRef In, StringRef &Class,
308 StringRef &Category) {
309 if (!hasObjCCategory(In)) {
310 Class = In.slice(In.find('[') + 1, In.find(' '));
315 Class = In.slice(In.find('[') + 1, In.find('('));
316 Category = In.slice(In.find('[') + 1, In.find(' '));
320 static StringRef getObjCMethodName(StringRef In) {
321 return In.slice(In.find(' ') + 1, In.find(']'));
324 // Add the various names to the Dwarf accelerator table names.
325 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
327 if (!SP.isDefinition()) return;
329 TheCU->addAccelName(SP.getName(), Die);
331 // If the linkage name is different than the name, go ahead and output
332 // that as well into the name table.
333 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
334 TheCU->addAccelName(SP.getLinkageName(), Die);
336 // If this is an Objective-C selector name add it to the ObjC accelerator
338 if (isObjCClass(SP.getName())) {
339 StringRef Class, Category;
340 getObjCClassCategory(SP.getName(), Class, Category);
341 TheCU->addAccelObjC(Class, Die);
343 TheCU->addAccelObjC(Category, Die);
344 // Also add the base method name to the name table.
345 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
349 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
350 // and DW_AT_high_pc attributes. If there are global variables in this
351 // scope then create and insert DIEs for these variables.
352 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
353 const MDNode *SPNode) {
354 DIE *SPDie = SPCU->getDIE(SPNode);
356 assert(SPDie && "Unable to find subprogram DIE!");
357 DISubprogram SP(SPNode);
359 // If we're updating an abstract DIE, then we will be adding the children and
360 // object pointer later on. But what we don't want to do is process the
361 // concrete DIE twice.
362 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
364 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
365 // Pick up abstract subprogram DIE.
366 SPDie = new DIE(dwarf::DW_TAG_subprogram);
367 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
369 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
370 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
374 DISubprogram SPDecl = SP.getFunctionDeclaration();
375 if (!SPDecl.isSubprogram()) {
376 // There is not any need to generate specification DIE for a function
377 // defined at compile unit level. If a function is defined inside another
378 // function then gdb prefers the definition at top level and but does not
379 // expect specification DIE in parent function. So avoid creating
380 // specification DIE for a function defined inside a function.
381 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
382 !SP.getContext().isFile() &&
383 !isSubprogramContext(SP.getContext())) {
384 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
387 DICompositeType SPTy = SP.getType();
388 DIArray Args = SPTy.getTypeArray();
389 unsigned SPTag = SPTy.getTag();
390 if (SPTag == dwarf::DW_TAG_subroutine_type)
391 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
392 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
393 DIType ATy = DIType(Args.getElement(i));
394 SPCU->addType(Arg, ATy);
395 if (ATy.isArtificial())
396 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
397 if (ATy.isObjectPointer())
398 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
399 dwarf::DW_FORM_ref4, Arg);
400 SPDie->addChild(Arg);
402 DIE *SPDeclDie = SPDie;
403 SPDie = new DIE(dwarf::DW_TAG_subprogram);
404 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
405 dwarf::DW_FORM_ref4, SPDeclDie);
411 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
412 Asm->GetTempSymbol("func_begin",
413 Asm->getFunctionNumber()));
414 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
415 Asm->GetTempSymbol("func_end",
416 Asm->getFunctionNumber()));
417 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
418 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
419 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
421 // Add name to the name table, we do this here because we're guaranteed
422 // to have concrete versions of our DW_TAG_subprogram nodes.
423 addSubprogramNames(SPCU, SP, SPDie);
428 // Construct new DW_TAG_lexical_block for this scope and attach
429 // DW_AT_low_pc/DW_AT_high_pc labels.
430 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
431 LexicalScope *Scope) {
432 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
433 if (Scope->isAbstractScope())
436 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
440 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
441 if (Ranges.size() > 1) {
442 // .debug_range section has not been laid out yet. Emit offset in
443 // .debug_range as a uint, size 4, for now. emitDIE will handle
444 // DW_AT_ranges appropriately.
445 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
446 DebugRangeSymbols.size()
447 * Asm->getDataLayout().getPointerSize());
448 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
449 RE = Ranges.end(); RI != RE; ++RI) {
450 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
451 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
453 DebugRangeSymbols.push_back(NULL);
454 DebugRangeSymbols.push_back(NULL);
458 MCSymbol *Start = getLabelBeforeInsn(RI->first);
459 MCSymbol *End = getLabelAfterInsn(RI->second);
461 if (End == 0) return 0;
463 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
464 assert(End->isDefined() && "Invalid end label for an inlined scope!");
466 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
467 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
472 // This scope represents inlined body of a function. Construct DIE to
473 // represent this concrete inlined copy of the function.
474 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
475 LexicalScope *Scope) {
476 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
477 assert(Ranges.empty() == false &&
478 "LexicalScope does not have instruction markers!");
480 if (!Scope->getScopeNode())
482 DIScope DS(Scope->getScopeNode());
483 DISubprogram InlinedSP = getDISubprogram(DS);
484 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
486 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
490 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
491 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
492 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
494 if (StartLabel == 0 || EndLabel == 0) {
495 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
497 assert(StartLabel->isDefined() &&
498 "Invalid starting label for an inlined scope!");
499 assert(EndLabel->isDefined() &&
500 "Invalid end label for an inlined scope!");
502 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
503 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
504 dwarf::DW_FORM_ref4, OriginDIE);
506 if (Ranges.size() > 1) {
507 // .debug_range section has not been laid out yet. Emit offset in
508 // .debug_range as a uint, size 4, for now. emitDIE will handle
509 // DW_AT_ranges appropriately.
510 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
511 DebugRangeSymbols.size()
512 * Asm->getDataLayout().getPointerSize());
513 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
514 RE = Ranges.end(); RI != RE; ++RI) {
515 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
516 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
518 DebugRangeSymbols.push_back(NULL);
519 DebugRangeSymbols.push_back(NULL);
521 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
522 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
525 InlinedSubprogramDIEs.insert(OriginDIE);
527 // Track the start label for this inlined function.
528 //.debug_inlined section specification does not clearly state how
529 // to emit inlined scope that is split into multiple instruction ranges.
530 // For now, use first instruction range and emit low_pc/high_pc pair and
531 // corresponding .debug_inlined section entry for this pair.
532 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
533 I = InlineInfo.find(InlinedSP);
535 if (I == InlineInfo.end()) {
536 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
537 InlinedSPNodes.push_back(InlinedSP);
539 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
541 DILocation DL(Scope->getInlinedAt());
542 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
543 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
544 TheCU->getUniqueID()));
545 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
547 // Add name to the name table, we do this here because we're guaranteed
548 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
549 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
554 // Construct a DIE for this scope.
555 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
556 if (!Scope || !Scope->getScopeNode())
559 DIScope DS(Scope->getScopeNode());
560 // Early return to avoid creating dangling variable|scope DIEs.
561 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
565 SmallVector<DIE *, 8> Children;
566 DIE *ObjectPointer = NULL;
568 // Collect arguments for current function.
569 if (LScopes.isCurrentFunctionScope(Scope))
570 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
571 if (DbgVariable *ArgDV = CurrentFnArguments[i])
573 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
574 Children.push_back(Arg);
575 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
578 // Collect lexical scope children first.
579 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
580 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
582 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
583 Children.push_back(Variable);
584 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
586 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
587 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
588 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
589 Children.push_back(Nested);
590 DIE *ScopeDIE = NULL;
591 if (Scope->getInlinedAt())
592 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
593 else if (DS.isSubprogram()) {
594 ProcessedSPNodes.insert(DS);
595 if (Scope->isAbstractScope()) {
596 ScopeDIE = TheCU->getDIE(DS);
597 // Note down abstract DIE.
599 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
602 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
605 // There is no need to emit empty lexical block DIE.
606 std::pair<ImportedEntityMap::const_iterator,
607 ImportedEntityMap::const_iterator> Range = std::equal_range(
608 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
609 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
611 if (Children.empty() && Range.first == Range.second)
613 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
614 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second; ++i)
615 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
618 if (!ScopeDIE) return NULL;
621 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
622 E = Children.end(); I != E; ++I)
623 ScopeDIE->addChild(*I);
625 if (DS.isSubprogram() && ObjectPointer != NULL)
626 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
627 dwarf::DW_FORM_ref4, ObjectPointer);
629 if (DS.isSubprogram())
630 TheCU->addPubTypes(DISubprogram(DS));
635 // Look up the source id with the given directory and source file names.
636 // If none currently exists, create a new id and insert it in the
637 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
639 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
640 StringRef DirName, unsigned CUID) {
641 // If we use .loc in assembly, we can't separate .file entries according to
642 // compile units. Thus all files will belong to the default compile unit.
643 if (Asm->TM.hasMCUseLoc() &&
644 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
647 // If FE did not provide a file name, then assume stdin.
648 if (FileName.empty())
649 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
651 // TODO: this might not belong here. See if we can factor this better.
652 if (DirName == CompilationDir)
655 // FileIDCUMap stores the current ID for the given compile unit.
656 unsigned SrcId = FileIDCUMap[CUID] + 1;
658 // We look up the CUID/file/dir by concatenating them with a zero byte.
659 SmallString<128> NamePair;
660 NamePair += utostr(CUID);
663 NamePair += '\0'; // Zero bytes are not allowed in paths.
664 NamePair += FileName;
666 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
667 if (Ent.getValue() != SrcId)
668 return Ent.getValue();
670 FileIDCUMap[CUID] = SrcId;
671 // Print out a .file directive to specify files for .loc directives.
672 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
677 // Create new CompileUnit for the given metadata node with tag
678 // DW_TAG_compile_unit.
679 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
680 DICompileUnit DIUnit(N);
681 StringRef FN = DIUnit.getFilename();
682 CompilationDir = DIUnit.getDirectory();
684 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
685 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
686 DIUnit.getLanguage(), Die, N, Asm,
689 FileIDCUMap[NewCU->getUniqueID()] = 0;
690 // Call this to emit a .file directive if it wasn't emitted for the source
691 // file this CU comes from yet.
692 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
694 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
695 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
696 DIUnit.getLanguage());
697 NewCU->addString(Die, dwarf::DW_AT_name, FN);
699 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
700 // into an entity. We're using 0 (or a NULL label) for this. For
701 // split dwarf it's in the skeleton CU so omit it here.
702 if (!useSplitDwarf())
703 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
705 // Define start line table label for each Compile Unit.
706 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
707 NewCU->getUniqueID());
708 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
709 NewCU->getUniqueID());
711 // DW_AT_stmt_list is a offset of line number information for this
712 // compile unit in debug_line section. For split dwarf this is
713 // left in the skeleton CU and so not included.
714 // The line table entries are not always emitted in assembly, so it
715 // is not okay to use line_table_start here.
716 if (!useSplitDwarf()) {
717 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
718 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
719 NewCU->getUniqueID() == 0 ?
720 Asm->GetTempSymbol("section_line") : LineTableStartSym);
721 else if (NewCU->getUniqueID() == 0)
722 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
724 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
725 LineTableStartSym, DwarfLineSectionSym);
728 // If we're using split dwarf the compilation dir is going to be in the
729 // skeleton CU and so we don't need to duplicate it here.
730 if (!useSplitDwarf() && !CompilationDir.empty())
731 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
732 if (DIUnit.isOptimized())
733 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
735 StringRef Flags = DIUnit.getFlags();
737 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
739 if (unsigned RVer = DIUnit.getRunTimeVersion())
740 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
741 dwarf::DW_FORM_data1, RVer);
746 InfoHolder.addUnit(NewCU);
748 CUMap.insert(std::make_pair(N, NewCU));
752 // Construct subprogram DIE.
753 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
755 CompileUnit *&CURef = SPMap[N];
761 if (!SP.isDefinition())
762 // This is a method declaration which will be handled while constructing
766 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
769 TheCU->insertDIE(N, SubprogramDie);
771 // Add to context owner.
772 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
774 // Expose as global, if requested.
775 if (GenerateDwarfPubNamesSection)
776 TheCU->addGlobalName(SP.getName(), SubprogramDie);
779 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
781 DIImportedEntity Module(N);
782 if (!Module.Verify())
784 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
785 constructImportedEntityDIE(TheCU, Module, D);
788 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
790 DIImportedEntity Module(N);
791 if (!Module.Verify())
793 return constructImportedEntityDIE(TheCU, Module, Context);
796 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
797 const DIImportedEntity &Module,
799 assert(Module.Verify() &&
800 "Use one of the MDNode * overloads to handle invalid metadata");
801 assert(Context && "Should always have a context for an imported_module");
802 DIE *IMDie = new DIE(Module.getTag());
803 TheCU->insertDIE(Module, IMDie);
805 DIDescriptor Entity = Module.getEntity();
806 if (Entity.isNameSpace())
807 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
808 else if (Entity.isSubprogram())
809 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
810 else if (Entity.isType())
811 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
813 EntityDie = TheCU->getDIE(Entity);
814 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
815 Module.getContext().getDirectory(),
816 TheCU->getUniqueID());
817 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
818 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
819 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4, EntityDie);
820 Context->addChild(IMDie);
823 // Emit all Dwarf sections that should come prior to the content. Create
824 // global DIEs and emit initial debug info sections. This is invoked by
825 // the target AsmPrinter.
826 void DwarfDebug::beginModule() {
827 if (DisableDebugInfoPrinting)
830 const Module *M = MMI->getModule();
832 // If module has named metadata anchors then use them, otherwise scan the
833 // module using debug info finder to collect debug info.
834 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
838 // Emit initial sections so we can reference labels later.
841 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
842 DICompileUnit CUNode(CU_Nodes->getOperand(i));
843 CompileUnit *CU = constructCompileUnit(CUNode);
844 DIArray ImportedEntities = CUNode.getImportedEntities();
845 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
846 ScopesWithImportedEntities.push_back(std::make_pair(
847 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
848 ImportedEntities.getElement(i)));
849 std::sort(ScopesWithImportedEntities.begin(),
850 ScopesWithImportedEntities.end(), CompareFirst());
851 DIArray GVs = CUNode.getGlobalVariables();
852 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
853 CU->createGlobalVariableDIE(GVs.getElement(i));
854 DIArray SPs = CUNode.getSubprograms();
855 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
856 constructSubprogramDIE(CU, SPs.getElement(i));
857 DIArray EnumTypes = CUNode.getEnumTypes();
858 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
859 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
860 DIArray RetainedTypes = CUNode.getRetainedTypes();
861 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
862 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
863 // Emit imported_modules last so that the relevant context is already
865 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
866 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
867 // If we're splitting the dwarf out now that we've got the entire
868 // CU then construct a skeleton CU based upon it.
869 if (useSplitDwarf()) {
870 // This should be a unique identifier when we want to build .dwp files.
871 CU->addUInt(CU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
872 dwarf::DW_FORM_data8, 0);
873 // Now construct the skeleton CU associated.
874 constructSkeletonCU(CUNode);
878 // Tell MMI that we have debug info.
879 MMI->setDebugInfoAvailability(true);
881 // Prime section data.
882 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
885 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
886 void DwarfDebug::computeInlinedDIEs() {
887 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
888 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
889 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
891 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
893 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
894 AE = AbstractSPDies.end(); AI != AE; ++AI) {
895 DIE *ISP = AI->second;
896 if (InlinedSubprogramDIEs.count(ISP))
898 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
902 // Collect info for variables that were optimized out.
903 void DwarfDebug::collectDeadVariables() {
904 const Module *M = MMI->getModule();
905 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
907 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
908 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
909 DICompileUnit TheCU(CU_Nodes->getOperand(i));
910 DIArray Subprograms = TheCU.getSubprograms();
911 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
912 DISubprogram SP(Subprograms.getElement(i));
913 if (ProcessedSPNodes.count(SP) != 0) continue;
914 if (!SP.Verify()) continue;
915 if (!SP.isDefinition()) continue;
916 DIArray Variables = SP.getVariables();
917 if (Variables.getNumElements() == 0) continue;
919 LexicalScope *Scope =
920 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
921 DeadFnScopeMap[SP] = Scope;
923 // Construct subprogram DIE and add variables DIEs.
924 CompileUnit *SPCU = CUMap.lookup(TheCU);
925 assert(SPCU && "Unable to find Compile Unit!");
926 constructSubprogramDIE(SPCU, SP);
927 DIE *ScopeDIE = SPCU->getDIE(SP);
928 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
929 DIVariable DV(Variables.getElement(vi));
930 if (!DV.Verify()) continue;
931 DbgVariable *NewVar = new DbgVariable(DV, NULL);
932 if (DIE *VariableDIE =
933 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
934 ScopeDIE->addChild(VariableDIE);
939 DeleteContainerSeconds(DeadFnScopeMap);
942 void DwarfDebug::finalizeModuleInfo() {
943 // Collect info for variables that were optimized out.
944 collectDeadVariables();
946 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
947 computeInlinedDIEs();
949 // Emit DW_AT_containing_type attribute to connect types with their
950 // vtable holding type.
951 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
952 CUE = CUMap.end(); CUI != CUE; ++CUI) {
953 CompileUnit *TheCU = CUI->second;
954 TheCU->constructContainingTypeDIEs();
957 // Compute DIE offsets and sizes.
958 InfoHolder.computeSizeAndOffsets();
960 SkeletonHolder.computeSizeAndOffsets();
963 void DwarfDebug::endSections() {
964 // Standard sections final addresses.
965 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
966 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
967 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
968 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
970 // End text sections.
971 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
972 Asm->OutStreamer.SwitchSection(SectionMap[I]);
973 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
977 // Emit all Dwarf sections that should come after the content.
978 void DwarfDebug::endModule() {
980 if (!FirstCU) return;
982 // End any existing sections.
983 // TODO: Does this need to happen?
986 // Finalize the debug info for the module.
987 finalizeModuleInfo();
989 if (!useSplitDwarf()) {
990 // Emit all the DIEs into a debug info section.
993 // Corresponding abbreviations into a abbrev section.
996 // Emit info into a debug loc section.
999 // Emit info into a debug aranges section.
1002 // Emit info into a debug ranges section.
1005 // Emit info into a debug macinfo section.
1008 // Emit inline info.
1009 // TODO: When we don't need the option anymore we
1010 // can remove all of the code that this section
1012 if (useDarwinGDBCompat())
1013 emitDebugInlineInfo();
1015 // TODO: Fill this in for separated debug sections and separate
1016 // out information into new sections.
1018 // Emit the debug info section and compile units.
1022 // Corresponding abbreviations into a abbrev section.
1023 emitAbbreviations();
1024 emitDebugAbbrevDWO();
1026 // Emit info into a debug loc section.
1029 // Emit info into a debug aranges section.
1032 // Emit info into a debug ranges section.
1035 // Emit info into a debug macinfo section.
1038 // Emit DWO addresses.
1039 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1041 // Emit inline info.
1042 // TODO: When we don't need the option anymore we
1043 // can remove all of the code that this section
1045 if (useDarwinGDBCompat())
1046 emitDebugInlineInfo();
1049 // Emit info into the dwarf accelerator table sections.
1050 if (useDwarfAccelTables()) {
1053 emitAccelNamespaces();
1057 // Emit info into a debug pubnames section, if requested.
1058 if (GenerateDwarfPubNamesSection)
1059 emitDebugPubnames();
1061 // Emit info into a debug pubtypes section.
1062 // TODO: When we don't need the option anymore we can
1063 // remove all of the code that adds to the table.
1064 if (useDarwinGDBCompat())
1065 emitDebugPubTypes();
1067 // Finally emit string information into a string table.
1069 if (useSplitDwarf())
1074 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1075 E = CUMap.end(); I != E; ++I)
1078 for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
1079 E = SkeletonCUs.end(); I != E; ++I)
1082 // Reset these for the next Module if we have one.
1086 // Find abstract variable, if any, associated with Var.
1087 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1088 DebugLoc ScopeLoc) {
1089 LLVMContext &Ctx = DV->getContext();
1090 // More then one inlined variable corresponds to one abstract variable.
1091 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1092 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1094 return AbsDbgVariable;
1096 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1100 AbsDbgVariable = new DbgVariable(Var, NULL);
1101 addScopeVariable(Scope, AbsDbgVariable);
1102 AbstractVariables[Var] = AbsDbgVariable;
1103 return AbsDbgVariable;
1106 // If Var is a current function argument then add it to CurrentFnArguments list.
1107 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1108 DbgVariable *Var, LexicalScope *Scope) {
1109 if (!LScopes.isCurrentFunctionScope(Scope))
1111 DIVariable DV = Var->getVariable();
1112 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1114 unsigned ArgNo = DV.getArgNumber();
1118 size_t Size = CurrentFnArguments.size();
1120 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1121 // llvm::Function argument size is not good indicator of how many
1122 // arguments does the function have at source level.
1124 CurrentFnArguments.resize(ArgNo * 2);
1125 CurrentFnArguments[ArgNo - 1] = Var;
1129 // Collect variable information from side table maintained by MMI.
1131 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1132 SmallPtrSet<const MDNode *, 16> &Processed) {
1133 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1134 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1135 VE = VMap.end(); VI != VE; ++VI) {
1136 const MDNode *Var = VI->first;
1138 Processed.insert(Var);
1140 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1142 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1144 // If variable scope is not found then skip this variable.
1148 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1149 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1150 RegVar->setFrameIndex(VP.first);
1151 if (!addCurrentFnArgument(MF, RegVar, Scope))
1152 addScopeVariable(Scope, RegVar);
1154 AbsDbgVariable->setFrameIndex(VP.first);
1158 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1160 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1161 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1162 return MI->getNumOperands() == 3 &&
1163 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1164 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1167 // Get .debug_loc entry for the instruction range starting at MI.
1168 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1169 const MCSymbol *FLabel,
1170 const MCSymbol *SLabel,
1171 const MachineInstr *MI) {
1172 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1174 if (MI->getNumOperands() != 3) {
1175 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1176 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1178 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1179 MachineLocation MLoc;
1180 // TODO: Currently an offset of 0 in a DBG_VALUE means
1181 // we need to generate a direct register value.
1182 // There is no way to specify an indirect value with offset 0.
1183 if (MI->getOperand(1).getImm() == 0)
1184 MLoc.set(MI->getOperand(0).getReg());
1186 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1187 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1189 if (MI->getOperand(0).isImm())
1190 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1191 if (MI->getOperand(0).isFPImm())
1192 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1193 if (MI->getOperand(0).isCImm())
1194 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1196 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1199 // Find variables for each lexical scope.
1201 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1202 SmallPtrSet<const MDNode *, 16> &Processed) {
1204 // collection info from MMI table.
1205 collectVariableInfoFromMMITable(MF, Processed);
1207 for (SmallVectorImpl<const MDNode*>::const_iterator
1208 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1210 const MDNode *Var = *UVI;
1211 if (Processed.count(Var))
1214 // History contains relevant DBG_VALUE instructions for Var and instructions
1216 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1217 if (History.empty())
1219 const MachineInstr *MInsn = History.front();
1222 LexicalScope *Scope = NULL;
1223 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1224 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1225 Scope = LScopes.getCurrentFunctionScope();
1226 else if (MDNode *IA = DV.getInlinedAt())
1227 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1229 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1230 // If variable scope is not found then skip this variable.
1234 Processed.insert(DV);
1235 assert(MInsn->isDebugValue() && "History must begin with debug value");
1236 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1237 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1238 if (!addCurrentFnArgument(MF, RegVar, Scope))
1239 addScopeVariable(Scope, RegVar);
1241 AbsVar->setMInsn(MInsn);
1243 // Simplify ranges that are fully coalesced.
1244 if (History.size() <= 1 || (History.size() == 2 &&
1245 MInsn->isIdenticalTo(History.back()))) {
1246 RegVar->setMInsn(MInsn);
1250 // Handle multiple DBG_VALUE instructions describing one variable.
1251 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1253 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1254 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1255 const MachineInstr *Begin = *HI;
1256 assert(Begin->isDebugValue() && "Invalid History entry");
1258 // Check if DBG_VALUE is truncating a range.
1259 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1260 && !Begin->getOperand(0).getReg())
1263 // Compute the range for a register location.
1264 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1265 const MCSymbol *SLabel = 0;
1268 // If Begin is the last instruction in History then its value is valid
1269 // until the end of the function.
1270 SLabel = FunctionEndSym;
1272 const MachineInstr *End = HI[1];
1273 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1274 << "\t" << *Begin << "\t" << *End << "\n");
1275 if (End->isDebugValue())
1276 SLabel = getLabelBeforeInsn(End);
1278 // End is a normal instruction clobbering the range.
1279 SLabel = getLabelAfterInsn(End);
1280 assert(SLabel && "Forgot label after clobber instruction");
1285 // The value is valid until the next DBG_VALUE or clobber.
1286 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1289 DotDebugLocEntries.push_back(DotDebugLocEntry());
1292 // Collect info for variables that were optimized out.
1293 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1294 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1295 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1296 DIVariable DV(Variables.getElement(i));
1297 if (!DV || !DV.Verify() || !Processed.insert(DV))
1299 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1300 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1304 // Return Label preceding the instruction.
1305 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1306 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1307 assert(Label && "Didn't insert label before instruction");
1311 // Return Label immediately following the instruction.
1312 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1313 return LabelsAfterInsn.lookup(MI);
1316 // Process beginning of an instruction.
1317 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1318 // Check if source location changes, but ignore DBG_VALUE locations.
1319 if (!MI->isDebugValue()) {
1320 DebugLoc DL = MI->getDebugLoc();
1321 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1324 if (DL == PrologEndLoc) {
1325 Flags |= DWARF2_FLAG_PROLOGUE_END;
1326 PrologEndLoc = DebugLoc();
1328 if (PrologEndLoc.isUnknown())
1329 Flags |= DWARF2_FLAG_IS_STMT;
1331 if (!DL.isUnknown()) {
1332 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1333 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1335 recordSourceLine(0, 0, 0, 0);
1339 // Insert labels where requested.
1340 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1341 LabelsBeforeInsn.find(MI);
1344 if (I == LabelsBeforeInsn.end())
1347 // Label already assigned.
1352 PrevLabel = MMI->getContext().CreateTempSymbol();
1353 Asm->OutStreamer.EmitLabel(PrevLabel);
1355 I->second = PrevLabel;
1358 // Process end of an instruction.
1359 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1360 // Don't create a new label after DBG_VALUE instructions.
1361 // They don't generate code.
1362 if (!MI->isDebugValue())
1365 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1366 LabelsAfterInsn.find(MI);
1369 if (I == LabelsAfterInsn.end())
1372 // Label already assigned.
1376 // We need a label after this instruction.
1378 PrevLabel = MMI->getContext().CreateTempSymbol();
1379 Asm->OutStreamer.EmitLabel(PrevLabel);
1381 I->second = PrevLabel;
1384 // Each LexicalScope has first instruction and last instruction to mark
1385 // beginning and end of a scope respectively. Create an inverse map that list
1386 // scopes starts (and ends) with an instruction. One instruction may start (or
1387 // end) multiple scopes. Ignore scopes that are not reachable.
1388 void DwarfDebug::identifyScopeMarkers() {
1389 SmallVector<LexicalScope *, 4> WorkList;
1390 WorkList.push_back(LScopes.getCurrentFunctionScope());
1391 while (!WorkList.empty()) {
1392 LexicalScope *S = WorkList.pop_back_val();
1394 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1395 if (!Children.empty())
1396 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1397 SE = Children.end(); SI != SE; ++SI)
1398 WorkList.push_back(*SI);
1400 if (S->isAbstractScope())
1403 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1406 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1407 RE = Ranges.end(); RI != RE; ++RI) {
1408 assert(RI->first && "InsnRange does not have first instruction!");
1409 assert(RI->second && "InsnRange does not have second instruction!");
1410 requestLabelBeforeInsn(RI->first);
1411 requestLabelAfterInsn(RI->second);
1416 // Get MDNode for DebugLoc's scope.
1417 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1418 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1419 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1420 return DL.getScope(Ctx);
1423 // Walk up the scope chain of given debug loc and find line number info
1424 // for the function.
1425 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1426 const MDNode *Scope = getScopeNode(DL, Ctx);
1427 DISubprogram SP = getDISubprogram(Scope);
1429 // Check for number of operands since the compatibility is
1431 if (SP->getNumOperands() > 19)
1432 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1434 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1440 // Gather pre-function debug information. Assumes being called immediately
1441 // after the function entry point has been emitted.
1442 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1443 if (!MMI->hasDebugInfo()) return;
1444 LScopes.initialize(*MF);
1445 if (LScopes.empty()) return;
1446 identifyScopeMarkers();
1448 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1450 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1451 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1452 assert(TheCU && "Unable to find compile unit!");
1453 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1455 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1456 Asm->getFunctionNumber());
1457 // Assumes in correct section after the entry point.
1458 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1460 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1462 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1463 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1464 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1466 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1468 bool AtBlockEntry = true;
1469 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1471 const MachineInstr *MI = II;
1473 if (MI->isDebugValue()) {
1474 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1476 // Keep track of user variables.
1478 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1480 // Variable is in a register, we need to check for clobbers.
1481 if (isDbgValueInDefinedReg(MI))
1482 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1484 // Check the history of this variable.
1485 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1486 if (History.empty()) {
1487 UserVariables.push_back(Var);
1488 // The first mention of a function argument gets the FunctionBeginSym
1489 // label, so arguments are visible when breaking at function entry.
1491 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1492 DISubprogram(getDISubprogram(DV.getContext()))
1493 .describes(MF->getFunction()))
1494 LabelsBeforeInsn[MI] = FunctionBeginSym;
1496 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1497 const MachineInstr *Prev = History.back();
1498 if (Prev->isDebugValue()) {
1499 // Coalesce identical entries at the end of History.
1500 if (History.size() >= 2 &&
1501 Prev->isIdenticalTo(History[History.size() - 2])) {
1502 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1504 << "\t" << *History[History.size() - 2] << "\n");
1508 // Terminate old register assignments that don't reach MI;
1509 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1510 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1511 isDbgValueInDefinedReg(Prev)) {
1512 // Previous register assignment needs to terminate at the end of
1514 MachineBasicBlock::const_iterator LastMI =
1515 PrevMBB->getLastNonDebugInstr();
1516 if (LastMI == PrevMBB->end()) {
1517 // Drop DBG_VALUE for empty range.
1518 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1519 << "\t" << *Prev << "\n");
1523 // Terminate after LastMI.
1524 History.push_back(LastMI);
1529 History.push_back(MI);
1531 // Not a DBG_VALUE instruction.
1533 AtBlockEntry = false;
1535 // First known non-DBG_VALUE and non-frame setup location marks
1536 // the beginning of the function body.
1537 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1538 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1539 PrologEndLoc = MI->getDebugLoc();
1541 // Check if the instruction clobbers any registers with debug vars.
1542 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1543 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1544 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1546 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1547 AI.isValid(); ++AI) {
1549 const MDNode *Var = LiveUserVar[Reg];
1552 // Reg is now clobbered.
1553 LiveUserVar[Reg] = 0;
1555 // Was MD last defined by a DBG_VALUE referring to Reg?
1556 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1557 if (HistI == DbgValues.end())
1559 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1560 if (History.empty())
1562 const MachineInstr *Prev = History.back();
1563 // Sanity-check: Register assignments are terminated at the end of
1565 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1567 // Is the variable still in Reg?
1568 if (!isDbgValueInDefinedReg(Prev) ||
1569 Prev->getOperand(0).getReg() != Reg)
1571 // Var is clobbered. Make sure the next instruction gets a label.
1572 History.push_back(MI);
1579 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1581 SmallVectorImpl<const MachineInstr*> &History = I->second;
1582 if (History.empty())
1585 // Make sure the final register assignments are terminated.
1586 const MachineInstr *Prev = History.back();
1587 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1588 const MachineBasicBlock *PrevMBB = Prev->getParent();
1589 MachineBasicBlock::const_iterator LastMI =
1590 PrevMBB->getLastNonDebugInstr();
1591 if (LastMI == PrevMBB->end())
1592 // Drop DBG_VALUE for empty range.
1595 // Terminate after LastMI.
1596 History.push_back(LastMI);
1599 // Request labels for the full history.
1600 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1601 const MachineInstr *MI = History[i];
1602 if (MI->isDebugValue())
1603 requestLabelBeforeInsn(MI);
1605 requestLabelAfterInsn(MI);
1609 PrevInstLoc = DebugLoc();
1610 PrevLabel = FunctionBeginSym;
1612 // Record beginning of function.
1613 if (!PrologEndLoc.isUnknown()) {
1614 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1615 MF->getFunction()->getContext());
1616 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1617 FnStartDL.getScope(MF->getFunction()->getContext()),
1618 // We'd like to list the prologue as "not statements" but GDB behaves
1619 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1620 DWARF2_FLAG_IS_STMT);
1624 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1625 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1626 ScopeVariables[LS].push_back(Var);
1627 // Vars.push_back(Var);
1630 // Gather and emit post-function debug information.
1631 void DwarfDebug::endFunction(const MachineFunction *MF) {
1632 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1634 // Define end label for subprogram.
1635 FunctionEndSym = Asm->GetTempSymbol("func_end",
1636 Asm->getFunctionNumber());
1637 // Assumes in correct section after the entry point.
1638 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1639 // Set DwarfCompileUnitID in MCContext to default value.
1640 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1642 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1643 collectVariableInfo(MF, ProcessedVars);
1645 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1646 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1647 assert(TheCU && "Unable to find compile unit!");
1649 // Construct abstract scopes.
1650 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1651 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1652 LexicalScope *AScope = AList[i];
1653 DISubprogram SP(AScope->getScopeNode());
1655 // Collect info for variables that were optimized out.
1656 DIArray Variables = SP.getVariables();
1657 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1658 DIVariable DV(Variables.getElement(i));
1659 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1661 // Check that DbgVariable for DV wasn't created earlier, when
1662 // findAbstractVariable() was called for inlined instance of DV.
1663 LLVMContext &Ctx = DV->getContext();
1664 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1665 if (AbstractVariables.lookup(CleanDV))
1667 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1668 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1671 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1672 constructScopeDIE(TheCU, AScope);
1675 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1677 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1678 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1681 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1682 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1683 DeleteContainerPointers(I->second);
1684 ScopeVariables.clear();
1685 DeleteContainerPointers(CurrentFnArguments);
1686 UserVariables.clear();
1688 AbstractVariables.clear();
1689 LabelsBeforeInsn.clear();
1690 LabelsAfterInsn.clear();
1694 // Register a source line with debug info. Returns the unique label that was
1695 // emitted and which provides correspondence to the source line list.
1696 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1702 DIDescriptor Scope(S);
1704 if (Scope.isCompileUnit()) {
1705 DICompileUnit CU(S);
1706 Fn = CU.getFilename();
1707 Dir = CU.getDirectory();
1708 } else if (Scope.isFile()) {
1710 Fn = F.getFilename();
1711 Dir = F.getDirectory();
1712 } else if (Scope.isSubprogram()) {
1714 Fn = SP.getFilename();
1715 Dir = SP.getDirectory();
1716 } else if (Scope.isLexicalBlockFile()) {
1717 DILexicalBlockFile DBF(S);
1718 Fn = DBF.getFilename();
1719 Dir = DBF.getDirectory();
1720 } else if (Scope.isLexicalBlock()) {
1721 DILexicalBlock DB(S);
1722 Fn = DB.getFilename();
1723 Dir = DB.getDirectory();
1725 llvm_unreachable("Unexpected scope info");
1727 Src = getOrCreateSourceID(Fn, Dir,
1728 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1730 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1733 //===----------------------------------------------------------------------===//
1735 //===----------------------------------------------------------------------===//
1737 // Compute the size and offset of a DIE.
1739 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1740 // Get the children.
1741 const std::vector<DIE *> &Children = Die->getChildren();
1743 // Record the abbreviation.
1744 assignAbbrevNumber(Die->getAbbrev());
1746 // Get the abbreviation for this DIE.
1747 unsigned AbbrevNumber = Die->getAbbrevNumber();
1748 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1751 Die->setOffset(Offset);
1753 // Start the size with the size of abbreviation code.
1754 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1756 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1757 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1759 // Size the DIE attribute values.
1760 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1761 // Size attribute value.
1762 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1764 // Size the DIE children if any.
1765 if (!Children.empty()) {
1766 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1767 "Children flag not set");
1769 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1770 Offset = computeSizeAndOffset(Children[j], Offset);
1772 // End of children marker.
1773 Offset += sizeof(int8_t);
1776 Die->setSize(Offset - Die->getOffset());
1780 // Compute the size and offset of all the DIEs.
1781 void DwarfUnits::computeSizeAndOffsets() {
1782 // Offset from the beginning of debug info section.
1783 unsigned AccuOffset = 0;
1784 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1785 E = CUs.end(); I != E; ++I) {
1786 (*I)->setDebugInfoOffset(AccuOffset);
1788 sizeof(int32_t) + // Length of Compilation Unit Info
1789 sizeof(int16_t) + // DWARF version number
1790 sizeof(int32_t) + // Offset Into Abbrev. Section
1791 sizeof(int8_t); // Pointer Size (in bytes)
1793 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1794 AccuOffset += EndOffset;
1798 // Emit initial Dwarf sections with a label at the start of each one.
1799 void DwarfDebug::emitSectionLabels() {
1800 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1802 // Dwarf sections base addresses.
1803 DwarfInfoSectionSym =
1804 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1805 DwarfAbbrevSectionSym =
1806 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1807 if (useSplitDwarf())
1808 DwarfAbbrevDWOSectionSym =
1809 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1810 "section_abbrev_dwo");
1811 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1813 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1814 emitSectionSym(Asm, MacroInfo);
1816 DwarfLineSectionSym =
1817 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1818 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1819 if (GenerateDwarfPubNamesSection)
1820 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1821 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1822 DwarfStrSectionSym =
1823 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1824 if (useSplitDwarf()) {
1825 DwarfStrDWOSectionSym =
1826 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1827 DwarfAddrSectionSym =
1828 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1830 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1833 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1834 "section_debug_loc");
1836 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1837 emitSectionSym(Asm, TLOF.getDataSection());
1840 // Recursively emits a debug information entry.
1841 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1842 // Get the abbreviation for this DIE.
1843 unsigned AbbrevNumber = Die->getAbbrevNumber();
1844 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1846 // Emit the code (index) for the abbreviation.
1847 if (Asm->isVerbose())
1848 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1849 Twine::utohexstr(Die->getOffset()) + ":0x" +
1850 Twine::utohexstr(Die->getSize()) + " " +
1851 dwarf::TagString(Abbrev->getTag()));
1852 Asm->EmitULEB128(AbbrevNumber);
1854 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1855 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1857 // Emit the DIE attribute values.
1858 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1859 unsigned Attr = AbbrevData[i].getAttribute();
1860 unsigned Form = AbbrevData[i].getForm();
1861 assert(Form && "Too many attributes for DIE (check abbreviation)");
1863 if (Asm->isVerbose())
1864 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1867 case dwarf::DW_AT_abstract_origin: {
1868 DIEEntry *E = cast<DIEEntry>(Values[i]);
1869 DIE *Origin = E->getEntry();
1870 unsigned Addr = Origin->getOffset();
1871 if (Form == dwarf::DW_FORM_ref_addr) {
1872 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1873 // section. Origin->getOffset() returns the offset from start of the
1875 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1876 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1878 Asm->EmitInt32(Addr);
1881 case dwarf::DW_AT_ranges: {
1882 // DW_AT_range Value encodes offset in debug_range section.
1883 DIEInteger *V = cast<DIEInteger>(Values[i]);
1885 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1886 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1890 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1892 DwarfDebugRangeSectionSym,
1897 case dwarf::DW_AT_location: {
1898 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1899 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1900 Asm->EmitLabelReference(L->getValue(), 4);
1902 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1904 Values[i]->EmitValue(Asm, Form);
1908 case dwarf::DW_AT_accessibility: {
1909 if (Asm->isVerbose()) {
1910 DIEInteger *V = cast<DIEInteger>(Values[i]);
1911 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1913 Values[i]->EmitValue(Asm, Form);
1917 // Emit an attribute using the defined form.
1918 Values[i]->EmitValue(Asm, Form);
1923 // Emit the DIE children if any.
1924 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1925 const std::vector<DIE *> &Children = Die->getChildren();
1927 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1928 emitDIE(Children[j], Abbrevs);
1930 if (Asm->isVerbose())
1931 Asm->OutStreamer.AddComment("End Of Children Mark");
1936 // Emit the various dwarf units to the unit section USection with
1937 // the abbreviations going into ASection.
1938 void DwarfUnits::emitUnits(DwarfDebug *DD,
1939 const MCSection *USection,
1940 const MCSection *ASection,
1941 const MCSymbol *ASectionSym) {
1942 Asm->OutStreamer.SwitchSection(USection);
1943 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1944 E = CUs.end(); I != E; ++I) {
1945 CompileUnit *TheCU = *I;
1946 DIE *Die = TheCU->getCUDie();
1948 // Emit the compile units header.
1950 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1951 TheCU->getUniqueID()));
1953 // Emit size of content not including length itself
1954 unsigned ContentSize = Die->getSize() +
1955 sizeof(int16_t) + // DWARF version number
1956 sizeof(int32_t) + // Offset Into Abbrev. Section
1957 sizeof(int8_t); // Pointer Size (in bytes)
1959 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1960 Asm->EmitInt32(ContentSize);
1961 Asm->OutStreamer.AddComment("DWARF version number");
1962 Asm->EmitInt16(dwarf::DWARF_VERSION);
1963 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1964 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1966 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1967 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1969 DD->emitDIE(Die, Abbreviations);
1970 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1971 TheCU->getUniqueID()));
1975 /// For a given compile unit DIE, returns offset from beginning of debug info.
1976 unsigned DwarfUnits::getCUOffset(DIE *Die) {
1977 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
1978 "Input DIE should be compile unit in getCUOffset.");
1979 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1980 E = CUs.end(); I != E; ++I) {
1981 CompileUnit *TheCU = *I;
1982 if (TheCU->getCUDie() == Die)
1983 return TheCU->getDebugInfoOffset();
1985 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
1988 // Emit the debug info section.
1989 void DwarfDebug::emitDebugInfo() {
1990 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1992 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
1993 Asm->getObjFileLowering().getDwarfAbbrevSection(),
1994 DwarfAbbrevSectionSym);
1997 // Emit the abbreviation section.
1998 void DwarfDebug::emitAbbreviations() {
1999 if (!useSplitDwarf())
2000 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2003 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2006 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2007 std::vector<DIEAbbrev *> *Abbrevs) {
2008 // Check to see if it is worth the effort.
2009 if (!Abbrevs->empty()) {
2010 // Start the debug abbrev section.
2011 Asm->OutStreamer.SwitchSection(Section);
2013 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2014 Asm->OutStreamer.EmitLabel(Begin);
2016 // For each abbrevation.
2017 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2018 // Get abbreviation data
2019 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2021 // Emit the abbrevations code (base 1 index.)
2022 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2024 // Emit the abbreviations data.
2028 // Mark end of abbreviations.
2029 Asm->EmitULEB128(0, "EOM(3)");
2031 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2032 Asm->OutStreamer.EmitLabel(End);
2036 // Emit the last address of the section and the end of the line matrix.
2037 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2038 // Define last address of section.
2039 Asm->OutStreamer.AddComment("Extended Op");
2042 Asm->OutStreamer.AddComment("Op size");
2043 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2044 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2045 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2047 Asm->OutStreamer.AddComment("Section end label");
2049 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2050 Asm->getDataLayout().getPointerSize());
2052 // Mark end of matrix.
2053 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2059 // Emit visible names into a hashed accelerator table section.
2060 void DwarfDebug::emitAccelNames() {
2061 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2062 dwarf::DW_FORM_data4));
2063 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2064 E = CUMap.end(); I != E; ++I) {
2065 CompileUnit *TheCU = I->second;
2066 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2067 for (StringMap<std::vector<DIE*> >::const_iterator
2068 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2069 StringRef Name = GI->getKey();
2070 const std::vector<DIE *> &Entities = GI->second;
2071 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2072 DE = Entities.end(); DI != DE; ++DI)
2073 AT.AddName(Name, (*DI));
2077 AT.FinalizeTable(Asm, "Names");
2078 Asm->OutStreamer.SwitchSection(
2079 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2080 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2081 Asm->OutStreamer.EmitLabel(SectionBegin);
2083 // Emit the full data.
2084 AT.Emit(Asm, SectionBegin, &InfoHolder);
2087 // Emit objective C classes and categories into a hashed accelerator table
2089 void DwarfDebug::emitAccelObjC() {
2090 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2091 dwarf::DW_FORM_data4));
2092 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2093 E = CUMap.end(); I != E; ++I) {
2094 CompileUnit *TheCU = I->second;
2095 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2096 for (StringMap<std::vector<DIE*> >::const_iterator
2097 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2098 StringRef Name = GI->getKey();
2099 const std::vector<DIE *> &Entities = GI->second;
2100 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2101 DE = Entities.end(); DI != DE; ++DI)
2102 AT.AddName(Name, (*DI));
2106 AT.FinalizeTable(Asm, "ObjC");
2107 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2108 .getDwarfAccelObjCSection());
2109 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2110 Asm->OutStreamer.EmitLabel(SectionBegin);
2112 // Emit the full data.
2113 AT.Emit(Asm, SectionBegin, &InfoHolder);
2116 // Emit namespace dies into a hashed accelerator table.
2117 void DwarfDebug::emitAccelNamespaces() {
2118 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2119 dwarf::DW_FORM_data4));
2120 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2121 E = CUMap.end(); I != E; ++I) {
2122 CompileUnit *TheCU = I->second;
2123 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2124 for (StringMap<std::vector<DIE*> >::const_iterator
2125 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2126 StringRef Name = GI->getKey();
2127 const std::vector<DIE *> &Entities = GI->second;
2128 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2129 DE = Entities.end(); DI != DE; ++DI)
2130 AT.AddName(Name, (*DI));
2134 AT.FinalizeTable(Asm, "namespac");
2135 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2136 .getDwarfAccelNamespaceSection());
2137 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2138 Asm->OutStreamer.EmitLabel(SectionBegin);
2140 // Emit the full data.
2141 AT.Emit(Asm, SectionBegin, &InfoHolder);
2144 // Emit type dies into a hashed accelerator table.
2145 void DwarfDebug::emitAccelTypes() {
2146 std::vector<DwarfAccelTable::Atom> Atoms;
2147 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2148 dwarf::DW_FORM_data4));
2149 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2150 dwarf::DW_FORM_data2));
2151 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2152 dwarf::DW_FORM_data1));
2153 DwarfAccelTable AT(Atoms);
2154 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2155 E = CUMap.end(); I != E; ++I) {
2156 CompileUnit *TheCU = I->second;
2157 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2158 = TheCU->getAccelTypes();
2159 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2160 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2161 StringRef Name = GI->getKey();
2162 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2163 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2164 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2165 AT.AddName(Name, (*DI).first, (*DI).second);
2169 AT.FinalizeTable(Asm, "types");
2170 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2171 .getDwarfAccelTypesSection());
2172 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2173 Asm->OutStreamer.EmitLabel(SectionBegin);
2175 // Emit the full data.
2176 AT.Emit(Asm, SectionBegin, &InfoHolder);
2179 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2181 void DwarfDebug::emitDebugPubnames() {
2182 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2184 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2185 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2186 CompileUnit *TheCU = I->second;
2187 unsigned ID = TheCU->getUniqueID();
2189 if (TheCU->getGlobalNames().empty())
2192 // Start the dwarf pubnames section.
2193 Asm->OutStreamer.SwitchSection(
2194 Asm->getObjFileLowering().getDwarfPubNamesSection());
2196 Asm->OutStreamer.AddComment("Length of Public Names Info");
2197 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2198 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2200 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2202 Asm->OutStreamer.AddComment("DWARF Version");
2203 Asm->EmitInt16(dwarf::DWARF_VERSION);
2205 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2206 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2207 DwarfInfoSectionSym);
2209 Asm->OutStreamer.AddComment("Compilation Unit Length");
2210 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2211 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2214 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2215 for (StringMap<DIE*>::const_iterator
2216 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2217 const char *Name = GI->getKeyData();
2218 const DIE *Entity = GI->second;
2220 Asm->OutStreamer.AddComment("DIE offset");
2221 Asm->EmitInt32(Entity->getOffset());
2223 if (Asm->isVerbose())
2224 Asm->OutStreamer.AddComment("External Name");
2225 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2228 Asm->OutStreamer.AddComment("End Mark");
2230 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2234 void DwarfDebug::emitDebugPubTypes() {
2235 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2236 E = CUMap.end(); I != E; ++I) {
2237 CompileUnit *TheCU = I->second;
2238 // Start the dwarf pubtypes section.
2239 Asm->OutStreamer.SwitchSection(
2240 Asm->getObjFileLowering().getDwarfPubTypesSection());
2241 Asm->OutStreamer.AddComment("Length of Public Types Info");
2242 Asm->EmitLabelDifference(
2243 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2244 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2246 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2247 TheCU->getUniqueID()));
2249 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2250 Asm->EmitInt16(dwarf::DWARF_VERSION);
2252 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2253 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2254 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2255 TheCU->getUniqueID()),
2256 DwarfInfoSectionSym);
2258 Asm->OutStreamer.AddComment("Compilation Unit Length");
2259 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2260 TheCU->getUniqueID()),
2261 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2262 TheCU->getUniqueID()),
2265 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2266 for (StringMap<DIE*>::const_iterator
2267 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2268 const char *Name = GI->getKeyData();
2269 DIE *Entity = GI->second;
2271 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2272 Asm->EmitInt32(Entity->getOffset());
2274 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2275 // Emit the name with a terminating null byte.
2276 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2279 Asm->OutStreamer.AddComment("End Mark");
2281 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2282 TheCU->getUniqueID()));
2286 // Emit strings into a string section.
2287 void DwarfUnits::emitStrings(const MCSection *StrSection,
2288 const MCSection *OffsetSection = NULL,
2289 const MCSymbol *StrSecSym = NULL) {
2291 if (StringPool.empty()) return;
2293 // Start the dwarf str section.
2294 Asm->OutStreamer.SwitchSection(StrSection);
2296 // Get all of the string pool entries and put them in an array by their ID so
2297 // we can sort them.
2298 SmallVector<std::pair<unsigned,
2299 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2301 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2302 I = StringPool.begin(), E = StringPool.end();
2304 Entries.push_back(std::make_pair(I->second.second, &*I));
2306 array_pod_sort(Entries.begin(), Entries.end());
2308 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2309 // Emit a label for reference from debug information entries.
2310 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2312 // Emit the string itself with a terminating null byte.
2313 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2314 Entries[i].second->getKeyLength()+1));
2317 // If we've got an offset section go ahead and emit that now as well.
2318 if (OffsetSection) {
2319 Asm->OutStreamer.SwitchSection(OffsetSection);
2320 unsigned offset = 0;
2321 unsigned size = 4; // FIXME: DWARF64 is 8.
2322 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2323 Asm->OutStreamer.EmitIntValue(offset, size);
2324 offset += Entries[i].second->getKeyLength() + 1;
2329 // Emit strings into a string section.
2330 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2332 if (AddressPool.empty()) return;
2334 // Start the dwarf addr section.
2335 Asm->OutStreamer.SwitchSection(AddrSection);
2337 // Get all of the string pool entries and put them in an array by their ID so
2338 // we can sort them.
2339 SmallVector<std::pair<unsigned,
2340 std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2342 for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2343 I = AddressPool.begin(), E = AddressPool.end();
2345 Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2347 array_pod_sort(Entries.begin(), Entries.end());
2349 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2350 // Emit a label for reference from debug information entries.
2351 MCSymbol *Sym = Entries[i].second->first;
2353 Asm->EmitLabelReference(Entries[i].second->first,
2354 Asm->getDataLayout().getPointerSize());
2356 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2361 // Emit visible names into a debug str section.
2362 void DwarfDebug::emitDebugStr() {
2363 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2364 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2367 // Emit visible names into a debug loc section.
2368 void DwarfDebug::emitDebugLoc() {
2369 if (DotDebugLocEntries.empty())
2372 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2373 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2375 DotDebugLocEntry &Entry = *I;
2376 if (I + 1 != DotDebugLocEntries.end())
2380 // Start the dwarf loc section.
2381 Asm->OutStreamer.SwitchSection(
2382 Asm->getObjFileLowering().getDwarfLocSection());
2383 unsigned char Size = Asm->getDataLayout().getPointerSize();
2384 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2386 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2387 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2388 I != E; ++I, ++index) {
2389 DotDebugLocEntry &Entry = *I;
2390 if (Entry.isMerged()) continue;
2391 if (Entry.isEmpty()) {
2392 Asm->OutStreamer.EmitIntValue(0, Size);
2393 Asm->OutStreamer.EmitIntValue(0, Size);
2394 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2396 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2397 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
2398 DIVariable DV(Entry.Variable);
2399 Asm->OutStreamer.AddComment("Loc expr size");
2400 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2401 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2402 Asm->EmitLabelDifference(end, begin, 2);
2403 Asm->OutStreamer.EmitLabel(begin);
2404 if (Entry.isInt()) {
2405 DIBasicType BTy(DV.getType());
2407 (BTy.getEncoding() == dwarf::DW_ATE_signed
2408 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2409 Asm->OutStreamer.AddComment("DW_OP_consts");
2410 Asm->EmitInt8(dwarf::DW_OP_consts);
2411 Asm->EmitSLEB128(Entry.getInt());
2413 Asm->OutStreamer.AddComment("DW_OP_constu");
2414 Asm->EmitInt8(dwarf::DW_OP_constu);
2415 Asm->EmitULEB128(Entry.getInt());
2417 } else if (Entry.isLocation()) {
2418 if (!DV.hasComplexAddress())
2420 Asm->EmitDwarfRegOp(Entry.Loc);
2422 // Complex address entry.
2423 unsigned N = DV.getNumAddrElements();
2425 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2426 if (Entry.Loc.getOffset()) {
2428 Asm->EmitDwarfRegOp(Entry.Loc);
2429 Asm->OutStreamer.AddComment("DW_OP_deref");
2430 Asm->EmitInt8(dwarf::DW_OP_deref);
2431 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2432 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2433 Asm->EmitSLEB128(DV.getAddrElement(1));
2435 // If first address element is OpPlus then emit
2436 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2437 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2438 Asm->EmitDwarfRegOp(Loc);
2442 Asm->EmitDwarfRegOp(Entry.Loc);
2445 // Emit remaining complex address elements.
2446 for (; i < N; ++i) {
2447 uint64_t Element = DV.getAddrElement(i);
2448 if (Element == DIBuilder::OpPlus) {
2449 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2450 Asm->EmitULEB128(DV.getAddrElement(++i));
2451 } else if (Element == DIBuilder::OpDeref) {
2452 if (!Entry.Loc.isReg())
2453 Asm->EmitInt8(dwarf::DW_OP_deref);
2455 llvm_unreachable("unknown Opcode found in complex address");
2459 // else ... ignore constant fp. There is not any good way to
2460 // to represent them here in dwarf.
2461 Asm->OutStreamer.EmitLabel(end);
2466 // Emit visible names into a debug aranges section.
2467 void DwarfDebug::emitDebugARanges() {
2468 // Start the dwarf aranges section.
2469 Asm->OutStreamer.SwitchSection(
2470 Asm->getObjFileLowering().getDwarfARangesSection());
2473 // Emit visible names into a debug ranges section.
2474 void DwarfDebug::emitDebugRanges() {
2475 // Start the dwarf ranges section.
2476 Asm->OutStreamer.SwitchSection(
2477 Asm->getObjFileLowering().getDwarfRangesSection());
2478 unsigned char Size = Asm->getDataLayout().getPointerSize();
2479 for (SmallVectorImpl<const MCSymbol *>::iterator
2480 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2483 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2485 Asm->OutStreamer.EmitIntValue(0, Size);
2489 // Emit visible names into a debug macinfo section.
2490 void DwarfDebug::emitDebugMacInfo() {
2491 if (const MCSection *LineInfo =
2492 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2493 // Start the dwarf macinfo section.
2494 Asm->OutStreamer.SwitchSection(LineInfo);
2498 // Emit inline info using following format.
2500 // 1. length of section
2501 // 2. Dwarf version number
2504 // Entries (one "entry" for each function that was inlined):
2506 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2507 // otherwise offset into __debug_str for regular function name.
2508 // 2. offset into __debug_str section for regular function name.
2509 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2510 // instances for the function.
2512 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2513 // inlined instance; the die_offset points to the inlined_subroutine die in the
2514 // __debug_info section, and the low_pc is the starting address for the
2515 // inlining instance.
2516 void DwarfDebug::emitDebugInlineInfo() {
2517 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2523 Asm->OutStreamer.SwitchSection(
2524 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2526 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2527 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2528 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2530 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2532 Asm->OutStreamer.AddComment("Dwarf Version");
2533 Asm->EmitInt16(dwarf::DWARF_VERSION);
2534 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2535 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2537 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2538 E = InlinedSPNodes.end(); I != E; ++I) {
2540 const MDNode *Node = *I;
2541 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2542 = InlineInfo.find(Node);
2543 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2544 DISubprogram SP(Node);
2545 StringRef LName = SP.getLinkageName();
2546 StringRef Name = SP.getName();
2548 Asm->OutStreamer.AddComment("MIPS linkage name");
2550 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2551 DwarfStrSectionSym);
2553 Asm->EmitSectionOffset(InfoHolder
2554 .getStringPoolEntry(getRealLinkageName(LName)),
2555 DwarfStrSectionSym);
2557 Asm->OutStreamer.AddComment("Function name");
2558 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2559 DwarfStrSectionSym);
2560 Asm->EmitULEB128(Labels.size(), "Inline count");
2562 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2563 LE = Labels.end(); LI != LE; ++LI) {
2564 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2565 Asm->EmitInt32(LI->second->getOffset());
2567 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2568 Asm->OutStreamer.EmitSymbolValue(LI->first,
2569 Asm->getDataLayout().getPointerSize());
2573 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2576 // DWARF5 Experimental Separate Dwarf emitters.
2578 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2579 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2580 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2581 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2582 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2583 DICompileUnit DIUnit(N);
2584 CompilationDir = DIUnit.getDirectory();
2586 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2587 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2588 DIUnit.getLanguage(), Die, N, Asm,
2589 this, &SkeletonHolder);
2591 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2592 DIUnit.getSplitDebugFilename());
2594 // This should be a unique identifier when we want to build .dwp files.
2595 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2597 // Relocate to the beginning of the addr_base section, else 0 for the
2598 // beginning of the one for this compile unit.
2599 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2600 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2601 DwarfAddrSectionSym);
2603 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2604 dwarf::DW_FORM_sec_offset, 0);
2606 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2607 // into an entity. We're using 0, or a NULL label for this.
2608 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2610 // DW_AT_stmt_list is a offset of line number information for this
2611 // compile unit in debug_line section.
2612 // FIXME: Should handle multiple compile units.
2613 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2614 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2615 DwarfLineSectionSym);
2617 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2619 if (!CompilationDir.empty())
2620 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2622 SkeletonHolder.addUnit(NewCU);
2623 SkeletonCUs.push_back(NewCU);
2628 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2629 assert(useSplitDwarf() && "No split dwarf debug info?");
2630 emitAbbrevs(Section, &SkeletonAbbrevs);
2633 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2634 // compile units that would normally be in debug_info.
2635 void DwarfDebug::emitDebugInfoDWO() {
2636 assert(useSplitDwarf() && "No split dwarf debug info?");
2637 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2638 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2639 DwarfAbbrevDWOSectionSym);
2642 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2643 // abbreviations for the .debug_info.dwo section.
2644 void DwarfDebug::emitDebugAbbrevDWO() {
2645 assert(useSplitDwarf() && "No split dwarf?");
2646 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2650 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2651 // string section and is identical in format to traditional .debug_str
2653 void DwarfDebug::emitDebugStrDWO() {
2654 assert(useSplitDwarf() && "No split dwarf?");
2655 const MCSection *OffSec = Asm->getObjFileLowering()
2656 .getDwarfStrOffDWOSection();
2657 const MCSymbol *StrSym = DwarfStrSectionSym;
2658 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),