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 // Use a single line table if we are using .loc and generating assembly.
713 (Asm->TM.hasMCUseLoc() &&
714 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
715 (NewCU->getUniqueID() == 0);
717 // DW_AT_stmt_list is a offset of line number information for this
718 // compile unit in debug_line section. For split dwarf this is
719 // left in the skeleton CU and so not included.
720 // The line table entries are not always emitted in assembly, so it
721 // is not okay to use line_table_start here.
722 if (!useSplitDwarf()) {
723 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
724 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
726 Asm->GetTempSymbol("section_line") : LineTableStartSym);
727 else if (UseTheFirstCU)
728 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
730 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
731 LineTableStartSym, DwarfLineSectionSym);
734 // If we're using split dwarf the compilation dir is going to be in the
735 // skeleton CU and so we don't need to duplicate it here.
736 if (!useSplitDwarf() && !CompilationDir.empty())
737 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
738 if (DIUnit.isOptimized())
739 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
741 StringRef Flags = DIUnit.getFlags();
743 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
745 if (unsigned RVer = DIUnit.getRunTimeVersion())
746 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
747 dwarf::DW_FORM_data1, RVer);
752 InfoHolder.addUnit(NewCU);
754 CUMap.insert(std::make_pair(N, NewCU));
758 // Construct subprogram DIE.
759 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
761 CompileUnit *&CURef = SPMap[N];
767 if (!SP.isDefinition())
768 // This is a method declaration which will be handled while constructing
772 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
775 TheCU->insertDIE(N, SubprogramDie);
777 // Add to context owner.
778 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
780 // Expose as global, if requested.
781 if (GenerateDwarfPubNamesSection)
782 TheCU->addGlobalName(SP.getName(), SubprogramDie);
785 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
787 DIImportedEntity Module(N);
788 if (!Module.Verify())
790 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
791 constructImportedEntityDIE(TheCU, Module, D);
794 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
796 DIImportedEntity Module(N);
797 if (!Module.Verify())
799 return constructImportedEntityDIE(TheCU, Module, Context);
802 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
803 const DIImportedEntity &Module,
805 assert(Module.Verify() &&
806 "Use one of the MDNode * overloads to handle invalid metadata");
807 assert(Context && "Should always have a context for an imported_module");
808 DIE *IMDie = new DIE(Module.getTag());
809 TheCU->insertDIE(Module, IMDie);
811 DIDescriptor Entity = Module.getEntity();
812 if (Entity.isNameSpace())
813 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
814 else if (Entity.isSubprogram())
815 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
816 else if (Entity.isType())
817 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
819 EntityDie = TheCU->getDIE(Entity);
820 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
821 Module.getContext().getDirectory(),
822 TheCU->getUniqueID());
823 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
824 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
825 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4, EntityDie);
826 StringRef Name = Module.getName();
828 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
829 Context->addChild(IMDie);
832 // Emit all Dwarf sections that should come prior to the content. Create
833 // global DIEs and emit initial debug info sections. This is invoked by
834 // the target AsmPrinter.
835 void DwarfDebug::beginModule() {
836 if (DisableDebugInfoPrinting)
839 const Module *M = MMI->getModule();
841 // If module has named metadata anchors then use them, otherwise scan the
842 // module using debug info finder to collect debug info.
843 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
847 // Emit initial sections so we can reference labels later.
850 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
851 DICompileUnit CUNode(CU_Nodes->getOperand(i));
852 CompileUnit *CU = constructCompileUnit(CUNode);
853 DIArray ImportedEntities = CUNode.getImportedEntities();
854 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
855 ScopesWithImportedEntities.push_back(std::make_pair(
856 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
857 ImportedEntities.getElement(i)));
858 std::sort(ScopesWithImportedEntities.begin(),
859 ScopesWithImportedEntities.end(), CompareFirst());
860 DIArray GVs = CUNode.getGlobalVariables();
861 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
862 CU->createGlobalVariableDIE(GVs.getElement(i));
863 DIArray SPs = CUNode.getSubprograms();
864 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
865 constructSubprogramDIE(CU, SPs.getElement(i));
866 DIArray EnumTypes = CUNode.getEnumTypes();
867 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
868 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
869 DIArray RetainedTypes = CUNode.getRetainedTypes();
870 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
871 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
872 // Emit imported_modules last so that the relevant context is already
874 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
875 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
876 // If we're splitting the dwarf out now that we've got the entire
877 // CU then construct a skeleton CU based upon it.
878 if (useSplitDwarf()) {
879 // This should be a unique identifier when we want to build .dwp files.
880 CU->addUInt(CU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
881 dwarf::DW_FORM_data8, 0);
882 // Now construct the skeleton CU associated.
883 constructSkeletonCU(CUNode);
887 // Tell MMI that we have debug info.
888 MMI->setDebugInfoAvailability(true);
890 // Prime section data.
891 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
894 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
895 void DwarfDebug::computeInlinedDIEs() {
896 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
897 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
898 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
900 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
902 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
903 AE = AbstractSPDies.end(); AI != AE; ++AI) {
904 DIE *ISP = AI->second;
905 if (InlinedSubprogramDIEs.count(ISP))
907 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
911 // Collect info for variables that were optimized out.
912 void DwarfDebug::collectDeadVariables() {
913 const Module *M = MMI->getModule();
914 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
916 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
917 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
918 DICompileUnit TheCU(CU_Nodes->getOperand(i));
919 DIArray Subprograms = TheCU.getSubprograms();
920 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
921 DISubprogram SP(Subprograms.getElement(i));
922 if (ProcessedSPNodes.count(SP) != 0) continue;
923 if (!SP.Verify()) continue;
924 if (!SP.isDefinition()) continue;
925 DIArray Variables = SP.getVariables();
926 if (Variables.getNumElements() == 0) continue;
928 LexicalScope *Scope =
929 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
930 DeadFnScopeMap[SP] = Scope;
932 // Construct subprogram DIE and add variables DIEs.
933 CompileUnit *SPCU = CUMap.lookup(TheCU);
934 assert(SPCU && "Unable to find Compile Unit!");
935 constructSubprogramDIE(SPCU, SP);
936 DIE *ScopeDIE = SPCU->getDIE(SP);
937 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
938 DIVariable DV(Variables.getElement(vi));
939 if (!DV.Verify()) continue;
940 DbgVariable *NewVar = new DbgVariable(DV, NULL);
941 if (DIE *VariableDIE =
942 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
943 ScopeDIE->addChild(VariableDIE);
948 DeleteContainerSeconds(DeadFnScopeMap);
951 void DwarfDebug::finalizeModuleInfo() {
952 // Collect info for variables that were optimized out.
953 collectDeadVariables();
955 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
956 computeInlinedDIEs();
958 // Emit DW_AT_containing_type attribute to connect types with their
959 // vtable holding type.
960 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
961 CUE = CUMap.end(); CUI != CUE; ++CUI) {
962 CompileUnit *TheCU = CUI->second;
963 TheCU->constructContainingTypeDIEs();
966 // Compute DIE offsets and sizes.
967 InfoHolder.computeSizeAndOffsets();
969 SkeletonHolder.computeSizeAndOffsets();
972 void DwarfDebug::endSections() {
973 // Standard sections final addresses.
974 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
975 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
976 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
977 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
979 // End text sections.
980 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
981 Asm->OutStreamer.SwitchSection(SectionMap[I]);
982 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
986 // Emit all Dwarf sections that should come after the content.
987 void DwarfDebug::endModule() {
989 if (!FirstCU) return;
991 // End any existing sections.
992 // TODO: Does this need to happen?
995 // Finalize the debug info for the module.
996 finalizeModuleInfo();
998 if (!useSplitDwarf()) {
999 // Emit all the DIEs into a debug info section.
1002 // Corresponding abbreviations into a abbrev section.
1003 emitAbbreviations();
1005 // Emit info into a debug loc section.
1008 // Emit info into a debug aranges section.
1011 // Emit info into a debug ranges section.
1014 // Emit info into a debug macinfo section.
1017 // Emit inline info.
1018 // TODO: When we don't need the option anymore we
1019 // can remove all of the code that this section
1021 if (useDarwinGDBCompat())
1022 emitDebugInlineInfo();
1024 // TODO: Fill this in for separated debug sections and separate
1025 // out information into new sections.
1027 // Emit the debug info section and compile units.
1031 // Corresponding abbreviations into a abbrev section.
1032 emitAbbreviations();
1033 emitDebugAbbrevDWO();
1035 // Emit info into a debug loc section.
1038 // Emit info into a debug aranges section.
1041 // Emit info into a debug ranges section.
1044 // Emit info into a debug macinfo section.
1047 // Emit DWO addresses.
1048 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1050 // Emit inline info.
1051 // TODO: When we don't need the option anymore we
1052 // can remove all of the code that this section
1054 if (useDarwinGDBCompat())
1055 emitDebugInlineInfo();
1058 // Emit info into the dwarf accelerator table sections.
1059 if (useDwarfAccelTables()) {
1062 emitAccelNamespaces();
1066 // Emit info into a debug pubnames section, if requested.
1067 if (GenerateDwarfPubNamesSection)
1068 emitDebugPubnames();
1070 // Emit info into a debug pubtypes section.
1071 // TODO: When we don't need the option anymore we can
1072 // remove all of the code that adds to the table.
1073 if (useDarwinGDBCompat())
1074 emitDebugPubTypes();
1076 // Finally emit string information into a string table.
1078 if (useSplitDwarf())
1083 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1084 E = CUMap.end(); I != E; ++I)
1087 for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
1088 E = SkeletonCUs.end(); I != E; ++I)
1091 // Reset these for the next Module if we have one.
1095 // Find abstract variable, if any, associated with Var.
1096 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1097 DebugLoc ScopeLoc) {
1098 LLVMContext &Ctx = DV->getContext();
1099 // More then one inlined variable corresponds to one abstract variable.
1100 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1101 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1103 return AbsDbgVariable;
1105 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1109 AbsDbgVariable = new DbgVariable(Var, NULL);
1110 addScopeVariable(Scope, AbsDbgVariable);
1111 AbstractVariables[Var] = AbsDbgVariable;
1112 return AbsDbgVariable;
1115 // If Var is a current function argument then add it to CurrentFnArguments list.
1116 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1117 DbgVariable *Var, LexicalScope *Scope) {
1118 if (!LScopes.isCurrentFunctionScope(Scope))
1120 DIVariable DV = Var->getVariable();
1121 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1123 unsigned ArgNo = DV.getArgNumber();
1127 size_t Size = CurrentFnArguments.size();
1129 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1130 // llvm::Function argument size is not good indicator of how many
1131 // arguments does the function have at source level.
1133 CurrentFnArguments.resize(ArgNo * 2);
1134 CurrentFnArguments[ArgNo - 1] = Var;
1138 // Collect variable information from side table maintained by MMI.
1140 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1141 SmallPtrSet<const MDNode *, 16> &Processed) {
1142 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1143 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1144 VE = VMap.end(); VI != VE; ++VI) {
1145 const MDNode *Var = VI->first;
1147 Processed.insert(Var);
1149 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1151 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1153 // If variable scope is not found then skip this variable.
1157 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1158 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1159 RegVar->setFrameIndex(VP.first);
1160 if (!addCurrentFnArgument(MF, RegVar, Scope))
1161 addScopeVariable(Scope, RegVar);
1163 AbsDbgVariable->setFrameIndex(VP.first);
1167 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1169 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1170 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1171 return MI->getNumOperands() == 3 &&
1172 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1173 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1176 // Get .debug_loc entry for the instruction range starting at MI.
1177 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1178 const MCSymbol *FLabel,
1179 const MCSymbol *SLabel,
1180 const MachineInstr *MI) {
1181 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1183 if (MI->getNumOperands() != 3) {
1184 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1185 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1187 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1188 MachineLocation MLoc;
1189 // TODO: Currently an offset of 0 in a DBG_VALUE means
1190 // we need to generate a direct register value.
1191 // There is no way to specify an indirect value with offset 0.
1192 if (MI->getOperand(1).getImm() == 0)
1193 MLoc.set(MI->getOperand(0).getReg());
1195 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1196 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1198 if (MI->getOperand(0).isImm())
1199 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1200 if (MI->getOperand(0).isFPImm())
1201 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1202 if (MI->getOperand(0).isCImm())
1203 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1205 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1208 // Find variables for each lexical scope.
1210 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1211 SmallPtrSet<const MDNode *, 16> &Processed) {
1213 // collection info from MMI table.
1214 collectVariableInfoFromMMITable(MF, Processed);
1216 for (SmallVectorImpl<const MDNode*>::const_iterator
1217 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1219 const MDNode *Var = *UVI;
1220 if (Processed.count(Var))
1223 // History contains relevant DBG_VALUE instructions for Var and instructions
1225 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1226 if (History.empty())
1228 const MachineInstr *MInsn = History.front();
1231 LexicalScope *Scope = NULL;
1232 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1233 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1234 Scope = LScopes.getCurrentFunctionScope();
1235 else if (MDNode *IA = DV.getInlinedAt())
1236 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1238 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1239 // If variable scope is not found then skip this variable.
1243 Processed.insert(DV);
1244 assert(MInsn->isDebugValue() && "History must begin with debug value");
1245 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1246 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1247 if (!addCurrentFnArgument(MF, RegVar, Scope))
1248 addScopeVariable(Scope, RegVar);
1250 AbsVar->setMInsn(MInsn);
1252 // Simplify ranges that are fully coalesced.
1253 if (History.size() <= 1 || (History.size() == 2 &&
1254 MInsn->isIdenticalTo(History.back()))) {
1255 RegVar->setMInsn(MInsn);
1259 // Handle multiple DBG_VALUE instructions describing one variable.
1260 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1262 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1263 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1264 const MachineInstr *Begin = *HI;
1265 assert(Begin->isDebugValue() && "Invalid History entry");
1267 // Check if DBG_VALUE is truncating a range.
1268 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1269 && !Begin->getOperand(0).getReg())
1272 // Compute the range for a register location.
1273 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1274 const MCSymbol *SLabel = 0;
1277 // If Begin is the last instruction in History then its value is valid
1278 // until the end of the function.
1279 SLabel = FunctionEndSym;
1281 const MachineInstr *End = HI[1];
1282 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1283 << "\t" << *Begin << "\t" << *End << "\n");
1284 if (End->isDebugValue())
1285 SLabel = getLabelBeforeInsn(End);
1287 // End is a normal instruction clobbering the range.
1288 SLabel = getLabelAfterInsn(End);
1289 assert(SLabel && "Forgot label after clobber instruction");
1294 // The value is valid until the next DBG_VALUE or clobber.
1295 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1298 DotDebugLocEntries.push_back(DotDebugLocEntry());
1301 // Collect info for variables that were optimized out.
1302 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1303 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1304 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1305 DIVariable DV(Variables.getElement(i));
1306 if (!DV || !DV.Verify() || !Processed.insert(DV))
1308 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1309 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1313 // Return Label preceding the instruction.
1314 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1315 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1316 assert(Label && "Didn't insert label before instruction");
1320 // Return Label immediately following the instruction.
1321 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1322 return LabelsAfterInsn.lookup(MI);
1325 // Process beginning of an instruction.
1326 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1327 // Check if source location changes, but ignore DBG_VALUE locations.
1328 if (!MI->isDebugValue()) {
1329 DebugLoc DL = MI->getDebugLoc();
1330 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1333 if (DL == PrologEndLoc) {
1334 Flags |= DWARF2_FLAG_PROLOGUE_END;
1335 PrologEndLoc = DebugLoc();
1337 if (PrologEndLoc.isUnknown())
1338 Flags |= DWARF2_FLAG_IS_STMT;
1340 if (!DL.isUnknown()) {
1341 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1342 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1344 recordSourceLine(0, 0, 0, 0);
1348 // Insert labels where requested.
1349 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1350 LabelsBeforeInsn.find(MI);
1353 if (I == LabelsBeforeInsn.end())
1356 // Label already assigned.
1361 PrevLabel = MMI->getContext().CreateTempSymbol();
1362 Asm->OutStreamer.EmitLabel(PrevLabel);
1364 I->second = PrevLabel;
1367 // Process end of an instruction.
1368 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1369 // Don't create a new label after DBG_VALUE instructions.
1370 // They don't generate code.
1371 if (!MI->isDebugValue())
1374 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1375 LabelsAfterInsn.find(MI);
1378 if (I == LabelsAfterInsn.end())
1381 // Label already assigned.
1385 // We need a label after this instruction.
1387 PrevLabel = MMI->getContext().CreateTempSymbol();
1388 Asm->OutStreamer.EmitLabel(PrevLabel);
1390 I->second = PrevLabel;
1393 // Each LexicalScope has first instruction and last instruction to mark
1394 // beginning and end of a scope respectively. Create an inverse map that list
1395 // scopes starts (and ends) with an instruction. One instruction may start (or
1396 // end) multiple scopes. Ignore scopes that are not reachable.
1397 void DwarfDebug::identifyScopeMarkers() {
1398 SmallVector<LexicalScope *, 4> WorkList;
1399 WorkList.push_back(LScopes.getCurrentFunctionScope());
1400 while (!WorkList.empty()) {
1401 LexicalScope *S = WorkList.pop_back_val();
1403 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1404 if (!Children.empty())
1405 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1406 SE = Children.end(); SI != SE; ++SI)
1407 WorkList.push_back(*SI);
1409 if (S->isAbstractScope())
1412 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1415 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1416 RE = Ranges.end(); RI != RE; ++RI) {
1417 assert(RI->first && "InsnRange does not have first instruction!");
1418 assert(RI->second && "InsnRange does not have second instruction!");
1419 requestLabelBeforeInsn(RI->first);
1420 requestLabelAfterInsn(RI->second);
1425 // Get MDNode for DebugLoc's scope.
1426 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1427 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1428 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1429 return DL.getScope(Ctx);
1432 // Walk up the scope chain of given debug loc and find line number info
1433 // for the function.
1434 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1435 const MDNode *Scope = getScopeNode(DL, Ctx);
1436 DISubprogram SP = getDISubprogram(Scope);
1438 // Check for number of operands since the compatibility is
1440 if (SP->getNumOperands() > 19)
1441 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1443 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1449 // Gather pre-function debug information. Assumes being called immediately
1450 // after the function entry point has been emitted.
1451 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1452 if (!MMI->hasDebugInfo()) return;
1453 LScopes.initialize(*MF);
1454 if (LScopes.empty()) return;
1455 identifyScopeMarkers();
1457 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1459 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1460 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1461 assert(TheCU && "Unable to find compile unit!");
1462 if (Asm->TM.hasMCUseLoc() &&
1463 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1464 // Use a single line table if we are using .loc and generating assembly.
1465 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1467 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1469 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1470 Asm->getFunctionNumber());
1471 // Assumes in correct section after the entry point.
1472 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1474 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1476 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1477 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1478 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1480 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1482 bool AtBlockEntry = true;
1483 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1485 const MachineInstr *MI = II;
1487 if (MI->isDebugValue()) {
1488 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1490 // Keep track of user variables.
1492 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1494 // Variable is in a register, we need to check for clobbers.
1495 if (isDbgValueInDefinedReg(MI))
1496 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1498 // Check the history of this variable.
1499 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1500 if (History.empty()) {
1501 UserVariables.push_back(Var);
1502 // The first mention of a function argument gets the FunctionBeginSym
1503 // label, so arguments are visible when breaking at function entry.
1505 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1506 DISubprogram(getDISubprogram(DV.getContext()))
1507 .describes(MF->getFunction()))
1508 LabelsBeforeInsn[MI] = FunctionBeginSym;
1510 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1511 const MachineInstr *Prev = History.back();
1512 if (Prev->isDebugValue()) {
1513 // Coalesce identical entries at the end of History.
1514 if (History.size() >= 2 &&
1515 Prev->isIdenticalTo(History[History.size() - 2])) {
1516 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1518 << "\t" << *History[History.size() - 2] << "\n");
1522 // Terminate old register assignments that don't reach MI;
1523 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1524 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1525 isDbgValueInDefinedReg(Prev)) {
1526 // Previous register assignment needs to terminate at the end of
1528 MachineBasicBlock::const_iterator LastMI =
1529 PrevMBB->getLastNonDebugInstr();
1530 if (LastMI == PrevMBB->end()) {
1531 // Drop DBG_VALUE for empty range.
1532 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1533 << "\t" << *Prev << "\n");
1537 // Terminate after LastMI.
1538 History.push_back(LastMI);
1543 History.push_back(MI);
1545 // Not a DBG_VALUE instruction.
1547 AtBlockEntry = false;
1549 // First known non-DBG_VALUE and non-frame setup location marks
1550 // the beginning of the function body.
1551 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1552 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1553 PrologEndLoc = MI->getDebugLoc();
1555 // Check if the instruction clobbers any registers with debug vars.
1556 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1557 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1558 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1560 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1561 AI.isValid(); ++AI) {
1563 const MDNode *Var = LiveUserVar[Reg];
1566 // Reg is now clobbered.
1567 LiveUserVar[Reg] = 0;
1569 // Was MD last defined by a DBG_VALUE referring to Reg?
1570 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1571 if (HistI == DbgValues.end())
1573 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1574 if (History.empty())
1576 const MachineInstr *Prev = History.back();
1577 // Sanity-check: Register assignments are terminated at the end of
1579 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1581 // Is the variable still in Reg?
1582 if (!isDbgValueInDefinedReg(Prev) ||
1583 Prev->getOperand(0).getReg() != Reg)
1585 // Var is clobbered. Make sure the next instruction gets a label.
1586 History.push_back(MI);
1593 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1595 SmallVectorImpl<const MachineInstr*> &History = I->second;
1596 if (History.empty())
1599 // Make sure the final register assignments are terminated.
1600 const MachineInstr *Prev = History.back();
1601 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1602 const MachineBasicBlock *PrevMBB = Prev->getParent();
1603 MachineBasicBlock::const_iterator LastMI =
1604 PrevMBB->getLastNonDebugInstr();
1605 if (LastMI == PrevMBB->end())
1606 // Drop DBG_VALUE for empty range.
1609 // Terminate after LastMI.
1610 History.push_back(LastMI);
1613 // Request labels for the full history.
1614 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1615 const MachineInstr *MI = History[i];
1616 if (MI->isDebugValue())
1617 requestLabelBeforeInsn(MI);
1619 requestLabelAfterInsn(MI);
1623 PrevInstLoc = DebugLoc();
1624 PrevLabel = FunctionBeginSym;
1626 // Record beginning of function.
1627 if (!PrologEndLoc.isUnknown()) {
1628 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1629 MF->getFunction()->getContext());
1630 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1631 FnStartDL.getScope(MF->getFunction()->getContext()),
1632 // We'd like to list the prologue as "not statements" but GDB behaves
1633 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1634 DWARF2_FLAG_IS_STMT);
1638 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1639 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1640 ScopeVariables[LS].push_back(Var);
1641 // Vars.push_back(Var);
1644 // Gather and emit post-function debug information.
1645 void DwarfDebug::endFunction(const MachineFunction *MF) {
1646 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1648 // Define end label for subprogram.
1649 FunctionEndSym = Asm->GetTempSymbol("func_end",
1650 Asm->getFunctionNumber());
1651 // Assumes in correct section after the entry point.
1652 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1653 // Set DwarfCompileUnitID in MCContext to default value.
1654 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1656 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1657 collectVariableInfo(MF, ProcessedVars);
1659 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1660 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1661 assert(TheCU && "Unable to find compile unit!");
1663 // Construct abstract scopes.
1664 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1665 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1666 LexicalScope *AScope = AList[i];
1667 DISubprogram SP(AScope->getScopeNode());
1669 // Collect info for variables that were optimized out.
1670 DIArray Variables = SP.getVariables();
1671 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1672 DIVariable DV(Variables.getElement(i));
1673 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1675 // Check that DbgVariable for DV wasn't created earlier, when
1676 // findAbstractVariable() was called for inlined instance of DV.
1677 LLVMContext &Ctx = DV->getContext();
1678 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1679 if (AbstractVariables.lookup(CleanDV))
1681 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1682 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1685 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1686 constructScopeDIE(TheCU, AScope);
1689 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1691 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1692 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1695 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1696 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1697 DeleteContainerPointers(I->second);
1698 ScopeVariables.clear();
1699 DeleteContainerPointers(CurrentFnArguments);
1700 UserVariables.clear();
1702 AbstractVariables.clear();
1703 LabelsBeforeInsn.clear();
1704 LabelsAfterInsn.clear();
1708 // Register a source line with debug info. Returns the unique label that was
1709 // emitted and which provides correspondence to the source line list.
1710 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1716 DIDescriptor Scope(S);
1718 if (Scope.isCompileUnit()) {
1719 DICompileUnit CU(S);
1720 Fn = CU.getFilename();
1721 Dir = CU.getDirectory();
1722 } else if (Scope.isFile()) {
1724 Fn = F.getFilename();
1725 Dir = F.getDirectory();
1726 } else if (Scope.isSubprogram()) {
1728 Fn = SP.getFilename();
1729 Dir = SP.getDirectory();
1730 } else if (Scope.isLexicalBlockFile()) {
1731 DILexicalBlockFile DBF(S);
1732 Fn = DBF.getFilename();
1733 Dir = DBF.getDirectory();
1734 } else if (Scope.isLexicalBlock()) {
1735 DILexicalBlock DB(S);
1736 Fn = DB.getFilename();
1737 Dir = DB.getDirectory();
1739 llvm_unreachable("Unexpected scope info");
1741 Src = getOrCreateSourceID(Fn, Dir,
1742 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1744 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1747 //===----------------------------------------------------------------------===//
1749 //===----------------------------------------------------------------------===//
1751 // Compute the size and offset of a DIE.
1753 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1754 // Get the children.
1755 const std::vector<DIE *> &Children = Die->getChildren();
1757 // Record the abbreviation.
1758 assignAbbrevNumber(Die->getAbbrev());
1760 // Get the abbreviation for this DIE.
1761 unsigned AbbrevNumber = Die->getAbbrevNumber();
1762 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1765 Die->setOffset(Offset);
1767 // Start the size with the size of abbreviation code.
1768 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1770 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1771 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1773 // Size the DIE attribute values.
1774 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1775 // Size attribute value.
1776 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1778 // Size the DIE children if any.
1779 if (!Children.empty()) {
1780 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1781 "Children flag not set");
1783 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1784 Offset = computeSizeAndOffset(Children[j], Offset);
1786 // End of children marker.
1787 Offset += sizeof(int8_t);
1790 Die->setSize(Offset - Die->getOffset());
1794 // Compute the size and offset of all the DIEs.
1795 void DwarfUnits::computeSizeAndOffsets() {
1796 // Offset from the beginning of debug info section.
1797 unsigned AccuOffset = 0;
1798 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1799 E = CUs.end(); I != E; ++I) {
1800 (*I)->setDebugInfoOffset(AccuOffset);
1802 sizeof(int32_t) + // Length of Compilation Unit Info
1803 sizeof(int16_t) + // DWARF version number
1804 sizeof(int32_t) + // Offset Into Abbrev. Section
1805 sizeof(int8_t); // Pointer Size (in bytes)
1807 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1808 AccuOffset += EndOffset;
1812 // Emit initial Dwarf sections with a label at the start of each one.
1813 void DwarfDebug::emitSectionLabels() {
1814 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1816 // Dwarf sections base addresses.
1817 DwarfInfoSectionSym =
1818 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1819 DwarfAbbrevSectionSym =
1820 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1821 if (useSplitDwarf())
1822 DwarfAbbrevDWOSectionSym =
1823 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1824 "section_abbrev_dwo");
1825 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1827 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1828 emitSectionSym(Asm, MacroInfo);
1830 DwarfLineSectionSym =
1831 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1832 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1833 if (GenerateDwarfPubNamesSection)
1834 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1835 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1836 DwarfStrSectionSym =
1837 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1838 if (useSplitDwarf()) {
1839 DwarfStrDWOSectionSym =
1840 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1841 DwarfAddrSectionSym =
1842 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1844 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1847 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1848 "section_debug_loc");
1850 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1851 emitSectionSym(Asm, TLOF.getDataSection());
1854 // Recursively emits a debug information entry.
1855 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1856 // Get the abbreviation for this DIE.
1857 unsigned AbbrevNumber = Die->getAbbrevNumber();
1858 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1860 // Emit the code (index) for the abbreviation.
1861 if (Asm->isVerbose())
1862 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1863 Twine::utohexstr(Die->getOffset()) + ":0x" +
1864 Twine::utohexstr(Die->getSize()) + " " +
1865 dwarf::TagString(Abbrev->getTag()));
1866 Asm->EmitULEB128(AbbrevNumber);
1868 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1869 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1871 // Emit the DIE attribute values.
1872 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1873 unsigned Attr = AbbrevData[i].getAttribute();
1874 unsigned Form = AbbrevData[i].getForm();
1875 assert(Form && "Too many attributes for DIE (check abbreviation)");
1877 if (Asm->isVerbose())
1878 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1881 case dwarf::DW_AT_abstract_origin: {
1882 DIEEntry *E = cast<DIEEntry>(Values[i]);
1883 DIE *Origin = E->getEntry();
1884 unsigned Addr = Origin->getOffset();
1885 if (Form == dwarf::DW_FORM_ref_addr) {
1886 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1887 // section. Origin->getOffset() returns the offset from start of the
1889 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1890 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1892 Asm->EmitInt32(Addr);
1895 case dwarf::DW_AT_ranges: {
1896 // DW_AT_range Value encodes offset in debug_range section.
1897 DIEInteger *V = cast<DIEInteger>(Values[i]);
1899 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1900 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1904 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1906 DwarfDebugRangeSectionSym,
1911 case dwarf::DW_AT_location: {
1912 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1913 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1914 Asm->EmitLabelReference(L->getValue(), 4);
1916 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1918 Values[i]->EmitValue(Asm, Form);
1922 case dwarf::DW_AT_accessibility: {
1923 if (Asm->isVerbose()) {
1924 DIEInteger *V = cast<DIEInteger>(Values[i]);
1925 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1927 Values[i]->EmitValue(Asm, Form);
1931 // Emit an attribute using the defined form.
1932 Values[i]->EmitValue(Asm, Form);
1937 // Emit the DIE children if any.
1938 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1939 const std::vector<DIE *> &Children = Die->getChildren();
1941 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1942 emitDIE(Children[j], Abbrevs);
1944 if (Asm->isVerbose())
1945 Asm->OutStreamer.AddComment("End Of Children Mark");
1950 // Emit the various dwarf units to the unit section USection with
1951 // the abbreviations going into ASection.
1952 void DwarfUnits::emitUnits(DwarfDebug *DD,
1953 const MCSection *USection,
1954 const MCSection *ASection,
1955 const MCSymbol *ASectionSym) {
1956 Asm->OutStreamer.SwitchSection(USection);
1957 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1958 E = CUs.end(); I != E; ++I) {
1959 CompileUnit *TheCU = *I;
1960 DIE *Die = TheCU->getCUDie();
1962 // Emit the compile units header.
1964 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1965 TheCU->getUniqueID()));
1967 // Emit size of content not including length itself
1968 unsigned ContentSize = Die->getSize() +
1969 sizeof(int16_t) + // DWARF version number
1970 sizeof(int32_t) + // Offset Into Abbrev. Section
1971 sizeof(int8_t); // Pointer Size (in bytes)
1973 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1974 Asm->EmitInt32(ContentSize);
1975 Asm->OutStreamer.AddComment("DWARF version number");
1976 Asm->EmitInt16(dwarf::DWARF_VERSION);
1977 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1978 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1980 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1981 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1983 DD->emitDIE(Die, Abbreviations);
1984 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1985 TheCU->getUniqueID()));
1989 /// For a given compile unit DIE, returns offset from beginning of debug info.
1990 unsigned DwarfUnits::getCUOffset(DIE *Die) {
1991 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
1992 "Input DIE should be compile unit in getCUOffset.");
1993 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1994 E = CUs.end(); I != E; ++I) {
1995 CompileUnit *TheCU = *I;
1996 if (TheCU->getCUDie() == Die)
1997 return TheCU->getDebugInfoOffset();
1999 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2002 // Emit the debug info section.
2003 void DwarfDebug::emitDebugInfo() {
2004 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2006 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2007 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2008 DwarfAbbrevSectionSym);
2011 // Emit the abbreviation section.
2012 void DwarfDebug::emitAbbreviations() {
2013 if (!useSplitDwarf())
2014 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2017 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2020 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2021 std::vector<DIEAbbrev *> *Abbrevs) {
2022 // Check to see if it is worth the effort.
2023 if (!Abbrevs->empty()) {
2024 // Start the debug abbrev section.
2025 Asm->OutStreamer.SwitchSection(Section);
2027 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2028 Asm->OutStreamer.EmitLabel(Begin);
2030 // For each abbrevation.
2031 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2032 // Get abbreviation data
2033 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2035 // Emit the abbrevations code (base 1 index.)
2036 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2038 // Emit the abbreviations data.
2042 // Mark end of abbreviations.
2043 Asm->EmitULEB128(0, "EOM(3)");
2045 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2046 Asm->OutStreamer.EmitLabel(End);
2050 // Emit the last address of the section and the end of the line matrix.
2051 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2052 // Define last address of section.
2053 Asm->OutStreamer.AddComment("Extended Op");
2056 Asm->OutStreamer.AddComment("Op size");
2057 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2058 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2059 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2061 Asm->OutStreamer.AddComment("Section end label");
2063 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2064 Asm->getDataLayout().getPointerSize());
2066 // Mark end of matrix.
2067 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2073 // Emit visible names into a hashed accelerator table section.
2074 void DwarfDebug::emitAccelNames() {
2075 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2076 dwarf::DW_FORM_data4));
2077 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2078 E = CUMap.end(); I != E; ++I) {
2079 CompileUnit *TheCU = I->second;
2080 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2081 for (StringMap<std::vector<DIE*> >::const_iterator
2082 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2083 StringRef Name = GI->getKey();
2084 const std::vector<DIE *> &Entities = GI->second;
2085 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2086 DE = Entities.end(); DI != DE; ++DI)
2087 AT.AddName(Name, (*DI));
2091 AT.FinalizeTable(Asm, "Names");
2092 Asm->OutStreamer.SwitchSection(
2093 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2094 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2095 Asm->OutStreamer.EmitLabel(SectionBegin);
2097 // Emit the full data.
2098 AT.Emit(Asm, SectionBegin, &InfoHolder);
2101 // Emit objective C classes and categories into a hashed accelerator table
2103 void DwarfDebug::emitAccelObjC() {
2104 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2105 dwarf::DW_FORM_data4));
2106 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2107 E = CUMap.end(); I != E; ++I) {
2108 CompileUnit *TheCU = I->second;
2109 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2110 for (StringMap<std::vector<DIE*> >::const_iterator
2111 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2112 StringRef Name = GI->getKey();
2113 const std::vector<DIE *> &Entities = GI->second;
2114 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2115 DE = Entities.end(); DI != DE; ++DI)
2116 AT.AddName(Name, (*DI));
2120 AT.FinalizeTable(Asm, "ObjC");
2121 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2122 .getDwarfAccelObjCSection());
2123 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2124 Asm->OutStreamer.EmitLabel(SectionBegin);
2126 // Emit the full data.
2127 AT.Emit(Asm, SectionBegin, &InfoHolder);
2130 // Emit namespace dies into a hashed accelerator table.
2131 void DwarfDebug::emitAccelNamespaces() {
2132 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2133 dwarf::DW_FORM_data4));
2134 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2135 E = CUMap.end(); I != E; ++I) {
2136 CompileUnit *TheCU = I->second;
2137 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2138 for (StringMap<std::vector<DIE*> >::const_iterator
2139 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2140 StringRef Name = GI->getKey();
2141 const std::vector<DIE *> &Entities = GI->second;
2142 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2143 DE = Entities.end(); DI != DE; ++DI)
2144 AT.AddName(Name, (*DI));
2148 AT.FinalizeTable(Asm, "namespac");
2149 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2150 .getDwarfAccelNamespaceSection());
2151 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2152 Asm->OutStreamer.EmitLabel(SectionBegin);
2154 // Emit the full data.
2155 AT.Emit(Asm, SectionBegin, &InfoHolder);
2158 // Emit type dies into a hashed accelerator table.
2159 void DwarfDebug::emitAccelTypes() {
2160 std::vector<DwarfAccelTable::Atom> Atoms;
2161 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2162 dwarf::DW_FORM_data4));
2163 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2164 dwarf::DW_FORM_data2));
2165 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2166 dwarf::DW_FORM_data1));
2167 DwarfAccelTable AT(Atoms);
2168 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2169 E = CUMap.end(); I != E; ++I) {
2170 CompileUnit *TheCU = I->second;
2171 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2172 = TheCU->getAccelTypes();
2173 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2174 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2175 StringRef Name = GI->getKey();
2176 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2177 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2178 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2179 AT.AddName(Name, (*DI).first, (*DI).second);
2183 AT.FinalizeTable(Asm, "types");
2184 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2185 .getDwarfAccelTypesSection());
2186 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2187 Asm->OutStreamer.EmitLabel(SectionBegin);
2189 // Emit the full data.
2190 AT.Emit(Asm, SectionBegin, &InfoHolder);
2193 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2195 void DwarfDebug::emitDebugPubnames() {
2196 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2198 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2199 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2200 CompileUnit *TheCU = I->second;
2201 unsigned ID = TheCU->getUniqueID();
2203 if (TheCU->getGlobalNames().empty())
2206 // Start the dwarf pubnames section.
2207 Asm->OutStreamer.SwitchSection(
2208 Asm->getObjFileLowering().getDwarfPubNamesSection());
2210 Asm->OutStreamer.AddComment("Length of Public Names Info");
2211 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2212 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2214 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2216 Asm->OutStreamer.AddComment("DWARF Version");
2217 Asm->EmitInt16(dwarf::DWARF_VERSION);
2219 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2220 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2221 DwarfInfoSectionSym);
2223 Asm->OutStreamer.AddComment("Compilation Unit Length");
2224 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2225 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2228 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2229 for (StringMap<DIE*>::const_iterator
2230 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2231 const char *Name = GI->getKeyData();
2232 const DIE *Entity = GI->second;
2234 Asm->OutStreamer.AddComment("DIE offset");
2235 Asm->EmitInt32(Entity->getOffset());
2237 if (Asm->isVerbose())
2238 Asm->OutStreamer.AddComment("External Name");
2239 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2242 Asm->OutStreamer.AddComment("End Mark");
2244 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2248 void DwarfDebug::emitDebugPubTypes() {
2249 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2250 E = CUMap.end(); I != E; ++I) {
2251 CompileUnit *TheCU = I->second;
2252 // Start the dwarf pubtypes section.
2253 Asm->OutStreamer.SwitchSection(
2254 Asm->getObjFileLowering().getDwarfPubTypesSection());
2255 Asm->OutStreamer.AddComment("Length of Public Types Info");
2256 Asm->EmitLabelDifference(
2257 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2258 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2260 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2261 TheCU->getUniqueID()));
2263 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2264 Asm->EmitInt16(dwarf::DWARF_VERSION);
2266 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2267 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2268 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2269 TheCU->getUniqueID()),
2270 DwarfInfoSectionSym);
2272 Asm->OutStreamer.AddComment("Compilation Unit Length");
2273 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2274 TheCU->getUniqueID()),
2275 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2276 TheCU->getUniqueID()),
2279 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2280 for (StringMap<DIE*>::const_iterator
2281 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2282 const char *Name = GI->getKeyData();
2283 DIE *Entity = GI->second;
2285 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2286 Asm->EmitInt32(Entity->getOffset());
2288 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2289 // Emit the name with a terminating null byte.
2290 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2293 Asm->OutStreamer.AddComment("End Mark");
2295 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2296 TheCU->getUniqueID()));
2300 // Emit strings into a string section.
2301 void DwarfUnits::emitStrings(const MCSection *StrSection,
2302 const MCSection *OffsetSection = NULL,
2303 const MCSymbol *StrSecSym = NULL) {
2305 if (StringPool.empty()) return;
2307 // Start the dwarf str section.
2308 Asm->OutStreamer.SwitchSection(StrSection);
2310 // Get all of the string pool entries and put them in an array by their ID so
2311 // we can sort them.
2312 SmallVector<std::pair<unsigned,
2313 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2315 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2316 I = StringPool.begin(), E = StringPool.end();
2318 Entries.push_back(std::make_pair(I->second.second, &*I));
2320 array_pod_sort(Entries.begin(), Entries.end());
2322 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2323 // Emit a label for reference from debug information entries.
2324 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2326 // Emit the string itself with a terminating null byte.
2327 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2328 Entries[i].second->getKeyLength()+1));
2331 // If we've got an offset section go ahead and emit that now as well.
2332 if (OffsetSection) {
2333 Asm->OutStreamer.SwitchSection(OffsetSection);
2334 unsigned offset = 0;
2335 unsigned size = 4; // FIXME: DWARF64 is 8.
2336 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2337 Asm->OutStreamer.EmitIntValue(offset, size);
2338 offset += Entries[i].second->getKeyLength() + 1;
2343 // Emit strings into a string section.
2344 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2346 if (AddressPool.empty()) return;
2348 // Start the dwarf addr section.
2349 Asm->OutStreamer.SwitchSection(AddrSection);
2351 // Get all of the string pool entries and put them in an array by their ID so
2352 // we can sort them.
2353 SmallVector<std::pair<unsigned,
2354 std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2356 for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2357 I = AddressPool.begin(), E = AddressPool.end();
2359 Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2361 array_pod_sort(Entries.begin(), Entries.end());
2363 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2364 // Emit a label for reference from debug information entries.
2365 MCSymbol *Sym = Entries[i].second->first;
2367 Asm->EmitLabelReference(Entries[i].second->first,
2368 Asm->getDataLayout().getPointerSize());
2370 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2375 // Emit visible names into a debug str section.
2376 void DwarfDebug::emitDebugStr() {
2377 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2378 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2381 // Emit visible names into a debug loc section.
2382 void DwarfDebug::emitDebugLoc() {
2383 if (DotDebugLocEntries.empty())
2386 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2387 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2389 DotDebugLocEntry &Entry = *I;
2390 if (I + 1 != DotDebugLocEntries.end())
2394 // Start the dwarf loc section.
2395 Asm->OutStreamer.SwitchSection(
2396 Asm->getObjFileLowering().getDwarfLocSection());
2397 unsigned char Size = Asm->getDataLayout().getPointerSize();
2398 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2400 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2401 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2402 I != E; ++I, ++index) {
2403 DotDebugLocEntry &Entry = *I;
2404 if (Entry.isMerged()) continue;
2405 if (Entry.isEmpty()) {
2406 Asm->OutStreamer.EmitIntValue(0, Size);
2407 Asm->OutStreamer.EmitIntValue(0, Size);
2408 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2410 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2411 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
2412 DIVariable DV(Entry.Variable);
2413 Asm->OutStreamer.AddComment("Loc expr size");
2414 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2415 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2416 Asm->EmitLabelDifference(end, begin, 2);
2417 Asm->OutStreamer.EmitLabel(begin);
2418 if (Entry.isInt()) {
2419 DIBasicType BTy(DV.getType());
2421 (BTy.getEncoding() == dwarf::DW_ATE_signed
2422 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2423 Asm->OutStreamer.AddComment("DW_OP_consts");
2424 Asm->EmitInt8(dwarf::DW_OP_consts);
2425 Asm->EmitSLEB128(Entry.getInt());
2427 Asm->OutStreamer.AddComment("DW_OP_constu");
2428 Asm->EmitInt8(dwarf::DW_OP_constu);
2429 Asm->EmitULEB128(Entry.getInt());
2431 } else if (Entry.isLocation()) {
2432 if (!DV.hasComplexAddress())
2434 Asm->EmitDwarfRegOp(Entry.Loc);
2436 // Complex address entry.
2437 unsigned N = DV.getNumAddrElements();
2439 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2440 if (Entry.Loc.getOffset()) {
2442 Asm->EmitDwarfRegOp(Entry.Loc);
2443 Asm->OutStreamer.AddComment("DW_OP_deref");
2444 Asm->EmitInt8(dwarf::DW_OP_deref);
2445 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2446 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2447 Asm->EmitSLEB128(DV.getAddrElement(1));
2449 // If first address element is OpPlus then emit
2450 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2451 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2452 Asm->EmitDwarfRegOp(Loc);
2456 Asm->EmitDwarfRegOp(Entry.Loc);
2459 // Emit remaining complex address elements.
2460 for (; i < N; ++i) {
2461 uint64_t Element = DV.getAddrElement(i);
2462 if (Element == DIBuilder::OpPlus) {
2463 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2464 Asm->EmitULEB128(DV.getAddrElement(++i));
2465 } else if (Element == DIBuilder::OpDeref) {
2466 if (!Entry.Loc.isReg())
2467 Asm->EmitInt8(dwarf::DW_OP_deref);
2469 llvm_unreachable("unknown Opcode found in complex address");
2473 // else ... ignore constant fp. There is not any good way to
2474 // to represent them here in dwarf.
2475 Asm->OutStreamer.EmitLabel(end);
2480 // Emit visible names into a debug aranges section.
2481 void DwarfDebug::emitDebugARanges() {
2482 // Start the dwarf aranges section.
2483 Asm->OutStreamer.SwitchSection(
2484 Asm->getObjFileLowering().getDwarfARangesSection());
2487 // Emit visible names into a debug ranges section.
2488 void DwarfDebug::emitDebugRanges() {
2489 // Start the dwarf ranges section.
2490 Asm->OutStreamer.SwitchSection(
2491 Asm->getObjFileLowering().getDwarfRangesSection());
2492 unsigned char Size = Asm->getDataLayout().getPointerSize();
2493 for (SmallVectorImpl<const MCSymbol *>::iterator
2494 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2497 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2499 Asm->OutStreamer.EmitIntValue(0, Size);
2503 // Emit visible names into a debug macinfo section.
2504 void DwarfDebug::emitDebugMacInfo() {
2505 if (const MCSection *LineInfo =
2506 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2507 // Start the dwarf macinfo section.
2508 Asm->OutStreamer.SwitchSection(LineInfo);
2512 // Emit inline info using following format.
2514 // 1. length of section
2515 // 2. Dwarf version number
2518 // Entries (one "entry" for each function that was inlined):
2520 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2521 // otherwise offset into __debug_str for regular function name.
2522 // 2. offset into __debug_str section for regular function name.
2523 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2524 // instances for the function.
2526 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2527 // inlined instance; the die_offset points to the inlined_subroutine die in the
2528 // __debug_info section, and the low_pc is the starting address for the
2529 // inlining instance.
2530 void DwarfDebug::emitDebugInlineInfo() {
2531 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2537 Asm->OutStreamer.SwitchSection(
2538 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2540 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2541 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2542 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2544 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2546 Asm->OutStreamer.AddComment("Dwarf Version");
2547 Asm->EmitInt16(dwarf::DWARF_VERSION);
2548 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2549 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2551 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2552 E = InlinedSPNodes.end(); I != E; ++I) {
2554 const MDNode *Node = *I;
2555 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2556 = InlineInfo.find(Node);
2557 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2558 DISubprogram SP(Node);
2559 StringRef LName = SP.getLinkageName();
2560 StringRef Name = SP.getName();
2562 Asm->OutStreamer.AddComment("MIPS linkage name");
2564 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2565 DwarfStrSectionSym);
2567 Asm->EmitSectionOffset(InfoHolder
2568 .getStringPoolEntry(getRealLinkageName(LName)),
2569 DwarfStrSectionSym);
2571 Asm->OutStreamer.AddComment("Function name");
2572 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2573 DwarfStrSectionSym);
2574 Asm->EmitULEB128(Labels.size(), "Inline count");
2576 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2577 LE = Labels.end(); LI != LE; ++LI) {
2578 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2579 Asm->EmitInt32(LI->second->getOffset());
2581 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2582 Asm->OutStreamer.EmitSymbolValue(LI->first,
2583 Asm->getDataLayout().getPointerSize());
2587 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2590 // DWARF5 Experimental Separate Dwarf emitters.
2592 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2593 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2594 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2595 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2596 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2597 DICompileUnit DIUnit(N);
2598 CompilationDir = DIUnit.getDirectory();
2600 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2601 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2602 DIUnit.getLanguage(), Die, N, Asm,
2603 this, &SkeletonHolder);
2605 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2606 DIUnit.getSplitDebugFilename());
2608 // This should be a unique identifier when we want to build .dwp files.
2609 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2611 // Relocate to the beginning of the addr_base section, else 0 for the
2612 // beginning of the one for this compile unit.
2613 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2614 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2615 DwarfAddrSectionSym);
2617 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2618 dwarf::DW_FORM_sec_offset, 0);
2620 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2621 // into an entity. We're using 0, or a NULL label for this.
2622 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2624 // DW_AT_stmt_list is a offset of line number information for this
2625 // compile unit in debug_line section.
2626 // FIXME: Should handle multiple compile units.
2627 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2628 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2629 DwarfLineSectionSym);
2631 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2633 if (!CompilationDir.empty())
2634 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2636 SkeletonHolder.addUnit(NewCU);
2637 SkeletonCUs.push_back(NewCU);
2642 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2643 assert(useSplitDwarf() && "No split dwarf debug info?");
2644 emitAbbrevs(Section, &SkeletonAbbrevs);
2647 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2648 // compile units that would normally be in debug_info.
2649 void DwarfDebug::emitDebugInfoDWO() {
2650 assert(useSplitDwarf() && "No split dwarf debug info?");
2651 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2652 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2653 DwarfAbbrevDWOSectionSym);
2656 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2657 // abbreviations for the .debug_info.dwo section.
2658 void DwarfDebug::emitDebugAbbrevDWO() {
2659 assert(useSplitDwarf() && "No split dwarf?");
2660 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2664 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2665 // string section and is identical in format to traditional .debug_str
2667 void DwarfDebug::emitDebugStrDWO() {
2668 assert(useSplitDwarf() && "No split dwarf?");
2669 const MCSection *OffSec = Asm->getObjFileLowering()
2670 .getDwarfStrOffDWOSection();
2671 const MCSymbol *StrSym = DwarfStrSectionSym;
2672 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),