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 static bool isObjCClass(StringRef Name) {
283 return Name.startswith("+") || Name.startswith("-");
286 static bool hasObjCCategory(StringRef Name) {
287 if (!isObjCClass(Name)) return false;
289 size_t pos = Name.find(')');
290 if (pos != std::string::npos) {
291 if (Name[pos+1] != ' ') return false;
297 static void getObjCClassCategory(StringRef In, StringRef &Class,
298 StringRef &Category) {
299 if (!hasObjCCategory(In)) {
300 Class = In.slice(In.find('[') + 1, In.find(' '));
305 Class = In.slice(In.find('[') + 1, In.find('('));
306 Category = In.slice(In.find('[') + 1, In.find(' '));
310 static StringRef getObjCMethodName(StringRef In) {
311 return In.slice(In.find(' ') + 1, In.find(']'));
314 // Add the various names to the Dwarf accelerator table names.
315 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
317 if (!SP.isDefinition()) return;
319 TheCU->addAccelName(SP.getName(), Die);
321 // If the linkage name is different than the name, go ahead and output
322 // that as well into the name table.
323 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
324 TheCU->addAccelName(SP.getLinkageName(), Die);
326 // If this is an Objective-C selector name add it to the ObjC accelerator
328 if (isObjCClass(SP.getName())) {
329 StringRef Class, Category;
330 getObjCClassCategory(SP.getName(), Class, Category);
331 TheCU->addAccelObjC(Class, Die);
333 TheCU->addAccelObjC(Category, Die);
334 // Also add the base method name to the name table.
335 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
339 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
340 // and DW_AT_high_pc attributes. If there are global variables in this
341 // scope then create and insert DIEs for these variables.
342 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
343 const MDNode *SPNode) {
344 DIE *SPDie = SPCU->getDIE(SPNode);
346 assert(SPDie && "Unable to find subprogram DIE!");
347 DISubprogram SP(SPNode);
349 // If we're updating an abstract DIE, then we will be adding the children and
350 // object pointer later on. But what we don't want to do is process the
351 // concrete DIE twice.
352 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
354 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
355 // Pick up abstract subprogram DIE.
356 SPDie = new DIE(dwarf::DW_TAG_subprogram);
357 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
359 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
360 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
364 DISubprogram SPDecl = SP.getFunctionDeclaration();
365 if (!SPDecl.isSubprogram()) {
366 // There is not any need to generate specification DIE for a function
367 // defined at compile unit level. If a function is defined inside another
368 // function then gdb prefers the definition at top level and but does not
369 // expect specification DIE in parent function. So avoid creating
370 // specification DIE for a function defined inside a function.
371 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
372 !SP.getContext().isFile() &&
373 !isSubprogramContext(SP.getContext())) {
374 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
377 DICompositeType SPTy = SP.getType();
378 DIArray Args = SPTy.getTypeArray();
379 unsigned SPTag = SPTy.getTag();
380 if (SPTag == dwarf::DW_TAG_subroutine_type)
381 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
382 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
383 DIType ATy = DIType(Args.getElement(i));
384 SPCU->addType(Arg, ATy);
385 if (ATy.isArtificial())
386 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
387 if (ATy.isObjectPointer())
388 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
389 dwarf::DW_FORM_ref4, Arg);
390 SPDie->addChild(Arg);
392 DIE *SPDeclDie = SPDie;
393 SPDie = new DIE(dwarf::DW_TAG_subprogram);
394 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
395 dwarf::DW_FORM_ref4, SPDeclDie);
401 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
402 Asm->GetTempSymbol("func_begin",
403 Asm->getFunctionNumber()));
404 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
405 Asm->GetTempSymbol("func_end",
406 Asm->getFunctionNumber()));
407 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
408 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
409 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
411 // Add name to the name table, we do this here because we're guaranteed
412 // to have concrete versions of our DW_TAG_subprogram nodes.
413 addSubprogramNames(SPCU, SP, SPDie);
418 // Construct new DW_TAG_lexical_block for this scope and attach
419 // DW_AT_low_pc/DW_AT_high_pc labels.
420 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
421 LexicalScope *Scope) {
422 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
423 if (Scope->isAbstractScope())
426 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
430 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
431 if (Ranges.size() > 1) {
432 // .debug_range section has not been laid out yet. Emit offset in
433 // .debug_range as a uint, size 4, for now. emitDIE will handle
434 // DW_AT_ranges appropriately.
435 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
436 DebugRangeSymbols.size()
437 * Asm->getDataLayout().getPointerSize());
438 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
439 RE = Ranges.end(); RI != RE; ++RI) {
440 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
441 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
443 DebugRangeSymbols.push_back(NULL);
444 DebugRangeSymbols.push_back(NULL);
448 MCSymbol *Start = getLabelBeforeInsn(RI->first);
449 MCSymbol *End = getLabelAfterInsn(RI->second);
451 if (End == 0) return 0;
453 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
454 assert(End->isDefined() && "Invalid end label for an inlined scope!");
456 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
457 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
462 // This scope represents inlined body of a function. Construct DIE to
463 // represent this concrete inlined copy of the function.
464 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
465 LexicalScope *Scope) {
466 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
467 assert(Ranges.empty() == false &&
468 "LexicalScope does not have instruction markers!");
470 if (!Scope->getScopeNode())
472 DIScope DS(Scope->getScopeNode());
473 DISubprogram InlinedSP = getDISubprogram(DS);
474 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
476 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
480 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
481 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
482 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
484 if (StartLabel == 0 || EndLabel == 0) {
485 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
487 assert(StartLabel->isDefined() &&
488 "Invalid starting label for an inlined scope!");
489 assert(EndLabel->isDefined() &&
490 "Invalid end label for an inlined scope!");
492 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
493 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
494 dwarf::DW_FORM_ref4, OriginDIE);
496 if (Ranges.size() > 1) {
497 // .debug_range section has not been laid out yet. Emit offset in
498 // .debug_range as a uint, size 4, for now. emitDIE will handle
499 // DW_AT_ranges appropriately.
500 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
501 DebugRangeSymbols.size()
502 * Asm->getDataLayout().getPointerSize());
503 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
504 RE = Ranges.end(); RI != RE; ++RI) {
505 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
506 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
508 DebugRangeSymbols.push_back(NULL);
509 DebugRangeSymbols.push_back(NULL);
511 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
512 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
515 InlinedSubprogramDIEs.insert(OriginDIE);
517 // Track the start label for this inlined function.
518 //.debug_inlined section specification does not clearly state how
519 // to emit inlined scope that is split into multiple instruction ranges.
520 // For now, use first instruction range and emit low_pc/high_pc pair and
521 // corresponding .debug_inlined section entry for this pair.
522 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
523 I = InlineInfo.find(InlinedSP);
525 if (I == InlineInfo.end()) {
526 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
527 InlinedSPNodes.push_back(InlinedSP);
529 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
531 DILocation DL(Scope->getInlinedAt());
532 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
533 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
534 TheCU->getUniqueID()));
535 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
537 // Add name to the name table, we do this here because we're guaranteed
538 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
539 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
544 // Construct a DIE for this scope.
545 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
546 if (!Scope || !Scope->getScopeNode())
549 DIScope DS(Scope->getScopeNode());
550 // Early return to avoid creating dangling variable|scope DIEs.
551 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
555 SmallVector<DIE *, 8> Children;
556 DIE *ObjectPointer = NULL;
558 // Collect arguments for current function.
559 if (LScopes.isCurrentFunctionScope(Scope))
560 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
561 if (DbgVariable *ArgDV = CurrentFnArguments[i])
563 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
564 Children.push_back(Arg);
565 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
568 // Collect lexical scope children first.
569 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
570 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
572 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
573 Children.push_back(Variable);
574 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
576 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
577 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
578 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
579 Children.push_back(Nested);
580 DIE *ScopeDIE = NULL;
581 if (Scope->getInlinedAt())
582 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
583 else if (DS.isSubprogram()) {
584 ProcessedSPNodes.insert(DS);
585 if (Scope->isAbstractScope()) {
586 ScopeDIE = TheCU->getDIE(DS);
587 // Note down abstract DIE.
589 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
592 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
595 // There is no need to emit empty lexical block DIE.
596 std::pair<ImportedEntityMap::const_iterator,
597 ImportedEntityMap::const_iterator> Range = std::equal_range(
598 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
599 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
601 if (Children.empty() && Range.first == Range.second)
603 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
604 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second; ++i)
605 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
608 if (!ScopeDIE) return NULL;
611 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
612 E = Children.end(); I != E; ++I)
613 ScopeDIE->addChild(*I);
615 if (DS.isSubprogram() && ObjectPointer != NULL)
616 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
617 dwarf::DW_FORM_ref4, ObjectPointer);
619 if (DS.isSubprogram())
620 TheCU->addPubTypes(DISubprogram(DS));
625 // Look up the source id with the given directory and source file names.
626 // If none currently exists, create a new id and insert it in the
627 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
629 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
630 StringRef DirName, unsigned CUID) {
631 // If we use .loc in assembly, we can't separate .file entries according to
632 // compile units. Thus all files will belong to the default compile unit.
633 if (Asm->TM.hasMCUseLoc() &&
634 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
637 // If FE did not provide a file name, then assume stdin.
638 if (FileName.empty())
639 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
641 // TODO: this might not belong here. See if we can factor this better.
642 if (DirName == CompilationDir)
645 // FileIDCUMap stores the current ID for the given compile unit.
646 unsigned SrcId = FileIDCUMap[CUID] + 1;
648 // We look up the CUID/file/dir by concatenating them with a zero byte.
649 SmallString<128> NamePair;
650 NamePair += utostr(CUID);
653 NamePair += '\0'; // Zero bytes are not allowed in paths.
654 NamePair += FileName;
656 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
657 if (Ent.getValue() != SrcId)
658 return Ent.getValue();
660 FileIDCUMap[CUID] = SrcId;
661 // Print out a .file directive to specify files for .loc directives.
662 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
667 // Create new CompileUnit for the given metadata node with tag
668 // DW_TAG_compile_unit.
669 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
670 DICompileUnit DIUnit(N);
671 StringRef FN = DIUnit.getFilename();
672 CompilationDir = DIUnit.getDirectory();
674 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
675 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
676 DIUnit.getLanguage(), Die, N, Asm,
679 FileIDCUMap[NewCU->getUniqueID()] = 0;
680 // Call this to emit a .file directive if it wasn't emitted for the source
681 // file this CU comes from yet.
682 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
684 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
685 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
686 DIUnit.getLanguage());
687 NewCU->addString(Die, dwarf::DW_AT_name, FN);
689 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
690 // into an entity. We're using 0 (or a NULL label) for this. For
691 // split dwarf it's in the skeleton CU so omit it here.
692 if (!useSplitDwarf())
693 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
695 // Define start line table label for each Compile Unit.
696 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
697 NewCU->getUniqueID());
698 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
699 NewCU->getUniqueID());
701 // Use a single line table if we are using .loc and generating assembly.
703 (Asm->TM.hasMCUseLoc() &&
704 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
705 (NewCU->getUniqueID() == 0);
707 // DW_AT_stmt_list is a offset of line number information for this
708 // compile unit in debug_line section. For split dwarf this is
709 // left in the skeleton CU and so not included.
710 // The line table entries are not always emitted in assembly, so it
711 // is not okay to use line_table_start here.
712 if (!useSplitDwarf()) {
713 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
714 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
716 Asm->GetTempSymbol("section_line") : LineTableStartSym);
717 else if (UseTheFirstCU)
718 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
720 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
721 LineTableStartSym, DwarfLineSectionSym);
724 // If we're using split dwarf the compilation dir is going to be in the
725 // skeleton CU and so we don't need to duplicate it here.
726 if (!useSplitDwarf() && !CompilationDir.empty())
727 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
728 if (DIUnit.isOptimized())
729 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
731 StringRef Flags = DIUnit.getFlags();
733 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
735 if (unsigned RVer = DIUnit.getRunTimeVersion())
736 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
737 dwarf::DW_FORM_data1, RVer);
742 InfoHolder.addUnit(NewCU);
744 CUMap.insert(std::make_pair(N, NewCU));
748 // Construct subprogram DIE.
749 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
751 CompileUnit *&CURef = SPMap[N];
757 if (!SP.isDefinition())
758 // This is a method declaration which will be handled while constructing
762 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
765 TheCU->insertDIE(N, SubprogramDie);
767 // Add to context owner.
768 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
770 // Expose as global, if requested.
771 if (GenerateDwarfPubNamesSection)
772 TheCU->addGlobalName(SP.getName(), SubprogramDie);
775 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
777 DIImportedEntity Module(N);
778 if (!Module.Verify())
780 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
781 constructImportedEntityDIE(TheCU, Module, D);
784 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
786 DIImportedEntity Module(N);
787 if (!Module.Verify())
789 return constructImportedEntityDIE(TheCU, Module, Context);
792 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
793 const DIImportedEntity &Module,
795 assert(Module.Verify() &&
796 "Use one of the MDNode * overloads to handle invalid metadata");
797 assert(Context && "Should always have a context for an imported_module");
798 DIE *IMDie = new DIE(Module.getTag());
799 TheCU->insertDIE(Module, IMDie);
801 DIDescriptor Entity = Module.getEntity();
802 if (Entity.isNameSpace())
803 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
804 else if (Entity.isSubprogram())
805 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
806 else if (Entity.isType())
807 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
809 EntityDie = TheCU->getDIE(Entity);
810 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
811 Module.getContext().getDirectory(),
812 TheCU->getUniqueID());
813 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
814 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
815 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4, EntityDie);
816 StringRef Name = Module.getName();
818 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
819 Context->addChild(IMDie);
822 // Emit all Dwarf sections that should come prior to the content. Create
823 // global DIEs and emit initial debug info sections. This is invoked by
824 // the target AsmPrinter.
825 void DwarfDebug::beginModule() {
826 if (DisableDebugInfoPrinting)
829 const Module *M = MMI->getModule();
831 // If module has named metadata anchors then use them, otherwise scan the
832 // module using debug info finder to collect debug info.
833 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
837 // Emit initial sections so we can reference labels later.
840 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
841 DICompileUnit CUNode(CU_Nodes->getOperand(i));
842 CompileUnit *CU = constructCompileUnit(CUNode);
843 DIArray ImportedEntities = CUNode.getImportedEntities();
844 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
845 ScopesWithImportedEntities.push_back(std::make_pair(
846 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
847 ImportedEntities.getElement(i)));
848 std::sort(ScopesWithImportedEntities.begin(),
849 ScopesWithImportedEntities.end(), CompareFirst());
850 DIArray GVs = CUNode.getGlobalVariables();
851 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
852 CU->createGlobalVariableDIE(GVs.getElement(i));
853 DIArray SPs = CUNode.getSubprograms();
854 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
855 constructSubprogramDIE(CU, SPs.getElement(i));
856 DIArray EnumTypes = CUNode.getEnumTypes();
857 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
858 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
859 DIArray RetainedTypes = CUNode.getRetainedTypes();
860 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
861 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
862 // Emit imported_modules last so that the relevant context is already
864 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
865 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
866 // If we're splitting the dwarf out now that we've got the entire
867 // CU then construct a skeleton CU based upon it.
868 if (useSplitDwarf()) {
869 // This should be a unique identifier when we want to build .dwp files.
870 CU->addUInt(CU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
871 dwarf::DW_FORM_data8, 0);
872 // Now construct the skeleton CU associated.
873 constructSkeletonCU(CUNode);
877 // Tell MMI that we have debug info.
878 MMI->setDebugInfoAvailability(true);
880 // Prime section data.
881 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
884 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
885 void DwarfDebug::computeInlinedDIEs() {
886 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
887 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
888 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
890 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
892 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
893 AE = AbstractSPDies.end(); AI != AE; ++AI) {
894 DIE *ISP = AI->second;
895 if (InlinedSubprogramDIEs.count(ISP))
897 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
901 // Collect info for variables that were optimized out.
902 void DwarfDebug::collectDeadVariables() {
903 const Module *M = MMI->getModule();
904 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
906 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
907 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
908 DICompileUnit TheCU(CU_Nodes->getOperand(i));
909 DIArray Subprograms = TheCU.getSubprograms();
910 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
911 DISubprogram SP(Subprograms.getElement(i));
912 if (ProcessedSPNodes.count(SP) != 0) continue;
913 if (!SP.Verify()) continue;
914 if (!SP.isDefinition()) continue;
915 DIArray Variables = SP.getVariables();
916 if (Variables.getNumElements() == 0) continue;
918 LexicalScope *Scope =
919 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
920 DeadFnScopeMap[SP] = Scope;
922 // Construct subprogram DIE and add variables DIEs.
923 CompileUnit *SPCU = CUMap.lookup(TheCU);
924 assert(SPCU && "Unable to find Compile Unit!");
925 constructSubprogramDIE(SPCU, SP);
926 DIE *ScopeDIE = SPCU->getDIE(SP);
927 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
928 DIVariable DV(Variables.getElement(vi));
929 if (!DV.Verify()) continue;
930 DbgVariable *NewVar = new DbgVariable(DV, NULL);
931 if (DIE *VariableDIE =
932 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
933 ScopeDIE->addChild(VariableDIE);
938 DeleteContainerSeconds(DeadFnScopeMap);
941 void DwarfDebug::finalizeModuleInfo() {
942 // Collect info for variables that were optimized out.
943 collectDeadVariables();
945 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
946 computeInlinedDIEs();
948 // Emit DW_AT_containing_type attribute to connect types with their
949 // vtable holding type.
950 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
951 CUE = CUMap.end(); CUI != CUE; ++CUI) {
952 CompileUnit *TheCU = CUI->second;
953 TheCU->constructContainingTypeDIEs();
956 // Compute DIE offsets and sizes.
957 InfoHolder.computeSizeAndOffsets();
959 SkeletonHolder.computeSizeAndOffsets();
962 void DwarfDebug::endSections() {
963 // Standard sections final addresses.
964 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
965 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
966 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
967 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
969 // End text sections.
970 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
971 Asm->OutStreamer.SwitchSection(SectionMap[I]);
972 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
976 // Emit all Dwarf sections that should come after the content.
977 void DwarfDebug::endModule() {
979 if (!FirstCU) return;
981 // End any existing sections.
982 // TODO: Does this need to happen?
985 // Finalize the debug info for the module.
986 finalizeModuleInfo();
988 if (!useSplitDwarf()) {
989 // Emit all the DIEs into a debug info section.
992 // Corresponding abbreviations into a abbrev section.
995 // Emit info into a debug loc section.
998 // Emit info into a debug aranges section.
1001 // Emit info into a debug ranges section.
1004 // Emit info into a debug macinfo section.
1007 // Emit inline info.
1008 // TODO: When we don't need the option anymore we
1009 // can remove all of the code that this section
1011 if (useDarwinGDBCompat())
1012 emitDebugInlineInfo();
1014 // TODO: Fill this in for separated debug sections and separate
1015 // out information into new sections.
1017 // Emit the debug info section and compile units.
1021 // Corresponding abbreviations into a abbrev section.
1022 emitAbbreviations();
1023 emitDebugAbbrevDWO();
1025 // Emit info into a debug loc section.
1028 // Emit info into a debug aranges section.
1031 // Emit info into a debug ranges section.
1034 // Emit info into a debug macinfo section.
1037 // Emit DWO addresses.
1038 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1040 // Emit inline info.
1041 // TODO: When we don't need the option anymore we
1042 // can remove all of the code that this section
1044 if (useDarwinGDBCompat())
1045 emitDebugInlineInfo();
1048 // Emit info into the dwarf accelerator table sections.
1049 if (useDwarfAccelTables()) {
1052 emitAccelNamespaces();
1056 // Emit info into a debug pubnames section, if requested.
1057 if (GenerateDwarfPubNamesSection)
1058 emitDebugPubnames();
1060 // Emit info into a debug pubtypes section.
1061 // TODO: When we don't need the option anymore we can
1062 // remove all of the code that adds to the table.
1063 if (useDarwinGDBCompat())
1064 emitDebugPubTypes();
1066 // Finally emit string information into a string table.
1068 if (useSplitDwarf())
1073 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1074 E = CUMap.end(); I != E; ++I)
1077 for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
1078 E = SkeletonCUs.end(); I != E; ++I)
1081 // Reset these for the next Module if we have one.
1085 // Find abstract variable, if any, associated with Var.
1086 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1087 DebugLoc ScopeLoc) {
1088 LLVMContext &Ctx = DV->getContext();
1089 // More then one inlined variable corresponds to one abstract variable.
1090 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1091 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1093 return AbsDbgVariable;
1095 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1099 AbsDbgVariable = new DbgVariable(Var, NULL);
1100 addScopeVariable(Scope, AbsDbgVariable);
1101 AbstractVariables[Var] = AbsDbgVariable;
1102 return AbsDbgVariable;
1105 // If Var is a current function argument then add it to CurrentFnArguments list.
1106 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1107 DbgVariable *Var, LexicalScope *Scope) {
1108 if (!LScopes.isCurrentFunctionScope(Scope))
1110 DIVariable DV = Var->getVariable();
1111 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1113 unsigned ArgNo = DV.getArgNumber();
1117 size_t Size = CurrentFnArguments.size();
1119 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1120 // llvm::Function argument size is not good indicator of how many
1121 // arguments does the function have at source level.
1123 CurrentFnArguments.resize(ArgNo * 2);
1124 CurrentFnArguments[ArgNo - 1] = Var;
1128 // Collect variable information from side table maintained by MMI.
1130 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1131 SmallPtrSet<const MDNode *, 16> &Processed) {
1132 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1133 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1134 VE = VMap.end(); VI != VE; ++VI) {
1135 const MDNode *Var = VI->first;
1137 Processed.insert(Var);
1139 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1141 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1143 // If variable scope is not found then skip this variable.
1147 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1148 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1149 RegVar->setFrameIndex(VP.first);
1150 if (!addCurrentFnArgument(MF, RegVar, Scope))
1151 addScopeVariable(Scope, RegVar);
1153 AbsDbgVariable->setFrameIndex(VP.first);
1157 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1159 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1160 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1161 return MI->getNumOperands() == 3 &&
1162 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1163 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1166 // Get .debug_loc entry for the instruction range starting at MI.
1167 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1168 const MCSymbol *FLabel,
1169 const MCSymbol *SLabel,
1170 const MachineInstr *MI) {
1171 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1173 assert(MI->getNumOperands() == 3);
1174 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1175 MachineLocation MLoc;
1176 // TODO: Currently an offset of 0 in a DBG_VALUE means
1177 // we need to generate a direct register value.
1178 // There is no way to specify an indirect value with offset 0.
1179 if (MI->getOperand(1).getImm() == 0)
1180 MLoc.set(MI->getOperand(0).getReg());
1182 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1183 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1185 if (MI->getOperand(0).isImm())
1186 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1187 if (MI->getOperand(0).isFPImm())
1188 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1189 if (MI->getOperand(0).isCImm())
1190 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1192 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1195 // Find variables for each lexical scope.
1197 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1198 SmallPtrSet<const MDNode *, 16> &Processed) {
1200 // collection info from MMI table.
1201 collectVariableInfoFromMMITable(MF, Processed);
1203 for (SmallVectorImpl<const MDNode*>::const_iterator
1204 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1206 const MDNode *Var = *UVI;
1207 if (Processed.count(Var))
1210 // History contains relevant DBG_VALUE instructions for Var and instructions
1212 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1213 if (History.empty())
1215 const MachineInstr *MInsn = History.front();
1218 LexicalScope *Scope = NULL;
1219 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1220 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1221 Scope = LScopes.getCurrentFunctionScope();
1222 else if (MDNode *IA = DV.getInlinedAt())
1223 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1225 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1226 // If variable scope is not found then skip this variable.
1230 Processed.insert(DV);
1231 assert(MInsn->isDebugValue() && "History must begin with debug value");
1232 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1233 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1234 if (!addCurrentFnArgument(MF, RegVar, Scope))
1235 addScopeVariable(Scope, RegVar);
1237 AbsVar->setMInsn(MInsn);
1239 // Simplify ranges that are fully coalesced.
1240 if (History.size() <= 1 || (History.size() == 2 &&
1241 MInsn->isIdenticalTo(History.back()))) {
1242 RegVar->setMInsn(MInsn);
1246 // Handle multiple DBG_VALUE instructions describing one variable.
1247 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1249 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1250 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1251 const MachineInstr *Begin = *HI;
1252 assert(Begin->isDebugValue() && "Invalid History entry");
1254 // Check if DBG_VALUE is truncating a range.
1255 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1256 && !Begin->getOperand(0).getReg())
1259 // Compute the range for a register location.
1260 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1261 const MCSymbol *SLabel = 0;
1264 // If Begin is the last instruction in History then its value is valid
1265 // until the end of the function.
1266 SLabel = FunctionEndSym;
1268 const MachineInstr *End = HI[1];
1269 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1270 << "\t" << *Begin << "\t" << *End << "\n");
1271 if (End->isDebugValue())
1272 SLabel = getLabelBeforeInsn(End);
1274 // End is a normal instruction clobbering the range.
1275 SLabel = getLabelAfterInsn(End);
1276 assert(SLabel && "Forgot label after clobber instruction");
1281 // The value is valid until the next DBG_VALUE or clobber.
1282 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1285 DotDebugLocEntries.push_back(DotDebugLocEntry());
1288 // Collect info for variables that were optimized out.
1289 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1290 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1291 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1292 DIVariable DV(Variables.getElement(i));
1293 if (!DV || !DV.Verify() || !Processed.insert(DV))
1295 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1296 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1300 // Return Label preceding the instruction.
1301 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1302 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1303 assert(Label && "Didn't insert label before instruction");
1307 // Return Label immediately following the instruction.
1308 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1309 return LabelsAfterInsn.lookup(MI);
1312 // Process beginning of an instruction.
1313 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1314 // Check if source location changes, but ignore DBG_VALUE locations.
1315 if (!MI->isDebugValue()) {
1316 DebugLoc DL = MI->getDebugLoc();
1317 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1320 if (DL == PrologEndLoc) {
1321 Flags |= DWARF2_FLAG_PROLOGUE_END;
1322 PrologEndLoc = DebugLoc();
1324 if (PrologEndLoc.isUnknown())
1325 Flags |= DWARF2_FLAG_IS_STMT;
1327 if (!DL.isUnknown()) {
1328 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1329 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1331 recordSourceLine(0, 0, 0, 0);
1335 // Insert labels where requested.
1336 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1337 LabelsBeforeInsn.find(MI);
1340 if (I == LabelsBeforeInsn.end())
1343 // Label already assigned.
1348 PrevLabel = MMI->getContext().CreateTempSymbol();
1349 Asm->OutStreamer.EmitLabel(PrevLabel);
1351 I->second = PrevLabel;
1354 // Process end of an instruction.
1355 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1356 // Don't create a new label after DBG_VALUE instructions.
1357 // They don't generate code.
1358 if (!MI->isDebugValue())
1361 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1362 LabelsAfterInsn.find(MI);
1365 if (I == LabelsAfterInsn.end())
1368 // Label already assigned.
1372 // We need a label after this instruction.
1374 PrevLabel = MMI->getContext().CreateTempSymbol();
1375 Asm->OutStreamer.EmitLabel(PrevLabel);
1377 I->second = PrevLabel;
1380 // Each LexicalScope has first instruction and last instruction to mark
1381 // beginning and end of a scope respectively. Create an inverse map that list
1382 // scopes starts (and ends) with an instruction. One instruction may start (or
1383 // end) multiple scopes. Ignore scopes that are not reachable.
1384 void DwarfDebug::identifyScopeMarkers() {
1385 SmallVector<LexicalScope *, 4> WorkList;
1386 WorkList.push_back(LScopes.getCurrentFunctionScope());
1387 while (!WorkList.empty()) {
1388 LexicalScope *S = WorkList.pop_back_val();
1390 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1391 if (!Children.empty())
1392 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1393 SE = Children.end(); SI != SE; ++SI)
1394 WorkList.push_back(*SI);
1396 if (S->isAbstractScope())
1399 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1402 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1403 RE = Ranges.end(); RI != RE; ++RI) {
1404 assert(RI->first && "InsnRange does not have first instruction!");
1405 assert(RI->second && "InsnRange does not have second instruction!");
1406 requestLabelBeforeInsn(RI->first);
1407 requestLabelAfterInsn(RI->second);
1412 // Get MDNode for DebugLoc's scope.
1413 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1414 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1415 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1416 return DL.getScope(Ctx);
1419 // Walk up the scope chain of given debug loc and find line number info
1420 // for the function.
1421 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1422 const MDNode *Scope = getScopeNode(DL, Ctx);
1423 DISubprogram SP = getDISubprogram(Scope);
1425 // Check for number of operands since the compatibility is
1427 if (SP->getNumOperands() > 19)
1428 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1430 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1436 // Gather pre-function debug information. Assumes being called immediately
1437 // after the function entry point has been emitted.
1438 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1439 if (!MMI->hasDebugInfo()) return;
1440 LScopes.initialize(*MF);
1441 if (LScopes.empty()) return;
1442 identifyScopeMarkers();
1444 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1446 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1447 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1448 assert(TheCU && "Unable to find compile unit!");
1449 if (Asm->TM.hasMCUseLoc() &&
1450 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1451 // Use a single line table if we are using .loc and generating assembly.
1452 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1454 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1456 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1457 Asm->getFunctionNumber());
1458 // Assumes in correct section after the entry point.
1459 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1461 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1463 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1464 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1465 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1467 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1469 bool AtBlockEntry = true;
1470 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1472 const MachineInstr *MI = II;
1474 if (MI->isDebugValue()) {
1475 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1477 // Keep track of user variables.
1479 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1481 // Variable is in a register, we need to check for clobbers.
1482 if (isDbgValueInDefinedReg(MI))
1483 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1485 // Check the history of this variable.
1486 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1487 if (History.empty()) {
1488 UserVariables.push_back(Var);
1489 // The first mention of a function argument gets the FunctionBeginSym
1490 // label, so arguments are visible when breaking at function entry.
1492 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1493 DISubprogram(getDISubprogram(DV.getContext()))
1494 .describes(MF->getFunction()))
1495 LabelsBeforeInsn[MI] = FunctionBeginSym;
1497 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1498 const MachineInstr *Prev = History.back();
1499 if (Prev->isDebugValue()) {
1500 // Coalesce identical entries at the end of History.
1501 if (History.size() >= 2 &&
1502 Prev->isIdenticalTo(History[History.size() - 2])) {
1503 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1505 << "\t" << *History[History.size() - 2] << "\n");
1509 // Terminate old register assignments that don't reach MI;
1510 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1511 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1512 isDbgValueInDefinedReg(Prev)) {
1513 // Previous register assignment needs to terminate at the end of
1515 MachineBasicBlock::const_iterator LastMI =
1516 PrevMBB->getLastNonDebugInstr();
1517 if (LastMI == PrevMBB->end()) {
1518 // Drop DBG_VALUE for empty range.
1519 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1520 << "\t" << *Prev << "\n");
1522 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1523 // Terminate after LastMI.
1524 History.push_back(LastMI);
1528 History.push_back(MI);
1530 // Not a DBG_VALUE instruction.
1532 AtBlockEntry = false;
1534 // First known non-DBG_VALUE and non-frame setup location marks
1535 // the beginning of the function body.
1536 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1537 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1538 PrologEndLoc = MI->getDebugLoc();
1540 // Check if the instruction clobbers any registers with debug vars.
1541 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1542 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1543 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1545 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1546 AI.isValid(); ++AI) {
1548 const MDNode *Var = LiveUserVar[Reg];
1551 // Reg is now clobbered.
1552 LiveUserVar[Reg] = 0;
1554 // Was MD last defined by a DBG_VALUE referring to Reg?
1555 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1556 if (HistI == DbgValues.end())
1558 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1559 if (History.empty())
1561 const MachineInstr *Prev = History.back();
1562 // Sanity-check: Register assignments are terminated at the end of
1564 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1566 // Is the variable still in Reg?
1567 if (!isDbgValueInDefinedReg(Prev) ||
1568 Prev->getOperand(0).getReg() != Reg)
1570 // Var is clobbered. Make sure the next instruction gets a label.
1571 History.push_back(MI);
1578 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1580 SmallVectorImpl<const MachineInstr*> &History = I->second;
1581 if (History.empty())
1584 // Make sure the final register assignments are terminated.
1585 const MachineInstr *Prev = History.back();
1586 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1587 const MachineBasicBlock *PrevMBB = Prev->getParent();
1588 MachineBasicBlock::const_iterator LastMI =
1589 PrevMBB->getLastNonDebugInstr();
1590 if (LastMI == PrevMBB->end())
1591 // Drop DBG_VALUE for empty range.
1593 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1594 // Terminate after LastMI.
1595 History.push_back(LastMI);
1598 // Request labels for the full history.
1599 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1600 const MachineInstr *MI = History[i];
1601 if (MI->isDebugValue())
1602 requestLabelBeforeInsn(MI);
1604 requestLabelAfterInsn(MI);
1608 PrevInstLoc = DebugLoc();
1609 PrevLabel = FunctionBeginSym;
1611 // Record beginning of function.
1612 if (!PrologEndLoc.isUnknown()) {
1613 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1614 MF->getFunction()->getContext());
1615 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1616 FnStartDL.getScope(MF->getFunction()->getContext()),
1617 // We'd like to list the prologue as "not statements" but GDB behaves
1618 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1619 DWARF2_FLAG_IS_STMT);
1623 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1624 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1625 DIVariable DV = Var->getVariable();
1626 // Variables with positive arg numbers are parameters.
1627 if (unsigned ArgNum = DV.getArgNumber()) {
1628 // Keep all parameters in order at the start of the variable list to ensure
1629 // function types are correct (no out-of-order parameters)
1631 // This could be improved by only doing it for optimized builds (unoptimized
1632 // builds have the right order to begin with), searching from the back (this
1633 // would catch the unoptimized case quickly), or doing a binary search
1634 // rather than linear search.
1635 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1636 while (I != Vars.end()) {
1637 unsigned CurNum = (*I)->getVariable().getArgNumber();
1638 // A local (non-parameter) variable has been found, insert immediately
1642 // A later indexed parameter has been found, insert immediately before it.
1643 if (CurNum > ArgNum)
1647 Vars.insert(I, Var);
1651 Vars.push_back(Var);
1654 // Gather and emit post-function debug information.
1655 void DwarfDebug::endFunction(const MachineFunction *MF) {
1656 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1658 // Define end label for subprogram.
1659 FunctionEndSym = Asm->GetTempSymbol("func_end",
1660 Asm->getFunctionNumber());
1661 // Assumes in correct section after the entry point.
1662 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1663 // Set DwarfCompileUnitID in MCContext to default value.
1664 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1666 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1667 collectVariableInfo(MF, ProcessedVars);
1669 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1670 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1671 assert(TheCU && "Unable to find compile unit!");
1673 // Construct abstract scopes.
1674 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1675 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1676 LexicalScope *AScope = AList[i];
1677 DISubprogram SP(AScope->getScopeNode());
1679 // Collect info for variables that were optimized out.
1680 DIArray Variables = SP.getVariables();
1681 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1682 DIVariable DV(Variables.getElement(i));
1683 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1685 // Check that DbgVariable for DV wasn't created earlier, when
1686 // findAbstractVariable() was called for inlined instance of DV.
1687 LLVMContext &Ctx = DV->getContext();
1688 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1689 if (AbstractVariables.lookup(CleanDV))
1691 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1692 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1695 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1696 constructScopeDIE(TheCU, AScope);
1699 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1701 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1702 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1705 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1706 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1707 DeleteContainerPointers(I->second);
1708 ScopeVariables.clear();
1709 DeleteContainerPointers(CurrentFnArguments);
1710 UserVariables.clear();
1712 AbstractVariables.clear();
1713 LabelsBeforeInsn.clear();
1714 LabelsAfterInsn.clear();
1718 // Register a source line with debug info. Returns the unique label that was
1719 // emitted and which provides correspondence to the source line list.
1720 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1726 DIDescriptor Scope(S);
1728 if (Scope.isCompileUnit()) {
1729 DICompileUnit CU(S);
1730 Fn = CU.getFilename();
1731 Dir = CU.getDirectory();
1732 } else if (Scope.isFile()) {
1734 Fn = F.getFilename();
1735 Dir = F.getDirectory();
1736 } else if (Scope.isSubprogram()) {
1738 Fn = SP.getFilename();
1739 Dir = SP.getDirectory();
1740 } else if (Scope.isLexicalBlockFile()) {
1741 DILexicalBlockFile DBF(S);
1742 Fn = DBF.getFilename();
1743 Dir = DBF.getDirectory();
1744 } else if (Scope.isLexicalBlock()) {
1745 DILexicalBlock DB(S);
1746 Fn = DB.getFilename();
1747 Dir = DB.getDirectory();
1749 llvm_unreachable("Unexpected scope info");
1751 Src = getOrCreateSourceID(Fn, Dir,
1752 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1754 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1757 //===----------------------------------------------------------------------===//
1759 //===----------------------------------------------------------------------===//
1761 // Compute the size and offset of a DIE.
1763 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1764 // Get the children.
1765 const std::vector<DIE *> &Children = Die->getChildren();
1767 // Record the abbreviation.
1768 assignAbbrevNumber(Die->getAbbrev());
1770 // Get the abbreviation for this DIE.
1771 unsigned AbbrevNumber = Die->getAbbrevNumber();
1772 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1775 Die->setOffset(Offset);
1777 // Start the size with the size of abbreviation code.
1778 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1780 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1781 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1783 // Size the DIE attribute values.
1784 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1785 // Size attribute value.
1786 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1788 // Size the DIE children if any.
1789 if (!Children.empty()) {
1790 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1791 "Children flag not set");
1793 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1794 Offset = computeSizeAndOffset(Children[j], Offset);
1796 // End of children marker.
1797 Offset += sizeof(int8_t);
1800 Die->setSize(Offset - Die->getOffset());
1804 // Compute the size and offset of all the DIEs.
1805 void DwarfUnits::computeSizeAndOffsets() {
1806 // Offset from the beginning of debug info section.
1807 unsigned SecOffset = 0;
1808 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1809 E = CUs.end(); I != E; ++I) {
1810 (*I)->setDebugInfoOffset(SecOffset);
1812 sizeof(int32_t) + // Length of Compilation Unit Info
1813 sizeof(int16_t) + // DWARF version number
1814 sizeof(int32_t) + // Offset Into Abbrev. Section
1815 sizeof(int8_t); // Pointer Size (in bytes)
1817 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1818 SecOffset += EndOffset;
1822 // Emit initial Dwarf sections with a label at the start of each one.
1823 void DwarfDebug::emitSectionLabels() {
1824 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1826 // Dwarf sections base addresses.
1827 DwarfInfoSectionSym =
1828 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1829 DwarfAbbrevSectionSym =
1830 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1831 if (useSplitDwarf())
1832 DwarfAbbrevDWOSectionSym =
1833 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1834 "section_abbrev_dwo");
1835 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1837 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1838 emitSectionSym(Asm, MacroInfo);
1840 DwarfLineSectionSym =
1841 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1842 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1843 if (GenerateDwarfPubNamesSection)
1844 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1845 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1846 DwarfStrSectionSym =
1847 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1848 if (useSplitDwarf()) {
1849 DwarfStrDWOSectionSym =
1850 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1851 DwarfAddrSectionSym =
1852 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1854 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1857 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1858 "section_debug_loc");
1860 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1861 emitSectionSym(Asm, TLOF.getDataSection());
1864 // Recursively emits a debug information entry.
1865 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1866 // Get the abbreviation for this DIE.
1867 unsigned AbbrevNumber = Die->getAbbrevNumber();
1868 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1870 // Emit the code (index) for the abbreviation.
1871 if (Asm->isVerbose())
1872 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1873 Twine::utohexstr(Die->getOffset()) + ":0x" +
1874 Twine::utohexstr(Die->getSize()) + " " +
1875 dwarf::TagString(Abbrev->getTag()));
1876 Asm->EmitULEB128(AbbrevNumber);
1878 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1879 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1881 // Emit the DIE attribute values.
1882 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1883 unsigned Attr = AbbrevData[i].getAttribute();
1884 unsigned Form = AbbrevData[i].getForm();
1885 assert(Form && "Too many attributes for DIE (check abbreviation)");
1887 if (Asm->isVerbose())
1888 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1891 case dwarf::DW_AT_abstract_origin: {
1892 DIEEntry *E = cast<DIEEntry>(Values[i]);
1893 DIE *Origin = E->getEntry();
1894 unsigned Addr = Origin->getOffset();
1895 if (Form == dwarf::DW_FORM_ref_addr) {
1896 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1897 // section. Origin->getOffset() returns the offset from start of the
1899 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1900 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1902 Asm->EmitInt32(Addr);
1905 case dwarf::DW_AT_ranges: {
1906 // DW_AT_range Value encodes offset in debug_range section.
1907 DIEInteger *V = cast<DIEInteger>(Values[i]);
1909 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1910 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1914 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1916 DwarfDebugRangeSectionSym,
1921 case dwarf::DW_AT_location: {
1922 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1923 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1924 Asm->EmitLabelReference(L->getValue(), 4);
1926 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1928 Values[i]->EmitValue(Asm, Form);
1932 case dwarf::DW_AT_accessibility: {
1933 if (Asm->isVerbose()) {
1934 DIEInteger *V = cast<DIEInteger>(Values[i]);
1935 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1937 Values[i]->EmitValue(Asm, Form);
1941 // Emit an attribute using the defined form.
1942 Values[i]->EmitValue(Asm, Form);
1947 // Emit the DIE children if any.
1948 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1949 const std::vector<DIE *> &Children = Die->getChildren();
1951 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1952 emitDIE(Children[j], Abbrevs);
1954 if (Asm->isVerbose())
1955 Asm->OutStreamer.AddComment("End Of Children Mark");
1960 // Emit the various dwarf units to the unit section USection with
1961 // the abbreviations going into ASection.
1962 void DwarfUnits::emitUnits(DwarfDebug *DD,
1963 const MCSection *USection,
1964 const MCSection *ASection,
1965 const MCSymbol *ASectionSym) {
1966 Asm->OutStreamer.SwitchSection(USection);
1967 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1968 E = CUs.end(); I != E; ++I) {
1969 CompileUnit *TheCU = *I;
1970 DIE *Die = TheCU->getCUDie();
1972 // Emit the compile units header.
1974 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1975 TheCU->getUniqueID()));
1977 // Emit size of content not including length itself
1978 unsigned ContentSize = Die->getSize() +
1979 sizeof(int16_t) + // DWARF version number
1980 sizeof(int32_t) + // Offset Into Abbrev. Section
1981 sizeof(int8_t); // Pointer Size (in bytes)
1983 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1984 Asm->EmitInt32(ContentSize);
1985 Asm->OutStreamer.AddComment("DWARF version number");
1986 Asm->EmitInt16(dwarf::DWARF_VERSION);
1987 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1988 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1990 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1991 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1993 DD->emitDIE(Die, Abbreviations);
1994 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1995 TheCU->getUniqueID()));
1999 /// For a given compile unit DIE, returns offset from beginning of debug info.
2000 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2001 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2002 "Input DIE should be compile unit in getCUOffset.");
2003 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2004 E = CUs.end(); I != E; ++I) {
2005 CompileUnit *TheCU = *I;
2006 if (TheCU->getCUDie() == Die)
2007 return TheCU->getDebugInfoOffset();
2009 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2012 // Emit the debug info section.
2013 void DwarfDebug::emitDebugInfo() {
2014 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2016 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2017 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2018 DwarfAbbrevSectionSym);
2021 // Emit the abbreviation section.
2022 void DwarfDebug::emitAbbreviations() {
2023 if (!useSplitDwarf())
2024 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2027 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2030 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2031 std::vector<DIEAbbrev *> *Abbrevs) {
2032 // Check to see if it is worth the effort.
2033 if (!Abbrevs->empty()) {
2034 // Start the debug abbrev section.
2035 Asm->OutStreamer.SwitchSection(Section);
2037 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2038 Asm->OutStreamer.EmitLabel(Begin);
2040 // For each abbrevation.
2041 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2042 // Get abbreviation data
2043 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2045 // Emit the abbrevations code (base 1 index.)
2046 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2048 // Emit the abbreviations data.
2052 // Mark end of abbreviations.
2053 Asm->EmitULEB128(0, "EOM(3)");
2055 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2056 Asm->OutStreamer.EmitLabel(End);
2060 // Emit the last address of the section and the end of the line matrix.
2061 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2062 // Define last address of section.
2063 Asm->OutStreamer.AddComment("Extended Op");
2066 Asm->OutStreamer.AddComment("Op size");
2067 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2068 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2069 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2071 Asm->OutStreamer.AddComment("Section end label");
2073 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2074 Asm->getDataLayout().getPointerSize());
2076 // Mark end of matrix.
2077 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2083 // Emit visible names into a hashed accelerator table section.
2084 void DwarfDebug::emitAccelNames() {
2085 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2086 dwarf::DW_FORM_data4));
2087 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2088 E = CUMap.end(); I != E; ++I) {
2089 CompileUnit *TheCU = I->second;
2090 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2091 for (StringMap<std::vector<DIE*> >::const_iterator
2092 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2093 StringRef Name = GI->getKey();
2094 const std::vector<DIE *> &Entities = GI->second;
2095 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2096 DE = Entities.end(); DI != DE; ++DI)
2097 AT.AddName(Name, (*DI));
2101 AT.FinalizeTable(Asm, "Names");
2102 Asm->OutStreamer.SwitchSection(
2103 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2104 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2105 Asm->OutStreamer.EmitLabel(SectionBegin);
2107 // Emit the full data.
2108 AT.Emit(Asm, SectionBegin, &InfoHolder);
2111 // Emit objective C classes and categories into a hashed accelerator table
2113 void DwarfDebug::emitAccelObjC() {
2114 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2115 dwarf::DW_FORM_data4));
2116 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2117 E = CUMap.end(); I != E; ++I) {
2118 CompileUnit *TheCU = I->second;
2119 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2120 for (StringMap<std::vector<DIE*> >::const_iterator
2121 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2122 StringRef Name = GI->getKey();
2123 const std::vector<DIE *> &Entities = GI->second;
2124 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2125 DE = Entities.end(); DI != DE; ++DI)
2126 AT.AddName(Name, (*DI));
2130 AT.FinalizeTable(Asm, "ObjC");
2131 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2132 .getDwarfAccelObjCSection());
2133 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2134 Asm->OutStreamer.EmitLabel(SectionBegin);
2136 // Emit the full data.
2137 AT.Emit(Asm, SectionBegin, &InfoHolder);
2140 // Emit namespace dies into a hashed accelerator table.
2141 void DwarfDebug::emitAccelNamespaces() {
2142 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2143 dwarf::DW_FORM_data4));
2144 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2145 E = CUMap.end(); I != E; ++I) {
2146 CompileUnit *TheCU = I->second;
2147 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2148 for (StringMap<std::vector<DIE*> >::const_iterator
2149 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2150 StringRef Name = GI->getKey();
2151 const std::vector<DIE *> &Entities = GI->second;
2152 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2153 DE = Entities.end(); DI != DE; ++DI)
2154 AT.AddName(Name, (*DI));
2158 AT.FinalizeTable(Asm, "namespac");
2159 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2160 .getDwarfAccelNamespaceSection());
2161 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2162 Asm->OutStreamer.EmitLabel(SectionBegin);
2164 // Emit the full data.
2165 AT.Emit(Asm, SectionBegin, &InfoHolder);
2168 // Emit type dies into a hashed accelerator table.
2169 void DwarfDebug::emitAccelTypes() {
2170 std::vector<DwarfAccelTable::Atom> Atoms;
2171 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2172 dwarf::DW_FORM_data4));
2173 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2174 dwarf::DW_FORM_data2));
2175 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2176 dwarf::DW_FORM_data1));
2177 DwarfAccelTable AT(Atoms);
2178 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2179 E = CUMap.end(); I != E; ++I) {
2180 CompileUnit *TheCU = I->second;
2181 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2182 = TheCU->getAccelTypes();
2183 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2184 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2185 StringRef Name = GI->getKey();
2186 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2187 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2188 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2189 AT.AddName(Name, (*DI).first, (*DI).second);
2193 AT.FinalizeTable(Asm, "types");
2194 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2195 .getDwarfAccelTypesSection());
2196 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2197 Asm->OutStreamer.EmitLabel(SectionBegin);
2199 // Emit the full data.
2200 AT.Emit(Asm, SectionBegin, &InfoHolder);
2203 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2205 void DwarfDebug::emitDebugPubnames() {
2206 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2208 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2209 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2210 CompileUnit *TheCU = I->second;
2211 unsigned ID = TheCU->getUniqueID();
2213 if (TheCU->getGlobalNames().empty())
2216 // Start the dwarf pubnames section.
2217 Asm->OutStreamer.SwitchSection(
2218 Asm->getObjFileLowering().getDwarfPubNamesSection());
2220 Asm->OutStreamer.AddComment("Length of Public Names Info");
2221 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2222 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2224 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2226 Asm->OutStreamer.AddComment("DWARF Version");
2227 Asm->EmitInt16(dwarf::DWARF_VERSION);
2229 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2230 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2231 DwarfInfoSectionSym);
2233 Asm->OutStreamer.AddComment("Compilation Unit Length");
2234 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2235 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2238 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2239 for (StringMap<DIE*>::const_iterator
2240 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2241 const char *Name = GI->getKeyData();
2242 const DIE *Entity = GI->second;
2244 Asm->OutStreamer.AddComment("DIE offset");
2245 Asm->EmitInt32(Entity->getOffset());
2247 if (Asm->isVerbose())
2248 Asm->OutStreamer.AddComment("External Name");
2249 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2252 Asm->OutStreamer.AddComment("End Mark");
2254 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2258 void DwarfDebug::emitDebugPubTypes() {
2259 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2260 E = CUMap.end(); I != E; ++I) {
2261 CompileUnit *TheCU = I->second;
2262 // Start the dwarf pubtypes section.
2263 Asm->OutStreamer.SwitchSection(
2264 Asm->getObjFileLowering().getDwarfPubTypesSection());
2265 Asm->OutStreamer.AddComment("Length of Public Types Info");
2266 Asm->EmitLabelDifference(
2267 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2268 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2270 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2271 TheCU->getUniqueID()));
2273 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2274 Asm->EmitInt16(dwarf::DWARF_VERSION);
2276 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2277 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2278 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2279 TheCU->getUniqueID()),
2280 DwarfInfoSectionSym);
2282 Asm->OutStreamer.AddComment("Compilation Unit Length");
2283 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2284 TheCU->getUniqueID()),
2285 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2286 TheCU->getUniqueID()),
2289 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2290 for (StringMap<DIE*>::const_iterator
2291 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2292 const char *Name = GI->getKeyData();
2293 DIE *Entity = GI->second;
2295 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2296 Asm->EmitInt32(Entity->getOffset());
2298 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2299 // Emit the name with a terminating null byte.
2300 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2303 Asm->OutStreamer.AddComment("End Mark");
2305 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2306 TheCU->getUniqueID()));
2310 // Emit strings into a string section.
2311 void DwarfUnits::emitStrings(const MCSection *StrSection,
2312 const MCSection *OffsetSection = NULL,
2313 const MCSymbol *StrSecSym = NULL) {
2315 if (StringPool.empty()) return;
2317 // Start the dwarf str section.
2318 Asm->OutStreamer.SwitchSection(StrSection);
2320 // Get all of the string pool entries and put them in an array by their ID so
2321 // we can sort them.
2322 SmallVector<std::pair<unsigned,
2323 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2325 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2326 I = StringPool.begin(), E = StringPool.end();
2328 Entries.push_back(std::make_pair(I->second.second, &*I));
2330 array_pod_sort(Entries.begin(), Entries.end());
2332 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2333 // Emit a label for reference from debug information entries.
2334 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2336 // Emit the string itself with a terminating null byte.
2337 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2338 Entries[i].second->getKeyLength()+1));
2341 // If we've got an offset section go ahead and emit that now as well.
2342 if (OffsetSection) {
2343 Asm->OutStreamer.SwitchSection(OffsetSection);
2344 unsigned offset = 0;
2345 unsigned size = 4; // FIXME: DWARF64 is 8.
2346 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2347 Asm->OutStreamer.EmitIntValue(offset, size);
2348 offset += Entries[i].second->getKeyLength() + 1;
2353 // Emit strings into a string section.
2354 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2356 if (AddressPool.empty()) return;
2358 // Start the dwarf addr section.
2359 Asm->OutStreamer.SwitchSection(AddrSection);
2361 // Get all of the string pool entries and put them in an array by their ID so
2362 // we can sort them.
2363 SmallVector<std::pair<unsigned,
2364 std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2366 for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2367 I = AddressPool.begin(), E = AddressPool.end();
2369 Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2371 array_pod_sort(Entries.begin(), Entries.end());
2373 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2374 // Emit a label for reference from debug information entries.
2375 MCSymbol *Sym = Entries[i].second->first;
2377 Asm->EmitLabelReference(Entries[i].second->first,
2378 Asm->getDataLayout().getPointerSize());
2380 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2385 // Emit visible names into a debug str section.
2386 void DwarfDebug::emitDebugStr() {
2387 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2388 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2391 // Emit visible names into a debug loc section.
2392 void DwarfDebug::emitDebugLoc() {
2393 if (DotDebugLocEntries.empty())
2396 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2397 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2399 DotDebugLocEntry &Entry = *I;
2400 if (I + 1 != DotDebugLocEntries.end())
2404 // Start the dwarf loc section.
2405 Asm->OutStreamer.SwitchSection(
2406 Asm->getObjFileLowering().getDwarfLocSection());
2407 unsigned char Size = Asm->getDataLayout().getPointerSize();
2408 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2410 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2411 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2412 I != E; ++I, ++index) {
2413 DotDebugLocEntry &Entry = *I;
2414 if (Entry.isMerged()) continue;
2415 if (Entry.isEmpty()) {
2416 Asm->OutStreamer.EmitIntValue(0, Size);
2417 Asm->OutStreamer.EmitIntValue(0, Size);
2418 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2420 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2421 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
2422 DIVariable DV(Entry.Variable);
2423 Asm->OutStreamer.AddComment("Loc expr size");
2424 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2425 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2426 Asm->EmitLabelDifference(end, begin, 2);
2427 Asm->OutStreamer.EmitLabel(begin);
2428 if (Entry.isInt()) {
2429 DIBasicType BTy(DV.getType());
2431 (BTy.getEncoding() == dwarf::DW_ATE_signed
2432 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2433 Asm->OutStreamer.AddComment("DW_OP_consts");
2434 Asm->EmitInt8(dwarf::DW_OP_consts);
2435 Asm->EmitSLEB128(Entry.getInt());
2437 Asm->OutStreamer.AddComment("DW_OP_constu");
2438 Asm->EmitInt8(dwarf::DW_OP_constu);
2439 Asm->EmitULEB128(Entry.getInt());
2441 } else if (Entry.isLocation()) {
2442 if (!DV.hasComplexAddress())
2444 Asm->EmitDwarfRegOp(Entry.Loc, DV.isIndirect());
2446 // Complex address entry.
2447 unsigned N = DV.getNumAddrElements();
2449 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2450 if (Entry.Loc.getOffset()) {
2452 Asm->EmitDwarfRegOp(Entry.Loc, DV.isIndirect());
2453 Asm->OutStreamer.AddComment("DW_OP_deref");
2454 Asm->EmitInt8(dwarf::DW_OP_deref);
2455 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2456 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2457 Asm->EmitSLEB128(DV.getAddrElement(1));
2459 // If first address element is OpPlus then emit
2460 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2461 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2462 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2466 Asm->EmitDwarfRegOp(Entry.Loc, DV.isIndirect());
2469 // Emit remaining complex address elements.
2470 for (; i < N; ++i) {
2471 uint64_t Element = DV.getAddrElement(i);
2472 if (Element == DIBuilder::OpPlus) {
2473 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2474 Asm->EmitULEB128(DV.getAddrElement(++i));
2475 } else if (Element == DIBuilder::OpDeref) {
2476 if (!Entry.Loc.isReg())
2477 Asm->EmitInt8(dwarf::DW_OP_deref);
2479 llvm_unreachable("unknown Opcode found in complex address");
2483 // else ... ignore constant fp. There is not any good way to
2484 // to represent them here in dwarf.
2485 Asm->OutStreamer.EmitLabel(end);
2490 // Emit visible names into a debug aranges section.
2491 void DwarfDebug::emitDebugARanges() {
2492 // Start the dwarf aranges section.
2493 Asm->OutStreamer.SwitchSection(
2494 Asm->getObjFileLowering().getDwarfARangesSection());
2497 // Emit visible names into a debug ranges section.
2498 void DwarfDebug::emitDebugRanges() {
2499 // Start the dwarf ranges section.
2500 Asm->OutStreamer.SwitchSection(
2501 Asm->getObjFileLowering().getDwarfRangesSection());
2502 unsigned char Size = Asm->getDataLayout().getPointerSize();
2503 for (SmallVectorImpl<const MCSymbol *>::iterator
2504 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2507 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2509 Asm->OutStreamer.EmitIntValue(0, Size);
2513 // Emit visible names into a debug macinfo section.
2514 void DwarfDebug::emitDebugMacInfo() {
2515 if (const MCSection *LineInfo =
2516 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2517 // Start the dwarf macinfo section.
2518 Asm->OutStreamer.SwitchSection(LineInfo);
2522 // Emit inline info using following format.
2524 // 1. length of section
2525 // 2. Dwarf version number
2528 // Entries (one "entry" for each function that was inlined):
2530 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2531 // otherwise offset into __debug_str for regular function name.
2532 // 2. offset into __debug_str section for regular function name.
2533 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2534 // instances for the function.
2536 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2537 // inlined instance; the die_offset points to the inlined_subroutine die in the
2538 // __debug_info section, and the low_pc is the starting address for the
2539 // inlining instance.
2540 void DwarfDebug::emitDebugInlineInfo() {
2541 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2547 Asm->OutStreamer.SwitchSection(
2548 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2550 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2551 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2552 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2554 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2556 Asm->OutStreamer.AddComment("Dwarf Version");
2557 Asm->EmitInt16(dwarf::DWARF_VERSION);
2558 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2559 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2561 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2562 E = InlinedSPNodes.end(); I != E; ++I) {
2564 const MDNode *Node = *I;
2565 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2566 = InlineInfo.find(Node);
2567 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2568 DISubprogram SP(Node);
2569 StringRef LName = SP.getLinkageName();
2570 StringRef Name = SP.getName();
2572 Asm->OutStreamer.AddComment("MIPS linkage name");
2574 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2575 DwarfStrSectionSym);
2577 Asm->EmitSectionOffset(
2578 InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2579 DwarfStrSectionSym);
2581 Asm->OutStreamer.AddComment("Function name");
2582 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2583 DwarfStrSectionSym);
2584 Asm->EmitULEB128(Labels.size(), "Inline count");
2586 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2587 LE = Labels.end(); LI != LE; ++LI) {
2588 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2589 Asm->EmitInt32(LI->second->getOffset());
2591 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2592 Asm->OutStreamer.EmitSymbolValue(LI->first,
2593 Asm->getDataLayout().getPointerSize());
2597 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2600 // DWARF5 Experimental Separate Dwarf emitters.
2602 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2603 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2604 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2605 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2606 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2607 DICompileUnit DIUnit(N);
2608 CompilationDir = DIUnit.getDirectory();
2610 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2611 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2612 DIUnit.getLanguage(), Die, N, Asm,
2613 this, &SkeletonHolder);
2615 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2616 DIUnit.getSplitDebugFilename());
2618 // This should be a unique identifier when we want to build .dwp files.
2619 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2621 // Relocate to the beginning of the addr_base section, else 0 for the
2622 // beginning of the one for this compile unit.
2623 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2624 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2625 DwarfAddrSectionSym);
2627 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2628 dwarf::DW_FORM_sec_offset, 0);
2630 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2631 // into an entity. We're using 0, or a NULL label for this.
2632 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2634 // DW_AT_stmt_list is a offset of line number information for this
2635 // compile unit in debug_line section.
2636 // FIXME: Should handle multiple compile units.
2637 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2638 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2639 DwarfLineSectionSym);
2641 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2643 if (!CompilationDir.empty())
2644 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2646 SkeletonHolder.addUnit(NewCU);
2647 SkeletonCUs.push_back(NewCU);
2652 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2653 assert(useSplitDwarf() && "No split dwarf debug info?");
2654 emitAbbrevs(Section, &SkeletonAbbrevs);
2657 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2658 // compile units that would normally be in debug_info.
2659 void DwarfDebug::emitDebugInfoDWO() {
2660 assert(useSplitDwarf() && "No split dwarf debug info?");
2661 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2662 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2663 DwarfAbbrevDWOSectionSym);
2666 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2667 // abbreviations for the .debug_info.dwo section.
2668 void DwarfDebug::emitDebugAbbrevDWO() {
2669 assert(useSplitDwarf() && "No split dwarf?");
2670 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2674 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2675 // string section and is identical in format to traditional .debug_str
2677 void DwarfDebug::emitDebugStrDWO() {
2678 assert(useSplitDwarf() && "No split dwarf?");
2679 const MCSection *OffSec = Asm->getObjFileLowering()
2680 .getDwarfStrOffDWOSection();
2681 const MCSymbol *StrSym = DwarfStrSectionSym;
2682 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),