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 //===----------------------------------------------------------------------===//
13
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
16 #include "DIE.h"
17 #include "DwarfAccelTable.h"
18 #include "DwarfCompileUnit.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/DIBuilder.h"
26 #include "llvm/DebugInfo.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DataLayout.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/MC/MCAsmInfo.h"
32 #include "llvm/MC/MCSection.h"
33 #include "llvm/MC/MCStreamer.h"
34 #include "llvm/MC/MCSymbol.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/FormattedStream.h"
39 #include "llvm/Support/Path.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/Support/ValueHandle.h"
42 #include "llvm/Target/TargetFrameLowering.h"
43 #include "llvm/Target/TargetLoweringObjectFile.h"
44 #include "llvm/Target/TargetMachine.h"
45 #include "llvm/Target/TargetOptions.h"
46 #include "llvm/Target/TargetRegisterInfo.h"
47 using namespace llvm;
48
49 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
50 cl::Hidden,
51 cl::desc("Disable debug info printing"));
52
53 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
54 cl::desc("Make an absence of debug location information explicit."),
55 cl::init(false));
56
57 static cl::opt<bool> GenerateDwarfPubNamesSection("generate-dwarf-pubnames",
58 cl::Hidden, cl::ZeroOrMore, cl::init(false),
59 cl::desc("Generate DWARF pubnames section"));
60
61 namespace {
62 enum DefaultOnOff {
63 Default, Enable, Disable
64 };
65 }
66
67 static cl::opt<DefaultOnOff> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
68 cl::desc("Output prototype dwarf accelerator tables."),
69 cl::values(
70 clEnumVal(Default, "Default for platform"),
71 clEnumVal(Enable, "Enabled"),
72 clEnumVal(Disable, "Disabled"),
73 clEnumValEnd),
74 cl::init(Default));
75
76 static cl::opt<DefaultOnOff> DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
77 cl::desc("Compatibility with Darwin gdb."),
78 cl::values(
79 clEnumVal(Default, "Default for platform"),
80 clEnumVal(Enable, "Enabled"),
81 clEnumVal(Disable, "Disabled"),
82 clEnumValEnd),
83 cl::init(Default));
84
85 static cl::opt<DefaultOnOff> SplitDwarf("split-dwarf", cl::Hidden,
86 cl::desc("Output prototype dwarf split debug info."),
87 cl::values(
88 clEnumVal(Default, "Default for platform"),
89 clEnumVal(Enable, "Enabled"),
90 clEnumVal(Disable, "Disabled"),
91 clEnumValEnd),
92 cl::init(Default));
93
94 namespace {
95 const char *DWARFGroupName = "DWARF Emission";
96 const char *DbgTimerName = "DWARF Debug Writer";
97 } // end anonymous namespace
98
99 //===----------------------------------------------------------------------===//
100
101 // Configuration values for initial hash set sizes (log2).
102 //
103 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
104
105 namespace llvm {
106
getType() const107 DIType DbgVariable::getType() const {
108 DIType Ty = Var.getType();
109 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
110 // addresses instead.
111 if (Var.isBlockByrefVariable()) {
112 /* Byref variables, in Blocks, are declared by the programmer as
113 "SomeType VarName;", but the compiler creates a
114 __Block_byref_x_VarName struct, and gives the variable VarName
115 either the struct, or a pointer to the struct, as its type. This
116 is necessary for various behind-the-scenes things the compiler
117 needs to do with by-reference variables in blocks.
118
119 However, as far as the original *programmer* is concerned, the
120 variable should still have type 'SomeType', as originally declared.
121
122 The following function dives into the __Block_byref_x_VarName
123 struct to find the original type of the variable. This will be
124 passed back to the code generating the type for the Debug
125 Information Entry for the variable 'VarName'. 'VarName' will then
126 have the original type 'SomeType' in its debug information.
127
128 The original type 'SomeType' will be the type of the field named
129 'VarName' inside the __Block_byref_x_VarName struct.
130
131 NOTE: In order for this to not completely fail on the debugger
132 side, the Debug Information Entry for the variable VarName needs to
133 have a DW_AT_location that tells the debugger how to unwind through
134 the pointers and __Block_byref_x_VarName struct to find the actual
135 value of the variable. The function addBlockByrefType does this. */
136 DIType subType = Ty;
137 unsigned tag = Ty.getTag();
138
139 if (tag == dwarf::DW_TAG_pointer_type) {
140 DIDerivedType DTy = DIDerivedType(Ty);
141 subType = DTy.getTypeDerivedFrom();
142 }
143
144 DICompositeType blockStruct = DICompositeType(subType);
145 DIArray Elements = blockStruct.getTypeArray();
146
147 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
148 DIDescriptor Element = Elements.getElement(i);
149 DIDerivedType DT = DIDerivedType(Element);
150 if (getName() == DT.getName())
151 return (DT.getTypeDerivedFrom());
152 }
153 }
154 return Ty;
155 }
156
157 } // end llvm namespace
158
DwarfDebug(AsmPrinter * A,Module * M)159 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
160 : Asm(A), MMI(Asm->MMI), FirstCU(0),
161 AbbreviationsSet(InitAbbreviationsSetSize),
162 SourceIdMap(DIEValueAllocator),
163 PrevLabel(NULL), GlobalCUIndexCount(0),
164 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
165 DIEValueAllocator),
166 SkeletonAbbrevSet(InitAbbreviationsSetSize),
167 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
168 DIEValueAllocator) {
169
170 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
171 DwarfStrSectionSym = TextSectionSym = 0;
172 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
173 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
174 FunctionBeginSym = FunctionEndSym = 0;
175
176 // Turn on accelerator tables and older gdb compatibility
177 // for Darwin.
178 bool IsDarwin = Triple(M->getTargetTriple()).isOSDarwin();
179 if (DarwinGDBCompat == Default) {
180 if (IsDarwin)
181 IsDarwinGDBCompat = true;
182 else
183 IsDarwinGDBCompat = false;
184 } else
185 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
186
187 if (DwarfAccelTables == Default) {
188 if (IsDarwin)
189 HasDwarfAccelTables = true;
190 else
191 HasDwarfAccelTables = false;
192 } else
193 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
194
195 if (SplitDwarf == Default)
196 HasSplitDwarf = false;
197 else
198 HasSplitDwarf = SplitDwarf == Enable ? true : false;
199
200 {
201 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
202 beginModule();
203 }
204 }
~DwarfDebug()205 DwarfDebug::~DwarfDebug() {
206 }
207
208 // Switch to the specified MCSection and emit an assembler
209 // temporary label to it if SymbolStem is specified.
emitSectionSym(AsmPrinter * Asm,const MCSection * Section,const char * SymbolStem=0)210 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
211 const char *SymbolStem = 0) {
212 Asm->OutStreamer.SwitchSection(Section);
213 if (!SymbolStem) return 0;
214
215 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
216 Asm->OutStreamer.EmitLabel(TmpSym);
217 return TmpSym;
218 }
219
getStringPoolSym()220 MCSymbol *DwarfUnits::getStringPoolSym() {
221 return Asm->GetTempSymbol(StringPref);
222 }
223
getStringPoolEntry(StringRef Str)224 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
225 std::pair<MCSymbol*, unsigned> &Entry =
226 StringPool.GetOrCreateValue(Str).getValue();
227 if (Entry.first) return Entry.first;
228
229 Entry.second = NextStringPoolNumber++;
230 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
231 }
232
getStringPoolIndex(StringRef Str)233 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
234 std::pair<MCSymbol*, unsigned> &Entry =
235 StringPool.GetOrCreateValue(Str).getValue();
236 if (Entry.first) return Entry.second;
237
238 Entry.second = NextStringPoolNumber++;
239 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
240 return Entry.second;
241 }
242
getAddrPoolIndex(MCSymbol * Sym)243 unsigned DwarfUnits::getAddrPoolIndex(MCSymbol *Sym) {
244 std::pair<MCSymbol*, unsigned> &Entry = AddressPool[Sym];
245 if (Entry.first) return Entry.second;
246
247 Entry.second = NextAddrPoolNumber++;
248 Entry.first = Sym;
249 return Entry.second;
250 }
251
252 // Define a unique number for the abbreviation.
253 //
assignAbbrevNumber(DIEAbbrev & Abbrev)254 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
255 // Profile the node so that we can make it unique.
256 FoldingSetNodeID ID;
257 Abbrev.Profile(ID);
258
259 // Check the set for priors.
260 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
261
262 // If it's newly added.
263 if (InSet == &Abbrev) {
264 // Add to abbreviation list.
265 Abbreviations->push_back(&Abbrev);
266
267 // Assign the vector position + 1 as its number.
268 Abbrev.setNumber(Abbreviations->size());
269 } else {
270 // Assign existing abbreviation number.
271 Abbrev.setNumber(InSet->getNumber());
272 }
273 }
274
275 // If special LLVM prefix that is used to inform the asm
276 // printer to not emit usual symbol prefix before the symbol name is used then
277 // return linkage name after skipping this special LLVM prefix.
getRealLinkageName(StringRef LinkageName)278 static StringRef getRealLinkageName(StringRef LinkageName) {
279 char One = '\1';
280 if (LinkageName.startswith(StringRef(&One, 1)))
281 return LinkageName.substr(1);
282 return LinkageName;
283 }
284
isObjCClass(StringRef Name)285 static bool isObjCClass(StringRef Name) {
286 return Name.startswith("+") || Name.startswith("-");
287 }
288
hasObjCCategory(StringRef Name)289 static bool hasObjCCategory(StringRef Name) {
290 if (!isObjCClass(Name)) return false;
291
292 size_t pos = Name.find(')');
293 if (pos != std::string::npos) {
294 if (Name[pos+1] != ' ') return false;
295 return true;
296 }
297 return false;
298 }
299
getObjCClassCategory(StringRef In,StringRef & Class,StringRef & Category)300 static void getObjCClassCategory(StringRef In, StringRef &Class,
301 StringRef &Category) {
302 if (!hasObjCCategory(In)) {
303 Class = In.slice(In.find('[') + 1, In.find(' '));
304 Category = "";
305 return;
306 }
307
308 Class = In.slice(In.find('[') + 1, In.find('('));
309 Category = In.slice(In.find('[') + 1, In.find(' '));
310 return;
311 }
312
getObjCMethodName(StringRef In)313 static StringRef getObjCMethodName(StringRef In) {
314 return In.slice(In.find(' ') + 1, In.find(']'));
315 }
316
317 // Add the various names to the Dwarf accelerator table names.
addSubprogramNames(CompileUnit * TheCU,DISubprogram SP,DIE * Die)318 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
319 DIE* Die) {
320 if (!SP.isDefinition()) return;
321
322 TheCU->addAccelName(SP.getName(), Die);
323
324 // If the linkage name is different than the name, go ahead and output
325 // that as well into the name table.
326 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
327 TheCU->addAccelName(SP.getLinkageName(), Die);
328
329 // If this is an Objective-C selector name add it to the ObjC accelerator
330 // too.
331 if (isObjCClass(SP.getName())) {
332 StringRef Class, Category;
333 getObjCClassCategory(SP.getName(), Class, Category);
334 TheCU->addAccelObjC(Class, Die);
335 if (Category != "")
336 TheCU->addAccelObjC(Category, Die);
337 // Also add the base method name to the name table.
338 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
339 }
340 }
341
342 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
343 // and DW_AT_high_pc attributes. If there are global variables in this
344 // scope then create and insert DIEs for these variables.
updateSubprogramScopeDIE(CompileUnit * SPCU,const MDNode * SPNode)345 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
346 const MDNode *SPNode) {
347 DIE *SPDie = SPCU->getDIE(SPNode);
348
349 assert(SPDie && "Unable to find subprogram DIE!");
350 DISubprogram SP(SPNode);
351
352 // If we're updating an abstract DIE, then we will be adding the children and
353 // object pointer later on. But what we don't want to do is process the
354 // concrete DIE twice.
355 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
356 if (AbsSPDIE) {
357 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
358 // Pick up abstract subprogram DIE.
359 SPDie = new DIE(dwarf::DW_TAG_subprogram);
360 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
361 // DW_FORM_ref4.
362 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
363 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
364 AbsSPDIE);
365 SPCU->addDie(SPDie);
366 } else {
367 DISubprogram SPDecl = SP.getFunctionDeclaration();
368 if (!SPDecl.isSubprogram()) {
369 // There is not any need to generate specification DIE for a function
370 // defined at compile unit level. If a function is defined inside another
371 // function then gdb prefers the definition at top level and but does not
372 // expect specification DIE in parent function. So avoid creating
373 // specification DIE for a function defined inside a function.
374 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
375 !SP.getContext().isFile() &&
376 !isSubprogramContext(SP.getContext())) {
377 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
378
379 // Add arguments.
380 DICompositeType SPTy = SP.getType();
381 DIArray Args = SPTy.getTypeArray();
382 unsigned SPTag = SPTy.getTag();
383 if (SPTag == dwarf::DW_TAG_subroutine_type)
384 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
385 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
386 DIType ATy = DIType(Args.getElement(i));
387 SPCU->addType(Arg, ATy);
388 if (ATy.isArtificial())
389 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
390 if (ATy.isObjectPointer())
391 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
392 dwarf::DW_FORM_ref4, Arg);
393 SPDie->addChild(Arg);
394 }
395 DIE *SPDeclDie = SPDie;
396 SPDie = new DIE(dwarf::DW_TAG_subprogram);
397 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
398 dwarf::DW_FORM_ref4, SPDeclDie);
399 SPCU->addDie(SPDie);
400 }
401 }
402 }
403
404 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
405 Asm->GetTempSymbol("func_begin",
406 Asm->getFunctionNumber()));
407 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
408 Asm->GetTempSymbol("func_end",
409 Asm->getFunctionNumber()));
410 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
411 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
412 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
413
414 // Add name to the name table, we do this here because we're guaranteed
415 // to have concrete versions of our DW_TAG_subprogram nodes.
416 addSubprogramNames(SPCU, SP, SPDie);
417
418 return SPDie;
419 }
420
421 // Construct new DW_TAG_lexical_block for this scope and attach
422 // DW_AT_low_pc/DW_AT_high_pc labels.
constructLexicalScopeDIE(CompileUnit * TheCU,LexicalScope * Scope)423 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
424 LexicalScope *Scope) {
425 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
426 if (Scope->isAbstractScope())
427 return ScopeDIE;
428
429 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
430 if (Ranges.empty())
431 return 0;
432
433 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
434 if (Ranges.size() > 1) {
435 // .debug_range section has not been laid out yet. Emit offset in
436 // .debug_range as a uint, size 4, for now. emitDIE will handle
437 // DW_AT_ranges appropriately.
438 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
439 DebugRangeSymbols.size()
440 * Asm->getDataLayout().getPointerSize());
441 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
442 RE = Ranges.end(); RI != RE; ++RI) {
443 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
444 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
445 }
446 DebugRangeSymbols.push_back(NULL);
447 DebugRangeSymbols.push_back(NULL);
448 return ScopeDIE;
449 }
450
451 MCSymbol *Start = getLabelBeforeInsn(RI->first);
452 MCSymbol *End = getLabelAfterInsn(RI->second);
453
454 if (End == 0) return 0;
455
456 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
457 assert(End->isDefined() && "Invalid end label for an inlined scope!");
458
459 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
460 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
461
462 return ScopeDIE;
463 }
464
465 // This scope represents inlined body of a function. Construct DIE to
466 // represent this concrete inlined copy of the function.
constructInlinedScopeDIE(CompileUnit * TheCU,LexicalScope * Scope)467 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
468 LexicalScope *Scope) {
469 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
470 assert(Ranges.empty() == false &&
471 "LexicalScope does not have instruction markers!");
472
473 if (!Scope->getScopeNode())
474 return NULL;
475 DIScope DS(Scope->getScopeNode());
476 DISubprogram InlinedSP = getDISubprogram(DS);
477 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
478 if (!OriginDIE) {
479 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
480 return NULL;
481 }
482
483 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
484 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
485 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
486
487 if (StartLabel == 0 || EndLabel == 0) {
488 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
489 }
490 assert(StartLabel->isDefined() &&
491 "Invalid starting label for an inlined scope!");
492 assert(EndLabel->isDefined() &&
493 "Invalid end label for an inlined scope!");
494
495 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
496 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
497 dwarf::DW_FORM_ref4, OriginDIE);
498
499 if (Ranges.size() > 1) {
500 // .debug_range section has not been laid out yet. Emit offset in
501 // .debug_range as a uint, size 4, for now. emitDIE will handle
502 // DW_AT_ranges appropriately.
503 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
504 DebugRangeSymbols.size()
505 * Asm->getDataLayout().getPointerSize());
506 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
507 RE = Ranges.end(); RI != RE; ++RI) {
508 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
509 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
510 }
511 DebugRangeSymbols.push_back(NULL);
512 DebugRangeSymbols.push_back(NULL);
513 } else {
514 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
515 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
516 }
517
518 InlinedSubprogramDIEs.insert(OriginDIE);
519
520 // Track the start label for this inlined function.
521 //.debug_inlined section specification does not clearly state how
522 // to emit inlined scope that is split into multiple instruction ranges.
523 // For now, use first instruction range and emit low_pc/high_pc pair and
524 // corresponding .debug_inlined section entry for this pair.
525 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
526 I = InlineInfo.find(InlinedSP);
527
528 if (I == InlineInfo.end()) {
529 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
530 InlinedSPNodes.push_back(InlinedSP);
531 } else
532 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
533
534 DILocation DL(Scope->getInlinedAt());
535 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
536 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
537 TheCU->getUniqueID()));
538 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
539
540 // Add name to the name table, we do this here because we're guaranteed
541 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
542 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
543
544 return ScopeDIE;
545 }
546
547 // Construct a DIE for this scope.
constructScopeDIE(CompileUnit * TheCU,LexicalScope * Scope)548 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
549 if (!Scope || !Scope->getScopeNode())
550 return NULL;
551
552 DIScope DS(Scope->getScopeNode());
553 // Early return to avoid creating dangling variable|scope DIEs.
554 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
555 !TheCU->getDIE(DS))
556 return NULL;
557
558 SmallVector<DIE *, 8> Children;
559 DIE *ObjectPointer = NULL;
560
561 // Collect arguments for current function.
562 if (LScopes.isCurrentFunctionScope(Scope))
563 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
564 if (DbgVariable *ArgDV = CurrentFnArguments[i])
565 if (DIE *Arg =
566 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
567 Children.push_back(Arg);
568 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
569 }
570
571 // Collect lexical scope children first.
572 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
573 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
574 if (DIE *Variable =
575 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
576 Children.push_back(Variable);
577 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
578 }
579 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
580 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
581 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
582 Children.push_back(Nested);
583 DIE *ScopeDIE = NULL;
584 if (Scope->getInlinedAt())
585 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
586 else if (DS.isSubprogram()) {
587 ProcessedSPNodes.insert(DS);
588 if (Scope->isAbstractScope()) {
589 ScopeDIE = TheCU->getDIE(DS);
590 // Note down abstract DIE.
591 if (ScopeDIE)
592 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
593 }
594 else
595 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
596 }
597 else {
598 // There is no need to emit empty lexical block DIE.
599 if (Children.empty())
600 return NULL;
601 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
602 }
603
604 if (!ScopeDIE) return NULL;
605
606 // Add children
607 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
608 E = Children.end(); I != E; ++I)
609 ScopeDIE->addChild(*I);
610
611 if (DS.isSubprogram() && ObjectPointer != NULL)
612 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
613 dwarf::DW_FORM_ref4, ObjectPointer);
614
615 if (DS.isSubprogram())
616 TheCU->addPubTypes(DISubprogram(DS));
617
618 return ScopeDIE;
619 }
620
621 // Look up the source id with the given directory and source file names.
622 // If none currently exists, create a new id and insert it in the
623 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
624 // as well.
getOrCreateSourceID(StringRef FileName,StringRef DirName,unsigned CUID)625 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
626 StringRef DirName, unsigned CUID) {
627 // If we use .loc in assembly, we can't separate .file entries according to
628 // compile units. Thus all files will belong to the default compile unit.
629 if (Asm->TM.hasMCUseLoc() &&
630 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
631 CUID = 0;
632
633 // If FE did not provide a file name, then assume stdin.
634 if (FileName.empty())
635 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
636
637 // TODO: this might not belong here. See if we can factor this better.
638 if (DirName == CompilationDir)
639 DirName = "";
640
641 // FileIDCUMap stores the current ID for the given compile unit.
642 unsigned SrcId = FileIDCUMap[CUID] + 1;
643
644 // We look up the CUID/file/dir by concatenating them with a zero byte.
645 SmallString<128> NamePair;
646 NamePair += CUID;
647 NamePair += '\0';
648 NamePair += DirName;
649 NamePair += '\0'; // Zero bytes are not allowed in paths.
650 NamePair += FileName;
651
652 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
653 if (Ent.getValue() != SrcId)
654 return Ent.getValue();
655
656 FileIDCUMap[CUID] = SrcId;
657 // Print out a .file directive to specify files for .loc directives.
658 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
659
660 return SrcId;
661 }
662
663 // Create new CompileUnit for the given metadata node with tag
664 // DW_TAG_compile_unit.
constructCompileUnit(const MDNode * N)665 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
666 DICompileUnit DIUnit(N);
667 StringRef FN = DIUnit.getFilename();
668 CompilationDir = DIUnit.getDirectory();
669
670 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
671 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
672 DIUnit.getLanguage(), Die, Asm,
673 this, &InfoHolder);
674
675 FileIDCUMap[NewCU->getUniqueID()] = 0;
676 // Call this to emit a .file directive if it wasn't emitted for the source
677 // file this CU comes from yet.
678 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
679
680 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
681 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
682 DIUnit.getLanguage());
683 NewCU->addString(Die, dwarf::DW_AT_name, FN);
684 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
685 // into an entity. We're using 0 (or a NULL label) for this.
686 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
687
688 // Define start line table label for each Compile Unit.
689 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
690 NewCU->getUniqueID());
691 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
692 NewCU->getUniqueID());
693
694 // DW_AT_stmt_list is a offset of line number information for this
695 // compile unit in debug_line section.
696 // The line table entries are not always emitted in assembly, so it
697 // is not okay to use line_table_start here.
698 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
699 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
700 NewCU->getUniqueID() == 0 ?
701 Asm->GetTempSymbol("section_line") : LineTableStartSym);
702 else if (NewCU->getUniqueID() == 0)
703 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
704 else
705 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
706 LineTableStartSym, DwarfLineSectionSym);
707
708 if (!CompilationDir.empty())
709 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
710 if (DIUnit.isOptimized())
711 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
712
713 StringRef Flags = DIUnit.getFlags();
714 if (!Flags.empty())
715 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
716
717 if (unsigned RVer = DIUnit.getRunTimeVersion())
718 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
719 dwarf::DW_FORM_data1, RVer);
720
721 if (!FirstCU)
722 FirstCU = NewCU;
723
724 if (useSplitDwarf()) {
725 // This should be a unique identifier when we want to build .dwp files.
726 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
727 // Now construct the skeleton CU associated.
728 constructSkeletonCU(N);
729 }
730
731 InfoHolder.addUnit(NewCU);
732
733 CUMap.insert(std::make_pair(N, NewCU));
734 return NewCU;
735 }
736
737 // Construct subprogram DIE.
constructSubprogramDIE(CompileUnit * TheCU,const MDNode * N)738 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
739 const MDNode *N) {
740 CompileUnit *&CURef = SPMap[N];
741 if (CURef)
742 return;
743 CURef = TheCU;
744
745 DISubprogram SP(N);
746 if (!SP.isDefinition())
747 // This is a method declaration which will be handled while constructing
748 // class type.
749 return;
750
751 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
752
753 // Add to map.
754 TheCU->insertDIE(N, SubprogramDie);
755
756 // Add to context owner.
757 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
758
759 // Expose as global, if requested.
760 if (GenerateDwarfPubNamesSection)
761 TheCU->addGlobalName(SP.getName(), SubprogramDie);
762 }
763
764 // Emit all Dwarf sections that should come prior to the content. Create
765 // global DIEs and emit initial debug info sections. This is invoked by
766 // the target AsmPrinter.
beginModule()767 void DwarfDebug::beginModule() {
768 if (DisableDebugInfoPrinting)
769 return;
770
771 const Module *M = MMI->getModule();
772
773 // If module has named metadata anchors then use them, otherwise scan the
774 // module using debug info finder to collect debug info.
775 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
776 if (!CU_Nodes)
777 return;
778
779 // Emit initial sections so we can reference labels later.
780 emitSectionLabels();
781
782 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
783 DICompileUnit CUNode(CU_Nodes->getOperand(i));
784 CompileUnit *CU = constructCompileUnit(CUNode);
785 DIArray GVs = CUNode.getGlobalVariables();
786 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
787 CU->createGlobalVariableDIE(GVs.getElement(i));
788 DIArray SPs = CUNode.getSubprograms();
789 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
790 constructSubprogramDIE(CU, SPs.getElement(i));
791 DIArray EnumTypes = CUNode.getEnumTypes();
792 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
793 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
794 DIArray RetainedTypes = CUNode.getRetainedTypes();
795 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
796 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
797 }
798
799 // Tell MMI that we have debug info.
800 MMI->setDebugInfoAvailability(true);
801
802 // Prime section data.
803 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
804 }
805
806 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
computeInlinedDIEs()807 void DwarfDebug::computeInlinedDIEs() {
808 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
809 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
810 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
811 DIE *ISP = *AI;
812 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
813 }
814 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
815 AE = AbstractSPDies.end(); AI != AE; ++AI) {
816 DIE *ISP = AI->second;
817 if (InlinedSubprogramDIEs.count(ISP))
818 continue;
819 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
820 }
821 }
822
823 // Collect info for variables that were optimized out.
collectDeadVariables()824 void DwarfDebug::collectDeadVariables() {
825 const Module *M = MMI->getModule();
826 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
827
828 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
829 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
830 DICompileUnit TheCU(CU_Nodes->getOperand(i));
831 DIArray Subprograms = TheCU.getSubprograms();
832 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
833 DISubprogram SP(Subprograms.getElement(i));
834 if (ProcessedSPNodes.count(SP) != 0) continue;
835 if (!SP.Verify()) continue;
836 if (!SP.isDefinition()) continue;
837 DIArray Variables = SP.getVariables();
838 if (Variables.getNumElements() == 0) continue;
839
840 LexicalScope *Scope =
841 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
842 DeadFnScopeMap[SP] = Scope;
843
844 // Construct subprogram DIE and add variables DIEs.
845 CompileUnit *SPCU = CUMap.lookup(TheCU);
846 assert(SPCU && "Unable to find Compile Unit!");
847 constructSubprogramDIE(SPCU, SP);
848 DIE *ScopeDIE = SPCU->getDIE(SP);
849 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
850 DIVariable DV(Variables.getElement(vi));
851 if (!DV.Verify()) continue;
852 DbgVariable *NewVar = new DbgVariable(DV, NULL);
853 if (DIE *VariableDIE =
854 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
855 ScopeDIE->addChild(VariableDIE);
856 }
857 }
858 }
859 }
860 DeleteContainerSeconds(DeadFnScopeMap);
861 }
862
finalizeModuleInfo()863 void DwarfDebug::finalizeModuleInfo() {
864 // Collect info for variables that were optimized out.
865 collectDeadVariables();
866
867 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
868 computeInlinedDIEs();
869
870 // Emit DW_AT_containing_type attribute to connect types with their
871 // vtable holding type.
872 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
873 CUE = CUMap.end(); CUI != CUE; ++CUI) {
874 CompileUnit *TheCU = CUI->second;
875 TheCU->constructContainingTypeDIEs();
876 }
877
878 // Compute DIE offsets and sizes.
879 InfoHolder.computeSizeAndOffsets();
880 if (useSplitDwarf())
881 SkeletonHolder.computeSizeAndOffsets();
882 }
883
endSections()884 void DwarfDebug::endSections() {
885 // Standard sections final addresses.
886 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
887 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
888 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
889 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
890
891 // End text sections.
892 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
893 Asm->OutStreamer.SwitchSection(SectionMap[I]);
894 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
895 }
896 }
897
898 // Emit all Dwarf sections that should come after the content.
endModule()899 void DwarfDebug::endModule() {
900
901 if (!FirstCU) return;
902
903 // End any existing sections.
904 // TODO: Does this need to happen?
905 endSections();
906
907 // Finalize the debug info for the module.
908 finalizeModuleInfo();
909
910 if (!useSplitDwarf()) {
911 // Emit all the DIEs into a debug info section.
912 emitDebugInfo();
913
914 // Corresponding abbreviations into a abbrev section.
915 emitAbbreviations();
916
917 // Emit info into a debug loc section.
918 emitDebugLoc();
919
920 // Emit info into a debug aranges section.
921 emitDebugARanges();
922
923 // Emit info into a debug ranges section.
924 emitDebugRanges();
925
926 // Emit info into a debug macinfo section.
927 emitDebugMacInfo();
928
929 // Emit inline info.
930 // TODO: When we don't need the option anymore we
931 // can remove all of the code that this section
932 // depends upon.
933 if (useDarwinGDBCompat())
934 emitDebugInlineInfo();
935 } else {
936 // TODO: Fill this in for separated debug sections and separate
937 // out information into new sections.
938
939 // Emit the debug info section and compile units.
940 emitDebugInfo();
941 emitDebugInfoDWO();
942
943 // Corresponding abbreviations into a abbrev section.
944 emitAbbreviations();
945 emitDebugAbbrevDWO();
946
947 // Emit info into a debug loc section.
948 emitDebugLoc();
949
950 // Emit info into a debug aranges section.
951 emitDebugARanges();
952
953 // Emit info into a debug ranges section.
954 emitDebugRanges();
955
956 // Emit info into a debug macinfo section.
957 emitDebugMacInfo();
958
959 // Emit DWO addresses.
960 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
961
962 // Emit inline info.
963 // TODO: When we don't need the option anymore we
964 // can remove all of the code that this section
965 // depends upon.
966 if (useDarwinGDBCompat())
967 emitDebugInlineInfo();
968 }
969
970 // Emit info into the dwarf accelerator table sections.
971 if (useDwarfAccelTables()) {
972 emitAccelNames();
973 emitAccelObjC();
974 emitAccelNamespaces();
975 emitAccelTypes();
976 }
977
978 // Emit info into a debug pubnames section, if requested.
979 if (GenerateDwarfPubNamesSection)
980 emitDebugPubnames();
981
982 // Emit info into a debug pubtypes section.
983 // TODO: When we don't need the option anymore we can
984 // remove all of the code that adds to the table.
985 if (useDarwinGDBCompat())
986 emitDebugPubTypes();
987
988 // Finally emit string information into a string table.
989 emitDebugStr();
990 if (useSplitDwarf())
991 emitDebugStrDWO();
992
993 // clean up.
994 SPMap.clear();
995 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
996 E = CUMap.end(); I != E; ++I)
997 delete I->second;
998
999 for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
1000 E = SkeletonCUs.end(); I != E; ++I)
1001 delete *I;
1002
1003 // Reset these for the next Module if we have one.
1004 FirstCU = NULL;
1005 }
1006
1007 // Find abstract variable, if any, associated with Var.
findAbstractVariable(DIVariable & DV,DebugLoc ScopeLoc)1008 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1009 DebugLoc ScopeLoc) {
1010 LLVMContext &Ctx = DV->getContext();
1011 // More then one inlined variable corresponds to one abstract variable.
1012 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1013 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1014 if (AbsDbgVariable)
1015 return AbsDbgVariable;
1016
1017 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1018 if (!Scope)
1019 return NULL;
1020
1021 AbsDbgVariable = new DbgVariable(Var, NULL);
1022 addScopeVariable(Scope, AbsDbgVariable);
1023 AbstractVariables[Var] = AbsDbgVariable;
1024 return AbsDbgVariable;
1025 }
1026
1027 // If Var is a current function argument then add it to CurrentFnArguments list.
addCurrentFnArgument(const MachineFunction * MF,DbgVariable * Var,LexicalScope * Scope)1028 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1029 DbgVariable *Var, LexicalScope *Scope) {
1030 if (!LScopes.isCurrentFunctionScope(Scope))
1031 return false;
1032 DIVariable DV = Var->getVariable();
1033 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1034 return false;
1035 unsigned ArgNo = DV.getArgNumber();
1036 if (ArgNo == 0)
1037 return false;
1038
1039 size_t Size = CurrentFnArguments.size();
1040 if (Size == 0)
1041 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1042 // llvm::Function argument size is not good indicator of how many
1043 // arguments does the function have at source level.
1044 if (ArgNo > Size)
1045 CurrentFnArguments.resize(ArgNo * 2);
1046 CurrentFnArguments[ArgNo - 1] = Var;
1047 return true;
1048 }
1049
1050 // Collect variable information from side table maintained by MMI.
1051 void
collectVariableInfoFromMMITable(const MachineFunction * MF,SmallPtrSet<const MDNode *,16> & Processed)1052 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1053 SmallPtrSet<const MDNode *, 16> &Processed) {
1054 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1055 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1056 VE = VMap.end(); VI != VE; ++VI) {
1057 const MDNode *Var = VI->first;
1058 if (!Var) continue;
1059 Processed.insert(Var);
1060 DIVariable DV(Var);
1061 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1062
1063 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1064
1065 // If variable scope is not found then skip this variable.
1066 if (Scope == 0)
1067 continue;
1068
1069 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1070 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1071 RegVar->setFrameIndex(VP.first);
1072 if (!addCurrentFnArgument(MF, RegVar, Scope))
1073 addScopeVariable(Scope, RegVar);
1074 if (AbsDbgVariable)
1075 AbsDbgVariable->setFrameIndex(VP.first);
1076 }
1077 }
1078
1079 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1080 // defined reg.
isDbgValueInDefinedReg(const MachineInstr * MI)1081 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1082 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1083 return MI->getNumOperands() == 3 &&
1084 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1085 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1086 }
1087
1088 // Get .debug_loc entry for the instruction range starting at MI.
getDebugLocEntry(AsmPrinter * Asm,const MCSymbol * FLabel,const MCSymbol * SLabel,const MachineInstr * MI)1089 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1090 const MCSymbol *FLabel,
1091 const MCSymbol *SLabel,
1092 const MachineInstr *MI) {
1093 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1094
1095 if (MI->getNumOperands() != 3) {
1096 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1097 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1098 }
1099 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1100 MachineLocation MLoc;
1101 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1102 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1103 }
1104 if (MI->getOperand(0).isImm())
1105 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1106 if (MI->getOperand(0).isFPImm())
1107 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1108 if (MI->getOperand(0).isCImm())
1109 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1110
1111 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1112 }
1113
1114 // Find variables for each lexical scope.
1115 void
collectVariableInfo(const MachineFunction * MF,SmallPtrSet<const MDNode *,16> & Processed)1116 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1117 SmallPtrSet<const MDNode *, 16> &Processed) {
1118
1119 // collection info from MMI table.
1120 collectVariableInfoFromMMITable(MF, Processed);
1121
1122 for (SmallVectorImpl<const MDNode*>::const_iterator
1123 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1124 ++UVI) {
1125 const MDNode *Var = *UVI;
1126 if (Processed.count(Var))
1127 continue;
1128
1129 // History contains relevant DBG_VALUE instructions for Var and instructions
1130 // clobbering it.
1131 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1132 if (History.empty())
1133 continue;
1134 const MachineInstr *MInsn = History.front();
1135
1136 DIVariable DV(Var);
1137 LexicalScope *Scope = NULL;
1138 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1139 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1140 Scope = LScopes.getCurrentFunctionScope();
1141 else if (MDNode *IA = DV.getInlinedAt())
1142 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1143 else
1144 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1145 // If variable scope is not found then skip this variable.
1146 if (!Scope)
1147 continue;
1148
1149 Processed.insert(DV);
1150 assert(MInsn->isDebugValue() && "History must begin with debug value");
1151 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1152 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1153 if (!addCurrentFnArgument(MF, RegVar, Scope))
1154 addScopeVariable(Scope, RegVar);
1155 if (AbsVar)
1156 AbsVar->setMInsn(MInsn);
1157
1158 // Simplify ranges that are fully coalesced.
1159 if (History.size() <= 1 || (History.size() == 2 &&
1160 MInsn->isIdenticalTo(History.back()))) {
1161 RegVar->setMInsn(MInsn);
1162 continue;
1163 }
1164
1165 // Handle multiple DBG_VALUE instructions describing one variable.
1166 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1167
1168 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1169 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1170 const MachineInstr *Begin = *HI;
1171 assert(Begin->isDebugValue() && "Invalid History entry");
1172
1173 // Check if DBG_VALUE is truncating a range.
1174 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1175 && !Begin->getOperand(0).getReg())
1176 continue;
1177
1178 // Compute the range for a register location.
1179 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1180 const MCSymbol *SLabel = 0;
1181
1182 if (HI + 1 == HE)
1183 // If Begin is the last instruction in History then its value is valid
1184 // until the end of the function.
1185 SLabel = FunctionEndSym;
1186 else {
1187 const MachineInstr *End = HI[1];
1188 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1189 << "\t" << *Begin << "\t" << *End << "\n");
1190 if (End->isDebugValue())
1191 SLabel = getLabelBeforeInsn(End);
1192 else {
1193 // End is a normal instruction clobbering the range.
1194 SLabel = getLabelAfterInsn(End);
1195 assert(SLabel && "Forgot label after clobber instruction");
1196 ++HI;
1197 }
1198 }
1199
1200 // The value is valid until the next DBG_VALUE or clobber.
1201 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1202 Begin));
1203 }
1204 DotDebugLocEntries.push_back(DotDebugLocEntry());
1205 }
1206
1207 // Collect info for variables that were optimized out.
1208 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1209 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1210 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1211 DIVariable DV(Variables.getElement(i));
1212 if (!DV || !DV.Verify() || !Processed.insert(DV))
1213 continue;
1214 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1215 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1216 }
1217 }
1218
1219 // Return Label preceding the instruction.
getLabelBeforeInsn(const MachineInstr * MI)1220 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1221 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1222 assert(Label && "Didn't insert label before instruction");
1223 return Label;
1224 }
1225
1226 // Return Label immediately following the instruction.
getLabelAfterInsn(const MachineInstr * MI)1227 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1228 return LabelsAfterInsn.lookup(MI);
1229 }
1230
1231 // Process beginning of an instruction.
beginInstruction(const MachineInstr * MI)1232 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1233 // Check if source location changes, but ignore DBG_VALUE locations.
1234 if (!MI->isDebugValue()) {
1235 DebugLoc DL = MI->getDebugLoc();
1236 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1237 unsigned Flags = 0;
1238 PrevInstLoc = DL;
1239 if (DL == PrologEndLoc) {
1240 Flags |= DWARF2_FLAG_PROLOGUE_END;
1241 PrologEndLoc = DebugLoc();
1242 }
1243 if (PrologEndLoc.isUnknown())
1244 Flags |= DWARF2_FLAG_IS_STMT;
1245
1246 if (!DL.isUnknown()) {
1247 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1248 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1249 } else
1250 recordSourceLine(0, 0, 0, 0);
1251 }
1252 }
1253
1254 // Insert labels where requested.
1255 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1256 LabelsBeforeInsn.find(MI);
1257
1258 // No label needed.
1259 if (I == LabelsBeforeInsn.end())
1260 return;
1261
1262 // Label already assigned.
1263 if (I->second)
1264 return;
1265
1266 if (!PrevLabel) {
1267 PrevLabel = MMI->getContext().CreateTempSymbol();
1268 Asm->OutStreamer.EmitLabel(PrevLabel);
1269 }
1270 I->second = PrevLabel;
1271 }
1272
1273 // Process end of an instruction.
endInstruction(const MachineInstr * MI)1274 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1275 // Don't create a new label after DBG_VALUE instructions.
1276 // They don't generate code.
1277 if (!MI->isDebugValue())
1278 PrevLabel = 0;
1279
1280 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1281 LabelsAfterInsn.find(MI);
1282
1283 // No label needed.
1284 if (I == LabelsAfterInsn.end())
1285 return;
1286
1287 // Label already assigned.
1288 if (I->second)
1289 return;
1290
1291 // We need a label after this instruction.
1292 if (!PrevLabel) {
1293 PrevLabel = MMI->getContext().CreateTempSymbol();
1294 Asm->OutStreamer.EmitLabel(PrevLabel);
1295 }
1296 I->second = PrevLabel;
1297 }
1298
1299 // Each LexicalScope has first instruction and last instruction to mark
1300 // beginning and end of a scope respectively. Create an inverse map that list
1301 // scopes starts (and ends) with an instruction. One instruction may start (or
1302 // end) multiple scopes. Ignore scopes that are not reachable.
identifyScopeMarkers()1303 void DwarfDebug::identifyScopeMarkers() {
1304 SmallVector<LexicalScope *, 4> WorkList;
1305 WorkList.push_back(LScopes.getCurrentFunctionScope());
1306 while (!WorkList.empty()) {
1307 LexicalScope *S = WorkList.pop_back_val();
1308
1309 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1310 if (!Children.empty())
1311 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1312 SE = Children.end(); SI != SE; ++SI)
1313 WorkList.push_back(*SI);
1314
1315 if (S->isAbstractScope())
1316 continue;
1317
1318 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1319 if (Ranges.empty())
1320 continue;
1321 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1322 RE = Ranges.end(); RI != RE; ++RI) {
1323 assert(RI->first && "InsnRange does not have first instruction!");
1324 assert(RI->second && "InsnRange does not have second instruction!");
1325 requestLabelBeforeInsn(RI->first);
1326 requestLabelAfterInsn(RI->second);
1327 }
1328 }
1329 }
1330
1331 // Get MDNode for DebugLoc's scope.
getScopeNode(DebugLoc DL,const LLVMContext & Ctx)1332 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1333 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1334 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1335 return DL.getScope(Ctx);
1336 }
1337
1338 // Walk up the scope chain of given debug loc and find line number info
1339 // for the function.
getFnDebugLoc(DebugLoc DL,const LLVMContext & Ctx)1340 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1341 const MDNode *Scope = getScopeNode(DL, Ctx);
1342 DISubprogram SP = getDISubprogram(Scope);
1343 if (SP.Verify()) {
1344 // Check for number of operands since the compatibility is
1345 // cheap here.
1346 if (SP->getNumOperands() > 19)
1347 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1348 else
1349 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1350 }
1351
1352 return DebugLoc();
1353 }
1354
1355 // Gather pre-function debug information. Assumes being called immediately
1356 // after the function entry point has been emitted.
beginFunction(const MachineFunction * MF)1357 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1358 if (!MMI->hasDebugInfo()) return;
1359 LScopes.initialize(*MF);
1360 if (LScopes.empty()) return;
1361 identifyScopeMarkers();
1362
1363 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1364 // belongs to.
1365 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1366 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1367 assert(TheCU && "Unable to find compile unit!");
1368 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1369
1370 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1371 Asm->getFunctionNumber());
1372 // Assumes in correct section after the entry point.
1373 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1374
1375 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1376
1377 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1378 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1379 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1380
1381 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1382 I != E; ++I) {
1383 bool AtBlockEntry = true;
1384 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1385 II != IE; ++II) {
1386 const MachineInstr *MI = II;
1387
1388 if (MI->isDebugValue()) {
1389 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1390
1391 // Keep track of user variables.
1392 const MDNode *Var =
1393 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1394
1395 // Variable is in a register, we need to check for clobbers.
1396 if (isDbgValueInDefinedReg(MI))
1397 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1398
1399 // Check the history of this variable.
1400 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1401 if (History.empty()) {
1402 UserVariables.push_back(Var);
1403 // The first mention of a function argument gets the FunctionBeginSym
1404 // label, so arguments are visible when breaking at function entry.
1405 DIVariable DV(Var);
1406 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1407 DISubprogram(getDISubprogram(DV.getContext()))
1408 .describes(MF->getFunction()))
1409 LabelsBeforeInsn[MI] = FunctionBeginSym;
1410 } else {
1411 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1412 const MachineInstr *Prev = History.back();
1413 if (Prev->isDebugValue()) {
1414 // Coalesce identical entries at the end of History.
1415 if (History.size() >= 2 &&
1416 Prev->isIdenticalTo(History[History.size() - 2])) {
1417 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1418 << "\t" << *Prev
1419 << "\t" << *History[History.size() - 2] << "\n");
1420 History.pop_back();
1421 }
1422
1423 // Terminate old register assignments that don't reach MI;
1424 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1425 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1426 isDbgValueInDefinedReg(Prev)) {
1427 // Previous register assignment needs to terminate at the end of
1428 // its basic block.
1429 MachineBasicBlock::const_iterator LastMI =
1430 PrevMBB->getLastNonDebugInstr();
1431 if (LastMI == PrevMBB->end()) {
1432 // Drop DBG_VALUE for empty range.
1433 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1434 << "\t" << *Prev << "\n");
1435 History.pop_back();
1436 }
1437 else {
1438 // Terminate after LastMI.
1439 History.push_back(LastMI);
1440 }
1441 }
1442 }
1443 }
1444 History.push_back(MI);
1445 } else {
1446 // Not a DBG_VALUE instruction.
1447 if (!MI->isLabel())
1448 AtBlockEntry = false;
1449
1450 // First known non-DBG_VALUE and non-frame setup location marks
1451 // the beginning of the function body.
1452 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1453 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1454 PrologEndLoc = MI->getDebugLoc();
1455
1456 // Check if the instruction clobbers any registers with debug vars.
1457 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1458 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1459 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1460 continue;
1461 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1462 AI.isValid(); ++AI) {
1463 unsigned Reg = *AI;
1464 const MDNode *Var = LiveUserVar[Reg];
1465 if (!Var)
1466 continue;
1467 // Reg is now clobbered.
1468 LiveUserVar[Reg] = 0;
1469
1470 // Was MD last defined by a DBG_VALUE referring to Reg?
1471 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1472 if (HistI == DbgValues.end())
1473 continue;
1474 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1475 if (History.empty())
1476 continue;
1477 const MachineInstr *Prev = History.back();
1478 // Sanity-check: Register assignments are terminated at the end of
1479 // their block.
1480 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1481 continue;
1482 // Is the variable still in Reg?
1483 if (!isDbgValueInDefinedReg(Prev) ||
1484 Prev->getOperand(0).getReg() != Reg)
1485 continue;
1486 // Var is clobbered. Make sure the next instruction gets a label.
1487 History.push_back(MI);
1488 }
1489 }
1490 }
1491 }
1492 }
1493
1494 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1495 I != E; ++I) {
1496 SmallVectorImpl<const MachineInstr*> &History = I->second;
1497 if (History.empty())
1498 continue;
1499
1500 // Make sure the final register assignments are terminated.
1501 const MachineInstr *Prev = History.back();
1502 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1503 const MachineBasicBlock *PrevMBB = Prev->getParent();
1504 MachineBasicBlock::const_iterator LastMI =
1505 PrevMBB->getLastNonDebugInstr();
1506 if (LastMI == PrevMBB->end())
1507 // Drop DBG_VALUE for empty range.
1508 History.pop_back();
1509 else {
1510 // Terminate after LastMI.
1511 History.push_back(LastMI);
1512 }
1513 }
1514 // Request labels for the full history.
1515 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1516 const MachineInstr *MI = History[i];
1517 if (MI->isDebugValue())
1518 requestLabelBeforeInsn(MI);
1519 else
1520 requestLabelAfterInsn(MI);
1521 }
1522 }
1523
1524 PrevInstLoc = DebugLoc();
1525 PrevLabel = FunctionBeginSym;
1526
1527 // Record beginning of function.
1528 if (!PrologEndLoc.isUnknown()) {
1529 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1530 MF->getFunction()->getContext());
1531 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1532 FnStartDL.getScope(MF->getFunction()->getContext()),
1533 // We'd like to list the prologue as "not statements" but GDB behaves
1534 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1535 DWARF2_FLAG_IS_STMT);
1536 }
1537 }
1538
addScopeVariable(LexicalScope * LS,DbgVariable * Var)1539 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1540 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1541 ScopeVariables[LS].push_back(Var);
1542 // Vars.push_back(Var);
1543 }
1544
1545 // Gather and emit post-function debug information.
endFunction(const MachineFunction * MF)1546 void DwarfDebug::endFunction(const MachineFunction *MF) {
1547 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1548
1549 // Define end label for subprogram.
1550 FunctionEndSym = Asm->GetTempSymbol("func_end",
1551 Asm->getFunctionNumber());
1552 // Assumes in correct section after the entry point.
1553 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1554 // Set DwarfCompileUnitID in MCContext to default value.
1555 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1556
1557 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1558 collectVariableInfo(MF, ProcessedVars);
1559
1560 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1561 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1562 assert(TheCU && "Unable to find compile unit!");
1563
1564 // Construct abstract scopes.
1565 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1566 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1567 LexicalScope *AScope = AList[i];
1568 DISubprogram SP(AScope->getScopeNode());
1569 if (SP.Verify()) {
1570 // Collect info for variables that were optimized out.
1571 DIArray Variables = SP.getVariables();
1572 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1573 DIVariable DV(Variables.getElement(i));
1574 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1575 continue;
1576 // Check that DbgVariable for DV wasn't created earlier, when
1577 // findAbstractVariable() was called for inlined instance of DV.
1578 LLVMContext &Ctx = DV->getContext();
1579 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1580 if (AbstractVariables.lookup(CleanDV))
1581 continue;
1582 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1583 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1584 }
1585 }
1586 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1587 constructScopeDIE(TheCU, AScope);
1588 }
1589
1590 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1591
1592 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1593 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1594
1595 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1596 MMI->getFrameMoves()));
1597
1598 // Clear debug info
1599 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1600 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1601 DeleteContainerPointers(I->second);
1602 ScopeVariables.clear();
1603 DeleteContainerPointers(CurrentFnArguments);
1604 UserVariables.clear();
1605 DbgValues.clear();
1606 AbstractVariables.clear();
1607 LabelsBeforeInsn.clear();
1608 LabelsAfterInsn.clear();
1609 PrevLabel = NULL;
1610 }
1611
1612 // Register a source line with debug info. Returns the unique label that was
1613 // emitted and which provides correspondence to the source line list.
recordSourceLine(unsigned Line,unsigned Col,const MDNode * S,unsigned Flags)1614 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1615 unsigned Flags) {
1616 StringRef Fn;
1617 StringRef Dir;
1618 unsigned Src = 1;
1619 if (S) {
1620 DIDescriptor Scope(S);
1621
1622 if (Scope.isCompileUnit()) {
1623 DICompileUnit CU(S);
1624 Fn = CU.getFilename();
1625 Dir = CU.getDirectory();
1626 } else if (Scope.isFile()) {
1627 DIFile F(S);
1628 Fn = F.getFilename();
1629 Dir = F.getDirectory();
1630 } else if (Scope.isSubprogram()) {
1631 DISubprogram SP(S);
1632 Fn = SP.getFilename();
1633 Dir = SP.getDirectory();
1634 } else if (Scope.isLexicalBlockFile()) {
1635 DILexicalBlockFile DBF(S);
1636 Fn = DBF.getFilename();
1637 Dir = DBF.getDirectory();
1638 } else if (Scope.isLexicalBlock()) {
1639 DILexicalBlock DB(S);
1640 Fn = DB.getFilename();
1641 Dir = DB.getDirectory();
1642 } else
1643 llvm_unreachable("Unexpected scope info");
1644
1645 Src = getOrCreateSourceID(Fn, Dir,
1646 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1647 }
1648 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1649 }
1650
1651 //===----------------------------------------------------------------------===//
1652 // Emit Methods
1653 //===----------------------------------------------------------------------===//
1654
1655 // Compute the size and offset of a DIE.
1656 unsigned
computeSizeAndOffset(DIE * Die,unsigned Offset)1657 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1658 // Get the children.
1659 const std::vector<DIE *> &Children = Die->getChildren();
1660
1661 // Record the abbreviation.
1662 assignAbbrevNumber(Die->getAbbrev());
1663
1664 // Get the abbreviation for this DIE.
1665 unsigned AbbrevNumber = Die->getAbbrevNumber();
1666 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1667
1668 // Set DIE offset
1669 Die->setOffset(Offset);
1670
1671 // Start the size with the size of abbreviation code.
1672 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1673
1674 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1675 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1676
1677 // Size the DIE attribute values.
1678 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1679 // Size attribute value.
1680 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1681
1682 // Size the DIE children if any.
1683 if (!Children.empty()) {
1684 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1685 "Children flag not set");
1686
1687 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1688 Offset = computeSizeAndOffset(Children[j], Offset);
1689
1690 // End of children marker.
1691 Offset += sizeof(int8_t);
1692 }
1693
1694 Die->setSize(Offset - Die->getOffset());
1695 return Offset;
1696 }
1697
1698 // Compute the size and offset of all the DIEs.
computeSizeAndOffsets()1699 void DwarfUnits::computeSizeAndOffsets() {
1700 // Offset from the beginning of debug info section.
1701 unsigned AccuOffset = 0;
1702 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1703 E = CUs.end(); I != E; ++I) {
1704 (*I)->setDebugInfoOffset(AccuOffset);
1705 unsigned Offset =
1706 sizeof(int32_t) + // Length of Compilation Unit Info
1707 sizeof(int16_t) + // DWARF version number
1708 sizeof(int32_t) + // Offset Into Abbrev. Section
1709 sizeof(int8_t); // Pointer Size (in bytes)
1710
1711 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1712 AccuOffset += EndOffset;
1713 }
1714 }
1715
1716 // Emit initial Dwarf sections with a label at the start of each one.
emitSectionLabels()1717 void DwarfDebug::emitSectionLabels() {
1718 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1719
1720 // Dwarf sections base addresses.
1721 DwarfInfoSectionSym =
1722 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1723 DwarfAbbrevSectionSym =
1724 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1725 if (useSplitDwarf())
1726 DwarfAbbrevDWOSectionSym =
1727 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1728 "section_abbrev_dwo");
1729 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1730
1731 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1732 emitSectionSym(Asm, MacroInfo);
1733
1734 DwarfLineSectionSym =
1735 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1736 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1737 if (GenerateDwarfPubNamesSection)
1738 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1739 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1740 DwarfStrSectionSym =
1741 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1742 if (useSplitDwarf())
1743 DwarfStrDWOSectionSym =
1744 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1745 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1746 "debug_range");
1747
1748 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1749 "section_debug_loc");
1750
1751 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1752 emitSectionSym(Asm, TLOF.getDataSection());
1753 }
1754
1755 // Recursively emits a debug information entry.
emitDIE(DIE * Die,std::vector<DIEAbbrev * > * Abbrevs)1756 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1757 // Get the abbreviation for this DIE.
1758 unsigned AbbrevNumber = Die->getAbbrevNumber();
1759 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1760
1761 // Emit the code (index) for the abbreviation.
1762 if (Asm->isVerbose())
1763 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1764 Twine::utohexstr(Die->getOffset()) + ":0x" +
1765 Twine::utohexstr(Die->getSize()) + " " +
1766 dwarf::TagString(Abbrev->getTag()));
1767 Asm->EmitULEB128(AbbrevNumber);
1768
1769 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1770 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1771
1772 // Emit the DIE attribute values.
1773 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1774 unsigned Attr = AbbrevData[i].getAttribute();
1775 unsigned Form = AbbrevData[i].getForm();
1776 assert(Form && "Too many attributes for DIE (check abbreviation)");
1777
1778 if (Asm->isVerbose())
1779 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1780
1781 switch (Attr) {
1782 case dwarf::DW_AT_abstract_origin: {
1783 DIEEntry *E = cast<DIEEntry>(Values[i]);
1784 DIE *Origin = E->getEntry();
1785 unsigned Addr = Origin->getOffset();
1786 if (Form == dwarf::DW_FORM_ref_addr) {
1787 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1788 // section. Origin->getOffset() returns the offset from start of the
1789 // compile unit.
1790 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1791 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1792 }
1793 Asm->EmitInt32(Addr);
1794 break;
1795 }
1796 case dwarf::DW_AT_ranges: {
1797 // DW_AT_range Value encodes offset in debug_range section.
1798 DIEInteger *V = cast<DIEInteger>(Values[i]);
1799
1800 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1801 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1802 V->getValue(),
1803 4);
1804 } else {
1805 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1806 V->getValue(),
1807 DwarfDebugRangeSectionSym,
1808 4);
1809 }
1810 break;
1811 }
1812 case dwarf::DW_AT_location: {
1813 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1814 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1815 Asm->EmitLabelReference(L->getValue(), 4);
1816 else
1817 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1818 } else {
1819 Values[i]->EmitValue(Asm, Form);
1820 }
1821 break;
1822 }
1823 case dwarf::DW_AT_accessibility: {
1824 if (Asm->isVerbose()) {
1825 DIEInteger *V = cast<DIEInteger>(Values[i]);
1826 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1827 }
1828 Values[i]->EmitValue(Asm, Form);
1829 break;
1830 }
1831 default:
1832 // Emit an attribute using the defined form.
1833 Values[i]->EmitValue(Asm, Form);
1834 break;
1835 }
1836 }
1837
1838 // Emit the DIE children if any.
1839 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1840 const std::vector<DIE *> &Children = Die->getChildren();
1841
1842 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1843 emitDIE(Children[j], Abbrevs);
1844
1845 if (Asm->isVerbose())
1846 Asm->OutStreamer.AddComment("End Of Children Mark");
1847 Asm->EmitInt8(0);
1848 }
1849 }
1850
1851 // Emit the various dwarf units to the unit section USection with
1852 // the abbreviations going into ASection.
emitUnits(DwarfDebug * DD,const MCSection * USection,const MCSection * ASection,const MCSymbol * ASectionSym)1853 void DwarfUnits::emitUnits(DwarfDebug *DD,
1854 const MCSection *USection,
1855 const MCSection *ASection,
1856 const MCSymbol *ASectionSym) {
1857 Asm->OutStreamer.SwitchSection(USection);
1858 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1859 E = CUs.end(); I != E; ++I) {
1860 CompileUnit *TheCU = *I;
1861 DIE *Die = TheCU->getCUDie();
1862
1863 // Emit the compile units header.
1864 Asm->OutStreamer
1865 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1866 TheCU->getUniqueID()));
1867
1868 // Emit size of content not including length itself
1869 unsigned ContentSize = Die->getSize() +
1870 sizeof(int16_t) + // DWARF version number
1871 sizeof(int32_t) + // Offset Into Abbrev. Section
1872 sizeof(int8_t); // Pointer Size (in bytes)
1873
1874 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1875 Asm->EmitInt32(ContentSize);
1876 Asm->OutStreamer.AddComment("DWARF version number");
1877 Asm->EmitInt16(dwarf::DWARF_VERSION);
1878 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1879 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1880 ASectionSym);
1881 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1882 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1883
1884 DD->emitDIE(Die, Abbreviations);
1885 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1886 TheCU->getUniqueID()));
1887 }
1888 }
1889
1890 /// For a given compile unit DIE, returns offset from beginning of debug info.
getCUOffset(DIE * Die)1891 unsigned DwarfUnits::getCUOffset(DIE *Die) {
1892 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
1893 "Input DIE should be compile unit in getCUOffset.");
1894 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1895 E = CUs.end(); I != E; ++I) {
1896 CompileUnit *TheCU = *I;
1897 if (TheCU->getCUDie() == Die)
1898 return TheCU->getDebugInfoOffset();
1899 }
1900 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
1901 }
1902
1903 // Emit the debug info section.
emitDebugInfo()1904 void DwarfDebug::emitDebugInfo() {
1905 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1906
1907 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
1908 Asm->getObjFileLowering().getDwarfAbbrevSection(),
1909 DwarfAbbrevSectionSym);
1910 }
1911
1912 // Emit the abbreviation section.
emitAbbreviations()1913 void DwarfDebug::emitAbbreviations() {
1914 if (!useSplitDwarf())
1915 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
1916 &Abbreviations);
1917 else
1918 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1919 }
1920
emitAbbrevs(const MCSection * Section,std::vector<DIEAbbrev * > * Abbrevs)1921 void DwarfDebug::emitAbbrevs(const MCSection *Section,
1922 std::vector<DIEAbbrev *> *Abbrevs) {
1923 // Check to see if it is worth the effort.
1924 if (!Abbrevs->empty()) {
1925 // Start the debug abbrev section.
1926 Asm->OutStreamer.SwitchSection(Section);
1927
1928 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
1929 Asm->OutStreamer.EmitLabel(Begin);
1930
1931 // For each abbrevation.
1932 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
1933 // Get abbreviation data
1934 const DIEAbbrev *Abbrev = Abbrevs->at(i);
1935
1936 // Emit the abbrevations code (base 1 index.)
1937 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1938
1939 // Emit the abbreviations data.
1940 Abbrev->Emit(Asm);
1941 }
1942
1943 // Mark end of abbreviations.
1944 Asm->EmitULEB128(0, "EOM(3)");
1945
1946 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
1947 Asm->OutStreamer.EmitLabel(End);
1948 }
1949 }
1950
1951 // Emit the last address of the section and the end of the line matrix.
emitEndOfLineMatrix(unsigned SectionEnd)1952 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1953 // Define last address of section.
1954 Asm->OutStreamer.AddComment("Extended Op");
1955 Asm->EmitInt8(0);
1956
1957 Asm->OutStreamer.AddComment("Op size");
1958 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1959 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1960 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1961
1962 Asm->OutStreamer.AddComment("Section end label");
1963
1964 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1965 Asm->getDataLayout().getPointerSize());
1966
1967 // Mark end of matrix.
1968 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1969 Asm->EmitInt8(0);
1970 Asm->EmitInt8(1);
1971 Asm->EmitInt8(1);
1972 }
1973
1974 // Emit visible names into a hashed accelerator table section.
emitAccelNames()1975 void DwarfDebug::emitAccelNames() {
1976 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1977 dwarf::DW_FORM_data4));
1978 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1979 E = CUMap.end(); I != E; ++I) {
1980 CompileUnit *TheCU = I->second;
1981 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1982 for (StringMap<std::vector<DIE*> >::const_iterator
1983 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1984 const char *Name = GI->getKeyData();
1985 const std::vector<DIE *> &Entities = GI->second;
1986 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1987 DE = Entities.end(); DI != DE; ++DI)
1988 AT.AddName(Name, (*DI));
1989 }
1990 }
1991
1992 AT.FinalizeTable(Asm, "Names");
1993 Asm->OutStreamer.SwitchSection(
1994 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1995 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1996 Asm->OutStreamer.EmitLabel(SectionBegin);
1997
1998 // Emit the full data.
1999 AT.Emit(Asm, SectionBegin, &InfoHolder);
2000 }
2001
2002 // Emit objective C classes and categories into a hashed accelerator table
2003 // section.
emitAccelObjC()2004 void DwarfDebug::emitAccelObjC() {
2005 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2006 dwarf::DW_FORM_data4));
2007 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2008 E = CUMap.end(); I != E; ++I) {
2009 CompileUnit *TheCU = I->second;
2010 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2011 for (StringMap<std::vector<DIE*> >::const_iterator
2012 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2013 const char *Name = GI->getKeyData();
2014 const std::vector<DIE *> &Entities = GI->second;
2015 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2016 DE = Entities.end(); DI != DE; ++DI)
2017 AT.AddName(Name, (*DI));
2018 }
2019 }
2020
2021 AT.FinalizeTable(Asm, "ObjC");
2022 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2023 .getDwarfAccelObjCSection());
2024 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2025 Asm->OutStreamer.EmitLabel(SectionBegin);
2026
2027 // Emit the full data.
2028 AT.Emit(Asm, SectionBegin, &InfoHolder);
2029 }
2030
2031 // Emit namespace dies into a hashed accelerator table.
emitAccelNamespaces()2032 void DwarfDebug::emitAccelNamespaces() {
2033 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2034 dwarf::DW_FORM_data4));
2035 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2036 E = CUMap.end(); I != E; ++I) {
2037 CompileUnit *TheCU = I->second;
2038 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2039 for (StringMap<std::vector<DIE*> >::const_iterator
2040 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2041 const char *Name = GI->getKeyData();
2042 const std::vector<DIE *> &Entities = GI->second;
2043 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2044 DE = Entities.end(); DI != DE; ++DI)
2045 AT.AddName(Name, (*DI));
2046 }
2047 }
2048
2049 AT.FinalizeTable(Asm, "namespac");
2050 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2051 .getDwarfAccelNamespaceSection());
2052 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2053 Asm->OutStreamer.EmitLabel(SectionBegin);
2054
2055 // Emit the full data.
2056 AT.Emit(Asm, SectionBegin, &InfoHolder);
2057 }
2058
2059 // Emit type dies into a hashed accelerator table.
emitAccelTypes()2060 void DwarfDebug::emitAccelTypes() {
2061 std::vector<DwarfAccelTable::Atom> Atoms;
2062 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2063 dwarf::DW_FORM_data4));
2064 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2065 dwarf::DW_FORM_data2));
2066 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2067 dwarf::DW_FORM_data1));
2068 DwarfAccelTable AT(Atoms);
2069 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2070 E = CUMap.end(); I != E; ++I) {
2071 CompileUnit *TheCU = I->second;
2072 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2073 = TheCU->getAccelTypes();
2074 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2075 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2076 const char *Name = GI->getKeyData();
2077 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2078 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2079 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2080 AT.AddName(Name, (*DI).first, (*DI).second);
2081 }
2082 }
2083
2084 AT.FinalizeTable(Asm, "types");
2085 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2086 .getDwarfAccelTypesSection());
2087 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2088 Asm->OutStreamer.EmitLabel(SectionBegin);
2089
2090 // Emit the full data.
2091 AT.Emit(Asm, SectionBegin, &InfoHolder);
2092 }
2093
2094 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2095 ///
emitDebugPubnames()2096 void DwarfDebug::emitDebugPubnames() {
2097 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2098
2099 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2100 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2101 CompileUnit *TheCU = I->second;
2102 unsigned ID = TheCU->getUniqueID();
2103
2104 if (TheCU->getGlobalNames().empty())
2105 continue;
2106
2107 // Start the dwarf pubnames section.
2108 Asm->OutStreamer.SwitchSection(
2109 Asm->getObjFileLowering().getDwarfPubNamesSection());
2110
2111 Asm->OutStreamer.AddComment("Length of Public Names Info");
2112 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2113 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2114
2115 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2116
2117 Asm->OutStreamer.AddComment("DWARF Version");
2118 Asm->EmitInt16(dwarf::DWARF_VERSION);
2119
2120 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2121 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2122 DwarfInfoSectionSym);
2123
2124 Asm->OutStreamer.AddComment("Compilation Unit Length");
2125 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2126 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2127 4);
2128
2129 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2130 for (StringMap<DIE*>::const_iterator
2131 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2132 const char *Name = GI->getKeyData();
2133 const DIE *Entity = GI->second;
2134
2135 Asm->OutStreamer.AddComment("DIE offset");
2136 Asm->EmitInt32(Entity->getOffset());
2137
2138 if (Asm->isVerbose())
2139 Asm->OutStreamer.AddComment("External Name");
2140 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2141 }
2142
2143 Asm->OutStreamer.AddComment("End Mark");
2144 Asm->EmitInt32(0);
2145 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2146 }
2147 }
2148
emitDebugPubTypes()2149 void DwarfDebug::emitDebugPubTypes() {
2150 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2151 E = CUMap.end(); I != E; ++I) {
2152 CompileUnit *TheCU = I->second;
2153 // Start the dwarf pubtypes section.
2154 Asm->OutStreamer.SwitchSection(
2155 Asm->getObjFileLowering().getDwarfPubTypesSection());
2156 Asm->OutStreamer.AddComment("Length of Public Types Info");
2157 Asm->EmitLabelDifference(
2158 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2159 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2160
2161 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2162 TheCU->getUniqueID()));
2163
2164 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2165 Asm->EmitInt16(dwarf::DWARF_VERSION);
2166
2167 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2168 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2169 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2170 TheCU->getUniqueID()),
2171 DwarfInfoSectionSym);
2172
2173 Asm->OutStreamer.AddComment("Compilation Unit Length");
2174 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2175 TheCU->getUniqueID()),
2176 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2177 TheCU->getUniqueID()),
2178 4);
2179
2180 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2181 for (StringMap<DIE*>::const_iterator
2182 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2183 const char *Name = GI->getKeyData();
2184 DIE *Entity = GI->second;
2185
2186 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2187 Asm->EmitInt32(Entity->getOffset());
2188
2189 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2190 // Emit the name with a terminating null byte.
2191 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2192 }
2193
2194 Asm->OutStreamer.AddComment("End Mark");
2195 Asm->EmitInt32(0);
2196 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2197 TheCU->getUniqueID()));
2198 }
2199 }
2200
2201 // Emit strings into a string section.
emitStrings(const MCSection * StrSection,const MCSection * OffsetSection=NULL,const MCSymbol * StrSecSym=NULL)2202 void DwarfUnits::emitStrings(const MCSection *StrSection,
2203 const MCSection *OffsetSection = NULL,
2204 const MCSymbol *StrSecSym = NULL) {
2205
2206 if (StringPool.empty()) return;
2207
2208 // Start the dwarf str section.
2209 Asm->OutStreamer.SwitchSection(StrSection);
2210
2211 // Get all of the string pool entries and put them in an array by their ID so
2212 // we can sort them.
2213 SmallVector<std::pair<unsigned,
2214 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2215
2216 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2217 I = StringPool.begin(), E = StringPool.end();
2218 I != E; ++I)
2219 Entries.push_back(std::make_pair(I->second.second, &*I));
2220
2221 array_pod_sort(Entries.begin(), Entries.end());
2222
2223 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2224 // Emit a label for reference from debug information entries.
2225 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2226
2227 // Emit the string itself with a terminating null byte.
2228 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2229 Entries[i].second->getKeyLength()+1));
2230 }
2231
2232 // If we've got an offset section go ahead and emit that now as well.
2233 if (OffsetSection) {
2234 Asm->OutStreamer.SwitchSection(OffsetSection);
2235 unsigned offset = 0;
2236 unsigned size = 4; // FIXME: DWARF64 is 8.
2237 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2238 Asm->OutStreamer.EmitIntValue(offset, size);
2239 offset += Entries[i].second->getKeyLength() + 1;
2240 }
2241 }
2242 }
2243
2244 // Emit strings into a string section.
emitAddresses(const MCSection * AddrSection)2245 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2246
2247 if (AddressPool.empty()) return;
2248
2249 // Start the dwarf addr section.
2250 Asm->OutStreamer.SwitchSection(AddrSection);
2251
2252 // Get all of the string pool entries and put them in an array by their ID so
2253 // we can sort them.
2254 SmallVector<std::pair<unsigned,
2255 std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2256
2257 for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2258 I = AddressPool.begin(), E = AddressPool.end();
2259 I != E; ++I)
2260 Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2261
2262 array_pod_sort(Entries.begin(), Entries.end());
2263
2264 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2265 // Emit a label for reference from debug information entries.
2266 MCSymbol *Sym = Entries[i].second->first;
2267 if (Sym)
2268 Asm->EmitLabelReference(Entries[i].second->first,
2269 Asm->getDataLayout().getPointerSize());
2270 else
2271 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2272 }
2273
2274 }
2275
2276 // Emit visible names into a debug str section.
emitDebugStr()2277 void DwarfDebug::emitDebugStr() {
2278 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2279 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2280 }
2281
2282 // Emit visible names into a debug loc section.
emitDebugLoc()2283 void DwarfDebug::emitDebugLoc() {
2284 if (DotDebugLocEntries.empty())
2285 return;
2286
2287 for (SmallVector<DotDebugLocEntry, 4>::iterator
2288 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2289 I != E; ++I) {
2290 DotDebugLocEntry &Entry = *I;
2291 if (I + 1 != DotDebugLocEntries.end())
2292 Entry.Merge(I+1);
2293 }
2294
2295 // Start the dwarf loc section.
2296 Asm->OutStreamer.SwitchSection(
2297 Asm->getObjFileLowering().getDwarfLocSection());
2298 unsigned char Size = Asm->getDataLayout().getPointerSize();
2299 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2300 unsigned index = 1;
2301 for (SmallVector<DotDebugLocEntry, 4>::iterator
2302 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2303 I != E; ++I, ++index) {
2304 DotDebugLocEntry &Entry = *I;
2305 if (Entry.isMerged()) continue;
2306 if (Entry.isEmpty()) {
2307 Asm->OutStreamer.EmitIntValue(0, Size);
2308 Asm->OutStreamer.EmitIntValue(0, Size);
2309 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2310 } else {
2311 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2312 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
2313 DIVariable DV(Entry.Variable);
2314 Asm->OutStreamer.AddComment("Loc expr size");
2315 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2316 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2317 Asm->EmitLabelDifference(end, begin, 2);
2318 Asm->OutStreamer.EmitLabel(begin);
2319 if (Entry.isInt()) {
2320 DIBasicType BTy(DV.getType());
2321 if (BTy.Verify() &&
2322 (BTy.getEncoding() == dwarf::DW_ATE_signed
2323 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2324 Asm->OutStreamer.AddComment("DW_OP_consts");
2325 Asm->EmitInt8(dwarf::DW_OP_consts);
2326 Asm->EmitSLEB128(Entry.getInt());
2327 } else {
2328 Asm->OutStreamer.AddComment("DW_OP_constu");
2329 Asm->EmitInt8(dwarf::DW_OP_constu);
2330 Asm->EmitULEB128(Entry.getInt());
2331 }
2332 } else if (Entry.isLocation()) {
2333 if (!DV.hasComplexAddress())
2334 // Regular entry.
2335 Asm->EmitDwarfRegOp(Entry.Loc);
2336 else {
2337 // Complex address entry.
2338 unsigned N = DV.getNumAddrElements();
2339 unsigned i = 0;
2340 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2341 if (Entry.Loc.getOffset()) {
2342 i = 2;
2343 Asm->EmitDwarfRegOp(Entry.Loc);
2344 Asm->OutStreamer.AddComment("DW_OP_deref");
2345 Asm->EmitInt8(dwarf::DW_OP_deref);
2346 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2347 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2348 Asm->EmitSLEB128(DV.getAddrElement(1));
2349 } else {
2350 // If first address element is OpPlus then emit
2351 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2352 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2353 Asm->EmitDwarfRegOp(Loc);
2354 i = 2;
2355 }
2356 } else {
2357 Asm->EmitDwarfRegOp(Entry.Loc);
2358 }
2359
2360 // Emit remaining complex address elements.
2361 for (; i < N; ++i) {
2362 uint64_t Element = DV.getAddrElement(i);
2363 if (Element == DIBuilder::OpPlus) {
2364 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2365 Asm->EmitULEB128(DV.getAddrElement(++i));
2366 } else if (Element == DIBuilder::OpDeref) {
2367 if (!Entry.Loc.isReg())
2368 Asm->EmitInt8(dwarf::DW_OP_deref);
2369 } else
2370 llvm_unreachable("unknown Opcode found in complex address");
2371 }
2372 }
2373 }
2374 // else ... ignore constant fp. There is not any good way to
2375 // to represent them here in dwarf.
2376 Asm->OutStreamer.EmitLabel(end);
2377 }
2378 }
2379 }
2380
2381 // Emit visible names into a debug aranges section.
emitDebugARanges()2382 void DwarfDebug::emitDebugARanges() {
2383 // Start the dwarf aranges section.
2384 Asm->OutStreamer.SwitchSection(
2385 Asm->getObjFileLowering().getDwarfARangesSection());
2386 }
2387
2388 // Emit visible names into a debug ranges section.
emitDebugRanges()2389 void DwarfDebug::emitDebugRanges() {
2390 // Start the dwarf ranges section.
2391 Asm->OutStreamer.SwitchSection(
2392 Asm->getObjFileLowering().getDwarfRangesSection());
2393 unsigned char Size = Asm->getDataLayout().getPointerSize();
2394 for (SmallVector<const MCSymbol *, 8>::iterator
2395 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2396 I != E; ++I) {
2397 if (*I)
2398 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2399 else
2400 Asm->OutStreamer.EmitIntValue(0, Size);
2401 }
2402 }
2403
2404 // Emit visible names into a debug macinfo section.
emitDebugMacInfo()2405 void DwarfDebug::emitDebugMacInfo() {
2406 if (const MCSection *LineInfo =
2407 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2408 // Start the dwarf macinfo section.
2409 Asm->OutStreamer.SwitchSection(LineInfo);
2410 }
2411 }
2412
2413 // Emit inline info using following format.
2414 // Section Header:
2415 // 1. length of section
2416 // 2. Dwarf version number
2417 // 3. address size.
2418 //
2419 // Entries (one "entry" for each function that was inlined):
2420 //
2421 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2422 // otherwise offset into __debug_str for regular function name.
2423 // 2. offset into __debug_str section for regular function name.
2424 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2425 // instances for the function.
2426 //
2427 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2428 // inlined instance; the die_offset points to the inlined_subroutine die in the
2429 // __debug_info section, and the low_pc is the starting address for the
2430 // inlining instance.
emitDebugInlineInfo()2431 void DwarfDebug::emitDebugInlineInfo() {
2432 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2433 return;
2434
2435 if (!FirstCU)
2436 return;
2437
2438 Asm->OutStreamer.SwitchSection(
2439 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2440
2441 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2442 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2443 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2444
2445 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2446
2447 Asm->OutStreamer.AddComment("Dwarf Version");
2448 Asm->EmitInt16(dwarf::DWARF_VERSION);
2449 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2450 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2451
2452 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2453 E = InlinedSPNodes.end(); I != E; ++I) {
2454
2455 const MDNode *Node = *I;
2456 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2457 = InlineInfo.find(Node);
2458 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2459 DISubprogram SP(Node);
2460 StringRef LName = SP.getLinkageName();
2461 StringRef Name = SP.getName();
2462
2463 Asm->OutStreamer.AddComment("MIPS linkage name");
2464 if (LName.empty())
2465 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2466 DwarfStrSectionSym);
2467 else
2468 Asm->EmitSectionOffset(InfoHolder
2469 .getStringPoolEntry(getRealLinkageName(LName)),
2470 DwarfStrSectionSym);
2471
2472 Asm->OutStreamer.AddComment("Function name");
2473 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2474 DwarfStrSectionSym);
2475 Asm->EmitULEB128(Labels.size(), "Inline count");
2476
2477 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2478 LE = Labels.end(); LI != LE; ++LI) {
2479 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2480 Asm->EmitInt32(LI->second->getOffset());
2481
2482 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2483 Asm->OutStreamer.EmitSymbolValue(LI->first,
2484 Asm->getDataLayout().getPointerSize());
2485 }
2486 }
2487
2488 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2489 }
2490
2491 // DWARF5 Experimental Separate Dwarf emitters.
2492
2493 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2494 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2495 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2496 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
constructSkeletonCU(const MDNode * N)2497 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2498 DICompileUnit DIUnit(N);
2499 CompilationDir = DIUnit.getDirectory();
2500
2501 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2502 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2503 DIUnit.getLanguage(), Die, Asm,
2504 this, &SkeletonHolder);
2505
2506 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2507 DIUnit.getSplitDebugFilename());
2508
2509 // This should be a unique identifier when we want to build .dwp files.
2510 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2511
2512 // FIXME: The addr base should be relative for each compile unit, however,
2513 // this one is going to be 0 anyhow.
2514 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset, 0);
2515
2516 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2517 // into an entity. We're using 0, or a NULL label for this.
2518 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2519
2520 // DW_AT_stmt_list is a offset of line number information for this
2521 // compile unit in debug_line section.
2522 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2523 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2524 DwarfLineSectionSym);
2525 else
2526 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2527
2528 if (!CompilationDir.empty())
2529 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2530
2531 SkeletonHolder.addUnit(NewCU);
2532 SkeletonCUs.push_back(NewCU);
2533
2534 return NewCU;
2535 }
2536
emitSkeletonAbbrevs(const MCSection * Section)2537 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2538 assert(useSplitDwarf() && "No split dwarf debug info?");
2539 emitAbbrevs(Section, &SkeletonAbbrevs);
2540 }
2541
2542 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2543 // compile units that would normally be in debug_info.
emitDebugInfoDWO()2544 void DwarfDebug::emitDebugInfoDWO() {
2545 assert(useSplitDwarf() && "No split dwarf debug info?");
2546 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2547 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2548 DwarfAbbrevDWOSectionSym);
2549 }
2550
2551 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2552 // abbreviations for the .debug_info.dwo section.
emitDebugAbbrevDWO()2553 void DwarfDebug::emitDebugAbbrevDWO() {
2554 assert(useSplitDwarf() && "No split dwarf?");
2555 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2556 &Abbreviations);
2557 }
2558
2559 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2560 // string section and is identical in format to traditional .debug_str
2561 // sections.
emitDebugStrDWO()2562 void DwarfDebug::emitDebugStrDWO() {
2563 assert(useSplitDwarf() && "No split dwarf?");
2564 const MCSection *OffSec = Asm->getObjFileLowering()
2565 .getDwarfStrOffDWOSection();
2566 const MCSymbol *StrSym = DwarfStrSectionSym;
2567 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2568 OffSec, StrSym);
2569 }
2570