1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for writing dwarf debug info into asm files.
11 //
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
16 #include "DIE.h"
17 #include "DIEHash.h"
18 #include "DwarfAccelTable.h"
19 #include "DwarfUnit.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"
50 using namespace llvm;
52 static cl::opt<bool>
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."),
59 cl::init(false));
61 static cl::opt<bool> GenerateCUHash("generate-cu-hash", cl::Hidden,
62 cl::desc("Add the CU hash as the dwo_id."),
63 cl::init(false));
65 static cl::opt<bool>
66 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
67 cl::desc("Generate GNU-style pubnames and pubtypes"),
68 cl::init(false));
70 namespace {
71 enum DefaultOnOff { Default, Enable, Disable };
72 }
74 static cl::opt<DefaultOnOff>
75 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
76 cl::desc("Output prototype dwarf accelerator tables."),
77 cl::values(clEnumVal(Default, "Default for platform"),
78 clEnumVal(Enable, "Enabled"),
79 clEnumVal(Disable, "Disabled"), clEnumValEnd),
80 cl::init(Default));
82 static cl::opt<DefaultOnOff>
83 SplitDwarf("split-dwarf", cl::Hidden,
84 cl::desc("Output DWARF5 split debug info."),
85 cl::values(clEnumVal(Default, "Default for platform"),
86 clEnumVal(Enable, "Enabled"),
87 clEnumVal(Disable, "Disabled"), clEnumValEnd),
88 cl::init(Default));
90 static cl::opt<DefaultOnOff>
91 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
92 cl::desc("Generate DWARF pubnames and pubtypes sections"),
93 cl::values(clEnumVal(Default, "Default for platform"),
94 clEnumVal(Enable, "Enabled"),
95 clEnumVal(Disable, "Disabled"), clEnumValEnd),
96 cl::init(Default));
98 static cl::opt<unsigned>
99 DwarfVersionNumber("dwarf-version", cl::Hidden,
100 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
102 static cl::opt<bool>
103 DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
104 cl::desc("Generate DW_AT_ranges for compile units"),
105 cl::init(false));
107 static const char *const DWARFGroupName = "DWARF Emission";
108 static const char *const DbgTimerName = "DWARF Debug Writer";
110 //===----------------------------------------------------------------------===//
112 namespace llvm {
114 /// resolve - Look in the DwarfDebug map for the MDNode that
115 /// corresponds to the reference.
116 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
117 return DD->resolve(Ref);
118 }
120 DIType DbgVariable::getType() const {
121 DIType Ty = Var.getType();
122 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
123 // addresses instead.
124 if (Var.isBlockByrefVariable()) {
125 /* Byref variables, in Blocks, are declared by the programmer as
126 "SomeType VarName;", but the compiler creates a
127 __Block_byref_x_VarName struct, and gives the variable VarName
128 either the struct, or a pointer to the struct, as its type. This
129 is necessary for various behind-the-scenes things the compiler
130 needs to do with by-reference variables in blocks.
132 However, as far as the original *programmer* is concerned, the
133 variable should still have type 'SomeType', as originally declared.
135 The following function dives into the __Block_byref_x_VarName
136 struct to find the original type of the variable. This will be
137 passed back to the code generating the type for the Debug
138 Information Entry for the variable 'VarName'. 'VarName' will then
139 have the original type 'SomeType' in its debug information.
141 The original type 'SomeType' will be the type of the field named
142 'VarName' inside the __Block_byref_x_VarName struct.
144 NOTE: In order for this to not completely fail on the debugger
145 side, the Debug Information Entry for the variable VarName needs to
146 have a DW_AT_location that tells the debugger how to unwind through
147 the pointers and __Block_byref_x_VarName struct to find the actual
148 value of the variable. The function addBlockByrefType does this. */
149 DIType subType = Ty;
150 uint16_t tag = Ty.getTag();
152 if (tag == dwarf::DW_TAG_pointer_type)
153 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
155 DIArray Elements = DICompositeType(subType).getTypeArray();
156 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
157 DIDerivedType DT(Elements.getElement(i));
158 if (getName() == DT.getName())
159 return (resolve(DT.getTypeDerivedFrom()));
160 }
161 }
162 return Ty;
163 }
165 } // end llvm namespace
167 /// Return Dwarf Version by checking module flags.
168 static unsigned getDwarfVersionFromModule(const Module *M) {
169 Value *Val = M->getModuleFlag("Dwarf Version");
170 if (!Val)
171 return dwarf::DWARF_VERSION;
172 return cast<ConstantInt>(Val)->getZExtValue();
173 }
175 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
176 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
177 PrevLabel(NULL), GlobalRangeCount(0),
178 InfoHolder(A, "info_string", DIEValueAllocator), HasCURanges(false),
179 UsedNonDefaultText(false),
180 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
182 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
183 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
184 DwarfAddrSectionSym = 0;
185 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
186 FunctionBeginSym = FunctionEndSym = 0;
187 CurFn = 0;
188 CurMI = 0;
190 // Turn on accelerator tables for Darwin by default, pubnames by
191 // default for non-Darwin, and handle split dwarf.
192 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
194 if (DwarfAccelTables == Default)
195 HasDwarfAccelTables = IsDarwin;
196 else
197 HasDwarfAccelTables = DwarfAccelTables == Enable;
199 if (SplitDwarf == Default)
200 HasSplitDwarf = false;
201 else
202 HasSplitDwarf = SplitDwarf == Enable;
204 if (DwarfPubSections == Default)
205 HasDwarfPubSections = !IsDarwin;
206 else
207 HasDwarfPubSections = DwarfPubSections == Enable;
209 DwarfVersion = DwarfVersionNumber
210 ? DwarfVersionNumber
211 : getDwarfVersionFromModule(MMI->getModule());
213 {
214 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
215 beginModule();
216 }
217 }
219 // Switch to the specified MCSection and emit an assembler
220 // temporary label to it if SymbolStem is specified.
221 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
222 const char *SymbolStem = 0) {
223 Asm->OutStreamer.SwitchSection(Section);
224 if (!SymbolStem)
225 return 0;
227 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
228 Asm->OutStreamer.EmitLabel(TmpSym);
229 return TmpSym;
230 }
232 DwarfFile::~DwarfFile() {
233 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
234 I != E; ++I)
235 delete *I;
236 }
238 MCSymbol *DwarfFile::getStringPoolSym() {
239 return Asm->GetTempSymbol(StringPref);
240 }
242 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
243 std::pair<MCSymbol *, unsigned> &Entry =
244 StringPool.GetOrCreateValue(Str).getValue();
245 if (Entry.first)
246 return Entry.first;
248 Entry.second = NextStringPoolNumber++;
249 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
250 }
252 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
253 std::pair<MCSymbol *, unsigned> &Entry =
254 StringPool.GetOrCreateValue(Str).getValue();
255 if (Entry.first)
256 return Entry.second;
258 Entry.second = NextStringPoolNumber++;
259 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
260 return Entry.second;
261 }
263 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
264 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
265 }
267 unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
268 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
269 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
270 if (P.second)
271 ++NextAddrPoolNumber;
272 return P.first->second;
273 }
275 // Define a unique number for the abbreviation.
276 //
277 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
278 // Check the set for priors.
279 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
281 // If it's newly added.
282 if (InSet == &Abbrev) {
283 // Add to abbreviation list.
284 Abbreviations.push_back(&Abbrev);
286 // Assign the vector position + 1 as its number.
287 Abbrev.setNumber(Abbreviations.size());
288 } else {
289 // Assign existing abbreviation number.
290 Abbrev.setNumber(InSet->getNumber());
291 }
292 }
294 static bool isObjCClass(StringRef Name) {
295 return Name.startswith("+") || Name.startswith("-");
296 }
298 static bool hasObjCCategory(StringRef Name) {
299 if (!isObjCClass(Name))
300 return false;
302 return Name.find(") ") != StringRef::npos;
303 }
305 static void getObjCClassCategory(StringRef In, StringRef &Class,
306 StringRef &Category) {
307 if (!hasObjCCategory(In)) {
308 Class = In.slice(In.find('[') + 1, In.find(' '));
309 Category = "";
310 return;
311 }
313 Class = In.slice(In.find('[') + 1, In.find('('));
314 Category = In.slice(In.find('[') + 1, In.find(' '));
315 return;
316 }
318 static StringRef getObjCMethodName(StringRef In) {
319 return In.slice(In.find(' ') + 1, In.find(']'));
320 }
322 // Helper for sorting sections into a stable output order.
323 static bool SectionSort(const MCSection *A, const MCSection *B) {
324 std::string LA = (A ? A->getLabelBeginName() : "");
325 std::string LB = (B ? B->getLabelBeginName() : "");
326 return LA < LB;
327 }
329 // Add the various names to the Dwarf accelerator table names.
330 // TODO: Determine whether or not we should add names for programs
331 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
332 // is only slightly different than the lookup of non-standard ObjC names.
333 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
334 if (!SP.isDefinition())
335 return;
336 TheU->addAccelName(SP.getName(), Die);
338 // If the linkage name is different than the name, go ahead and output
339 // that as well into the name table.
340 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
341 TheU->addAccelName(SP.getLinkageName(), Die);
343 // If this is an Objective-C selector name add it to the ObjC accelerator
344 // too.
345 if (isObjCClass(SP.getName())) {
346 StringRef Class, Category;
347 getObjCClassCategory(SP.getName(), Class, Category);
348 TheU->addAccelObjC(Class, Die);
349 if (Category != "")
350 TheU->addAccelObjC(Category, Die);
351 // Also add the base method name to the name table.
352 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
353 }
354 }
356 /// isSubprogramContext - Return true if Context is either a subprogram
357 /// or another context nested inside a subprogram.
358 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
359 if (!Context)
360 return false;
361 DIDescriptor D(Context);
362 if (D.isSubprogram())
363 return true;
364 if (D.isType())
365 return isSubprogramContext(resolve(DIType(Context).getContext()));
366 return false;
367 }
369 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
370 // and DW_AT_high_pc attributes. If there are global variables in this
371 // scope then create and insert DIEs for these variables.
372 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
373 DISubprogram SP) {
374 DIE *SPDie = SPCU->getDIE(SP);
376 assert(SPDie && "Unable to find subprogram DIE!");
378 // If we're updating an abstract DIE, then we will be adding the children and
379 // object pointer later on. But what we don't want to do is process the
380 // concrete DIE twice.
381 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
382 // Pick up abstract subprogram DIE.
383 SPDie =
384 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
385 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
386 } else {
387 DISubprogram SPDecl = SP.getFunctionDeclaration();
388 if (!SPDecl.isSubprogram()) {
389 // There is not any need to generate specification DIE for a function
390 // defined at compile unit level. If a function is defined inside another
391 // function then gdb prefers the definition at top level and but does not
392 // expect specification DIE in parent function. So avoid creating
393 // specification DIE for a function defined inside a function.
394 DIScope SPContext = resolve(SP.getContext());
395 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
396 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
397 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
399 // Add arguments.
400 DICompositeType SPTy = SP.getType();
401 DIArray Args = SPTy.getTypeArray();
402 uint16_t SPTag = SPTy.getTag();
403 if (SPTag == dwarf::DW_TAG_subroutine_type)
404 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
405 DIE *Arg =
406 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
407 DIType ATy(Args.getElement(i));
408 SPCU->addType(Arg, ATy);
409 if (ATy.isArtificial())
410 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
411 if (ATy.isObjectPointer())
412 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
413 }
414 DIE *SPDeclDie = SPDie;
415 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
416 *SPCU->getUnitDie());
417 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
418 }
419 }
420 }
422 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
423 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
425 // Add this range to the list of ranges for the CU.
426 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
427 SPCU->addRange(llvm_move(Span));
429 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
430 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
431 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
433 // Add name to the name table, we do this here because we're guaranteed
434 // to have concrete versions of our DW_TAG_subprogram nodes.
435 addSubprogramNames(SPCU, SP, SPDie);
437 return SPDie;
438 }
440 /// Check whether we should create a DIE for the given Scope, return true
441 /// if we don't create a DIE (the corresponding DIE is null).
442 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
443 if (Scope->isAbstractScope())
444 return false;
446 // We don't create a DIE if there is no Range.
447 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
448 if (Ranges.empty())
449 return true;
451 if (Ranges.size() > 1)
452 return false;
454 // We don't create a DIE if we have a single Range and the end label
455 // is null.
456 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
457 MCSymbol *End = getLabelAfterInsn(RI->second);
458 return !End;
459 }
461 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
462 dwarf::Attribute A, const MCSymbol *L,
463 const MCSymbol *Sec) {
464 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
465 U->addSectionLabel(D, A, L);
466 else
467 U->addSectionDelta(D, A, L, Sec);
468 }
470 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
471 const SmallVectorImpl<InsnRange> &Range) {
472 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
473 // emitting it appropriately.
474 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
475 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
476 DwarfDebugRangeSectionSym);
478 RangeSpanList List(RangeSym);
479 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
480 RE = Range.end();
481 RI != RE; ++RI) {
482 RangeSpan Span(getLabelBeforeInsn(RI->first),
483 getLabelAfterInsn(RI->second));
484 List.addRange(llvm_move(Span));
485 }
487 // Add the range list to the set of ranges to be emitted.
488 TheCU->addRangeList(llvm_move(List));
489 }
491 // Construct new DW_TAG_lexical_block for this scope and attach
492 // DW_AT_low_pc/DW_AT_high_pc labels.
493 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
494 LexicalScope *Scope) {
495 if (isLexicalScopeDIENull(Scope))
496 return 0;
498 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
499 if (Scope->isAbstractScope())
500 return ScopeDIE;
502 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
504 // If we have multiple ranges, emit them into the range section.
505 if (ScopeRanges.size() > 1) {
506 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
507 return ScopeDIE;
508 }
510 // Construct the address range for this DIE.
511 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
512 MCSymbol *Start = getLabelBeforeInsn(RI->first);
513 MCSymbol *End = getLabelAfterInsn(RI->second);
514 assert(End && "End label should not be null!");
516 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
517 assert(End->isDefined() && "Invalid end label for an inlined scope!");
519 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
520 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
522 return ScopeDIE;
523 }
525 // This scope represents inlined body of a function. Construct DIE to
526 // represent this concrete inlined copy of the function.
527 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
528 LexicalScope *Scope) {
529 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
530 assert(!ScopeRanges.empty() &&
531 "LexicalScope does not have instruction markers!");
533 if (!Scope->getScopeNode())
534 return NULL;
535 DIScope DS(Scope->getScopeNode());
536 DISubprogram InlinedSP = getDISubprogram(DS);
537 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
538 if (!OriginDIE) {
539 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
540 return NULL;
541 }
543 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
544 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
546 // If we have multiple ranges, emit them into the range section.
547 if (ScopeRanges.size() > 1)
548 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
549 else {
550 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
551 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
552 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
554 if (StartLabel == 0 || EndLabel == 0)
555 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
557 assert(StartLabel->isDefined() &&
558 "Invalid starting label for an inlined scope!");
559 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
561 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
562 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
563 }
565 InlinedSubprogramDIEs.insert(OriginDIE);
567 // Add the call site information to the DIE.
568 DILocation DL(Scope->getInlinedAt());
569 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
570 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
571 TheCU->getUniqueID()));
572 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
574 // Add name to the name table, we do this here because we're guaranteed
575 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
576 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
578 return ScopeDIE;
579 }
581 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
582 LexicalScope *Scope,
583 SmallVectorImpl<DIE *> &Children) {
584 DIE *ObjectPointer = NULL;
586 // Collect arguments for current function.
587 if (LScopes.isCurrentFunctionScope(Scope))
588 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
589 if (DbgVariable *ArgDV = CurrentFnArguments[i])
590 if (DIE *Arg =
591 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
592 Children.push_back(Arg);
593 if (ArgDV->isObjectPointer())
594 ObjectPointer = Arg;
595 }
597 // Collect lexical scope children first.
598 const SmallVectorImpl<DbgVariable *> &Variables =
599 ScopeVariables.lookup(Scope);
600 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
601 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
602 Scope->isAbstractScope())) {
603 Children.push_back(Variable);
604 if (Variables[i]->isObjectPointer())
605 ObjectPointer = Variable;
606 }
607 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
608 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
609 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
610 Children.push_back(Nested);
611 return ObjectPointer;
612 }
614 // Construct a DIE for this scope.
615 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
616 LexicalScope *Scope) {
617 if (!Scope || !Scope->getScopeNode())
618 return NULL;
620 DIScope DS(Scope->getScopeNode());
622 SmallVector<DIE *, 8> Children;
623 DIE *ObjectPointer = NULL;
624 bool ChildrenCreated = false;
626 // We try to create the scope DIE first, then the children DIEs. This will
627 // avoid creating un-used children then removing them later when we find out
628 // the scope DIE is null.
629 DIE *ScopeDIE = NULL;
630 if (Scope->getInlinedAt())
631 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
632 else if (DS.isSubprogram()) {
633 ProcessedSPNodes.insert(DS);
634 if (Scope->isAbstractScope()) {
635 ScopeDIE = TheCU->getDIE(DS);
636 // Note down abstract DIE.
637 if (ScopeDIE)
638 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
639 } else
640 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
641 } else {
642 // Early exit when we know the scope DIE is going to be null.
643 if (isLexicalScopeDIENull(Scope))
644 return NULL;
646 // We create children here when we know the scope DIE is not going to be
647 // null and the children will be added to the scope DIE.
648 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
649 ChildrenCreated = true;
651 // There is no need to emit empty lexical block DIE.
652 std::pair<ImportedEntityMap::const_iterator,
653 ImportedEntityMap::const_iterator> Range =
654 std::equal_range(
655 ScopesWithImportedEntities.begin(),
656 ScopesWithImportedEntities.end(),
657 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
658 less_first());
659 if (Children.empty() && Range.first == Range.second)
660 return NULL;
661 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
662 assert(ScopeDIE && "Scope DIE should not be null.");
663 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
664 ++i)
665 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
666 }
668 if (!ScopeDIE) {
669 assert(Children.empty() &&
670 "We create children only when the scope DIE is not null.");
671 return NULL;
672 }
673 if (!ChildrenCreated)
674 // We create children when the scope DIE is not null.
675 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
677 // Add children
678 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
679 E = Children.end();
680 I != E; ++I)
681 ScopeDIE->addChild(*I);
683 if (DS.isSubprogram() && ObjectPointer != NULL)
684 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
686 return ScopeDIE;
687 }
689 // Look up the source id with the given directory and source file names.
690 // If none currently exists, create a new id and insert it in the
691 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
692 // as well.
693 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
694 unsigned CUID) {
695 // If we use .loc in assembly, we can't separate .file entries according to
696 // compile units. Thus all files will belong to the default compile unit.
698 // FIXME: add a better feature test than hasRawTextSupport. Even better,
699 // extend .file to support this.
700 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
701 CUID = 0;
703 // If FE did not provide a file name, then assume stdin.
704 if (FileName.empty())
705 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
707 // TODO: this might not belong here. See if we can factor this better.
708 if (DirName == CompilationDir)
709 DirName = "";
711 // FileIDCUMap stores the current ID for the given compile unit.
712 unsigned SrcId = FileIDCUMap[CUID] + 1;
714 // We look up the CUID/file/dir by concatenating them with a zero byte.
715 SmallString<128> NamePair;
716 NamePair += utostr(CUID);
717 NamePair += '\0';
718 NamePair += DirName;
719 NamePair += '\0'; // Zero bytes are not allowed in paths.
720 NamePair += FileName;
722 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
723 if (Ent.getValue() != SrcId)
724 return Ent.getValue();
726 FileIDCUMap[CUID] = SrcId;
727 // Print out a .file directive to specify files for .loc directives.
728 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
730 return SrcId;
731 }
733 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
734 if (!GenerateGnuPubSections)
735 return;
737 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
738 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
739 DwarfGnuPubNamesSectionSym);
741 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
742 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
743 DwarfGnuPubTypesSectionSym);
744 }
746 // Create new DwarfCompileUnit for the given metadata node with tag
747 // DW_TAG_compile_unit.
748 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
749 StringRef FN = DIUnit.getFilename();
750 CompilationDir = DIUnit.getDirectory();
752 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
753 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
754 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
755 InfoHolder.addUnit(NewCU);
757 FileIDCUMap[NewCU->getUniqueID()] = 0;
758 // Call this to emit a .file directive if it wasn't emitted for the source
759 // file this CU comes from yet.
760 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
762 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
763 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
764 DIUnit.getLanguage());
765 NewCU->addString(Die, dwarf::DW_AT_name, FN);
767 // Define start line table label for each Compile Unit.
768 MCSymbol *LineTableStartSym =
769 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
770 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
771 NewCU->getUniqueID());
773 // Use a single line table if we are using .loc and generating assembly.
774 bool UseTheFirstCU =
775 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
776 (NewCU->getUniqueID() == 0);
778 if (!useSplitDwarf()) {
779 // DW_AT_stmt_list is a offset of line number information for this
780 // compile unit in debug_line section. For split dwarf this is
781 // left in the skeleton CU and so not included.
782 // The line table entries are not always emitted in assembly, so it
783 // is not okay to use line_table_start here.
784 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
785 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
786 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
787 : LineTableStartSym);
788 else if (UseTheFirstCU)
789 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
790 else
791 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
792 DwarfLineSectionSym);
794 // If we're using split dwarf the compilation dir is going to be in the
795 // skeleton CU and so we don't need to duplicate it here.
796 if (!CompilationDir.empty())
797 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
799 addGnuPubAttributes(NewCU, Die);
800 }
802 if (DIUnit.isOptimized())
803 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
805 StringRef Flags = DIUnit.getFlags();
806 if (!Flags.empty())
807 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
809 if (unsigned RVer = DIUnit.getRunTimeVersion())
810 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
811 dwarf::DW_FORM_data1, RVer);
813 if (!FirstCU)
814 FirstCU = NewCU;
816 if (useSplitDwarf()) {
817 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
818 DwarfInfoDWOSectionSym);
819 NewCU->setSkeleton(constructSkeletonCU(NewCU));
820 } else
821 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
822 DwarfInfoSectionSym);
824 CUMap.insert(std::make_pair(DIUnit, NewCU));
825 CUDieMap.insert(std::make_pair(Die, NewCU));
826 return NewCU;
827 }
829 // Construct subprogram DIE.
830 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
831 const MDNode *N) {
832 // FIXME: We should only call this routine once, however, during LTO if a
833 // program is defined in multiple CUs we could end up calling it out of
834 // beginModule as we walk the CUs.
836 DwarfCompileUnit *&CURef = SPMap[N];
837 if (CURef)
838 return;
839 CURef = TheCU;
841 DISubprogram SP(N);
842 if (!SP.isDefinition())
843 // This is a method declaration which will be handled while constructing
844 // class type.
845 return;
847 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
849 // Expose as a global name.
850 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
851 }
853 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
854 const MDNode *N) {
855 DIImportedEntity Module(N);
856 if (!Module.Verify())
857 return;
858 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
859 constructImportedEntityDIE(TheCU, Module, D);
860 }
862 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
863 const MDNode *N, DIE *Context) {
864 DIImportedEntity Module(N);
865 if (!Module.Verify())
866 return;
867 return constructImportedEntityDIE(TheCU, Module, Context);
868 }
870 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
871 const DIImportedEntity &Module,
872 DIE *Context) {
873 assert(Module.Verify() &&
874 "Use one of the MDNode * overloads to handle invalid metadata");
875 assert(Context && "Should always have a context for an imported_module");
876 DIE *IMDie = new DIE(Module.getTag());
877 TheCU->insertDIE(Module, IMDie);
878 DIE *EntityDie;
879 DIDescriptor Entity = Module.getEntity();
880 if (Entity.isNameSpace())
881 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
882 else if (Entity.isSubprogram())
883 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
884 else if (Entity.isType())
885 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
886 else
887 EntityDie = TheCU->getDIE(Entity);
888 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
889 Module.getContext().getDirectory(),
890 TheCU->getUniqueID());
891 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
892 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
893 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
894 StringRef Name = Module.getName();
895 if (!Name.empty())
896 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
897 Context->addChild(IMDie);
898 }
900 // Emit all Dwarf sections that should come prior to the content. Create
901 // global DIEs and emit initial debug info sections. This is invoked by
902 // the target AsmPrinter.
903 void DwarfDebug::beginModule() {
904 if (DisableDebugInfoPrinting)
905 return;
907 const Module *M = MMI->getModule();
909 // If module has named metadata anchors then use them, otherwise scan the
910 // module using debug info finder to collect debug info.
911 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
912 if (!CU_Nodes)
913 return;
914 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
916 // Emit initial sections so we can reference labels later.
917 emitSectionLabels();
919 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
920 DICompileUnit CUNode(CU_Nodes->getOperand(i));
921 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
922 DIArray ImportedEntities = CUNode.getImportedEntities();
923 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
924 ScopesWithImportedEntities.push_back(std::make_pair(
925 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
926 ImportedEntities.getElement(i)));
927 std::sort(ScopesWithImportedEntities.begin(),
928 ScopesWithImportedEntities.end(), less_first());
929 DIArray GVs = CUNode.getGlobalVariables();
930 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
931 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
932 DIArray SPs = CUNode.getSubprograms();
933 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
934 constructSubprogramDIE(CU, SPs.getElement(i));
935 DIArray EnumTypes = CUNode.getEnumTypes();
936 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
937 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
938 DIArray RetainedTypes = CUNode.getRetainedTypes();
939 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
940 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
941 // Emit imported_modules last so that the relevant context is already
942 // available.
943 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
944 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
945 }
947 // Tell MMI that we have debug info.
948 MMI->setDebugInfoAvailability(true);
950 // Prime section data.
951 SectionMap[Asm->getObjFileLowering().getTextSection()];
952 }
954 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
955 void DwarfDebug::computeInlinedDIEs() {
956 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
957 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
958 AE = InlinedSubprogramDIEs.end();
959 AI != AE; ++AI) {
960 DIE *ISP = *AI;
961 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
962 }
963 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
964 AE = AbstractSPDies.end();
965 AI != AE; ++AI) {
966 DIE *ISP = AI->second;
967 if (InlinedSubprogramDIEs.count(ISP))
968 continue;
969 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
970 }
971 }
973 // Collect info for variables that were optimized out.
974 void DwarfDebug::collectDeadVariables() {
975 const Module *M = MMI->getModule();
977 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
978 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
979 DICompileUnit TheCU(CU_Nodes->getOperand(i));
980 DIArray Subprograms = TheCU.getSubprograms();
981 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
982 DISubprogram SP(Subprograms.getElement(i));
983 if (ProcessedSPNodes.count(SP) != 0)
984 continue;
985 if (!SP.isSubprogram())
986 continue;
987 if (!SP.isDefinition())
988 continue;
989 DIArray Variables = SP.getVariables();
990 if (Variables.getNumElements() == 0)
991 continue;
993 // Construct subprogram DIE and add variables DIEs.
994 DwarfCompileUnit *SPCU =
995 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
996 assert(SPCU && "Unable to find Compile Unit!");
997 // FIXME: See the comment in constructSubprogramDIE about duplicate
998 // subprogram DIEs.
999 constructSubprogramDIE(SPCU, SP);
1000 DIE *SPDIE = SPCU->getDIE(SP);
1001 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1002 DIVariable DV(Variables.getElement(vi));
1003 if (!DV.isVariable())
1004 continue;
1005 DbgVariable NewVar(DV, NULL, this);
1006 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1007 SPDIE->addChild(VariableDIE);
1008 }
1009 }
1010 }
1011 }
1012 }
1014 void DwarfDebug::finalizeModuleInfo() {
1015 // Collect info for variables that were optimized out.
1016 collectDeadVariables();
1018 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1019 computeInlinedDIEs();
1021 // Handle anything that needs to be done on a per-unit basis after
1022 // all other generation.
1023 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1024 E = getUnits().end();
1025 I != E; ++I) {
1026 DwarfUnit *TheU = *I;
1027 // Emit DW_AT_containing_type attribute to connect types with their
1028 // vtable holding type.
1029 TheU->constructContainingTypeDIEs();
1031 // Add CU specific attributes if we need to add any.
1032 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1033 // If we're splitting the dwarf out now that we've got the entire
1034 // CU then add the dwo id to it.
1035 DwarfCompileUnit *SkCU =
1036 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1037 if (useSplitDwarf()) {
1038 // This should be a unique identifier when we want to build .dwp files.
1039 uint64_t ID = 0;
1040 if (GenerateCUHash) {
1041 DIEHash CUHash;
1042 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1043 }
1044 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1045 dwarf::DW_FORM_data8, ID);
1046 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1047 dwarf::DW_FORM_data8, ID);
1048 }
1050 // If we have code split among multiple sections or we've requested
1051 // it then emit a DW_AT_ranges attribute on the unit that will remain
1052 // in the .o file, otherwise add a DW_AT_low_pc.
1053 // FIXME: Also add a high pc if we can.
1054 // FIXME: We should use ranges if we have multiple compile units or
1055 // allow reordering of code ala .subsections_via_symbols in mach-o.
1056 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1057 if (useCURanges() && TheU->getRanges().size())
1058 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1059 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1060 DwarfDebugRangeSectionSym);
1061 else
1062 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1063 0);
1064 }
1065 }
1067 // Compute DIE offsets and sizes.
1068 InfoHolder.computeSizeAndOffsets();
1069 if (useSplitDwarf())
1070 SkeletonHolder.computeSizeAndOffsets();
1071 }
1073 void DwarfDebug::endSections() {
1074 // Filter labels by section.
1075 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1076 const SymbolCU &SCU = ArangeLabels[n];
1077 if (SCU.Sym->isInSection()) {
1078 // Make a note of this symbol and it's section.
1079 const MCSection *Section = &SCU.Sym->getSection();
1080 if (!Section->getKind().isMetadata())
1081 SectionMap[Section].push_back(SCU);
1082 } else {
1083 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1084 // appear in the output. This sucks as we rely on sections to build
1085 // arange spans. We can do it without, but it's icky.
1086 SectionMap[NULL].push_back(SCU);
1087 }
1088 }
1090 // Build a list of sections used.
1091 std::vector<const MCSection *> Sections;
1092 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1093 it++) {
1094 const MCSection *Section = it->first;
1095 Sections.push_back(Section);
1096 }
1098 // Sort the sections into order.
1099 // This is only done to ensure consistent output order across different runs.
1100 std::sort(Sections.begin(), Sections.end(), SectionSort);
1102 // Add terminating symbols for each section.
1103 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1104 const MCSection *Section = Sections[ID];
1105 MCSymbol *Sym = NULL;
1107 if (Section) {
1108 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1109 // if we know the section name up-front. For user-created sections, the
1110 // resulting label may not be valid to use as a label. (section names can
1111 // use a greater set of characters on some systems)
1112 Sym = Asm->GetTempSymbol("debug_end", ID);
1113 Asm->OutStreamer.SwitchSection(Section);
1114 Asm->OutStreamer.EmitLabel(Sym);
1115 }
1117 // Insert a final terminator.
1118 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1119 }
1121 // For now only turn on CU ranges if we've explicitly asked for it,
1122 // we have -ffunction-sections enabled, or we've emitted a function
1123 // into a unique section. At this point all sections should be finalized
1124 // except for dwarf sections.
1125 HasCURanges = DwarfCURanges || UsedNonDefaultText ||
1126 TargetMachine::getFunctionSections();
1127 }
1129 // Emit all Dwarf sections that should come after the content.
1130 void DwarfDebug::endModule() {
1131 assert(CurFn == 0);
1132 assert(CurMI == 0);
1134 if (!FirstCU)
1135 return;
1137 // End any existing sections.
1138 // TODO: Does this need to happen?
1139 endSections();
1141 // Finalize the debug info for the module.
1142 finalizeModuleInfo();
1144 emitDebugStr();
1146 // Emit all the DIEs into a debug info section.
1147 emitDebugInfo();
1149 // Corresponding abbreviations into a abbrev section.
1150 emitAbbreviations();
1152 // Emit info into a debug loc section.
1153 emitDebugLoc();
1155 // Emit info into a debug aranges section.
1156 emitDebugARanges();
1158 // Emit info into a debug ranges section.
1159 emitDebugRanges();
1161 if (useSplitDwarf()) {
1162 emitDebugStrDWO();
1163 emitDebugInfoDWO();
1164 emitDebugAbbrevDWO();
1165 // Emit DWO addresses.
1166 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1167 }
1169 // Emit info into the dwarf accelerator table sections.
1170 if (useDwarfAccelTables()) {
1171 emitAccelNames();
1172 emitAccelObjC();
1173 emitAccelNamespaces();
1174 emitAccelTypes();
1175 }
1177 // Emit the pubnames and pubtypes sections if requested.
1178 if (HasDwarfPubSections) {
1179 emitDebugPubNames(GenerateGnuPubSections);
1180 emitDebugPubTypes(GenerateGnuPubSections);
1181 }
1183 // clean up.
1184 SPMap.clear();
1186 // Reset these for the next Module if we have one.
1187 FirstCU = NULL;
1188 }
1190 // Find abstract variable, if any, associated with Var.
1191 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1192 DebugLoc ScopeLoc) {
1193 LLVMContext &Ctx = DV->getContext();
1194 // More then one inlined variable corresponds to one abstract variable.
1195 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1196 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1197 if (AbsDbgVariable)
1198 return AbsDbgVariable;
1200 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1201 if (!Scope)
1202 return NULL;
1204 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1205 addScopeVariable(Scope, AbsDbgVariable);
1206 AbstractVariables[Var] = AbsDbgVariable;
1207 return AbsDbgVariable;
1208 }
1210 // If Var is a current function argument then add it to CurrentFnArguments list.
1211 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1212 if (!LScopes.isCurrentFunctionScope(Scope))
1213 return false;
1214 DIVariable DV = Var->getVariable();
1215 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1216 return false;
1217 unsigned ArgNo = DV.getArgNumber();
1218 if (ArgNo == 0)
1219 return false;
1221 size_t Size = CurrentFnArguments.size();
1222 if (Size == 0)
1223 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1224 // llvm::Function argument size is not good indicator of how many
1225 // arguments does the function have at source level.
1226 if (ArgNo > Size)
1227 CurrentFnArguments.resize(ArgNo * 2);
1228 CurrentFnArguments[ArgNo - 1] = Var;
1229 return true;
1230 }
1232 // Collect variable information from side table maintained by MMI.
1233 void DwarfDebug::collectVariableInfoFromMMITable(
1234 SmallPtrSet<const MDNode *, 16> &Processed) {
1235 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1236 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1237 VE = VMap.end();
1238 VI != VE; ++VI) {
1239 const MDNode *Var = VI->first;
1240 if (!Var)
1241 continue;
1242 Processed.insert(Var);
1243 DIVariable DV(Var);
1244 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1246 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1248 // If variable scope is not found then skip this variable.
1249 if (Scope == 0)
1250 continue;
1252 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1253 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1254 RegVar->setFrameIndex(VP.first);
1255 if (!addCurrentFnArgument(RegVar, Scope))
1256 addScopeVariable(Scope, RegVar);
1257 if (AbsDbgVariable)
1258 AbsDbgVariable->setFrameIndex(VP.first);
1259 }
1260 }
1262 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1263 // defined reg.
1264 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1265 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1266 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1267 MI->getOperand(0).getReg() &&
1268 (MI->getOperand(1).isImm() ||
1269 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1270 }
1272 // Get .debug_loc entry for the instruction range starting at MI.
1273 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1274 const MCSymbol *FLabel,
1275 const MCSymbol *SLabel,
1276 const MachineInstr *MI) {
1277 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1279 assert(MI->getNumOperands() == 3);
1280 if (MI->getOperand(0).isReg()) {
1281 MachineLocation MLoc;
1282 // If the second operand is an immediate, this is a
1283 // register-indirect address.
1284 if (!MI->getOperand(1).isImm())
1285 MLoc.set(MI->getOperand(0).getReg());
1286 else
1287 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1288 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1289 }
1290 if (MI->getOperand(0).isImm())
1291 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1292 if (MI->getOperand(0).isFPImm())
1293 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1294 if (MI->getOperand(0).isCImm())
1295 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1297 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1298 }
1300 // Find variables for each lexical scope.
1301 void
1302 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1304 // Grab the variable info that was squirreled away in the MMI side-table.
1305 collectVariableInfoFromMMITable(Processed);
1307 for (SmallVectorImpl<const MDNode *>::const_iterator
1308 UVI = UserVariables.begin(),
1309 UVE = UserVariables.end();
1310 UVI != UVE; ++UVI) {
1311 const MDNode *Var = *UVI;
1312 if (Processed.count(Var))
1313 continue;
1315 // History contains relevant DBG_VALUE instructions for Var and instructions
1316 // clobbering it.
1317 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1318 if (History.empty())
1319 continue;
1320 const MachineInstr *MInsn = History.front();
1322 DIVariable DV(Var);
1323 LexicalScope *Scope = NULL;
1324 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1325 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1326 Scope = LScopes.getCurrentFunctionScope();
1327 else if (MDNode *IA = DV.getInlinedAt())
1328 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1329 else
1330 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1331 // If variable scope is not found then skip this variable.
1332 if (!Scope)
1333 continue;
1335 Processed.insert(DV);
1336 assert(MInsn->isDebugValue() && "History must begin with debug value");
1337 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1338 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1339 if (!addCurrentFnArgument(RegVar, Scope))
1340 addScopeVariable(Scope, RegVar);
1341 if (AbsVar)
1342 AbsVar->setMInsn(MInsn);
1344 // Simplify ranges that are fully coalesced.
1345 if (History.size() <= 1 ||
1346 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1347 RegVar->setMInsn(MInsn);
1348 continue;
1349 }
1351 // Handle multiple DBG_VALUE instructions describing one variable.
1352 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1354 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1355 HI = History.begin(),
1356 HE = History.end();
1357 HI != HE; ++HI) {
1358 const MachineInstr *Begin = *HI;
1359 assert(Begin->isDebugValue() && "Invalid History entry");
1361 // Check if DBG_VALUE is truncating a range.
1362 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1363 !Begin->getOperand(0).getReg())
1364 continue;
1366 // Compute the range for a register location.
1367 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1368 const MCSymbol *SLabel = 0;
1370 if (HI + 1 == HE)
1371 // If Begin is the last instruction in History then its value is valid
1372 // until the end of the function.
1373 SLabel = FunctionEndSym;
1374 else {
1375 const MachineInstr *End = HI[1];
1376 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1377 << "\t" << *Begin << "\t" << *End << "\n");
1378 if (End->isDebugValue())
1379 SLabel = getLabelBeforeInsn(End);
1380 else {
1381 // End is a normal instruction clobbering the range.
1382 SLabel = getLabelAfterInsn(End);
1383 assert(SLabel && "Forgot label after clobber instruction");
1384 ++HI;
1385 }
1386 }
1388 // The value is valid until the next DBG_VALUE or clobber.
1389 DotDebugLocEntries.push_back(
1390 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1391 }
1392 DotDebugLocEntries.push_back(DotDebugLocEntry());
1393 }
1395 // Collect info for variables that were optimized out.
1396 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1397 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1398 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1399 DIVariable DV(Variables.getElement(i));
1400 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1401 continue;
1402 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1403 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1404 }
1405 }
1407 // Return Label preceding the instruction.
1408 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1409 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1410 assert(Label && "Didn't insert label before instruction");
1411 return Label;
1412 }
1414 // Return Label immediately following the instruction.
1415 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1416 return LabelsAfterInsn.lookup(MI);
1417 }
1419 // Process beginning of an instruction.
1420 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1421 assert(CurMI == 0);
1422 CurMI = MI;
1423 // Check if source location changes, but ignore DBG_VALUE locations.
1424 if (!MI->isDebugValue()) {
1425 DebugLoc DL = MI->getDebugLoc();
1426 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1427 unsigned Flags = 0;
1428 PrevInstLoc = DL;
1429 if (DL == PrologEndLoc) {
1430 Flags |= DWARF2_FLAG_PROLOGUE_END;
1431 PrologEndLoc = DebugLoc();
1432 }
1433 if (PrologEndLoc.isUnknown())
1434 Flags |= DWARF2_FLAG_IS_STMT;
1436 if (!DL.isUnknown()) {
1437 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1438 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1439 } else
1440 recordSourceLine(0, 0, 0, 0);
1441 }
1442 }
1444 // Insert labels where requested.
1445 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1446 LabelsBeforeInsn.find(MI);
1448 // No label needed.
1449 if (I == LabelsBeforeInsn.end())
1450 return;
1452 // Label already assigned.
1453 if (I->second)
1454 return;
1456 if (!PrevLabel) {
1457 PrevLabel = MMI->getContext().CreateTempSymbol();
1458 Asm->OutStreamer.EmitLabel(PrevLabel);
1459 }
1460 I->second = PrevLabel;
1461 }
1463 // Process end of an instruction.
1464 void DwarfDebug::endInstruction() {
1465 assert(CurMI != 0);
1466 // Don't create a new label after DBG_VALUE instructions.
1467 // They don't generate code.
1468 if (!CurMI->isDebugValue())
1469 PrevLabel = 0;
1471 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1472 LabelsAfterInsn.find(CurMI);
1473 CurMI = 0;
1475 // No label needed.
1476 if (I == LabelsAfterInsn.end())
1477 return;
1479 // Label already assigned.
1480 if (I->second)
1481 return;
1483 // We need a label after this instruction.
1484 if (!PrevLabel) {
1485 PrevLabel = MMI->getContext().CreateTempSymbol();
1486 Asm->OutStreamer.EmitLabel(PrevLabel);
1487 }
1488 I->second = PrevLabel;
1489 }
1491 // Each LexicalScope has first instruction and last instruction to mark
1492 // beginning and end of a scope respectively. Create an inverse map that list
1493 // scopes starts (and ends) with an instruction. One instruction may start (or
1494 // end) multiple scopes. Ignore scopes that are not reachable.
1495 void DwarfDebug::identifyScopeMarkers() {
1496 SmallVector<LexicalScope *, 4> WorkList;
1497 WorkList.push_back(LScopes.getCurrentFunctionScope());
1498 while (!WorkList.empty()) {
1499 LexicalScope *S = WorkList.pop_back_val();
1501 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1502 if (!Children.empty())
1503 for (SmallVectorImpl<LexicalScope *>::const_iterator
1504 SI = Children.begin(),
1505 SE = Children.end();
1506 SI != SE; ++SI)
1507 WorkList.push_back(*SI);
1509 if (S->isAbstractScope())
1510 continue;
1512 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1513 if (Ranges.empty())
1514 continue;
1515 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1516 RE = Ranges.end();
1517 RI != RE; ++RI) {
1518 assert(RI->first && "InsnRange does not have first instruction!");
1519 assert(RI->second && "InsnRange does not have second instruction!");
1520 requestLabelBeforeInsn(RI->first);
1521 requestLabelAfterInsn(RI->second);
1522 }
1523 }
1524 }
1526 // Get MDNode for DebugLoc's scope.
1527 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1528 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1529 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1530 return DL.getScope(Ctx);
1531 }
1533 // Walk up the scope chain of given debug loc and find line number info
1534 // for the function.
1535 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1536 const MDNode *Scope = getScopeNode(DL, Ctx);
1537 DISubprogram SP = getDISubprogram(Scope);
1538 if (SP.isSubprogram()) {
1539 // Check for number of operands since the compatibility is
1540 // cheap here.
1541 if (SP->getNumOperands() > 19)
1542 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1543 else
1544 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1545 }
1547 return DebugLoc();
1548 }
1550 // Gather pre-function debug information. Assumes being called immediately
1551 // after the function entry point has been emitted.
1552 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1553 CurFn = MF;
1555 // If there's no debug info for the function we're not going to do anything.
1556 if (!MMI->hasDebugInfo())
1557 return;
1559 // Grab the lexical scopes for the function, if we don't have any of those
1560 // then we're not going to be able to do anything.
1561 LScopes.initialize(*MF);
1562 if (LScopes.empty())
1563 return;
1565 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1567 // Make sure that each lexical scope will have a begin/end label.
1568 identifyScopeMarkers();
1570 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1571 // belongs to so that we add to the correct per-cu line table in the
1572 // non-asm case.
1573 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1574 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1575 assert(TheCU && "Unable to find compile unit!");
1576 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1577 // Use a single line table if we are using .loc and generating assembly.
1578 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1579 else
1580 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1582 // Check the current section against the standard text section. If different
1583 // keep track so that we will know when we're emitting functions into multiple
1584 // sections.
1585 if (Asm->getObjFileLowering().getTextSection() != Asm->getCurrentSection())
1586 UsedNonDefaultText = true;
1588 // Emit a label for the function so that we have a beginning address.
1589 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1590 // Assumes in correct section after the entry point.
1591 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1593 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1594 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1595 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1597 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1598 ++I) {
1599 bool AtBlockEntry = true;
1600 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1601 II != IE; ++II) {
1602 const MachineInstr *MI = II;
1604 if (MI->isDebugValue()) {
1605 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1607 // Keep track of user variables.
1608 const MDNode *Var =
1609 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1611 // Variable is in a register, we need to check for clobbers.
1612 if (isDbgValueInDefinedReg(MI))
1613 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1615 // Check the history of this variable.
1616 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1617 if (History.empty()) {
1618 UserVariables.push_back(Var);
1619 // The first mention of a function argument gets the FunctionBeginSym
1620 // label, so arguments are visible when breaking at function entry.
1621 DIVariable DV(Var);
1622 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1623 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1624 LabelsBeforeInsn[MI] = FunctionBeginSym;
1625 } else {
1626 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1627 const MachineInstr *Prev = History.back();
1628 if (Prev->isDebugValue()) {
1629 // Coalesce identical entries at the end of History.
1630 if (History.size() >= 2 &&
1631 Prev->isIdenticalTo(History[History.size() - 2])) {
1632 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1633 << "\t" << *Prev << "\t"
1634 << *History[History.size() - 2] << "\n");
1635 History.pop_back();
1636 }
1638 // Terminate old register assignments that don't reach MI;
1639 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1640 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1641 isDbgValueInDefinedReg(Prev)) {
1642 // Previous register assignment needs to terminate at the end of
1643 // its basic block.
1644 MachineBasicBlock::const_iterator LastMI =
1645 PrevMBB->getLastNonDebugInstr();
1646 if (LastMI == PrevMBB->end()) {
1647 // Drop DBG_VALUE for empty range.
1648 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1649 << "\t" << *Prev << "\n");
1650 History.pop_back();
1651 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1652 // Terminate after LastMI.
1653 History.push_back(LastMI);
1654 }
1655 }
1656 }
1657 History.push_back(MI);
1658 } else {
1659 // Not a DBG_VALUE instruction.
1660 if (!MI->isLabel())
1661 AtBlockEntry = false;
1663 // First known non-DBG_VALUE and non-frame setup location marks
1664 // the beginning of the function body.
1665 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1666 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1667 PrologEndLoc = MI->getDebugLoc();
1669 // Check if the instruction clobbers any registers with debug vars.
1670 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1671 MOE = MI->operands_end();
1672 MOI != MOE; ++MOI) {
1673 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1674 continue;
1675 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1676 ++AI) {
1677 unsigned Reg = *AI;
1678 const MDNode *Var = LiveUserVar[Reg];
1679 if (!Var)
1680 continue;
1681 // Reg is now clobbered.
1682 LiveUserVar[Reg] = 0;
1684 // Was MD last defined by a DBG_VALUE referring to Reg?
1685 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1686 if (HistI == DbgValues.end())
1687 continue;
1688 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1689 if (History.empty())
1690 continue;
1691 const MachineInstr *Prev = History.back();
1692 // Sanity-check: Register assignments are terminated at the end of
1693 // their block.
1694 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1695 continue;
1696 // Is the variable still in Reg?
1697 if (!isDbgValueInDefinedReg(Prev) ||
1698 Prev->getOperand(0).getReg() != Reg)
1699 continue;
1700 // Var is clobbered. Make sure the next instruction gets a label.
1701 History.push_back(MI);
1702 }
1703 }
1704 }
1705 }
1706 }
1708 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1709 I != E; ++I) {
1710 SmallVectorImpl<const MachineInstr *> &History = I->second;
1711 if (History.empty())
1712 continue;
1714 // Make sure the final register assignments are terminated.
1715 const MachineInstr *Prev = History.back();
1716 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1717 const MachineBasicBlock *PrevMBB = Prev->getParent();
1718 MachineBasicBlock::const_iterator LastMI =
1719 PrevMBB->getLastNonDebugInstr();
1720 if (LastMI == PrevMBB->end())
1721 // Drop DBG_VALUE for empty range.
1722 History.pop_back();
1723 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1724 // Terminate after LastMI.
1725 History.push_back(LastMI);
1726 }
1727 }
1728 // Request labels for the full history.
1729 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1730 const MachineInstr *MI = History[i];
1731 if (MI->isDebugValue())
1732 requestLabelBeforeInsn(MI);
1733 else
1734 requestLabelAfterInsn(MI);
1735 }
1736 }
1738 PrevInstLoc = DebugLoc();
1739 PrevLabel = FunctionBeginSym;
1741 // Record beginning of function.
1742 if (!PrologEndLoc.isUnknown()) {
1743 DebugLoc FnStartDL =
1744 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1745 recordSourceLine(
1746 FnStartDL.getLine(), FnStartDL.getCol(),
1747 FnStartDL.getScope(MF->getFunction()->getContext()),
1748 // We'd like to list the prologue as "not statements" but GDB behaves
1749 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1750 DWARF2_FLAG_IS_STMT);
1751 }
1752 }
1754 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1755 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1756 DIVariable DV = Var->getVariable();
1757 // Variables with positive arg numbers are parameters.
1758 if (unsigned ArgNum = DV.getArgNumber()) {
1759 // Keep all parameters in order at the start of the variable list to ensure
1760 // function types are correct (no out-of-order parameters)
1761 //
1762 // This could be improved by only doing it for optimized builds (unoptimized
1763 // builds have the right order to begin with), searching from the back (this
1764 // would catch the unoptimized case quickly), or doing a binary search
1765 // rather than linear search.
1766 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1767 while (I != Vars.end()) {
1768 unsigned CurNum = (*I)->getVariable().getArgNumber();
1769 // A local (non-parameter) variable has been found, insert immediately
1770 // before it.
1771 if (CurNum == 0)
1772 break;
1773 // A later indexed parameter has been found, insert immediately before it.
1774 if (CurNum > ArgNum)
1775 break;
1776 ++I;
1777 }
1778 Vars.insert(I, Var);
1779 return;
1780 }
1782 Vars.push_back(Var);
1783 }
1785 // Gather and emit post-function debug information.
1786 void DwarfDebug::endFunction(const MachineFunction *MF) {
1787 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1788 // though the beginFunction may not be called at all.
1789 // We should handle both cases.
1790 if (CurFn == 0)
1791 CurFn = MF;
1792 else
1793 assert(CurFn == MF);
1794 assert(CurFn != 0);
1796 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1797 CurFn = 0;
1798 return;
1799 }
1801 // Define end label for subprogram.
1802 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1803 // Assumes in correct section after the entry point.
1804 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1805 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1806 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1808 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1809 collectVariableInfo(ProcessedVars);
1811 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1812 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1813 assert(TheCU && "Unable to find compile unit!");
1815 // Construct abstract scopes.
1816 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1817 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1818 LexicalScope *AScope = AList[i];
1819 DISubprogram SP(AScope->getScopeNode());
1820 if (SP.isSubprogram()) {
1821 // Collect info for variables that were optimized out.
1822 DIArray Variables = SP.getVariables();
1823 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1824 DIVariable DV(Variables.getElement(i));
1825 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1826 continue;
1827 // Check that DbgVariable for DV wasn't created earlier, when
1828 // findAbstractVariable() was called for inlined instance of DV.
1829 LLVMContext &Ctx = DV->getContext();
1830 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1831 if (AbstractVariables.lookup(CleanDV))
1832 continue;
1833 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1834 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1835 }
1836 }
1837 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1838 constructScopeDIE(TheCU, AScope);
1839 }
1841 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1843 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1844 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1846 // Clear debug info
1847 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1848 E = ScopeVariables.end();
1849 I != E; ++I)
1850 DeleteContainerPointers(I->second);
1851 ScopeVariables.clear();
1852 DeleteContainerPointers(CurrentFnArguments);
1853 UserVariables.clear();
1854 DbgValues.clear();
1855 AbstractVariables.clear();
1856 LabelsBeforeInsn.clear();
1857 LabelsAfterInsn.clear();
1858 PrevLabel = NULL;
1859 CurFn = 0;
1860 }
1862 // Register a source line with debug info. Returns the unique label that was
1863 // emitted and which provides correspondence to the source line list.
1864 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1865 unsigned Flags) {
1866 StringRef Fn;
1867 StringRef Dir;
1868 unsigned Src = 1;
1869 if (S) {
1870 DIDescriptor Scope(S);
1872 if (Scope.isCompileUnit()) {
1873 DICompileUnit CU(S);
1874 Fn = CU.getFilename();
1875 Dir = CU.getDirectory();
1876 } else if (Scope.isFile()) {
1877 DIFile F(S);
1878 Fn = F.getFilename();
1879 Dir = F.getDirectory();
1880 } else if (Scope.isSubprogram()) {
1881 DISubprogram SP(S);
1882 Fn = SP.getFilename();
1883 Dir = SP.getDirectory();
1884 } else if (Scope.isLexicalBlockFile()) {
1885 DILexicalBlockFile DBF(S);
1886 Fn = DBF.getFilename();
1887 Dir = DBF.getDirectory();
1888 } else if (Scope.isLexicalBlock()) {
1889 DILexicalBlock DB(S);
1890 Fn = DB.getFilename();
1891 Dir = DB.getDirectory();
1892 } else
1893 llvm_unreachable("Unexpected scope info");
1895 Src = getOrCreateSourceID(
1896 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1897 }
1898 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1899 }
1901 //===----------------------------------------------------------------------===//
1902 // Emit Methods
1903 //===----------------------------------------------------------------------===//
1905 // Compute the size and offset of a DIE. The offset is relative to start of the
1906 // CU. It returns the offset after laying out the DIE.
1907 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1908 // Get the children.
1909 const std::vector<DIE *> &Children = Die->getChildren();
1911 // Record the abbreviation.
1912 assignAbbrevNumber(Die->getAbbrev());
1914 // Get the abbreviation for this DIE.
1915 const DIEAbbrev &Abbrev = Die->getAbbrev();
1917 // Set DIE offset
1918 Die->setOffset(Offset);
1920 // Start the size with the size of abbreviation code.
1921 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1923 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1924 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1926 // Size the DIE attribute values.
1927 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1928 // Size attribute value.
1929 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1931 // Size the DIE children if any.
1932 if (!Children.empty()) {
1933 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1934 "Children flag not set");
1936 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1937 Offset = computeSizeAndOffset(Children[j], Offset);
1939 // End of children marker.
1940 Offset += sizeof(int8_t);
1941 }
1943 Die->setSize(Offset - Die->getOffset());
1944 return Offset;
1945 }
1947 // Compute the size and offset for each DIE.
1948 void DwarfFile::computeSizeAndOffsets() {
1949 // Offset from the first CU in the debug info section is 0 initially.
1950 unsigned SecOffset = 0;
1952 // Iterate over each compile unit and set the size and offsets for each
1953 // DIE within each compile unit. All offsets are CU relative.
1954 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1955 E = CUs.end();
1956 I != E; ++I) {
1957 (*I)->setDebugInfoOffset(SecOffset);
1959 // CU-relative offset is reset to 0 here.
1960 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1961 (*I)->getHeaderSize(); // Unit-specific headers
1963 // EndOffset here is CU-relative, after laying out
1964 // all of the CU DIE.
1965 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1966 SecOffset += EndOffset;
1967 }
1968 }
1970 // Emit initial Dwarf sections with a label at the start of each one.
1971 void DwarfDebug::emitSectionLabels() {
1972 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1974 // Dwarf sections base addresses.
1975 DwarfInfoSectionSym =
1976 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1977 if (useSplitDwarf())
1978 DwarfInfoDWOSectionSym =
1979 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1980 DwarfAbbrevSectionSym =
1981 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1982 if (useSplitDwarf())
1983 DwarfAbbrevDWOSectionSym = emitSectionSym(
1984 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1985 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1987 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1988 emitSectionSym(Asm, MacroInfo);
1990 DwarfLineSectionSym =
1991 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1992 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1993 if (GenerateGnuPubSections) {
1994 DwarfGnuPubNamesSectionSym =
1995 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1996 DwarfGnuPubTypesSectionSym =
1997 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1998 } else if (HasDwarfPubSections) {
1999 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2000 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2001 }
2003 DwarfStrSectionSym =
2004 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2005 if (useSplitDwarf()) {
2006 DwarfStrDWOSectionSym =
2007 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2008 DwarfAddrSectionSym =
2009 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2010 }
2011 DwarfDebugRangeSectionSym =
2012 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2014 DwarfDebugLocSectionSym =
2015 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2016 }
2018 // Recursively emits a debug information entry.
2019 void DwarfDebug::emitDIE(DIE *Die) {
2020 // Get the abbreviation for this DIE.
2021 const DIEAbbrev &Abbrev = Die->getAbbrev();
2023 // Emit the code (index) for the abbreviation.
2024 if (Asm->isVerbose())
2025 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2026 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2027 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2028 dwarf::TagString(Abbrev.getTag()));
2029 Asm->EmitULEB128(Abbrev.getNumber());
2031 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2032 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2034 // Emit the DIE attribute values.
2035 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2036 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2037 dwarf::Form Form = AbbrevData[i].getForm();
2038 assert(Form && "Too many attributes for DIE (check abbreviation)");
2040 if (Asm->isVerbose())
2041 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2043 switch (Attr) {
2044 case dwarf::DW_AT_abstract_origin:
2045 case dwarf::DW_AT_type:
2046 case dwarf::DW_AT_friend:
2047 case dwarf::DW_AT_specification:
2048 case dwarf::DW_AT_import:
2049 case dwarf::DW_AT_containing_type: {
2050 DIEEntry *E = cast<DIEEntry>(Values[i]);
2051 DIE *Origin = E->getEntry();
2052 unsigned Addr = Origin->getOffset();
2053 if (Form == dwarf::DW_FORM_ref_addr) {
2054 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2055 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2056 // section. Origin->getOffset() returns the offset from start of the
2057 // compile unit.
2058 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2059 assert(CU && "CUDie should belong to a CU.");
2060 Addr += CU->getDebugInfoOffset();
2061 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2062 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2063 DIEEntry::getRefAddrSize(Asm));
2064 else
2065 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2066 CU->getSectionSym(),
2067 DIEEntry::getRefAddrSize(Asm));
2068 } else {
2069 // Make sure Origin belong to the same CU.
2070 assert(Die->getUnit() == Origin->getUnit() &&
2071 "The referenced DIE should belong to the same CU in ref4");
2072 Asm->EmitInt32(Addr);
2073 }
2074 break;
2075 }
2076 case dwarf::DW_AT_location: {
2077 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2078 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2079 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2080 else
2081 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2082 } else {
2083 Values[i]->EmitValue(Asm, Form);
2084 }
2085 break;
2086 }
2087 case dwarf::DW_AT_accessibility: {
2088 if (Asm->isVerbose()) {
2089 DIEInteger *V = cast<DIEInteger>(Values[i]);
2090 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2091 }
2092 Values[i]->EmitValue(Asm, Form);
2093 break;
2094 }
2095 default:
2096 // Emit an attribute using the defined form.
2097 Values[i]->EmitValue(Asm, Form);
2098 break;
2099 }
2100 }
2102 // Emit the DIE children if any.
2103 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2104 const std::vector<DIE *> &Children = Die->getChildren();
2106 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2107 emitDIE(Children[j]);
2109 Asm->OutStreamer.AddComment("End Of Children Mark");
2110 Asm->EmitInt8(0);
2111 }
2112 }
2114 // Emit the various dwarf units to the unit section USection with
2115 // the abbreviations going into ASection.
2116 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2117 const MCSymbol *ASectionSym) {
2118 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2119 I != E; ++I) {
2120 DwarfUnit *TheU = *I;
2121 DIE *Die = TheU->getUnitDie();
2122 const MCSection *USection = TheU->getSection();
2123 Asm->OutStreamer.SwitchSection(USection);
2125 // Emit the compile units header.
2126 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2128 // Emit size of content not including length itself
2129 Asm->OutStreamer.AddComment("Length of Unit");
2130 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2132 TheU->emitHeader(ASection, ASectionSym);
2134 DD->emitDIE(Die);
2135 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2136 }
2137 }
2139 // Emit the debug info section.
2140 void DwarfDebug::emitDebugInfo() {
2141 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2143 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2144 DwarfAbbrevSectionSym);
2145 }
2147 // Emit the abbreviation section.
2148 void DwarfDebug::emitAbbreviations() {
2149 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2151 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2152 }
2154 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2155 // Check to see if it is worth the effort.
2156 if (!Abbreviations.empty()) {
2157 // Start the debug abbrev section.
2158 Asm->OutStreamer.SwitchSection(Section);
2160 // For each abbrevation.
2161 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2162 // Get abbreviation data
2163 const DIEAbbrev *Abbrev = Abbreviations[i];
2165 // Emit the abbrevations code (base 1 index.)
2166 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2168 // Emit the abbreviations data.
2169 Abbrev->Emit(Asm);
2170 }
2172 // Mark end of abbreviations.
2173 Asm->EmitULEB128(0, "EOM(3)");
2174 }
2175 }
2177 // Emit the last address of the section and the end of the line matrix.
2178 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2179 // Define last address of section.
2180 Asm->OutStreamer.AddComment("Extended Op");
2181 Asm->EmitInt8(0);
2183 Asm->OutStreamer.AddComment("Op size");
2184 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2185 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2186 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2188 Asm->OutStreamer.AddComment("Section end label");
2190 Asm->OutStreamer.EmitSymbolValue(
2191 Asm->GetTempSymbol("section_end", SectionEnd),
2192 Asm->getDataLayout().getPointerSize());
2194 // Mark end of matrix.
2195 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2196 Asm->EmitInt8(0);
2197 Asm->EmitInt8(1);
2198 Asm->EmitInt8(1);
2199 }
2201 // Emit visible names into a hashed accelerator table section.
2202 void DwarfDebug::emitAccelNames() {
2203 DwarfAccelTable AT(
2204 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2205 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2206 E = getUnits().end();
2207 I != E; ++I) {
2208 DwarfUnit *TheU = *I;
2209 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2210 for (StringMap<std::vector<const DIE *> >::const_iterator
2211 GI = Names.begin(),
2212 GE = Names.end();
2213 GI != GE; ++GI) {
2214 StringRef Name = GI->getKey();
2215 const std::vector<const DIE *> &Entities = GI->second;
2216 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2217 DE = Entities.end();
2218 DI != DE; ++DI)
2219 AT.AddName(Name, *DI);
2220 }
2221 }
2223 AT.FinalizeTable(Asm, "Names");
2224 Asm->OutStreamer.SwitchSection(
2225 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2226 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2227 Asm->OutStreamer.EmitLabel(SectionBegin);
2229 // Emit the full data.
2230 AT.Emit(Asm, SectionBegin, &InfoHolder);
2231 }
2233 // Emit objective C classes and categories into a hashed accelerator table
2234 // section.
2235 void DwarfDebug::emitAccelObjC() {
2236 DwarfAccelTable AT(
2237 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2238 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2239 E = getUnits().end();
2240 I != E; ++I) {
2241 DwarfUnit *TheU = *I;
2242 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2243 for (StringMap<std::vector<const DIE *> >::const_iterator
2244 GI = Names.begin(),
2245 GE = Names.end();
2246 GI != GE; ++GI) {
2247 StringRef Name = GI->getKey();
2248 const std::vector<const DIE *> &Entities = GI->second;
2249 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2250 DE = Entities.end();
2251 DI != DE; ++DI)
2252 AT.AddName(Name, *DI);
2253 }
2254 }
2256 AT.FinalizeTable(Asm, "ObjC");
2257 Asm->OutStreamer.SwitchSection(
2258 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2259 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2260 Asm->OutStreamer.EmitLabel(SectionBegin);
2262 // Emit the full data.
2263 AT.Emit(Asm, SectionBegin, &InfoHolder);
2264 }
2266 // Emit namespace dies into a hashed accelerator table.
2267 void DwarfDebug::emitAccelNamespaces() {
2268 DwarfAccelTable AT(
2269 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2270 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2271 E = getUnits().end();
2272 I != E; ++I) {
2273 DwarfUnit *TheU = *I;
2274 const StringMap<std::vector<const DIE *> > &Names =
2275 TheU->getAccelNamespace();
2276 for (StringMap<std::vector<const DIE *> >::const_iterator
2277 GI = Names.begin(),
2278 GE = Names.end();
2279 GI != GE; ++GI) {
2280 StringRef Name = GI->getKey();
2281 const std::vector<const DIE *> &Entities = GI->second;
2282 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2283 DE = Entities.end();
2284 DI != DE; ++DI)
2285 AT.AddName(Name, *DI);
2286 }
2287 }
2289 AT.FinalizeTable(Asm, "namespac");
2290 Asm->OutStreamer.SwitchSection(
2291 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2292 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2293 Asm->OutStreamer.EmitLabel(SectionBegin);
2295 // Emit the full data.
2296 AT.Emit(Asm, SectionBegin, &InfoHolder);
2297 }
2299 // Emit type dies into a hashed accelerator table.
2300 void DwarfDebug::emitAccelTypes() {
2301 std::vector<DwarfAccelTable::Atom> Atoms;
2302 Atoms.push_back(
2303 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2304 Atoms.push_back(
2305 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2306 Atoms.push_back(
2307 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2308 DwarfAccelTable AT(Atoms);
2309 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2310 E = getUnits().end();
2311 I != E; ++I) {
2312 DwarfUnit *TheU = *I;
2313 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2314 TheU->getAccelTypes();
2315 for (StringMap<
2316 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2317 GI = Names.begin(),
2318 GE = Names.end();
2319 GI != GE; ++GI) {
2320 StringRef Name = GI->getKey();
2321 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2322 GI->second;
2323 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2324 DI = Entities.begin(),
2325 DE = Entities.end();
2326 DI != DE; ++DI)
2327 AT.AddName(Name, DI->first, DI->second);
2328 }
2329 }
2331 AT.FinalizeTable(Asm, "types");
2332 Asm->OutStreamer.SwitchSection(
2333 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2334 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2335 Asm->OutStreamer.EmitLabel(SectionBegin);
2337 // Emit the full data.
2338 AT.Emit(Asm, SectionBegin, &InfoHolder);
2339 }
2341 // Public name handling.
2342 // The format for the various pubnames:
2343 //
2344 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2345 // for the DIE that is named.
2346 //
2347 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2348 // into the CU and the index value is computed according to the type of value
2349 // for the DIE that is named.
2350 //
2351 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2352 // it's the offset within the debug_info/debug_types dwo section, however, the
2353 // reference in the pubname header doesn't change.
2355 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2356 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2357 const DIE *Die) {
2358 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2360 // We could have a specification DIE that has our most of our knowledge,
2361 // look for that now.
2362 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2363 if (SpecVal) {
2364 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2365 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2366 Linkage = dwarf::GIEL_EXTERNAL;
2367 } else if (Die->findAttribute(dwarf::DW_AT_external))
2368 Linkage = dwarf::GIEL_EXTERNAL;
2370 switch (Die->getTag()) {
2371 case dwarf::DW_TAG_class_type:
2372 case dwarf::DW_TAG_structure_type:
2373 case dwarf::DW_TAG_union_type:
2374 case dwarf::DW_TAG_enumeration_type:
2375 return dwarf::PubIndexEntryDescriptor(
2376 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2377 ? dwarf::GIEL_STATIC
2378 : dwarf::GIEL_EXTERNAL);
2379 case dwarf::DW_TAG_typedef:
2380 case dwarf::DW_TAG_base_type:
2381 case dwarf::DW_TAG_subrange_type:
2382 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2383 case dwarf::DW_TAG_namespace:
2384 return dwarf::GIEK_TYPE;
2385 case dwarf::DW_TAG_subprogram:
2386 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2387 case dwarf::DW_TAG_constant:
2388 case dwarf::DW_TAG_variable:
2389 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2390 case dwarf::DW_TAG_enumerator:
2391 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2392 dwarf::GIEL_STATIC);
2393 default:
2394 return dwarf::GIEK_NONE;
2395 }
2396 }
2398 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2399 ///
2400 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2401 const MCSection *PSec =
2402 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2403 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2405 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2406 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2407 for (unsigned i = 0; i != Units.size(); ++i) {
2408 DwarfUnit *TheU = Units[i];
2409 unsigned ID = TheU->getUniqueID();
2411 // Start the dwarf pubnames section.
2412 Asm->OutStreamer.SwitchSection(PSec);
2414 // Emit a label so we can reference the beginning of this pubname section.
2415 if (GnuStyle)
2416 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2418 // Emit the header.
2419 Asm->OutStreamer.AddComment("Length of Public Names Info");
2420 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2421 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2422 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2424 Asm->OutStreamer.EmitLabel(BeginLabel);
2426 Asm->OutStreamer.AddComment("DWARF Version");
2427 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2429 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2430 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2432 Asm->OutStreamer.AddComment("Compilation Unit Length");
2433 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2435 // Emit the pubnames for this compilation unit.
2436 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2437 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2438 GE = Globals.end();
2439 GI != GE; ++GI) {
2440 const char *Name = GI->getKeyData();
2441 const DIE *Entity = GI->second;
2443 Asm->OutStreamer.AddComment("DIE offset");
2444 Asm->EmitInt32(Entity->getOffset());
2446 if (GnuStyle) {
2447 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2448 Asm->OutStreamer.AddComment(
2449 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2450 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2451 Asm->EmitInt8(Desc.toBits());
2452 }
2454 Asm->OutStreamer.AddComment("External Name");
2455 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2456 }
2458 Asm->OutStreamer.AddComment("End Mark");
2459 Asm->EmitInt32(0);
2460 Asm->OutStreamer.EmitLabel(EndLabel);
2461 }
2462 }
2464 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2465 const MCSection *PSec =
2466 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2467 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2469 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2470 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2471 for (unsigned i = 0; i != Units.size(); ++i) {
2472 DwarfUnit *TheU = Units[i];
2473 unsigned ID = TheU->getUniqueID();
2475 // Start the dwarf pubtypes section.
2476 Asm->OutStreamer.SwitchSection(PSec);
2478 // Emit a label so we can reference the beginning of this pubtype section.
2479 if (GnuStyle)
2480 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2482 // Emit the header.
2483 Asm->OutStreamer.AddComment("Length of Public Types Info");
2484 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2485 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2486 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2488 Asm->OutStreamer.EmitLabel(BeginLabel);
2490 Asm->OutStreamer.AddComment("DWARF Version");
2491 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2493 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2494 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2496 Asm->OutStreamer.AddComment("Compilation Unit Length");
2497 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2499 // Emit the pubtypes.
2500 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2501 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2502 GE = Globals.end();
2503 GI != GE; ++GI) {
2504 const char *Name = GI->getKeyData();
2505 const DIE *Entity = GI->second;
2507 Asm->OutStreamer.AddComment("DIE offset");
2508 Asm->EmitInt32(Entity->getOffset());
2510 if (GnuStyle) {
2511 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2512 Asm->OutStreamer.AddComment(
2513 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2514 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2515 Asm->EmitInt8(Desc.toBits());
2516 }
2518 Asm->OutStreamer.AddComment("External Name");
2520 // Emit the name with a terminating null byte.
2521 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2522 }
2524 Asm->OutStreamer.AddComment("End Mark");
2525 Asm->EmitInt32(0);
2526 Asm->OutStreamer.EmitLabel(EndLabel);
2527 }
2528 }
2530 // Emit strings into a string section.
2531 void DwarfFile::emitStrings(const MCSection *StrSection,
2532 const MCSection *OffsetSection = NULL,
2533 const MCSymbol *StrSecSym = NULL) {
2535 if (StringPool.empty())
2536 return;
2538 // Start the dwarf str section.
2539 Asm->OutStreamer.SwitchSection(StrSection);
2541 // Get all of the string pool entries and put them in an array by their ID so
2542 // we can sort them.
2543 SmallVector<
2544 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2545 64> Entries;
2547 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2548 I = StringPool.begin(),
2549 E = StringPool.end();
2550 I != E; ++I)
2551 Entries.push_back(std::make_pair(I->second.second, &*I));
2553 array_pod_sort(Entries.begin(), Entries.end());
2555 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2556 // Emit a label for reference from debug information entries.
2557 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2559 // Emit the string itself with a terminating null byte.
2560 Asm->OutStreamer.EmitBytes(
2561 StringRef(Entries[i].second->getKeyData(),
2562 Entries[i].second->getKeyLength() + 1));
2563 }
2565 // If we've got an offset section go ahead and emit that now as well.
2566 if (OffsetSection) {
2567 Asm->OutStreamer.SwitchSection(OffsetSection);
2568 unsigned offset = 0;
2569 unsigned size = 4; // FIXME: DWARF64 is 8.
2570 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2571 Asm->OutStreamer.EmitIntValue(offset, size);
2572 offset += Entries[i].second->getKeyLength() + 1;
2573 }
2574 }
2575 }
2577 // Emit addresses into the section given.
2578 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2580 if (AddressPool.empty())
2581 return;
2583 // Start the dwarf addr section.
2584 Asm->OutStreamer.SwitchSection(AddrSection);
2586 // Order the address pool entries by ID
2587 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2589 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2590 E = AddressPool.end();
2591 I != E; ++I)
2592 Entries[I->second] = I->first;
2594 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2595 // Emit an expression for reference from debug information entries.
2596 if (const MCExpr *Expr = Entries[i])
2597 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2598 else
2599 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2600 }
2601 }
2603 // Emit visible names into a debug str section.
2604 void DwarfDebug::emitDebugStr() {
2605 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2606 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2607 }
2609 // Emit locations into the debug loc section.
2610 void DwarfDebug::emitDebugLoc() {
2611 if (DotDebugLocEntries.empty())
2612 return;
2614 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2615 I = DotDebugLocEntries.begin(),
2616 E = DotDebugLocEntries.end();
2617 I != E; ++I) {
2618 DotDebugLocEntry &Entry = *I;
2619 if (I + 1 != DotDebugLocEntries.end())
2620 Entry.Merge(I + 1);
2621 }
2623 // Start the dwarf loc section.
2624 Asm->OutStreamer.SwitchSection(
2625 Asm->getObjFileLowering().getDwarfLocSection());
2626 unsigned char Size = Asm->getDataLayout().getPointerSize();
2627 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2628 unsigned index = 1;
2629 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2630 I = DotDebugLocEntries.begin(),
2631 E = DotDebugLocEntries.end();
2632 I != E; ++I, ++index) {
2633 DotDebugLocEntry &Entry = *I;
2634 if (Entry.isMerged())
2635 continue;
2636 if (Entry.isEmpty()) {
2637 Asm->OutStreamer.EmitIntValue(0, Size);
2638 Asm->OutStreamer.EmitIntValue(0, Size);
2639 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2640 } else {
2641 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2642 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2643 DIVariable DV(Entry.getVariable());
2644 Asm->OutStreamer.AddComment("Loc expr size");
2645 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2646 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2647 Asm->EmitLabelDifference(end, begin, 2);
2648 Asm->OutStreamer.EmitLabel(begin);
2649 if (Entry.isInt()) {
2650 DIBasicType BTy(DV.getType());
2651 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2652 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2653 Asm->OutStreamer.AddComment("DW_OP_consts");
2654 Asm->EmitInt8(dwarf::DW_OP_consts);
2655 Asm->EmitSLEB128(Entry.getInt());
2656 } else {
2657 Asm->OutStreamer.AddComment("DW_OP_constu");
2658 Asm->EmitInt8(dwarf::DW_OP_constu);
2659 Asm->EmitULEB128(Entry.getInt());
2660 }
2661 } else if (Entry.isLocation()) {
2662 MachineLocation Loc = Entry.getLoc();
2663 if (!DV.hasComplexAddress())
2664 // Regular entry.
2665 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2666 else {
2667 // Complex address entry.
2668 unsigned N = DV.getNumAddrElements();
2669 unsigned i = 0;
2670 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2671 if (Loc.getOffset()) {
2672 i = 2;
2673 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2674 Asm->OutStreamer.AddComment("DW_OP_deref");
2675 Asm->EmitInt8(dwarf::DW_OP_deref);
2676 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2677 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2678 Asm->EmitSLEB128(DV.getAddrElement(1));
2679 } else {
2680 // If first address element is OpPlus then emit
2681 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2682 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2683 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2684 i = 2;
2685 }
2686 } else {
2687 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2688 }
2690 // Emit remaining complex address elements.
2691 for (; i < N; ++i) {
2692 uint64_t Element = DV.getAddrElement(i);
2693 if (Element == DIBuilder::OpPlus) {
2694 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2695 Asm->EmitULEB128(DV.getAddrElement(++i));
2696 } else if (Element == DIBuilder::OpDeref) {
2697 if (!Loc.isReg())
2698 Asm->EmitInt8(dwarf::DW_OP_deref);
2699 } else
2700 llvm_unreachable("unknown Opcode found in complex address");
2701 }
2702 }
2703 }
2704 // else ... ignore constant fp. There is not any good way to
2705 // to represent them here in dwarf.
2706 Asm->OutStreamer.EmitLabel(end);
2707 }
2708 }
2709 }
2711 struct SymbolCUSorter {
2712 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2713 const MCStreamer &Streamer;
2715 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2716 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2717 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2719 // Symbols with no order assigned should be placed at the end.
2720 // (e.g. section end labels)
2721 if (IA == 0)
2722 IA = (unsigned)(-1);
2723 if (IB == 0)
2724 IB = (unsigned)(-1);
2725 return IA < IB;
2726 }
2727 };
2729 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2730 return (A->getUniqueID() < B->getUniqueID());
2731 }
2733 struct ArangeSpan {
2734 const MCSymbol *Start, *End;
2735 };
2737 // Emit a debug aranges section, containing a CU lookup for any
2738 // address we can tie back to a CU.
2739 void DwarfDebug::emitDebugARanges() {
2740 // Start the dwarf aranges section.
2741 Asm->OutStreamer.SwitchSection(
2742 Asm->getObjFileLowering().getDwarfARangesSection());
2744 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2746 SpansType Spans;
2748 // Build a list of sections used.
2749 std::vector<const MCSection *> Sections;
2750 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2751 it++) {
2752 const MCSection *Section = it->first;
2753 Sections.push_back(Section);
2754 }
2756 // Sort the sections into order.
2757 // This is only done to ensure consistent output order across different runs.
2758 std::sort(Sections.begin(), Sections.end(), SectionSort);
2760 // Build a set of address spans, sorted by CU.
2761 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2762 const MCSection *Section = Sections[SecIdx];
2763 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2764 if (List.size() < 2)
2765 continue;
2767 // Sort the symbols by offset within the section.
2768 SymbolCUSorter sorter(Asm->OutStreamer);
2769 std::sort(List.begin(), List.end(), sorter);
2771 // If we have no section (e.g. common), just write out
2772 // individual spans for each symbol.
2773 if (Section == NULL) {
2774 for (size_t n = 0; n < List.size(); n++) {
2775 const SymbolCU &Cur = List[n];
2777 ArangeSpan Span;
2778 Span.Start = Cur.Sym;
2779 Span.End = NULL;
2780 if (Cur.CU)
2781 Spans[Cur.CU].push_back(Span);
2782 }
2783 } else {
2784 // Build spans between each label.
2785 const MCSymbol *StartSym = List[0].Sym;
2786 for (size_t n = 1; n < List.size(); n++) {
2787 const SymbolCU &Prev = List[n - 1];
2788 const SymbolCU &Cur = List[n];
2790 // Try and build the longest span we can within the same CU.
2791 if (Cur.CU != Prev.CU) {
2792 ArangeSpan Span;
2793 Span.Start = StartSym;
2794 Span.End = Cur.Sym;
2795 Spans[Prev.CU].push_back(Span);
2796 StartSym = Cur.Sym;
2797 }
2798 }
2799 }
2800 }
2802 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2804 // Build a list of CUs used.
2805 std::vector<DwarfCompileUnit *> CUs;
2806 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2807 DwarfCompileUnit *CU = it->first;
2808 CUs.push_back(CU);
2809 }
2811 // Sort the CU list (again, to ensure consistent output order).
2812 std::sort(CUs.begin(), CUs.end(), CUSort);
2814 // Emit an arange table for each CU we used.
2815 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2816 DwarfCompileUnit *CU = CUs[CUIdx];
2817 std::vector<ArangeSpan> &List = Spans[CU];
2819 // Emit size of content not including length itself.
2820 unsigned ContentSize =
2821 sizeof(int16_t) + // DWARF ARange version number
2822 sizeof(int32_t) + // Offset of CU in the .debug_info section
2823 sizeof(int8_t) + // Pointer Size (in bytes)
2824 sizeof(int8_t); // Segment Size (in bytes)
2826 unsigned TupleSize = PtrSize * 2;
2828 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2829 unsigned Padding =
2830 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2832 ContentSize += Padding;
2833 ContentSize += (List.size() + 1) * TupleSize;
2835 // For each compile unit, write the list of spans it covers.
2836 Asm->OutStreamer.AddComment("Length of ARange Set");
2837 Asm->EmitInt32(ContentSize);
2838 Asm->OutStreamer.AddComment("DWARF Arange version number");
2839 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2840 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2841 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2842 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2843 Asm->EmitInt8(PtrSize);
2844 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2845 Asm->EmitInt8(0);
2847 Asm->OutStreamer.EmitFill(Padding, 0xff);
2849 for (unsigned n = 0; n < List.size(); n++) {
2850 const ArangeSpan &Span = List[n];
2851 Asm->EmitLabelReference(Span.Start, PtrSize);
2853 // Calculate the size as being from the span start to it's end.
2854 if (Span.End) {
2855 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2856 } else {
2857 // For symbols without an end marker (e.g. common), we
2858 // write a single arange entry containing just that one symbol.
2859 uint64_t Size = SymSize[Span.Start];
2860 if (Size == 0)
2861 Size = 1;
2863 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2864 }
2865 }
2867 Asm->OutStreamer.AddComment("ARange terminator");
2868 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2869 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2870 }
2871 }
2873 // Emit visible names into a debug ranges section.
2874 void DwarfDebug::emitDebugRanges() {
2875 // Start the dwarf ranges section.
2876 Asm->OutStreamer.SwitchSection(
2877 Asm->getObjFileLowering().getDwarfRangesSection());
2879 // Size for our labels.
2880 unsigned char Size = Asm->getDataLayout().getPointerSize();
2882 // Grab the specific ranges for the compile units in the module.
2883 for (MapVector<const MDNode *, DwarfCompileUnit *>::iterator
2884 I = CUMap.begin(),
2885 E = CUMap.end();
2886 I != E; ++I) {
2887 DwarfCompileUnit *TheCU = I->second;
2889 // Emit a symbol so we can find the beginning of our ranges.
2890 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2892 // Iterate over the misc ranges for the compile units in the module.
2893 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2894 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2895 E = RangeLists.end();
2896 I != E; ++I) {
2897 const RangeSpanList &List = *I;
2899 // Emit our symbol so we can find the beginning of the range.
2900 Asm->OutStreamer.EmitLabel(List.getSym());
2902 for (SmallVectorImpl<RangeSpan>::const_iterator
2903 RI = List.getRanges().begin(),
2904 RE = List.getRanges().end();
2905 RI != RE; ++RI) {
2906 const RangeSpan &Range = *RI;
2907 const MCSymbol *Begin = Range.getStart();
2908 const MCSymbol *End = Range.getEnd();
2909 assert(Begin && "Range without a begin symbol?");
2910 assert(End && "Range without an end symbol?");
2911 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2912 Asm->OutStreamer.EmitSymbolValue(End, Size);
2913 }
2915 // And terminate the list with two 0 values.
2916 Asm->OutStreamer.EmitIntValue(0, Size);
2917 Asm->OutStreamer.EmitIntValue(0, Size);
2918 }
2920 // Now emit a range for the CU itself.
2921 if (useCURanges()) {
2922 Asm->OutStreamer.EmitLabel(
2923 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2924 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2925 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2926 RangeSpan Range = Ranges[i];
2927 const MCSymbol *Begin = Range.getStart();
2928 const MCSymbol *End = Range.getEnd();
2929 assert(Begin && "Range without a begin symbol?");
2930 assert(End && "Range without an end symbol?");
2931 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2932 Asm->OutStreamer.EmitSymbolValue(End, Size);
2933 }
2934 // And terminate the list with two 0 values.
2935 Asm->OutStreamer.EmitIntValue(0, Size);
2936 Asm->OutStreamer.EmitIntValue(0, Size);
2937 }
2938 }
2939 }
2941 // DWARF5 Experimental Separate Dwarf emitters.
2943 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2944 DwarfUnit *NewU) {
2945 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2946 U->getCUNode().getSplitDebugFilename());
2948 // Relocate to the beginning of the addr_base section, else 0 for the
2949 // beginning of the one for this compile unit.
2950 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2951 NewU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym);
2952 else
2953 NewU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2955 if (!CompilationDir.empty())
2956 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2958 addGnuPubAttributes(NewU, Die);
2960 SkeletonHolder.addUnit(NewU);
2961 }
2963 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2964 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2965 // DW_AT_ranges_base, DW_AT_addr_base.
2966 // TODO: Implement DW_AT_ranges_base.
2967 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2969 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2970 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2971 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2972 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2973 DwarfInfoSectionSym);
2975 // DW_AT_stmt_list is a offset of line number information for this
2976 // compile unit in debug_line section.
2977 // FIXME: Should handle multiple compile units.
2978 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2979 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
2980 else
2981 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
2983 initSkeletonUnit(CU, Die, NewCU);
2985 return NewCU;
2986 }
2988 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2989 // DW_AT_addr_base.
2990 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(const DwarfTypeUnit *TU) {
2992 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2993 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
2994 TU->getUniqueID(), Die, TU->getCUNode(), Asm, this, &SkeletonHolder);
2995 NewTU->setTypeSignature(TU->getTypeSignature());
2996 NewTU->setType(NULL);
2997 NewTU->initSection(
2998 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
3000 initSkeletonUnit(TU, Die, NewTU);
3001 return NewTU;
3002 }
3004 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3005 // compile units that would normally be in debug_info.
3006 void DwarfDebug::emitDebugInfoDWO() {
3007 assert(useSplitDwarf() && "No split dwarf debug info?");
3008 InfoHolder.emitUnits(this,
3009 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3010 DwarfAbbrevDWOSectionSym);
3011 }
3013 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3014 // abbreviations for the .debug_info.dwo section.
3015 void DwarfDebug::emitDebugAbbrevDWO() {
3016 assert(useSplitDwarf() && "No split dwarf?");
3017 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3018 }
3020 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3021 // string section and is identical in format to traditional .debug_str
3022 // sections.
3023 void DwarfDebug::emitDebugStrDWO() {
3024 assert(useSplitDwarf() && "No split dwarf?");
3025 const MCSection *OffSec =
3026 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3027 const MCSymbol *StrSym = DwarfStrSectionSym;
3028 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3029 OffSec, StrSym);
3030 }
3032 void DwarfDebug::addDwarfTypeUnitType(DICompileUnit CUNode,
3033 StringRef Identifier, DIE *RefDie,
3034 DICompositeType CTy) {
3036 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3037 if (TU) {
3038 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);
3039 return;
3040 }
3042 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3043 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
3044 InfoHolder.getUnits().size(), UnitDie, CUNode, Asm, this, &InfoHolder);
3045 TU = NewTU;
3046 InfoHolder.addUnit(NewTU);
3048 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3049 CUNode.getLanguage());
3051 MD5 Hash;
3052 Hash.update(Identifier);
3053 // ... take the least significant 8 bytes and return those. Our MD5
3054 // implementation always returns its results in little endian, swap bytes
3055 // appropriately.
3056 MD5::MD5Result Result;
3057 Hash.final(Result);
3058 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
3059 NewTU->setTypeSignature(Signature);
3060 if (useSplitDwarf())
3061 NewTU->setSkeleton(constructSkeletonTU(NewTU));
3063 NewTU->setType(NewTU->createTypeDIE(CTy));
3065 NewTU->initSection(
3066 useSplitDwarf()
3067 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3068 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3070 CUMap.begin()->second->addDIETypeSignature(RefDie, *NewTU);
3071 }