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/Constants.h"
26 #include "llvm/DIBuilder.h"
27 #include "llvm/DataLayout.h"
28 #include "llvm/DebugInfo.h"
29 #include "llvm/Instructions.h"
30 #include "llvm/MC/MCAsmInfo.h"
31 #include "llvm/MC/MCSection.h"
32 #include "llvm/MC/MCStreamer.h"
33 #include "llvm/MC/MCSymbol.h"
34 #include "llvm/Module.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, &InfoStringPool),
162 SkeletonAbbrevSet(InitAbbreviationsSetSize),
163 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, &InfoStringPool) {
165 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
166 DwarfStrSectionSym = TextSectionSym = 0;
167 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
168 DwarfAbbrevDWOSectionSym = 0;
169 FunctionBeginSym = FunctionEndSym = 0;
171 // Turn on accelerator tables and older gdb compatibility
173 bool IsDarwin = Triple(M->getTargetTriple()).isOSDarwin();
174 if (DarwinGDBCompat == Default) {
176 IsDarwinGDBCompat = true;
178 IsDarwinGDBCompat = false;
180 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
182 if (DwarfAccelTables == Default) {
184 HasDwarfAccelTables = true;
186 HasDwarfAccelTables = false;
188 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
190 if (SplitDwarf == Default)
191 HasSplitDwarf = false;
193 HasSplitDwarf = SplitDwarf == Enable ? true : false;
196 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
200 DwarfDebug::~DwarfDebug() {
203 // Switch to the specified MCSection and emit an assembler
204 // temporary label to it if SymbolStem is specified.
205 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
206 const char *SymbolStem = 0) {
207 Asm->OutStreamer.SwitchSection(Section);
208 if (!SymbolStem) return 0;
210 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
211 Asm->OutStreamer.EmitLabel(TmpSym);
215 MCSymbol *DwarfUnits::getStringPoolSym() {
216 return Asm->GetTempSymbol("section_str");
219 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
220 std::pair<MCSymbol*, unsigned> &Entry =
221 StringPool->GetOrCreateValue(Str).getValue();
222 if (Entry.first) return Entry.first;
224 Entry.second = NextStringPoolNumber++;
225 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
228 // Define a unique number for the abbreviation.
230 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
231 // Profile the node so that we can make it unique.
235 // Check the set for priors.
236 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
238 // If it's newly added.
239 if (InSet == &Abbrev) {
240 // Add to abbreviation list.
241 Abbreviations->push_back(&Abbrev);
243 // Assign the vector position + 1 as its number.
244 Abbrev.setNumber(Abbreviations->size());
246 // Assign existing abbreviation number.
247 Abbrev.setNumber(InSet->getNumber());
251 // If special LLVM prefix that is used to inform the asm
252 // printer to not emit usual symbol prefix before the symbol name is used then
253 // return linkage name after skipping this special LLVM prefix.
254 static StringRef getRealLinkageName(StringRef LinkageName) {
256 if (LinkageName.startswith(StringRef(&One, 1)))
257 return LinkageName.substr(1);
261 static bool isObjCClass(StringRef Name) {
262 return Name.startswith("+") || Name.startswith("-");
265 static bool hasObjCCategory(StringRef Name) {
266 if (!isObjCClass(Name)) return false;
268 size_t pos = Name.find(')');
269 if (pos != std::string::npos) {
270 if (Name[pos+1] != ' ') return false;
276 static void getObjCClassCategory(StringRef In, StringRef &Class,
277 StringRef &Category) {
278 if (!hasObjCCategory(In)) {
279 Class = In.slice(In.find('[') + 1, In.find(' '));
284 Class = In.slice(In.find('[') + 1, In.find('('));
285 Category = In.slice(In.find('[') + 1, In.find(' '));
289 static StringRef getObjCMethodName(StringRef In) {
290 return In.slice(In.find(' ') + 1, In.find(']'));
293 // Add the various names to the Dwarf accelerator table names.
294 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
296 if (!SP.isDefinition()) return;
298 TheCU->addAccelName(SP.getName(), Die);
300 // If the linkage name is different than the name, go ahead and output
301 // that as well into the name table.
302 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
303 TheCU->addAccelName(SP.getLinkageName(), Die);
305 // If this is an Objective-C selector name add it to the ObjC accelerator
307 if (isObjCClass(SP.getName())) {
308 StringRef Class, Category;
309 getObjCClassCategory(SP.getName(), Class, Category);
310 TheCU->addAccelObjC(Class, Die);
312 TheCU->addAccelObjC(Category, Die);
313 // Also add the base method name to the name table.
314 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
318 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
319 // and DW_AT_high_pc attributes. If there are global variables in this
320 // scope then create and insert DIEs for these variables.
321 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
322 const MDNode *SPNode) {
323 DIE *SPDie = SPCU->getDIE(SPNode);
325 assert(SPDie && "Unable to find subprogram DIE!");
326 DISubprogram SP(SPNode);
328 // If we're updating an abstract DIE, then we will be adding the children and
329 // object pointer later on. But what we don't want to do is process the
330 // concrete DIE twice.
331 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
332 // Pick up abstract subprogram DIE.
333 SPDie = new DIE(dwarf::DW_TAG_subprogram);
334 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
335 dwarf::DW_FORM_ref4, AbsSPDIE);
338 DISubprogram SPDecl = SP.getFunctionDeclaration();
339 if (!SPDecl.isSubprogram()) {
340 // There is not any need to generate specification DIE for a function
341 // defined at compile unit level. If a function is defined inside another
342 // function then gdb prefers the definition at top level and but does not
343 // expect specification DIE in parent function. So avoid creating
344 // specification DIE for a function defined inside a function.
345 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
346 !SP.getContext().isFile() &&
347 !isSubprogramContext(SP.getContext())) {
348 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
351 DICompositeType SPTy = SP.getType();
352 DIArray Args = SPTy.getTypeArray();
353 unsigned SPTag = SPTy.getTag();
354 if (SPTag == dwarf::DW_TAG_subroutine_type)
355 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
356 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
357 DIType ATy = DIType(Args.getElement(i));
358 SPCU->addType(Arg, ATy);
359 if (ATy.isArtificial())
360 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
361 if (ATy.isObjectPointer())
362 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
363 dwarf::DW_FORM_ref4, Arg);
364 SPDie->addChild(Arg);
366 DIE *SPDeclDie = SPDie;
367 SPDie = new DIE(dwarf::DW_TAG_subprogram);
368 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
369 dwarf::DW_FORM_ref4, SPDeclDie);
375 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
376 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
377 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
378 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
379 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
380 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
381 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
383 // Add name to the name table, we do this here because we're guaranteed
384 // to have concrete versions of our DW_TAG_subprogram nodes.
385 addSubprogramNames(SPCU, SP, SPDie);
390 // Construct new DW_TAG_lexical_block for this scope and attach
391 // DW_AT_low_pc/DW_AT_high_pc labels.
392 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
393 LexicalScope *Scope) {
394 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
395 if (Scope->isAbstractScope())
398 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
402 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
403 if (Ranges.size() > 1) {
404 // .debug_range section has not been laid out yet. Emit offset in
405 // .debug_range as a uint, size 4, for now. emitDIE will handle
406 // DW_AT_ranges appropriately.
407 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
408 DebugRangeSymbols.size()
409 * Asm->getDataLayout().getPointerSize());
410 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
411 RE = Ranges.end(); RI != RE; ++RI) {
412 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
413 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
415 DebugRangeSymbols.push_back(NULL);
416 DebugRangeSymbols.push_back(NULL);
420 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
421 const MCSymbol *End = getLabelAfterInsn(RI->second);
423 if (End == 0) return 0;
425 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
426 assert(End->isDefined() && "Invalid end label for an inlined scope!");
428 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
429 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
434 // This scope represents inlined body of a function. Construct DIE to
435 // represent this concrete inlined copy of the function.
436 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
437 LexicalScope *Scope) {
438 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
439 assert(Ranges.empty() == false &&
440 "LexicalScope does not have instruction markers!");
442 if (!Scope->getScopeNode())
444 DIScope DS(Scope->getScopeNode());
445 DISubprogram InlinedSP = getDISubprogram(DS);
446 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
448 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
452 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
453 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
454 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
456 if (StartLabel == 0 || EndLabel == 0) {
457 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
459 assert(StartLabel->isDefined() &&
460 "Invalid starting label for an inlined scope!");
461 assert(EndLabel->isDefined() &&
462 "Invalid end label for an inlined scope!");
464 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
465 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
466 dwarf::DW_FORM_ref4, OriginDIE);
468 if (Ranges.size() > 1) {
469 // .debug_range section has not been laid out yet. Emit offset in
470 // .debug_range as a uint, size 4, for now. emitDIE will handle
471 // DW_AT_ranges appropriately.
472 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
473 DebugRangeSymbols.size()
474 * Asm->getDataLayout().getPointerSize());
475 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
476 RE = Ranges.end(); RI != RE; ++RI) {
477 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
478 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
480 DebugRangeSymbols.push_back(NULL);
481 DebugRangeSymbols.push_back(NULL);
483 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
485 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
489 InlinedSubprogramDIEs.insert(OriginDIE);
491 // Track the start label for this inlined function.
492 //.debug_inlined section specification does not clearly state how
493 // to emit inlined scope that is split into multiple instruction ranges.
494 // For now, use first instruction range and emit low_pc/high_pc pair and
495 // corresponding .debug_inlined section entry for this pair.
496 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
497 I = InlineInfo.find(InlinedSP);
499 if (I == InlineInfo.end()) {
500 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
501 InlinedSPNodes.push_back(InlinedSP);
503 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
505 DILocation DL(Scope->getInlinedAt());
506 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
507 getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
508 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
510 // Add name to the name table, we do this here because we're guaranteed
511 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
512 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
517 // Construct a DIE for this scope.
518 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
519 if (!Scope || !Scope->getScopeNode())
522 SmallVector<DIE *, 8> Children;
523 DIE *ObjectPointer = NULL;
525 // Collect arguments for current function.
526 if (LScopes.isCurrentFunctionScope(Scope))
527 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
528 if (DbgVariable *ArgDV = CurrentFnArguments[i])
530 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
531 Children.push_back(Arg);
532 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
535 // Collect lexical scope children first.
536 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
537 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
539 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
540 Children.push_back(Variable);
541 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
543 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
544 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
545 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
546 Children.push_back(Nested);
547 DIScope DS(Scope->getScopeNode());
548 DIE *ScopeDIE = NULL;
549 if (Scope->getInlinedAt())
550 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
551 else if (DS.isSubprogram()) {
552 ProcessedSPNodes.insert(DS);
553 if (Scope->isAbstractScope()) {
554 ScopeDIE = TheCU->getDIE(DS);
555 // Note down abstract DIE.
557 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
560 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
563 // There is no need to emit empty lexical block DIE.
564 if (Children.empty())
566 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
569 if (!ScopeDIE) return NULL;
572 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
573 E = Children.end(); I != E; ++I)
574 ScopeDIE->addChild(*I);
576 if (DS.isSubprogram() && ObjectPointer != NULL)
577 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
578 dwarf::DW_FORM_ref4, ObjectPointer);
580 if (DS.isSubprogram())
581 TheCU->addPubTypes(DISubprogram(DS));
586 // Look up the source id with the given directory and source file names.
587 // If none currently exists, create a new id and insert it in the
588 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
590 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
592 // If FE did not provide a file name, then assume stdin.
593 if (FileName.empty())
594 return getOrCreateSourceID("<stdin>", StringRef());
596 // TODO: this might not belong here. See if we can factor this better.
597 if (DirName == CompilationDir)
600 unsigned SrcId = SourceIdMap.size()+1;
602 // We look up the file/dir pair by concatenating them with a zero byte.
603 SmallString<128> NamePair;
605 NamePair += '\0'; // Zero bytes are not allowed in paths.
606 NamePair += FileName;
608 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
609 if (Ent.getValue() != SrcId)
610 return Ent.getValue();
612 // Print out a .file directive to specify files for .loc directives.
613 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
618 // Create new CompileUnit for the given metadata node with tag DW_TAG_compile_unit.
619 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
620 DICompileUnit DIUnit(N);
621 StringRef FN = DIUnit.getFilename();
622 CompilationDir = DIUnit.getDirectory();
623 // Call this to emit a .file directive if it wasn't emitted for the source
624 // file this CU comes from yet.
625 getOrCreateSourceID(FN, CompilationDir);
627 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
628 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
629 DIUnit.getLanguage(), Die, Asm,
631 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
632 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
633 DIUnit.getLanguage());
634 NewCU->addString(Die, dwarf::DW_AT_name, FN);
635 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
637 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
638 // DW_AT_stmt_list is a offset of line number information for this
639 // compile unit in debug_line section.
640 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
641 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
642 Asm->GetTempSymbol("section_line"));
644 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
646 if (!CompilationDir.empty())
647 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
648 if (DIUnit.isOptimized())
649 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
651 StringRef Flags = DIUnit.getFlags();
653 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
655 if (unsigned RVer = DIUnit.getRunTimeVersion())
656 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
657 dwarf::DW_FORM_data1, RVer);
661 if (useSplitDwarf() && !SkeletonCU)
662 SkeletonCU = constructSkeletonCU(N);
664 InfoHolder.addUnit(NewCU);
666 CUMap.insert(std::make_pair(N, NewCU));
670 // Construct subprogram DIE.
671 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
673 CompileUnit *&CURef = SPMap[N];
679 if (!SP.isDefinition())
680 // This is a method declaration which will be handled while constructing
684 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
687 TheCU->insertDIE(N, SubprogramDie);
689 // Add to context owner.
690 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
695 // Collect debug info from named mdnodes such as llvm.dbg.enum and llvm.dbg.ty.
696 void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) {
697 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
698 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
699 const MDNode *N = NMD->getOperand(i);
700 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
701 constructSubprogramDIE(CU, N);
704 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
705 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
706 const MDNode *N = NMD->getOperand(i);
707 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
708 CU->createGlobalVariableDIE(N);
711 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
712 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
713 DIType Ty(NMD->getOperand(i));
714 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
715 CU->getOrCreateTypeDIE(Ty);
718 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
719 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
720 DIType Ty(NMD->getOperand(i));
721 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
722 CU->getOrCreateTypeDIE(Ty);
726 // Collect debug info using DebugInfoFinder.
727 // FIXME - Remove this when dragonegg switches to DIBuilder.
728 bool DwarfDebug::collectLegacyDebugInfo(const Module *M) {
729 DebugInfoFinder DbgFinder;
730 DbgFinder.processModule(*M);
732 bool HasDebugInfo = false;
733 // Scan all the compile-units to see if there are any marked as the main
734 // unit. If not, we do not generate debug info.
735 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
736 E = DbgFinder.compile_unit_end(); I != E; ++I) {
737 if (DICompileUnit(*I).isMain()) {
742 if (!HasDebugInfo) return false;
744 // Create all the compile unit DIEs.
745 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
746 E = DbgFinder.compile_unit_end(); I != E; ++I)
747 constructCompileUnit(*I);
749 // Create DIEs for each global variable.
750 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
751 E = DbgFinder.global_variable_end(); I != E; ++I) {
752 const MDNode *N = *I;
753 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
754 CU->createGlobalVariableDIE(N);
757 // Create DIEs for each subprogram.
758 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
759 E = DbgFinder.subprogram_end(); I != E; ++I) {
760 const MDNode *N = *I;
761 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
762 constructSubprogramDIE(CU, N);
768 // Emit all Dwarf sections that should come prior to the content. Create
769 // global DIEs and emit initial debug info sections. This is invoked by
770 // the target AsmPrinter.
771 void DwarfDebug::beginModule() {
772 if (DisableDebugInfoPrinting)
775 const Module *M = MMI->getModule();
777 // If module has named metadata anchors then use them, otherwise scan the
778 // module using debug info finder to collect debug info.
779 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
781 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
782 DICompileUnit CUNode(CU_Nodes->getOperand(i));
783 CompileUnit *CU = constructCompileUnit(CUNode);
784 DIArray GVs = CUNode.getGlobalVariables();
785 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
786 CU->createGlobalVariableDIE(GVs.getElement(i));
787 DIArray SPs = CUNode.getSubprograms();
788 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
789 constructSubprogramDIE(CU, SPs.getElement(i));
790 DIArray EnumTypes = CUNode.getEnumTypes();
791 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
792 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
793 DIArray RetainedTypes = CUNode.getRetainedTypes();
794 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
795 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
797 } else if (!collectLegacyDebugInfo(M))
800 collectInfoFromNamedMDNodes(M);
802 // Tell MMI that we have debug info.
803 MMI->setDebugInfoAvailability(true);
805 // Prime section data.
806 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
809 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
810 void DwarfDebug::computeInlinedDIEs() {
811 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
812 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
813 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
815 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
817 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
818 AE = AbstractSPDies.end(); AI != AE; ++AI) {
819 DIE *ISP = AI->second;
820 if (InlinedSubprogramDIEs.count(ISP))
822 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
826 // Collect info for variables that were optimized out.
827 void DwarfDebug::collectDeadVariables() {
828 const Module *M = MMI->getModule();
829 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
831 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
832 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
833 DICompileUnit TheCU(CU_Nodes->getOperand(i));
834 DIArray Subprograms = TheCU.getSubprograms();
835 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
836 DISubprogram SP(Subprograms.getElement(i));
837 if (ProcessedSPNodes.count(SP) != 0) continue;
838 if (!SP.Verify()) continue;
839 if (!SP.isDefinition()) continue;
840 DIArray Variables = SP.getVariables();
841 if (Variables.getNumElements() == 0) continue;
843 LexicalScope *Scope =
844 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
845 DeadFnScopeMap[SP] = Scope;
847 // Construct subprogram DIE and add variables DIEs.
848 CompileUnit *SPCU = CUMap.lookup(TheCU);
849 assert(SPCU && "Unable to find Compile Unit!");
850 constructSubprogramDIE(SPCU, SP);
851 DIE *ScopeDIE = SPCU->getDIE(SP);
852 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
853 DIVariable DV(Variables.getElement(vi));
854 if (!DV.Verify()) continue;
855 DbgVariable *NewVar = new DbgVariable(DV, NULL);
856 if (DIE *VariableDIE =
857 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
858 ScopeDIE->addChild(VariableDIE);
863 DeleteContainerSeconds(DeadFnScopeMap);
866 void DwarfDebug::finalizeModuleInfo() {
867 // Collect info for variables that were optimized out.
868 collectDeadVariables();
870 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
871 computeInlinedDIEs();
873 // Emit DW_AT_containing_type attribute to connect types with their
874 // vtable holding type.
875 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
876 CUE = CUMap.end(); CUI != CUE; ++CUI) {
877 CompileUnit *TheCU = CUI->second;
878 TheCU->constructContainingTypeDIEs();
881 // Compute DIE offsets and sizes.
882 InfoHolder.computeSizeAndOffsets();
884 SkeletonHolder.computeSizeAndOffsets();
887 void DwarfDebug::endSections() {
888 // Standard sections final addresses.
889 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
890 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
891 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
892 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
894 // End text sections.
895 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
896 Asm->OutStreamer.SwitchSection(SectionMap[I]);
897 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
901 // Emit all Dwarf sections that should come after the content.
902 void DwarfDebug::endModule() {
904 if (!FirstCU) return;
906 // End any existing sections.
907 // TODO: Does this need to happen?
910 // Finalize the debug info for the module.
911 finalizeModuleInfo();
913 // Emit initial sections.
916 if (!useSplitDwarf()) {
917 // Emit all the DIEs into a debug info section.
920 // Corresponding abbreviations into a abbrev section.
923 // Emit info into a debug loc section.
926 // Emit info into a debug aranges section.
929 // Emit info into a debug ranges section.
932 // Emit info into a debug macinfo section.
936 // TODO: When we don't need the option anymore we
937 // can remove all of the code that this section
939 if (useDarwinGDBCompat())
940 emitDebugInlineInfo();
942 // TODO: Fill this in for separated debug sections and separate
943 // out information into new sections.
945 // Emit the debug info section and compile units.
949 // Corresponding abbreviations into a abbrev section.
951 emitDebugAbbrevDWO();
953 // Emit info into a debug loc section.
956 // Emit info into a debug aranges section.
959 // Emit info into a debug ranges section.
962 // Emit info into a debug macinfo section.
966 // TODO: When we don't need the option anymore we
967 // can remove all of the code that this section
969 if (useDarwinGDBCompat())
970 emitDebugInlineInfo();
973 // Emit info into the dwarf accelerator table sections.
974 if (useDwarfAccelTables()) {
977 emitAccelNamespaces();
981 // Emit info into a debug pubtypes section.
982 // TODO: When we don't need the option anymore we can
983 // remove all of the code that adds to the table.
984 if (useDarwinGDBCompat())
987 // Finally emit string information into a string table.
992 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
993 E = CUMap.end(); I != E; ++I)
998 // Reset these for the next Module if we have one.
1003 // Find abstract variable, if any, associated with Var.
1004 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1005 DebugLoc ScopeLoc) {
1006 LLVMContext &Ctx = DV->getContext();
1007 // More then one inlined variable corresponds to one abstract variable.
1008 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1009 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1011 return AbsDbgVariable;
1013 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1017 AbsDbgVariable = new DbgVariable(Var, NULL);
1018 addScopeVariable(Scope, AbsDbgVariable);
1019 AbstractVariables[Var] = AbsDbgVariable;
1020 return AbsDbgVariable;
1023 // If Var is a current function argument then add it to CurrentFnArguments list.
1024 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1025 DbgVariable *Var, LexicalScope *Scope) {
1026 if (!LScopes.isCurrentFunctionScope(Scope))
1028 DIVariable DV = Var->getVariable();
1029 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1031 unsigned ArgNo = DV.getArgNumber();
1035 size_t Size = CurrentFnArguments.size();
1037 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1038 // llvm::Function argument size is not good indicator of how many
1039 // arguments does the function have at source level.
1041 CurrentFnArguments.resize(ArgNo * 2);
1042 CurrentFnArguments[ArgNo - 1] = Var;
1046 // Collect variable information from side table maintained by MMI.
1048 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1049 SmallPtrSet<const MDNode *, 16> &Processed) {
1050 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1051 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1052 VE = VMap.end(); VI != VE; ++VI) {
1053 const MDNode *Var = VI->first;
1055 Processed.insert(Var);
1057 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1059 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1061 // If variable scope is not found then skip this variable.
1065 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1066 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1067 RegVar->setFrameIndex(VP.first);
1068 if (!addCurrentFnArgument(MF, RegVar, Scope))
1069 addScopeVariable(Scope, RegVar);
1071 AbsDbgVariable->setFrameIndex(VP.first);
1075 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1077 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1078 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1079 return MI->getNumOperands() == 3 &&
1080 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1081 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1084 // Get .debug_loc entry for the instruction range starting at MI.
1085 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1086 const MCSymbol *FLabel,
1087 const MCSymbol *SLabel,
1088 const MachineInstr *MI) {
1089 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1091 if (MI->getNumOperands() != 3) {
1092 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1093 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1095 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1096 MachineLocation MLoc;
1097 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1098 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1100 if (MI->getOperand(0).isImm())
1101 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1102 if (MI->getOperand(0).isFPImm())
1103 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1104 if (MI->getOperand(0).isCImm())
1105 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1107 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1110 // Find variables for each lexical scope.
1112 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1113 SmallPtrSet<const MDNode *, 16> &Processed) {
1115 // collection info from MMI table.
1116 collectVariableInfoFromMMITable(MF, Processed);
1118 for (SmallVectorImpl<const MDNode*>::const_iterator
1119 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1121 const MDNode *Var = *UVI;
1122 if (Processed.count(Var))
1125 // History contains relevant DBG_VALUE instructions for Var and instructions
1127 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1128 if (History.empty())
1130 const MachineInstr *MInsn = History.front();
1133 LexicalScope *Scope = NULL;
1134 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1135 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1136 Scope = LScopes.getCurrentFunctionScope();
1138 if (DV.getVersion() <= LLVMDebugVersion9)
1139 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1141 if (MDNode *IA = DV.getInlinedAt())
1142 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1144 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1147 // If variable scope is not found then skip this variable.
1151 Processed.insert(DV);
1152 assert(MInsn->isDebugValue() && "History must begin with debug value");
1153 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1154 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1155 if (!addCurrentFnArgument(MF, RegVar, Scope))
1156 addScopeVariable(Scope, RegVar);
1158 AbsVar->setMInsn(MInsn);
1160 // Simplify ranges that are fully coalesced.
1161 if (History.size() <= 1 || (History.size() == 2 &&
1162 MInsn->isIdenticalTo(History.back()))) {
1163 RegVar->setMInsn(MInsn);
1167 // handle multiple DBG_VALUE instructions describing one variable.
1168 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1170 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1171 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1172 const MachineInstr *Begin = *HI;
1173 assert(Begin->isDebugValue() && "Invalid History entry");
1175 // Check if DBG_VALUE is truncating a range.
1176 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1177 && !Begin->getOperand(0).getReg())
1180 // Compute the range for a register location.
1181 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1182 const MCSymbol *SLabel = 0;
1185 // If Begin is the last instruction in History then its value is valid
1186 // until the end of the function.
1187 SLabel = FunctionEndSym;
1189 const MachineInstr *End = HI[1];
1190 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1191 << "\t" << *Begin << "\t" << *End << "\n");
1192 if (End->isDebugValue())
1193 SLabel = getLabelBeforeInsn(End);
1195 // End is a normal instruction clobbering the range.
1196 SLabel = getLabelAfterInsn(End);
1197 assert(SLabel && "Forgot label after clobber instruction");
1202 // The value is valid until the next DBG_VALUE or clobber.
1203 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1206 DotDebugLocEntries.push_back(DotDebugLocEntry());
1209 // Collect info for variables that were optimized out.
1210 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1211 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1212 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1213 DIVariable DV(Variables.getElement(i));
1214 if (!DV || !DV.Verify() || !Processed.insert(DV))
1216 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1217 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1221 // Return Label preceding the instruction.
1222 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1223 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1224 assert(Label && "Didn't insert label before instruction");
1228 // Return Label immediately following the instruction.
1229 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1230 return LabelsAfterInsn.lookup(MI);
1233 // Process beginning of an instruction.
1234 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1235 // Check if source location changes, but ignore DBG_VALUE locations.
1236 if (!MI->isDebugValue()) {
1237 DebugLoc DL = MI->getDebugLoc();
1238 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1241 if (DL == PrologEndLoc) {
1242 Flags |= DWARF2_FLAG_PROLOGUE_END;
1243 PrologEndLoc = DebugLoc();
1245 if (PrologEndLoc.isUnknown())
1246 Flags |= DWARF2_FLAG_IS_STMT;
1248 if (!DL.isUnknown()) {
1249 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1250 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1252 recordSourceLine(0, 0, 0, 0);
1256 // Insert labels where requested.
1257 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1258 LabelsBeforeInsn.find(MI);
1261 if (I == LabelsBeforeInsn.end())
1264 // Label already assigned.
1269 PrevLabel = MMI->getContext().CreateTempSymbol();
1270 Asm->OutStreamer.EmitLabel(PrevLabel);
1272 I->second = PrevLabel;
1275 // Process end of an instruction.
1276 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1277 // Don't create a new label after DBG_VALUE instructions.
1278 // They don't generate code.
1279 if (!MI->isDebugValue())
1282 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1283 LabelsAfterInsn.find(MI);
1286 if (I == LabelsAfterInsn.end())
1289 // Label already assigned.
1293 // We need a label after this instruction.
1295 PrevLabel = MMI->getContext().CreateTempSymbol();
1296 Asm->OutStreamer.EmitLabel(PrevLabel);
1298 I->second = PrevLabel;
1301 // Each LexicalScope has first instruction and last instruction to mark
1302 // beginning and end of a scope respectively. Create an inverse map that list
1303 // scopes starts (and ends) with an instruction. One instruction may start (or
1304 // end) multiple scopes. Ignore scopes that are not reachable.
1305 void DwarfDebug::identifyScopeMarkers() {
1306 SmallVector<LexicalScope *, 4> WorkList;
1307 WorkList.push_back(LScopes.getCurrentFunctionScope());
1308 while (!WorkList.empty()) {
1309 LexicalScope *S = WorkList.pop_back_val();
1311 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1312 if (!Children.empty())
1313 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1314 SE = Children.end(); SI != SE; ++SI)
1315 WorkList.push_back(*SI);
1317 if (S->isAbstractScope())
1320 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1323 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1324 RE = Ranges.end(); RI != RE; ++RI) {
1325 assert(RI->first && "InsnRange does not have first instruction!");
1326 assert(RI->second && "InsnRange does not have second instruction!");
1327 requestLabelBeforeInsn(RI->first);
1328 requestLabelAfterInsn(RI->second);
1333 // Get MDNode for DebugLoc's scope.
1334 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1335 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1336 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1337 return DL.getScope(Ctx);
1340 // Walk up the scope chain of given debug loc and find line number info
1341 // for the function.
1342 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1343 const MDNode *Scope = getScopeNode(DL, Ctx);
1344 DISubprogram SP = getDISubprogram(Scope);
1346 // Check for number of operands since the compatibility is
1348 if (SP->getNumOperands() > 19)
1349 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1351 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1357 // Gather pre-function debug information. Assumes being called immediately
1358 // after the function entry point has been emitted.
1359 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1360 if (!MMI->hasDebugInfo()) return;
1361 LScopes.initialize(*MF);
1362 if (LScopes.empty()) return;
1363 identifyScopeMarkers();
1365 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1366 Asm->getFunctionNumber());
1367 // Assumes in correct section after the entry point.
1368 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1370 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1372 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1373 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1374 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1376 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1378 bool AtBlockEntry = true;
1379 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1381 const MachineInstr *MI = II;
1383 if (MI->isDebugValue()) {
1384 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1386 // Keep track of user variables.
1388 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1390 // Variable is in a register, we need to check for clobbers.
1391 if (isDbgValueInDefinedReg(MI))
1392 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1394 // Check the history of this variable.
1395 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1396 if (History.empty()) {
1397 UserVariables.push_back(Var);
1398 // The first mention of a function argument gets the FunctionBeginSym
1399 // label, so arguments are visible when breaking at function entry.
1401 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1402 DISubprogram(getDISubprogram(DV.getContext()))
1403 .describes(MF->getFunction()))
1404 LabelsBeforeInsn[MI] = FunctionBeginSym;
1406 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1407 const MachineInstr *Prev = History.back();
1408 if (Prev->isDebugValue()) {
1409 // Coalesce identical entries at the end of History.
1410 if (History.size() >= 2 &&
1411 Prev->isIdenticalTo(History[History.size() - 2])) {
1412 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1414 << "\t" << *History[History.size() - 2] << "\n");
1418 // Terminate old register assignments that don't reach MI;
1419 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1420 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1421 isDbgValueInDefinedReg(Prev)) {
1422 // Previous register assignment needs to terminate at the end of
1424 MachineBasicBlock::const_iterator LastMI =
1425 PrevMBB->getLastNonDebugInstr();
1426 if (LastMI == PrevMBB->end()) {
1427 // Drop DBG_VALUE for empty range.
1428 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1429 << "\t" << *Prev << "\n");
1433 // Terminate after LastMI.
1434 History.push_back(LastMI);
1439 History.push_back(MI);
1441 // Not a DBG_VALUE instruction.
1443 AtBlockEntry = false;
1445 // First known non-DBG_VALUE and non-frame setup location marks
1446 // the beginning of the function body.
1447 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1448 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1449 PrologEndLoc = MI->getDebugLoc();
1451 // Check if the instruction clobbers any registers with debug vars.
1452 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1453 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1454 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1456 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1457 AI.isValid(); ++AI) {
1459 const MDNode *Var = LiveUserVar[Reg];
1462 // Reg is now clobbered.
1463 LiveUserVar[Reg] = 0;
1465 // Was MD last defined by a DBG_VALUE referring to Reg?
1466 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1467 if (HistI == DbgValues.end())
1469 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1470 if (History.empty())
1472 const MachineInstr *Prev = History.back();
1473 // Sanity-check: Register assignments are terminated at the end of
1475 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1477 // Is the variable still in Reg?
1478 if (!isDbgValueInDefinedReg(Prev) ||
1479 Prev->getOperand(0).getReg() != Reg)
1481 // Var is clobbered. Make sure the next instruction gets a label.
1482 History.push_back(MI);
1489 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1491 SmallVectorImpl<const MachineInstr*> &History = I->second;
1492 if (History.empty())
1495 // Make sure the final register assignments are terminated.
1496 const MachineInstr *Prev = History.back();
1497 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1498 const MachineBasicBlock *PrevMBB = Prev->getParent();
1499 MachineBasicBlock::const_iterator LastMI =
1500 PrevMBB->getLastNonDebugInstr();
1501 if (LastMI == PrevMBB->end())
1502 // Drop DBG_VALUE for empty range.
1505 // Terminate after LastMI.
1506 History.push_back(LastMI);
1509 // Request labels for the full history.
1510 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1511 const MachineInstr *MI = History[i];
1512 if (MI->isDebugValue())
1513 requestLabelBeforeInsn(MI);
1515 requestLabelAfterInsn(MI);
1519 PrevInstLoc = DebugLoc();
1520 PrevLabel = FunctionBeginSym;
1522 // Record beginning of function.
1523 if (!PrologEndLoc.isUnknown()) {
1524 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1525 MF->getFunction()->getContext());
1526 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1527 FnStartDL.getScope(MF->getFunction()->getContext()),
1528 // We'd like to list the prologue as "not statements" but GDB behaves
1529 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1530 DWARF2_FLAG_IS_STMT);
1534 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1535 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1536 ScopeVariables[LS].push_back(Var);
1537 // Vars.push_back(Var);
1540 // Gather and emit post-function debug information.
1541 void DwarfDebug::endFunction(const MachineFunction *MF) {
1542 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1544 // Define end label for subprogram.
1545 FunctionEndSym = Asm->GetTempSymbol("func_end",
1546 Asm->getFunctionNumber());
1547 // Assumes in correct section after the entry point.
1548 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1550 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1551 collectVariableInfo(MF, ProcessedVars);
1553 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1554 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1555 assert(TheCU && "Unable to find compile unit!");
1557 // Construct abstract scopes.
1558 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1559 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1560 LexicalScope *AScope = AList[i];
1561 DISubprogram SP(AScope->getScopeNode());
1563 // Collect info for variables that were optimized out.
1564 DIArray Variables = SP.getVariables();
1565 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1566 DIVariable DV(Variables.getElement(i));
1567 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1569 // Check that DbgVariable for DV wasn't created earlier, when
1570 // findAbstractVariable() was called for inlined instance of DV.
1571 LLVMContext &Ctx = DV->getContext();
1572 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1573 if (AbstractVariables.lookup(CleanDV))
1575 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1576 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1579 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1580 constructScopeDIE(TheCU, AScope);
1583 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1585 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1586 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1588 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1589 MMI->getFrameMoves()));
1592 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1593 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1594 DeleteContainerPointers(I->second);
1595 ScopeVariables.clear();
1596 DeleteContainerPointers(CurrentFnArguments);
1597 UserVariables.clear();
1599 AbstractVariables.clear();
1600 LabelsBeforeInsn.clear();
1601 LabelsAfterInsn.clear();
1605 // Register a source line with debug info. Returns the unique label that was
1606 // emitted and which provides correspondence to the source line list.
1607 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1613 DIDescriptor Scope(S);
1615 if (Scope.isCompileUnit()) {
1616 DICompileUnit CU(S);
1617 Fn = CU.getFilename();
1618 Dir = CU.getDirectory();
1619 } else if (Scope.isFile()) {
1621 Fn = F.getFilename();
1622 Dir = F.getDirectory();
1623 } else if (Scope.isSubprogram()) {
1625 Fn = SP.getFilename();
1626 Dir = SP.getDirectory();
1627 } else if (Scope.isLexicalBlockFile()) {
1628 DILexicalBlockFile DBF(S);
1629 Fn = DBF.getFilename();
1630 Dir = DBF.getDirectory();
1631 } else if (Scope.isLexicalBlock()) {
1632 DILexicalBlock DB(S);
1633 Fn = DB.getFilename();
1634 Dir = DB.getDirectory();
1636 llvm_unreachable("Unexpected scope info");
1638 Src = getOrCreateSourceID(Fn, Dir);
1640 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1643 //===----------------------------------------------------------------------===//
1645 //===----------------------------------------------------------------------===//
1647 // Compute the size and offset of a DIE.
1649 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1650 // Get the children.
1651 const std::vector<DIE *> &Children = Die->getChildren();
1653 // Record the abbreviation.
1654 assignAbbrevNumber(Die->getAbbrev());
1656 // Get the abbreviation for this DIE.
1657 unsigned AbbrevNumber = Die->getAbbrevNumber();
1658 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1661 Die->setOffset(Offset);
1663 // Start the size with the size of abbreviation code.
1664 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1666 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1667 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1669 // Size the DIE attribute values.
1670 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1671 // Size attribute value.
1672 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1674 // Size the DIE children if any.
1675 if (!Children.empty()) {
1676 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1677 "Children flag not set");
1679 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1680 Offset = computeSizeAndOffset(Children[j], Offset);
1682 // End of children marker.
1683 Offset += sizeof(int8_t);
1686 Die->setSize(Offset - Die->getOffset());
1690 // Compute the size and offset of all the DIEs.
1691 void DwarfUnits::computeSizeAndOffsets() {
1692 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1693 E = CUs.end(); I != E; ++I) {
1695 sizeof(int32_t) + // Length of Compilation Unit Info
1696 sizeof(int16_t) + // DWARF version number
1697 sizeof(int32_t) + // Offset Into Abbrev. Section
1698 sizeof(int8_t); // Pointer Size (in bytes)
1700 computeSizeAndOffset((*I)->getCUDie(), Offset);
1704 // Emit initial Dwarf sections with a label at the start of each one.
1705 void DwarfDebug::emitSectionLabels() {
1706 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1708 // Dwarf sections base addresses.
1709 DwarfInfoSectionSym =
1710 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1711 DwarfAbbrevSectionSym =
1712 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1713 if (useSplitDwarf())
1714 DwarfAbbrevDWOSectionSym =
1715 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1716 "section_abbrev_dwo");
1717 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1719 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1720 emitSectionSym(Asm, MacroInfo);
1722 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1723 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1724 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1725 DwarfStrSectionSym =
1726 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1727 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1730 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1731 "section_debug_loc");
1733 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1734 emitSectionSym(Asm, TLOF.getDataSection());
1737 // Recursively emits a debug information entry.
1738 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1739 // Get the abbreviation for this DIE.
1740 unsigned AbbrevNumber = Die->getAbbrevNumber();
1741 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1743 // Emit the code (index) for the abbreviation.
1744 if (Asm->isVerbose())
1745 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1746 Twine::utohexstr(Die->getOffset()) + ":0x" +
1747 Twine::utohexstr(Die->getSize()) + " " +
1748 dwarf::TagString(Abbrev->getTag()));
1749 Asm->EmitULEB128(AbbrevNumber);
1751 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1752 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1754 // Emit the DIE attribute values.
1755 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1756 unsigned Attr = AbbrevData[i].getAttribute();
1757 unsigned Form = AbbrevData[i].getForm();
1758 assert(Form && "Too many attributes for DIE (check abbreviation)");
1760 if (Asm->isVerbose())
1761 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1764 case dwarf::DW_AT_abstract_origin: {
1765 DIEEntry *E = cast<DIEEntry>(Values[i]);
1766 DIE *Origin = E->getEntry();
1767 unsigned Addr = Origin->getOffset();
1768 Asm->EmitInt32(Addr);
1771 case dwarf::DW_AT_ranges: {
1772 // DW_AT_range Value encodes offset in debug_range section.
1773 DIEInteger *V = cast<DIEInteger>(Values[i]);
1775 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1776 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1780 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1782 DwarfDebugRangeSectionSym,
1787 case dwarf::DW_AT_location: {
1788 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1789 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1790 Asm->EmitLabelReference(L->getValue(), 4);
1792 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1794 Values[i]->EmitValue(Asm, Form);
1798 case dwarf::DW_AT_accessibility: {
1799 if (Asm->isVerbose()) {
1800 DIEInteger *V = cast<DIEInteger>(Values[i]);
1801 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1803 Values[i]->EmitValue(Asm, Form);
1807 // Emit an attribute using the defined form.
1808 Values[i]->EmitValue(Asm, Form);
1813 // Emit the DIE children if any.
1814 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1815 const std::vector<DIE *> &Children = Die->getChildren();
1817 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1818 emitDIE(Children[j], Abbrevs);
1820 if (Asm->isVerbose())
1821 Asm->OutStreamer.AddComment("End Of Children Mark");
1826 // Emit the various dwarf units to the unit section USection with
1827 // the abbreviations going into ASection.
1828 void DwarfUnits::emitUnits(DwarfDebug *DD,
1829 const MCSection *USection,
1830 const MCSection *ASection,
1831 const MCSymbol *ASectionSym) {
1832 Asm->OutStreamer.SwitchSection(USection);
1833 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1834 E = CUs.end(); I != E; ++I) {
1835 CompileUnit *TheCU = *I;
1836 DIE *Die = TheCU->getCUDie();
1838 // Emit the compile units header.
1840 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1841 TheCU->getUniqueID()));
1843 // Emit size of content not including length itself
1844 unsigned ContentSize = Die->getSize() +
1845 sizeof(int16_t) + // DWARF version number
1846 sizeof(int32_t) + // Offset Into Abbrev. Section
1847 sizeof(int8_t); // Pointer Size (in bytes)
1849 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1850 Asm->EmitInt32(ContentSize);
1851 Asm->OutStreamer.AddComment("DWARF version number");
1852 Asm->EmitInt16(dwarf::DWARF_VERSION);
1853 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1854 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1856 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1857 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1859 DD->emitDIE(Die, Abbreviations);
1860 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1861 TheCU->getUniqueID()));
1865 // Emit the debug info section.
1866 void DwarfDebug::emitDebugInfo() {
1867 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1869 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
1870 Asm->getObjFileLowering().getDwarfAbbrevSection(),
1871 DwarfAbbrevSectionSym);
1874 // Emit the abbreviation section.
1875 void DwarfDebug::emitAbbreviations() {
1876 if (!useSplitDwarf())
1877 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
1880 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1883 void DwarfDebug::emitAbbrevs(const MCSection *Section,
1884 std::vector<DIEAbbrev *> *Abbrevs) {
1885 // Check to see if it is worth the effort.
1886 if (!Abbrevs->empty()) {
1887 // Start the debug abbrev section.
1888 Asm->OutStreamer.SwitchSection(Section);
1890 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
1891 Asm->OutStreamer.EmitLabel(Begin);
1893 // For each abbrevation.
1894 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
1895 // Get abbreviation data
1896 const DIEAbbrev *Abbrev = Abbrevs->at(i);
1898 // Emit the abbrevations code (base 1 index.)
1899 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1901 // Emit the abbreviations data.
1905 // Mark end of abbreviations.
1906 Asm->EmitULEB128(0, "EOM(3)");
1908 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
1909 Asm->OutStreamer.EmitLabel(End);
1913 // Emit the last address of the section and the end of the line matrix.
1914 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1915 // Define last address of section.
1916 Asm->OutStreamer.AddComment("Extended Op");
1919 Asm->OutStreamer.AddComment("Op size");
1920 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1921 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1922 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1924 Asm->OutStreamer.AddComment("Section end label");
1926 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1927 Asm->getDataLayout().getPointerSize(),
1930 // Mark end of matrix.
1931 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1937 // Emit visible names into a hashed accelerator table section.
1938 void DwarfDebug::emitAccelNames() {
1939 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1940 dwarf::DW_FORM_data4));
1941 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1942 E = CUMap.end(); I != E; ++I) {
1943 CompileUnit *TheCU = I->second;
1944 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1945 for (StringMap<std::vector<DIE*> >::const_iterator
1946 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1947 const char *Name = GI->getKeyData();
1948 const std::vector<DIE *> &Entities = GI->second;
1949 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1950 DE = Entities.end(); DI != DE; ++DI)
1951 AT.AddName(Name, (*DI));
1955 AT.FinalizeTable(Asm, "Names");
1956 Asm->OutStreamer.SwitchSection(
1957 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1958 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1959 Asm->OutStreamer.EmitLabel(SectionBegin);
1961 // Emit the full data.
1962 AT.Emit(Asm, SectionBegin, &InfoHolder);
1965 // Emit objective C classes and categories into a hashed accelerator table section.
1966 void DwarfDebug::emitAccelObjC() {
1967 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1968 dwarf::DW_FORM_data4));
1969 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1970 E = CUMap.end(); I != E; ++I) {
1971 CompileUnit *TheCU = I->second;
1972 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1973 for (StringMap<std::vector<DIE*> >::const_iterator
1974 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1975 const char *Name = GI->getKeyData();
1976 const std::vector<DIE *> &Entities = GI->second;
1977 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1978 DE = Entities.end(); DI != DE; ++DI)
1979 AT.AddName(Name, (*DI));
1983 AT.FinalizeTable(Asm, "ObjC");
1984 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1985 .getDwarfAccelObjCSection());
1986 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1987 Asm->OutStreamer.EmitLabel(SectionBegin);
1989 // Emit the full data.
1990 AT.Emit(Asm, SectionBegin, &InfoHolder);
1993 // Emit namespace dies into a hashed accelerator table.
1994 void DwarfDebug::emitAccelNamespaces() {
1995 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1996 dwarf::DW_FORM_data4));
1997 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1998 E = CUMap.end(); I != E; ++I) {
1999 CompileUnit *TheCU = I->second;
2000 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2001 for (StringMap<std::vector<DIE*> >::const_iterator
2002 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2003 const char *Name = GI->getKeyData();
2004 const std::vector<DIE *> &Entities = GI->second;
2005 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2006 DE = Entities.end(); DI != DE; ++DI)
2007 AT.AddName(Name, (*DI));
2011 AT.FinalizeTable(Asm, "namespac");
2012 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2013 .getDwarfAccelNamespaceSection());
2014 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2015 Asm->OutStreamer.EmitLabel(SectionBegin);
2017 // Emit the full data.
2018 AT.Emit(Asm, SectionBegin, &InfoHolder);
2021 // Emit type dies into a hashed accelerator table.
2022 void DwarfDebug::emitAccelTypes() {
2023 std::vector<DwarfAccelTable::Atom> Atoms;
2024 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2025 dwarf::DW_FORM_data4));
2026 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2027 dwarf::DW_FORM_data2));
2028 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2029 dwarf::DW_FORM_data1));
2030 DwarfAccelTable AT(Atoms);
2031 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2032 E = CUMap.end(); I != E; ++I) {
2033 CompileUnit *TheCU = I->second;
2034 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2035 = TheCU->getAccelTypes();
2036 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2037 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2038 const char *Name = GI->getKeyData();
2039 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2040 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2041 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2042 AT.AddName(Name, (*DI).first, (*DI).second);
2046 AT.FinalizeTable(Asm, "types");
2047 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2048 .getDwarfAccelTypesSection());
2049 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2050 Asm->OutStreamer.EmitLabel(SectionBegin);
2052 // Emit the full data.
2053 AT.Emit(Asm, SectionBegin, &InfoHolder);
2056 void DwarfDebug::emitDebugPubTypes() {
2057 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2058 E = CUMap.end(); I != E; ++I) {
2059 CompileUnit *TheCU = I->second;
2060 // Start the dwarf pubtypes section.
2061 Asm->OutStreamer.SwitchSection(
2062 Asm->getObjFileLowering().getDwarfPubTypesSection());
2063 Asm->OutStreamer.AddComment("Length of Public Types Info");
2064 Asm->EmitLabelDifference(
2065 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2066 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2068 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2069 TheCU->getUniqueID()));
2071 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2072 Asm->EmitInt16(dwarf::DWARF_VERSION);
2074 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2075 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2076 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2077 TheCU->getUniqueID()),
2078 DwarfInfoSectionSym);
2080 Asm->OutStreamer.AddComment("Compilation Unit Length");
2081 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2082 TheCU->getUniqueID()),
2083 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2084 TheCU->getUniqueID()),
2087 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2088 for (StringMap<DIE*>::const_iterator
2089 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2090 const char *Name = GI->getKeyData();
2091 DIE *Entity = GI->second;
2093 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2094 Asm->EmitInt32(Entity->getOffset());
2096 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2097 // Emit the name with a terminating null byte.
2098 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2101 Asm->OutStreamer.AddComment("End Mark");
2103 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2104 TheCU->getUniqueID()));
2108 // Emit visible names into a debug str section.
2109 void DwarfDebug::emitDebugStr() {
2110 // Check to see if it is worth the effort.
2111 if (InfoHolder.getStringPool()->empty()) return;
2113 // Start the dwarf str section.
2114 Asm->OutStreamer.SwitchSection(
2115 Asm->getObjFileLowering().getDwarfStrSection());
2117 // Get all of the string pool entries and put them in an array by their ID so
2118 // we can sort them.
2119 SmallVector<std::pair<unsigned,
2120 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2122 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2123 I = InfoHolder.getStringPool()->begin(), E = InfoHolder.getStringPool()->end(); I != E; ++I)
2124 Entries.push_back(std::make_pair(I->second.second, &*I));
2126 array_pod_sort(Entries.begin(), Entries.end());
2128 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2129 // Emit a label for reference from debug information entries.
2130 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2132 // Emit the string itself with a terminating null byte.
2133 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2134 Entries[i].second->getKeyLength()+1),
2139 // Emit visible names into a debug loc section.
2140 void DwarfDebug::emitDebugLoc() {
2141 if (DotDebugLocEntries.empty())
2144 for (SmallVector<DotDebugLocEntry, 4>::iterator
2145 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2147 DotDebugLocEntry &Entry = *I;
2148 if (I + 1 != DotDebugLocEntries.end())
2152 // Start the dwarf loc section.
2153 Asm->OutStreamer.SwitchSection(
2154 Asm->getObjFileLowering().getDwarfLocSection());
2155 unsigned char Size = Asm->getDataLayout().getPointerSize();
2156 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2158 for (SmallVector<DotDebugLocEntry, 4>::iterator
2159 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2160 I != E; ++I, ++index) {
2161 DotDebugLocEntry &Entry = *I;
2162 if (Entry.isMerged()) continue;
2163 if (Entry.isEmpty()) {
2164 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2165 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2166 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2168 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2169 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2170 DIVariable DV(Entry.Variable);
2171 Asm->OutStreamer.AddComment("Loc expr size");
2172 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2173 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2174 Asm->EmitLabelDifference(end, begin, 2);
2175 Asm->OutStreamer.EmitLabel(begin);
2176 if (Entry.isInt()) {
2177 DIBasicType BTy(DV.getType());
2179 (BTy.getEncoding() == dwarf::DW_ATE_signed
2180 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2181 Asm->OutStreamer.AddComment("DW_OP_consts");
2182 Asm->EmitInt8(dwarf::DW_OP_consts);
2183 Asm->EmitSLEB128(Entry.getInt());
2185 Asm->OutStreamer.AddComment("DW_OP_constu");
2186 Asm->EmitInt8(dwarf::DW_OP_constu);
2187 Asm->EmitULEB128(Entry.getInt());
2189 } else if (Entry.isLocation()) {
2190 if (!DV.hasComplexAddress())
2192 Asm->EmitDwarfRegOp(Entry.Loc);
2194 // Complex address entry.
2195 unsigned N = DV.getNumAddrElements();
2197 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2198 if (Entry.Loc.getOffset()) {
2200 Asm->EmitDwarfRegOp(Entry.Loc);
2201 Asm->OutStreamer.AddComment("DW_OP_deref");
2202 Asm->EmitInt8(dwarf::DW_OP_deref);
2203 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2204 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2205 Asm->EmitSLEB128(DV.getAddrElement(1));
2207 // If first address element is OpPlus then emit
2208 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2209 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2210 Asm->EmitDwarfRegOp(Loc);
2214 Asm->EmitDwarfRegOp(Entry.Loc);
2217 // Emit remaining complex address elements.
2218 for (; i < N; ++i) {
2219 uint64_t Element = DV.getAddrElement(i);
2220 if (Element == DIBuilder::OpPlus) {
2221 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2222 Asm->EmitULEB128(DV.getAddrElement(++i));
2223 } else if (Element == DIBuilder::OpDeref) {
2224 if (!Entry.Loc.isReg())
2225 Asm->EmitInt8(dwarf::DW_OP_deref);
2227 llvm_unreachable("unknown Opcode found in complex address");
2231 // else ... ignore constant fp. There is not any good way to
2232 // to represent them here in dwarf.
2233 Asm->OutStreamer.EmitLabel(end);
2238 // Emit visible names into a debug aranges section.
2239 void DwarfDebug::emitDebugARanges() {
2240 // Start the dwarf aranges section.
2241 Asm->OutStreamer.SwitchSection(
2242 Asm->getObjFileLowering().getDwarfARangesSection());
2245 // Emit visible names into a debug ranges section.
2246 void DwarfDebug::emitDebugRanges() {
2247 // Start the dwarf ranges section.
2248 Asm->OutStreamer.SwitchSection(
2249 Asm->getObjFileLowering().getDwarfRangesSection());
2250 unsigned char Size = Asm->getDataLayout().getPointerSize();
2251 for (SmallVector<const MCSymbol *, 8>::iterator
2252 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2255 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2257 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2261 // Emit visible names into a debug macinfo section.
2262 void DwarfDebug::emitDebugMacInfo() {
2263 if (const MCSection *LineInfo =
2264 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2265 // Start the dwarf macinfo section.
2266 Asm->OutStreamer.SwitchSection(LineInfo);
2270 // Emit inline info using following format.
2272 // 1. length of section
2273 // 2. Dwarf version number
2276 // Entries (one "entry" for each function that was inlined):
2278 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2279 // otherwise offset into __debug_str for regular function name.
2280 // 2. offset into __debug_str section for regular function name.
2281 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2282 // instances for the function.
2284 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2285 // inlined instance; the die_offset points to the inlined_subroutine die in the
2286 // __debug_info section, and the low_pc is the starting address for the
2287 // inlining instance.
2288 void DwarfDebug::emitDebugInlineInfo() {
2289 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2295 Asm->OutStreamer.SwitchSection(
2296 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2298 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2299 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2300 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2302 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2304 Asm->OutStreamer.AddComment("Dwarf Version");
2305 Asm->EmitInt16(dwarf::DWARF_VERSION);
2306 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2307 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2309 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2310 E = InlinedSPNodes.end(); I != E; ++I) {
2312 const MDNode *Node = *I;
2313 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2314 = InlineInfo.find(Node);
2315 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2316 DISubprogram SP(Node);
2317 StringRef LName = SP.getLinkageName();
2318 StringRef Name = SP.getName();
2320 Asm->OutStreamer.AddComment("MIPS linkage name");
2322 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2323 DwarfStrSectionSym);
2325 Asm->EmitSectionOffset(InfoHolder
2326 .getStringPoolEntry(getRealLinkageName(LName)),
2327 DwarfStrSectionSym);
2329 Asm->OutStreamer.AddComment("Function name");
2330 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2331 DwarfStrSectionSym);
2332 Asm->EmitULEB128(Labels.size(), "Inline count");
2334 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2335 LE = Labels.end(); LI != LE; ++LI) {
2336 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2337 Asm->EmitInt32(LI->second->getOffset());
2339 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2340 Asm->OutStreamer.EmitSymbolValue(LI->first,
2341 Asm->getDataLayout().getPointerSize(),0);
2345 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2348 // DWARF5 Experimental Separate Dwarf emitters.
2350 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2351 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2352 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2353 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2354 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2355 DICompileUnit DIUnit(N);
2356 StringRef FN = DIUnit.getFilename();
2357 CompilationDir = DIUnit.getDirectory();
2359 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2360 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2361 DIUnit.getLanguage(), Die, Asm,
2363 // FIXME: This should be the .dwo file.
2364 NewCU->addString(Die, dwarf::DW_AT_GNU_dwo_name, FN);
2366 // FIXME: We also need DW_AT_addr_base and DW_AT_dwo_id.
2368 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2370 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2371 // DW_AT_stmt_list is a offset of line number information for this
2372 // compile unit in debug_line section.
2373 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2374 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
2375 Asm->GetTempSymbol("section_line"));
2377 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
2379 if (!CompilationDir.empty())
2380 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2382 SkeletonHolder.addUnit(NewCU);
2387 void DwarfDebug::emitSkeletonCU(const MCSection *Section) {
2388 Asm->OutStreamer.SwitchSection(Section);
2389 DIE *Die = SkeletonCU->getCUDie();
2391 // Emit the compile units header.
2392 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(Section->getLabelBeginName(),
2393 SkeletonCU->getUniqueID()));
2395 // Emit size of content not including length itself
2396 unsigned ContentSize = Die->getSize() +
2397 sizeof(int16_t) + // DWARF version number
2398 sizeof(int32_t) + // Offset Into Abbrev. Section
2399 sizeof(int8_t); // Pointer Size (in bytes)
2401 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2402 Asm->EmitInt32(ContentSize);
2403 Asm->OutStreamer.AddComment("DWARF version number");
2404 Asm->EmitInt16(dwarf::DWARF_VERSION);
2405 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2407 const MCSection *ASec = Asm->getObjFileLowering().getDwarfAbbrevSection();
2408 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASec->getLabelBeginName()),
2409 DwarfAbbrevSectionSym);
2410 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2411 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2413 emitDIE(Die, &SkeletonAbbrevs);
2414 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(Section->getLabelEndName(),
2415 SkeletonCU->getUniqueID()));
2418 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2419 assert(useSplitDwarf() && "No split dwarf debug info?");
2420 emitAbbrevs(Section, &SkeletonAbbrevs);
2423 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2424 // compile units that would normally be in debug_info.
2425 void DwarfDebug::emitDebugInfoDWO() {
2426 assert(useSplitDwarf() && "No split dwarf debug info?");
2427 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2428 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2429 DwarfAbbrevDWOSectionSym);
2432 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2433 // abbreviations for the .debug_info.dwo section.
2434 void DwarfDebug::emitDebugAbbrevDWO() {
2435 assert(useSplitDwarf() && "No split dwarf?");
2436 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(), &Abbreviations);