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 DwarfPubNames("generate-dwarf-pubnames", cl::Hidden,
105 cl::desc("Generate DWARF pubnames section"),
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 (DwarfPubNames == Default)
221 HasDwarfPubNames = !IsDarwin;
223 HasDwarfPubNames = DwarfPubNames == 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);
699 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
700 DIUnit.getLanguage(), Die, N, Asm,
703 FileIDCUMap[NewCU->getUniqueID()] = 0;
704 // Call this to emit a .file directive if it wasn't emitted for the source
705 // file this CU comes from yet.
706 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
708 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
709 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
710 DIUnit.getLanguage());
711 NewCU->addString(Die, dwarf::DW_AT_name, FN);
713 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
714 // into an entity. We're using 0 (or a NULL label) for this. For
715 // split dwarf it's in the skeleton CU so omit it here.
716 if (!useSplitDwarf())
717 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
719 // Define start line table label for each Compile Unit.
720 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
721 NewCU->getUniqueID());
722 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
723 NewCU->getUniqueID());
725 // Use a single line table if we are using .loc and generating assembly.
727 (Asm->TM.hasMCUseLoc() &&
728 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
729 (NewCU->getUniqueID() == 0);
731 // DW_AT_stmt_list is a offset of line number information for this
732 // compile unit in debug_line section. For split dwarf this is
733 // left in the skeleton CU and so not included.
734 // The line table entries are not always emitted in assembly, so it
735 // is not okay to use line_table_start here.
736 if (!useSplitDwarf()) {
737 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
738 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
740 Asm->GetTempSymbol("section_line") : LineTableStartSym);
741 else if (UseTheFirstCU)
742 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
744 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
745 LineTableStartSym, DwarfLineSectionSym);
748 // If we're using split dwarf the compilation dir is going to be in the
749 // skeleton CU and so we don't need to duplicate it here.
750 if (!useSplitDwarf() && !CompilationDir.empty())
751 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
752 if (DIUnit.isOptimized())
753 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
755 StringRef Flags = DIUnit.getFlags();
757 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
759 if (unsigned RVer = DIUnit.getRunTimeVersion())
760 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
761 dwarf::DW_FORM_data1, RVer);
766 InfoHolder.addUnit(NewCU);
768 CUMap.insert(std::make_pair(N, NewCU));
772 // Construct subprogram DIE.
773 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
775 CompileUnit *&CURef = SPMap[N];
781 if (!SP.isDefinition())
782 // This is a method declaration which will be handled while constructing
786 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
789 TheCU->insertDIE(N, SubprogramDie);
791 // Add to context owner.
792 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
794 // Expose as global, if requested.
795 if (HasDwarfPubNames)
796 TheCU->addGlobalName(SP.getName(), SubprogramDie);
799 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
801 DIImportedEntity Module(N);
802 if (!Module.Verify())
804 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
805 constructImportedEntityDIE(TheCU, Module, D);
808 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
810 DIImportedEntity Module(N);
811 if (!Module.Verify())
813 return constructImportedEntityDIE(TheCU, Module, Context);
816 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
817 const DIImportedEntity &Module,
819 assert(Module.Verify() &&
820 "Use one of the MDNode * overloads to handle invalid metadata");
821 assert(Context && "Should always have a context for an imported_module");
822 DIE *IMDie = new DIE(Module.getTag());
823 TheCU->insertDIE(Module, IMDie);
825 DIDescriptor Entity = Module.getEntity();
826 if (Entity.isNameSpace())
827 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
828 else if (Entity.isSubprogram())
829 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
830 else if (Entity.isType())
831 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
833 EntityDie = TheCU->getDIE(Entity);
834 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
835 Module.getContext().getDirectory(),
836 TheCU->getUniqueID());
837 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
838 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
839 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
841 StringRef Name = Module.getName();
843 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
844 Context->addChild(IMDie);
847 // Emit all Dwarf sections that should come prior to the content. Create
848 // global DIEs and emit initial debug info sections. This is invoked by
849 // the target AsmPrinter.
850 void DwarfDebug::beginModule() {
851 if (DisableDebugInfoPrinting)
854 const Module *M = MMI->getModule();
856 // If module has named metadata anchors then use them, otherwise scan the
857 // module using debug info finder to collect debug info.
858 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
862 // Emit initial sections so we can reference labels later.
865 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
866 DICompileUnit CUNode(CU_Nodes->getOperand(i));
867 CompileUnit *CU = constructCompileUnit(CUNode);
868 DIArray ImportedEntities = CUNode.getImportedEntities();
869 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
870 ScopesWithImportedEntities.push_back(std::make_pair(
871 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
872 ImportedEntities.getElement(i)));
873 std::sort(ScopesWithImportedEntities.begin(),
874 ScopesWithImportedEntities.end(), less_first());
875 DIArray GVs = CUNode.getGlobalVariables();
876 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
877 CU->createGlobalVariableDIE(GVs.getElement(i));
878 DIArray SPs = CUNode.getSubprograms();
879 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
880 constructSubprogramDIE(CU, SPs.getElement(i));
881 DIArray EnumTypes = CUNode.getEnumTypes();
882 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
883 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
884 DIArray RetainedTypes = CUNode.getRetainedTypes();
885 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
886 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
887 // Emit imported_modules last so that the relevant context is already
889 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
890 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
893 // Tell MMI that we have debug info.
894 MMI->setDebugInfoAvailability(true);
896 // Prime section data.
897 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
900 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
901 void DwarfDebug::computeInlinedDIEs() {
902 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
903 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
904 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
906 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
908 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
909 AE = AbstractSPDies.end(); AI != AE; ++AI) {
910 DIE *ISP = AI->second;
911 if (InlinedSubprogramDIEs.count(ISP))
913 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
917 // Collect info for variables that were optimized out.
918 void DwarfDebug::collectDeadVariables() {
919 const Module *M = MMI->getModule();
920 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
922 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
923 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
924 DICompileUnit TheCU(CU_Nodes->getOperand(i));
925 DIArray Subprograms = TheCU.getSubprograms();
926 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
927 DISubprogram SP(Subprograms.getElement(i));
928 if (ProcessedSPNodes.count(SP) != 0) continue;
929 if (!SP.isSubprogram()) continue;
930 if (!SP.isDefinition()) continue;
931 DIArray Variables = SP.getVariables();
932 if (Variables.getNumElements() == 0) continue;
934 LexicalScope *Scope =
935 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
936 DeadFnScopeMap[SP] = Scope;
938 // Construct subprogram DIE and add variables DIEs.
939 CompileUnit *SPCU = CUMap.lookup(TheCU);
940 assert(SPCU && "Unable to find Compile Unit!");
941 constructSubprogramDIE(SPCU, SP);
942 DIE *ScopeDIE = SPCU->getDIE(SP);
943 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
944 DIVariable DV(Variables.getElement(vi));
945 if (!DV.isVariable()) continue;
946 DbgVariable NewVar(DV, NULL);
947 if (DIE *VariableDIE =
948 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
949 ScopeDIE->addChild(VariableDIE);
954 DeleteContainerSeconds(DeadFnScopeMap);
957 // Type Signature [7.27] and ODR Hash code.
959 /// \brief Grabs the string in whichever attribute is passed in and returns
960 /// a reference to it. Returns "" if the attribute doesn't exist.
961 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
962 DIEValue *V = Die->findAttribute(Attr);
964 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
965 return S->getString();
967 return StringRef("");
970 /// Return true if the current DIE is contained within an anonymous namespace.
971 static bool isContainedInAnonNamespace(DIE *Die) {
972 DIE *Parent = Die->getParent();
975 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
976 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
978 Parent = Parent->getParent();
984 /// Test if the current CU language is C++ and that we have
985 /// a named type that is not contained in an anonymous namespace.
986 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
987 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
988 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
989 !isContainedInAnonNamespace(Die);
992 void DwarfDebug::finalizeModuleInfo() {
993 // Collect info for variables that were optimized out.
994 collectDeadVariables();
996 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
997 computeInlinedDIEs();
999 // Split out type units and conditionally add an ODR tag to the split
1001 // FIXME: Do type splitting.
1002 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1003 DIE *Die = TypeUnits[i];
1005 // If we've requested ODR hashes and it's applicable for an ODR hash then
1006 // add the ODR signature now.
1007 // FIXME: This should be added onto the type unit, not the type, but this
1008 // works as an intermediate stage.
1009 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1010 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1011 dwarf::DW_FORM_data8,
1012 Hash.computeDIEODRSignature(Die));
1015 // Handle anything that needs to be done on a per-cu basis.
1016 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1018 CUI != CUE; ++CUI) {
1019 CompileUnit *TheCU = CUI->second;
1020 // Emit DW_AT_containing_type attribute to connect types with their
1021 // vtable holding type.
1022 TheCU->constructContainingTypeDIEs();
1024 // If we're splitting the dwarf out now that we've got the entire
1025 // CU then construct a skeleton CU based upon it.
1026 if (useSplitDwarf()) {
1028 if (GenerateCUHash) {
1030 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1032 // This should be a unique identifier when we want to build .dwp files.
1033 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1034 dwarf::DW_FORM_data8, ID);
1035 // Now construct the skeleton CU associated.
1036 CompileUnit *SkCU = constructSkeletonCU(CUI->first);
1037 // This should be a unique identifier when we want to build .dwp files.
1038 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1039 dwarf::DW_FORM_data8, ID);
1043 // Compute DIE offsets and sizes.
1044 InfoHolder.computeSizeAndOffsets();
1045 if (useSplitDwarf())
1046 SkeletonHolder.computeSizeAndOffsets();
1049 void DwarfDebug::endSections() {
1050 // Standard sections final addresses.
1051 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1052 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1053 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1054 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1056 // End text sections.
1057 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1058 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1059 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1063 // Emit all Dwarf sections that should come after the content.
1064 void DwarfDebug::endModule() {
1066 if (!FirstCU) return;
1068 // End any existing sections.
1069 // TODO: Does this need to happen?
1072 // Finalize the debug info for the module.
1073 finalizeModuleInfo();
1075 if (!useSplitDwarf()) {
1076 // Emit all the DIEs into a debug info section.
1079 // Corresponding abbreviations into a abbrev section.
1080 emitAbbreviations();
1082 // Emit info into a debug loc section.
1085 // Emit info into a debug aranges section.
1088 // Emit info into a debug ranges section.
1091 // Emit info into a debug macinfo section.
1094 // Emit inline info.
1095 // TODO: When we don't need the option anymore we
1096 // can remove all of the code that this section
1098 if (useDarwinGDBCompat())
1099 emitDebugInlineInfo();
1101 // TODO: Fill this in for separated debug sections and separate
1102 // out information into new sections.
1104 // Emit the debug info section and compile units.
1108 // Corresponding abbreviations into a abbrev section.
1109 emitAbbreviations();
1110 emitDebugAbbrevDWO();
1112 // Emit info into a debug loc section.
1115 // Emit info into a debug aranges section.
1118 // Emit info into a debug ranges section.
1121 // Emit info into a debug macinfo section.
1124 // Emit DWO addresses.
1125 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1127 // Emit inline info.
1128 // TODO: When we don't need the option anymore we
1129 // can remove all of the code that this section
1131 if (useDarwinGDBCompat())
1132 emitDebugInlineInfo();
1135 // Emit info into the dwarf accelerator table sections.
1136 if (useDwarfAccelTables()) {
1139 emitAccelNamespaces();
1143 // Emit info into a debug pubnames section, if requested.
1144 if (HasDwarfPubNames)
1145 emitDebugPubnames();
1147 // Emit info into a debug pubtypes section.
1148 // TODO: When we don't need the option anymore we can
1149 // remove all of the code that adds to the table.
1150 if (useDarwinGDBCompat())
1151 emitDebugPubTypes();
1153 // Finally emit string information into a string table.
1155 if (useSplitDwarf())
1160 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1161 E = CUMap.end(); I != E; ++I)
1164 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1165 E = SkeletonCUs.end(); I != E; ++I)
1168 // Reset these for the next Module if we have one.
1172 // Find abstract variable, if any, associated with Var.
1173 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1174 DebugLoc ScopeLoc) {
1175 LLVMContext &Ctx = DV->getContext();
1176 // More then one inlined variable corresponds to one abstract variable.
1177 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1178 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1180 return AbsDbgVariable;
1182 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1186 AbsDbgVariable = new DbgVariable(Var, NULL);
1187 addScopeVariable(Scope, AbsDbgVariable);
1188 AbstractVariables[Var] = AbsDbgVariable;
1189 return AbsDbgVariable;
1192 // If Var is a current function argument then add it to CurrentFnArguments list.
1193 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1194 DbgVariable *Var, LexicalScope *Scope) {
1195 if (!LScopes.isCurrentFunctionScope(Scope))
1197 DIVariable DV = Var->getVariable();
1198 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1200 unsigned ArgNo = DV.getArgNumber();
1204 size_t Size = CurrentFnArguments.size();
1206 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1207 // llvm::Function argument size is not good indicator of how many
1208 // arguments does the function have at source level.
1210 CurrentFnArguments.resize(ArgNo * 2);
1211 CurrentFnArguments[ArgNo - 1] = Var;
1215 // Collect variable information from side table maintained by MMI.
1217 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1218 SmallPtrSet<const MDNode *, 16> &Processed) {
1219 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1220 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1221 VE = VMap.end(); VI != VE; ++VI) {
1222 const MDNode *Var = VI->first;
1224 Processed.insert(Var);
1226 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1228 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1230 // If variable scope is not found then skip this variable.
1234 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1235 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1236 RegVar->setFrameIndex(VP.first);
1237 if (!addCurrentFnArgument(MF, RegVar, Scope))
1238 addScopeVariable(Scope, RegVar);
1240 AbsDbgVariable->setFrameIndex(VP.first);
1244 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1246 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1247 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1248 return MI->getNumOperands() == 3 &&
1249 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1250 (MI->getOperand(1).isImm() ||
1251 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1254 // Get .debug_loc entry for the instruction range starting at MI.
1255 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1256 const MCSymbol *FLabel,
1257 const MCSymbol *SLabel,
1258 const MachineInstr *MI) {
1259 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1261 assert(MI->getNumOperands() == 3);
1262 if (MI->getOperand(0).isReg()) {
1263 MachineLocation MLoc;
1264 // If the second operand is an immediate, this is a
1265 // register-indirect address.
1266 if (!MI->getOperand(1).isImm())
1267 MLoc.set(MI->getOperand(0).getReg());
1269 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1270 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1272 if (MI->getOperand(0).isImm())
1273 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1274 if (MI->getOperand(0).isFPImm())
1275 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1276 if (MI->getOperand(0).isCImm())
1277 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1279 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1282 // Find variables for each lexical scope.
1284 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1285 SmallPtrSet<const MDNode *, 16> &Processed) {
1287 // Grab the variable info that was squirreled away in the MMI side-table.
1288 collectVariableInfoFromMMITable(MF, Processed);
1290 for (SmallVectorImpl<const MDNode*>::const_iterator
1291 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1293 const MDNode *Var = *UVI;
1294 if (Processed.count(Var))
1297 // History contains relevant DBG_VALUE instructions for Var and instructions
1299 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1300 if (History.empty())
1302 const MachineInstr *MInsn = History.front();
1305 LexicalScope *Scope = NULL;
1306 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1307 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1308 Scope = LScopes.getCurrentFunctionScope();
1309 else if (MDNode *IA = DV.getInlinedAt())
1310 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1312 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1313 // If variable scope is not found then skip this variable.
1317 Processed.insert(DV);
1318 assert(MInsn->isDebugValue() && "History must begin with debug value");
1319 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1320 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1321 if (!addCurrentFnArgument(MF, RegVar, Scope))
1322 addScopeVariable(Scope, RegVar);
1324 AbsVar->setMInsn(MInsn);
1326 // Simplify ranges that are fully coalesced.
1327 if (History.size() <= 1 || (History.size() == 2 &&
1328 MInsn->isIdenticalTo(History.back()))) {
1329 RegVar->setMInsn(MInsn);
1333 // Handle multiple DBG_VALUE instructions describing one variable.
1334 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1336 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1337 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1338 const MachineInstr *Begin = *HI;
1339 assert(Begin->isDebugValue() && "Invalid History entry");
1341 // Check if DBG_VALUE is truncating a range.
1342 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1343 && !Begin->getOperand(0).getReg())
1346 // Compute the range for a register location.
1347 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1348 const MCSymbol *SLabel = 0;
1351 // If Begin is the last instruction in History then its value is valid
1352 // until the end of the function.
1353 SLabel = FunctionEndSym;
1355 const MachineInstr *End = HI[1];
1356 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1357 << "\t" << *Begin << "\t" << *End << "\n");
1358 if (End->isDebugValue())
1359 SLabel = getLabelBeforeInsn(End);
1361 // End is a normal instruction clobbering the range.
1362 SLabel = getLabelAfterInsn(End);
1363 assert(SLabel && "Forgot label after clobber instruction");
1368 // The value is valid until the next DBG_VALUE or clobber.
1369 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1372 DotDebugLocEntries.push_back(DotDebugLocEntry());
1375 // Collect info for variables that were optimized out.
1376 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1377 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1378 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1379 DIVariable DV(Variables.getElement(i));
1380 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1382 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1383 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1387 // Return Label preceding the instruction.
1388 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1389 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1390 assert(Label && "Didn't insert label before instruction");
1394 // Return Label immediately following the instruction.
1395 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1396 return LabelsAfterInsn.lookup(MI);
1399 // Process beginning of an instruction.
1400 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1401 // Check if source location changes, but ignore DBG_VALUE locations.
1402 if (!MI->isDebugValue()) {
1403 DebugLoc DL = MI->getDebugLoc();
1404 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1407 if (DL == PrologEndLoc) {
1408 Flags |= DWARF2_FLAG_PROLOGUE_END;
1409 PrologEndLoc = DebugLoc();
1411 if (PrologEndLoc.isUnknown())
1412 Flags |= DWARF2_FLAG_IS_STMT;
1414 if (!DL.isUnknown()) {
1415 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1416 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1418 recordSourceLine(0, 0, 0, 0);
1422 // Insert labels where requested.
1423 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1424 LabelsBeforeInsn.find(MI);
1427 if (I == LabelsBeforeInsn.end())
1430 // Label already assigned.
1435 PrevLabel = MMI->getContext().CreateTempSymbol();
1436 Asm->OutStreamer.EmitLabel(PrevLabel);
1438 I->second = PrevLabel;
1441 // Process end of an instruction.
1442 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1443 // Don't create a new label after DBG_VALUE instructions.
1444 // They don't generate code.
1445 if (!MI->isDebugValue())
1448 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1449 LabelsAfterInsn.find(MI);
1452 if (I == LabelsAfterInsn.end())
1455 // Label already assigned.
1459 // We need a label after this instruction.
1461 PrevLabel = MMI->getContext().CreateTempSymbol();
1462 Asm->OutStreamer.EmitLabel(PrevLabel);
1464 I->second = PrevLabel;
1467 // Each LexicalScope has first instruction and last instruction to mark
1468 // beginning and end of a scope respectively. Create an inverse map that list
1469 // scopes starts (and ends) with an instruction. One instruction may start (or
1470 // end) multiple scopes. Ignore scopes that are not reachable.
1471 void DwarfDebug::identifyScopeMarkers() {
1472 SmallVector<LexicalScope *, 4> WorkList;
1473 WorkList.push_back(LScopes.getCurrentFunctionScope());
1474 while (!WorkList.empty()) {
1475 LexicalScope *S = WorkList.pop_back_val();
1477 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1478 if (!Children.empty())
1479 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1480 SE = Children.end(); SI != SE; ++SI)
1481 WorkList.push_back(*SI);
1483 if (S->isAbstractScope())
1486 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1489 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1490 RE = Ranges.end(); RI != RE; ++RI) {
1491 assert(RI->first && "InsnRange does not have first instruction!");
1492 assert(RI->second && "InsnRange does not have second instruction!");
1493 requestLabelBeforeInsn(RI->first);
1494 requestLabelAfterInsn(RI->second);
1499 // Get MDNode for DebugLoc's scope.
1500 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1501 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1502 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1503 return DL.getScope(Ctx);
1506 // Walk up the scope chain of given debug loc and find line number info
1507 // for the function.
1508 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1509 const MDNode *Scope = getScopeNode(DL, Ctx);
1510 DISubprogram SP = getDISubprogram(Scope);
1511 if (SP.isSubprogram()) {
1512 // Check for number of operands since the compatibility is
1514 if (SP->getNumOperands() > 19)
1515 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1517 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1523 // Gather pre-function debug information. Assumes being called immediately
1524 // after the function entry point has been emitted.
1525 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1526 if (!MMI->hasDebugInfo()) return;
1527 LScopes.initialize(*MF);
1528 if (LScopes.empty()) return;
1529 identifyScopeMarkers();
1531 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1533 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1534 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1535 assert(TheCU && "Unable to find compile unit!");
1536 if (Asm->TM.hasMCUseLoc() &&
1537 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1538 // Use a single line table if we are using .loc and generating assembly.
1539 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1541 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1543 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1544 Asm->getFunctionNumber());
1545 // Assumes in correct section after the entry point.
1546 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1548 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1550 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1551 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1552 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1554 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1556 bool AtBlockEntry = true;
1557 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1559 const MachineInstr *MI = II;
1561 if (MI->isDebugValue()) {
1562 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1564 // Keep track of user variables.
1566 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1568 // Variable is in a register, we need to check for clobbers.
1569 if (isDbgValueInDefinedReg(MI))
1570 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1572 // Check the history of this variable.
1573 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1574 if (History.empty()) {
1575 UserVariables.push_back(Var);
1576 // The first mention of a function argument gets the FunctionBeginSym
1577 // label, so arguments are visible when breaking at function entry.
1579 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1580 DISubprogram(getDISubprogram(DV.getContext()))
1581 .describes(MF->getFunction()))
1582 LabelsBeforeInsn[MI] = FunctionBeginSym;
1584 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1585 const MachineInstr *Prev = History.back();
1586 if (Prev->isDebugValue()) {
1587 // Coalesce identical entries at the end of History.
1588 if (History.size() >= 2 &&
1589 Prev->isIdenticalTo(History[History.size() - 2])) {
1590 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1592 << "\t" << *History[History.size() - 2] << "\n");
1596 // Terminate old register assignments that don't reach MI;
1597 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1598 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1599 isDbgValueInDefinedReg(Prev)) {
1600 // Previous register assignment needs to terminate at the end of
1602 MachineBasicBlock::const_iterator LastMI =
1603 PrevMBB->getLastNonDebugInstr();
1604 if (LastMI == PrevMBB->end()) {
1605 // Drop DBG_VALUE for empty range.
1606 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1607 << "\t" << *Prev << "\n");
1609 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1610 // Terminate after LastMI.
1611 History.push_back(LastMI);
1615 History.push_back(MI);
1617 // Not a DBG_VALUE instruction.
1619 AtBlockEntry = false;
1621 // First known non-DBG_VALUE and non-frame setup location marks
1622 // the beginning of the function body.
1623 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1624 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1625 PrologEndLoc = MI->getDebugLoc();
1627 // Check if the instruction clobbers any registers with debug vars.
1628 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1629 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1630 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1632 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1633 AI.isValid(); ++AI) {
1635 const MDNode *Var = LiveUserVar[Reg];
1638 // Reg is now clobbered.
1639 LiveUserVar[Reg] = 0;
1641 // Was MD last defined by a DBG_VALUE referring to Reg?
1642 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1643 if (HistI == DbgValues.end())
1645 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1646 if (History.empty())
1648 const MachineInstr *Prev = History.back();
1649 // Sanity-check: Register assignments are terminated at the end of
1651 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1653 // Is the variable still in Reg?
1654 if (!isDbgValueInDefinedReg(Prev) ||
1655 Prev->getOperand(0).getReg() != Reg)
1657 // Var is clobbered. Make sure the next instruction gets a label.
1658 History.push_back(MI);
1665 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1667 SmallVectorImpl<const MachineInstr*> &History = I->second;
1668 if (History.empty())
1671 // Make sure the final register assignments are terminated.
1672 const MachineInstr *Prev = History.back();
1673 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1674 const MachineBasicBlock *PrevMBB = Prev->getParent();
1675 MachineBasicBlock::const_iterator LastMI =
1676 PrevMBB->getLastNonDebugInstr();
1677 if (LastMI == PrevMBB->end())
1678 // Drop DBG_VALUE for empty range.
1680 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1681 // Terminate after LastMI.
1682 History.push_back(LastMI);
1685 // Request labels for the full history.
1686 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1687 const MachineInstr *MI = History[i];
1688 if (MI->isDebugValue())
1689 requestLabelBeforeInsn(MI);
1691 requestLabelAfterInsn(MI);
1695 PrevInstLoc = DebugLoc();
1696 PrevLabel = FunctionBeginSym;
1698 // Record beginning of function.
1699 if (!PrologEndLoc.isUnknown()) {
1700 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1701 MF->getFunction()->getContext());
1702 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1703 FnStartDL.getScope(MF->getFunction()->getContext()),
1704 // We'd like to list the prologue as "not statements" but GDB behaves
1705 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1706 DWARF2_FLAG_IS_STMT);
1710 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1711 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1712 DIVariable DV = Var->getVariable();
1713 // Variables with positive arg numbers are parameters.
1714 if (unsigned ArgNum = DV.getArgNumber()) {
1715 // Keep all parameters in order at the start of the variable list to ensure
1716 // function types are correct (no out-of-order parameters)
1718 // This could be improved by only doing it for optimized builds (unoptimized
1719 // builds have the right order to begin with), searching from the back (this
1720 // would catch the unoptimized case quickly), or doing a binary search
1721 // rather than linear search.
1722 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1723 while (I != Vars.end()) {
1724 unsigned CurNum = (*I)->getVariable().getArgNumber();
1725 // A local (non-parameter) variable has been found, insert immediately
1729 // A later indexed parameter has been found, insert immediately before it.
1730 if (CurNum > ArgNum)
1734 Vars.insert(I, Var);
1738 Vars.push_back(Var);
1741 // Gather and emit post-function debug information.
1742 void DwarfDebug::endFunction(const MachineFunction *MF) {
1743 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1745 // Define end label for subprogram.
1746 FunctionEndSym = Asm->GetTempSymbol("func_end",
1747 Asm->getFunctionNumber());
1748 // Assumes in correct section after the entry point.
1749 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1750 // Set DwarfCompileUnitID in MCContext to default value.
1751 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1753 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1754 collectVariableInfo(MF, ProcessedVars);
1756 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1757 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1758 assert(TheCU && "Unable to find compile unit!");
1760 // Construct abstract scopes.
1761 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1762 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1763 LexicalScope *AScope = AList[i];
1764 DISubprogram SP(AScope->getScopeNode());
1765 if (SP.isSubprogram()) {
1766 // Collect info for variables that were optimized out.
1767 DIArray Variables = SP.getVariables();
1768 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1769 DIVariable DV(Variables.getElement(i));
1770 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1772 // Check that DbgVariable for DV wasn't created earlier, when
1773 // findAbstractVariable() was called for inlined instance of DV.
1774 LLVMContext &Ctx = DV->getContext();
1775 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1776 if (AbstractVariables.lookup(CleanDV))
1778 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1779 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1782 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1783 constructScopeDIE(TheCU, AScope);
1786 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1788 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1789 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1792 for (ScopeVariablesMap::iterator
1793 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1794 DeleteContainerPointers(I->second);
1795 ScopeVariables.clear();
1796 DeleteContainerPointers(CurrentFnArguments);
1797 UserVariables.clear();
1799 AbstractVariables.clear();
1800 LabelsBeforeInsn.clear();
1801 LabelsAfterInsn.clear();
1805 // Register a source line with debug info. Returns the unique label that was
1806 // emitted and which provides correspondence to the source line list.
1807 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1813 DIDescriptor Scope(S);
1815 if (Scope.isCompileUnit()) {
1816 DICompileUnit CU(S);
1817 Fn = CU.getFilename();
1818 Dir = CU.getDirectory();
1819 } else if (Scope.isFile()) {
1821 Fn = F.getFilename();
1822 Dir = F.getDirectory();
1823 } else if (Scope.isSubprogram()) {
1825 Fn = SP.getFilename();
1826 Dir = SP.getDirectory();
1827 } else if (Scope.isLexicalBlockFile()) {
1828 DILexicalBlockFile DBF(S);
1829 Fn = DBF.getFilename();
1830 Dir = DBF.getDirectory();
1831 } else if (Scope.isLexicalBlock()) {
1832 DILexicalBlock DB(S);
1833 Fn = DB.getFilename();
1834 Dir = DB.getDirectory();
1836 llvm_unreachable("Unexpected scope info");
1838 Src = getOrCreateSourceID(Fn, Dir,
1839 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1841 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1844 //===----------------------------------------------------------------------===//
1846 //===----------------------------------------------------------------------===//
1848 // Compute the size and offset of a DIE.
1850 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1851 // Get the children.
1852 const std::vector<DIE *> &Children = Die->getChildren();
1854 // Record the abbreviation.
1855 assignAbbrevNumber(Die->getAbbrev());
1857 // Get the abbreviation for this DIE.
1858 unsigned AbbrevNumber = Die->getAbbrevNumber();
1859 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1862 Die->setOffset(Offset);
1864 // Start the size with the size of abbreviation code.
1865 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1867 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1868 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1870 // Size the DIE attribute values.
1871 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1872 // Size attribute value.
1873 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1875 // Size the DIE children if any.
1876 if (!Children.empty()) {
1877 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1878 "Children flag not set");
1880 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1881 Offset = computeSizeAndOffset(Children[j], Offset);
1883 // End of children marker.
1884 Offset += sizeof(int8_t);
1887 Die->setSize(Offset - Die->getOffset());
1891 // Compute the size and offset of all the DIEs.
1892 void DwarfUnits::computeSizeAndOffsets() {
1893 // Offset from the beginning of debug info section.
1894 unsigned SecOffset = 0;
1895 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1896 E = CUs.end(); I != E; ++I) {
1897 (*I)->setDebugInfoOffset(SecOffset);
1899 sizeof(int32_t) + // Length of Compilation Unit Info
1900 sizeof(int16_t) + // DWARF version number
1901 sizeof(int32_t) + // Offset Into Abbrev. Section
1902 sizeof(int8_t); // Pointer Size (in bytes)
1904 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1905 SecOffset += EndOffset;
1909 // Emit initial Dwarf sections with a label at the start of each one.
1910 void DwarfDebug::emitSectionLabels() {
1911 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1913 // Dwarf sections base addresses.
1914 DwarfInfoSectionSym =
1915 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1916 DwarfAbbrevSectionSym =
1917 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1918 if (useSplitDwarf())
1919 DwarfAbbrevDWOSectionSym =
1920 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1921 "section_abbrev_dwo");
1922 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1924 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1925 emitSectionSym(Asm, MacroInfo);
1927 DwarfLineSectionSym =
1928 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1929 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1930 if (HasDwarfPubNames)
1931 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1932 if (useDarwinGDBCompat())
1933 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1934 DwarfStrSectionSym =
1935 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1936 if (useSplitDwarf()) {
1937 DwarfStrDWOSectionSym =
1938 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1939 DwarfAddrSectionSym =
1940 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1942 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1945 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1946 "section_debug_loc");
1948 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1949 emitSectionSym(Asm, TLOF.getDataSection());
1952 // Recursively emits a debug information entry.
1953 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1954 // Get the abbreviation for this DIE.
1955 unsigned AbbrevNumber = Die->getAbbrevNumber();
1956 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1958 // Emit the code (index) for the abbreviation.
1959 if (Asm->isVerbose())
1960 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1961 Twine::utohexstr(Die->getOffset()) + ":0x" +
1962 Twine::utohexstr(Die->getSize()) + " " +
1963 dwarf::TagString(Abbrev->getTag()));
1964 Asm->EmitULEB128(AbbrevNumber);
1966 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1967 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1969 // Emit the DIE attribute values.
1970 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1971 unsigned Attr = AbbrevData[i].getAttribute();
1972 unsigned Form = AbbrevData[i].getForm();
1973 assert(Form && "Too many attributes for DIE (check abbreviation)");
1975 if (Asm->isVerbose())
1976 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1979 case dwarf::DW_AT_abstract_origin: {
1980 DIEEntry *E = cast<DIEEntry>(Values[i]);
1981 DIE *Origin = E->getEntry();
1982 unsigned Addr = Origin->getOffset();
1983 if (Form == dwarf::DW_FORM_ref_addr) {
1984 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1985 // section. Origin->getOffset() returns the offset from start of the
1987 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1988 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1990 Asm->OutStreamer.EmitIntValue(Addr,
1991 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
1994 case dwarf::DW_AT_ranges: {
1995 // DW_AT_range Value encodes offset in debug_range section.
1996 DIEInteger *V = cast<DIEInteger>(Values[i]);
1998 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1999 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2003 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2005 DwarfDebugRangeSectionSym,
2010 case dwarf::DW_AT_location: {
2011 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2012 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2013 Asm->EmitLabelReference(L->getValue(), 4);
2015 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2017 Values[i]->EmitValue(Asm, Form);
2021 case dwarf::DW_AT_accessibility: {
2022 if (Asm->isVerbose()) {
2023 DIEInteger *V = cast<DIEInteger>(Values[i]);
2024 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2026 Values[i]->EmitValue(Asm, Form);
2030 // Emit an attribute using the defined form.
2031 Values[i]->EmitValue(Asm, Form);
2036 // Emit the DIE children if any.
2037 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2038 const std::vector<DIE *> &Children = Die->getChildren();
2040 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2041 emitDIE(Children[j], Abbrevs);
2043 if (Asm->isVerbose())
2044 Asm->OutStreamer.AddComment("End Of Children Mark");
2049 // Emit the various dwarf units to the unit section USection with
2050 // the abbreviations going into ASection.
2051 void DwarfUnits::emitUnits(DwarfDebug *DD,
2052 const MCSection *USection,
2053 const MCSection *ASection,
2054 const MCSymbol *ASectionSym) {
2055 Asm->OutStreamer.SwitchSection(USection);
2056 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2057 E = CUs.end(); I != E; ++I) {
2058 CompileUnit *TheCU = *I;
2059 DIE *Die = TheCU->getCUDie();
2061 // Emit the compile units header.
2063 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2064 TheCU->getUniqueID()));
2066 // Emit size of content not including length itself
2067 unsigned ContentSize = Die->getSize() +
2068 sizeof(int16_t) + // DWARF version number
2069 sizeof(int32_t) + // Offset Into Abbrev. Section
2070 sizeof(int8_t); // Pointer Size (in bytes)
2072 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2073 Asm->EmitInt32(ContentSize);
2074 Asm->OutStreamer.AddComment("DWARF version number");
2075 Asm->EmitInt16(DD->getDwarfVersion());
2076 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2077 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2079 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2080 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2082 DD->emitDIE(Die, Abbreviations);
2083 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2084 TheCU->getUniqueID()));
2088 /// For a given compile unit DIE, returns offset from beginning of debug info.
2089 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2090 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2091 "Input DIE should be compile unit in getCUOffset.");
2092 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2094 CompileUnit *TheCU = *I;
2095 if (TheCU->getCUDie() == Die)
2096 return TheCU->getDebugInfoOffset();
2098 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2101 // Emit the debug info section.
2102 void DwarfDebug::emitDebugInfo() {
2103 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2105 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2106 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2107 DwarfAbbrevSectionSym);
2110 // Emit the abbreviation section.
2111 void DwarfDebug::emitAbbreviations() {
2112 if (!useSplitDwarf())
2113 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2116 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2119 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2120 std::vector<DIEAbbrev *> *Abbrevs) {
2121 // Check to see if it is worth the effort.
2122 if (!Abbrevs->empty()) {
2123 // Start the debug abbrev section.
2124 Asm->OutStreamer.SwitchSection(Section);
2126 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2127 Asm->OutStreamer.EmitLabel(Begin);
2129 // For each abbrevation.
2130 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2131 // Get abbreviation data
2132 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2134 // Emit the abbrevations code (base 1 index.)
2135 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2137 // Emit the abbreviations data.
2141 // Mark end of abbreviations.
2142 Asm->EmitULEB128(0, "EOM(3)");
2144 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2145 Asm->OutStreamer.EmitLabel(End);
2149 // Emit the last address of the section and the end of the line matrix.
2150 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2151 // Define last address of section.
2152 Asm->OutStreamer.AddComment("Extended Op");
2155 Asm->OutStreamer.AddComment("Op size");
2156 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2157 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2158 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2160 Asm->OutStreamer.AddComment("Section end label");
2162 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2163 Asm->getDataLayout().getPointerSize());
2165 // Mark end of matrix.
2166 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2172 // Emit visible names into a hashed accelerator table section.
2173 void DwarfDebug::emitAccelNames() {
2174 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2175 dwarf::DW_FORM_data4));
2176 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2177 E = CUMap.end(); I != E; ++I) {
2178 CompileUnit *TheCU = I->second;
2179 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2180 for (StringMap<std::vector<DIE*> >::const_iterator
2181 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2182 StringRef Name = GI->getKey();
2183 const std::vector<DIE *> &Entities = GI->second;
2184 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2185 DE = Entities.end(); DI != DE; ++DI)
2186 AT.AddName(Name, (*DI));
2190 AT.FinalizeTable(Asm, "Names");
2191 Asm->OutStreamer.SwitchSection(
2192 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2193 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2194 Asm->OutStreamer.EmitLabel(SectionBegin);
2196 // Emit the full data.
2197 AT.Emit(Asm, SectionBegin, &InfoHolder);
2200 // Emit objective C classes and categories into a hashed accelerator table
2202 void DwarfDebug::emitAccelObjC() {
2203 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2204 dwarf::DW_FORM_data4));
2205 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2206 E = CUMap.end(); I != E; ++I) {
2207 CompileUnit *TheCU = I->second;
2208 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2209 for (StringMap<std::vector<DIE*> >::const_iterator
2210 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2211 StringRef Name = GI->getKey();
2212 const std::vector<DIE *> &Entities = GI->second;
2213 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2214 DE = Entities.end(); DI != DE; ++DI)
2215 AT.AddName(Name, (*DI));
2219 AT.FinalizeTable(Asm, "ObjC");
2220 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2221 .getDwarfAccelObjCSection());
2222 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2223 Asm->OutStreamer.EmitLabel(SectionBegin);
2225 // Emit the full data.
2226 AT.Emit(Asm, SectionBegin, &InfoHolder);
2229 // Emit namespace dies into a hashed accelerator table.
2230 void DwarfDebug::emitAccelNamespaces() {
2231 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2232 dwarf::DW_FORM_data4));
2233 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2234 E = CUMap.end(); I != E; ++I) {
2235 CompileUnit *TheCU = I->second;
2236 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2237 for (StringMap<std::vector<DIE*> >::const_iterator
2238 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2239 StringRef Name = GI->getKey();
2240 const std::vector<DIE *> &Entities = GI->second;
2241 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2242 DE = Entities.end(); DI != DE; ++DI)
2243 AT.AddName(Name, (*DI));
2247 AT.FinalizeTable(Asm, "namespac");
2248 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2249 .getDwarfAccelNamespaceSection());
2250 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2251 Asm->OutStreamer.EmitLabel(SectionBegin);
2253 // Emit the full data.
2254 AT.Emit(Asm, SectionBegin, &InfoHolder);
2257 // Emit type dies into a hashed accelerator table.
2258 void DwarfDebug::emitAccelTypes() {
2259 std::vector<DwarfAccelTable::Atom> Atoms;
2260 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2261 dwarf::DW_FORM_data4));
2262 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2263 dwarf::DW_FORM_data2));
2264 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2265 dwarf::DW_FORM_data1));
2266 DwarfAccelTable AT(Atoms);
2267 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2268 E = CUMap.end(); I != E; ++I) {
2269 CompileUnit *TheCU = I->second;
2270 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2271 = TheCU->getAccelTypes();
2272 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2273 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2274 StringRef Name = GI->getKey();
2275 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2276 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2277 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2278 AT.AddName(Name, (*DI).first, (*DI).second);
2282 AT.FinalizeTable(Asm, "types");
2283 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2284 .getDwarfAccelTypesSection());
2285 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2286 Asm->OutStreamer.EmitLabel(SectionBegin);
2288 // Emit the full data.
2289 AT.Emit(Asm, SectionBegin, &InfoHolder);
2292 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2294 void DwarfDebug::emitDebugPubnames() {
2295 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2297 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2298 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2299 CompileUnit *TheCU = I->second;
2300 unsigned ID = TheCU->getUniqueID();
2302 if (TheCU->getGlobalNames().empty())
2305 // Start the dwarf pubnames section.
2307 .SwitchSection(Asm->getObjFileLowering().getDwarfPubNamesSection());
2309 Asm->OutStreamer.AddComment("Length of Public Names Info");
2310 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2311 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2313 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2315 Asm->OutStreamer.AddComment("DWARF Version");
2316 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2318 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2319 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2320 DwarfInfoSectionSym);
2322 Asm->OutStreamer.AddComment("Compilation Unit Length");
2323 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2324 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2327 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2328 for (StringMap<DIE*>::const_iterator
2329 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2330 const char *Name = GI->getKeyData();
2331 const DIE *Entity = GI->second;
2333 Asm->OutStreamer.AddComment("DIE offset");
2334 Asm->EmitInt32(Entity->getOffset());
2336 if (Asm->isVerbose())
2337 Asm->OutStreamer.AddComment("External Name");
2338 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2341 Asm->OutStreamer.AddComment("End Mark");
2343 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2347 void DwarfDebug::emitDebugPubTypes() {
2348 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2349 E = CUMap.end(); I != E; ++I) {
2350 CompileUnit *TheCU = I->second;
2351 // Start the dwarf pubtypes section.
2352 Asm->OutStreamer.SwitchSection(
2353 Asm->getObjFileLowering().getDwarfPubTypesSection());
2354 Asm->OutStreamer.AddComment("Length of Public Types Info");
2355 Asm->EmitLabelDifference(
2356 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2357 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2359 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2360 TheCU->getUniqueID()));
2362 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2363 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2365 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2366 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2367 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2368 TheCU->getUniqueID()),
2369 DwarfInfoSectionSym);
2371 Asm->OutStreamer.AddComment("Compilation Unit Length");
2372 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2373 TheCU->getUniqueID()),
2374 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2375 TheCU->getUniqueID()),
2378 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2379 for (StringMap<DIE*>::const_iterator
2380 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2381 const char *Name = GI->getKeyData();
2382 DIE *Entity = GI->second;
2384 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2385 Asm->EmitInt32(Entity->getOffset());
2387 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2388 // Emit the name with a terminating null byte.
2389 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2392 Asm->OutStreamer.AddComment("End Mark");
2394 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2395 TheCU->getUniqueID()));
2399 // Emit strings into a string section.
2400 void DwarfUnits::emitStrings(const MCSection *StrSection,
2401 const MCSection *OffsetSection = NULL,
2402 const MCSymbol *StrSecSym = NULL) {
2404 if (StringPool.empty()) return;
2406 // Start the dwarf str section.
2407 Asm->OutStreamer.SwitchSection(StrSection);
2409 // Get all of the string pool entries and put them in an array by their ID so
2410 // we can sort them.
2411 SmallVector<std::pair<unsigned,
2412 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2414 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2415 I = StringPool.begin(), E = StringPool.end();
2417 Entries.push_back(std::make_pair(I->second.second, &*I));
2419 array_pod_sort(Entries.begin(), Entries.end());
2421 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2422 // Emit a label for reference from debug information entries.
2423 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2425 // Emit the string itself with a terminating null byte.
2426 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2427 Entries[i].second->getKeyLength()+1));
2430 // If we've got an offset section go ahead and emit that now as well.
2431 if (OffsetSection) {
2432 Asm->OutStreamer.SwitchSection(OffsetSection);
2433 unsigned offset = 0;
2434 unsigned size = 4; // FIXME: DWARF64 is 8.
2435 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2436 Asm->OutStreamer.EmitIntValue(offset, size);
2437 offset += Entries[i].second->getKeyLength() + 1;
2442 // Emit strings into a string section.
2443 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2445 if (AddressPool.empty()) return;
2447 // Start the dwarf addr section.
2448 Asm->OutStreamer.SwitchSection(AddrSection);
2450 // Order the address pool entries by ID
2451 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2453 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2454 E = AddressPool.end();
2456 Entries[I->second] = I->first;
2458 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2459 // Emit an expression for reference from debug information entries.
2460 if (const MCExpr *Expr = Entries[i])
2461 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2463 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2468 // Emit visible names into a debug str section.
2469 void DwarfDebug::emitDebugStr() {
2470 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2471 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2474 // Emit locations into the debug loc section.
2475 void DwarfDebug::emitDebugLoc() {
2476 if (DotDebugLocEntries.empty())
2479 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2480 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2482 DotDebugLocEntry &Entry = *I;
2483 if (I + 1 != DotDebugLocEntries.end())
2487 // Start the dwarf loc section.
2488 Asm->OutStreamer.SwitchSection(
2489 Asm->getObjFileLowering().getDwarfLocSection());
2490 unsigned char Size = Asm->getDataLayout().getPointerSize();
2491 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2493 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2494 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2495 I != E; ++I, ++index) {
2496 DotDebugLocEntry &Entry = *I;
2497 if (Entry.isMerged()) continue;
2498 if (Entry.isEmpty()) {
2499 Asm->OutStreamer.EmitIntValue(0, Size);
2500 Asm->OutStreamer.EmitIntValue(0, Size);
2501 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2503 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2504 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2505 DIVariable DV(Entry.getVariable());
2506 Asm->OutStreamer.AddComment("Loc expr size");
2507 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2508 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2509 Asm->EmitLabelDifference(end, begin, 2);
2510 Asm->OutStreamer.EmitLabel(begin);
2511 if (Entry.isInt()) {
2512 DIBasicType BTy(DV.getType());
2514 (BTy.getEncoding() == dwarf::DW_ATE_signed
2515 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2516 Asm->OutStreamer.AddComment("DW_OP_consts");
2517 Asm->EmitInt8(dwarf::DW_OP_consts);
2518 Asm->EmitSLEB128(Entry.getInt());
2520 Asm->OutStreamer.AddComment("DW_OP_constu");
2521 Asm->EmitInt8(dwarf::DW_OP_constu);
2522 Asm->EmitULEB128(Entry.getInt());
2524 } else if (Entry.isLocation()) {
2525 MachineLocation Loc = Entry.getLoc();
2526 if (!DV.hasComplexAddress())
2528 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2530 // Complex address entry.
2531 unsigned N = DV.getNumAddrElements();
2533 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2534 if (Loc.getOffset()) {
2536 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2537 Asm->OutStreamer.AddComment("DW_OP_deref");
2538 Asm->EmitInt8(dwarf::DW_OP_deref);
2539 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2540 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2541 Asm->EmitSLEB128(DV.getAddrElement(1));
2543 // If first address element is OpPlus then emit
2544 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2545 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2546 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2550 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2553 // Emit remaining complex address elements.
2554 for (; i < N; ++i) {
2555 uint64_t Element = DV.getAddrElement(i);
2556 if (Element == DIBuilder::OpPlus) {
2557 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2558 Asm->EmitULEB128(DV.getAddrElement(++i));
2559 } else if (Element == DIBuilder::OpDeref) {
2561 Asm->EmitInt8(dwarf::DW_OP_deref);
2563 llvm_unreachable("unknown Opcode found in complex address");
2567 // else ... ignore constant fp. There is not any good way to
2568 // to represent them here in dwarf.
2569 Asm->OutStreamer.EmitLabel(end);
2574 // Emit visible names into a debug aranges section.
2575 void DwarfDebug::emitDebugARanges() {
2576 // Start the dwarf aranges section.
2577 Asm->OutStreamer.SwitchSection(
2578 Asm->getObjFileLowering().getDwarfARangesSection());
2581 // Emit visible names into a debug ranges section.
2582 void DwarfDebug::emitDebugRanges() {
2583 // Start the dwarf ranges section.
2584 Asm->OutStreamer.SwitchSection(
2585 Asm->getObjFileLowering().getDwarfRangesSection());
2586 unsigned char Size = Asm->getDataLayout().getPointerSize();
2587 for (SmallVectorImpl<const MCSymbol *>::iterator
2588 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2591 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2593 Asm->OutStreamer.EmitIntValue(0, Size);
2597 // Emit visible names into a debug macinfo section.
2598 void DwarfDebug::emitDebugMacInfo() {
2599 if (const MCSection *LineInfo =
2600 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2601 // Start the dwarf macinfo section.
2602 Asm->OutStreamer.SwitchSection(LineInfo);
2606 // Emit inline info using following format.
2608 // 1. length of section
2609 // 2. Dwarf version number
2612 // Entries (one "entry" for each function that was inlined):
2614 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2615 // otherwise offset into __debug_str for regular function name.
2616 // 2. offset into __debug_str section for regular function name.
2617 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2618 // instances for the function.
2620 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2621 // inlined instance; the die_offset points to the inlined_subroutine die in the
2622 // __debug_info section, and the low_pc is the starting address for the
2623 // inlining instance.
2624 void DwarfDebug::emitDebugInlineInfo() {
2625 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2631 Asm->OutStreamer.SwitchSection(
2632 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2634 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2635 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2636 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2638 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2640 Asm->OutStreamer.AddComment("Dwarf Version");
2641 Asm->EmitInt16(DwarfVersion);
2642 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2643 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2645 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2646 E = InlinedSPNodes.end(); I != E; ++I) {
2648 const MDNode *Node = *I;
2649 InlineInfoMap::iterator II = InlineInfo.find(Node);
2650 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2651 DISubprogram SP(Node);
2652 StringRef LName = SP.getLinkageName();
2653 StringRef Name = SP.getName();
2655 Asm->OutStreamer.AddComment("MIPS linkage name");
2657 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2658 DwarfStrSectionSym);
2660 Asm->EmitSectionOffset(
2661 InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2662 DwarfStrSectionSym);
2664 Asm->OutStreamer.AddComment("Function name");
2665 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2666 DwarfStrSectionSym);
2667 Asm->EmitULEB128(Labels.size(), "Inline count");
2669 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2670 LE = Labels.end(); LI != LE; ++LI) {
2671 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2672 Asm->EmitInt32(LI->second->getOffset());
2674 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2675 Asm->OutStreamer.EmitSymbolValue(LI->first,
2676 Asm->getDataLayout().getPointerSize());
2680 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2683 // DWARF5 Experimental Separate Dwarf emitters.
2685 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2686 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2687 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2688 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2689 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2690 DICompileUnit DIUnit(N);
2691 CompilationDir = DIUnit.getDirectory();
2693 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2694 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2695 DIUnit.getLanguage(), Die, N, Asm,
2696 this, &SkeletonHolder);
2698 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2699 DIUnit.getSplitDebugFilename());
2701 // Relocate to the beginning of the addr_base section, else 0 for the
2702 // beginning of the one for this compile unit.
2703 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2704 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2705 DwarfAddrSectionSym);
2707 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2708 dwarf::DW_FORM_sec_offset, 0);
2710 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2711 // into an entity. We're using 0, or a NULL label for this.
2712 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2714 // DW_AT_stmt_list is a offset of line number information for this
2715 // compile unit in debug_line section.
2716 // FIXME: Should handle multiple compile units.
2717 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2718 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2719 DwarfLineSectionSym);
2721 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2723 if (!CompilationDir.empty())
2724 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2726 SkeletonHolder.addUnit(NewCU);
2727 SkeletonCUs.push_back(NewCU);
2732 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2733 assert(useSplitDwarf() && "No split dwarf debug info?");
2734 emitAbbrevs(Section, &SkeletonAbbrevs);
2737 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2738 // compile units that would normally be in debug_info.
2739 void DwarfDebug::emitDebugInfoDWO() {
2740 assert(useSplitDwarf() && "No split dwarf debug info?");
2741 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2742 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2743 DwarfAbbrevDWOSectionSym);
2746 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2747 // abbreviations for the .debug_info.dwo section.
2748 void DwarfDebug::emitDebugAbbrevDWO() {
2749 assert(useSplitDwarf() && "No split dwarf?");
2750 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2754 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2755 // string section and is identical in format to traditional .debug_str
2757 void DwarfDebug::emitDebugStrDWO() {
2758 assert(useSplitDwarf() && "No split dwarf?");
2759 const MCSection *OffSec = Asm->getObjFileLowering()
2760 .getDwarfStrOffDWOSection();
2761 const MCSymbol *StrSym = DwarfStrSectionSym;
2762 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),