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 SplitDwarf("split-dwarf", cl::Hidden,
89 cl::desc("Output prototype dwarf split debug info."),
90 cl::values(clEnumVal(Default, "Default for platform"),
91 clEnumVal(Enable, "Enabled"),
92 clEnumVal(Disable, "Disabled"), clEnumValEnd),
95 static cl::opt<DefaultOnOff>
96 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
97 cl::desc("Generate DWARF pubnames and pubtypes sections"),
98 cl::values(clEnumVal(Default, "Default for platform"),
99 clEnumVal(Enable, "Enabled"),
100 clEnumVal(Disable, "Disabled"), clEnumValEnd),
103 static const char *const DWARFGroupName = "DWARF Emission";
104 static const char *const DbgTimerName = "DWARF Debug Writer";
106 //===----------------------------------------------------------------------===//
108 // Configuration values for initial hash set sizes (log2).
110 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
114 DIType DbgVariable::getType() const {
115 DIType Ty = Var.getType();
116 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
117 // addresses instead.
118 if (Var.isBlockByrefVariable()) {
119 /* Byref variables, in Blocks, are declared by the programmer as
120 "SomeType VarName;", but the compiler creates a
121 __Block_byref_x_VarName struct, and gives the variable VarName
122 either the struct, or a pointer to the struct, as its type. This
123 is necessary for various behind-the-scenes things the compiler
124 needs to do with by-reference variables in blocks.
126 However, as far as the original *programmer* is concerned, the
127 variable should still have type 'SomeType', as originally declared.
129 The following function dives into the __Block_byref_x_VarName
130 struct to find the original type of the variable. This will be
131 passed back to the code generating the type for the Debug
132 Information Entry for the variable 'VarName'. 'VarName' will then
133 have the original type 'SomeType' in its debug information.
135 The original type 'SomeType' will be the type of the field named
136 'VarName' inside the __Block_byref_x_VarName struct.
138 NOTE: In order for this to not completely fail on the debugger
139 side, the Debug Information Entry for the variable VarName needs to
140 have a DW_AT_location that tells the debugger how to unwind through
141 the pointers and __Block_byref_x_VarName struct to find the actual
142 value of the variable. The function addBlockByrefType does this. */
144 uint16_t tag = Ty.getTag();
146 if (tag == dwarf::DW_TAG_pointer_type)
147 subType = DIDerivedType(Ty).getTypeDerivedFrom();
149 DIArray Elements = DICompositeType(subType).getTypeArray();
150 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
151 DIDerivedType DT = DIDerivedType(Elements.getElement(i));
152 if (getName() == DT.getName())
153 return (DT.getTypeDerivedFrom());
159 } // end llvm namespace
161 /// Return Dwarf Version by checking module flags.
162 static unsigned getDwarfVersionFromModule(const Module *M) {
163 Value *Val = M->getModuleFlag("Dwarf Version");
165 return dwarf::DWARF_VERSION;
166 return cast<ConstantInt>(Val)->getZExtValue();
169 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
170 : Asm(A), MMI(Asm->MMI), FirstCU(0),
171 AbbreviationsSet(InitAbbreviationsSetSize),
172 SourceIdMap(DIEValueAllocator),
173 PrevLabel(NULL), GlobalCUIndexCount(0),
174 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
176 SkeletonAbbrevSet(InitAbbreviationsSetSize),
177 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
180 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
181 DwarfStrSectionSym = TextSectionSym = 0;
182 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
183 DwarfAddrSectionSym = 0;
184 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
185 FunctionBeginSym = FunctionEndSym = 0;
187 // Turn on accelerator tables and older gdb compatibility
188 // for Darwin by default, pubnames by default for non-Darwin,
189 // and handle split dwarf.
190 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
192 if (DwarfAccelTables == Default)
193 HasDwarfAccelTables = IsDarwin;
195 HasDwarfAccelTables = DwarfAccelTables == Enable;
197 if (SplitDwarf == Default)
198 HasSplitDwarf = false;
200 HasSplitDwarf = SplitDwarf == Enable;
202 if (DwarfPubSections == Default)
203 HasDwarfPubSections = !IsDarwin;
205 HasDwarfPubSections = DwarfPubSections == Enable;
207 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
210 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
214 DwarfDebug::~DwarfDebug() {
217 // Switch to the specified MCSection and emit an assembler
218 // temporary label to it if SymbolStem is specified.
219 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
220 const char *SymbolStem = 0) {
221 Asm->OutStreamer.SwitchSection(Section);
222 if (!SymbolStem) return 0;
224 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
225 Asm->OutStreamer.EmitLabel(TmpSym);
229 MCSymbol *DwarfUnits::getStringPoolSym() {
230 return Asm->GetTempSymbol(StringPref);
233 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
234 std::pair<MCSymbol*, unsigned> &Entry =
235 StringPool.GetOrCreateValue(Str).getValue();
236 if (Entry.first) return Entry.first;
238 Entry.second = NextStringPoolNumber++;
239 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
242 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
243 std::pair<MCSymbol*, unsigned> &Entry =
244 StringPool.GetOrCreateValue(Str).getValue();
245 if (Entry.first) return Entry.second;
247 Entry.second = NextStringPoolNumber++;
248 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
252 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
253 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
256 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
257 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
258 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
260 ++NextAddrPoolNumber;
261 return P.first->second;
264 // Define a unique number for the abbreviation.
266 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
267 // Check the set for priors.
268 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
270 // If it's newly added.
271 if (InSet == &Abbrev) {
272 // Add to abbreviation list.
273 Abbreviations->push_back(&Abbrev);
275 // Assign the vector position + 1 as its number.
276 Abbrev.setNumber(Abbreviations->size());
278 // Assign existing abbreviation number.
279 Abbrev.setNumber(InSet->getNumber());
283 static bool isObjCClass(StringRef Name) {
284 return Name.startswith("+") || Name.startswith("-");
287 static bool hasObjCCategory(StringRef Name) {
288 if (!isObjCClass(Name)) return false;
290 return Name.find(") ") != StringRef::npos;
293 static void getObjCClassCategory(StringRef In, StringRef &Class,
294 StringRef &Category) {
295 if (!hasObjCCategory(In)) {
296 Class = In.slice(In.find('[') + 1, In.find(' '));
301 Class = In.slice(In.find('[') + 1, In.find('('));
302 Category = In.slice(In.find('[') + 1, In.find(' '));
306 static StringRef getObjCMethodName(StringRef In) {
307 return In.slice(In.find(' ') + 1, In.find(']'));
310 // Add the various names to the Dwarf accelerator table names.
311 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
313 if (!SP.isDefinition()) return;
315 TheCU->addAccelName(SP.getName(), Die);
317 // If the linkage name is different than the name, go ahead and output
318 // that as well into the name table.
319 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
320 TheCU->addAccelName(SP.getLinkageName(), Die);
322 // If this is an Objective-C selector name add it to the ObjC accelerator
324 if (isObjCClass(SP.getName())) {
325 StringRef Class, Category;
326 getObjCClassCategory(SP.getName(), Class, Category);
327 TheCU->addAccelObjC(Class, Die);
329 TheCU->addAccelObjC(Category, Die);
330 // Also add the base method name to the name table.
331 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
335 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
336 // and DW_AT_high_pc attributes. If there are global variables in this
337 // scope then create and insert DIEs for these variables.
338 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
339 const MDNode *SPNode) {
340 DIE *SPDie = SPCU->getDIE(SPNode);
342 assert(SPDie && "Unable to find subprogram DIE!");
343 DISubprogram SP(SPNode);
345 // If we're updating an abstract DIE, then we will be adding the children and
346 // object pointer later on. But what we don't want to do is process the
347 // concrete DIE twice.
348 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
350 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
351 // Pick up abstract subprogram DIE.
352 SPDie = new DIE(dwarf::DW_TAG_subprogram);
353 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
355 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
356 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
360 DISubprogram SPDecl = SP.getFunctionDeclaration();
361 if (!SPDecl.isSubprogram()) {
362 // There is not any need to generate specification DIE for a function
363 // defined at compile unit level. If a function is defined inside another
364 // function then gdb prefers the definition at top level and but does not
365 // expect specification DIE in parent function. So avoid creating
366 // specification DIE for a function defined inside a function.
367 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
368 !SP.getContext().isFile() &&
369 !isSubprogramContext(SP.getContext())) {
370 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
373 DICompositeType SPTy = SP.getType();
374 DIArray Args = SPTy.getTypeArray();
375 uint16_t SPTag = SPTy.getTag();
376 if (SPTag == dwarf::DW_TAG_subroutine_type)
377 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
378 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
379 DIType ATy = DIType(Args.getElement(i));
380 SPCU->addType(Arg, ATy);
381 if (ATy.isArtificial())
382 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
383 if (ATy.isObjectPointer())
384 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
385 dwarf::DW_FORM_ref4, Arg);
386 SPDie->addChild(Arg);
388 DIE *SPDeclDie = SPDie;
389 SPDie = new DIE(dwarf::DW_TAG_subprogram);
390 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
391 dwarf::DW_FORM_ref4, SPDeclDie);
397 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
398 Asm->GetTempSymbol("func_begin",
399 Asm->getFunctionNumber()));
400 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
401 Asm->GetTempSymbol("func_end",
402 Asm->getFunctionNumber()));
403 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
404 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
405 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
407 // Add name to the name table, we do this here because we're guaranteed
408 // to have concrete versions of our DW_TAG_subprogram nodes.
409 addSubprogramNames(SPCU, SP, SPDie);
414 // Construct new DW_TAG_lexical_block for this scope and attach
415 // DW_AT_low_pc/DW_AT_high_pc labels.
416 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
417 LexicalScope *Scope) {
418 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
419 if (Scope->isAbstractScope())
422 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
426 // If we have multiple ranges, emit them into the range section.
427 if (Ranges.size() > 1) {
428 // .debug_range section has not been laid out yet. Emit offset in
429 // .debug_range as a uint, size 4, for now. emitDIE will handle
430 // DW_AT_ranges appropriately.
431 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
432 DebugRangeSymbols.size()
433 * Asm->getDataLayout().getPointerSize());
434 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
435 RE = Ranges.end(); RI != RE; ++RI) {
436 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
437 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
440 // Terminate the range list.
441 DebugRangeSymbols.push_back(NULL);
442 DebugRangeSymbols.push_back(NULL);
446 // Construct the address range for this DIE.
447 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
448 MCSymbol *Start = getLabelBeforeInsn(RI->first);
449 MCSymbol *End = getLabelAfterInsn(RI->second);
451 if (End == 0) return 0;
453 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
454 assert(End->isDefined() && "Invalid end label for an inlined scope!");
456 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
457 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
462 // This scope represents inlined body of a function. Construct DIE to
463 // represent this concrete inlined copy of the function.
464 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
465 LexicalScope *Scope) {
466 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
467 assert(Ranges.empty() == false &&
468 "LexicalScope does not have instruction markers!");
470 if (!Scope->getScopeNode())
472 DIScope DS(Scope->getScopeNode());
473 DISubprogram InlinedSP = getDISubprogram(DS);
474 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
476 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
480 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
481 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
482 dwarf::DW_FORM_ref4, OriginDIE);
484 if (Ranges.size() > 1) {
485 // .debug_range section has not been laid out yet. Emit offset in
486 // .debug_range as a uint, size 4, for now. emitDIE will handle
487 // DW_AT_ranges appropriately.
488 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
489 DebugRangeSymbols.size()
490 * Asm->getDataLayout().getPointerSize());
491 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
492 RE = Ranges.end(); RI != RE; ++RI) {
493 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
494 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
496 DebugRangeSymbols.push_back(NULL);
497 DebugRangeSymbols.push_back(NULL);
499 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
500 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
501 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
503 if (StartLabel == 0 || EndLabel == 0)
504 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
506 assert(StartLabel->isDefined() &&
507 "Invalid starting label for an inlined scope!");
508 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
510 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
511 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
514 InlinedSubprogramDIEs.insert(OriginDIE);
516 // Add the call site information to the DIE.
517 DILocation DL(Scope->getInlinedAt());
518 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
519 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
520 TheCU->getUniqueID()));
521 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
523 // Add name to the name table, we do this here because we're guaranteed
524 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
525 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
530 // Construct a DIE for this scope.
531 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
532 if (!Scope || !Scope->getScopeNode())
535 DIScope DS(Scope->getScopeNode());
536 // Early return to avoid creating dangling variable|scope DIEs.
537 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
541 SmallVector<DIE *, 8> Children;
542 DIE *ObjectPointer = NULL;
544 // Collect arguments for current function.
545 if (LScopes.isCurrentFunctionScope(Scope))
546 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
547 if (DbgVariable *ArgDV = CurrentFnArguments[i])
549 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
550 Children.push_back(Arg);
551 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
554 // Collect lexical scope children first.
555 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
556 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
558 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
559 Children.push_back(Variable);
560 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
562 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
563 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
564 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
565 Children.push_back(Nested);
566 DIE *ScopeDIE = NULL;
567 if (Scope->getInlinedAt())
568 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
569 else if (DS.isSubprogram()) {
570 ProcessedSPNodes.insert(DS);
571 if (Scope->isAbstractScope()) {
572 ScopeDIE = TheCU->getDIE(DS);
573 // Note down abstract DIE.
575 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
578 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
581 // There is no need to emit empty lexical block DIE.
582 std::pair<ImportedEntityMap::const_iterator,
583 ImportedEntityMap::const_iterator> Range = std::equal_range(
584 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
585 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
587 if (Children.empty() && Range.first == Range.second)
589 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
590 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
592 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
596 std::for_each(Children.begin(), Children.end(), deleter<DIE>);
601 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
602 E = Children.end(); I != E; ++I)
603 ScopeDIE->addChild(*I);
605 if (DS.isSubprogram() && ObjectPointer != NULL)
606 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
607 dwarf::DW_FORM_ref4, ObjectPointer);
609 if (DS.isSubprogram())
610 TheCU->addPubTypes(DISubprogram(DS));
615 // Look up the source id with the given directory and source file names.
616 // If none currently exists, create a new id and insert it in the
617 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
619 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
620 StringRef DirName, unsigned CUID) {
621 // If we use .loc in assembly, we can't separate .file entries according to
622 // compile units. Thus all files will belong to the default compile unit.
623 if (Asm->TM.hasMCUseLoc() &&
624 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
627 // If FE did not provide a file name, then assume stdin.
628 if (FileName.empty())
629 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
631 // TODO: this might not belong here. See if we can factor this better.
632 if (DirName == CompilationDir)
635 // FileIDCUMap stores the current ID for the given compile unit.
636 unsigned SrcId = FileIDCUMap[CUID] + 1;
638 // We look up the CUID/file/dir by concatenating them with a zero byte.
639 SmallString<128> NamePair;
640 NamePair += utostr(CUID);
643 NamePair += '\0'; // Zero bytes are not allowed in paths.
644 NamePair += FileName;
646 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
647 if (Ent.getValue() != SrcId)
648 return Ent.getValue();
650 FileIDCUMap[CUID] = SrcId;
651 // Print out a .file directive to specify files for .loc directives.
652 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
657 // Create new CompileUnit for the given metadata node with tag
658 // DW_TAG_compile_unit.
659 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
660 DICompileUnit DIUnit(N);
661 StringRef FN = DIUnit.getFilename();
662 CompilationDir = DIUnit.getDirectory();
664 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
666 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder);
668 FileIDCUMap[NewCU->getUniqueID()] = 0;
669 // Call this to emit a .file directive if it wasn't emitted for the source
670 // file this CU comes from yet.
671 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
673 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
674 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
675 DIUnit.getLanguage());
676 NewCU->addString(Die, dwarf::DW_AT_name, FN);
678 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
679 // into an entity. We're using 0 (or a NULL label) for this. For
680 // split dwarf it's in the skeleton CU so omit it here.
681 if (!useSplitDwarf())
682 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
684 // Define start line table label for each Compile Unit.
685 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
686 NewCU->getUniqueID());
687 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
688 NewCU->getUniqueID());
690 // Use a single line table if we are using .loc and generating assembly.
692 (Asm->TM.hasMCUseLoc() &&
693 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
694 (NewCU->getUniqueID() == 0);
696 // DW_AT_stmt_list is a offset of line number information for this
697 // compile unit in debug_line section. For split dwarf this is
698 // left in the skeleton CU and so not included.
699 // The line table entries are not always emitted in assembly, so it
700 // is not okay to use line_table_start here.
701 if (!useSplitDwarf()) {
702 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
703 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
705 Asm->GetTempSymbol("section_line") : LineTableStartSym);
706 else if (UseTheFirstCU)
707 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
709 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
710 LineTableStartSym, DwarfLineSectionSym);
713 // If we're using split dwarf the compilation dir is going to be in the
714 // skeleton CU and so we don't need to duplicate it here.
715 if (!useSplitDwarf() && !CompilationDir.empty())
716 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
717 if (DIUnit.isOptimized())
718 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
720 StringRef Flags = DIUnit.getFlags();
722 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
724 if (unsigned RVer = DIUnit.getRunTimeVersion())
725 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
726 dwarf::DW_FORM_data1, RVer);
731 InfoHolder.addUnit(NewCU);
733 CUMap.insert(std::make_pair(N, NewCU));
737 // Construct subprogram DIE.
738 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
740 CompileUnit *&CURef = SPMap[N];
746 if (!SP.isDefinition())
747 // This is a method declaration which will be handled while constructing
751 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
754 TheCU->insertDIE(N, SubprogramDie);
756 // Add to context owner.
757 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
759 // Expose as global, if requested.
760 if (HasDwarfPubSections)
761 TheCU->addGlobalName(SP.getName(), SubprogramDie);
764 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
766 DIImportedEntity Module(N);
767 if (!Module.Verify())
769 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
770 constructImportedEntityDIE(TheCU, Module, D);
773 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
775 DIImportedEntity Module(N);
776 if (!Module.Verify())
778 return constructImportedEntityDIE(TheCU, Module, Context);
781 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
782 const DIImportedEntity &Module,
784 assert(Module.Verify() &&
785 "Use one of the MDNode * overloads to handle invalid metadata");
786 assert(Context && "Should always have a context for an imported_module");
787 DIE *IMDie = new DIE(Module.getTag());
788 TheCU->insertDIE(Module, IMDie);
790 DIDescriptor Entity = Module.getEntity();
791 if (Entity.isNameSpace())
792 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
793 else if (Entity.isSubprogram())
794 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
795 else if (Entity.isType())
796 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
798 EntityDie = TheCU->getDIE(Entity);
799 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
800 Module.getContext().getDirectory(),
801 TheCU->getUniqueID());
802 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
803 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
804 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
806 StringRef Name = Module.getName();
808 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
809 Context->addChild(IMDie);
812 // Emit all Dwarf sections that should come prior to the content. Create
813 // global DIEs and emit initial debug info sections. This is invoked by
814 // the target AsmPrinter.
815 void DwarfDebug::beginModule() {
816 if (DisableDebugInfoPrinting)
819 const Module *M = MMI->getModule();
821 // If module has named metadata anchors then use them, otherwise scan the
822 // module using debug info finder to collect debug info.
823 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
826 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
828 // Emit initial sections so we can reference labels later.
831 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
832 DICompileUnit CUNode(CU_Nodes->getOperand(i));
833 CompileUnit *CU = constructCompileUnit(CUNode);
834 DIArray ImportedEntities = CUNode.getImportedEntities();
835 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
836 ScopesWithImportedEntities.push_back(std::make_pair(
837 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
838 ImportedEntities.getElement(i)));
839 std::sort(ScopesWithImportedEntities.begin(),
840 ScopesWithImportedEntities.end(), less_first());
841 DIArray GVs = CUNode.getGlobalVariables();
842 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
843 CU->createGlobalVariableDIE(GVs.getElement(i));
844 DIArray SPs = CUNode.getSubprograms();
845 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
846 constructSubprogramDIE(CU, SPs.getElement(i));
847 DIArray EnumTypes = CUNode.getEnumTypes();
848 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
849 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
850 DIArray RetainedTypes = CUNode.getRetainedTypes();
851 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
852 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
853 // Emit imported_modules last so that the relevant context is already
855 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
856 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
859 // Tell MMI that we have debug info.
860 MMI->setDebugInfoAvailability(true);
862 // Prime section data.
863 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
866 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
867 void DwarfDebug::computeInlinedDIEs() {
868 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
869 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
870 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
872 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
874 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
875 AE = AbstractSPDies.end(); AI != AE; ++AI) {
876 DIE *ISP = AI->second;
877 if (InlinedSubprogramDIEs.count(ISP))
879 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
883 // Collect info for variables that were optimized out.
884 void DwarfDebug::collectDeadVariables() {
885 const Module *M = MMI->getModule();
886 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
888 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
889 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
890 DICompileUnit TheCU(CU_Nodes->getOperand(i));
891 DIArray Subprograms = TheCU.getSubprograms();
892 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
893 DISubprogram SP(Subprograms.getElement(i));
894 if (ProcessedSPNodes.count(SP) != 0) continue;
895 if (!SP.isSubprogram()) continue;
896 if (!SP.isDefinition()) continue;
897 DIArray Variables = SP.getVariables();
898 if (Variables.getNumElements() == 0) continue;
900 LexicalScope *Scope =
901 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
902 DeadFnScopeMap[SP] = Scope;
904 // Construct subprogram DIE and add variables DIEs.
905 CompileUnit *SPCU = CUMap.lookup(TheCU);
906 assert(SPCU && "Unable to find Compile Unit!");
907 constructSubprogramDIE(SPCU, SP);
908 DIE *ScopeDIE = SPCU->getDIE(SP);
909 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
910 DIVariable DV(Variables.getElement(vi));
911 if (!DV.isVariable()) continue;
912 DbgVariable NewVar(DV, NULL);
913 if (DIE *VariableDIE =
914 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
915 ScopeDIE->addChild(VariableDIE);
920 DeleteContainerSeconds(DeadFnScopeMap);
923 // Type Signature [7.27] and ODR Hash code.
925 /// \brief Grabs the string in whichever attribute is passed in and returns
926 /// a reference to it. Returns "" if the attribute doesn't exist.
927 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
928 DIEValue *V = Die->findAttribute(Attr);
930 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
931 return S->getString();
933 return StringRef("");
936 /// Return true if the current DIE is contained within an anonymous namespace.
937 static bool isContainedInAnonNamespace(DIE *Die) {
938 DIE *Parent = Die->getParent();
941 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
942 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
944 Parent = Parent->getParent();
950 /// Test if the current CU language is C++ and that we have
951 /// a named type that is not contained in an anonymous namespace.
952 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
953 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
954 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
955 !isContainedInAnonNamespace(Die);
958 void DwarfDebug::finalizeModuleInfo() {
959 // Collect info for variables that were optimized out.
960 collectDeadVariables();
962 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
963 computeInlinedDIEs();
965 // Split out type units and conditionally add an ODR tag to the split
967 // FIXME: Do type splitting.
968 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
969 DIE *Die = TypeUnits[i];
971 // If we've requested ODR hashes and it's applicable for an ODR hash then
972 // add the ODR signature now.
973 // FIXME: This should be added onto the type unit, not the type, but this
974 // works as an intermediate stage.
975 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
976 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
977 dwarf::DW_FORM_data8,
978 Hash.computeDIEODRSignature(Die));
981 // Handle anything that needs to be done on a per-cu basis.
982 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
985 CompileUnit *TheCU = CUI->second;
986 // Emit DW_AT_containing_type attribute to connect types with their
987 // vtable holding type.
988 TheCU->constructContainingTypeDIEs();
990 // If we're splitting the dwarf out now that we've got the entire
991 // CU then construct a skeleton CU based upon it.
992 if (useSplitDwarf()) {
994 if (GenerateCUHash) {
996 ID = CUHash.computeCUSignature(TheCU->getCUDie());
998 // This should be a unique identifier when we want to build .dwp files.
999 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1000 dwarf::DW_FORM_data8, ID);
1001 // Now construct the skeleton CU associated.
1002 CompileUnit *SkCU = constructSkeletonCU(TheCU);
1003 // This should be a unique identifier when we want to build .dwp files.
1004 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1005 dwarf::DW_FORM_data8, ID);
1009 // Compute DIE offsets and sizes.
1010 InfoHolder.computeSizeAndOffsets();
1011 if (useSplitDwarf())
1012 SkeletonHolder.computeSizeAndOffsets();
1015 void DwarfDebug::endSections() {
1016 // Standard sections final addresses.
1017 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1018 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1019 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1020 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1022 // End text sections.
1023 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1024 Asm->OutStreamer.SwitchSection(SectionMap[I]);
1025 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1029 // Emit all Dwarf sections that should come after the content.
1030 void DwarfDebug::endModule() {
1032 if (!FirstCU) return;
1034 // End any existing sections.
1035 // TODO: Does this need to happen?
1038 // Finalize the debug info for the module.
1039 finalizeModuleInfo();
1041 if (!useSplitDwarf()) {
1042 // Emit all the DIEs into a debug info section.
1045 // Corresponding abbreviations into a abbrev section.
1046 emitAbbreviations();
1048 // Emit info into a debug loc section.
1051 // Emit info into a debug aranges section.
1054 // Emit info into a debug ranges section.
1057 // Emit info into a debug macinfo section.
1061 // TODO: Fill this in for separated debug sections and separate
1062 // out information into new sections.
1064 // Emit the debug info section and compile units.
1068 // Corresponding abbreviations into a abbrev section.
1069 emitAbbreviations();
1070 emitDebugAbbrevDWO();
1072 // Emit info into a debug loc section.
1075 // Emit info into a debug aranges section.
1078 // Emit info into a debug ranges section.
1081 // Emit info into a debug macinfo section.
1084 // Emit DWO addresses.
1085 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1089 // Emit info into the dwarf accelerator table sections.
1090 if (useDwarfAccelTables()) {
1093 emitAccelNamespaces();
1097 // Emit the pubnames and pubtypes sections if requested.
1098 if (HasDwarfPubSections) {
1099 emitDebugPubnames();
1100 emitDebugPubTypes();
1103 // Finally emit string information into a string table.
1105 if (useSplitDwarf())
1110 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1111 E = CUMap.end(); I != E; ++I)
1114 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1115 E = SkeletonCUs.end(); I != E; ++I)
1118 // Reset these for the next Module if we have one.
1122 // Find abstract variable, if any, associated with Var.
1123 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1124 DebugLoc ScopeLoc) {
1125 LLVMContext &Ctx = DV->getContext();
1126 // More then one inlined variable corresponds to one abstract variable.
1127 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1128 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1130 return AbsDbgVariable;
1132 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1136 AbsDbgVariable = new DbgVariable(Var, NULL);
1137 addScopeVariable(Scope, AbsDbgVariable);
1138 AbstractVariables[Var] = AbsDbgVariable;
1139 return AbsDbgVariable;
1142 // If Var is a current function argument then add it to CurrentFnArguments list.
1143 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1144 DbgVariable *Var, LexicalScope *Scope) {
1145 if (!LScopes.isCurrentFunctionScope(Scope))
1147 DIVariable DV = Var->getVariable();
1148 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1150 unsigned ArgNo = DV.getArgNumber();
1154 size_t Size = CurrentFnArguments.size();
1156 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1157 // llvm::Function argument size is not good indicator of how many
1158 // arguments does the function have at source level.
1160 CurrentFnArguments.resize(ArgNo * 2);
1161 CurrentFnArguments[ArgNo - 1] = Var;
1165 // Collect variable information from side table maintained by MMI.
1167 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1168 SmallPtrSet<const MDNode *, 16> &Processed) {
1169 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1170 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1171 VE = VMap.end(); VI != VE; ++VI) {
1172 const MDNode *Var = VI->first;
1174 Processed.insert(Var);
1176 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1178 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1180 // If variable scope is not found then skip this variable.
1184 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1185 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1186 RegVar->setFrameIndex(VP.first);
1187 if (!addCurrentFnArgument(MF, RegVar, Scope))
1188 addScopeVariable(Scope, RegVar);
1190 AbsDbgVariable->setFrameIndex(VP.first);
1194 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1196 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1197 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1198 return MI->getNumOperands() == 3 &&
1199 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1200 (MI->getOperand(1).isImm() ||
1201 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1204 // Get .debug_loc entry for the instruction range starting at MI.
1205 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1206 const MCSymbol *FLabel,
1207 const MCSymbol *SLabel,
1208 const MachineInstr *MI) {
1209 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1211 assert(MI->getNumOperands() == 3);
1212 if (MI->getOperand(0).isReg()) {
1213 MachineLocation MLoc;
1214 // If the second operand is an immediate, this is a
1215 // register-indirect address.
1216 if (!MI->getOperand(1).isImm())
1217 MLoc.set(MI->getOperand(0).getReg());
1219 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1220 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1222 if (MI->getOperand(0).isImm())
1223 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1224 if (MI->getOperand(0).isFPImm())
1225 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1226 if (MI->getOperand(0).isCImm())
1227 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1229 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1232 // Find variables for each lexical scope.
1234 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1235 SmallPtrSet<const MDNode *, 16> &Processed) {
1237 // Grab the variable info that was squirreled away in the MMI side-table.
1238 collectVariableInfoFromMMITable(MF, Processed);
1240 for (SmallVectorImpl<const MDNode*>::const_iterator
1241 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1243 const MDNode *Var = *UVI;
1244 if (Processed.count(Var))
1247 // History contains relevant DBG_VALUE instructions for Var and instructions
1249 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1250 if (History.empty())
1252 const MachineInstr *MInsn = History.front();
1255 LexicalScope *Scope = NULL;
1256 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1257 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1258 Scope = LScopes.getCurrentFunctionScope();
1259 else if (MDNode *IA = DV.getInlinedAt())
1260 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1262 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1263 // If variable scope is not found then skip this variable.
1267 Processed.insert(DV);
1268 assert(MInsn->isDebugValue() && "History must begin with debug value");
1269 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1270 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1271 if (!addCurrentFnArgument(MF, RegVar, Scope))
1272 addScopeVariable(Scope, RegVar);
1274 AbsVar->setMInsn(MInsn);
1276 // Simplify ranges that are fully coalesced.
1277 if (History.size() <= 1 || (History.size() == 2 &&
1278 MInsn->isIdenticalTo(History.back()))) {
1279 RegVar->setMInsn(MInsn);
1283 // Handle multiple DBG_VALUE instructions describing one variable.
1284 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1286 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1287 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1288 const MachineInstr *Begin = *HI;
1289 assert(Begin->isDebugValue() && "Invalid History entry");
1291 // Check if DBG_VALUE is truncating a range.
1292 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1293 && !Begin->getOperand(0).getReg())
1296 // Compute the range for a register location.
1297 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1298 const MCSymbol *SLabel = 0;
1301 // If Begin is the last instruction in History then its value is valid
1302 // until the end of the function.
1303 SLabel = FunctionEndSym;
1305 const MachineInstr *End = HI[1];
1306 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1307 << "\t" << *Begin << "\t" << *End << "\n");
1308 if (End->isDebugValue())
1309 SLabel = getLabelBeforeInsn(End);
1311 // End is a normal instruction clobbering the range.
1312 SLabel = getLabelAfterInsn(End);
1313 assert(SLabel && "Forgot label after clobber instruction");
1318 // The value is valid until the next DBG_VALUE or clobber.
1319 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1322 DotDebugLocEntries.push_back(DotDebugLocEntry());
1325 // Collect info for variables that were optimized out.
1326 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1327 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1328 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1329 DIVariable DV(Variables.getElement(i));
1330 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1332 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1333 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1337 // Return Label preceding the instruction.
1338 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1339 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1340 assert(Label && "Didn't insert label before instruction");
1344 // Return Label immediately following the instruction.
1345 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1346 return LabelsAfterInsn.lookup(MI);
1349 // Process beginning of an instruction.
1350 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1351 // Check if source location changes, but ignore DBG_VALUE locations.
1352 if (!MI->isDebugValue()) {
1353 DebugLoc DL = MI->getDebugLoc();
1354 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1357 if (DL == PrologEndLoc) {
1358 Flags |= DWARF2_FLAG_PROLOGUE_END;
1359 PrologEndLoc = DebugLoc();
1361 if (PrologEndLoc.isUnknown())
1362 Flags |= DWARF2_FLAG_IS_STMT;
1364 if (!DL.isUnknown()) {
1365 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1366 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1368 recordSourceLine(0, 0, 0, 0);
1372 // Insert labels where requested.
1373 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1374 LabelsBeforeInsn.find(MI);
1377 if (I == LabelsBeforeInsn.end())
1380 // Label already assigned.
1385 PrevLabel = MMI->getContext().CreateTempSymbol();
1386 Asm->OutStreamer.EmitLabel(PrevLabel);
1388 I->second = PrevLabel;
1391 // Process end of an instruction.
1392 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1393 // Don't create a new label after DBG_VALUE instructions.
1394 // They don't generate code.
1395 if (!MI->isDebugValue())
1398 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1399 LabelsAfterInsn.find(MI);
1402 if (I == LabelsAfterInsn.end())
1405 // Label already assigned.
1409 // We need a label after this instruction.
1411 PrevLabel = MMI->getContext().CreateTempSymbol();
1412 Asm->OutStreamer.EmitLabel(PrevLabel);
1414 I->second = PrevLabel;
1417 // Each LexicalScope has first instruction and last instruction to mark
1418 // beginning and end of a scope respectively. Create an inverse map that list
1419 // scopes starts (and ends) with an instruction. One instruction may start (or
1420 // end) multiple scopes. Ignore scopes that are not reachable.
1421 void DwarfDebug::identifyScopeMarkers() {
1422 SmallVector<LexicalScope *, 4> WorkList;
1423 WorkList.push_back(LScopes.getCurrentFunctionScope());
1424 while (!WorkList.empty()) {
1425 LexicalScope *S = WorkList.pop_back_val();
1427 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1428 if (!Children.empty())
1429 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1430 SE = Children.end(); SI != SE; ++SI)
1431 WorkList.push_back(*SI);
1433 if (S->isAbstractScope())
1436 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1439 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1440 RE = Ranges.end(); RI != RE; ++RI) {
1441 assert(RI->first && "InsnRange does not have first instruction!");
1442 assert(RI->second && "InsnRange does not have second instruction!");
1443 requestLabelBeforeInsn(RI->first);
1444 requestLabelAfterInsn(RI->second);
1449 // Get MDNode for DebugLoc's scope.
1450 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1451 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1452 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1453 return DL.getScope(Ctx);
1456 // Walk up the scope chain of given debug loc and find line number info
1457 // for the function.
1458 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1459 const MDNode *Scope = getScopeNode(DL, Ctx);
1460 DISubprogram SP = getDISubprogram(Scope);
1461 if (SP.isSubprogram()) {
1462 // Check for number of operands since the compatibility is
1464 if (SP->getNumOperands() > 19)
1465 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1467 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1473 // Gather pre-function debug information. Assumes being called immediately
1474 // after the function entry point has been emitted.
1475 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1476 if (!MMI->hasDebugInfo()) return;
1477 LScopes.initialize(*MF);
1478 if (LScopes.empty()) return;
1479 identifyScopeMarkers();
1481 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1483 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1484 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1485 assert(TheCU && "Unable to find compile unit!");
1486 if (Asm->TM.hasMCUseLoc() &&
1487 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1488 // Use a single line table if we are using .loc and generating assembly.
1489 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1491 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1493 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1494 Asm->getFunctionNumber());
1495 // Assumes in correct section after the entry point.
1496 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1498 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1500 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1501 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1502 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1504 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1506 bool AtBlockEntry = true;
1507 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1509 const MachineInstr *MI = II;
1511 if (MI->isDebugValue()) {
1512 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1514 // Keep track of user variables.
1516 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1518 // Variable is in a register, we need to check for clobbers.
1519 if (isDbgValueInDefinedReg(MI))
1520 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1522 // Check the history of this variable.
1523 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1524 if (History.empty()) {
1525 UserVariables.push_back(Var);
1526 // The first mention of a function argument gets the FunctionBeginSym
1527 // label, so arguments are visible when breaking at function entry.
1529 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1530 DISubprogram(getDISubprogram(DV.getContext()))
1531 .describes(MF->getFunction()))
1532 LabelsBeforeInsn[MI] = FunctionBeginSym;
1534 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1535 const MachineInstr *Prev = History.back();
1536 if (Prev->isDebugValue()) {
1537 // Coalesce identical entries at the end of History.
1538 if (History.size() >= 2 &&
1539 Prev->isIdenticalTo(History[History.size() - 2])) {
1540 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1542 << "\t" << *History[History.size() - 2] << "\n");
1546 // Terminate old register assignments that don't reach MI;
1547 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1548 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1549 isDbgValueInDefinedReg(Prev)) {
1550 // Previous register assignment needs to terminate at the end of
1552 MachineBasicBlock::const_iterator LastMI =
1553 PrevMBB->getLastNonDebugInstr();
1554 if (LastMI == PrevMBB->end()) {
1555 // Drop DBG_VALUE for empty range.
1556 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1557 << "\t" << *Prev << "\n");
1559 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1560 // Terminate after LastMI.
1561 History.push_back(LastMI);
1565 History.push_back(MI);
1567 // Not a DBG_VALUE instruction.
1569 AtBlockEntry = false;
1571 // First known non-DBG_VALUE and non-frame setup location marks
1572 // the beginning of the function body.
1573 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1574 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1575 PrologEndLoc = MI->getDebugLoc();
1577 // Check if the instruction clobbers any registers with debug vars.
1578 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1579 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1580 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1582 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1583 AI.isValid(); ++AI) {
1585 const MDNode *Var = LiveUserVar[Reg];
1588 // Reg is now clobbered.
1589 LiveUserVar[Reg] = 0;
1591 // Was MD last defined by a DBG_VALUE referring to Reg?
1592 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1593 if (HistI == DbgValues.end())
1595 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1596 if (History.empty())
1598 const MachineInstr *Prev = History.back();
1599 // Sanity-check: Register assignments are terminated at the end of
1601 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1603 // Is the variable still in Reg?
1604 if (!isDbgValueInDefinedReg(Prev) ||
1605 Prev->getOperand(0).getReg() != Reg)
1607 // Var is clobbered. Make sure the next instruction gets a label.
1608 History.push_back(MI);
1615 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1617 SmallVectorImpl<const MachineInstr*> &History = I->second;
1618 if (History.empty())
1621 // Make sure the final register assignments are terminated.
1622 const MachineInstr *Prev = History.back();
1623 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1624 const MachineBasicBlock *PrevMBB = Prev->getParent();
1625 MachineBasicBlock::const_iterator LastMI =
1626 PrevMBB->getLastNonDebugInstr();
1627 if (LastMI == PrevMBB->end())
1628 // Drop DBG_VALUE for empty range.
1630 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1631 // Terminate after LastMI.
1632 History.push_back(LastMI);
1635 // Request labels for the full history.
1636 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1637 const MachineInstr *MI = History[i];
1638 if (MI->isDebugValue())
1639 requestLabelBeforeInsn(MI);
1641 requestLabelAfterInsn(MI);
1645 PrevInstLoc = DebugLoc();
1646 PrevLabel = FunctionBeginSym;
1648 // Record beginning of function.
1649 if (!PrologEndLoc.isUnknown()) {
1650 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1651 MF->getFunction()->getContext());
1652 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1653 FnStartDL.getScope(MF->getFunction()->getContext()),
1654 // We'd like to list the prologue as "not statements" but GDB behaves
1655 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1656 DWARF2_FLAG_IS_STMT);
1660 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1661 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1662 DIVariable DV = Var->getVariable();
1663 // Variables with positive arg numbers are parameters.
1664 if (unsigned ArgNum = DV.getArgNumber()) {
1665 // Keep all parameters in order at the start of the variable list to ensure
1666 // function types are correct (no out-of-order parameters)
1668 // This could be improved by only doing it for optimized builds (unoptimized
1669 // builds have the right order to begin with), searching from the back (this
1670 // would catch the unoptimized case quickly), or doing a binary search
1671 // rather than linear search.
1672 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1673 while (I != Vars.end()) {
1674 unsigned CurNum = (*I)->getVariable().getArgNumber();
1675 // A local (non-parameter) variable has been found, insert immediately
1679 // A later indexed parameter has been found, insert immediately before it.
1680 if (CurNum > ArgNum)
1684 Vars.insert(I, Var);
1688 Vars.push_back(Var);
1691 // Gather and emit post-function debug information.
1692 void DwarfDebug::endFunction(const MachineFunction *MF) {
1693 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1695 // Define end label for subprogram.
1696 FunctionEndSym = Asm->GetTempSymbol("func_end",
1697 Asm->getFunctionNumber());
1698 // Assumes in correct section after the entry point.
1699 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1700 // Set DwarfCompileUnitID in MCContext to default value.
1701 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1703 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1704 collectVariableInfo(MF, ProcessedVars);
1706 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1707 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1708 assert(TheCU && "Unable to find compile unit!");
1710 // Construct abstract scopes.
1711 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1712 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1713 LexicalScope *AScope = AList[i];
1714 DISubprogram SP(AScope->getScopeNode());
1715 if (SP.isSubprogram()) {
1716 // Collect info for variables that were optimized out.
1717 DIArray Variables = SP.getVariables();
1718 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1719 DIVariable DV(Variables.getElement(i));
1720 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1722 // Check that DbgVariable for DV wasn't created earlier, when
1723 // findAbstractVariable() was called for inlined instance of DV.
1724 LLVMContext &Ctx = DV->getContext();
1725 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1726 if (AbstractVariables.lookup(CleanDV))
1728 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1729 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1732 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1733 constructScopeDIE(TheCU, AScope);
1736 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1738 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1739 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1742 for (ScopeVariablesMap::iterator
1743 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1744 DeleteContainerPointers(I->second);
1745 ScopeVariables.clear();
1746 DeleteContainerPointers(CurrentFnArguments);
1747 UserVariables.clear();
1749 AbstractVariables.clear();
1750 LabelsBeforeInsn.clear();
1751 LabelsAfterInsn.clear();
1755 // Register a source line with debug info. Returns the unique label that was
1756 // emitted and which provides correspondence to the source line list.
1757 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1763 DIDescriptor Scope(S);
1765 if (Scope.isCompileUnit()) {
1766 DICompileUnit CU(S);
1767 Fn = CU.getFilename();
1768 Dir = CU.getDirectory();
1769 } else if (Scope.isFile()) {
1771 Fn = F.getFilename();
1772 Dir = F.getDirectory();
1773 } else if (Scope.isSubprogram()) {
1775 Fn = SP.getFilename();
1776 Dir = SP.getDirectory();
1777 } else if (Scope.isLexicalBlockFile()) {
1778 DILexicalBlockFile DBF(S);
1779 Fn = DBF.getFilename();
1780 Dir = DBF.getDirectory();
1781 } else if (Scope.isLexicalBlock()) {
1782 DILexicalBlock DB(S);
1783 Fn = DB.getFilename();
1784 Dir = DB.getDirectory();
1786 llvm_unreachable("Unexpected scope info");
1788 Src = getOrCreateSourceID(Fn, Dir,
1789 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1791 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1794 //===----------------------------------------------------------------------===//
1796 //===----------------------------------------------------------------------===//
1798 // Compute the size and offset of a DIE.
1800 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1801 // Get the children.
1802 const std::vector<DIE *> &Children = Die->getChildren();
1804 // Record the abbreviation.
1805 assignAbbrevNumber(Die->getAbbrev());
1807 // Get the abbreviation for this DIE.
1808 unsigned AbbrevNumber = Die->getAbbrevNumber();
1809 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1812 Die->setOffset(Offset);
1814 // Start the size with the size of abbreviation code.
1815 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1817 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1818 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1820 // Size the DIE attribute values.
1821 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1822 // Size attribute value.
1823 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1825 // Size the DIE children if any.
1826 if (!Children.empty()) {
1827 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1828 "Children flag not set");
1830 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1831 Offset = computeSizeAndOffset(Children[j], Offset);
1833 // End of children marker.
1834 Offset += sizeof(int8_t);
1837 Die->setSize(Offset - Die->getOffset());
1841 // Compute the size and offset of all the DIEs.
1842 void DwarfUnits::computeSizeAndOffsets() {
1843 // Offset from the beginning of debug info section.
1844 unsigned SecOffset = 0;
1845 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1846 E = CUs.end(); I != E; ++I) {
1847 (*I)->setDebugInfoOffset(SecOffset);
1849 sizeof(int32_t) + // Length of Compilation Unit Info
1850 sizeof(int16_t) + // DWARF version number
1851 sizeof(int32_t) + // Offset Into Abbrev. Section
1852 sizeof(int8_t); // Pointer Size (in bytes)
1854 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1855 SecOffset += EndOffset;
1859 // Emit initial Dwarf sections with a label at the start of each one.
1860 void DwarfDebug::emitSectionLabels() {
1861 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1863 // Dwarf sections base addresses.
1864 DwarfInfoSectionSym =
1865 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1866 DwarfAbbrevSectionSym =
1867 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1868 if (useSplitDwarf())
1869 DwarfAbbrevDWOSectionSym =
1870 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1871 "section_abbrev_dwo");
1872 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1874 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1875 emitSectionSym(Asm, MacroInfo);
1877 DwarfLineSectionSym =
1878 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1879 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1880 if (HasDwarfPubSections) {
1881 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1882 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1884 DwarfStrSectionSym =
1885 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1886 if (useSplitDwarf()) {
1887 DwarfStrDWOSectionSym =
1888 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1889 DwarfAddrSectionSym =
1890 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1892 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1895 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1896 "section_debug_loc");
1898 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1899 emitSectionSym(Asm, TLOF.getDataSection());
1902 // Recursively emits a debug information entry.
1903 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1904 // Get the abbreviation for this DIE.
1905 unsigned AbbrevNumber = Die->getAbbrevNumber();
1906 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1908 // Emit the code (index) for the abbreviation.
1909 if (Asm->isVerbose())
1910 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1911 Twine::utohexstr(Die->getOffset()) + ":0x" +
1912 Twine::utohexstr(Die->getSize()) + " " +
1913 dwarf::TagString(Abbrev->getTag()));
1914 Asm->EmitULEB128(AbbrevNumber);
1916 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1917 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1919 // Emit the DIE attribute values.
1920 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1921 unsigned Attr = AbbrevData[i].getAttribute();
1922 unsigned Form = AbbrevData[i].getForm();
1923 assert(Form && "Too many attributes for DIE (check abbreviation)");
1925 if (Asm->isVerbose())
1926 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1929 case dwarf::DW_AT_abstract_origin: {
1930 DIEEntry *E = cast<DIEEntry>(Values[i]);
1931 DIE *Origin = E->getEntry();
1932 unsigned Addr = Origin->getOffset();
1933 if (Form == dwarf::DW_FORM_ref_addr) {
1934 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1935 // section. Origin->getOffset() returns the offset from start of the
1937 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1938 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1940 Asm->OutStreamer.EmitIntValue(Addr,
1941 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
1944 case dwarf::DW_AT_ranges: {
1945 // DW_AT_range Value encodes offset in debug_range section.
1946 DIEInteger *V = cast<DIEInteger>(Values[i]);
1948 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1949 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1953 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1955 DwarfDebugRangeSectionSym,
1960 case dwarf::DW_AT_location: {
1961 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1962 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1963 Asm->EmitLabelReference(L->getValue(), 4);
1965 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1967 Values[i]->EmitValue(Asm, Form);
1971 case dwarf::DW_AT_accessibility: {
1972 if (Asm->isVerbose()) {
1973 DIEInteger *V = cast<DIEInteger>(Values[i]);
1974 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1976 Values[i]->EmitValue(Asm, Form);
1980 // Emit an attribute using the defined form.
1981 Values[i]->EmitValue(Asm, Form);
1986 // Emit the DIE children if any.
1987 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1988 const std::vector<DIE *> &Children = Die->getChildren();
1990 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1991 emitDIE(Children[j], Abbrevs);
1993 if (Asm->isVerbose())
1994 Asm->OutStreamer.AddComment("End Of Children Mark");
1999 // Emit the various dwarf units to the unit section USection with
2000 // the abbreviations going into ASection.
2001 void DwarfUnits::emitUnits(DwarfDebug *DD,
2002 const MCSection *USection,
2003 const MCSection *ASection,
2004 const MCSymbol *ASectionSym) {
2005 Asm->OutStreamer.SwitchSection(USection);
2006 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2007 E = CUs.end(); I != E; ++I) {
2008 CompileUnit *TheCU = *I;
2009 DIE *Die = TheCU->getCUDie();
2011 // Emit the compile units header.
2013 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2014 TheCU->getUniqueID()));
2016 // Emit size of content not including length itself
2017 unsigned ContentSize = Die->getSize() +
2018 sizeof(int16_t) + // DWARF version number
2019 sizeof(int32_t) + // Offset Into Abbrev. Section
2020 sizeof(int8_t); // Pointer Size (in bytes)
2022 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2023 Asm->EmitInt32(ContentSize);
2024 Asm->OutStreamer.AddComment("DWARF version number");
2025 Asm->EmitInt16(DD->getDwarfVersion());
2026 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2027 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2029 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2030 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2032 DD->emitDIE(Die, Abbreviations);
2033 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2034 TheCU->getUniqueID()));
2038 /// For a given compile unit DIE, returns offset from beginning of debug info.
2039 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2040 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2041 "Input DIE should be compile unit in getCUOffset.");
2042 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2044 CompileUnit *TheCU = *I;
2045 if (TheCU->getCUDie() == Die)
2046 return TheCU->getDebugInfoOffset();
2048 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2051 // Emit the debug info section.
2052 void DwarfDebug::emitDebugInfo() {
2053 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2055 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2056 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2057 DwarfAbbrevSectionSym);
2060 // Emit the abbreviation section.
2061 void DwarfDebug::emitAbbreviations() {
2062 if (!useSplitDwarf())
2063 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2066 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2069 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2070 std::vector<DIEAbbrev *> *Abbrevs) {
2071 // Check to see if it is worth the effort.
2072 if (!Abbrevs->empty()) {
2073 // Start the debug abbrev section.
2074 Asm->OutStreamer.SwitchSection(Section);
2076 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2077 Asm->OutStreamer.EmitLabel(Begin);
2079 // For each abbrevation.
2080 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2081 // Get abbreviation data
2082 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2084 // Emit the abbrevations code (base 1 index.)
2085 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2087 // Emit the abbreviations data.
2091 // Mark end of abbreviations.
2092 Asm->EmitULEB128(0, "EOM(3)");
2094 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2095 Asm->OutStreamer.EmitLabel(End);
2099 // Emit the last address of the section and the end of the line matrix.
2100 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2101 // Define last address of section.
2102 Asm->OutStreamer.AddComment("Extended Op");
2105 Asm->OutStreamer.AddComment("Op size");
2106 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2107 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2108 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2110 Asm->OutStreamer.AddComment("Section end label");
2112 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2113 Asm->getDataLayout().getPointerSize());
2115 // Mark end of matrix.
2116 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2122 // Emit visible names into a hashed accelerator table section.
2123 void DwarfDebug::emitAccelNames() {
2124 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2125 dwarf::DW_FORM_data4));
2126 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2127 E = CUMap.end(); I != E; ++I) {
2128 CompileUnit *TheCU = I->second;
2129 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2130 for (StringMap<std::vector<DIE*> >::const_iterator
2131 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2132 StringRef Name = GI->getKey();
2133 const std::vector<DIE *> &Entities = GI->second;
2134 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2135 DE = Entities.end(); DI != DE; ++DI)
2136 AT.AddName(Name, (*DI));
2140 AT.FinalizeTable(Asm, "Names");
2141 Asm->OutStreamer.SwitchSection(
2142 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2143 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2144 Asm->OutStreamer.EmitLabel(SectionBegin);
2146 // Emit the full data.
2147 AT.Emit(Asm, SectionBegin, &InfoHolder);
2150 // Emit objective C classes and categories into a hashed accelerator table
2152 void DwarfDebug::emitAccelObjC() {
2153 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2154 dwarf::DW_FORM_data4));
2155 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2156 E = CUMap.end(); I != E; ++I) {
2157 CompileUnit *TheCU = I->second;
2158 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2159 for (StringMap<std::vector<DIE*> >::const_iterator
2160 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2161 StringRef Name = GI->getKey();
2162 const std::vector<DIE *> &Entities = GI->second;
2163 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2164 DE = Entities.end(); DI != DE; ++DI)
2165 AT.AddName(Name, (*DI));
2169 AT.FinalizeTable(Asm, "ObjC");
2170 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2171 .getDwarfAccelObjCSection());
2172 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2173 Asm->OutStreamer.EmitLabel(SectionBegin);
2175 // Emit the full data.
2176 AT.Emit(Asm, SectionBegin, &InfoHolder);
2179 // Emit namespace dies into a hashed accelerator table.
2180 void DwarfDebug::emitAccelNamespaces() {
2181 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2182 dwarf::DW_FORM_data4));
2183 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2184 E = CUMap.end(); I != E; ++I) {
2185 CompileUnit *TheCU = I->second;
2186 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2187 for (StringMap<std::vector<DIE*> >::const_iterator
2188 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2189 StringRef Name = GI->getKey();
2190 const std::vector<DIE *> &Entities = GI->second;
2191 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2192 DE = Entities.end(); DI != DE; ++DI)
2193 AT.AddName(Name, (*DI));
2197 AT.FinalizeTable(Asm, "namespac");
2198 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2199 .getDwarfAccelNamespaceSection());
2200 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2201 Asm->OutStreamer.EmitLabel(SectionBegin);
2203 // Emit the full data.
2204 AT.Emit(Asm, SectionBegin, &InfoHolder);
2207 // Emit type dies into a hashed accelerator table.
2208 void DwarfDebug::emitAccelTypes() {
2209 std::vector<DwarfAccelTable::Atom> Atoms;
2210 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2211 dwarf::DW_FORM_data4));
2212 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2213 dwarf::DW_FORM_data2));
2214 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2215 dwarf::DW_FORM_data1));
2216 DwarfAccelTable AT(Atoms);
2217 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2218 E = CUMap.end(); I != E; ++I) {
2219 CompileUnit *TheCU = I->second;
2220 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2221 = TheCU->getAccelTypes();
2222 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2223 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2224 StringRef Name = GI->getKey();
2225 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2226 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2227 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2228 AT.AddName(Name, (*DI).first, (*DI).second);
2232 AT.FinalizeTable(Asm, "types");
2233 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2234 .getDwarfAccelTypesSection());
2235 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2236 Asm->OutStreamer.EmitLabel(SectionBegin);
2238 // Emit the full data.
2239 AT.Emit(Asm, SectionBegin, &InfoHolder);
2242 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2244 void DwarfDebug::emitDebugPubnames() {
2245 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2247 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2248 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2249 CompileUnit *TheCU = I->second;
2250 unsigned ID = TheCU->getUniqueID();
2252 if (TheCU->getGlobalNames().empty())
2255 // Start the dwarf pubnames section.
2257 .SwitchSection(Asm->getObjFileLowering().getDwarfPubNamesSection());
2259 Asm->OutStreamer.AddComment("Length of Public Names Info");
2260 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2261 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2263 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2265 Asm->OutStreamer.AddComment("DWARF Version");
2266 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2268 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2269 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2270 DwarfInfoSectionSym);
2272 Asm->OutStreamer.AddComment("Compilation Unit Length");
2273 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2274 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2277 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2278 for (StringMap<DIE*>::const_iterator
2279 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2280 const char *Name = GI->getKeyData();
2281 const DIE *Entity = GI->second;
2283 Asm->OutStreamer.AddComment("DIE offset");
2284 Asm->EmitInt32(Entity->getOffset());
2286 if (Asm->isVerbose())
2287 Asm->OutStreamer.AddComment("External Name");
2288 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2291 Asm->OutStreamer.AddComment("End Mark");
2293 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2297 void DwarfDebug::emitDebugPubTypes() {
2298 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2299 E = CUMap.end(); I != E; ++I) {
2300 CompileUnit *TheCU = I->second;
2301 // Start the dwarf pubtypes section.
2302 Asm->OutStreamer.SwitchSection(
2303 Asm->getObjFileLowering().getDwarfPubTypesSection());
2304 Asm->OutStreamer.AddComment("Length of Public Types Info");
2305 Asm->EmitLabelDifference(
2306 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2307 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2309 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2310 TheCU->getUniqueID()));
2312 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2313 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2315 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2316 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2317 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2318 TheCU->getUniqueID()),
2319 DwarfInfoSectionSym);
2321 Asm->OutStreamer.AddComment("Compilation Unit Length");
2322 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2323 TheCU->getUniqueID()),
2324 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2325 TheCU->getUniqueID()),
2328 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2329 for (StringMap<DIE*>::const_iterator
2330 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2331 const char *Name = GI->getKeyData();
2332 DIE *Entity = GI->second;
2334 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2335 Asm->EmitInt32(Entity->getOffset());
2337 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2338 // Emit the name with a terminating null byte.
2339 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2342 Asm->OutStreamer.AddComment("End Mark");
2344 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2345 TheCU->getUniqueID()));
2349 // Emit strings into a string section.
2350 void DwarfUnits::emitStrings(const MCSection *StrSection,
2351 const MCSection *OffsetSection = NULL,
2352 const MCSymbol *StrSecSym = NULL) {
2354 if (StringPool.empty()) return;
2356 // Start the dwarf str section.
2357 Asm->OutStreamer.SwitchSection(StrSection);
2359 // Get all of the string pool entries and put them in an array by their ID so
2360 // we can sort them.
2361 SmallVector<std::pair<unsigned,
2362 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2364 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2365 I = StringPool.begin(), E = StringPool.end();
2367 Entries.push_back(std::make_pair(I->second.second, &*I));
2369 array_pod_sort(Entries.begin(), Entries.end());
2371 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2372 // Emit a label for reference from debug information entries.
2373 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2375 // Emit the string itself with a terminating null byte.
2376 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2377 Entries[i].second->getKeyLength()+1));
2380 // If we've got an offset section go ahead and emit that now as well.
2381 if (OffsetSection) {
2382 Asm->OutStreamer.SwitchSection(OffsetSection);
2383 unsigned offset = 0;
2384 unsigned size = 4; // FIXME: DWARF64 is 8.
2385 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2386 Asm->OutStreamer.EmitIntValue(offset, size);
2387 offset += Entries[i].second->getKeyLength() + 1;
2392 // Emit strings into a string section.
2393 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2395 if (AddressPool.empty()) return;
2397 // Start the dwarf addr section.
2398 Asm->OutStreamer.SwitchSection(AddrSection);
2400 // Order the address pool entries by ID
2401 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2403 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2404 E = AddressPool.end();
2406 Entries[I->second] = I->first;
2408 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2409 // Emit an expression for reference from debug information entries.
2410 if (const MCExpr *Expr = Entries[i])
2411 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2413 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2418 // Emit visible names into a debug str section.
2419 void DwarfDebug::emitDebugStr() {
2420 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2421 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2424 // Emit locations into the debug loc section.
2425 void DwarfDebug::emitDebugLoc() {
2426 if (DotDebugLocEntries.empty())
2429 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2430 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2432 DotDebugLocEntry &Entry = *I;
2433 if (I + 1 != DotDebugLocEntries.end())
2437 // Start the dwarf loc section.
2438 Asm->OutStreamer.SwitchSection(
2439 Asm->getObjFileLowering().getDwarfLocSection());
2440 unsigned char Size = Asm->getDataLayout().getPointerSize();
2441 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2443 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2444 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2445 I != E; ++I, ++index) {
2446 DotDebugLocEntry &Entry = *I;
2447 if (Entry.isMerged()) continue;
2448 if (Entry.isEmpty()) {
2449 Asm->OutStreamer.EmitIntValue(0, Size);
2450 Asm->OutStreamer.EmitIntValue(0, Size);
2451 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2453 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2454 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2455 DIVariable DV(Entry.getVariable());
2456 Asm->OutStreamer.AddComment("Loc expr size");
2457 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2458 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2459 Asm->EmitLabelDifference(end, begin, 2);
2460 Asm->OutStreamer.EmitLabel(begin);
2461 if (Entry.isInt()) {
2462 DIBasicType BTy(DV.getType());
2464 (BTy.getEncoding() == dwarf::DW_ATE_signed
2465 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2466 Asm->OutStreamer.AddComment("DW_OP_consts");
2467 Asm->EmitInt8(dwarf::DW_OP_consts);
2468 Asm->EmitSLEB128(Entry.getInt());
2470 Asm->OutStreamer.AddComment("DW_OP_constu");
2471 Asm->EmitInt8(dwarf::DW_OP_constu);
2472 Asm->EmitULEB128(Entry.getInt());
2474 } else if (Entry.isLocation()) {
2475 MachineLocation Loc = Entry.getLoc();
2476 if (!DV.hasComplexAddress())
2478 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2480 // Complex address entry.
2481 unsigned N = DV.getNumAddrElements();
2483 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2484 if (Loc.getOffset()) {
2486 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2487 Asm->OutStreamer.AddComment("DW_OP_deref");
2488 Asm->EmitInt8(dwarf::DW_OP_deref);
2489 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2490 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2491 Asm->EmitSLEB128(DV.getAddrElement(1));
2493 // If first address element is OpPlus then emit
2494 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2495 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2496 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2500 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2503 // Emit remaining complex address elements.
2504 for (; i < N; ++i) {
2505 uint64_t Element = DV.getAddrElement(i);
2506 if (Element == DIBuilder::OpPlus) {
2507 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2508 Asm->EmitULEB128(DV.getAddrElement(++i));
2509 } else if (Element == DIBuilder::OpDeref) {
2511 Asm->EmitInt8(dwarf::DW_OP_deref);
2513 llvm_unreachable("unknown Opcode found in complex address");
2517 // else ... ignore constant fp. There is not any good way to
2518 // to represent them here in dwarf.
2519 Asm->OutStreamer.EmitLabel(end);
2524 // Emit visible names into a debug aranges section.
2525 void DwarfDebug::emitDebugARanges() {
2526 // Start the dwarf aranges section.
2528 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2531 // Emit visible names into a debug ranges section.
2532 void DwarfDebug::emitDebugRanges() {
2533 // Start the dwarf ranges section.
2535 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2536 unsigned char Size = Asm->getDataLayout().getPointerSize();
2537 for (SmallVectorImpl<const MCSymbol *>::iterator
2538 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2541 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2543 Asm->OutStreamer.EmitIntValue(0, Size);
2547 // Emit visible names into a debug macinfo section.
2548 void DwarfDebug::emitDebugMacInfo() {
2549 if (const MCSection *LineInfo =
2550 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2551 // Start the dwarf macinfo section.
2552 Asm->OutStreamer.SwitchSection(LineInfo);
2556 // DWARF5 Experimental Separate Dwarf emitters.
2558 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2559 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2560 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2561 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2562 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2564 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2565 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2566 Asm, this, &SkeletonHolder);
2568 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2569 DICompileUnit(CU->getNode()).getSplitDebugFilename());
2571 // Relocate to the beginning of the addr_base section, else 0 for the
2572 // beginning of the one for this compile unit.
2573 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2574 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2575 DwarfAddrSectionSym);
2577 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2578 dwarf::DW_FORM_sec_offset, 0);
2580 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2581 // into an entity. We're using 0, or a NULL label for this.
2582 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2584 // DW_AT_stmt_list is a offset of line number information for this
2585 // compile unit in debug_line section.
2586 // FIXME: Should handle multiple compile units.
2587 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2588 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2589 DwarfLineSectionSym);
2591 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2593 if (!CompilationDir.empty())
2594 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2596 SkeletonHolder.addUnit(NewCU);
2597 SkeletonCUs.push_back(NewCU);
2602 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2603 assert(useSplitDwarf() && "No split dwarf debug info?");
2604 emitAbbrevs(Section, &SkeletonAbbrevs);
2607 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2608 // compile units that would normally be in debug_info.
2609 void DwarfDebug::emitDebugInfoDWO() {
2610 assert(useSplitDwarf() && "No split dwarf debug info?");
2611 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2612 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2613 DwarfAbbrevDWOSectionSym);
2616 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2617 // abbreviations for the .debug_info.dwo section.
2618 void DwarfDebug::emitDebugAbbrevDWO() {
2619 assert(useSplitDwarf() && "No split dwarf?");
2620 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2624 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2625 // string section and is identical in format to traditional .debug_str
2627 void DwarfDebug::emitDebugStrDWO() {
2628 assert(useSplitDwarf() && "No split dwarf?");
2629 const MCSection *OffSec = Asm->getObjFileLowering()
2630 .getDwarfStrOffDWOSection();
2631 const MCSymbol *StrSym = DwarfStrSectionSym;
2632 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2636 /// Find the MDNode for the given type reference.
2637 MDNode *DwarfDebug::resolve(DITypeRef TRef) const {
2638 return TRef.resolve(TypeIdentifierMap);