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"
18 #include "DwarfAccelTable.h"
19 #include "DwarfCompileUnit.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/DIBuilder.h"
27 #include "llvm/DebugInfo.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/Module.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/MD5.h"
42 #include "llvm/Support/Path.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/ValueHandle.h"
45 #include "llvm/Target/TargetFrameLowering.h"
46 #include "llvm/Target/TargetLoweringObjectFile.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include "llvm/Target/TargetOptions.h"
49 #include "llvm/Target/TargetRegisterInfo.h"
53 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
54 cl::desc("Disable debug info printing"));
56 static cl::opt<bool> UnknownLocations(
57 "use-unknown-locations", cl::Hidden,
58 cl::desc("Make an absence of debug location information explicit."),
62 GenerateODRHash("generate-odr-hash", cl::Hidden,
63 cl::desc("Add an ODR hash to external type DIEs."),
67 GenerateCUHash("generate-cu-hash", cl::Hidden,
68 cl::desc("Add the CU hash as the dwo_id."),
79 static cl::opt<DefaultOnOff>
80 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
81 cl::desc("Output prototype dwarf accelerator tables."),
82 cl::values(clEnumVal(Default, "Default for platform"),
83 clEnumVal(Enable, "Enabled"),
84 clEnumVal(Disable, "Disabled"), clEnumValEnd),
87 static cl::opt<DefaultOnOff>
88 DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
89 cl::desc("Compatibility with Darwin gdb."),
90 cl::values(clEnumVal(Default, "Default for platform"),
91 clEnumVal(Enable, "Enabled"),
92 clEnumVal(Disable, "Disabled"), clEnumValEnd),
95 static cl::opt<DefaultOnOff>
96 SplitDwarf("split-dwarf", cl::Hidden,
97 cl::desc("Output prototype dwarf split debug info."),
98 cl::values(clEnumVal(Default, "Default for platform"),
99 clEnumVal(Enable, "Enabled"),
100 clEnumVal(Disable, "Disabled"), clEnumValEnd),
103 static cl::opt<DefaultOnOff>
104 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
105 cl::desc("Generate DWARF pubnames and pubtypes sections"),
106 cl::values(clEnumVal(Default, "Default for platform"),
107 clEnumVal(Enable, "Enabled"),
108 clEnumVal(Disable, "Disabled"), clEnumValEnd),
111 static const char *const DWARFGroupName = "DWARF Emission";
112 static const char *const DbgTimerName = "DWARF Debug Writer";
114 //===----------------------------------------------------------------------===//
116 // Configuration values for initial hash set sizes (log2).
118 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
122 DIType DbgVariable::getType() const {
123 DIType Ty = Var.getType();
124 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
125 // addresses instead.
126 if (Var.isBlockByrefVariable()) {
127 /* Byref variables, in Blocks, are declared by the programmer as
128 "SomeType VarName;", but the compiler creates a
129 __Block_byref_x_VarName struct, and gives the variable VarName
130 either the struct, or a pointer to the struct, as its type. This
131 is necessary for various behind-the-scenes things the compiler
132 needs to do with by-reference variables in blocks.
134 However, as far as the original *programmer* is concerned, the
135 variable should still have type 'SomeType', as originally declared.
137 The following function dives into the __Block_byref_x_VarName
138 struct to find the original type of the variable. This will be
139 passed back to the code generating the type for the Debug
140 Information Entry for the variable 'VarName'. 'VarName' will then
141 have the original type 'SomeType' in its debug information.
143 The original type 'SomeType' will be the type of the field named
144 'VarName' inside the __Block_byref_x_VarName struct.
146 NOTE: In order for this to not completely fail on the debugger
147 side, the Debug Information Entry for the variable VarName needs to
148 have a DW_AT_location that tells the debugger how to unwind through
149 the pointers and __Block_byref_x_VarName struct to find the actual
150 value of the variable. The function addBlockByrefType does this. */
152 uint16_t tag = Ty.getTag();
154 if (tag == dwarf::DW_TAG_pointer_type) {
155 DIDerivedType DTy = DIDerivedType(Ty);
156 subType = DTy.getTypeDerivedFrom();
159 DICompositeType blockStruct = DICompositeType(subType);
160 DIArray Elements = blockStruct.getTypeArray();
162 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
163 DIDescriptor Element = Elements.getElement(i);
164 DIDerivedType DT = DIDerivedType(Element);
165 if (getName() == DT.getName())
166 return (DT.getTypeDerivedFrom());
172 } // end llvm namespace
174 /// Return Dwarf Version by checking module flags.
175 static unsigned getDwarfVersionFromModule(const Module *M) {
176 Value *Val = M->getModuleFlag("Dwarf Version");
178 return dwarf::DWARF_VERSION;
179 return cast<ConstantInt>(Val)->getZExtValue();
182 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
183 : Asm(A), MMI(Asm->MMI), FirstCU(0),
184 AbbreviationsSet(InitAbbreviationsSetSize),
185 SourceIdMap(DIEValueAllocator),
186 PrevLabel(NULL), GlobalCUIndexCount(0),
187 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
189 SkeletonAbbrevSet(InitAbbreviationsSetSize),
190 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
193 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
194 DwarfStrSectionSym = TextSectionSym = 0;
195 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
196 DwarfAddrSectionSym = 0;
197 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
198 FunctionBeginSym = FunctionEndSym = 0;
200 // Turn on accelerator tables and older gdb compatibility
201 // for Darwin by default, pubnames by default for non-Darwin,
202 // and handle split dwarf.
203 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
205 if (DarwinGDBCompat == Default)
206 IsDarwinGDBCompat = IsDarwin;
208 IsDarwinGDBCompat = DarwinGDBCompat == Enable;
210 if (DwarfAccelTables == Default)
211 HasDwarfAccelTables = IsDarwin;
213 HasDwarfAccelTables = DwarfAccelTables == Enable;
215 if (SplitDwarf == Default)
216 HasSplitDwarf = false;
218 HasSplitDwarf = SplitDwarf == Enable;
220 if (DwarfPubSections == Default)
221 HasDwarfPubSections = !IsDarwin;
223 HasDwarfPubSections = DwarfPubSections == Enable;
225 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
228 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
232 DwarfDebug::~DwarfDebug() {
235 // Switch to the specified MCSection and emit an assembler
236 // temporary label to it if SymbolStem is specified.
237 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
238 const char *SymbolStem = 0) {
239 Asm->OutStreamer.SwitchSection(Section);
240 if (!SymbolStem) return 0;
242 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
243 Asm->OutStreamer.EmitLabel(TmpSym);
247 MCSymbol *DwarfUnits::getStringPoolSym() {
248 return Asm->GetTempSymbol(StringPref);
251 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
252 std::pair<MCSymbol*, unsigned> &Entry =
253 StringPool.GetOrCreateValue(Str).getValue();
254 if (Entry.first) return Entry.first;
256 Entry.second = NextStringPoolNumber++;
257 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
260 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
261 std::pair<MCSymbol*, unsigned> &Entry =
262 StringPool.GetOrCreateValue(Str).getValue();
263 if (Entry.first) return Entry.second;
265 Entry.second = NextStringPoolNumber++;
266 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
270 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
271 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
274 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
275 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
276 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
278 ++NextAddrPoolNumber;
279 return P.first->second;
282 // Define a unique number for the abbreviation.
284 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
285 // Check the set for priors.
286 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
288 // If it's newly added.
289 if (InSet == &Abbrev) {
290 // Add to abbreviation list.
291 Abbreviations->push_back(&Abbrev);
293 // Assign the vector position + 1 as its number.
294 Abbrev.setNumber(Abbreviations->size());
296 // Assign existing abbreviation number.
297 Abbrev.setNumber(InSet->getNumber());
301 static bool isObjCClass(StringRef Name) {
302 return Name.startswith("+") || Name.startswith("-");
305 static bool hasObjCCategory(StringRef Name) {
306 if (!isObjCClass(Name)) return false;
308 return Name.find(") ") != StringRef::npos;
311 static void getObjCClassCategory(StringRef In, StringRef &Class,
312 StringRef &Category) {
313 if (!hasObjCCategory(In)) {
314 Class = In.slice(In.find('[') + 1, In.find(' '));
319 Class = In.slice(In.find('[') + 1, In.find('('));
320 Category = In.slice(In.find('[') + 1, In.find(' '));
324 static StringRef getObjCMethodName(StringRef In) {
325 return In.slice(In.find(' ') + 1, In.find(']'));
328 // Add the various names to the Dwarf accelerator table names.
329 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
331 if (!SP.isDefinition()) return;
333 TheCU->addAccelName(SP.getName(), Die);
335 // If the linkage name is different than the name, go ahead and output
336 // that as well into the name table.
337 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
338 TheCU->addAccelName(SP.getLinkageName(), Die);
340 // If this is an Objective-C selector name add it to the ObjC accelerator
342 if (isObjCClass(SP.getName())) {
343 StringRef Class, Category;
344 getObjCClassCategory(SP.getName(), Class, Category);
345 TheCU->addAccelObjC(Class, Die);
347 TheCU->addAccelObjC(Category, Die);
348 // Also add the base method name to the name table.
349 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
353 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
354 // and DW_AT_high_pc attributes. If there are global variables in this
355 // scope then create and insert DIEs for these variables.
356 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
357 const MDNode *SPNode) {
358 DIE *SPDie = SPCU->getDIE(SPNode);
360 assert(SPDie && "Unable to find subprogram DIE!");
361 DISubprogram SP(SPNode);
363 // If we're updating an abstract DIE, then we will be adding the children and
364 // object pointer later on. But what we don't want to do is process the
365 // concrete DIE twice.
366 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
368 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
369 // Pick up abstract subprogram DIE.
370 SPDie = new DIE(dwarf::DW_TAG_subprogram);
371 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
373 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
374 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
378 DISubprogram SPDecl = SP.getFunctionDeclaration();
379 if (!SPDecl.isSubprogram()) {
380 // There is not any need to generate specification DIE for a function
381 // defined at compile unit level. If a function is defined inside another
382 // function then gdb prefers the definition at top level and but does not
383 // expect specification DIE in parent function. So avoid creating
384 // specification DIE for a function defined inside a function.
385 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
386 !SP.getContext().isFile() &&
387 !isSubprogramContext(SP.getContext())) {
388 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
391 DICompositeType SPTy = SP.getType();
392 DIArray Args = SPTy.getTypeArray();
393 uint16_t SPTag = SPTy.getTag();
394 if (SPTag == dwarf::DW_TAG_subroutine_type)
395 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
396 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
397 DIType ATy = DIType(Args.getElement(i));
398 SPCU->addType(Arg, ATy);
399 if (ATy.isArtificial())
400 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
401 if (ATy.isObjectPointer())
402 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
403 dwarf::DW_FORM_ref4, Arg);
404 SPDie->addChild(Arg);
406 DIE *SPDeclDie = SPDie;
407 SPDie = new DIE(dwarf::DW_TAG_subprogram);
408 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
409 dwarf::DW_FORM_ref4, SPDeclDie);
415 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
416 Asm->GetTempSymbol("func_begin",
417 Asm->getFunctionNumber()));
418 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
419 Asm->GetTempSymbol("func_end",
420 Asm->getFunctionNumber()));
421 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
422 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
423 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
425 // Add name to the name table, we do this here because we're guaranteed
426 // to have concrete versions of our DW_TAG_subprogram nodes.
427 addSubprogramNames(SPCU, SP, SPDie);
432 // Construct new DW_TAG_lexical_block for this scope and attach
433 // DW_AT_low_pc/DW_AT_high_pc labels.
434 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
435 LexicalScope *Scope) {
436 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
437 if (Scope->isAbstractScope())
440 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
444 // If we have multiple ranges, emit them into the range section.
445 if (Ranges.size() > 1) {
446 // .debug_range section has not been laid out yet. Emit offset in
447 // .debug_range as a uint, size 4, for now. emitDIE will handle
448 // DW_AT_ranges appropriately.
449 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
450 DebugRangeSymbols.size()
451 * Asm->getDataLayout().getPointerSize());
452 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
453 RE = Ranges.end(); RI != RE; ++RI) {
454 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
455 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
458 // Terminate the range list.
459 DebugRangeSymbols.push_back(NULL);
460 DebugRangeSymbols.push_back(NULL);
464 // Construct the address range for this DIE.
465 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
466 MCSymbol *Start = getLabelBeforeInsn(RI->first);
467 MCSymbol *End = getLabelAfterInsn(RI->second);
469 if (End == 0) return 0;
471 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
472 assert(End->isDefined() && "Invalid end label for an inlined scope!");
474 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
475 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
480 // This scope represents inlined body of a function. Construct DIE to
481 // represent this concrete inlined copy of the function.
482 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
483 LexicalScope *Scope) {
484 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
485 assert(Ranges.empty() == false &&
486 "LexicalScope does not have instruction markers!");
488 if (!Scope->getScopeNode())
490 DIScope DS(Scope->getScopeNode());
491 DISubprogram InlinedSP = getDISubprogram(DS);
492 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
494 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
498 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
499 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
500 dwarf::DW_FORM_ref4, OriginDIE);
502 if (Ranges.size() > 1) {
503 // .debug_range section has not been laid out yet. Emit offset in
504 // .debug_range as a uint, size 4, for now. emitDIE will handle
505 // DW_AT_ranges appropriately.
506 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
507 DebugRangeSymbols.size()
508 * Asm->getDataLayout().getPointerSize());
509 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
510 RE = Ranges.end(); RI != RE; ++RI) {
511 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
512 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
514 DebugRangeSymbols.push_back(NULL);
515 DebugRangeSymbols.push_back(NULL);
517 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
518 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
519 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
521 if (StartLabel == 0 || EndLabel == 0)
522 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
524 assert(StartLabel->isDefined() &&
525 "Invalid starting label for an inlined scope!");
526 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
528 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
529 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
532 InlinedSubprogramDIEs.insert(OriginDIE);
534 // Add the call site information to the DIE.
535 DILocation DL(Scope->getInlinedAt());
536 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
537 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
538 TheCU->getUniqueID()));
539 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
541 // Track the start label for this inlined function.
542 //.debug_inlined section specification does not clearly state how
543 // to emit inlined scopes that are split into multiple instruction ranges.
544 // For now, use the first instruction range and emit low_pc/high_pc pair and
545 // corresponding the .debug_inlined section entry for this pair.
546 if (Asm->MAI->doesDwarfUseInlineInfoSection()) {
547 MCSymbol *StartLabel = getLabelBeforeInsn(Ranges.begin()->first);
548 InlineInfoMap::iterator I = InlineInfo.find(InlinedSP);
550 if (I == InlineInfo.end()) {
551 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
552 InlinedSPNodes.push_back(InlinedSP);
554 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
557 // Add name to the name table, we do this here because we're guaranteed
558 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
559 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
564 // Construct a DIE for this scope.
565 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
566 if (!Scope || !Scope->getScopeNode())
569 DIScope DS(Scope->getScopeNode());
570 // Early return to avoid creating dangling variable|scope DIEs.
571 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
575 SmallVector<DIE *, 8> Children;
576 DIE *ObjectPointer = NULL;
578 // Collect arguments for current function.
579 if (LScopes.isCurrentFunctionScope(Scope))
580 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
581 if (DbgVariable *ArgDV = CurrentFnArguments[i])
583 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
584 Children.push_back(Arg);
585 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
588 // Collect lexical scope children first.
589 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
590 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
592 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
593 Children.push_back(Variable);
594 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
596 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
597 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
598 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
599 Children.push_back(Nested);
600 DIE *ScopeDIE = NULL;
601 if (Scope->getInlinedAt())
602 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
603 else if (DS.isSubprogram()) {
604 ProcessedSPNodes.insert(DS);
605 if (Scope->isAbstractScope()) {
606 ScopeDIE = TheCU->getDIE(DS);
607 // Note down abstract DIE.
609 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
612 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
615 // There is no need to emit empty lexical block DIE.
616 std::pair<ImportedEntityMap::const_iterator,
617 ImportedEntityMap::const_iterator> Range = std::equal_range(
618 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
619 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
621 if (Children.empty() && Range.first == Range.second)
623 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
624 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
626 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
630 std::for_each(Children.begin(), Children.end(), deleter<DIE>);
635 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
636 E = Children.end(); I != E; ++I)
637 ScopeDIE->addChild(*I);
639 if (DS.isSubprogram() && ObjectPointer != NULL)
640 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
641 dwarf::DW_FORM_ref4, ObjectPointer);
643 if (DS.isSubprogram())
644 TheCU->addPubTypes(DISubprogram(DS));
649 // Look up the source id with the given directory and source file names.
650 // If none currently exists, create a new id and insert it in the
651 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
653 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
654 StringRef DirName, unsigned CUID) {
655 // If we use .loc in assembly, we can't separate .file entries according to
656 // compile units. Thus all files will belong to the default compile unit.
657 if (Asm->TM.hasMCUseLoc() &&
658 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
661 // If FE did not provide a file name, then assume stdin.
662 if (FileName.empty())
663 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
665 // TODO: this might not belong here. See if we can factor this better.
666 if (DirName == CompilationDir)
669 // FileIDCUMap stores the current ID for the given compile unit.
670 unsigned SrcId = FileIDCUMap[CUID] + 1;
672 // We look up the CUID/file/dir by concatenating them with a zero byte.
673 SmallString<128> NamePair;
674 NamePair += utostr(CUID);
677 NamePair += '\0'; // Zero bytes are not allowed in paths.
678 NamePair += FileName;
680 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
681 if (Ent.getValue() != SrcId)
682 return Ent.getValue();
684 FileIDCUMap[CUID] = SrcId;
685 // Print out a .file directive to specify files for .loc directives.
686 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
691 // Create new CompileUnit for the given metadata node with tag
692 // DW_TAG_compile_unit.
693 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
694 DICompileUnit DIUnit(N);
695 StringRef FN = DIUnit.getFilename();
696 CompilationDir = DIUnit.getDirectory();
698 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
700 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder);
702 FileIDCUMap[NewCU->getUniqueID()] = 0;
703 // Call this to emit a .file directive if it wasn't emitted for the source
704 // file this CU comes from yet.
705 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
707 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
708 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
709 DIUnit.getLanguage());
710 NewCU->addString(Die, dwarf::DW_AT_name, FN);
712 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
713 // into an entity. We're using 0 (or a NULL label) for this. For
714 // split dwarf it's in the skeleton CU so omit it here.
715 if (!useSplitDwarf())
716 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
718 // Define start line table label for each Compile Unit.
719 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
720 NewCU->getUniqueID());
721 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
722 NewCU->getUniqueID());
724 // Use a single line table if we are using .loc and generating assembly.
726 (Asm->TM.hasMCUseLoc() &&
727 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
728 (NewCU->getUniqueID() == 0);
730 // DW_AT_stmt_list is a offset of line number information for this
731 // compile unit in debug_line section. For split dwarf this is
732 // left in the skeleton CU and so not included.
733 // The line table entries are not always emitted in assembly, so it
734 // is not okay to use line_table_start here.
735 if (!useSplitDwarf()) {
736 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
737 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
739 Asm->GetTempSymbol("section_line") : LineTableStartSym);
740 else if (UseTheFirstCU)
741 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
743 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
744 LineTableStartSym, DwarfLineSectionSym);
747 // If we're using split dwarf the compilation dir is going to be in the
748 // skeleton CU and so we don't need to duplicate it here.
749 if (!useSplitDwarf() && !CompilationDir.empty())
750 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
751 if (DIUnit.isOptimized())
752 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
754 StringRef Flags = DIUnit.getFlags();
756 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
758 if (unsigned RVer = DIUnit.getRunTimeVersion())
759 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
760 dwarf::DW_FORM_data1, RVer);
765 InfoHolder.addUnit(NewCU);
767 CUMap.insert(std::make_pair(N, NewCU));
771 // Construct subprogram DIE.
772 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
774 CompileUnit *&CURef = SPMap[N];
780 if (!SP.isDefinition())
781 // This is a method declaration which will be handled while constructing
785 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
788 TheCU->insertDIE(N, SubprogramDie);
790 // Add to context owner.
791 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
793 // Expose as global, if requested.
794 if (HasDwarfPubSections)
795 TheCU->addGlobalName(SP.getName(), SubprogramDie);
798 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
800 DIImportedEntity Module(N);
801 if (!Module.Verify())
803 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
804 constructImportedEntityDIE(TheCU, Module, D);
807 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
809 DIImportedEntity Module(N);
810 if (!Module.Verify())
812 return constructImportedEntityDIE(TheCU, Module, Context);
815 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
816 const DIImportedEntity &Module,
818 assert(Module.Verify() &&
819 "Use one of the MDNode * overloads to handle invalid metadata");
820 assert(Context && "Should always have a context for an imported_module");
821 DIE *IMDie = new DIE(Module.getTag());
822 TheCU->insertDIE(Module, IMDie);
824 DIDescriptor Entity = Module.getEntity();
825 if (Entity.isNameSpace())
826 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
827 else if (Entity.isSubprogram())
828 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
829 else if (Entity.isType())
830 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
832 EntityDie = TheCU->getDIE(Entity);
833 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
834 Module.getContext().getDirectory(),
835 TheCU->getUniqueID());
836 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
837 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
838 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
840 StringRef Name = Module.getName();
842 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
843 Context->addChild(IMDie);
846 // Emit all Dwarf sections that should come prior to the content. Create
847 // global DIEs and emit initial debug info sections. This is invoked by
848 // the target AsmPrinter.
849 void DwarfDebug::beginModule() {
850 if (DisableDebugInfoPrinting)
853 const Module *M = MMI->getModule();
855 // If module has named metadata anchors then use them, otherwise scan the
856 // module using debug info finder to collect debug info.
857 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
861 // Emit initial sections so we can reference labels later.
864 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
865 DICompileUnit CUNode(CU_Nodes->getOperand(i));
866 CompileUnit *CU = constructCompileUnit(CUNode);
867 DIArray ImportedEntities = CUNode.getImportedEntities();
868 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
869 ScopesWithImportedEntities.push_back(std::make_pair(
870 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
871 ImportedEntities.getElement(i)));
872 std::sort(ScopesWithImportedEntities.begin(),
873 ScopesWithImportedEntities.end(), less_first());
874 DIArray GVs = CUNode.getGlobalVariables();
875 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
876 CU->createGlobalVariableDIE(GVs.getElement(i));
877 DIArray SPs = CUNode.getSubprograms();
878 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
879 constructSubprogramDIE(CU, SPs.getElement(i));
880 DIArray EnumTypes = CUNode.getEnumTypes();
881 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
882 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
883 DIArray RetainedTypes = CUNode.getRetainedTypes();
884 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
885 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
886 // Emit imported_modules last so that the relevant context is already
888 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
889 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
892 // Tell MMI that we have debug info.
893 MMI->setDebugInfoAvailability(true);
895 // Prime section data.
896 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
899 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
900 void DwarfDebug::computeInlinedDIEs() {
901 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
902 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
903 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
905 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
907 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
908 AE = AbstractSPDies.end(); AI != AE; ++AI) {
909 DIE *ISP = AI->second;
910 if (InlinedSubprogramDIEs.count(ISP))
912 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
916 // Collect info for variables that were optimized out.
917 void DwarfDebug::collectDeadVariables() {
918 const Module *M = MMI->getModule();
919 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
921 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
922 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
923 DICompileUnit TheCU(CU_Nodes->getOperand(i));
924 DIArray Subprograms = TheCU.getSubprograms();
925 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
926 DISubprogram SP(Subprograms.getElement(i));
927 if (ProcessedSPNodes.count(SP) != 0) continue;
928 if (!SP.isSubprogram()) continue;
929 if (!SP.isDefinition()) continue;
930 DIArray Variables = SP.getVariables();
931 if (Variables.getNumElements() == 0) continue;
933 LexicalScope *Scope =
934 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
935 DeadFnScopeMap[SP] = Scope;
937 // Construct subprogram DIE and add variables DIEs.
938 CompileUnit *SPCU = CUMap.lookup(TheCU);
939 assert(SPCU && "Unable to find Compile Unit!");
940 constructSubprogramDIE(SPCU, SP);
941 DIE *ScopeDIE = SPCU->getDIE(SP);
942 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
943 DIVariable DV(Variables.getElement(vi));
944 if (!DV.isVariable()) continue;
945 DbgVariable NewVar(DV, NULL);
946 if (DIE *VariableDIE =
947 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
948 ScopeDIE->addChild(VariableDIE);
953 DeleteContainerSeconds(DeadFnScopeMap);
956 // Type Signature [7.27] and ODR Hash code.
958 /// \brief Grabs the string in whichever attribute is passed in and returns
959 /// a reference to it. Returns "" if the attribute doesn't exist.
960 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
961 DIEValue *V = Die->findAttribute(Attr);
963 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
964 return S->getString();
966 return StringRef("");
969 /// Return true if the current DIE is contained within an anonymous namespace.
970 static bool isContainedInAnonNamespace(DIE *Die) {
971 DIE *Parent = Die->getParent();
974 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
975 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
977 Parent = Parent->getParent();
983 /// Test if the current CU language is C++ and that we have
984 /// a named type that is not contained in an anonymous namespace.
985 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
986 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
987 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
988 !isContainedInAnonNamespace(Die);
991 void DwarfDebug::finalizeModuleInfo() {
992 // Collect info for variables that were optimized out.
993 collectDeadVariables();
995 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
996 computeInlinedDIEs();
998 // Split out type units and conditionally add an ODR tag to the split
1000 // FIXME: Do type splitting.
1001 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1002 DIE *Die = TypeUnits[i];
1004 // If we've requested ODR hashes and it's applicable for an ODR hash then
1005 // add the ODR signature now.
1006 // FIXME: This should be added onto the type unit, not the type, but this
1007 // works as an intermediate stage.
1008 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1009 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1010 dwarf::DW_FORM_data8,
1011 Hash.computeDIEODRSignature(Die));
1014 // Handle anything that needs to be done on a per-cu basis.
1015 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1017 CUI != CUE; ++CUI) {
1018 CompileUnit *TheCU = CUI->second;
1019 // Emit DW_AT_containing_type attribute to connect types with their
1020 // vtable holding type.
1021 TheCU->constructContainingTypeDIEs();
1023 // If we're splitting the dwarf out now that we've got the entire
1024 // CU then construct a skeleton CU based upon it.
1025 if (useSplitDwarf()) {
1027 if (GenerateCUHash) {
1029 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1031 // This should be a unique identifier when we want to build .dwp files.
1032 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1033 dwarf::DW_FORM_data8, ID);
1034 // Now construct the skeleton CU associated.
1035 CompileUnit *SkCU = constructSkeletonCU(CUI->first);
1036 // This should be a unique identifier when we want to build .dwp files.
1037 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1038 dwarf::DW_FORM_data8, ID);
1042 // Compute DIE offsets and sizes.
1043 InfoHolder.computeSizeAndOffsets();
1044 if (useSplitDwarf())
1045 SkeletonHolder.computeSizeAndOffsets();
1048 void DwarfDebug::endSections() {
1049 // Standard sections final addresses.
1050 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1051 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1052 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1053 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1055 // End text sections.
1056 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1057 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1058 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1062 // Emit all Dwarf sections that should come after the content.
1063 void DwarfDebug::endModule() {
1065 if (!FirstCU) return;
1067 // End any existing sections.
1068 // TODO: Does this need to happen?
1071 // Finalize the debug info for the module.
1072 finalizeModuleInfo();
1074 if (!useSplitDwarf()) {
1075 // Emit all the DIEs into a debug info section.
1078 // Corresponding abbreviations into a abbrev section.
1079 emitAbbreviations();
1081 // Emit info into a debug loc section.
1084 // Emit info into a debug aranges section.
1087 // Emit info into a debug ranges section.
1090 // Emit info into a debug macinfo section.
1093 // Emit inline info.
1094 // TODO: When we don't need the option anymore we
1095 // can remove all of the code that this section
1097 if (useDarwinGDBCompat())
1098 emitDebugInlineInfo();
1100 // TODO: Fill this in for separated debug sections and separate
1101 // out information into new sections.
1103 // Emit the debug info section and compile units.
1107 // Corresponding abbreviations into a abbrev section.
1108 emitAbbreviations();
1109 emitDebugAbbrevDWO();
1111 // Emit info into a debug loc section.
1114 // Emit info into a debug aranges section.
1117 // Emit info into a debug ranges section.
1120 // Emit info into a debug macinfo section.
1123 // Emit DWO addresses.
1124 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1126 // Emit inline info.
1127 // TODO: When we don't need the option anymore we
1128 // can remove all of the code that this section
1130 if (useDarwinGDBCompat())
1131 emitDebugInlineInfo();
1134 // Emit info into the dwarf accelerator table sections.
1135 if (useDwarfAccelTables()) {
1138 emitAccelNamespaces();
1142 // Emit info into a debug pubnames section, if requested.
1143 if (HasDwarfPubSections)
1144 emitDebugPubnames();
1146 // Emit info into a debug pubtypes section.
1147 // TODO: When we don't need the option anymore we can
1148 // remove all of the code that adds to the table.
1149 if (useDarwinGDBCompat() || HasDwarfPubSections)
1150 emitDebugPubTypes();
1152 // Finally emit string information into a string table.
1154 if (useSplitDwarf())
1159 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1160 E = CUMap.end(); I != E; ++I)
1163 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1164 E = SkeletonCUs.end(); I != E; ++I)
1167 // Reset these for the next Module if we have one.
1171 // Find abstract variable, if any, associated with Var.
1172 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1173 DebugLoc ScopeLoc) {
1174 LLVMContext &Ctx = DV->getContext();
1175 // More then one inlined variable corresponds to one abstract variable.
1176 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1177 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1179 return AbsDbgVariable;
1181 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1185 AbsDbgVariable = new DbgVariable(Var, NULL);
1186 addScopeVariable(Scope, AbsDbgVariable);
1187 AbstractVariables[Var] = AbsDbgVariable;
1188 return AbsDbgVariable;
1191 // If Var is a current function argument then add it to CurrentFnArguments list.
1192 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1193 DbgVariable *Var, LexicalScope *Scope) {
1194 if (!LScopes.isCurrentFunctionScope(Scope))
1196 DIVariable DV = Var->getVariable();
1197 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1199 unsigned ArgNo = DV.getArgNumber();
1203 size_t Size = CurrentFnArguments.size();
1205 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1206 // llvm::Function argument size is not good indicator of how many
1207 // arguments does the function have at source level.
1209 CurrentFnArguments.resize(ArgNo * 2);
1210 CurrentFnArguments[ArgNo - 1] = Var;
1214 // Collect variable information from side table maintained by MMI.
1216 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1217 SmallPtrSet<const MDNode *, 16> &Processed) {
1218 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1219 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1220 VE = VMap.end(); VI != VE; ++VI) {
1221 const MDNode *Var = VI->first;
1223 Processed.insert(Var);
1225 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1227 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1229 // If variable scope is not found then skip this variable.
1233 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1234 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1235 RegVar->setFrameIndex(VP.first);
1236 if (!addCurrentFnArgument(MF, RegVar, Scope))
1237 addScopeVariable(Scope, RegVar);
1239 AbsDbgVariable->setFrameIndex(VP.first);
1243 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1245 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1246 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1247 return MI->getNumOperands() == 3 &&
1248 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1249 (MI->getOperand(1).isImm() ||
1250 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1253 // Get .debug_loc entry for the instruction range starting at MI.
1254 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1255 const MCSymbol *FLabel,
1256 const MCSymbol *SLabel,
1257 const MachineInstr *MI) {
1258 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1260 assert(MI->getNumOperands() == 3);
1261 if (MI->getOperand(0).isReg()) {
1262 MachineLocation MLoc;
1263 // If the second operand is an immediate, this is a
1264 // register-indirect address.
1265 if (!MI->getOperand(1).isImm())
1266 MLoc.set(MI->getOperand(0).getReg());
1268 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1269 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1271 if (MI->getOperand(0).isImm())
1272 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1273 if (MI->getOperand(0).isFPImm())
1274 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1275 if (MI->getOperand(0).isCImm())
1276 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1278 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1281 // Find variables for each lexical scope.
1283 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1284 SmallPtrSet<const MDNode *, 16> &Processed) {
1286 // Grab the variable info that was squirreled away in the MMI side-table.
1287 collectVariableInfoFromMMITable(MF, Processed);
1289 for (SmallVectorImpl<const MDNode*>::const_iterator
1290 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1292 const MDNode *Var = *UVI;
1293 if (Processed.count(Var))
1296 // History contains relevant DBG_VALUE instructions for Var and instructions
1298 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1299 if (History.empty())
1301 const MachineInstr *MInsn = History.front();
1304 LexicalScope *Scope = NULL;
1305 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1306 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1307 Scope = LScopes.getCurrentFunctionScope();
1308 else if (MDNode *IA = DV.getInlinedAt())
1309 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1311 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1312 // If variable scope is not found then skip this variable.
1316 Processed.insert(DV);
1317 assert(MInsn->isDebugValue() && "History must begin with debug value");
1318 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1319 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1320 if (!addCurrentFnArgument(MF, RegVar, Scope))
1321 addScopeVariable(Scope, RegVar);
1323 AbsVar->setMInsn(MInsn);
1325 // Simplify ranges that are fully coalesced.
1326 if (History.size() <= 1 || (History.size() == 2 &&
1327 MInsn->isIdenticalTo(History.back()))) {
1328 RegVar->setMInsn(MInsn);
1332 // Handle multiple DBG_VALUE instructions describing one variable.
1333 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1335 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1336 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1337 const MachineInstr *Begin = *HI;
1338 assert(Begin->isDebugValue() && "Invalid History entry");
1340 // Check if DBG_VALUE is truncating a range.
1341 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1342 && !Begin->getOperand(0).getReg())
1345 // Compute the range for a register location.
1346 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1347 const MCSymbol *SLabel = 0;
1350 // If Begin is the last instruction in History then its value is valid
1351 // until the end of the function.
1352 SLabel = FunctionEndSym;
1354 const MachineInstr *End = HI[1];
1355 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1356 << "\t" << *Begin << "\t" << *End << "\n");
1357 if (End->isDebugValue())
1358 SLabel = getLabelBeforeInsn(End);
1360 // End is a normal instruction clobbering the range.
1361 SLabel = getLabelAfterInsn(End);
1362 assert(SLabel && "Forgot label after clobber instruction");
1367 // The value is valid until the next DBG_VALUE or clobber.
1368 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1371 DotDebugLocEntries.push_back(DotDebugLocEntry());
1374 // Collect info for variables that were optimized out.
1375 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1376 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1377 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1378 DIVariable DV(Variables.getElement(i));
1379 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1381 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1382 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1386 // Return Label preceding the instruction.
1387 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1388 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1389 assert(Label && "Didn't insert label before instruction");
1393 // Return Label immediately following the instruction.
1394 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1395 return LabelsAfterInsn.lookup(MI);
1398 // Process beginning of an instruction.
1399 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1400 // Check if source location changes, but ignore DBG_VALUE locations.
1401 if (!MI->isDebugValue()) {
1402 DebugLoc DL = MI->getDebugLoc();
1403 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1406 if (DL == PrologEndLoc) {
1407 Flags |= DWARF2_FLAG_PROLOGUE_END;
1408 PrologEndLoc = DebugLoc();
1410 if (PrologEndLoc.isUnknown())
1411 Flags |= DWARF2_FLAG_IS_STMT;
1413 if (!DL.isUnknown()) {
1414 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1415 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1417 recordSourceLine(0, 0, 0, 0);
1421 // Insert labels where requested.
1422 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1423 LabelsBeforeInsn.find(MI);
1426 if (I == LabelsBeforeInsn.end())
1429 // Label already assigned.
1434 PrevLabel = MMI->getContext().CreateTempSymbol();
1435 Asm->OutStreamer.EmitLabel(PrevLabel);
1437 I->second = PrevLabel;
1440 // Process end of an instruction.
1441 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1442 // Don't create a new label after DBG_VALUE instructions.
1443 // They don't generate code.
1444 if (!MI->isDebugValue())
1447 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1448 LabelsAfterInsn.find(MI);
1451 if (I == LabelsAfterInsn.end())
1454 // Label already assigned.
1458 // We need a label after this instruction.
1460 PrevLabel = MMI->getContext().CreateTempSymbol();
1461 Asm->OutStreamer.EmitLabel(PrevLabel);
1463 I->second = PrevLabel;
1466 // Each LexicalScope has first instruction and last instruction to mark
1467 // beginning and end of a scope respectively. Create an inverse map that list
1468 // scopes starts (and ends) with an instruction. One instruction may start (or
1469 // end) multiple scopes. Ignore scopes that are not reachable.
1470 void DwarfDebug::identifyScopeMarkers() {
1471 SmallVector<LexicalScope *, 4> WorkList;
1472 WorkList.push_back(LScopes.getCurrentFunctionScope());
1473 while (!WorkList.empty()) {
1474 LexicalScope *S = WorkList.pop_back_val();
1476 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1477 if (!Children.empty())
1478 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1479 SE = Children.end(); SI != SE; ++SI)
1480 WorkList.push_back(*SI);
1482 if (S->isAbstractScope())
1485 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1488 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1489 RE = Ranges.end(); RI != RE; ++RI) {
1490 assert(RI->first && "InsnRange does not have first instruction!");
1491 assert(RI->second && "InsnRange does not have second instruction!");
1492 requestLabelBeforeInsn(RI->first);
1493 requestLabelAfterInsn(RI->second);
1498 // Get MDNode for DebugLoc's scope.
1499 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1500 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1501 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1502 return DL.getScope(Ctx);
1505 // Walk up the scope chain of given debug loc and find line number info
1506 // for the function.
1507 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1508 const MDNode *Scope = getScopeNode(DL, Ctx);
1509 DISubprogram SP = getDISubprogram(Scope);
1510 if (SP.isSubprogram()) {
1511 // Check for number of operands since the compatibility is
1513 if (SP->getNumOperands() > 19)
1514 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1516 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1522 // Gather pre-function debug information. Assumes being called immediately
1523 // after the function entry point has been emitted.
1524 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1525 if (!MMI->hasDebugInfo()) return;
1526 LScopes.initialize(*MF);
1527 if (LScopes.empty()) return;
1528 identifyScopeMarkers();
1530 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1532 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1533 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1534 assert(TheCU && "Unable to find compile unit!");
1535 if (Asm->TM.hasMCUseLoc() &&
1536 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1537 // Use a single line table if we are using .loc and generating assembly.
1538 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1540 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1542 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1543 Asm->getFunctionNumber());
1544 // Assumes in correct section after the entry point.
1545 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1547 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1549 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1550 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1551 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1553 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1555 bool AtBlockEntry = true;
1556 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1558 const MachineInstr *MI = II;
1560 if (MI->isDebugValue()) {
1561 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1563 // Keep track of user variables.
1565 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1567 // Variable is in a register, we need to check for clobbers.
1568 if (isDbgValueInDefinedReg(MI))
1569 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1571 // Check the history of this variable.
1572 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1573 if (History.empty()) {
1574 UserVariables.push_back(Var);
1575 // The first mention of a function argument gets the FunctionBeginSym
1576 // label, so arguments are visible when breaking at function entry.
1578 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1579 DISubprogram(getDISubprogram(DV.getContext()))
1580 .describes(MF->getFunction()))
1581 LabelsBeforeInsn[MI] = FunctionBeginSym;
1583 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1584 const MachineInstr *Prev = History.back();
1585 if (Prev->isDebugValue()) {
1586 // Coalesce identical entries at the end of History.
1587 if (History.size() >= 2 &&
1588 Prev->isIdenticalTo(History[History.size() - 2])) {
1589 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1591 << "\t" << *History[History.size() - 2] << "\n");
1595 // Terminate old register assignments that don't reach MI;
1596 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1597 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1598 isDbgValueInDefinedReg(Prev)) {
1599 // Previous register assignment needs to terminate at the end of
1601 MachineBasicBlock::const_iterator LastMI =
1602 PrevMBB->getLastNonDebugInstr();
1603 if (LastMI == PrevMBB->end()) {
1604 // Drop DBG_VALUE for empty range.
1605 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1606 << "\t" << *Prev << "\n");
1608 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1609 // Terminate after LastMI.
1610 History.push_back(LastMI);
1614 History.push_back(MI);
1616 // Not a DBG_VALUE instruction.
1618 AtBlockEntry = false;
1620 // First known non-DBG_VALUE and non-frame setup location marks
1621 // the beginning of the function body.
1622 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1623 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1624 PrologEndLoc = MI->getDebugLoc();
1626 // Check if the instruction clobbers any registers with debug vars.
1627 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1628 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1629 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1631 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1632 AI.isValid(); ++AI) {
1634 const MDNode *Var = LiveUserVar[Reg];
1637 // Reg is now clobbered.
1638 LiveUserVar[Reg] = 0;
1640 // Was MD last defined by a DBG_VALUE referring to Reg?
1641 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1642 if (HistI == DbgValues.end())
1644 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1645 if (History.empty())
1647 const MachineInstr *Prev = History.back();
1648 // Sanity-check: Register assignments are terminated at the end of
1650 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1652 // Is the variable still in Reg?
1653 if (!isDbgValueInDefinedReg(Prev) ||
1654 Prev->getOperand(0).getReg() != Reg)
1656 // Var is clobbered. Make sure the next instruction gets a label.
1657 History.push_back(MI);
1664 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1666 SmallVectorImpl<const MachineInstr*> &History = I->second;
1667 if (History.empty())
1670 // Make sure the final register assignments are terminated.
1671 const MachineInstr *Prev = History.back();
1672 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1673 const MachineBasicBlock *PrevMBB = Prev->getParent();
1674 MachineBasicBlock::const_iterator LastMI =
1675 PrevMBB->getLastNonDebugInstr();
1676 if (LastMI == PrevMBB->end())
1677 // Drop DBG_VALUE for empty range.
1679 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1680 // Terminate after LastMI.
1681 History.push_back(LastMI);
1684 // Request labels for the full history.
1685 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1686 const MachineInstr *MI = History[i];
1687 if (MI->isDebugValue())
1688 requestLabelBeforeInsn(MI);
1690 requestLabelAfterInsn(MI);
1694 PrevInstLoc = DebugLoc();
1695 PrevLabel = FunctionBeginSym;
1697 // Record beginning of function.
1698 if (!PrologEndLoc.isUnknown()) {
1699 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1700 MF->getFunction()->getContext());
1701 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1702 FnStartDL.getScope(MF->getFunction()->getContext()),
1703 // We'd like to list the prologue as "not statements" but GDB behaves
1704 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1705 DWARF2_FLAG_IS_STMT);
1709 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1710 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1711 DIVariable DV = Var->getVariable();
1712 // Variables with positive arg numbers are parameters.
1713 if (unsigned ArgNum = DV.getArgNumber()) {
1714 // Keep all parameters in order at the start of the variable list to ensure
1715 // function types are correct (no out-of-order parameters)
1717 // This could be improved by only doing it for optimized builds (unoptimized
1718 // builds have the right order to begin with), searching from the back (this
1719 // would catch the unoptimized case quickly), or doing a binary search
1720 // rather than linear search.
1721 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1722 while (I != Vars.end()) {
1723 unsigned CurNum = (*I)->getVariable().getArgNumber();
1724 // A local (non-parameter) variable has been found, insert immediately
1728 // A later indexed parameter has been found, insert immediately before it.
1729 if (CurNum > ArgNum)
1733 Vars.insert(I, Var);
1737 Vars.push_back(Var);
1740 // Gather and emit post-function debug information.
1741 void DwarfDebug::endFunction(const MachineFunction *MF) {
1742 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1744 // Define end label for subprogram.
1745 FunctionEndSym = Asm->GetTempSymbol("func_end",
1746 Asm->getFunctionNumber());
1747 // Assumes in correct section after the entry point.
1748 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1749 // Set DwarfCompileUnitID in MCContext to default value.
1750 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1752 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1753 collectVariableInfo(MF, ProcessedVars);
1755 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1756 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1757 assert(TheCU && "Unable to find compile unit!");
1759 // Construct abstract scopes.
1760 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1761 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1762 LexicalScope *AScope = AList[i];
1763 DISubprogram SP(AScope->getScopeNode());
1764 if (SP.isSubprogram()) {
1765 // Collect info for variables that were optimized out.
1766 DIArray Variables = SP.getVariables();
1767 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1768 DIVariable DV(Variables.getElement(i));
1769 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1771 // Check that DbgVariable for DV wasn't created earlier, when
1772 // findAbstractVariable() was called for inlined instance of DV.
1773 LLVMContext &Ctx = DV->getContext();
1774 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1775 if (AbstractVariables.lookup(CleanDV))
1777 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1778 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1781 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1782 constructScopeDIE(TheCU, AScope);
1785 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1787 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1788 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1791 for (ScopeVariablesMap::iterator
1792 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1793 DeleteContainerPointers(I->second);
1794 ScopeVariables.clear();
1795 DeleteContainerPointers(CurrentFnArguments);
1796 UserVariables.clear();
1798 AbstractVariables.clear();
1799 LabelsBeforeInsn.clear();
1800 LabelsAfterInsn.clear();
1804 // Register a source line with debug info. Returns the unique label that was
1805 // emitted and which provides correspondence to the source line list.
1806 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1812 DIDescriptor Scope(S);
1814 if (Scope.isCompileUnit()) {
1815 DICompileUnit CU(S);
1816 Fn = CU.getFilename();
1817 Dir = CU.getDirectory();
1818 } else if (Scope.isFile()) {
1820 Fn = F.getFilename();
1821 Dir = F.getDirectory();
1822 } else if (Scope.isSubprogram()) {
1824 Fn = SP.getFilename();
1825 Dir = SP.getDirectory();
1826 } else if (Scope.isLexicalBlockFile()) {
1827 DILexicalBlockFile DBF(S);
1828 Fn = DBF.getFilename();
1829 Dir = DBF.getDirectory();
1830 } else if (Scope.isLexicalBlock()) {
1831 DILexicalBlock DB(S);
1832 Fn = DB.getFilename();
1833 Dir = DB.getDirectory();
1835 llvm_unreachable("Unexpected scope info");
1837 Src = getOrCreateSourceID(Fn, Dir,
1838 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1840 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1843 //===----------------------------------------------------------------------===//
1845 //===----------------------------------------------------------------------===//
1847 // Compute the size and offset of a DIE.
1849 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1850 // Get the children.
1851 const std::vector<DIE *> &Children = Die->getChildren();
1853 // Record the abbreviation.
1854 assignAbbrevNumber(Die->getAbbrev());
1856 // Get the abbreviation for this DIE.
1857 unsigned AbbrevNumber = Die->getAbbrevNumber();
1858 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1861 Die->setOffset(Offset);
1863 // Start the size with the size of abbreviation code.
1864 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1866 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1867 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1869 // Size the DIE attribute values.
1870 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1871 // Size attribute value.
1872 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1874 // Size the DIE children if any.
1875 if (!Children.empty()) {
1876 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1877 "Children flag not set");
1879 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1880 Offset = computeSizeAndOffset(Children[j], Offset);
1882 // End of children marker.
1883 Offset += sizeof(int8_t);
1886 Die->setSize(Offset - Die->getOffset());
1890 // Compute the size and offset of all the DIEs.
1891 void DwarfUnits::computeSizeAndOffsets() {
1892 // Offset from the beginning of debug info section.
1893 unsigned SecOffset = 0;
1894 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1895 E = CUs.end(); I != E; ++I) {
1896 (*I)->setDebugInfoOffset(SecOffset);
1898 sizeof(int32_t) + // Length of Compilation Unit Info
1899 sizeof(int16_t) + // DWARF version number
1900 sizeof(int32_t) + // Offset Into Abbrev. Section
1901 sizeof(int8_t); // Pointer Size (in bytes)
1903 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1904 SecOffset += EndOffset;
1908 // Emit initial Dwarf sections with a label at the start of each one.
1909 void DwarfDebug::emitSectionLabels() {
1910 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1912 // Dwarf sections base addresses.
1913 DwarfInfoSectionSym =
1914 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1915 DwarfAbbrevSectionSym =
1916 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1917 if (useSplitDwarf())
1918 DwarfAbbrevDWOSectionSym =
1919 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1920 "section_abbrev_dwo");
1921 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1923 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1924 emitSectionSym(Asm, MacroInfo);
1926 DwarfLineSectionSym =
1927 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1928 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1929 if (HasDwarfPubSections)
1930 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1931 if (useDarwinGDBCompat() || HasDwarfPubSections)
1932 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1933 DwarfStrSectionSym =
1934 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1935 if (useSplitDwarf()) {
1936 DwarfStrDWOSectionSym =
1937 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1938 DwarfAddrSectionSym =
1939 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1941 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1944 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1945 "section_debug_loc");
1947 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1948 emitSectionSym(Asm, TLOF.getDataSection());
1951 // Recursively emits a debug information entry.
1952 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1953 // Get the abbreviation for this DIE.
1954 unsigned AbbrevNumber = Die->getAbbrevNumber();
1955 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1957 // Emit the code (index) for the abbreviation.
1958 if (Asm->isVerbose())
1959 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1960 Twine::utohexstr(Die->getOffset()) + ":0x" +
1961 Twine::utohexstr(Die->getSize()) + " " +
1962 dwarf::TagString(Abbrev->getTag()));
1963 Asm->EmitULEB128(AbbrevNumber);
1965 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1966 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1968 // Emit the DIE attribute values.
1969 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1970 unsigned Attr = AbbrevData[i].getAttribute();
1971 unsigned Form = AbbrevData[i].getForm();
1972 assert(Form && "Too many attributes for DIE (check abbreviation)");
1974 if (Asm->isVerbose())
1975 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1978 case dwarf::DW_AT_abstract_origin: {
1979 DIEEntry *E = cast<DIEEntry>(Values[i]);
1980 DIE *Origin = E->getEntry();
1981 unsigned Addr = Origin->getOffset();
1982 if (Form == dwarf::DW_FORM_ref_addr) {
1983 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1984 // section. Origin->getOffset() returns the offset from start of the
1986 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1987 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1989 Asm->OutStreamer.EmitIntValue(Addr,
1990 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
1993 case dwarf::DW_AT_ranges: {
1994 // DW_AT_range Value encodes offset in debug_range section.
1995 DIEInteger *V = cast<DIEInteger>(Values[i]);
1997 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1998 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2002 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2004 DwarfDebugRangeSectionSym,
2009 case dwarf::DW_AT_location: {
2010 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2011 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2012 Asm->EmitLabelReference(L->getValue(), 4);
2014 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2016 Values[i]->EmitValue(Asm, Form);
2020 case dwarf::DW_AT_accessibility: {
2021 if (Asm->isVerbose()) {
2022 DIEInteger *V = cast<DIEInteger>(Values[i]);
2023 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2025 Values[i]->EmitValue(Asm, Form);
2029 // Emit an attribute using the defined form.
2030 Values[i]->EmitValue(Asm, Form);
2035 // Emit the DIE children if any.
2036 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2037 const std::vector<DIE *> &Children = Die->getChildren();
2039 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2040 emitDIE(Children[j], Abbrevs);
2042 if (Asm->isVerbose())
2043 Asm->OutStreamer.AddComment("End Of Children Mark");
2048 // Emit the various dwarf units to the unit section USection with
2049 // the abbreviations going into ASection.
2050 void DwarfUnits::emitUnits(DwarfDebug *DD,
2051 const MCSection *USection,
2052 const MCSection *ASection,
2053 const MCSymbol *ASectionSym) {
2054 Asm->OutStreamer.SwitchSection(USection);
2055 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2056 E = CUs.end(); I != E; ++I) {
2057 CompileUnit *TheCU = *I;
2058 DIE *Die = TheCU->getCUDie();
2060 // Emit the compile units header.
2062 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2063 TheCU->getUniqueID()));
2065 // Emit size of content not including length itself
2066 unsigned ContentSize = Die->getSize() +
2067 sizeof(int16_t) + // DWARF version number
2068 sizeof(int32_t) + // Offset Into Abbrev. Section
2069 sizeof(int8_t); // Pointer Size (in bytes)
2071 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2072 Asm->EmitInt32(ContentSize);
2073 Asm->OutStreamer.AddComment("DWARF version number");
2074 Asm->EmitInt16(DD->getDwarfVersion());
2075 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2076 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2078 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2079 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2081 DD->emitDIE(Die, Abbreviations);
2082 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2083 TheCU->getUniqueID()));
2087 /// For a given compile unit DIE, returns offset from beginning of debug info.
2088 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2089 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2090 "Input DIE should be compile unit in getCUOffset.");
2091 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2093 CompileUnit *TheCU = *I;
2094 if (TheCU->getCUDie() == Die)
2095 return TheCU->getDebugInfoOffset();
2097 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2100 // Emit the debug info section.
2101 void DwarfDebug::emitDebugInfo() {
2102 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2104 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2105 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2106 DwarfAbbrevSectionSym);
2109 // Emit the abbreviation section.
2110 void DwarfDebug::emitAbbreviations() {
2111 if (!useSplitDwarf())
2112 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2115 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2118 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2119 std::vector<DIEAbbrev *> *Abbrevs) {
2120 // Check to see if it is worth the effort.
2121 if (!Abbrevs->empty()) {
2122 // Start the debug abbrev section.
2123 Asm->OutStreamer.SwitchSection(Section);
2125 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2126 Asm->OutStreamer.EmitLabel(Begin);
2128 // For each abbrevation.
2129 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2130 // Get abbreviation data
2131 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2133 // Emit the abbrevations code (base 1 index.)
2134 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2136 // Emit the abbreviations data.
2140 // Mark end of abbreviations.
2141 Asm->EmitULEB128(0, "EOM(3)");
2143 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2144 Asm->OutStreamer.EmitLabel(End);
2148 // Emit the last address of the section and the end of the line matrix.
2149 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2150 // Define last address of section.
2151 Asm->OutStreamer.AddComment("Extended Op");
2154 Asm->OutStreamer.AddComment("Op size");
2155 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2156 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2157 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2159 Asm->OutStreamer.AddComment("Section end label");
2161 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2162 Asm->getDataLayout().getPointerSize());
2164 // Mark end of matrix.
2165 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2171 // Emit visible names into a hashed accelerator table section.
2172 void DwarfDebug::emitAccelNames() {
2173 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2174 dwarf::DW_FORM_data4));
2175 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2176 E = CUMap.end(); I != E; ++I) {
2177 CompileUnit *TheCU = I->second;
2178 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2179 for (StringMap<std::vector<DIE*> >::const_iterator
2180 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2181 StringRef Name = GI->getKey();
2182 const std::vector<DIE *> &Entities = GI->second;
2183 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2184 DE = Entities.end(); DI != DE; ++DI)
2185 AT.AddName(Name, (*DI));
2189 AT.FinalizeTable(Asm, "Names");
2190 Asm->OutStreamer.SwitchSection(
2191 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2192 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2193 Asm->OutStreamer.EmitLabel(SectionBegin);
2195 // Emit the full data.
2196 AT.Emit(Asm, SectionBegin, &InfoHolder);
2199 // Emit objective C classes and categories into a hashed accelerator table
2201 void DwarfDebug::emitAccelObjC() {
2202 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2203 dwarf::DW_FORM_data4));
2204 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2205 E = CUMap.end(); I != E; ++I) {
2206 CompileUnit *TheCU = I->second;
2207 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2208 for (StringMap<std::vector<DIE*> >::const_iterator
2209 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2210 StringRef Name = GI->getKey();
2211 const std::vector<DIE *> &Entities = GI->second;
2212 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2213 DE = Entities.end(); DI != DE; ++DI)
2214 AT.AddName(Name, (*DI));
2218 AT.FinalizeTable(Asm, "ObjC");
2219 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2220 .getDwarfAccelObjCSection());
2221 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2222 Asm->OutStreamer.EmitLabel(SectionBegin);
2224 // Emit the full data.
2225 AT.Emit(Asm, SectionBegin, &InfoHolder);
2228 // Emit namespace dies into a hashed accelerator table.
2229 void DwarfDebug::emitAccelNamespaces() {
2230 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2231 dwarf::DW_FORM_data4));
2232 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2233 E = CUMap.end(); I != E; ++I) {
2234 CompileUnit *TheCU = I->second;
2235 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2236 for (StringMap<std::vector<DIE*> >::const_iterator
2237 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2238 StringRef Name = GI->getKey();
2239 const std::vector<DIE *> &Entities = GI->second;
2240 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2241 DE = Entities.end(); DI != DE; ++DI)
2242 AT.AddName(Name, (*DI));
2246 AT.FinalizeTable(Asm, "namespac");
2247 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2248 .getDwarfAccelNamespaceSection());
2249 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2250 Asm->OutStreamer.EmitLabel(SectionBegin);
2252 // Emit the full data.
2253 AT.Emit(Asm, SectionBegin, &InfoHolder);
2256 // Emit type dies into a hashed accelerator table.
2257 void DwarfDebug::emitAccelTypes() {
2258 std::vector<DwarfAccelTable::Atom> Atoms;
2259 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2260 dwarf::DW_FORM_data4));
2261 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2262 dwarf::DW_FORM_data2));
2263 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2264 dwarf::DW_FORM_data1));
2265 DwarfAccelTable AT(Atoms);
2266 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2267 E = CUMap.end(); I != E; ++I) {
2268 CompileUnit *TheCU = I->second;
2269 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2270 = TheCU->getAccelTypes();
2271 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2272 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2273 StringRef Name = GI->getKey();
2274 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2275 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2276 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2277 AT.AddName(Name, (*DI).first, (*DI).second);
2281 AT.FinalizeTable(Asm, "types");
2282 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2283 .getDwarfAccelTypesSection());
2284 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2285 Asm->OutStreamer.EmitLabel(SectionBegin);
2287 // Emit the full data.
2288 AT.Emit(Asm, SectionBegin, &InfoHolder);
2291 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2293 void DwarfDebug::emitDebugPubnames() {
2294 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2296 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2297 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2298 CompileUnit *TheCU = I->second;
2299 unsigned ID = TheCU->getUniqueID();
2301 if (TheCU->getGlobalNames().empty())
2304 // Start the dwarf pubnames section.
2306 .SwitchSection(Asm->getObjFileLowering().getDwarfPubNamesSection());
2308 Asm->OutStreamer.AddComment("Length of Public Names Info");
2309 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2310 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2312 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2314 Asm->OutStreamer.AddComment("DWARF Version");
2315 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2317 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2318 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2319 DwarfInfoSectionSym);
2321 Asm->OutStreamer.AddComment("Compilation Unit Length");
2322 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2323 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2326 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2327 for (StringMap<DIE*>::const_iterator
2328 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2329 const char *Name = GI->getKeyData();
2330 const DIE *Entity = GI->second;
2332 Asm->OutStreamer.AddComment("DIE offset");
2333 Asm->EmitInt32(Entity->getOffset());
2335 if (Asm->isVerbose())
2336 Asm->OutStreamer.AddComment("External Name");
2337 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2340 Asm->OutStreamer.AddComment("End Mark");
2342 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2346 void DwarfDebug::emitDebugPubTypes() {
2347 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2348 E = CUMap.end(); I != E; ++I) {
2349 CompileUnit *TheCU = I->second;
2350 // Start the dwarf pubtypes section.
2351 Asm->OutStreamer.SwitchSection(
2352 Asm->getObjFileLowering().getDwarfPubTypesSection());
2353 Asm->OutStreamer.AddComment("Length of Public Types Info");
2354 Asm->EmitLabelDifference(
2355 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2356 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2358 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2359 TheCU->getUniqueID()));
2361 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2362 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2364 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2365 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2366 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2367 TheCU->getUniqueID()),
2368 DwarfInfoSectionSym);
2370 Asm->OutStreamer.AddComment("Compilation Unit Length");
2371 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2372 TheCU->getUniqueID()),
2373 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2374 TheCU->getUniqueID()),
2377 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2378 for (StringMap<DIE*>::const_iterator
2379 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2380 const char *Name = GI->getKeyData();
2381 DIE *Entity = GI->second;
2383 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2384 Asm->EmitInt32(Entity->getOffset());
2386 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2387 // Emit the name with a terminating null byte.
2388 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2391 Asm->OutStreamer.AddComment("End Mark");
2393 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2394 TheCU->getUniqueID()));
2398 // Emit strings into a string section.
2399 void DwarfUnits::emitStrings(const MCSection *StrSection,
2400 const MCSection *OffsetSection = NULL,
2401 const MCSymbol *StrSecSym = NULL) {
2403 if (StringPool.empty()) return;
2405 // Start the dwarf str section.
2406 Asm->OutStreamer.SwitchSection(StrSection);
2408 // Get all of the string pool entries and put them in an array by their ID so
2409 // we can sort them.
2410 SmallVector<std::pair<unsigned,
2411 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2413 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2414 I = StringPool.begin(), E = StringPool.end();
2416 Entries.push_back(std::make_pair(I->second.second, &*I));
2418 array_pod_sort(Entries.begin(), Entries.end());
2420 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2421 // Emit a label for reference from debug information entries.
2422 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2424 // Emit the string itself with a terminating null byte.
2425 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2426 Entries[i].second->getKeyLength()+1));
2429 // If we've got an offset section go ahead and emit that now as well.
2430 if (OffsetSection) {
2431 Asm->OutStreamer.SwitchSection(OffsetSection);
2432 unsigned offset = 0;
2433 unsigned size = 4; // FIXME: DWARF64 is 8.
2434 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2435 Asm->OutStreamer.EmitIntValue(offset, size);
2436 offset += Entries[i].second->getKeyLength() + 1;
2441 // Emit strings into a string section.
2442 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2444 if (AddressPool.empty()) return;
2446 // Start the dwarf addr section.
2447 Asm->OutStreamer.SwitchSection(AddrSection);
2449 // Order the address pool entries by ID
2450 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2452 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2453 E = AddressPool.end();
2455 Entries[I->second] = I->first;
2457 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2458 // Emit an expression for reference from debug information entries.
2459 if (const MCExpr *Expr = Entries[i])
2460 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2462 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2467 // Emit visible names into a debug str section.
2468 void DwarfDebug::emitDebugStr() {
2469 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2470 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2473 // Emit locations into the debug loc section.
2474 void DwarfDebug::emitDebugLoc() {
2475 if (DotDebugLocEntries.empty())
2478 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2479 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2481 DotDebugLocEntry &Entry = *I;
2482 if (I + 1 != DotDebugLocEntries.end())
2486 // Start the dwarf loc section.
2487 Asm->OutStreamer.SwitchSection(
2488 Asm->getObjFileLowering().getDwarfLocSection());
2489 unsigned char Size = Asm->getDataLayout().getPointerSize();
2490 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2492 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2493 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2494 I != E; ++I, ++index) {
2495 DotDebugLocEntry &Entry = *I;
2496 if (Entry.isMerged()) continue;
2497 if (Entry.isEmpty()) {
2498 Asm->OutStreamer.EmitIntValue(0, Size);
2499 Asm->OutStreamer.EmitIntValue(0, Size);
2500 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2502 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2503 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2504 DIVariable DV(Entry.getVariable());
2505 Asm->OutStreamer.AddComment("Loc expr size");
2506 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2507 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2508 Asm->EmitLabelDifference(end, begin, 2);
2509 Asm->OutStreamer.EmitLabel(begin);
2510 if (Entry.isInt()) {
2511 DIBasicType BTy(DV.getType());
2513 (BTy.getEncoding() == dwarf::DW_ATE_signed
2514 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2515 Asm->OutStreamer.AddComment("DW_OP_consts");
2516 Asm->EmitInt8(dwarf::DW_OP_consts);
2517 Asm->EmitSLEB128(Entry.getInt());
2519 Asm->OutStreamer.AddComment("DW_OP_constu");
2520 Asm->EmitInt8(dwarf::DW_OP_constu);
2521 Asm->EmitULEB128(Entry.getInt());
2523 } else if (Entry.isLocation()) {
2524 MachineLocation Loc = Entry.getLoc();
2525 if (!DV.hasComplexAddress())
2527 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2529 // Complex address entry.
2530 unsigned N = DV.getNumAddrElements();
2532 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2533 if (Loc.getOffset()) {
2535 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2536 Asm->OutStreamer.AddComment("DW_OP_deref");
2537 Asm->EmitInt8(dwarf::DW_OP_deref);
2538 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2539 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2540 Asm->EmitSLEB128(DV.getAddrElement(1));
2542 // If first address element is OpPlus then emit
2543 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2544 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2545 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2549 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2552 // Emit remaining complex address elements.
2553 for (; i < N; ++i) {
2554 uint64_t Element = DV.getAddrElement(i);
2555 if (Element == DIBuilder::OpPlus) {
2556 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2557 Asm->EmitULEB128(DV.getAddrElement(++i));
2558 } else if (Element == DIBuilder::OpDeref) {
2560 Asm->EmitInt8(dwarf::DW_OP_deref);
2562 llvm_unreachable("unknown Opcode found in complex address");
2566 // else ... ignore constant fp. There is not any good way to
2567 // to represent them here in dwarf.
2568 Asm->OutStreamer.EmitLabel(end);
2573 // Emit visible names into a debug aranges section.
2574 void DwarfDebug::emitDebugARanges() {
2575 // Start the dwarf aranges section.
2576 Asm->OutStreamer.SwitchSection(
2577 Asm->getObjFileLowering().getDwarfARangesSection());
2580 // Emit visible names into a debug ranges section.
2581 void DwarfDebug::emitDebugRanges() {
2582 // Start the dwarf ranges section.
2583 Asm->OutStreamer.SwitchSection(
2584 Asm->getObjFileLowering().getDwarfRangesSection());
2585 unsigned char Size = Asm->getDataLayout().getPointerSize();
2586 for (SmallVectorImpl<const MCSymbol *>::iterator
2587 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2590 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2592 Asm->OutStreamer.EmitIntValue(0, Size);
2596 // Emit visible names into a debug macinfo section.
2597 void DwarfDebug::emitDebugMacInfo() {
2598 if (const MCSection *LineInfo =
2599 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2600 // Start the dwarf macinfo section.
2601 Asm->OutStreamer.SwitchSection(LineInfo);
2605 // Emit inline info using following format.
2607 // 1. length of section
2608 // 2. Dwarf version number
2611 // Entries (one "entry" for each function that was inlined):
2613 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2614 // otherwise offset into __debug_str for regular function name.
2615 // 2. offset into __debug_str section for regular function name.
2616 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2617 // instances for the function.
2619 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2620 // inlined instance; the die_offset points to the inlined_subroutine die in the
2621 // __debug_info section, and the low_pc is the starting address for the
2622 // inlining instance.
2623 void DwarfDebug::emitDebugInlineInfo() {
2624 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2630 Asm->OutStreamer.SwitchSection(
2631 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2633 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2634 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2635 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2637 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2639 Asm->OutStreamer.AddComment("Dwarf Version");
2640 Asm->EmitInt16(DwarfVersion);
2641 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2642 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2644 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2645 E = InlinedSPNodes.end(); I != E; ++I) {
2647 const MDNode *Node = *I;
2648 InlineInfoMap::iterator II = InlineInfo.find(Node);
2649 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2650 DISubprogram SP(Node);
2651 StringRef LName = SP.getLinkageName();
2652 StringRef Name = SP.getName();
2654 Asm->OutStreamer.AddComment("MIPS linkage name");
2656 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2657 DwarfStrSectionSym);
2659 Asm->EmitSectionOffset(
2660 InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2661 DwarfStrSectionSym);
2663 Asm->OutStreamer.AddComment("Function name");
2664 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2665 DwarfStrSectionSym);
2666 Asm->EmitULEB128(Labels.size(), "Inline count");
2668 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2669 LE = Labels.end(); LI != LE; ++LI) {
2670 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2671 Asm->EmitInt32(LI->second->getOffset());
2673 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2674 Asm->OutStreamer.EmitSymbolValue(LI->first,
2675 Asm->getDataLayout().getPointerSize());
2679 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2682 // DWARF5 Experimental Separate Dwarf emitters.
2684 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2685 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2686 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2687 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2688 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2689 DICompileUnit DIUnit(N);
2690 CompilationDir = DIUnit.getDirectory();
2692 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2693 CompileUnit *NewCU =
2694 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &SkeletonHolder);
2696 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2697 DIUnit.getSplitDebugFilename());
2699 // Relocate to the beginning of the addr_base section, else 0 for the
2700 // beginning of the one for this compile unit.
2701 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2702 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2703 DwarfAddrSectionSym);
2705 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2706 dwarf::DW_FORM_sec_offset, 0);
2708 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2709 // into an entity. We're using 0, or a NULL label for this.
2710 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2712 // DW_AT_stmt_list is a offset of line number information for this
2713 // compile unit in debug_line section.
2714 // FIXME: Should handle multiple compile units.
2715 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2716 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2717 DwarfLineSectionSym);
2719 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2721 if (!CompilationDir.empty())
2722 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2724 SkeletonHolder.addUnit(NewCU);
2725 SkeletonCUs.push_back(NewCU);
2730 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2731 assert(useSplitDwarf() && "No split dwarf debug info?");
2732 emitAbbrevs(Section, &SkeletonAbbrevs);
2735 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2736 // compile units that would normally be in debug_info.
2737 void DwarfDebug::emitDebugInfoDWO() {
2738 assert(useSplitDwarf() && "No split dwarf debug info?");
2739 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2740 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2741 DwarfAbbrevDWOSectionSym);
2744 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2745 // abbreviations for the .debug_info.dwo section.
2746 void DwarfDebug::emitDebugAbbrevDWO() {
2747 assert(useSplitDwarf() && "No split dwarf?");
2748 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2752 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2753 // string section and is identical in format to traditional .debug_str
2755 void DwarfDebug::emitDebugStrDWO() {
2756 assert(useSplitDwarf() && "No split dwarf?");
2757 const MCSection *OffSec = Asm->getObjFileLowering()
2758 .getDwarfStrOffDWOSection();
2759 const MCSymbol *StrSym = DwarfStrSectionSym;
2760 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),