1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
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"
49 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
51 cl::desc("Disable debug info printing"));
53 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
54 cl::desc("Make an absence of debug location information explicit."),
59 Default, Enable, Disable
63 static cl::opt<DefaultOnOff> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
64 cl::desc("Output prototype dwarf accelerator tables."),
66 clEnumVal(Default, "Default for platform"),
67 clEnumVal(Enable, "Enabled"),
68 clEnumVal(Disable, "Disabled"),
72 static cl::opt<DefaultOnOff> DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
73 cl::desc("Compatibility with Darwin gdb."),
75 clEnumVal(Default, "Default for platform"),
76 clEnumVal(Enable, "Enabled"),
77 clEnumVal(Disable, "Disabled"),
81 static cl::opt<DefaultOnOff> SplitDwarf("split-dwarf", cl::Hidden,
82 cl::desc("Output prototype dwarf split debug info."),
84 clEnumVal(Default, "Default for platform"),
85 clEnumVal(Enable, "Enabled"),
86 clEnumVal(Disable, "Disabled"),
91 const char *DWARFGroupName = "DWARF Emission";
92 const char *DbgTimerName = "DWARF Debug Writer";
93 } // end anonymous namespace
95 //===----------------------------------------------------------------------===//
97 // Configuration values for initial hash set sizes (log2).
99 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
103 DIType DbgVariable::getType() const {
104 DIType Ty = Var.getType();
105 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
106 // addresses instead.
107 if (Var.isBlockByrefVariable()) {
108 /* Byref variables, in Blocks, are declared by the programmer as
109 "SomeType VarName;", but the compiler creates a
110 __Block_byref_x_VarName struct, and gives the variable VarName
111 either the struct, or a pointer to the struct, as its type. This
112 is necessary for various behind-the-scenes things the compiler
113 needs to do with by-reference variables in blocks.
115 However, as far as the original *programmer* is concerned, the
116 variable should still have type 'SomeType', as originally declared.
118 The following function dives into the __Block_byref_x_VarName
119 struct to find the original type of the variable. This will be
120 passed back to the code generating the type for the Debug
121 Information Entry for the variable 'VarName'. 'VarName' will then
122 have the original type 'SomeType' in its debug information.
124 The original type 'SomeType' will be the type of the field named
125 'VarName' inside the __Block_byref_x_VarName struct.
127 NOTE: In order for this to not completely fail on the debugger
128 side, the Debug Information Entry for the variable VarName needs to
129 have a DW_AT_location that tells the debugger how to unwind through
130 the pointers and __Block_byref_x_VarName struct to find the actual
131 value of the variable. The function addBlockByrefType does this. */
133 unsigned tag = Ty.getTag();
135 if (tag == dwarf::DW_TAG_pointer_type) {
136 DIDerivedType DTy = DIDerivedType(Ty);
137 subType = DTy.getTypeDerivedFrom();
140 DICompositeType blockStruct = DICompositeType(subType);
141 DIArray Elements = blockStruct.getTypeArray();
143 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
144 DIDescriptor Element = Elements.getElement(i);
145 DIDerivedType DT = DIDerivedType(Element);
146 if (getName() == DT.getName())
147 return (DT.getTypeDerivedFrom());
153 } // end llvm namespace
155 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
156 : Asm(A), MMI(Asm->MMI), FirstCU(0),
157 AbbreviationsSet(InitAbbreviationsSetSize),
158 SourceIdMap(DIEValueAllocator), InfoStringPool(DIEValueAllocator),
159 PrevLabel(NULL), GlobalCUIndexCount(0),
160 InfoHolder(A, &AbbreviationsSet, &Abbreviations,
161 &InfoStringPool, "info_string"),
163 SkeletonAbbrevSet(InitAbbreviationsSetSize),
164 SkeletonStringPool(DIEValueAllocator),
165 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs,
166 &SkeletonStringPool, "skel_string") {
168 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
169 DwarfStrSectionSym = TextSectionSym = 0;
170 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
171 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
172 FunctionBeginSym = FunctionEndSym = 0;
174 // Turn on accelerator tables and older gdb compatibility
176 bool IsDarwin = Triple(M->getTargetTriple()).isOSDarwin();
177 if (DarwinGDBCompat == Default) {
179 IsDarwinGDBCompat = true;
181 IsDarwinGDBCompat = false;
183 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
185 if (DwarfAccelTables == Default) {
187 HasDwarfAccelTables = true;
189 HasDwarfAccelTables = false;
191 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
193 if (SplitDwarf == Default)
194 HasSplitDwarf = false;
196 HasSplitDwarf = SplitDwarf == Enable ? true : false;
199 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
203 DwarfDebug::~DwarfDebug() {
206 // Switch to the specified MCSection and emit an assembler
207 // temporary label to it if SymbolStem is specified.
208 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
209 const char *SymbolStem = 0) {
210 Asm->OutStreamer.SwitchSection(Section);
211 if (!SymbolStem) return 0;
213 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
214 Asm->OutStreamer.EmitLabel(TmpSym);
218 MCSymbol *DwarfUnits::getStringPoolSym() {
219 return Asm->GetTempSymbol(StringPref);
222 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
223 std::pair<MCSymbol*, unsigned> &Entry =
224 StringPool->GetOrCreateValue(Str).getValue();
225 if (Entry.first) return Entry.first;
227 Entry.second = NextStringPoolNumber++;
228 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
231 // Define a unique number for the abbreviation.
233 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
234 // Profile the node so that we can make it unique.
238 // Check the set for priors.
239 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
241 // If it's newly added.
242 if (InSet == &Abbrev) {
243 // Add to abbreviation list.
244 Abbreviations->push_back(&Abbrev);
246 // Assign the vector position + 1 as its number.
247 Abbrev.setNumber(Abbreviations->size());
249 // Assign existing abbreviation number.
250 Abbrev.setNumber(InSet->getNumber());
254 // If special LLVM prefix that is used to inform the asm
255 // printer to not emit usual symbol prefix before the symbol name is used then
256 // return linkage name after skipping this special LLVM prefix.
257 static StringRef getRealLinkageName(StringRef LinkageName) {
259 if (LinkageName.startswith(StringRef(&One, 1)))
260 return LinkageName.substr(1);
264 static bool isObjCClass(StringRef Name) {
265 return Name.startswith("+") || Name.startswith("-");
268 static bool hasObjCCategory(StringRef Name) {
269 if (!isObjCClass(Name)) return false;
271 size_t pos = Name.find(')');
272 if (pos != std::string::npos) {
273 if (Name[pos+1] != ' ') return false;
279 static void getObjCClassCategory(StringRef In, StringRef &Class,
280 StringRef &Category) {
281 if (!hasObjCCategory(In)) {
282 Class = In.slice(In.find('[') + 1, In.find(' '));
287 Class = In.slice(In.find('[') + 1, In.find('('));
288 Category = In.slice(In.find('[') + 1, In.find(' '));
292 static StringRef getObjCMethodName(StringRef In) {
293 return In.slice(In.find(' ') + 1, In.find(']'));
296 // Add the various names to the Dwarf accelerator table names.
297 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
299 if (!SP.isDefinition()) return;
301 TheCU->addAccelName(SP.getName(), Die);
303 // If the linkage name is different than the name, go ahead and output
304 // that as well into the name table.
305 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
306 TheCU->addAccelName(SP.getLinkageName(), Die);
308 // If this is an Objective-C selector name add it to the ObjC accelerator
310 if (isObjCClass(SP.getName())) {
311 StringRef Class, Category;
312 getObjCClassCategory(SP.getName(), Class, Category);
313 TheCU->addAccelObjC(Class, Die);
315 TheCU->addAccelObjC(Category, Die);
316 // Also add the base method name to the name table.
317 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
321 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
322 // and DW_AT_high_pc attributes. If there are global variables in this
323 // scope then create and insert DIEs for these variables.
324 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
325 const MDNode *SPNode) {
326 DIE *SPDie = SPCU->getDIE(SPNode);
328 assert(SPDie && "Unable to find subprogram DIE!");
329 DISubprogram SP(SPNode);
331 // If we're updating an abstract DIE, then we will be adding the children and
332 // object pointer later on. But what we don't want to do is process the
333 // concrete DIE twice.
334 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
335 // Pick up abstract subprogram DIE.
336 SPDie = new DIE(dwarf::DW_TAG_subprogram);
337 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
338 dwarf::DW_FORM_ref4, AbsSPDIE);
341 DISubprogram SPDecl = SP.getFunctionDeclaration();
342 if (!SPDecl.isSubprogram()) {
343 // There is not any need to generate specification DIE for a function
344 // defined at compile unit level. If a function is defined inside another
345 // function then gdb prefers the definition at top level and but does not
346 // expect specification DIE in parent function. So avoid creating
347 // specification DIE for a function defined inside a function.
348 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
349 !SP.getContext().isFile() &&
350 !isSubprogramContext(SP.getContext())) {
351 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
354 DICompositeType SPTy = SP.getType();
355 DIArray Args = SPTy.getTypeArray();
356 unsigned SPTag = SPTy.getTag();
357 if (SPTag == dwarf::DW_TAG_subroutine_type)
358 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
359 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
360 DIType ATy = DIType(Args.getElement(i));
361 SPCU->addType(Arg, ATy);
362 if (ATy.isArtificial())
363 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
364 if (ATy.isObjectPointer())
365 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
366 dwarf::DW_FORM_ref4, Arg);
367 SPDie->addChild(Arg);
369 DIE *SPDeclDie = SPDie;
370 SPDie = new DIE(dwarf::DW_TAG_subprogram);
371 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
372 dwarf::DW_FORM_ref4, SPDeclDie);
378 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
379 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
380 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
381 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
382 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
383 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
384 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
386 // Add name to the name table, we do this here because we're guaranteed
387 // to have concrete versions of our DW_TAG_subprogram nodes.
388 addSubprogramNames(SPCU, SP, SPDie);
393 // Construct new DW_TAG_lexical_block for this scope and attach
394 // DW_AT_low_pc/DW_AT_high_pc labels.
395 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
396 LexicalScope *Scope) {
397 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
398 if (Scope->isAbstractScope())
401 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
405 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
406 if (Ranges.size() > 1) {
407 // .debug_range section has not been laid out yet. Emit offset in
408 // .debug_range as a uint, size 4, for now. emitDIE will handle
409 // DW_AT_ranges appropriately.
410 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
411 DebugRangeSymbols.size()
412 * Asm->getDataLayout().getPointerSize());
413 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
414 RE = Ranges.end(); RI != RE; ++RI) {
415 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
416 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
418 DebugRangeSymbols.push_back(NULL);
419 DebugRangeSymbols.push_back(NULL);
423 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
424 const MCSymbol *End = getLabelAfterInsn(RI->second);
426 if (End == 0) return 0;
428 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
429 assert(End->isDefined() && "Invalid end label for an inlined scope!");
431 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
432 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
437 // This scope represents inlined body of a function. Construct DIE to
438 // represent this concrete inlined copy of the function.
439 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
440 LexicalScope *Scope) {
441 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
442 assert(Ranges.empty() == false &&
443 "LexicalScope does not have instruction markers!");
445 if (!Scope->getScopeNode())
447 DIScope DS(Scope->getScopeNode());
448 DISubprogram InlinedSP = getDISubprogram(DS);
449 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
451 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
455 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
456 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
457 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
459 if (StartLabel == 0 || EndLabel == 0) {
460 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
462 assert(StartLabel->isDefined() &&
463 "Invalid starting label for an inlined scope!");
464 assert(EndLabel->isDefined() &&
465 "Invalid end label for an inlined scope!");
467 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
468 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
469 dwarf::DW_FORM_ref4, OriginDIE);
471 if (Ranges.size() > 1) {
472 // .debug_range section has not been laid out yet. Emit offset in
473 // .debug_range as a uint, size 4, for now. emitDIE will handle
474 // DW_AT_ranges appropriately.
475 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
476 DebugRangeSymbols.size()
477 * Asm->getDataLayout().getPointerSize());
478 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
479 RE = Ranges.end(); RI != RE; ++RI) {
480 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
481 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
483 DebugRangeSymbols.push_back(NULL);
484 DebugRangeSymbols.push_back(NULL);
486 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
488 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
492 InlinedSubprogramDIEs.insert(OriginDIE);
494 // Track the start label for this inlined function.
495 //.debug_inlined section specification does not clearly state how
496 // to emit inlined scope that is split into multiple instruction ranges.
497 // For now, use first instruction range and emit low_pc/high_pc pair and
498 // corresponding .debug_inlined section entry for this pair.
499 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
500 I = InlineInfo.find(InlinedSP);
502 if (I == InlineInfo.end()) {
503 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
504 InlinedSPNodes.push_back(InlinedSP);
506 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
508 DILocation DL(Scope->getInlinedAt());
509 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
510 getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
511 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
513 // Add name to the name table, we do this here because we're guaranteed
514 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
515 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
520 // Construct a DIE for this scope.
521 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
522 if (!Scope || !Scope->getScopeNode())
525 SmallVector<DIE *, 8> Children;
526 DIE *ObjectPointer = NULL;
528 // Collect arguments for current function.
529 if (LScopes.isCurrentFunctionScope(Scope))
530 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
531 if (DbgVariable *ArgDV = CurrentFnArguments[i])
533 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
534 Children.push_back(Arg);
535 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
538 // Collect lexical scope children first.
539 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
540 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
542 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
543 Children.push_back(Variable);
544 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
546 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
547 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
548 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
549 Children.push_back(Nested);
550 DIScope DS(Scope->getScopeNode());
551 DIE *ScopeDIE = NULL;
552 if (Scope->getInlinedAt())
553 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
554 else if (DS.isSubprogram()) {
555 ProcessedSPNodes.insert(DS);
556 if (Scope->isAbstractScope()) {
557 ScopeDIE = TheCU->getDIE(DS);
558 // Note down abstract DIE.
560 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
563 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
566 // There is no need to emit empty lexical block DIE.
567 if (Children.empty())
569 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
572 if (!ScopeDIE) return NULL;
575 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
576 E = Children.end(); I != E; ++I)
577 ScopeDIE->addChild(*I);
579 if (DS.isSubprogram() && ObjectPointer != NULL)
580 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
581 dwarf::DW_FORM_ref4, ObjectPointer);
583 if (DS.isSubprogram())
584 TheCU->addPubTypes(DISubprogram(DS));
589 // Look up the source id with the given directory and source file names.
590 // If none currently exists, create a new id and insert it in the
591 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
593 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
595 // If FE did not provide a file name, then assume stdin.
596 if (FileName.empty())
597 return getOrCreateSourceID("<stdin>", StringRef());
599 // TODO: this might not belong here. See if we can factor this better.
600 if (DirName == CompilationDir)
603 unsigned SrcId = SourceIdMap.size()+1;
605 // We look up the file/dir pair by concatenating them with a zero byte.
606 SmallString<128> NamePair;
608 NamePair += '\0'; // Zero bytes are not allowed in paths.
609 NamePair += FileName;
611 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
612 if (Ent.getValue() != SrcId)
613 return Ent.getValue();
615 // Print out a .file directive to specify files for .loc directives.
616 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
621 // Create new CompileUnit for the given metadata node with tag
622 // DW_TAG_compile_unit.
623 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
624 DICompileUnit DIUnit(N);
625 StringRef FN = DIUnit.getFilename();
626 CompilationDir = DIUnit.getDirectory();
627 // Call this to emit a .file directive if it wasn't emitted for the source
628 // file this CU comes from yet.
629 getOrCreateSourceID(FN, CompilationDir);
631 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
632 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
633 DIUnit.getLanguage(), Die, Asm,
635 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
636 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
637 DIUnit.getLanguage());
638 NewCU->addString(Die, dwarf::DW_AT_name, FN);
639 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
641 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
642 // DW_AT_stmt_list is a offset of line number information for this
643 // compile unit in debug_line section.
644 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
645 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
646 Asm->GetTempSymbol("section_line"));
648 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
650 if (!CompilationDir.empty())
651 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
652 if (DIUnit.isOptimized())
653 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
655 StringRef Flags = DIUnit.getFlags();
657 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
659 if (unsigned RVer = DIUnit.getRunTimeVersion())
660 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
661 dwarf::DW_FORM_data1, RVer);
665 if (useSplitDwarf() && !SkeletonCU)
666 SkeletonCU = constructSkeletonCU(N);
668 InfoHolder.addUnit(NewCU);
670 CUMap.insert(std::make_pair(N, NewCU));
674 // Construct subprogram DIE.
675 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
677 CompileUnit *&CURef = SPMap[N];
683 if (!SP.isDefinition())
684 // This is a method declaration which will be handled while constructing
688 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
691 TheCU->insertDIE(N, SubprogramDie);
693 // Add to context owner.
694 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
699 // Collect debug info from named mdnodes such as llvm.dbg.enum and llvm.dbg.ty.
700 void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) {
701 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
702 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
703 const MDNode *N = NMD->getOperand(i);
704 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
705 constructSubprogramDIE(CU, N);
708 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
709 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
710 const MDNode *N = NMD->getOperand(i);
711 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
712 CU->createGlobalVariableDIE(N);
715 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
716 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
717 DIType Ty(NMD->getOperand(i));
718 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
719 CU->getOrCreateTypeDIE(Ty);
722 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
723 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
724 DIType Ty(NMD->getOperand(i));
725 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
726 CU->getOrCreateTypeDIE(Ty);
730 // Collect debug info using DebugInfoFinder.
731 // FIXME - Remove this when dragonegg switches to DIBuilder.
732 bool DwarfDebug::collectLegacyDebugInfo(const Module *M) {
733 DebugInfoFinder DbgFinder;
734 DbgFinder.processModule(*M);
736 bool HasDebugInfo = false;
737 // Scan all the compile-units to see if there are any marked as the main
738 // unit. If not, we do not generate debug info.
739 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
740 E = DbgFinder.compile_unit_end(); I != E; ++I) {
741 if (DICompileUnit(*I).isMain()) {
746 if (!HasDebugInfo) return false;
748 // Create all the compile unit DIEs.
749 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
750 E = DbgFinder.compile_unit_end(); I != E; ++I)
751 constructCompileUnit(*I);
753 // Create DIEs for each global variable.
754 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
755 E = DbgFinder.global_variable_end(); I != E; ++I) {
756 const MDNode *N = *I;
757 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
758 CU->createGlobalVariableDIE(N);
761 // Create DIEs for each subprogram.
762 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
763 E = DbgFinder.subprogram_end(); I != E; ++I) {
764 const MDNode *N = *I;
765 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
766 constructSubprogramDIE(CU, N);
772 // Emit all Dwarf sections that should come prior to the content. Create
773 // global DIEs and emit initial debug info sections. This is invoked by
774 // the target AsmPrinter.
775 void DwarfDebug::beginModule() {
776 if (DisableDebugInfoPrinting)
779 const Module *M = MMI->getModule();
781 // If module has named metadata anchors then use them, otherwise scan the
782 // module using debug info finder to collect debug info.
783 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
785 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
786 DICompileUnit CUNode(CU_Nodes->getOperand(i));
787 CompileUnit *CU = constructCompileUnit(CUNode);
788 DIArray GVs = CUNode.getGlobalVariables();
789 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
790 CU->createGlobalVariableDIE(GVs.getElement(i));
791 DIArray SPs = CUNode.getSubprograms();
792 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
793 constructSubprogramDIE(CU, SPs.getElement(i));
794 DIArray EnumTypes = CUNode.getEnumTypes();
795 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
796 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
797 DIArray RetainedTypes = CUNode.getRetainedTypes();
798 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
799 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
801 } else if (!collectLegacyDebugInfo(M))
804 collectInfoFromNamedMDNodes(M);
806 // Tell MMI that we have debug info.
807 MMI->setDebugInfoAvailability(true);
809 // Prime section data.
810 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
813 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
814 void DwarfDebug::computeInlinedDIEs() {
815 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
816 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
817 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
819 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
821 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
822 AE = AbstractSPDies.end(); AI != AE; ++AI) {
823 DIE *ISP = AI->second;
824 if (InlinedSubprogramDIEs.count(ISP))
826 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
830 // Collect info for variables that were optimized out.
831 void DwarfDebug::collectDeadVariables() {
832 const Module *M = MMI->getModule();
833 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
835 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
836 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
837 DICompileUnit TheCU(CU_Nodes->getOperand(i));
838 DIArray Subprograms = TheCU.getSubprograms();
839 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
840 DISubprogram SP(Subprograms.getElement(i));
841 if (ProcessedSPNodes.count(SP) != 0) continue;
842 if (!SP.Verify()) continue;
843 if (!SP.isDefinition()) continue;
844 DIArray Variables = SP.getVariables();
845 if (Variables.getNumElements() == 0) continue;
847 LexicalScope *Scope =
848 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
849 DeadFnScopeMap[SP] = Scope;
851 // Construct subprogram DIE and add variables DIEs.
852 CompileUnit *SPCU = CUMap.lookup(TheCU);
853 assert(SPCU && "Unable to find Compile Unit!");
854 constructSubprogramDIE(SPCU, SP);
855 DIE *ScopeDIE = SPCU->getDIE(SP);
856 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
857 DIVariable DV(Variables.getElement(vi));
858 if (!DV.Verify()) continue;
859 DbgVariable *NewVar = new DbgVariable(DV, NULL);
860 if (DIE *VariableDIE =
861 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
862 ScopeDIE->addChild(VariableDIE);
867 DeleteContainerSeconds(DeadFnScopeMap);
870 void DwarfDebug::finalizeModuleInfo() {
871 // Collect info for variables that were optimized out.
872 collectDeadVariables();
874 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
875 computeInlinedDIEs();
877 // Emit DW_AT_containing_type attribute to connect types with their
878 // vtable holding type.
879 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
880 CUE = CUMap.end(); CUI != CUE; ++CUI) {
881 CompileUnit *TheCU = CUI->second;
882 TheCU->constructContainingTypeDIEs();
885 // Compute DIE offsets and sizes.
886 InfoHolder.computeSizeAndOffsets();
888 SkeletonHolder.computeSizeAndOffsets();
891 void DwarfDebug::endSections() {
892 // Standard sections final addresses.
893 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
894 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
895 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
896 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
898 // End text sections.
899 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
900 Asm->OutStreamer.SwitchSection(SectionMap[I]);
901 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
905 // Emit all Dwarf sections that should come after the content.
906 void DwarfDebug::endModule() {
908 if (!FirstCU) return;
910 // End any existing sections.
911 // TODO: Does this need to happen?
914 // Finalize the debug info for the module.
915 finalizeModuleInfo();
917 // Emit initial sections.
920 if (!useSplitDwarf()) {
921 // Emit all the DIEs into a debug info section.
924 // Corresponding abbreviations into a abbrev section.
927 // Emit info into a debug loc section.
930 // Emit info into a debug aranges section.
933 // Emit info into a debug ranges section.
936 // Emit info into a debug macinfo section.
940 // TODO: When we don't need the option anymore we
941 // can remove all of the code that this section
943 if (useDarwinGDBCompat())
944 emitDebugInlineInfo();
946 // TODO: Fill this in for separated debug sections and separate
947 // out information into new sections.
949 // Emit the debug info section and compile units.
953 // Corresponding abbreviations into a abbrev section.
955 emitDebugAbbrevDWO();
957 // Emit info into a debug loc section.
960 // Emit info into a debug aranges section.
963 // Emit info into a debug ranges section.
966 // Emit info into a debug macinfo section.
970 // TODO: When we don't need the option anymore we
971 // can remove all of the code that this section
973 if (useDarwinGDBCompat())
974 emitDebugInlineInfo();
977 // Emit info into the dwarf accelerator table sections.
978 if (useDwarfAccelTables()) {
981 emitAccelNamespaces();
985 // Emit info into a debug pubtypes section.
986 // TODO: When we don't need the option anymore we can
987 // remove all of the code that adds to the table.
988 if (useDarwinGDBCompat())
991 // Finally emit string information into a string table.
998 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
999 E = CUMap.end(); I != E; ++I)
1004 // Reset these for the next Module if we have one.
1009 // Find abstract variable, if any, associated with Var.
1010 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1011 DebugLoc ScopeLoc) {
1012 LLVMContext &Ctx = DV->getContext();
1013 // More then one inlined variable corresponds to one abstract variable.
1014 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1015 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1017 return AbsDbgVariable;
1019 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1023 AbsDbgVariable = new DbgVariable(Var, NULL);
1024 addScopeVariable(Scope, AbsDbgVariable);
1025 AbstractVariables[Var] = AbsDbgVariable;
1026 return AbsDbgVariable;
1029 // If Var is a current function argument then add it to CurrentFnArguments list.
1030 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1031 DbgVariable *Var, LexicalScope *Scope) {
1032 if (!LScopes.isCurrentFunctionScope(Scope))
1034 DIVariable DV = Var->getVariable();
1035 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1037 unsigned ArgNo = DV.getArgNumber();
1041 size_t Size = CurrentFnArguments.size();
1043 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1044 // llvm::Function argument size is not good indicator of how many
1045 // arguments does the function have at source level.
1047 CurrentFnArguments.resize(ArgNo * 2);
1048 CurrentFnArguments[ArgNo - 1] = Var;
1052 // Collect variable information from side table maintained by MMI.
1054 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1055 SmallPtrSet<const MDNode *, 16> &Processed) {
1056 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1057 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1058 VE = VMap.end(); VI != VE; ++VI) {
1059 const MDNode *Var = VI->first;
1061 Processed.insert(Var);
1063 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1065 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1067 // If variable scope is not found then skip this variable.
1071 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1072 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1073 RegVar->setFrameIndex(VP.first);
1074 if (!addCurrentFnArgument(MF, RegVar, Scope))
1075 addScopeVariable(Scope, RegVar);
1077 AbsDbgVariable->setFrameIndex(VP.first);
1081 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1083 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1084 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1085 return MI->getNumOperands() == 3 &&
1086 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1087 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1090 // Get .debug_loc entry for the instruction range starting at MI.
1091 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1092 const MCSymbol *FLabel,
1093 const MCSymbol *SLabel,
1094 const MachineInstr *MI) {
1095 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1097 if (MI->getNumOperands() != 3) {
1098 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1099 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1101 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1102 MachineLocation MLoc;
1103 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1104 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1106 if (MI->getOperand(0).isImm())
1107 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1108 if (MI->getOperand(0).isFPImm())
1109 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1110 if (MI->getOperand(0).isCImm())
1111 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1113 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1116 // Find variables for each lexical scope.
1118 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1119 SmallPtrSet<const MDNode *, 16> &Processed) {
1121 // collection info from MMI table.
1122 collectVariableInfoFromMMITable(MF, Processed);
1124 for (SmallVectorImpl<const MDNode*>::const_iterator
1125 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1127 const MDNode *Var = *UVI;
1128 if (Processed.count(Var))
1131 // History contains relevant DBG_VALUE instructions for Var and instructions
1133 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1134 if (History.empty())
1136 const MachineInstr *MInsn = History.front();
1139 LexicalScope *Scope = NULL;
1140 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1141 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1142 Scope = LScopes.getCurrentFunctionScope();
1144 if (DV.getVersion() <= LLVMDebugVersion9)
1145 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1147 if (MDNode *IA = DV.getInlinedAt())
1148 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1150 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1153 // If variable scope is not found then skip this variable.
1157 Processed.insert(DV);
1158 assert(MInsn->isDebugValue() && "History must begin with debug value");
1159 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1160 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1161 if (!addCurrentFnArgument(MF, RegVar, Scope))
1162 addScopeVariable(Scope, RegVar);
1164 AbsVar->setMInsn(MInsn);
1166 // Simplify ranges that are fully coalesced.
1167 if (History.size() <= 1 || (History.size() == 2 &&
1168 MInsn->isIdenticalTo(History.back()))) {
1169 RegVar->setMInsn(MInsn);
1173 // handle multiple DBG_VALUE instructions describing one variable.
1174 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1176 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1177 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1178 const MachineInstr *Begin = *HI;
1179 assert(Begin->isDebugValue() && "Invalid History entry");
1181 // Check if DBG_VALUE is truncating a range.
1182 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1183 && !Begin->getOperand(0).getReg())
1186 // Compute the range for a register location.
1187 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1188 const MCSymbol *SLabel = 0;
1191 // If Begin is the last instruction in History then its value is valid
1192 // until the end of the function.
1193 SLabel = FunctionEndSym;
1195 const MachineInstr *End = HI[1];
1196 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1197 << "\t" << *Begin << "\t" << *End << "\n");
1198 if (End->isDebugValue())
1199 SLabel = getLabelBeforeInsn(End);
1201 // End is a normal instruction clobbering the range.
1202 SLabel = getLabelAfterInsn(End);
1203 assert(SLabel && "Forgot label after clobber instruction");
1208 // The value is valid until the next DBG_VALUE or clobber.
1209 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1212 DotDebugLocEntries.push_back(DotDebugLocEntry());
1215 // Collect info for variables that were optimized out.
1216 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1217 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1218 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1219 DIVariable DV(Variables.getElement(i));
1220 if (!DV || !DV.Verify() || !Processed.insert(DV))
1222 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1223 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1227 // Return Label preceding the instruction.
1228 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1229 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1230 assert(Label && "Didn't insert label before instruction");
1234 // Return Label immediately following the instruction.
1235 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1236 return LabelsAfterInsn.lookup(MI);
1239 // Process beginning of an instruction.
1240 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1241 // Check if source location changes, but ignore DBG_VALUE locations.
1242 if (!MI->isDebugValue()) {
1243 DebugLoc DL = MI->getDebugLoc();
1244 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1247 if (DL == PrologEndLoc) {
1248 Flags |= DWARF2_FLAG_PROLOGUE_END;
1249 PrologEndLoc = DebugLoc();
1251 if (PrologEndLoc.isUnknown())
1252 Flags |= DWARF2_FLAG_IS_STMT;
1254 if (!DL.isUnknown()) {
1255 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1256 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1258 recordSourceLine(0, 0, 0, 0);
1262 // Insert labels where requested.
1263 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1264 LabelsBeforeInsn.find(MI);
1267 if (I == LabelsBeforeInsn.end())
1270 // Label already assigned.
1275 PrevLabel = MMI->getContext().CreateTempSymbol();
1276 Asm->OutStreamer.EmitLabel(PrevLabel);
1278 I->second = PrevLabel;
1281 // Process end of an instruction.
1282 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1283 // Don't create a new label after DBG_VALUE instructions.
1284 // They don't generate code.
1285 if (!MI->isDebugValue())
1288 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1289 LabelsAfterInsn.find(MI);
1292 if (I == LabelsAfterInsn.end())
1295 // Label already assigned.
1299 // We need a label after this instruction.
1301 PrevLabel = MMI->getContext().CreateTempSymbol();
1302 Asm->OutStreamer.EmitLabel(PrevLabel);
1304 I->second = PrevLabel;
1307 // Each LexicalScope has first instruction and last instruction to mark
1308 // beginning and end of a scope respectively. Create an inverse map that list
1309 // scopes starts (and ends) with an instruction. One instruction may start (or
1310 // end) multiple scopes. Ignore scopes that are not reachable.
1311 void DwarfDebug::identifyScopeMarkers() {
1312 SmallVector<LexicalScope *, 4> WorkList;
1313 WorkList.push_back(LScopes.getCurrentFunctionScope());
1314 while (!WorkList.empty()) {
1315 LexicalScope *S = WorkList.pop_back_val();
1317 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1318 if (!Children.empty())
1319 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1320 SE = Children.end(); SI != SE; ++SI)
1321 WorkList.push_back(*SI);
1323 if (S->isAbstractScope())
1326 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1329 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1330 RE = Ranges.end(); RI != RE; ++RI) {
1331 assert(RI->first && "InsnRange does not have first instruction!");
1332 assert(RI->second && "InsnRange does not have second instruction!");
1333 requestLabelBeforeInsn(RI->first);
1334 requestLabelAfterInsn(RI->second);
1339 // Get MDNode for DebugLoc's scope.
1340 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1341 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1342 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1343 return DL.getScope(Ctx);
1346 // Walk up the scope chain of given debug loc and find line number info
1347 // for the function.
1348 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1349 const MDNode *Scope = getScopeNode(DL, Ctx);
1350 DISubprogram SP = getDISubprogram(Scope);
1352 // Check for number of operands since the compatibility is
1354 if (SP->getNumOperands() > 19)
1355 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1357 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1363 // Gather pre-function debug information. Assumes being called immediately
1364 // after the function entry point has been emitted.
1365 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1366 if (!MMI->hasDebugInfo()) return;
1367 LScopes.initialize(*MF);
1368 if (LScopes.empty()) return;
1369 identifyScopeMarkers();
1371 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1372 Asm->getFunctionNumber());
1373 // Assumes in correct section after the entry point.
1374 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1376 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1378 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1379 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1380 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1382 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1384 bool AtBlockEntry = true;
1385 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1387 const MachineInstr *MI = II;
1389 if (MI->isDebugValue()) {
1390 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1392 // Keep track of user variables.
1394 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1396 // Variable is in a register, we need to check for clobbers.
1397 if (isDbgValueInDefinedReg(MI))
1398 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1400 // Check the history of this variable.
1401 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1402 if (History.empty()) {
1403 UserVariables.push_back(Var);
1404 // The first mention of a function argument gets the FunctionBeginSym
1405 // label, so arguments are visible when breaking at function entry.
1407 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1408 DISubprogram(getDISubprogram(DV.getContext()))
1409 .describes(MF->getFunction()))
1410 LabelsBeforeInsn[MI] = FunctionBeginSym;
1412 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1413 const MachineInstr *Prev = History.back();
1414 if (Prev->isDebugValue()) {
1415 // Coalesce identical entries at the end of History.
1416 if (History.size() >= 2 &&
1417 Prev->isIdenticalTo(History[History.size() - 2])) {
1418 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1420 << "\t" << *History[History.size() - 2] << "\n");
1424 // Terminate old register assignments that don't reach MI;
1425 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1426 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1427 isDbgValueInDefinedReg(Prev)) {
1428 // Previous register assignment needs to terminate at the end of
1430 MachineBasicBlock::const_iterator LastMI =
1431 PrevMBB->getLastNonDebugInstr();
1432 if (LastMI == PrevMBB->end()) {
1433 // Drop DBG_VALUE for empty range.
1434 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1435 << "\t" << *Prev << "\n");
1439 // Terminate after LastMI.
1440 History.push_back(LastMI);
1445 History.push_back(MI);
1447 // Not a DBG_VALUE instruction.
1449 AtBlockEntry = false;
1451 // First known non-DBG_VALUE and non-frame setup location marks
1452 // the beginning of the function body.
1453 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1454 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1455 PrologEndLoc = MI->getDebugLoc();
1457 // Check if the instruction clobbers any registers with debug vars.
1458 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1459 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1460 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1462 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1463 AI.isValid(); ++AI) {
1465 const MDNode *Var = LiveUserVar[Reg];
1468 // Reg is now clobbered.
1469 LiveUserVar[Reg] = 0;
1471 // Was MD last defined by a DBG_VALUE referring to Reg?
1472 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1473 if (HistI == DbgValues.end())
1475 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1476 if (History.empty())
1478 const MachineInstr *Prev = History.back();
1479 // Sanity-check: Register assignments are terminated at the end of
1481 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1483 // Is the variable still in Reg?
1484 if (!isDbgValueInDefinedReg(Prev) ||
1485 Prev->getOperand(0).getReg() != Reg)
1487 // Var is clobbered. Make sure the next instruction gets a label.
1488 History.push_back(MI);
1495 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1497 SmallVectorImpl<const MachineInstr*> &History = I->second;
1498 if (History.empty())
1501 // Make sure the final register assignments are terminated.
1502 const MachineInstr *Prev = History.back();
1503 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1504 const MachineBasicBlock *PrevMBB = Prev->getParent();
1505 MachineBasicBlock::const_iterator LastMI =
1506 PrevMBB->getLastNonDebugInstr();
1507 if (LastMI == PrevMBB->end())
1508 // Drop DBG_VALUE for empty range.
1511 // Terminate after LastMI.
1512 History.push_back(LastMI);
1515 // Request labels for the full history.
1516 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1517 const MachineInstr *MI = History[i];
1518 if (MI->isDebugValue())
1519 requestLabelBeforeInsn(MI);
1521 requestLabelAfterInsn(MI);
1525 PrevInstLoc = DebugLoc();
1526 PrevLabel = FunctionBeginSym;
1528 // Record beginning of function.
1529 if (!PrologEndLoc.isUnknown()) {
1530 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1531 MF->getFunction()->getContext());
1532 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1533 FnStartDL.getScope(MF->getFunction()->getContext()),
1534 // We'd like to list the prologue as "not statements" but GDB behaves
1535 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1536 DWARF2_FLAG_IS_STMT);
1540 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1541 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1542 ScopeVariables[LS].push_back(Var);
1543 // Vars.push_back(Var);
1546 // Gather and emit post-function debug information.
1547 void DwarfDebug::endFunction(const MachineFunction *MF) {
1548 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1550 // Define end label for subprogram.
1551 FunctionEndSym = Asm->GetTempSymbol("func_end",
1552 Asm->getFunctionNumber());
1553 // Assumes in correct section after the entry point.
1554 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1556 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1557 collectVariableInfo(MF, ProcessedVars);
1559 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1560 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1561 assert(TheCU && "Unable to find compile unit!");
1563 // Construct abstract scopes.
1564 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1565 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1566 LexicalScope *AScope = AList[i];
1567 DISubprogram SP(AScope->getScopeNode());
1569 // Collect info for variables that were optimized out.
1570 DIArray Variables = SP.getVariables();
1571 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1572 DIVariable DV(Variables.getElement(i));
1573 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1575 // Check that DbgVariable for DV wasn't created earlier, when
1576 // findAbstractVariable() was called for inlined instance of DV.
1577 LLVMContext &Ctx = DV->getContext();
1578 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1579 if (AbstractVariables.lookup(CleanDV))
1581 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1582 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1585 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1586 constructScopeDIE(TheCU, AScope);
1589 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1591 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1592 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1594 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1595 MMI->getFrameMoves()));
1598 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1599 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1600 DeleteContainerPointers(I->second);
1601 ScopeVariables.clear();
1602 DeleteContainerPointers(CurrentFnArguments);
1603 UserVariables.clear();
1605 AbstractVariables.clear();
1606 LabelsBeforeInsn.clear();
1607 LabelsAfterInsn.clear();
1611 // Register a source line with debug info. Returns the unique label that was
1612 // emitted and which provides correspondence to the source line list.
1613 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1619 DIDescriptor Scope(S);
1621 if (Scope.isCompileUnit()) {
1622 DICompileUnit CU(S);
1623 Fn = CU.getFilename();
1624 Dir = CU.getDirectory();
1625 } else if (Scope.isFile()) {
1627 Fn = F.getFilename();
1628 Dir = F.getDirectory();
1629 } else if (Scope.isSubprogram()) {
1631 Fn = SP.getFilename();
1632 Dir = SP.getDirectory();
1633 } else if (Scope.isLexicalBlockFile()) {
1634 DILexicalBlockFile DBF(S);
1635 Fn = DBF.getFilename();
1636 Dir = DBF.getDirectory();
1637 } else if (Scope.isLexicalBlock()) {
1638 DILexicalBlock DB(S);
1639 Fn = DB.getFilename();
1640 Dir = DB.getDirectory();
1642 llvm_unreachable("Unexpected scope info");
1644 Src = getOrCreateSourceID(Fn, Dir);
1646 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1649 //===----------------------------------------------------------------------===//
1651 //===----------------------------------------------------------------------===//
1653 // Compute the size and offset of a DIE.
1655 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1656 // Get the children.
1657 const std::vector<DIE *> &Children = Die->getChildren();
1659 // Record the abbreviation.
1660 assignAbbrevNumber(Die->getAbbrev());
1662 // Get the abbreviation for this DIE.
1663 unsigned AbbrevNumber = Die->getAbbrevNumber();
1664 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1667 Die->setOffset(Offset);
1669 // Start the size with the size of abbreviation code.
1670 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1672 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1673 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1675 // Size the DIE attribute values.
1676 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1677 // Size attribute value.
1678 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1680 // Size the DIE children if any.
1681 if (!Children.empty()) {
1682 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1683 "Children flag not set");
1685 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1686 Offset = computeSizeAndOffset(Children[j], Offset);
1688 // End of children marker.
1689 Offset += sizeof(int8_t);
1692 Die->setSize(Offset - Die->getOffset());
1696 // Compute the size and offset of all the DIEs.
1697 void DwarfUnits::computeSizeAndOffsets() {
1698 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1699 E = CUs.end(); I != E; ++I) {
1701 sizeof(int32_t) + // Length of Compilation Unit Info
1702 sizeof(int16_t) + // DWARF version number
1703 sizeof(int32_t) + // Offset Into Abbrev. Section
1704 sizeof(int8_t); // Pointer Size (in bytes)
1706 computeSizeAndOffset((*I)->getCUDie(), Offset);
1710 // Emit initial Dwarf sections with a label at the start of each one.
1711 void DwarfDebug::emitSectionLabels() {
1712 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1714 // Dwarf sections base addresses.
1715 DwarfInfoSectionSym =
1716 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1717 DwarfAbbrevSectionSym =
1718 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1719 if (useSplitDwarf())
1720 DwarfAbbrevDWOSectionSym =
1721 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1722 "section_abbrev_dwo");
1723 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1725 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1726 emitSectionSym(Asm, MacroInfo);
1728 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1729 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1730 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1731 DwarfStrSectionSym =
1732 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1733 if (useSplitDwarf())
1734 DwarfStrDWOSectionSym =
1735 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1736 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1739 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1740 "section_debug_loc");
1742 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1743 emitSectionSym(Asm, TLOF.getDataSection());
1746 // Recursively emits a debug information entry.
1747 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1748 // Get the abbreviation for this DIE.
1749 unsigned AbbrevNumber = Die->getAbbrevNumber();
1750 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1752 // Emit the code (index) for the abbreviation.
1753 if (Asm->isVerbose())
1754 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1755 Twine::utohexstr(Die->getOffset()) + ":0x" +
1756 Twine::utohexstr(Die->getSize()) + " " +
1757 dwarf::TagString(Abbrev->getTag()));
1758 Asm->EmitULEB128(AbbrevNumber);
1760 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1761 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1763 // Emit the DIE attribute values.
1764 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1765 unsigned Attr = AbbrevData[i].getAttribute();
1766 unsigned Form = AbbrevData[i].getForm();
1767 assert(Form && "Too many attributes for DIE (check abbreviation)");
1769 if (Asm->isVerbose())
1770 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1773 case dwarf::DW_AT_abstract_origin: {
1774 DIEEntry *E = cast<DIEEntry>(Values[i]);
1775 DIE *Origin = E->getEntry();
1776 unsigned Addr = Origin->getOffset();
1777 Asm->EmitInt32(Addr);
1780 case dwarf::DW_AT_ranges: {
1781 // DW_AT_range Value encodes offset in debug_range section.
1782 DIEInteger *V = cast<DIEInteger>(Values[i]);
1784 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1785 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1789 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1791 DwarfDebugRangeSectionSym,
1796 case dwarf::DW_AT_location: {
1797 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1798 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1799 Asm->EmitLabelReference(L->getValue(), 4);
1801 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1803 Values[i]->EmitValue(Asm, Form);
1807 case dwarf::DW_AT_accessibility: {
1808 if (Asm->isVerbose()) {
1809 DIEInteger *V = cast<DIEInteger>(Values[i]);
1810 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1812 Values[i]->EmitValue(Asm, Form);
1816 // Emit an attribute using the defined form.
1817 Values[i]->EmitValue(Asm, Form);
1822 // Emit the DIE children if any.
1823 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1824 const std::vector<DIE *> &Children = Die->getChildren();
1826 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1827 emitDIE(Children[j], Abbrevs);
1829 if (Asm->isVerbose())
1830 Asm->OutStreamer.AddComment("End Of Children Mark");
1835 // Emit the various dwarf units to the unit section USection with
1836 // the abbreviations going into ASection.
1837 void DwarfUnits::emitUnits(DwarfDebug *DD,
1838 const MCSection *USection,
1839 const MCSection *ASection,
1840 const MCSymbol *ASectionSym) {
1841 Asm->OutStreamer.SwitchSection(USection);
1842 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1843 E = CUs.end(); I != E; ++I) {
1844 CompileUnit *TheCU = *I;
1845 DIE *Die = TheCU->getCUDie();
1847 // Emit the compile units header.
1849 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1850 TheCU->getUniqueID()));
1852 // Emit size of content not including length itself
1853 unsigned ContentSize = Die->getSize() +
1854 sizeof(int16_t) + // DWARF version number
1855 sizeof(int32_t) + // Offset Into Abbrev. Section
1856 sizeof(int8_t); // Pointer Size (in bytes)
1858 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1859 Asm->EmitInt32(ContentSize);
1860 Asm->OutStreamer.AddComment("DWARF version number");
1861 Asm->EmitInt16(dwarf::DWARF_VERSION);
1862 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1863 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1865 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1866 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1868 DD->emitDIE(Die, Abbreviations);
1869 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1870 TheCU->getUniqueID()));
1874 // Emit the debug info section.
1875 void DwarfDebug::emitDebugInfo() {
1876 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1878 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
1879 Asm->getObjFileLowering().getDwarfAbbrevSection(),
1880 DwarfAbbrevSectionSym);
1883 // Emit the abbreviation section.
1884 void DwarfDebug::emitAbbreviations() {
1885 if (!useSplitDwarf())
1886 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
1889 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1892 void DwarfDebug::emitAbbrevs(const MCSection *Section,
1893 std::vector<DIEAbbrev *> *Abbrevs) {
1894 // Check to see if it is worth the effort.
1895 if (!Abbrevs->empty()) {
1896 // Start the debug abbrev section.
1897 Asm->OutStreamer.SwitchSection(Section);
1899 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
1900 Asm->OutStreamer.EmitLabel(Begin);
1902 // For each abbrevation.
1903 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
1904 // Get abbreviation data
1905 const DIEAbbrev *Abbrev = Abbrevs->at(i);
1907 // Emit the abbrevations code (base 1 index.)
1908 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1910 // Emit the abbreviations data.
1914 // Mark end of abbreviations.
1915 Asm->EmitULEB128(0, "EOM(3)");
1917 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
1918 Asm->OutStreamer.EmitLabel(End);
1922 // Emit the last address of the section and the end of the line matrix.
1923 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1924 // Define last address of section.
1925 Asm->OutStreamer.AddComment("Extended Op");
1928 Asm->OutStreamer.AddComment("Op size");
1929 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1930 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1931 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1933 Asm->OutStreamer.AddComment("Section end label");
1935 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1936 Asm->getDataLayout().getPointerSize(),
1939 // Mark end of matrix.
1940 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1946 // Emit visible names into a hashed accelerator table section.
1947 void DwarfDebug::emitAccelNames() {
1948 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1949 dwarf::DW_FORM_data4));
1950 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1951 E = CUMap.end(); I != E; ++I) {
1952 CompileUnit *TheCU = I->second;
1953 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1954 for (StringMap<std::vector<DIE*> >::const_iterator
1955 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1956 const char *Name = GI->getKeyData();
1957 const std::vector<DIE *> &Entities = GI->second;
1958 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1959 DE = Entities.end(); DI != DE; ++DI)
1960 AT.AddName(Name, (*DI));
1964 AT.FinalizeTable(Asm, "Names");
1965 Asm->OutStreamer.SwitchSection(
1966 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1967 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1968 Asm->OutStreamer.EmitLabel(SectionBegin);
1970 // Emit the full data.
1971 AT.Emit(Asm, SectionBegin, &InfoHolder);
1974 // Emit objective C classes and categories into a hashed accelerator table
1976 void DwarfDebug::emitAccelObjC() {
1977 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1978 dwarf::DW_FORM_data4));
1979 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1980 E = CUMap.end(); I != E; ++I) {
1981 CompileUnit *TheCU = I->second;
1982 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1983 for (StringMap<std::vector<DIE*> >::const_iterator
1984 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1985 const char *Name = GI->getKeyData();
1986 const std::vector<DIE *> &Entities = GI->second;
1987 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1988 DE = Entities.end(); DI != DE; ++DI)
1989 AT.AddName(Name, (*DI));
1993 AT.FinalizeTable(Asm, "ObjC");
1994 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1995 .getDwarfAccelObjCSection());
1996 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1997 Asm->OutStreamer.EmitLabel(SectionBegin);
1999 // Emit the full data.
2000 AT.Emit(Asm, SectionBegin, &InfoHolder);
2003 // Emit namespace dies into a hashed accelerator table.
2004 void DwarfDebug::emitAccelNamespaces() {
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->getAccelNamespace();
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));
2021 AT.FinalizeTable(Asm, "namespac");
2022 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2023 .getDwarfAccelNamespaceSection());
2024 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2025 Asm->OutStreamer.EmitLabel(SectionBegin);
2027 // Emit the full data.
2028 AT.Emit(Asm, SectionBegin, &InfoHolder);
2031 // Emit type dies into a hashed accelerator table.
2032 void DwarfDebug::emitAccelTypes() {
2033 std::vector<DwarfAccelTable::Atom> Atoms;
2034 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2035 dwarf::DW_FORM_data4));
2036 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2037 dwarf::DW_FORM_data2));
2038 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2039 dwarf::DW_FORM_data1));
2040 DwarfAccelTable AT(Atoms);
2041 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2042 E = CUMap.end(); I != E; ++I) {
2043 CompileUnit *TheCU = I->second;
2044 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2045 = TheCU->getAccelTypes();
2046 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2047 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2048 const char *Name = GI->getKeyData();
2049 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2050 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2051 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2052 AT.AddName(Name, (*DI).first, (*DI).second);
2056 AT.FinalizeTable(Asm, "types");
2057 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2058 .getDwarfAccelTypesSection());
2059 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2060 Asm->OutStreamer.EmitLabel(SectionBegin);
2062 // Emit the full data.
2063 AT.Emit(Asm, SectionBegin, &InfoHolder);
2066 void DwarfDebug::emitDebugPubTypes() {
2067 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2068 E = CUMap.end(); I != E; ++I) {
2069 CompileUnit *TheCU = I->second;
2070 // Start the dwarf pubtypes section.
2071 Asm->OutStreamer.SwitchSection(
2072 Asm->getObjFileLowering().getDwarfPubTypesSection());
2073 Asm->OutStreamer.AddComment("Length of Public Types Info");
2074 Asm->EmitLabelDifference(
2075 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2076 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2078 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2079 TheCU->getUniqueID()));
2081 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2082 Asm->EmitInt16(dwarf::DWARF_VERSION);
2084 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2085 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2086 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2087 TheCU->getUniqueID()),
2088 DwarfInfoSectionSym);
2090 Asm->OutStreamer.AddComment("Compilation Unit Length");
2091 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2092 TheCU->getUniqueID()),
2093 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2094 TheCU->getUniqueID()),
2097 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2098 for (StringMap<DIE*>::const_iterator
2099 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2100 const char *Name = GI->getKeyData();
2101 DIE *Entity = GI->second;
2103 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2104 Asm->EmitInt32(Entity->getOffset());
2106 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2107 // Emit the name with a terminating null byte.
2108 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2111 Asm->OutStreamer.AddComment("End Mark");
2113 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2114 TheCU->getUniqueID()));
2118 // Emit strings into a string section.
2119 void DwarfUnits::emitStrings(const MCSection *Section) {
2121 if (StringPool->empty()) return;
2123 // Start the dwarf str section.
2124 Asm->OutStreamer.SwitchSection(Section);
2126 // Get all of the string pool entries and put them in an array by their ID so
2127 // we can sort them.
2128 SmallVector<std::pair<unsigned,
2129 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2131 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2132 I = StringPool->begin(), E = StringPool->end();
2134 Entries.push_back(std::make_pair(I->second.second, &*I));
2136 array_pod_sort(Entries.begin(), Entries.end());
2138 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2139 // Emit a label for reference from debug information entries.
2140 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2142 // Emit the string itself with a terminating null byte.
2143 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2144 Entries[i].second->getKeyLength()+1),
2149 // Emit visible names into a debug str section.
2150 void DwarfDebug::emitDebugStr() {
2151 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2152 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2155 // Emit visible names into a debug loc section.
2156 void DwarfDebug::emitDebugLoc() {
2157 if (DotDebugLocEntries.empty())
2160 for (SmallVector<DotDebugLocEntry, 4>::iterator
2161 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2163 DotDebugLocEntry &Entry = *I;
2164 if (I + 1 != DotDebugLocEntries.end())
2168 // Start the dwarf loc section.
2169 Asm->OutStreamer.SwitchSection(
2170 Asm->getObjFileLowering().getDwarfLocSection());
2171 unsigned char Size = Asm->getDataLayout().getPointerSize();
2172 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2174 for (SmallVector<DotDebugLocEntry, 4>::iterator
2175 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2176 I != E; ++I, ++index) {
2177 DotDebugLocEntry &Entry = *I;
2178 if (Entry.isMerged()) continue;
2179 if (Entry.isEmpty()) {
2180 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2181 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2182 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2184 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2185 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2186 DIVariable DV(Entry.Variable);
2187 Asm->OutStreamer.AddComment("Loc expr size");
2188 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2189 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2190 Asm->EmitLabelDifference(end, begin, 2);
2191 Asm->OutStreamer.EmitLabel(begin);
2192 if (Entry.isInt()) {
2193 DIBasicType BTy(DV.getType());
2195 (BTy.getEncoding() == dwarf::DW_ATE_signed
2196 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2197 Asm->OutStreamer.AddComment("DW_OP_consts");
2198 Asm->EmitInt8(dwarf::DW_OP_consts);
2199 Asm->EmitSLEB128(Entry.getInt());
2201 Asm->OutStreamer.AddComment("DW_OP_constu");
2202 Asm->EmitInt8(dwarf::DW_OP_constu);
2203 Asm->EmitULEB128(Entry.getInt());
2205 } else if (Entry.isLocation()) {
2206 if (!DV.hasComplexAddress())
2208 Asm->EmitDwarfRegOp(Entry.Loc);
2210 // Complex address entry.
2211 unsigned N = DV.getNumAddrElements();
2213 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2214 if (Entry.Loc.getOffset()) {
2216 Asm->EmitDwarfRegOp(Entry.Loc);
2217 Asm->OutStreamer.AddComment("DW_OP_deref");
2218 Asm->EmitInt8(dwarf::DW_OP_deref);
2219 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2220 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2221 Asm->EmitSLEB128(DV.getAddrElement(1));
2223 // If first address element is OpPlus then emit
2224 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2225 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2226 Asm->EmitDwarfRegOp(Loc);
2230 Asm->EmitDwarfRegOp(Entry.Loc);
2233 // Emit remaining complex address elements.
2234 for (; i < N; ++i) {
2235 uint64_t Element = DV.getAddrElement(i);
2236 if (Element == DIBuilder::OpPlus) {
2237 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2238 Asm->EmitULEB128(DV.getAddrElement(++i));
2239 } else if (Element == DIBuilder::OpDeref) {
2240 if (!Entry.Loc.isReg())
2241 Asm->EmitInt8(dwarf::DW_OP_deref);
2243 llvm_unreachable("unknown Opcode found in complex address");
2247 // else ... ignore constant fp. There is not any good way to
2248 // to represent them here in dwarf.
2249 Asm->OutStreamer.EmitLabel(end);
2254 // Emit visible names into a debug aranges section.
2255 void DwarfDebug::emitDebugARanges() {
2256 // Start the dwarf aranges section.
2257 Asm->OutStreamer.SwitchSection(
2258 Asm->getObjFileLowering().getDwarfARangesSection());
2261 // Emit visible names into a debug ranges section.
2262 void DwarfDebug::emitDebugRanges() {
2263 // Start the dwarf ranges section.
2264 Asm->OutStreamer.SwitchSection(
2265 Asm->getObjFileLowering().getDwarfRangesSection());
2266 unsigned char Size = Asm->getDataLayout().getPointerSize();
2267 for (SmallVector<const MCSymbol *, 8>::iterator
2268 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2271 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2273 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2277 // Emit visible names into a debug macinfo section.
2278 void DwarfDebug::emitDebugMacInfo() {
2279 if (const MCSection *LineInfo =
2280 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2281 // Start the dwarf macinfo section.
2282 Asm->OutStreamer.SwitchSection(LineInfo);
2286 // Emit inline info using following format.
2288 // 1. length of section
2289 // 2. Dwarf version number
2292 // Entries (one "entry" for each function that was inlined):
2294 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2295 // otherwise offset into __debug_str for regular function name.
2296 // 2. offset into __debug_str section for regular function name.
2297 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2298 // instances for the function.
2300 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2301 // inlined instance; the die_offset points to the inlined_subroutine die in the
2302 // __debug_info section, and the low_pc is the starting address for the
2303 // inlining instance.
2304 void DwarfDebug::emitDebugInlineInfo() {
2305 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2311 Asm->OutStreamer.SwitchSection(
2312 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2314 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2315 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2316 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2318 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2320 Asm->OutStreamer.AddComment("Dwarf Version");
2321 Asm->EmitInt16(dwarf::DWARF_VERSION);
2322 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2323 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2325 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2326 E = InlinedSPNodes.end(); I != E; ++I) {
2328 const MDNode *Node = *I;
2329 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2330 = InlineInfo.find(Node);
2331 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2332 DISubprogram SP(Node);
2333 StringRef LName = SP.getLinkageName();
2334 StringRef Name = SP.getName();
2336 Asm->OutStreamer.AddComment("MIPS linkage name");
2338 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2339 DwarfStrSectionSym);
2341 Asm->EmitSectionOffset(InfoHolder
2342 .getStringPoolEntry(getRealLinkageName(LName)),
2343 DwarfStrSectionSym);
2345 Asm->OutStreamer.AddComment("Function name");
2346 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2347 DwarfStrSectionSym);
2348 Asm->EmitULEB128(Labels.size(), "Inline count");
2350 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2351 LE = Labels.end(); LI != LE; ++LI) {
2352 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2353 Asm->EmitInt32(LI->second->getOffset());
2355 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2356 Asm->OutStreamer.EmitSymbolValue(LI->first,
2357 Asm->getDataLayout().getPointerSize(),0);
2361 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2364 // DWARF5 Experimental Separate Dwarf emitters.
2366 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2367 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2368 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2369 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2370 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2371 DICompileUnit DIUnit(N);
2372 StringRef FN = DIUnit.getFilename();
2373 CompilationDir = DIUnit.getDirectory();
2375 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2376 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2377 DIUnit.getLanguage(), Die, Asm,
2378 this, &SkeletonHolder);
2379 // FIXME: This should be the .dwo file.
2380 NewCU->addString(Die, dwarf::DW_AT_GNU_dwo_name, FN);
2382 // FIXME: We also need DW_AT_addr_base and DW_AT_dwo_id.
2384 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2386 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2387 // DW_AT_stmt_list is a offset of line number information for this
2388 // compile unit in debug_line section.
2389 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2390 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
2391 Asm->GetTempSymbol("section_line"));
2393 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
2395 if (!CompilationDir.empty())
2396 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2398 SkeletonHolder.addUnit(NewCU);
2403 void DwarfDebug::emitSkeletonCU(const MCSection *Section) {
2404 Asm->OutStreamer.SwitchSection(Section);
2405 DIE *Die = SkeletonCU->getCUDie();
2407 // Emit the compile units header.
2408 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(Section->getLabelBeginName(),
2409 SkeletonCU->getUniqueID()));
2411 // Emit size of content not including length itself
2412 unsigned ContentSize = Die->getSize() +
2413 sizeof(int16_t) + // DWARF version number
2414 sizeof(int32_t) + // Offset Into Abbrev. Section
2415 sizeof(int8_t); // Pointer Size (in bytes)
2417 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2418 Asm->EmitInt32(ContentSize);
2419 Asm->OutStreamer.AddComment("DWARF version number");
2420 Asm->EmitInt16(dwarf::DWARF_VERSION);
2421 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2423 const MCSection *ASec = Asm->getObjFileLowering().getDwarfAbbrevSection();
2424 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASec->getLabelBeginName()),
2425 DwarfAbbrevSectionSym);
2426 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2427 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2429 emitDIE(Die, &SkeletonAbbrevs);
2430 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(Section->getLabelEndName(),
2431 SkeletonCU->getUniqueID()));
2434 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2435 assert(useSplitDwarf() && "No split dwarf debug info?");
2436 emitAbbrevs(Section, &SkeletonAbbrevs);
2439 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2440 // compile units that would normally be in debug_info.
2441 void DwarfDebug::emitDebugInfoDWO() {
2442 assert(useSplitDwarf() && "No split dwarf debug info?");
2443 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2444 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2445 DwarfAbbrevDWOSectionSym);
2448 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2449 // abbreviations for the .debug_info.dwo section.
2450 void DwarfDebug::emitDebugAbbrevDWO() {
2451 assert(useSplitDwarf() && "No split dwarf?");
2452 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2456 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2457 // string section and is identical in format to traditional .debug_str
2459 void DwarfDebug::emitDebugStrDWO() {
2460 assert(useSplitDwarf() && "No split dwarf?");
2461 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection());