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::ZeroOrMore, 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";
97 } // end anonymous namespace
99 //===----------------------------------------------------------------------===//
101 // Configuration values for initial hash set sizes (log2).
103 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
107 DIType DbgVariable::getType() const {
108 DIType Ty = Var.getType();
109 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
110 // addresses instead.
111 if (Var.isBlockByrefVariable()) {
112 /* Byref variables, in Blocks, are declared by the programmer as
113 "SomeType VarName;", but the compiler creates a
114 __Block_byref_x_VarName struct, and gives the variable VarName
115 either the struct, or a pointer to the struct, as its type. This
116 is necessary for various behind-the-scenes things the compiler
117 needs to do with by-reference variables in blocks.
119 However, as far as the original *programmer* is concerned, the
120 variable should still have type 'SomeType', as originally declared.
122 The following function dives into the __Block_byref_x_VarName
123 struct to find the original type of the variable. This will be
124 passed back to the code generating the type for the Debug
125 Information Entry for the variable 'VarName'. 'VarName' will then
126 have the original type 'SomeType' in its debug information.
128 The original type 'SomeType' will be the type of the field named
129 'VarName' inside the __Block_byref_x_VarName struct.
131 NOTE: In order for this to not completely fail on the debugger
132 side, the Debug Information Entry for the variable VarName needs to
133 have a DW_AT_location that tells the debugger how to unwind through
134 the pointers and __Block_byref_x_VarName struct to find the actual
135 value of the variable. The function addBlockByrefType does this. */
137 unsigned tag = Ty.getTag();
139 if (tag == dwarf::DW_TAG_pointer_type) {
140 DIDerivedType DTy = DIDerivedType(Ty);
141 subType = DTy.getTypeDerivedFrom();
144 DICompositeType blockStruct = DICompositeType(subType);
145 DIArray Elements = blockStruct.getTypeArray();
147 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
148 DIDescriptor Element = Elements.getElement(i);
149 DIDerivedType DT = DIDerivedType(Element);
150 if (getName() == DT.getName())
151 return (DT.getTypeDerivedFrom());
157 } // end llvm namespace
159 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
160 : Asm(A), MMI(Asm->MMI), FirstCU(0),
161 AbbreviationsSet(InitAbbreviationsSetSize),
162 SourceIdMap(DIEValueAllocator),
163 PrevLabel(NULL), GlobalCUIndexCount(0),
164 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
166 SkeletonAbbrevSet(InitAbbreviationsSetSize),
167 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
170 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
171 DwarfStrSectionSym = TextSectionSym = 0;
172 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
173 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
174 FunctionBeginSym = FunctionEndSym = 0;
176 // Turn on accelerator tables and older gdb compatibility
178 bool IsDarwin = Triple(M->getTargetTriple()).isOSDarwin();
179 if (DarwinGDBCompat == Default) {
181 IsDarwinGDBCompat = true;
183 IsDarwinGDBCompat = false;
185 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
187 if (DwarfAccelTables == Default) {
189 HasDwarfAccelTables = true;
191 HasDwarfAccelTables = false;
193 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
195 if (SplitDwarf == Default)
196 HasSplitDwarf = false;
198 HasSplitDwarf = SplitDwarf == Enable ? true : false;
201 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
205 DwarfDebug::~DwarfDebug() {
208 // Switch to the specified MCSection and emit an assembler
209 // temporary label to it if SymbolStem is specified.
210 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
211 const char *SymbolStem = 0) {
212 Asm->OutStreamer.SwitchSection(Section);
213 if (!SymbolStem) return 0;
215 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
216 Asm->OutStreamer.EmitLabel(TmpSym);
220 MCSymbol *DwarfUnits::getStringPoolSym() {
221 return Asm->GetTempSymbol(StringPref);
224 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
225 std::pair<MCSymbol*, unsigned> &Entry =
226 StringPool.GetOrCreateValue(Str).getValue();
227 if (Entry.first) return Entry.first;
229 Entry.second = NextStringPoolNumber++;
230 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
233 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
234 std::pair<MCSymbol*, unsigned> &Entry =
235 StringPool.GetOrCreateValue(Str).getValue();
236 if (Entry.first) return Entry.second;
238 Entry.second = NextStringPoolNumber++;
239 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
243 unsigned DwarfUnits::getAddrPoolIndex(MCSymbol *Sym) {
244 std::pair<MCSymbol*, unsigned> &Entry = AddressPool[Sym];
245 if (Entry.first) return Entry.second;
247 Entry.second = NextAddrPoolNumber++;
252 // Define a unique number for the abbreviation.
254 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
255 // Profile the node so that we can make it unique.
259 // Check the set for priors.
260 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
262 // If it's newly added.
263 if (InSet == &Abbrev) {
264 // Add to abbreviation list.
265 Abbreviations->push_back(&Abbrev);
267 // Assign the vector position + 1 as its number.
268 Abbrev.setNumber(Abbreviations->size());
270 // Assign existing abbreviation number.
271 Abbrev.setNumber(InSet->getNumber());
275 // If special LLVM prefix that is used to inform the asm
276 // printer to not emit usual symbol prefix before the symbol name is used then
277 // return linkage name after skipping this special LLVM prefix.
278 static StringRef getRealLinkageName(StringRef LinkageName) {
280 if (LinkageName.startswith(StringRef(&One, 1)))
281 return LinkageName.substr(1);
285 static bool isObjCClass(StringRef Name) {
286 return Name.startswith("+") || Name.startswith("-");
289 static bool hasObjCCategory(StringRef Name) {
290 if (!isObjCClass(Name)) return false;
292 size_t pos = Name.find(')');
293 if (pos != std::string::npos) {
294 if (Name[pos+1] != ' ') return false;
300 static void getObjCClassCategory(StringRef In, StringRef &Class,
301 StringRef &Category) {
302 if (!hasObjCCategory(In)) {
303 Class = In.slice(In.find('[') + 1, In.find(' '));
308 Class = In.slice(In.find('[') + 1, In.find('('));
309 Category = In.slice(In.find('[') + 1, In.find(' '));
313 static StringRef getObjCMethodName(StringRef In) {
314 return In.slice(In.find(' ') + 1, In.find(']'));
317 // Add the various names to the Dwarf accelerator table names.
318 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
320 if (!SP.isDefinition()) return;
322 TheCU->addAccelName(SP.getName(), Die);
324 // If the linkage name is different than the name, go ahead and output
325 // that as well into the name table.
326 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
327 TheCU->addAccelName(SP.getLinkageName(), Die);
329 // If this is an Objective-C selector name add it to the ObjC accelerator
331 if (isObjCClass(SP.getName())) {
332 StringRef Class, Category;
333 getObjCClassCategory(SP.getName(), Class, Category);
334 TheCU->addAccelObjC(Class, Die);
336 TheCU->addAccelObjC(Category, Die);
337 // Also add the base method name to the name table.
338 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
342 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
343 // and DW_AT_high_pc attributes. If there are global variables in this
344 // scope then create and insert DIEs for these variables.
345 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
346 const MDNode *SPNode) {
347 DIE *SPDie = SPCU->getDIE(SPNode);
349 assert(SPDie && "Unable to find subprogram DIE!");
350 DISubprogram SP(SPNode);
352 // If we're updating an abstract DIE, then we will be adding the children and
353 // object pointer later on. But what we don't want to do is process the
354 // concrete DIE twice.
355 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
356 // Pick up abstract subprogram DIE.
357 SPDie = new DIE(dwarf::DW_TAG_subprogram);
358 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
359 dwarf::DW_FORM_ref4, AbsSPDIE);
362 DISubprogram SPDecl = SP.getFunctionDeclaration();
363 if (!SPDecl.isSubprogram()) {
364 // There is not any need to generate specification DIE for a function
365 // defined at compile unit level. If a function is defined inside another
366 // function then gdb prefers the definition at top level and but does not
367 // expect specification DIE in parent function. So avoid creating
368 // specification DIE for a function defined inside a function.
369 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
370 !SP.getContext().isFile() &&
371 !isSubprogramContext(SP.getContext())) {
372 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
375 DICompositeType SPTy = SP.getType();
376 DIArray Args = SPTy.getTypeArray();
377 unsigned SPTag = SPTy.getTag();
378 if (SPTag == dwarf::DW_TAG_subroutine_type)
379 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
380 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
381 DIType ATy = DIType(Args.getElement(i));
382 SPCU->addType(Arg, ATy);
383 if (ATy.isArtificial())
384 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
385 if (ATy.isObjectPointer())
386 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
387 dwarf::DW_FORM_ref4, Arg);
388 SPDie->addChild(Arg);
390 DIE *SPDeclDie = SPDie;
391 SPDie = new DIE(dwarf::DW_TAG_subprogram);
392 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
393 dwarf::DW_FORM_ref4, SPDeclDie);
399 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
400 Asm->GetTempSymbol("func_begin",
401 Asm->getFunctionNumber()));
402 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
403 Asm->GetTempSymbol("func_end",
404 Asm->getFunctionNumber()));
405 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
406 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
407 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
409 // Add name to the name table, we do this here because we're guaranteed
410 // to have concrete versions of our DW_TAG_subprogram nodes.
411 addSubprogramNames(SPCU, SP, SPDie);
416 // Construct new DW_TAG_lexical_block for this scope and attach
417 // DW_AT_low_pc/DW_AT_high_pc labels.
418 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
419 LexicalScope *Scope) {
420 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
421 if (Scope->isAbstractScope())
424 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
428 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
429 if (Ranges.size() > 1) {
430 // .debug_range section has not been laid out yet. Emit offset in
431 // .debug_range as a uint, size 4, for now. emitDIE will handle
432 // DW_AT_ranges appropriately.
433 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
434 DebugRangeSymbols.size()
435 * Asm->getDataLayout().getPointerSize());
436 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
437 RE = Ranges.end(); RI != RE; ++RI) {
438 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
439 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
441 DebugRangeSymbols.push_back(NULL);
442 DebugRangeSymbols.push_back(NULL);
446 MCSymbol *Start = getLabelBeforeInsn(RI->first);
447 MCSymbol *End = getLabelAfterInsn(RI->second);
449 if (End == 0) return 0;
451 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
452 assert(End->isDefined() && "Invalid end label for an inlined scope!");
454 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
455 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
460 // This scope represents inlined body of a function. Construct DIE to
461 // represent this concrete inlined copy of the function.
462 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
463 LexicalScope *Scope) {
464 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
465 assert(Ranges.empty() == false &&
466 "LexicalScope does not have instruction markers!");
468 if (!Scope->getScopeNode())
470 DIScope DS(Scope->getScopeNode());
471 DISubprogram InlinedSP = getDISubprogram(DS);
472 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
474 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
478 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
479 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
480 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
482 if (StartLabel == 0 || EndLabel == 0) {
483 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
485 assert(StartLabel->isDefined() &&
486 "Invalid starting label for an inlined scope!");
487 assert(EndLabel->isDefined() &&
488 "Invalid end label for an inlined scope!");
490 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
491 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
492 dwarf::DW_FORM_ref4, OriginDIE);
494 if (Ranges.size() > 1) {
495 // .debug_range section has not been laid out yet. Emit offset in
496 // .debug_range as a uint, size 4, for now. emitDIE will handle
497 // DW_AT_ranges appropriately.
498 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
499 DebugRangeSymbols.size()
500 * Asm->getDataLayout().getPointerSize());
501 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
502 RE = Ranges.end(); RI != RE; ++RI) {
503 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
504 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
506 DebugRangeSymbols.push_back(NULL);
507 DebugRangeSymbols.push_back(NULL);
509 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
510 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
513 InlinedSubprogramDIEs.insert(OriginDIE);
515 // Track the start label for this inlined function.
516 //.debug_inlined section specification does not clearly state how
517 // to emit inlined scope that is split into multiple instruction ranges.
518 // For now, use first instruction range and emit low_pc/high_pc pair and
519 // corresponding .debug_inlined section entry for this pair.
520 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
521 I = InlineInfo.find(InlinedSP);
523 if (I == InlineInfo.end()) {
524 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
525 InlinedSPNodes.push_back(InlinedSP);
527 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
529 DILocation DL(Scope->getInlinedAt());
530 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
531 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
532 TheCU->getUniqueID()));
533 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
535 // Add name to the name table, we do this here because we're guaranteed
536 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
537 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
542 // Construct a DIE for this scope.
543 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
544 if (!Scope || !Scope->getScopeNode())
547 DIScope DS(Scope->getScopeNode());
548 // Early return to avoid creating dangling variable|scope DIEs.
549 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
553 SmallVector<DIE *, 8> Children;
554 DIE *ObjectPointer = NULL;
556 // Collect arguments for current function.
557 if (LScopes.isCurrentFunctionScope(Scope))
558 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
559 if (DbgVariable *ArgDV = CurrentFnArguments[i])
561 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
562 Children.push_back(Arg);
563 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
566 // Collect lexical scope children first.
567 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
568 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
570 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
571 Children.push_back(Variable);
572 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
574 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
575 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
576 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
577 Children.push_back(Nested);
578 DIE *ScopeDIE = NULL;
579 if (Scope->getInlinedAt())
580 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
581 else if (DS.isSubprogram()) {
582 ProcessedSPNodes.insert(DS);
583 if (Scope->isAbstractScope()) {
584 ScopeDIE = TheCU->getDIE(DS);
585 // Note down abstract DIE.
587 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
590 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
593 // There is no need to emit empty lexical block DIE.
594 if (Children.empty())
596 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
599 if (!ScopeDIE) return NULL;
602 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
603 E = Children.end(); I != E; ++I)
604 ScopeDIE->addChild(*I);
606 if (DS.isSubprogram() && ObjectPointer != NULL)
607 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
608 dwarf::DW_FORM_ref4, ObjectPointer);
610 if (DS.isSubprogram())
611 TheCU->addPubTypes(DISubprogram(DS));
616 // Look up the source id with the given directory and source file names.
617 // If none currently exists, create a new id and insert it in the
618 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
620 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
621 StringRef DirName, unsigned CUID) {
622 // If we use .loc in assembly, we can't separate .file entries according to
623 // compile units. Thus all files will belong to the default compile unit.
624 if (Asm->TM.hasMCUseLoc() &&
625 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
628 // If FE did not provide a file name, then assume stdin.
629 if (FileName.empty())
630 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
632 // TODO: this might not belong here. See if we can factor this better.
633 if (DirName == CompilationDir)
636 // FileIDCUMap stores the current ID for the given compile unit.
637 unsigned SrcId = FileIDCUMap[CUID] + 1;
639 // We look up the CUID/file/dir by concatenating them with a zero byte.
640 SmallString<128> NamePair;
644 NamePair += '\0'; // Zero bytes are not allowed in paths.
645 NamePair += FileName;
647 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
648 if (Ent.getValue() != SrcId)
649 return Ent.getValue();
651 FileIDCUMap[CUID] = SrcId;
652 // Print out a .file directive to specify files for .loc directives.
653 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
658 // Create new CompileUnit for the given metadata node with tag
659 // DW_TAG_compile_unit.
660 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
661 DICompileUnit DIUnit(N);
662 StringRef FN = DIUnit.getFilename();
663 CompilationDir = DIUnit.getDirectory();
665 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
666 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
667 DIUnit.getLanguage(), Die, Asm,
670 FileIDCUMap[NewCU->getUniqueID()] = 0;
671 // Call this to emit a .file directive if it wasn't emitted for the source
672 // file this CU comes from yet.
673 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
675 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
676 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
677 DIUnit.getLanguage());
678 NewCU->addString(Die, dwarf::DW_AT_name, FN);
679 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
680 // into an entity. We're using 0 (or a NULL label) for this.
681 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
683 // Define start line table label for each Compile Unit.
684 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
685 NewCU->getUniqueID());
686 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
687 NewCU->getUniqueID());
689 // DW_AT_stmt_list is a offset of line number information for this
690 // compile unit in debug_line section.
691 // The line table entries are not always emitted in assembly, so it
692 // is not okay to use line_table_start here.
693 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
694 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
695 NewCU->getUniqueID() == 0 ?
696 Asm->GetTempSymbol("section_line") : LineTableStartSym);
697 else if (NewCU->getUniqueID() == 0)
698 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
700 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
701 LineTableStartSym, DwarfLineSectionSym);
703 if (!CompilationDir.empty())
704 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
705 if (DIUnit.isOptimized())
706 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
708 StringRef Flags = DIUnit.getFlags();
710 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
712 if (unsigned RVer = DIUnit.getRunTimeVersion())
713 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
714 dwarf::DW_FORM_data1, RVer);
719 if (useSplitDwarf()) {
720 // This should be a unique identifier when we want to build .dwp files.
721 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
722 // Now construct the skeleton CU associated.
723 constructSkeletonCU(N);
726 InfoHolder.addUnit(NewCU);
728 CUMap.insert(std::make_pair(N, NewCU));
732 // Construct subprogram DIE.
733 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
735 CompileUnit *&CURef = SPMap[N];
741 if (!SP.isDefinition())
742 // This is a method declaration which will be handled while constructing
746 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
749 TheCU->insertDIE(N, SubprogramDie);
751 // Add to context owner.
752 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
754 // Expose as global, if requested.
755 if (GenerateDwarfPubNamesSection)
756 TheCU->addGlobalName(SP.getName(), SubprogramDie);
759 // Emit all Dwarf sections that should come prior to the content. Create
760 // global DIEs and emit initial debug info sections. This is invoked by
761 // the target AsmPrinter.
762 void DwarfDebug::beginModule() {
763 if (DisableDebugInfoPrinting)
766 const Module *M = MMI->getModule();
768 // If module has named metadata anchors then use them, otherwise scan the
769 // module using debug info finder to collect debug info.
770 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
774 // Emit initial sections so we can reference labels later.
777 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
778 DICompileUnit CUNode(CU_Nodes->getOperand(i));
779 CompileUnit *CU = constructCompileUnit(CUNode);
780 DIArray GVs = CUNode.getGlobalVariables();
781 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
782 CU->createGlobalVariableDIE(GVs.getElement(i));
783 DIArray SPs = CUNode.getSubprograms();
784 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
785 constructSubprogramDIE(CU, SPs.getElement(i));
786 DIArray EnumTypes = CUNode.getEnumTypes();
787 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
788 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
789 DIArray RetainedTypes = CUNode.getRetainedTypes();
790 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
791 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
794 // Tell MMI that we have debug info.
795 MMI->setDebugInfoAvailability(true);
797 // Prime section data.
798 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
801 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
802 void DwarfDebug::computeInlinedDIEs() {
803 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
804 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
805 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
807 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
809 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
810 AE = AbstractSPDies.end(); AI != AE; ++AI) {
811 DIE *ISP = AI->second;
812 if (InlinedSubprogramDIEs.count(ISP))
814 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
818 // Collect info for variables that were optimized out.
819 void DwarfDebug::collectDeadVariables() {
820 const Module *M = MMI->getModule();
821 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
823 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
824 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
825 DICompileUnit TheCU(CU_Nodes->getOperand(i));
826 DIArray Subprograms = TheCU.getSubprograms();
827 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
828 DISubprogram SP(Subprograms.getElement(i));
829 if (ProcessedSPNodes.count(SP) != 0) continue;
830 if (!SP.Verify()) continue;
831 if (!SP.isDefinition()) continue;
832 DIArray Variables = SP.getVariables();
833 if (Variables.getNumElements() == 0) continue;
835 LexicalScope *Scope =
836 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
837 DeadFnScopeMap[SP] = Scope;
839 // Construct subprogram DIE and add variables DIEs.
840 CompileUnit *SPCU = CUMap.lookup(TheCU);
841 assert(SPCU && "Unable to find Compile Unit!");
842 constructSubprogramDIE(SPCU, SP);
843 DIE *ScopeDIE = SPCU->getDIE(SP);
844 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
845 DIVariable DV(Variables.getElement(vi));
846 if (!DV.Verify()) continue;
847 DbgVariable *NewVar = new DbgVariable(DV, NULL);
848 if (DIE *VariableDIE =
849 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
850 ScopeDIE->addChild(VariableDIE);
855 DeleteContainerSeconds(DeadFnScopeMap);
858 void DwarfDebug::finalizeModuleInfo() {
859 // Collect info for variables that were optimized out.
860 collectDeadVariables();
862 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
863 computeInlinedDIEs();
865 // Emit DW_AT_containing_type attribute to connect types with their
866 // vtable holding type.
867 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
868 CUE = CUMap.end(); CUI != CUE; ++CUI) {
869 CompileUnit *TheCU = CUI->second;
870 TheCU->constructContainingTypeDIEs();
873 // Compute DIE offsets and sizes.
874 InfoHolder.computeSizeAndOffsets();
876 SkeletonHolder.computeSizeAndOffsets();
879 void DwarfDebug::endSections() {
880 // Standard sections final addresses.
881 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
882 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
883 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
884 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
886 // End text sections.
887 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
888 Asm->OutStreamer.SwitchSection(SectionMap[I]);
889 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
893 // Emit all Dwarf sections that should come after the content.
894 void DwarfDebug::endModule() {
896 if (!FirstCU) return;
898 // End any existing sections.
899 // TODO: Does this need to happen?
902 // Finalize the debug info for the module.
903 finalizeModuleInfo();
905 if (!useSplitDwarf()) {
906 // Emit all the DIEs into a debug info section.
909 // Corresponding abbreviations into a abbrev section.
912 // Emit info into a debug loc section.
915 // Emit info into a debug aranges section.
918 // Emit info into a debug ranges section.
921 // Emit info into a debug macinfo section.
925 // TODO: When we don't need the option anymore we
926 // can remove all of the code that this section
928 if (useDarwinGDBCompat())
929 emitDebugInlineInfo();
931 // TODO: Fill this in for separated debug sections and separate
932 // out information into new sections.
934 // Emit the debug info section and compile units.
938 // Corresponding abbreviations into a abbrev section.
940 emitDebugAbbrevDWO();
942 // Emit info into a debug loc section.
945 // Emit info into a debug aranges section.
948 // Emit info into a debug ranges section.
951 // Emit info into a debug macinfo section.
954 // Emit DWO addresses.
955 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
958 // TODO: When we don't need the option anymore we
959 // can remove all of the code that this section
961 if (useDarwinGDBCompat())
962 emitDebugInlineInfo();
965 // Emit info into the dwarf accelerator table sections.
966 if (useDwarfAccelTables()) {
969 emitAccelNamespaces();
973 // Emit info into a debug pubnames section, if requested.
974 if (GenerateDwarfPubNamesSection)
977 // Emit info into a debug pubtypes section.
978 // TODO: When we don't need the option anymore we can
979 // remove all of the code that adds to the table.
980 if (useDarwinGDBCompat())
983 // Finally emit string information into a string table.
990 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
991 E = CUMap.end(); I != E; ++I)
994 for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
995 E = SkeletonCUs.end(); I != E; ++I)
998 // Reset these for the next Module if we have one.
1002 // Find abstract variable, if any, associated with Var.
1003 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1004 DebugLoc ScopeLoc) {
1005 LLVMContext &Ctx = DV->getContext();
1006 // More then one inlined variable corresponds to one abstract variable.
1007 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1008 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1010 return AbsDbgVariable;
1012 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1016 AbsDbgVariable = new DbgVariable(Var, NULL);
1017 addScopeVariable(Scope, AbsDbgVariable);
1018 AbstractVariables[Var] = AbsDbgVariable;
1019 return AbsDbgVariable;
1022 // If Var is a current function argument then add it to CurrentFnArguments list.
1023 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1024 DbgVariable *Var, LexicalScope *Scope) {
1025 if (!LScopes.isCurrentFunctionScope(Scope))
1027 DIVariable DV = Var->getVariable();
1028 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1030 unsigned ArgNo = DV.getArgNumber();
1034 size_t Size = CurrentFnArguments.size();
1036 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1037 // llvm::Function argument size is not good indicator of how many
1038 // arguments does the function have at source level.
1040 CurrentFnArguments.resize(ArgNo * 2);
1041 CurrentFnArguments[ArgNo - 1] = Var;
1045 // Collect variable information from side table maintained by MMI.
1047 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1048 SmallPtrSet<const MDNode *, 16> &Processed) {
1049 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1050 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1051 VE = VMap.end(); VI != VE; ++VI) {
1052 const MDNode *Var = VI->first;
1054 Processed.insert(Var);
1056 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1058 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1060 // If variable scope is not found then skip this variable.
1064 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1065 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1066 RegVar->setFrameIndex(VP.first);
1067 if (!addCurrentFnArgument(MF, RegVar, Scope))
1068 addScopeVariable(Scope, RegVar);
1070 AbsDbgVariable->setFrameIndex(VP.first);
1074 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1076 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1077 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1078 return MI->getNumOperands() == 3 &&
1079 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1080 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1083 // Get .debug_loc entry for the instruction range starting at MI.
1084 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1085 const MCSymbol *FLabel,
1086 const MCSymbol *SLabel,
1087 const MachineInstr *MI) {
1088 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1090 if (MI->getNumOperands() != 3) {
1091 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1092 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1094 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1095 MachineLocation MLoc;
1096 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1097 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1099 if (MI->getOperand(0).isImm())
1100 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1101 if (MI->getOperand(0).isFPImm())
1102 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1103 if (MI->getOperand(0).isCImm())
1104 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1106 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1109 // Find variables for each lexical scope.
1111 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1112 SmallPtrSet<const MDNode *, 16> &Processed) {
1114 // collection info from MMI table.
1115 collectVariableInfoFromMMITable(MF, Processed);
1117 for (SmallVectorImpl<const MDNode*>::const_iterator
1118 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1120 const MDNode *Var = *UVI;
1121 if (Processed.count(Var))
1124 // History contains relevant DBG_VALUE instructions for Var and instructions
1126 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1127 if (History.empty())
1129 const MachineInstr *MInsn = History.front();
1132 LexicalScope *Scope = NULL;
1133 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1134 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1135 Scope = LScopes.getCurrentFunctionScope();
1136 else if (MDNode *IA = DV.getInlinedAt())
1137 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1139 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1140 // If variable scope is not found then skip this variable.
1144 Processed.insert(DV);
1145 assert(MInsn->isDebugValue() && "History must begin with debug value");
1146 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1147 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1148 if (!addCurrentFnArgument(MF, RegVar, Scope))
1149 addScopeVariable(Scope, RegVar);
1151 AbsVar->setMInsn(MInsn);
1153 // Simplify ranges that are fully coalesced.
1154 if (History.size() <= 1 || (History.size() == 2 &&
1155 MInsn->isIdenticalTo(History.back()))) {
1156 RegVar->setMInsn(MInsn);
1160 // Handle multiple DBG_VALUE instructions describing one variable.
1161 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1163 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1164 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1165 const MachineInstr *Begin = *HI;
1166 assert(Begin->isDebugValue() && "Invalid History entry");
1168 // Check if DBG_VALUE is truncating a range.
1169 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1170 && !Begin->getOperand(0).getReg())
1173 // Compute the range for a register location.
1174 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1175 const MCSymbol *SLabel = 0;
1178 // If Begin is the last instruction in History then its value is valid
1179 // until the end of the function.
1180 SLabel = FunctionEndSym;
1182 const MachineInstr *End = HI[1];
1183 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1184 << "\t" << *Begin << "\t" << *End << "\n");
1185 if (End->isDebugValue())
1186 SLabel = getLabelBeforeInsn(End);
1188 // End is a normal instruction clobbering the range.
1189 SLabel = getLabelAfterInsn(End);
1190 assert(SLabel && "Forgot label after clobber instruction");
1195 // The value is valid until the next DBG_VALUE or clobber.
1196 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1199 DotDebugLocEntries.push_back(DotDebugLocEntry());
1202 // Collect info for variables that were optimized out.
1203 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1204 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1205 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1206 DIVariable DV(Variables.getElement(i));
1207 if (!DV || !DV.Verify() || !Processed.insert(DV))
1209 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1210 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1214 // Return Label preceding the instruction.
1215 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1216 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1217 assert(Label && "Didn't insert label before instruction");
1221 // Return Label immediately following the instruction.
1222 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1223 return LabelsAfterInsn.lookup(MI);
1226 // Process beginning of an instruction.
1227 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1228 // Check if source location changes, but ignore DBG_VALUE locations.
1229 if (!MI->isDebugValue()) {
1230 DebugLoc DL = MI->getDebugLoc();
1231 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1234 if (DL == PrologEndLoc) {
1235 Flags |= DWARF2_FLAG_PROLOGUE_END;
1236 PrologEndLoc = DebugLoc();
1238 if (PrologEndLoc.isUnknown())
1239 Flags |= DWARF2_FLAG_IS_STMT;
1241 if (!DL.isUnknown()) {
1242 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1243 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1245 recordSourceLine(0, 0, 0, 0);
1249 // Insert labels where requested.
1250 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1251 LabelsBeforeInsn.find(MI);
1254 if (I == LabelsBeforeInsn.end())
1257 // Label already assigned.
1262 PrevLabel = MMI->getContext().CreateTempSymbol();
1263 Asm->OutStreamer.EmitLabel(PrevLabel);
1265 I->second = PrevLabel;
1268 // Process end of an instruction.
1269 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1270 // Don't create a new label after DBG_VALUE instructions.
1271 // They don't generate code.
1272 if (!MI->isDebugValue())
1275 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1276 LabelsAfterInsn.find(MI);
1279 if (I == LabelsAfterInsn.end())
1282 // Label already assigned.
1286 // We need a label after this instruction.
1288 PrevLabel = MMI->getContext().CreateTempSymbol();
1289 Asm->OutStreamer.EmitLabel(PrevLabel);
1291 I->second = PrevLabel;
1294 // Each LexicalScope has first instruction and last instruction to mark
1295 // beginning and end of a scope respectively. Create an inverse map that list
1296 // scopes starts (and ends) with an instruction. One instruction may start (or
1297 // end) multiple scopes. Ignore scopes that are not reachable.
1298 void DwarfDebug::identifyScopeMarkers() {
1299 SmallVector<LexicalScope *, 4> WorkList;
1300 WorkList.push_back(LScopes.getCurrentFunctionScope());
1301 while (!WorkList.empty()) {
1302 LexicalScope *S = WorkList.pop_back_val();
1304 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1305 if (!Children.empty())
1306 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1307 SE = Children.end(); SI != SE; ++SI)
1308 WorkList.push_back(*SI);
1310 if (S->isAbstractScope())
1313 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1316 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1317 RE = Ranges.end(); RI != RE; ++RI) {
1318 assert(RI->first && "InsnRange does not have first instruction!");
1319 assert(RI->second && "InsnRange does not have second instruction!");
1320 requestLabelBeforeInsn(RI->first);
1321 requestLabelAfterInsn(RI->second);
1326 // Get MDNode for DebugLoc's scope.
1327 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1328 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1329 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1330 return DL.getScope(Ctx);
1333 // Walk up the scope chain of given debug loc and find line number info
1334 // for the function.
1335 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1336 const MDNode *Scope = getScopeNode(DL, Ctx);
1337 DISubprogram SP = getDISubprogram(Scope);
1339 // Check for number of operands since the compatibility is
1341 if (SP->getNumOperands() > 19)
1342 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1344 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1350 // Gather pre-function debug information. Assumes being called immediately
1351 // after the function entry point has been emitted.
1352 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1353 if (!MMI->hasDebugInfo()) return;
1354 LScopes.initialize(*MF);
1355 if (LScopes.empty()) return;
1356 identifyScopeMarkers();
1358 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1360 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1361 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1362 assert(TheCU && "Unable to find compile unit!");
1363 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1365 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1366 Asm->getFunctionNumber());
1367 // Assumes in correct section after the entry point.
1368 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1370 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1372 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1373 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1374 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1376 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1378 bool AtBlockEntry = true;
1379 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1381 const MachineInstr *MI = II;
1383 if (MI->isDebugValue()) {
1384 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1386 // Keep track of user variables.
1388 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1390 // Variable is in a register, we need to check for clobbers.
1391 if (isDbgValueInDefinedReg(MI))
1392 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1394 // Check the history of this variable.
1395 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1396 if (History.empty()) {
1397 UserVariables.push_back(Var);
1398 // The first mention of a function argument gets the FunctionBeginSym
1399 // label, so arguments are visible when breaking at function entry.
1401 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1402 DISubprogram(getDISubprogram(DV.getContext()))
1403 .describes(MF->getFunction()))
1404 LabelsBeforeInsn[MI] = FunctionBeginSym;
1406 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1407 const MachineInstr *Prev = History.back();
1408 if (Prev->isDebugValue()) {
1409 // Coalesce identical entries at the end of History.
1410 if (History.size() >= 2 &&
1411 Prev->isIdenticalTo(History[History.size() - 2])) {
1412 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1414 << "\t" << *History[History.size() - 2] << "\n");
1418 // Terminate old register assignments that don't reach MI;
1419 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1420 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1421 isDbgValueInDefinedReg(Prev)) {
1422 // Previous register assignment needs to terminate at the end of
1424 MachineBasicBlock::const_iterator LastMI =
1425 PrevMBB->getLastNonDebugInstr();
1426 if (LastMI == PrevMBB->end()) {
1427 // Drop DBG_VALUE for empty range.
1428 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1429 << "\t" << *Prev << "\n");
1433 // Terminate after LastMI.
1434 History.push_back(LastMI);
1439 History.push_back(MI);
1441 // Not a DBG_VALUE instruction.
1443 AtBlockEntry = false;
1445 // First known non-DBG_VALUE and non-frame setup location marks
1446 // the beginning of the function body.
1447 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1448 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1449 PrologEndLoc = MI->getDebugLoc();
1451 // Check if the instruction clobbers any registers with debug vars.
1452 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1453 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1454 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1456 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1457 AI.isValid(); ++AI) {
1459 const MDNode *Var = LiveUserVar[Reg];
1462 // Reg is now clobbered.
1463 LiveUserVar[Reg] = 0;
1465 // Was MD last defined by a DBG_VALUE referring to Reg?
1466 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1467 if (HistI == DbgValues.end())
1469 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1470 if (History.empty())
1472 const MachineInstr *Prev = History.back();
1473 // Sanity-check: Register assignments are terminated at the end of
1475 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1477 // Is the variable still in Reg?
1478 if (!isDbgValueInDefinedReg(Prev) ||
1479 Prev->getOperand(0).getReg() != Reg)
1481 // Var is clobbered. Make sure the next instruction gets a label.
1482 History.push_back(MI);
1489 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1491 SmallVectorImpl<const MachineInstr*> &History = I->second;
1492 if (History.empty())
1495 // Make sure the final register assignments are terminated.
1496 const MachineInstr *Prev = History.back();
1497 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1498 const MachineBasicBlock *PrevMBB = Prev->getParent();
1499 MachineBasicBlock::const_iterator LastMI =
1500 PrevMBB->getLastNonDebugInstr();
1501 if (LastMI == PrevMBB->end())
1502 // Drop DBG_VALUE for empty range.
1505 // Terminate after LastMI.
1506 History.push_back(LastMI);
1509 // Request labels for the full history.
1510 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1511 const MachineInstr *MI = History[i];
1512 if (MI->isDebugValue())
1513 requestLabelBeforeInsn(MI);
1515 requestLabelAfterInsn(MI);
1519 PrevInstLoc = DebugLoc();
1520 PrevLabel = FunctionBeginSym;
1522 // Record beginning of function.
1523 if (!PrologEndLoc.isUnknown()) {
1524 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1525 MF->getFunction()->getContext());
1526 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1527 FnStartDL.getScope(MF->getFunction()->getContext()),
1528 // We'd like to list the prologue as "not statements" but GDB behaves
1529 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1530 DWARF2_FLAG_IS_STMT);
1534 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1535 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1536 ScopeVariables[LS].push_back(Var);
1537 // Vars.push_back(Var);
1540 // Gather and emit post-function debug information.
1541 void DwarfDebug::endFunction(const MachineFunction *MF) {
1542 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1544 // Define end label for subprogram.
1545 FunctionEndSym = Asm->GetTempSymbol("func_end",
1546 Asm->getFunctionNumber());
1547 // Assumes in correct section after the entry point.
1548 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1549 // Set DwarfCompileUnitID in MCContext to default value.
1550 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1552 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1553 collectVariableInfo(MF, ProcessedVars);
1555 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1556 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1557 assert(TheCU && "Unable to find compile unit!");
1559 // Construct abstract scopes.
1560 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1561 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1562 LexicalScope *AScope = AList[i];
1563 DISubprogram SP(AScope->getScopeNode());
1565 // Collect info for variables that were optimized out.
1566 DIArray Variables = SP.getVariables();
1567 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1568 DIVariable DV(Variables.getElement(i));
1569 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1571 // Check that DbgVariable for DV wasn't created earlier, when
1572 // findAbstractVariable() was called for inlined instance of DV.
1573 LLVMContext &Ctx = DV->getContext();
1574 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1575 if (AbstractVariables.lookup(CleanDV))
1577 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1578 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1581 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1582 constructScopeDIE(TheCU, AScope);
1585 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1587 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1588 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1590 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1591 MMI->getFrameMoves()));
1594 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1595 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1596 DeleteContainerPointers(I->second);
1597 ScopeVariables.clear();
1598 DeleteContainerPointers(CurrentFnArguments);
1599 UserVariables.clear();
1601 AbstractVariables.clear();
1602 LabelsBeforeInsn.clear();
1603 LabelsAfterInsn.clear();
1607 // Register a source line with debug info. Returns the unique label that was
1608 // emitted and which provides correspondence to the source line list.
1609 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1615 DIDescriptor Scope(S);
1617 if (Scope.isCompileUnit()) {
1618 DICompileUnit CU(S);
1619 Fn = CU.getFilename();
1620 Dir = CU.getDirectory();
1621 } else if (Scope.isFile()) {
1623 Fn = F.getFilename();
1624 Dir = F.getDirectory();
1625 } else if (Scope.isSubprogram()) {
1627 Fn = SP.getFilename();
1628 Dir = SP.getDirectory();
1629 } else if (Scope.isLexicalBlockFile()) {
1630 DILexicalBlockFile DBF(S);
1631 Fn = DBF.getFilename();
1632 Dir = DBF.getDirectory();
1633 } else if (Scope.isLexicalBlock()) {
1634 DILexicalBlock DB(S);
1635 Fn = DB.getFilename();
1636 Dir = DB.getDirectory();
1638 llvm_unreachable("Unexpected scope info");
1640 Src = getOrCreateSourceID(Fn, Dir,
1641 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1643 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1646 //===----------------------------------------------------------------------===//
1648 //===----------------------------------------------------------------------===//
1650 // Compute the size and offset of a DIE.
1652 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1653 // Get the children.
1654 const std::vector<DIE *> &Children = Die->getChildren();
1656 // Record the abbreviation.
1657 assignAbbrevNumber(Die->getAbbrev());
1659 // Get the abbreviation for this DIE.
1660 unsigned AbbrevNumber = Die->getAbbrevNumber();
1661 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1664 Die->setOffset(Offset);
1666 // Start the size with the size of abbreviation code.
1667 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1669 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1670 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1672 // Size the DIE attribute values.
1673 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1674 // Size attribute value.
1675 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1677 // Size the DIE children if any.
1678 if (!Children.empty()) {
1679 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1680 "Children flag not set");
1682 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1683 Offset = computeSizeAndOffset(Children[j], Offset);
1685 // End of children marker.
1686 Offset += sizeof(int8_t);
1689 Die->setSize(Offset - Die->getOffset());
1693 // Compute the size and offset of all the DIEs.
1694 void DwarfUnits::computeSizeAndOffsets() {
1695 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1696 E = CUs.end(); I != E; ++I) {
1698 sizeof(int32_t) + // Length of Compilation Unit Info
1699 sizeof(int16_t) + // DWARF version number
1700 sizeof(int32_t) + // Offset Into Abbrev. Section
1701 sizeof(int8_t); // Pointer Size (in bytes)
1703 computeSizeAndOffset((*I)->getCUDie(), Offset);
1707 // Emit initial Dwarf sections with a label at the start of each one.
1708 void DwarfDebug::emitSectionLabels() {
1709 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1711 // Dwarf sections base addresses.
1712 DwarfInfoSectionSym =
1713 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1714 DwarfAbbrevSectionSym =
1715 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1716 if (useSplitDwarf())
1717 DwarfAbbrevDWOSectionSym =
1718 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1719 "section_abbrev_dwo");
1720 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1722 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1723 emitSectionSym(Asm, MacroInfo);
1725 DwarfLineSectionSym =
1726 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1727 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1728 if (GenerateDwarfPubNamesSection)
1729 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1730 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1731 DwarfStrSectionSym =
1732 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1733 if (useSplitDwarf())
1734 DwarfStrDWOSectionSym =
1735 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1736 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1739 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1740 "section_debug_loc");
1742 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1743 emitSectionSym(Asm, TLOF.getDataSection());
1746 // Recursively emits a debug information entry.
1747 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1748 // Get the abbreviation for this DIE.
1749 unsigned AbbrevNumber = Die->getAbbrevNumber();
1750 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1752 // Emit the code (index) for the abbreviation.
1753 if (Asm->isVerbose())
1754 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1755 Twine::utohexstr(Die->getOffset()) + ":0x" +
1756 Twine::utohexstr(Die->getSize()) + " " +
1757 dwarf::TagString(Abbrev->getTag()));
1758 Asm->EmitULEB128(AbbrevNumber);
1760 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1761 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1763 // Emit the DIE attribute values.
1764 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1765 unsigned Attr = AbbrevData[i].getAttribute();
1766 unsigned Form = AbbrevData[i].getForm();
1767 assert(Form && "Too many attributes for DIE (check abbreviation)");
1769 if (Asm->isVerbose())
1770 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1773 case dwarf::DW_AT_abstract_origin: {
1774 DIEEntry *E = cast<DIEEntry>(Values[i]);
1775 DIE *Origin = E->getEntry();
1776 unsigned Addr = Origin->getOffset();
1777 Asm->EmitInt32(Addr);
1780 case dwarf::DW_AT_ranges: {
1781 // DW_AT_range Value encodes offset in debug_range section.
1782 DIEInteger *V = cast<DIEInteger>(Values[i]);
1784 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1785 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1789 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1791 DwarfDebugRangeSectionSym,
1796 case dwarf::DW_AT_location: {
1797 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1798 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1799 Asm->EmitLabelReference(L->getValue(), 4);
1801 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1803 Values[i]->EmitValue(Asm, Form);
1807 case dwarf::DW_AT_accessibility: {
1808 if (Asm->isVerbose()) {
1809 DIEInteger *V = cast<DIEInteger>(Values[i]);
1810 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1812 Values[i]->EmitValue(Asm, Form);
1816 // Emit an attribute using the defined form.
1817 Values[i]->EmitValue(Asm, Form);
1822 // Emit the DIE children if any.
1823 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1824 const std::vector<DIE *> &Children = Die->getChildren();
1826 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1827 emitDIE(Children[j], Abbrevs);
1829 if (Asm->isVerbose())
1830 Asm->OutStreamer.AddComment("End Of Children Mark");
1835 // Emit the various dwarf units to the unit section USection with
1836 // the abbreviations going into ASection.
1837 void DwarfUnits::emitUnits(DwarfDebug *DD,
1838 const MCSection *USection,
1839 const MCSection *ASection,
1840 const MCSymbol *ASectionSym) {
1841 Asm->OutStreamer.SwitchSection(USection);
1842 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1843 E = CUs.end(); I != E; ++I) {
1844 CompileUnit *TheCU = *I;
1845 DIE *Die = TheCU->getCUDie();
1847 // Emit the compile units header.
1849 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1850 TheCU->getUniqueID()));
1852 // Emit size of content not including length itself
1853 unsigned ContentSize = Die->getSize() +
1854 sizeof(int16_t) + // DWARF version number
1855 sizeof(int32_t) + // Offset Into Abbrev. Section
1856 sizeof(int8_t); // Pointer Size (in bytes)
1858 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1859 Asm->EmitInt32(ContentSize);
1860 Asm->OutStreamer.AddComment("DWARF version number");
1861 Asm->EmitInt16(dwarf::DWARF_VERSION);
1862 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1863 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1865 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1866 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1868 DD->emitDIE(Die, Abbreviations);
1869 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1870 TheCU->getUniqueID()));
1874 // Emit the debug info section.
1875 void DwarfDebug::emitDebugInfo() {
1876 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1878 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
1879 Asm->getObjFileLowering().getDwarfAbbrevSection(),
1880 DwarfAbbrevSectionSym);
1883 // Emit the abbreviation section.
1884 void DwarfDebug::emitAbbreviations() {
1885 if (!useSplitDwarf())
1886 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
1889 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1892 void DwarfDebug::emitAbbrevs(const MCSection *Section,
1893 std::vector<DIEAbbrev *> *Abbrevs) {
1894 // Check to see if it is worth the effort.
1895 if (!Abbrevs->empty()) {
1896 // Start the debug abbrev section.
1897 Asm->OutStreamer.SwitchSection(Section);
1899 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
1900 Asm->OutStreamer.EmitLabel(Begin);
1902 // For each abbrevation.
1903 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
1904 // Get abbreviation data
1905 const DIEAbbrev *Abbrev = Abbrevs->at(i);
1907 // Emit the abbrevations code (base 1 index.)
1908 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1910 // Emit the abbreviations data.
1914 // Mark end of abbreviations.
1915 Asm->EmitULEB128(0, "EOM(3)");
1917 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
1918 Asm->OutStreamer.EmitLabel(End);
1922 // Emit the last address of the section and the end of the line matrix.
1923 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1924 // Define last address of section.
1925 Asm->OutStreamer.AddComment("Extended Op");
1928 Asm->OutStreamer.AddComment("Op size");
1929 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1930 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1931 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1933 Asm->OutStreamer.AddComment("Section end label");
1935 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1936 Asm->getDataLayout().getPointerSize());
1938 // Mark end of matrix.
1939 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1945 // Emit visible names into a hashed accelerator table section.
1946 void DwarfDebug::emitAccelNames() {
1947 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1948 dwarf::DW_FORM_data4));
1949 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1950 E = CUMap.end(); I != E; ++I) {
1951 CompileUnit *TheCU = I->second;
1952 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1953 for (StringMap<std::vector<DIE*> >::const_iterator
1954 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1955 const char *Name = GI->getKeyData();
1956 const std::vector<DIE *> &Entities = GI->second;
1957 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1958 DE = Entities.end(); DI != DE; ++DI)
1959 AT.AddName(Name, (*DI));
1963 AT.FinalizeTable(Asm, "Names");
1964 Asm->OutStreamer.SwitchSection(
1965 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1966 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1967 Asm->OutStreamer.EmitLabel(SectionBegin);
1969 // Emit the full data.
1970 AT.Emit(Asm, SectionBegin, &InfoHolder);
1973 // Emit objective C classes and categories into a hashed accelerator table
1975 void DwarfDebug::emitAccelObjC() {
1976 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1977 dwarf::DW_FORM_data4));
1978 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1979 E = CUMap.end(); I != E; ++I) {
1980 CompileUnit *TheCU = I->second;
1981 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1982 for (StringMap<std::vector<DIE*> >::const_iterator
1983 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1984 const char *Name = GI->getKeyData();
1985 const std::vector<DIE *> &Entities = GI->second;
1986 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1987 DE = Entities.end(); DI != DE; ++DI)
1988 AT.AddName(Name, (*DI));
1992 AT.FinalizeTable(Asm, "ObjC");
1993 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1994 .getDwarfAccelObjCSection());
1995 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1996 Asm->OutStreamer.EmitLabel(SectionBegin);
1998 // Emit the full data.
1999 AT.Emit(Asm, SectionBegin, &InfoHolder);
2002 // Emit namespace dies into a hashed accelerator table.
2003 void DwarfDebug::emitAccelNamespaces() {
2004 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2005 dwarf::DW_FORM_data4));
2006 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2007 E = CUMap.end(); I != E; ++I) {
2008 CompileUnit *TheCU = I->second;
2009 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2010 for (StringMap<std::vector<DIE*> >::const_iterator
2011 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2012 const char *Name = GI->getKeyData();
2013 const std::vector<DIE *> &Entities = GI->second;
2014 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2015 DE = Entities.end(); DI != DE; ++DI)
2016 AT.AddName(Name, (*DI));
2020 AT.FinalizeTable(Asm, "namespac");
2021 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2022 .getDwarfAccelNamespaceSection());
2023 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2024 Asm->OutStreamer.EmitLabel(SectionBegin);
2026 // Emit the full data.
2027 AT.Emit(Asm, SectionBegin, &InfoHolder);
2030 // Emit type dies into a hashed accelerator table.
2031 void DwarfDebug::emitAccelTypes() {
2032 std::vector<DwarfAccelTable::Atom> Atoms;
2033 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2034 dwarf::DW_FORM_data4));
2035 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2036 dwarf::DW_FORM_data2));
2037 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2038 dwarf::DW_FORM_data1));
2039 DwarfAccelTable AT(Atoms);
2040 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2041 E = CUMap.end(); I != E; ++I) {
2042 CompileUnit *TheCU = I->second;
2043 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2044 = TheCU->getAccelTypes();
2045 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2046 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2047 const char *Name = GI->getKeyData();
2048 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2049 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2050 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2051 AT.AddName(Name, (*DI).first, (*DI).second);
2055 AT.FinalizeTable(Asm, "types");
2056 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2057 .getDwarfAccelTypesSection());
2058 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2059 Asm->OutStreamer.EmitLabel(SectionBegin);
2061 // Emit the full data.
2062 AT.Emit(Asm, SectionBegin, &InfoHolder);
2065 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2067 void DwarfDebug::emitDebugPubnames() {
2068 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2070 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2071 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2072 CompileUnit *TheCU = I->second;
2073 unsigned ID = TheCU->getUniqueID();
2075 if (TheCU->getGlobalNames().empty())
2078 // Start the dwarf pubnames section.
2079 Asm->OutStreamer.SwitchSection(
2080 Asm->getObjFileLowering().getDwarfPubNamesSection());
2082 Asm->OutStreamer.AddComment("Length of Public Names Info");
2083 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2084 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2086 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2088 Asm->OutStreamer.AddComment("DWARF Version");
2089 Asm->EmitInt16(dwarf::DWARF_VERSION);
2091 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2092 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2093 DwarfInfoSectionSym);
2095 Asm->OutStreamer.AddComment("Compilation Unit Length");
2096 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2097 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2100 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2101 for (StringMap<DIE*>::const_iterator
2102 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2103 const char *Name = GI->getKeyData();
2104 const DIE *Entity = GI->second;
2106 Asm->OutStreamer.AddComment("DIE offset");
2107 Asm->EmitInt32(Entity->getOffset());
2109 if (Asm->isVerbose())
2110 Asm->OutStreamer.AddComment("External Name");
2111 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2114 Asm->OutStreamer.AddComment("End Mark");
2116 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2120 void DwarfDebug::emitDebugPubTypes() {
2121 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2122 E = CUMap.end(); I != E; ++I) {
2123 CompileUnit *TheCU = I->second;
2124 // Start the dwarf pubtypes section.
2125 Asm->OutStreamer.SwitchSection(
2126 Asm->getObjFileLowering().getDwarfPubTypesSection());
2127 Asm->OutStreamer.AddComment("Length of Public Types Info");
2128 Asm->EmitLabelDifference(
2129 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2130 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2132 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2133 TheCU->getUniqueID()));
2135 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2136 Asm->EmitInt16(dwarf::DWARF_VERSION);
2138 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2139 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2140 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2141 TheCU->getUniqueID()),
2142 DwarfInfoSectionSym);
2144 Asm->OutStreamer.AddComment("Compilation Unit Length");
2145 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2146 TheCU->getUniqueID()),
2147 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2148 TheCU->getUniqueID()),
2151 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2152 for (StringMap<DIE*>::const_iterator
2153 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2154 const char *Name = GI->getKeyData();
2155 DIE *Entity = GI->second;
2157 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2158 Asm->EmitInt32(Entity->getOffset());
2160 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2161 // Emit the name with a terminating null byte.
2162 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2165 Asm->OutStreamer.AddComment("End Mark");
2167 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2168 TheCU->getUniqueID()));
2172 // Emit strings into a string section.
2173 void DwarfUnits::emitStrings(const MCSection *StrSection,
2174 const MCSection *OffsetSection = NULL,
2175 const MCSymbol *StrSecSym = NULL) {
2177 if (StringPool.empty()) return;
2179 // Start the dwarf str section.
2180 Asm->OutStreamer.SwitchSection(StrSection);
2182 // Get all of the string pool entries and put them in an array by their ID so
2183 // we can sort them.
2184 SmallVector<std::pair<unsigned,
2185 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2187 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2188 I = StringPool.begin(), E = StringPool.end();
2190 Entries.push_back(std::make_pair(I->second.second, &*I));
2192 array_pod_sort(Entries.begin(), Entries.end());
2194 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2195 // Emit a label for reference from debug information entries.
2196 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2198 // Emit the string itself with a terminating null byte.
2199 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2200 Entries[i].second->getKeyLength()+1));
2203 // If we've got an offset section go ahead and emit that now as well.
2204 if (OffsetSection) {
2205 Asm->OutStreamer.SwitchSection(OffsetSection);
2206 unsigned offset = 0;
2207 unsigned size = 4; // FIXME: DWARF64 is 8.
2208 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2209 Asm->OutStreamer.EmitIntValue(offset, size);
2210 offset += Entries[i].second->getKeyLength() + 1;
2215 // Emit strings into a string section.
2216 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2218 if (AddressPool.empty()) return;
2220 // Start the dwarf addr section.
2221 Asm->OutStreamer.SwitchSection(AddrSection);
2223 // Get all of the string pool entries and put them in an array by their ID so
2224 // we can sort them.
2225 SmallVector<std::pair<unsigned,
2226 std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2228 for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2229 I = AddressPool.begin(), E = AddressPool.end();
2231 Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2233 array_pod_sort(Entries.begin(), Entries.end());
2235 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2236 // Emit a label for reference from debug information entries.
2237 MCSymbol *Sym = Entries[i].second->first;
2239 Asm->EmitLabelReference(Entries[i].second->first,
2240 Asm->getDataLayout().getPointerSize());
2242 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2247 // Emit visible names into a debug str section.
2248 void DwarfDebug::emitDebugStr() {
2249 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2250 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2253 // Emit visible names into a debug loc section.
2254 void DwarfDebug::emitDebugLoc() {
2255 if (DotDebugLocEntries.empty())
2258 for (SmallVector<DotDebugLocEntry, 4>::iterator
2259 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2261 DotDebugLocEntry &Entry = *I;
2262 if (I + 1 != DotDebugLocEntries.end())
2266 // Start the dwarf loc section.
2267 Asm->OutStreamer.SwitchSection(
2268 Asm->getObjFileLowering().getDwarfLocSection());
2269 unsigned char Size = Asm->getDataLayout().getPointerSize();
2270 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2272 for (SmallVector<DotDebugLocEntry, 4>::iterator
2273 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2274 I != E; ++I, ++index) {
2275 DotDebugLocEntry &Entry = *I;
2276 if (Entry.isMerged()) continue;
2277 if (Entry.isEmpty()) {
2278 Asm->OutStreamer.EmitIntValue(0, Size);
2279 Asm->OutStreamer.EmitIntValue(0, Size);
2280 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2282 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2283 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
2284 DIVariable DV(Entry.Variable);
2285 Asm->OutStreamer.AddComment("Loc expr size");
2286 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2287 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2288 Asm->EmitLabelDifference(end, begin, 2);
2289 Asm->OutStreamer.EmitLabel(begin);
2290 if (Entry.isInt()) {
2291 DIBasicType BTy(DV.getType());
2293 (BTy.getEncoding() == dwarf::DW_ATE_signed
2294 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2295 Asm->OutStreamer.AddComment("DW_OP_consts");
2296 Asm->EmitInt8(dwarf::DW_OP_consts);
2297 Asm->EmitSLEB128(Entry.getInt());
2299 Asm->OutStreamer.AddComment("DW_OP_constu");
2300 Asm->EmitInt8(dwarf::DW_OP_constu);
2301 Asm->EmitULEB128(Entry.getInt());
2303 } else if (Entry.isLocation()) {
2304 if (!DV.hasComplexAddress())
2306 Asm->EmitDwarfRegOp(Entry.Loc);
2308 // Complex address entry.
2309 unsigned N = DV.getNumAddrElements();
2311 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2312 if (Entry.Loc.getOffset()) {
2314 Asm->EmitDwarfRegOp(Entry.Loc);
2315 Asm->OutStreamer.AddComment("DW_OP_deref");
2316 Asm->EmitInt8(dwarf::DW_OP_deref);
2317 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2318 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2319 Asm->EmitSLEB128(DV.getAddrElement(1));
2321 // If first address element is OpPlus then emit
2322 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2323 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2324 Asm->EmitDwarfRegOp(Loc);
2328 Asm->EmitDwarfRegOp(Entry.Loc);
2331 // Emit remaining complex address elements.
2332 for (; i < N; ++i) {
2333 uint64_t Element = DV.getAddrElement(i);
2334 if (Element == DIBuilder::OpPlus) {
2335 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2336 Asm->EmitULEB128(DV.getAddrElement(++i));
2337 } else if (Element == DIBuilder::OpDeref) {
2338 if (!Entry.Loc.isReg())
2339 Asm->EmitInt8(dwarf::DW_OP_deref);
2341 llvm_unreachable("unknown Opcode found in complex address");
2345 // else ... ignore constant fp. There is not any good way to
2346 // to represent them here in dwarf.
2347 Asm->OutStreamer.EmitLabel(end);
2352 // Emit visible names into a debug aranges section.
2353 void DwarfDebug::emitDebugARanges() {
2354 // Start the dwarf aranges section.
2355 Asm->OutStreamer.SwitchSection(
2356 Asm->getObjFileLowering().getDwarfARangesSection());
2359 // Emit visible names into a debug ranges section.
2360 void DwarfDebug::emitDebugRanges() {
2361 // Start the dwarf ranges section.
2362 Asm->OutStreamer.SwitchSection(
2363 Asm->getObjFileLowering().getDwarfRangesSection());
2364 unsigned char Size = Asm->getDataLayout().getPointerSize();
2365 for (SmallVector<const MCSymbol *, 8>::iterator
2366 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2369 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2371 Asm->OutStreamer.EmitIntValue(0, Size);
2375 // Emit visible names into a debug macinfo section.
2376 void DwarfDebug::emitDebugMacInfo() {
2377 if (const MCSection *LineInfo =
2378 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2379 // Start the dwarf macinfo section.
2380 Asm->OutStreamer.SwitchSection(LineInfo);
2384 // Emit inline info using following format.
2386 // 1. length of section
2387 // 2. Dwarf version number
2390 // Entries (one "entry" for each function that was inlined):
2392 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2393 // otherwise offset into __debug_str for regular function name.
2394 // 2. offset into __debug_str section for regular function name.
2395 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2396 // instances for the function.
2398 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2399 // inlined instance; the die_offset points to the inlined_subroutine die in the
2400 // __debug_info section, and the low_pc is the starting address for the
2401 // inlining instance.
2402 void DwarfDebug::emitDebugInlineInfo() {
2403 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2409 Asm->OutStreamer.SwitchSection(
2410 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2412 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2413 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2414 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2416 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2418 Asm->OutStreamer.AddComment("Dwarf Version");
2419 Asm->EmitInt16(dwarf::DWARF_VERSION);
2420 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2421 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2423 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2424 E = InlinedSPNodes.end(); I != E; ++I) {
2426 const MDNode *Node = *I;
2427 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2428 = InlineInfo.find(Node);
2429 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2430 DISubprogram SP(Node);
2431 StringRef LName = SP.getLinkageName();
2432 StringRef Name = SP.getName();
2434 Asm->OutStreamer.AddComment("MIPS linkage name");
2436 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2437 DwarfStrSectionSym);
2439 Asm->EmitSectionOffset(InfoHolder
2440 .getStringPoolEntry(getRealLinkageName(LName)),
2441 DwarfStrSectionSym);
2443 Asm->OutStreamer.AddComment("Function name");
2444 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2445 DwarfStrSectionSym);
2446 Asm->EmitULEB128(Labels.size(), "Inline count");
2448 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2449 LE = Labels.end(); LI != LE; ++LI) {
2450 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2451 Asm->EmitInt32(LI->second->getOffset());
2453 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2454 Asm->OutStreamer.EmitSymbolValue(LI->first,
2455 Asm->getDataLayout().getPointerSize());
2459 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2462 // DWARF5 Experimental Separate Dwarf emitters.
2464 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2465 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2466 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2467 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2468 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2469 DICompileUnit DIUnit(N);
2470 CompilationDir = DIUnit.getDirectory();
2472 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2473 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2474 DIUnit.getLanguage(), Die, Asm,
2475 this, &SkeletonHolder);
2477 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2478 DIUnit.getSplitDebugFilename());
2480 // This should be a unique identifier when we want to build .dwp files.
2481 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2483 // FIXME: The addr base should be relative for each compile unit, however,
2484 // this one is going to be 0 anyhow.
2485 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset, 0);
2487 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2488 // into an entity. We're using 0, or a NULL label for this.
2489 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2491 // DW_AT_stmt_list is a offset of line number information for this
2492 // compile unit in debug_line section.
2493 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2494 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2495 DwarfLineSectionSym);
2497 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2499 if (!CompilationDir.empty())
2500 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2502 SkeletonHolder.addUnit(NewCU);
2503 SkeletonCUs.push_back(NewCU);
2508 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2509 assert(useSplitDwarf() && "No split dwarf debug info?");
2510 emitAbbrevs(Section, &SkeletonAbbrevs);
2513 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2514 // compile units that would normally be in debug_info.
2515 void DwarfDebug::emitDebugInfoDWO() {
2516 assert(useSplitDwarf() && "No split dwarf debug info?");
2517 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2518 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2519 DwarfAbbrevDWOSectionSym);
2522 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2523 // abbreviations for the .debug_info.dwo section.
2524 void DwarfDebug::emitDebugAbbrevDWO() {
2525 assert(useSplitDwarf() && "No split dwarf?");
2526 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2530 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2531 // string section and is identical in format to traditional .debug_str
2533 void DwarfDebug::emitDebugStrDWO() {
2534 assert(useSplitDwarf() && "No split dwarf?");
2535 const MCSection *OffSec = Asm->getObjFileLowering()
2536 .getDwarfStrOffDWOSection();
2537 const MCSymbol *StrSym = DwarfStrSectionSym;
2538 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),