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 StringRef Name = Module.getName();
822 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
823 Context->addChild(IMDie);
826 // Emit all Dwarf sections that should come prior to the content. Create
827 // global DIEs and emit initial debug info sections. This is invoked by
828 // the target AsmPrinter.
829 void DwarfDebug::beginModule() {
830 if (DisableDebugInfoPrinting)
833 const Module *M = MMI->getModule();
835 // If module has named metadata anchors then use them, otherwise scan the
836 // module using debug info finder to collect debug info.
837 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
841 // Emit initial sections so we can reference labels later.
844 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
845 DICompileUnit CUNode(CU_Nodes->getOperand(i));
846 CompileUnit *CU = constructCompileUnit(CUNode);
847 DIArray ImportedEntities = CUNode.getImportedEntities();
848 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
849 ScopesWithImportedEntities.push_back(std::make_pair(
850 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
851 ImportedEntities.getElement(i)));
852 std::sort(ScopesWithImportedEntities.begin(),
853 ScopesWithImportedEntities.end(), CompareFirst());
854 DIArray GVs = CUNode.getGlobalVariables();
855 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
856 CU->createGlobalVariableDIE(GVs.getElement(i));
857 DIArray SPs = CUNode.getSubprograms();
858 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
859 constructSubprogramDIE(CU, SPs.getElement(i));
860 DIArray EnumTypes = CUNode.getEnumTypes();
861 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
862 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
863 DIArray RetainedTypes = CUNode.getRetainedTypes();
864 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
865 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
866 // Emit imported_modules last so that the relevant context is already
868 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
869 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
870 // If we're splitting the dwarf out now that we've got the entire
871 // CU then construct a skeleton CU based upon it.
872 if (useSplitDwarf()) {
873 // This should be a unique identifier when we want to build .dwp files.
874 CU->addUInt(CU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
875 dwarf::DW_FORM_data8, 0);
876 // Now construct the skeleton CU associated.
877 constructSkeletonCU(CUNode);
881 // Tell MMI that we have debug info.
882 MMI->setDebugInfoAvailability(true);
884 // Prime section data.
885 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
888 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
889 void DwarfDebug::computeInlinedDIEs() {
890 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
891 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
892 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
894 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
896 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
897 AE = AbstractSPDies.end(); AI != AE; ++AI) {
898 DIE *ISP = AI->second;
899 if (InlinedSubprogramDIEs.count(ISP))
901 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
905 // Collect info for variables that were optimized out.
906 void DwarfDebug::collectDeadVariables() {
907 const Module *M = MMI->getModule();
908 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
910 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
911 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
912 DICompileUnit TheCU(CU_Nodes->getOperand(i));
913 DIArray Subprograms = TheCU.getSubprograms();
914 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
915 DISubprogram SP(Subprograms.getElement(i));
916 if (ProcessedSPNodes.count(SP) != 0) continue;
917 if (!SP.Verify()) continue;
918 if (!SP.isDefinition()) continue;
919 DIArray Variables = SP.getVariables();
920 if (Variables.getNumElements() == 0) continue;
922 LexicalScope *Scope =
923 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
924 DeadFnScopeMap[SP] = Scope;
926 // Construct subprogram DIE and add variables DIEs.
927 CompileUnit *SPCU = CUMap.lookup(TheCU);
928 assert(SPCU && "Unable to find Compile Unit!");
929 constructSubprogramDIE(SPCU, SP);
930 DIE *ScopeDIE = SPCU->getDIE(SP);
931 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
932 DIVariable DV(Variables.getElement(vi));
933 if (!DV.Verify()) continue;
934 DbgVariable *NewVar = new DbgVariable(DV, NULL);
935 if (DIE *VariableDIE =
936 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
937 ScopeDIE->addChild(VariableDIE);
942 DeleteContainerSeconds(DeadFnScopeMap);
945 void DwarfDebug::finalizeModuleInfo() {
946 // Collect info for variables that were optimized out.
947 collectDeadVariables();
949 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
950 computeInlinedDIEs();
952 // Emit DW_AT_containing_type attribute to connect types with their
953 // vtable holding type.
954 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
955 CUE = CUMap.end(); CUI != CUE; ++CUI) {
956 CompileUnit *TheCU = CUI->second;
957 TheCU->constructContainingTypeDIEs();
960 // Compute DIE offsets and sizes.
961 InfoHolder.computeSizeAndOffsets();
963 SkeletonHolder.computeSizeAndOffsets();
966 void DwarfDebug::endSections() {
967 // Standard sections final addresses.
968 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
969 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
970 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
971 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
973 // End text sections.
974 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
975 Asm->OutStreamer.SwitchSection(SectionMap[I]);
976 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
980 // Emit all Dwarf sections that should come after the content.
981 void DwarfDebug::endModule() {
983 if (!FirstCU) return;
985 // End any existing sections.
986 // TODO: Does this need to happen?
989 // Finalize the debug info for the module.
990 finalizeModuleInfo();
992 if (!useSplitDwarf()) {
993 // Emit all the DIEs into a debug info section.
996 // Corresponding abbreviations into a abbrev section.
999 // Emit info into a debug loc section.
1002 // Emit info into a debug aranges section.
1005 // Emit info into a debug ranges section.
1008 // Emit info into a debug macinfo section.
1011 // Emit inline info.
1012 // TODO: When we don't need the option anymore we
1013 // can remove all of the code that this section
1015 if (useDarwinGDBCompat())
1016 emitDebugInlineInfo();
1018 // TODO: Fill this in for separated debug sections and separate
1019 // out information into new sections.
1021 // Emit the debug info section and compile units.
1025 // Corresponding abbreviations into a abbrev section.
1026 emitAbbreviations();
1027 emitDebugAbbrevDWO();
1029 // Emit info into a debug loc section.
1032 // Emit info into a debug aranges section.
1035 // Emit info into a debug ranges section.
1038 // Emit info into a debug macinfo section.
1041 // Emit DWO addresses.
1042 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1044 // Emit inline info.
1045 // TODO: When we don't need the option anymore we
1046 // can remove all of the code that this section
1048 if (useDarwinGDBCompat())
1049 emitDebugInlineInfo();
1052 // Emit info into the dwarf accelerator table sections.
1053 if (useDwarfAccelTables()) {
1056 emitAccelNamespaces();
1060 // Emit info into a debug pubnames section, if requested.
1061 if (GenerateDwarfPubNamesSection)
1062 emitDebugPubnames();
1064 // Emit info into a debug pubtypes section.
1065 // TODO: When we don't need the option anymore we can
1066 // remove all of the code that adds to the table.
1067 if (useDarwinGDBCompat())
1068 emitDebugPubTypes();
1070 // Finally emit string information into a string table.
1072 if (useSplitDwarf())
1077 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1078 E = CUMap.end(); I != E; ++I)
1081 for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
1082 E = SkeletonCUs.end(); I != E; ++I)
1085 // Reset these for the next Module if we have one.
1089 // Find abstract variable, if any, associated with Var.
1090 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1091 DebugLoc ScopeLoc) {
1092 LLVMContext &Ctx = DV->getContext();
1093 // More then one inlined variable corresponds to one abstract variable.
1094 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1095 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1097 return AbsDbgVariable;
1099 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1103 AbsDbgVariable = new DbgVariable(Var, NULL);
1104 addScopeVariable(Scope, AbsDbgVariable);
1105 AbstractVariables[Var] = AbsDbgVariable;
1106 return AbsDbgVariable;
1109 // If Var is a current function argument then add it to CurrentFnArguments list.
1110 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1111 DbgVariable *Var, LexicalScope *Scope) {
1112 if (!LScopes.isCurrentFunctionScope(Scope))
1114 DIVariable DV = Var->getVariable();
1115 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1117 unsigned ArgNo = DV.getArgNumber();
1121 size_t Size = CurrentFnArguments.size();
1123 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1124 // llvm::Function argument size is not good indicator of how many
1125 // arguments does the function have at source level.
1127 CurrentFnArguments.resize(ArgNo * 2);
1128 CurrentFnArguments[ArgNo - 1] = Var;
1132 // Collect variable information from side table maintained by MMI.
1134 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1135 SmallPtrSet<const MDNode *, 16> &Processed) {
1136 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1137 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1138 VE = VMap.end(); VI != VE; ++VI) {
1139 const MDNode *Var = VI->first;
1141 Processed.insert(Var);
1143 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1145 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1147 // If variable scope is not found then skip this variable.
1151 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1152 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1153 RegVar->setFrameIndex(VP.first);
1154 if (!addCurrentFnArgument(MF, RegVar, Scope))
1155 addScopeVariable(Scope, RegVar);
1157 AbsDbgVariable->setFrameIndex(VP.first);
1161 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1163 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1164 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1165 return MI->getNumOperands() == 3 &&
1166 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1167 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1170 // Get .debug_loc entry for the instruction range starting at MI.
1171 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1172 const MCSymbol *FLabel,
1173 const MCSymbol *SLabel,
1174 const MachineInstr *MI) {
1175 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1177 if (MI->getNumOperands() != 3) {
1178 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1179 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1181 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1182 MachineLocation MLoc;
1183 // TODO: Currently an offset of 0 in a DBG_VALUE means
1184 // we need to generate a direct register value.
1185 // There is no way to specify an indirect value with offset 0.
1186 if (MI->getOperand(1).getImm() == 0)
1187 MLoc.set(MI->getOperand(0).getReg());
1189 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1190 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1192 if (MI->getOperand(0).isImm())
1193 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1194 if (MI->getOperand(0).isFPImm())
1195 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1196 if (MI->getOperand(0).isCImm())
1197 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1199 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1202 // Find variables for each lexical scope.
1204 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1205 SmallPtrSet<const MDNode *, 16> &Processed) {
1207 // collection info from MMI table.
1208 collectVariableInfoFromMMITable(MF, Processed);
1210 for (SmallVectorImpl<const MDNode*>::const_iterator
1211 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1213 const MDNode *Var = *UVI;
1214 if (Processed.count(Var))
1217 // History contains relevant DBG_VALUE instructions for Var and instructions
1219 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1220 if (History.empty())
1222 const MachineInstr *MInsn = History.front();
1225 LexicalScope *Scope = NULL;
1226 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1227 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1228 Scope = LScopes.getCurrentFunctionScope();
1229 else if (MDNode *IA = DV.getInlinedAt())
1230 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1232 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1233 // If variable scope is not found then skip this variable.
1237 Processed.insert(DV);
1238 assert(MInsn->isDebugValue() && "History must begin with debug value");
1239 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1240 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1241 if (!addCurrentFnArgument(MF, RegVar, Scope))
1242 addScopeVariable(Scope, RegVar);
1244 AbsVar->setMInsn(MInsn);
1246 // Simplify ranges that are fully coalesced.
1247 if (History.size() <= 1 || (History.size() == 2 &&
1248 MInsn->isIdenticalTo(History.back()))) {
1249 RegVar->setMInsn(MInsn);
1253 // Handle multiple DBG_VALUE instructions describing one variable.
1254 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1256 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1257 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1258 const MachineInstr *Begin = *HI;
1259 assert(Begin->isDebugValue() && "Invalid History entry");
1261 // Check if DBG_VALUE is truncating a range.
1262 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1263 && !Begin->getOperand(0).getReg())
1266 // Compute the range for a register location.
1267 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1268 const MCSymbol *SLabel = 0;
1271 // If Begin is the last instruction in History then its value is valid
1272 // until the end of the function.
1273 SLabel = FunctionEndSym;
1275 const MachineInstr *End = HI[1];
1276 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1277 << "\t" << *Begin << "\t" << *End << "\n");
1278 if (End->isDebugValue())
1279 SLabel = getLabelBeforeInsn(End);
1281 // End is a normal instruction clobbering the range.
1282 SLabel = getLabelAfterInsn(End);
1283 assert(SLabel && "Forgot label after clobber instruction");
1288 // The value is valid until the next DBG_VALUE or clobber.
1289 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1292 DotDebugLocEntries.push_back(DotDebugLocEntry());
1295 // Collect info for variables that were optimized out.
1296 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1297 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1298 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1299 DIVariable DV(Variables.getElement(i));
1300 if (!DV || !DV.Verify() || !Processed.insert(DV))
1302 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1303 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1307 // Return Label preceding the instruction.
1308 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1309 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1310 assert(Label && "Didn't insert label before instruction");
1314 // Return Label immediately following the instruction.
1315 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1316 return LabelsAfterInsn.lookup(MI);
1319 // Process beginning of an instruction.
1320 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1321 // Check if source location changes, but ignore DBG_VALUE locations.
1322 if (!MI->isDebugValue()) {
1323 DebugLoc DL = MI->getDebugLoc();
1324 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1327 if (DL == PrologEndLoc) {
1328 Flags |= DWARF2_FLAG_PROLOGUE_END;
1329 PrologEndLoc = DebugLoc();
1331 if (PrologEndLoc.isUnknown())
1332 Flags |= DWARF2_FLAG_IS_STMT;
1334 if (!DL.isUnknown()) {
1335 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1336 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1338 recordSourceLine(0, 0, 0, 0);
1342 // Insert labels where requested.
1343 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1344 LabelsBeforeInsn.find(MI);
1347 if (I == LabelsBeforeInsn.end())
1350 // Label already assigned.
1355 PrevLabel = MMI->getContext().CreateTempSymbol();
1356 Asm->OutStreamer.EmitLabel(PrevLabel);
1358 I->second = PrevLabel;
1361 // Process end of an instruction.
1362 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1363 // Don't create a new label after DBG_VALUE instructions.
1364 // They don't generate code.
1365 if (!MI->isDebugValue())
1368 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1369 LabelsAfterInsn.find(MI);
1372 if (I == LabelsAfterInsn.end())
1375 // Label already assigned.
1379 // We need a label after this instruction.
1381 PrevLabel = MMI->getContext().CreateTempSymbol();
1382 Asm->OutStreamer.EmitLabel(PrevLabel);
1384 I->second = PrevLabel;
1387 // Each LexicalScope has first instruction and last instruction to mark
1388 // beginning and end of a scope respectively. Create an inverse map that list
1389 // scopes starts (and ends) with an instruction. One instruction may start (or
1390 // end) multiple scopes. Ignore scopes that are not reachable.
1391 void DwarfDebug::identifyScopeMarkers() {
1392 SmallVector<LexicalScope *, 4> WorkList;
1393 WorkList.push_back(LScopes.getCurrentFunctionScope());
1394 while (!WorkList.empty()) {
1395 LexicalScope *S = WorkList.pop_back_val();
1397 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1398 if (!Children.empty())
1399 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1400 SE = Children.end(); SI != SE; ++SI)
1401 WorkList.push_back(*SI);
1403 if (S->isAbstractScope())
1406 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1409 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1410 RE = Ranges.end(); RI != RE; ++RI) {
1411 assert(RI->first && "InsnRange does not have first instruction!");
1412 assert(RI->second && "InsnRange does not have second instruction!");
1413 requestLabelBeforeInsn(RI->first);
1414 requestLabelAfterInsn(RI->second);
1419 // Get MDNode for DebugLoc's scope.
1420 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1421 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1422 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1423 return DL.getScope(Ctx);
1426 // Walk up the scope chain of given debug loc and find line number info
1427 // for the function.
1428 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1429 const MDNode *Scope = getScopeNode(DL, Ctx);
1430 DISubprogram SP = getDISubprogram(Scope);
1432 // Check for number of operands since the compatibility is
1434 if (SP->getNumOperands() > 19)
1435 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1437 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1443 // Gather pre-function debug information. Assumes being called immediately
1444 // after the function entry point has been emitted.
1445 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1446 if (!MMI->hasDebugInfo()) return;
1447 LScopes.initialize(*MF);
1448 if (LScopes.empty()) return;
1449 identifyScopeMarkers();
1451 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1453 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1454 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1455 assert(TheCU && "Unable to find compile unit!");
1456 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1458 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1459 Asm->getFunctionNumber());
1460 // Assumes in correct section after the entry point.
1461 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1463 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1465 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1466 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1467 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1469 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1471 bool AtBlockEntry = true;
1472 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1474 const MachineInstr *MI = II;
1476 if (MI->isDebugValue()) {
1477 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1479 // Keep track of user variables.
1481 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1483 // Variable is in a register, we need to check for clobbers.
1484 if (isDbgValueInDefinedReg(MI))
1485 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1487 // Check the history of this variable.
1488 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1489 if (History.empty()) {
1490 UserVariables.push_back(Var);
1491 // The first mention of a function argument gets the FunctionBeginSym
1492 // label, so arguments are visible when breaking at function entry.
1494 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1495 DISubprogram(getDISubprogram(DV.getContext()))
1496 .describes(MF->getFunction()))
1497 LabelsBeforeInsn[MI] = FunctionBeginSym;
1499 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1500 const MachineInstr *Prev = History.back();
1501 if (Prev->isDebugValue()) {
1502 // Coalesce identical entries at the end of History.
1503 if (History.size() >= 2 &&
1504 Prev->isIdenticalTo(History[History.size() - 2])) {
1505 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1507 << "\t" << *History[History.size() - 2] << "\n");
1511 // Terminate old register assignments that don't reach MI;
1512 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1513 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1514 isDbgValueInDefinedReg(Prev)) {
1515 // Previous register assignment needs to terminate at the end of
1517 MachineBasicBlock::const_iterator LastMI =
1518 PrevMBB->getLastNonDebugInstr();
1519 if (LastMI == PrevMBB->end()) {
1520 // Drop DBG_VALUE for empty range.
1521 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1522 << "\t" << *Prev << "\n");
1526 // Terminate after LastMI.
1527 History.push_back(LastMI);
1532 History.push_back(MI);
1534 // Not a DBG_VALUE instruction.
1536 AtBlockEntry = false;
1538 // First known non-DBG_VALUE and non-frame setup location marks
1539 // the beginning of the function body.
1540 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1541 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1542 PrologEndLoc = MI->getDebugLoc();
1544 // Check if the instruction clobbers any registers with debug vars.
1545 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1546 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1547 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1549 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1550 AI.isValid(); ++AI) {
1552 const MDNode *Var = LiveUserVar[Reg];
1555 // Reg is now clobbered.
1556 LiveUserVar[Reg] = 0;
1558 // Was MD last defined by a DBG_VALUE referring to Reg?
1559 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1560 if (HistI == DbgValues.end())
1562 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1563 if (History.empty())
1565 const MachineInstr *Prev = History.back();
1566 // Sanity-check: Register assignments are terminated at the end of
1568 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1570 // Is the variable still in Reg?
1571 if (!isDbgValueInDefinedReg(Prev) ||
1572 Prev->getOperand(0).getReg() != Reg)
1574 // Var is clobbered. Make sure the next instruction gets a label.
1575 History.push_back(MI);
1582 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1584 SmallVectorImpl<const MachineInstr*> &History = I->second;
1585 if (History.empty())
1588 // Make sure the final register assignments are terminated.
1589 const MachineInstr *Prev = History.back();
1590 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1591 const MachineBasicBlock *PrevMBB = Prev->getParent();
1592 MachineBasicBlock::const_iterator LastMI =
1593 PrevMBB->getLastNonDebugInstr();
1594 if (LastMI == PrevMBB->end())
1595 // Drop DBG_VALUE for empty range.
1598 // Terminate after LastMI.
1599 History.push_back(LastMI);
1602 // Request labels for the full history.
1603 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1604 const MachineInstr *MI = History[i];
1605 if (MI->isDebugValue())
1606 requestLabelBeforeInsn(MI);
1608 requestLabelAfterInsn(MI);
1612 PrevInstLoc = DebugLoc();
1613 PrevLabel = FunctionBeginSym;
1615 // Record beginning of function.
1616 if (!PrologEndLoc.isUnknown()) {
1617 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1618 MF->getFunction()->getContext());
1619 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1620 FnStartDL.getScope(MF->getFunction()->getContext()),
1621 // We'd like to list the prologue as "not statements" but GDB behaves
1622 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1623 DWARF2_FLAG_IS_STMT);
1627 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1628 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1629 ScopeVariables[LS].push_back(Var);
1630 // Vars.push_back(Var);
1633 // Gather and emit post-function debug information.
1634 void DwarfDebug::endFunction(const MachineFunction *MF) {
1635 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1637 // Define end label for subprogram.
1638 FunctionEndSym = Asm->GetTempSymbol("func_end",
1639 Asm->getFunctionNumber());
1640 // Assumes in correct section after the entry point.
1641 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1642 // Set DwarfCompileUnitID in MCContext to default value.
1643 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1645 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1646 collectVariableInfo(MF, ProcessedVars);
1648 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1649 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1650 assert(TheCU && "Unable to find compile unit!");
1652 // Construct abstract scopes.
1653 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1654 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1655 LexicalScope *AScope = AList[i];
1656 DISubprogram SP(AScope->getScopeNode());
1658 // Collect info for variables that were optimized out.
1659 DIArray Variables = SP.getVariables();
1660 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1661 DIVariable DV(Variables.getElement(i));
1662 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1664 // Check that DbgVariable for DV wasn't created earlier, when
1665 // findAbstractVariable() was called for inlined instance of DV.
1666 LLVMContext &Ctx = DV->getContext();
1667 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1668 if (AbstractVariables.lookup(CleanDV))
1670 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1671 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1674 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1675 constructScopeDIE(TheCU, AScope);
1678 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1680 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1681 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1684 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1685 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1686 DeleteContainerPointers(I->second);
1687 ScopeVariables.clear();
1688 DeleteContainerPointers(CurrentFnArguments);
1689 UserVariables.clear();
1691 AbstractVariables.clear();
1692 LabelsBeforeInsn.clear();
1693 LabelsAfterInsn.clear();
1697 // Register a source line with debug info. Returns the unique label that was
1698 // emitted and which provides correspondence to the source line list.
1699 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1705 DIDescriptor Scope(S);
1707 if (Scope.isCompileUnit()) {
1708 DICompileUnit CU(S);
1709 Fn = CU.getFilename();
1710 Dir = CU.getDirectory();
1711 } else if (Scope.isFile()) {
1713 Fn = F.getFilename();
1714 Dir = F.getDirectory();
1715 } else if (Scope.isSubprogram()) {
1717 Fn = SP.getFilename();
1718 Dir = SP.getDirectory();
1719 } else if (Scope.isLexicalBlockFile()) {
1720 DILexicalBlockFile DBF(S);
1721 Fn = DBF.getFilename();
1722 Dir = DBF.getDirectory();
1723 } else if (Scope.isLexicalBlock()) {
1724 DILexicalBlock DB(S);
1725 Fn = DB.getFilename();
1726 Dir = DB.getDirectory();
1728 llvm_unreachable("Unexpected scope info");
1730 Src = getOrCreateSourceID(Fn, Dir,
1731 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1733 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1736 //===----------------------------------------------------------------------===//
1738 //===----------------------------------------------------------------------===//
1740 // Compute the size and offset of a DIE.
1742 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1743 // Get the children.
1744 const std::vector<DIE *> &Children = Die->getChildren();
1746 // Record the abbreviation.
1747 assignAbbrevNumber(Die->getAbbrev());
1749 // Get the abbreviation for this DIE.
1750 unsigned AbbrevNumber = Die->getAbbrevNumber();
1751 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1754 Die->setOffset(Offset);
1756 // Start the size with the size of abbreviation code.
1757 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1759 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1760 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1762 // Size the DIE attribute values.
1763 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1764 // Size attribute value.
1765 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1767 // Size the DIE children if any.
1768 if (!Children.empty()) {
1769 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1770 "Children flag not set");
1772 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1773 Offset = computeSizeAndOffset(Children[j], Offset);
1775 // End of children marker.
1776 Offset += sizeof(int8_t);
1779 Die->setSize(Offset - Die->getOffset());
1783 // Compute the size and offset of all the DIEs.
1784 void DwarfUnits::computeSizeAndOffsets() {
1785 // Offset from the beginning of debug info section.
1786 unsigned AccuOffset = 0;
1787 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1788 E = CUs.end(); I != E; ++I) {
1789 (*I)->setDebugInfoOffset(AccuOffset);
1791 sizeof(int32_t) + // Length of Compilation Unit Info
1792 sizeof(int16_t) + // DWARF version number
1793 sizeof(int32_t) + // Offset Into Abbrev. Section
1794 sizeof(int8_t); // Pointer Size (in bytes)
1796 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1797 AccuOffset += EndOffset;
1801 // Emit initial Dwarf sections with a label at the start of each one.
1802 void DwarfDebug::emitSectionLabels() {
1803 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1805 // Dwarf sections base addresses.
1806 DwarfInfoSectionSym =
1807 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1808 DwarfAbbrevSectionSym =
1809 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1810 if (useSplitDwarf())
1811 DwarfAbbrevDWOSectionSym =
1812 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1813 "section_abbrev_dwo");
1814 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1816 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1817 emitSectionSym(Asm, MacroInfo);
1819 DwarfLineSectionSym =
1820 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1821 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1822 if (GenerateDwarfPubNamesSection)
1823 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1824 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1825 DwarfStrSectionSym =
1826 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1827 if (useSplitDwarf()) {
1828 DwarfStrDWOSectionSym =
1829 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1830 DwarfAddrSectionSym =
1831 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1833 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1836 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1837 "section_debug_loc");
1839 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1840 emitSectionSym(Asm, TLOF.getDataSection());
1843 // Recursively emits a debug information entry.
1844 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1845 // Get the abbreviation for this DIE.
1846 unsigned AbbrevNumber = Die->getAbbrevNumber();
1847 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1849 // Emit the code (index) for the abbreviation.
1850 if (Asm->isVerbose())
1851 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1852 Twine::utohexstr(Die->getOffset()) + ":0x" +
1853 Twine::utohexstr(Die->getSize()) + " " +
1854 dwarf::TagString(Abbrev->getTag()));
1855 Asm->EmitULEB128(AbbrevNumber);
1857 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1858 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1860 // Emit the DIE attribute values.
1861 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1862 unsigned Attr = AbbrevData[i].getAttribute();
1863 unsigned Form = AbbrevData[i].getForm();
1864 assert(Form && "Too many attributes for DIE (check abbreviation)");
1866 if (Asm->isVerbose())
1867 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1870 case dwarf::DW_AT_abstract_origin: {
1871 DIEEntry *E = cast<DIEEntry>(Values[i]);
1872 DIE *Origin = E->getEntry();
1873 unsigned Addr = Origin->getOffset();
1874 if (Form == dwarf::DW_FORM_ref_addr) {
1875 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1876 // section. Origin->getOffset() returns the offset from start of the
1878 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1879 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1881 Asm->EmitInt32(Addr);
1884 case dwarf::DW_AT_ranges: {
1885 // DW_AT_range Value encodes offset in debug_range section.
1886 DIEInteger *V = cast<DIEInteger>(Values[i]);
1888 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1889 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1893 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1895 DwarfDebugRangeSectionSym,
1900 case dwarf::DW_AT_location: {
1901 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1902 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1903 Asm->EmitLabelReference(L->getValue(), 4);
1905 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1907 Values[i]->EmitValue(Asm, Form);
1911 case dwarf::DW_AT_accessibility: {
1912 if (Asm->isVerbose()) {
1913 DIEInteger *V = cast<DIEInteger>(Values[i]);
1914 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1916 Values[i]->EmitValue(Asm, Form);
1920 // Emit an attribute using the defined form.
1921 Values[i]->EmitValue(Asm, Form);
1926 // Emit the DIE children if any.
1927 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1928 const std::vector<DIE *> &Children = Die->getChildren();
1930 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1931 emitDIE(Children[j], Abbrevs);
1933 if (Asm->isVerbose())
1934 Asm->OutStreamer.AddComment("End Of Children Mark");
1939 // Emit the various dwarf units to the unit section USection with
1940 // the abbreviations going into ASection.
1941 void DwarfUnits::emitUnits(DwarfDebug *DD,
1942 const MCSection *USection,
1943 const MCSection *ASection,
1944 const MCSymbol *ASectionSym) {
1945 Asm->OutStreamer.SwitchSection(USection);
1946 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1947 E = CUs.end(); I != E; ++I) {
1948 CompileUnit *TheCU = *I;
1949 DIE *Die = TheCU->getCUDie();
1951 // Emit the compile units header.
1953 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1954 TheCU->getUniqueID()));
1956 // Emit size of content not including length itself
1957 unsigned ContentSize = Die->getSize() +
1958 sizeof(int16_t) + // DWARF version number
1959 sizeof(int32_t) + // Offset Into Abbrev. Section
1960 sizeof(int8_t); // Pointer Size (in bytes)
1962 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1963 Asm->EmitInt32(ContentSize);
1964 Asm->OutStreamer.AddComment("DWARF version number");
1965 Asm->EmitInt16(dwarf::DWARF_VERSION);
1966 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1967 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1969 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1970 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1972 DD->emitDIE(Die, Abbreviations);
1973 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1974 TheCU->getUniqueID()));
1978 /// For a given compile unit DIE, returns offset from beginning of debug info.
1979 unsigned DwarfUnits::getCUOffset(DIE *Die) {
1980 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
1981 "Input DIE should be compile unit in getCUOffset.");
1982 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1983 E = CUs.end(); I != E; ++I) {
1984 CompileUnit *TheCU = *I;
1985 if (TheCU->getCUDie() == Die)
1986 return TheCU->getDebugInfoOffset();
1988 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
1991 // Emit the debug info section.
1992 void DwarfDebug::emitDebugInfo() {
1993 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1995 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
1996 Asm->getObjFileLowering().getDwarfAbbrevSection(),
1997 DwarfAbbrevSectionSym);
2000 // Emit the abbreviation section.
2001 void DwarfDebug::emitAbbreviations() {
2002 if (!useSplitDwarf())
2003 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2006 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2009 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2010 std::vector<DIEAbbrev *> *Abbrevs) {
2011 // Check to see if it is worth the effort.
2012 if (!Abbrevs->empty()) {
2013 // Start the debug abbrev section.
2014 Asm->OutStreamer.SwitchSection(Section);
2016 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2017 Asm->OutStreamer.EmitLabel(Begin);
2019 // For each abbrevation.
2020 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2021 // Get abbreviation data
2022 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2024 // Emit the abbrevations code (base 1 index.)
2025 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2027 // Emit the abbreviations data.
2031 // Mark end of abbreviations.
2032 Asm->EmitULEB128(0, "EOM(3)");
2034 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2035 Asm->OutStreamer.EmitLabel(End);
2039 // Emit the last address of the section and the end of the line matrix.
2040 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2041 // Define last address of section.
2042 Asm->OutStreamer.AddComment("Extended Op");
2045 Asm->OutStreamer.AddComment("Op size");
2046 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2047 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2048 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2050 Asm->OutStreamer.AddComment("Section end label");
2052 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2053 Asm->getDataLayout().getPointerSize());
2055 // Mark end of matrix.
2056 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2062 // Emit visible names into a hashed accelerator table section.
2063 void DwarfDebug::emitAccelNames() {
2064 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2065 dwarf::DW_FORM_data4));
2066 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2067 E = CUMap.end(); I != E; ++I) {
2068 CompileUnit *TheCU = I->second;
2069 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2070 for (StringMap<std::vector<DIE*> >::const_iterator
2071 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2072 StringRef Name = GI->getKey();
2073 const std::vector<DIE *> &Entities = GI->second;
2074 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2075 DE = Entities.end(); DI != DE; ++DI)
2076 AT.AddName(Name, (*DI));
2080 AT.FinalizeTable(Asm, "Names");
2081 Asm->OutStreamer.SwitchSection(
2082 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2083 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2084 Asm->OutStreamer.EmitLabel(SectionBegin);
2086 // Emit the full data.
2087 AT.Emit(Asm, SectionBegin, &InfoHolder);
2090 // Emit objective C classes and categories into a hashed accelerator table
2092 void DwarfDebug::emitAccelObjC() {
2093 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2094 dwarf::DW_FORM_data4));
2095 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2096 E = CUMap.end(); I != E; ++I) {
2097 CompileUnit *TheCU = I->second;
2098 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2099 for (StringMap<std::vector<DIE*> >::const_iterator
2100 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2101 StringRef Name = GI->getKey();
2102 const std::vector<DIE *> &Entities = GI->second;
2103 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2104 DE = Entities.end(); DI != DE; ++DI)
2105 AT.AddName(Name, (*DI));
2109 AT.FinalizeTable(Asm, "ObjC");
2110 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2111 .getDwarfAccelObjCSection());
2112 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2113 Asm->OutStreamer.EmitLabel(SectionBegin);
2115 // Emit the full data.
2116 AT.Emit(Asm, SectionBegin, &InfoHolder);
2119 // Emit namespace dies into a hashed accelerator table.
2120 void DwarfDebug::emitAccelNamespaces() {
2121 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2122 dwarf::DW_FORM_data4));
2123 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2124 E = CUMap.end(); I != E; ++I) {
2125 CompileUnit *TheCU = I->second;
2126 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2127 for (StringMap<std::vector<DIE*> >::const_iterator
2128 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2129 StringRef Name = GI->getKey();
2130 const std::vector<DIE *> &Entities = GI->second;
2131 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2132 DE = Entities.end(); DI != DE; ++DI)
2133 AT.AddName(Name, (*DI));
2137 AT.FinalizeTable(Asm, "namespac");
2138 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2139 .getDwarfAccelNamespaceSection());
2140 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2141 Asm->OutStreamer.EmitLabel(SectionBegin);
2143 // Emit the full data.
2144 AT.Emit(Asm, SectionBegin, &InfoHolder);
2147 // Emit type dies into a hashed accelerator table.
2148 void DwarfDebug::emitAccelTypes() {
2149 std::vector<DwarfAccelTable::Atom> Atoms;
2150 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2151 dwarf::DW_FORM_data4));
2152 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2153 dwarf::DW_FORM_data2));
2154 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2155 dwarf::DW_FORM_data1));
2156 DwarfAccelTable AT(Atoms);
2157 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2158 E = CUMap.end(); I != E; ++I) {
2159 CompileUnit *TheCU = I->second;
2160 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2161 = TheCU->getAccelTypes();
2162 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2163 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2164 StringRef Name = GI->getKey();
2165 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2166 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2167 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2168 AT.AddName(Name, (*DI).first, (*DI).second);
2172 AT.FinalizeTable(Asm, "types");
2173 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2174 .getDwarfAccelTypesSection());
2175 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2176 Asm->OutStreamer.EmitLabel(SectionBegin);
2178 // Emit the full data.
2179 AT.Emit(Asm, SectionBegin, &InfoHolder);
2182 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2184 void DwarfDebug::emitDebugPubnames() {
2185 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2187 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2188 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2189 CompileUnit *TheCU = I->second;
2190 unsigned ID = TheCU->getUniqueID();
2192 if (TheCU->getGlobalNames().empty())
2195 // Start the dwarf pubnames section.
2196 Asm->OutStreamer.SwitchSection(
2197 Asm->getObjFileLowering().getDwarfPubNamesSection());
2199 Asm->OutStreamer.AddComment("Length of Public Names Info");
2200 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2201 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2203 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2205 Asm->OutStreamer.AddComment("DWARF Version");
2206 Asm->EmitInt16(dwarf::DWARF_VERSION);
2208 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2209 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2210 DwarfInfoSectionSym);
2212 Asm->OutStreamer.AddComment("Compilation Unit Length");
2213 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2214 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2217 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2218 for (StringMap<DIE*>::const_iterator
2219 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2220 const char *Name = GI->getKeyData();
2221 const DIE *Entity = GI->second;
2223 Asm->OutStreamer.AddComment("DIE offset");
2224 Asm->EmitInt32(Entity->getOffset());
2226 if (Asm->isVerbose())
2227 Asm->OutStreamer.AddComment("External Name");
2228 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2231 Asm->OutStreamer.AddComment("End Mark");
2233 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2237 void DwarfDebug::emitDebugPubTypes() {
2238 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2239 E = CUMap.end(); I != E; ++I) {
2240 CompileUnit *TheCU = I->second;
2241 // Start the dwarf pubtypes section.
2242 Asm->OutStreamer.SwitchSection(
2243 Asm->getObjFileLowering().getDwarfPubTypesSection());
2244 Asm->OutStreamer.AddComment("Length of Public Types Info");
2245 Asm->EmitLabelDifference(
2246 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2247 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2249 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2250 TheCU->getUniqueID()));
2252 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2253 Asm->EmitInt16(dwarf::DWARF_VERSION);
2255 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2256 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2257 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2258 TheCU->getUniqueID()),
2259 DwarfInfoSectionSym);
2261 Asm->OutStreamer.AddComment("Compilation Unit Length");
2262 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2263 TheCU->getUniqueID()),
2264 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2265 TheCU->getUniqueID()),
2268 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2269 for (StringMap<DIE*>::const_iterator
2270 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2271 const char *Name = GI->getKeyData();
2272 DIE *Entity = GI->second;
2274 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2275 Asm->EmitInt32(Entity->getOffset());
2277 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2278 // Emit the name with a terminating null byte.
2279 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2282 Asm->OutStreamer.AddComment("End Mark");
2284 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2285 TheCU->getUniqueID()));
2289 // Emit strings into a string section.
2290 void DwarfUnits::emitStrings(const MCSection *StrSection,
2291 const MCSection *OffsetSection = NULL,
2292 const MCSymbol *StrSecSym = NULL) {
2294 if (StringPool.empty()) return;
2296 // Start the dwarf str section.
2297 Asm->OutStreamer.SwitchSection(StrSection);
2299 // Get all of the string pool entries and put them in an array by their ID so
2300 // we can sort them.
2301 SmallVector<std::pair<unsigned,
2302 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2304 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2305 I = StringPool.begin(), E = StringPool.end();
2307 Entries.push_back(std::make_pair(I->second.second, &*I));
2309 array_pod_sort(Entries.begin(), Entries.end());
2311 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2312 // Emit a label for reference from debug information entries.
2313 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2315 // Emit the string itself with a terminating null byte.
2316 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2317 Entries[i].second->getKeyLength()+1));
2320 // If we've got an offset section go ahead and emit that now as well.
2321 if (OffsetSection) {
2322 Asm->OutStreamer.SwitchSection(OffsetSection);
2323 unsigned offset = 0;
2324 unsigned size = 4; // FIXME: DWARF64 is 8.
2325 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2326 Asm->OutStreamer.EmitIntValue(offset, size);
2327 offset += Entries[i].second->getKeyLength() + 1;
2332 // Emit strings into a string section.
2333 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2335 if (AddressPool.empty()) return;
2337 // Start the dwarf addr section.
2338 Asm->OutStreamer.SwitchSection(AddrSection);
2340 // Get all of the string pool entries and put them in an array by their ID so
2341 // we can sort them.
2342 SmallVector<std::pair<unsigned,
2343 std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2345 for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2346 I = AddressPool.begin(), E = AddressPool.end();
2348 Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2350 array_pod_sort(Entries.begin(), Entries.end());
2352 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2353 // Emit a label for reference from debug information entries.
2354 MCSymbol *Sym = Entries[i].second->first;
2356 Asm->EmitLabelReference(Entries[i].second->first,
2357 Asm->getDataLayout().getPointerSize());
2359 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2364 // Emit visible names into a debug str section.
2365 void DwarfDebug::emitDebugStr() {
2366 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2367 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2370 // Emit visible names into a debug loc section.
2371 void DwarfDebug::emitDebugLoc() {
2372 if (DotDebugLocEntries.empty())
2375 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2376 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2378 DotDebugLocEntry &Entry = *I;
2379 if (I + 1 != DotDebugLocEntries.end())
2383 // Start the dwarf loc section.
2384 Asm->OutStreamer.SwitchSection(
2385 Asm->getObjFileLowering().getDwarfLocSection());
2386 unsigned char Size = Asm->getDataLayout().getPointerSize();
2387 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2389 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2390 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2391 I != E; ++I, ++index) {
2392 DotDebugLocEntry &Entry = *I;
2393 if (Entry.isMerged()) continue;
2394 if (Entry.isEmpty()) {
2395 Asm->OutStreamer.EmitIntValue(0, Size);
2396 Asm->OutStreamer.EmitIntValue(0, Size);
2397 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2399 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2400 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
2401 DIVariable DV(Entry.Variable);
2402 Asm->OutStreamer.AddComment("Loc expr size");
2403 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2404 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2405 Asm->EmitLabelDifference(end, begin, 2);
2406 Asm->OutStreamer.EmitLabel(begin);
2407 if (Entry.isInt()) {
2408 DIBasicType BTy(DV.getType());
2410 (BTy.getEncoding() == dwarf::DW_ATE_signed
2411 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2412 Asm->OutStreamer.AddComment("DW_OP_consts");
2413 Asm->EmitInt8(dwarf::DW_OP_consts);
2414 Asm->EmitSLEB128(Entry.getInt());
2416 Asm->OutStreamer.AddComment("DW_OP_constu");
2417 Asm->EmitInt8(dwarf::DW_OP_constu);
2418 Asm->EmitULEB128(Entry.getInt());
2420 } else if (Entry.isLocation()) {
2421 if (!DV.hasComplexAddress())
2423 Asm->EmitDwarfRegOp(Entry.Loc);
2425 // Complex address entry.
2426 unsigned N = DV.getNumAddrElements();
2428 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2429 if (Entry.Loc.getOffset()) {
2431 Asm->EmitDwarfRegOp(Entry.Loc);
2432 Asm->OutStreamer.AddComment("DW_OP_deref");
2433 Asm->EmitInt8(dwarf::DW_OP_deref);
2434 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2435 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2436 Asm->EmitSLEB128(DV.getAddrElement(1));
2438 // If first address element is OpPlus then emit
2439 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2440 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2441 Asm->EmitDwarfRegOp(Loc);
2445 Asm->EmitDwarfRegOp(Entry.Loc);
2448 // Emit remaining complex address elements.
2449 for (; i < N; ++i) {
2450 uint64_t Element = DV.getAddrElement(i);
2451 if (Element == DIBuilder::OpPlus) {
2452 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2453 Asm->EmitULEB128(DV.getAddrElement(++i));
2454 } else if (Element == DIBuilder::OpDeref) {
2455 if (!Entry.Loc.isReg())
2456 Asm->EmitInt8(dwarf::DW_OP_deref);
2458 llvm_unreachable("unknown Opcode found in complex address");
2462 // else ... ignore constant fp. There is not any good way to
2463 // to represent them here in dwarf.
2464 Asm->OutStreamer.EmitLabel(end);
2469 // Emit visible names into a debug aranges section.
2470 void DwarfDebug::emitDebugARanges() {
2471 // Start the dwarf aranges section.
2472 Asm->OutStreamer.SwitchSection(
2473 Asm->getObjFileLowering().getDwarfARangesSection());
2476 // Emit visible names into a debug ranges section.
2477 void DwarfDebug::emitDebugRanges() {
2478 // Start the dwarf ranges section.
2479 Asm->OutStreamer.SwitchSection(
2480 Asm->getObjFileLowering().getDwarfRangesSection());
2481 unsigned char Size = Asm->getDataLayout().getPointerSize();
2482 for (SmallVectorImpl<const MCSymbol *>::iterator
2483 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2486 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2488 Asm->OutStreamer.EmitIntValue(0, Size);
2492 // Emit visible names into a debug macinfo section.
2493 void DwarfDebug::emitDebugMacInfo() {
2494 if (const MCSection *LineInfo =
2495 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2496 // Start the dwarf macinfo section.
2497 Asm->OutStreamer.SwitchSection(LineInfo);
2501 // Emit inline info using following format.
2503 // 1. length of section
2504 // 2. Dwarf version number
2507 // Entries (one "entry" for each function that was inlined):
2509 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2510 // otherwise offset into __debug_str for regular function name.
2511 // 2. offset into __debug_str section for regular function name.
2512 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2513 // instances for the function.
2515 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2516 // inlined instance; the die_offset points to the inlined_subroutine die in the
2517 // __debug_info section, and the low_pc is the starting address for the
2518 // inlining instance.
2519 void DwarfDebug::emitDebugInlineInfo() {
2520 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2526 Asm->OutStreamer.SwitchSection(
2527 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2529 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2530 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2531 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2533 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2535 Asm->OutStreamer.AddComment("Dwarf Version");
2536 Asm->EmitInt16(dwarf::DWARF_VERSION);
2537 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2538 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2540 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2541 E = InlinedSPNodes.end(); I != E; ++I) {
2543 const MDNode *Node = *I;
2544 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2545 = InlineInfo.find(Node);
2546 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2547 DISubprogram SP(Node);
2548 StringRef LName = SP.getLinkageName();
2549 StringRef Name = SP.getName();
2551 Asm->OutStreamer.AddComment("MIPS linkage name");
2553 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2554 DwarfStrSectionSym);
2556 Asm->EmitSectionOffset(InfoHolder
2557 .getStringPoolEntry(getRealLinkageName(LName)),
2558 DwarfStrSectionSym);
2560 Asm->OutStreamer.AddComment("Function name");
2561 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2562 DwarfStrSectionSym);
2563 Asm->EmitULEB128(Labels.size(), "Inline count");
2565 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2566 LE = Labels.end(); LI != LE; ++LI) {
2567 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2568 Asm->EmitInt32(LI->second->getOffset());
2570 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2571 Asm->OutStreamer.EmitSymbolValue(LI->first,
2572 Asm->getDataLayout().getPointerSize());
2576 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2579 // DWARF5 Experimental Separate Dwarf emitters.
2581 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2582 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2583 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2584 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2585 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2586 DICompileUnit DIUnit(N);
2587 CompilationDir = DIUnit.getDirectory();
2589 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2590 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2591 DIUnit.getLanguage(), Die, N, Asm,
2592 this, &SkeletonHolder);
2594 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2595 DIUnit.getSplitDebugFilename());
2597 // This should be a unique identifier when we want to build .dwp files.
2598 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2600 // Relocate to the beginning of the addr_base section, else 0 for the
2601 // beginning of the one for this compile unit.
2602 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2603 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2604 DwarfAddrSectionSym);
2606 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2607 dwarf::DW_FORM_sec_offset, 0);
2609 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2610 // into an entity. We're using 0, or a NULL label for this.
2611 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2613 // DW_AT_stmt_list is a offset of line number information for this
2614 // compile unit in debug_line section.
2615 // FIXME: Should handle multiple compile units.
2616 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2617 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2618 DwarfLineSectionSym);
2620 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2622 if (!CompilationDir.empty())
2623 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2625 SkeletonHolder.addUnit(NewCU);
2626 SkeletonCUs.push_back(NewCU);
2631 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2632 assert(useSplitDwarf() && "No split dwarf debug info?");
2633 emitAbbrevs(Section, &SkeletonAbbrevs);
2636 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2637 // compile units that would normally be in debug_info.
2638 void DwarfDebug::emitDebugInfoDWO() {
2639 assert(useSplitDwarf() && "No split dwarf debug info?");
2640 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2641 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2642 DwarfAbbrevDWOSectionSym);
2645 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2646 // abbreviations for the .debug_info.dwo section.
2647 void DwarfDebug::emitDebugAbbrevDWO() {
2648 assert(useSplitDwarf() && "No split dwarf?");
2649 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2653 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2654 // string section and is identical in format to traditional .debug_str
2656 void DwarfDebug::emitDebugStrDWO() {
2657 assert(useSplitDwarf() && "No split dwarf?");
2658 const MCSection *OffSec = Asm->getObjFileLowering()
2659 .getDwarfStrOffDWOSection();
2660 const MCSymbol *StrSym = DwarfStrSectionSym;
2661 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),