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."),
57 static cl::opt<bool> GenerateDwarfPubNamesSection("generate-dwarf-pubnames",
58 cl::Hidden, cl::init(false),
59 cl::desc("Generate DWARF pubnames section"));
63 Default, Enable, Disable
67 static cl::opt<DefaultOnOff> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
68 cl::desc("Output prototype dwarf accelerator tables."),
70 clEnumVal(Default, "Default for platform"),
71 clEnumVal(Enable, "Enabled"),
72 clEnumVal(Disable, "Disabled"),
76 static cl::opt<DefaultOnOff> DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
77 cl::desc("Compatibility with Darwin gdb."),
79 clEnumVal(Default, "Default for platform"),
80 clEnumVal(Enable, "Enabled"),
81 clEnumVal(Disable, "Disabled"),
85 static cl::opt<DefaultOnOff> SplitDwarf("split-dwarf", cl::Hidden,
86 cl::desc("Output prototype dwarf split debug info."),
88 clEnumVal(Default, "Default for platform"),
89 clEnumVal(Enable, "Enabled"),
90 clEnumVal(Disable, "Disabled"),
95 const char *DWARFGroupName = "DWARF Emission";
96 const char *DbgTimerName = "DWARF Debug Writer";
97 } // end anonymous namespace
99 //===----------------------------------------------------------------------===//
101 // Configuration values for initial hash set sizes (log2).
103 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
107 DIType DbgVariable::getType() const {
108 DIType Ty = Var.getType();
109 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
110 // addresses instead.
111 if (Var.isBlockByrefVariable()) {
112 /* Byref variables, in Blocks, are declared by the programmer as
113 "SomeType VarName;", but the compiler creates a
114 __Block_byref_x_VarName struct, and gives the variable VarName
115 either the struct, or a pointer to the struct, as its type. This
116 is necessary for various behind-the-scenes things the compiler
117 needs to do with by-reference variables in blocks.
119 However, as far as the original *programmer* is concerned, the
120 variable should still have type 'SomeType', as originally declared.
122 The following function dives into the __Block_byref_x_VarName
123 struct to find the original type of the variable. This will be
124 passed back to the code generating the type for the Debug
125 Information Entry for the variable 'VarName'. 'VarName' will then
126 have the original type 'SomeType' in its debug information.
128 The original type 'SomeType' will be the type of the field named
129 'VarName' inside the __Block_byref_x_VarName struct.
131 NOTE: In order for this to not completely fail on the debugger
132 side, the Debug Information Entry for the variable VarName needs to
133 have a DW_AT_location that tells the debugger how to unwind through
134 the pointers and __Block_byref_x_VarName struct to find the actual
135 value of the variable. The function addBlockByrefType does this. */
137 unsigned tag = Ty.getTag();
139 if (tag == dwarf::DW_TAG_pointer_type) {
140 DIDerivedType DTy = DIDerivedType(Ty);
141 subType = DTy.getTypeDerivedFrom();
144 DICompositeType blockStruct = DICompositeType(subType);
145 DIArray Elements = blockStruct.getTypeArray();
147 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
148 DIDescriptor Element = Elements.getElement(i);
149 DIDerivedType DT = DIDerivedType(Element);
150 if (getName() == DT.getName())
151 return (DT.getTypeDerivedFrom());
157 } // end llvm namespace
159 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
160 : Asm(A), MMI(Asm->MMI), FirstCU(0),
161 AbbreviationsSet(InitAbbreviationsSetSize),
162 SourceIdMap(DIEValueAllocator),
163 PrevLabel(NULL), GlobalCUIndexCount(0),
164 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
166 SkeletonAbbrevSet(InitAbbreviationsSetSize),
167 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
170 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
171 DwarfStrSectionSym = TextSectionSym = 0;
172 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
173 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
174 FunctionBeginSym = FunctionEndSym = 0;
176 // Turn on accelerator tables and older gdb compatibility
178 bool IsDarwin = Triple(M->getTargetTriple()).isOSDarwin();
179 if (DarwinGDBCompat == Default) {
181 IsDarwinGDBCompat = true;
183 IsDarwinGDBCompat = false;
185 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
187 if (DwarfAccelTables == Default) {
189 HasDwarfAccelTables = true;
191 HasDwarfAccelTables = false;
193 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
195 if (SplitDwarf == Default)
196 HasSplitDwarf = false;
198 HasSplitDwarf = SplitDwarf == Enable ? true : false;
201 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
205 DwarfDebug::~DwarfDebug() {
208 // Switch to the specified MCSection and emit an assembler
209 // temporary label to it if SymbolStem is specified.
210 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
211 const char *SymbolStem = 0) {
212 Asm->OutStreamer.SwitchSection(Section);
213 if (!SymbolStem) return 0;
215 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
216 Asm->OutStreamer.EmitLabel(TmpSym);
220 MCSymbol *DwarfUnits::getStringPoolSym() {
221 return Asm->GetTempSymbol(StringPref);
224 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
225 std::pair<MCSymbol*, unsigned> &Entry =
226 StringPool.GetOrCreateValue(Str).getValue();
227 if (Entry.first) return Entry.first;
229 Entry.second = NextStringPoolNumber++;
230 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
233 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
234 std::pair<MCSymbol*, unsigned> &Entry =
235 StringPool.GetOrCreateValue(Str).getValue();
236 if (Entry.first) return Entry.second;
238 Entry.second = NextStringPoolNumber++;
239 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
243 unsigned DwarfUnits::getAddrPoolIndex(MCSymbol *Sym) {
244 std::pair<MCSymbol*, unsigned> &Entry = AddressPool[Sym];
245 if (Entry.first) return Entry.second;
247 Entry.second = NextAddrPoolNumber++;
252 // Define a unique number for the abbreviation.
254 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
255 // Profile the node so that we can make it unique.
259 // Check the set for priors.
260 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
262 // If it's newly added.
263 if (InSet == &Abbrev) {
264 // Add to abbreviation list.
265 Abbreviations->push_back(&Abbrev);
267 // Assign the vector position + 1 as its number.
268 Abbrev.setNumber(Abbreviations->size());
270 // Assign existing abbreviation number.
271 Abbrev.setNumber(InSet->getNumber());
275 // If special LLVM prefix that is used to inform the asm
276 // printer to not emit usual symbol prefix before the symbol name is used then
277 // return linkage name after skipping this special LLVM prefix.
278 static StringRef getRealLinkageName(StringRef LinkageName) {
280 if (LinkageName.startswith(StringRef(&One, 1)))
281 return LinkageName.substr(1);
285 static bool isObjCClass(StringRef Name) {
286 return Name.startswith("+") || Name.startswith("-");
289 static bool hasObjCCategory(StringRef Name) {
290 if (!isObjCClass(Name)) return false;
292 size_t pos = Name.find(')');
293 if (pos != std::string::npos) {
294 if (Name[pos+1] != ' ') return false;
300 static void getObjCClassCategory(StringRef In, StringRef &Class,
301 StringRef &Category) {
302 if (!hasObjCCategory(In)) {
303 Class = In.slice(In.find('[') + 1, In.find(' '));
308 Class = In.slice(In.find('[') + 1, In.find('('));
309 Category = In.slice(In.find('[') + 1, In.find(' '));
313 static StringRef getObjCMethodName(StringRef In) {
314 return In.slice(In.find(' ') + 1, In.find(']'));
317 // Add the various names to the Dwarf accelerator table names.
318 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
320 if (!SP.isDefinition()) return;
322 TheCU->addAccelName(SP.getName(), Die);
324 // If the linkage name is different than the name, go ahead and output
325 // that as well into the name table.
326 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
327 TheCU->addAccelName(SP.getLinkageName(), Die);
329 // If this is an Objective-C selector name add it to the ObjC accelerator
331 if (isObjCClass(SP.getName())) {
332 StringRef Class, Category;
333 getObjCClassCategory(SP.getName(), Class, Category);
334 TheCU->addAccelObjC(Class, Die);
336 TheCU->addAccelObjC(Category, Die);
337 // Also add the base method name to the name table.
338 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
342 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
343 // and DW_AT_high_pc attributes. If there are global variables in this
344 // scope then create and insert DIEs for these variables.
345 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
346 const MDNode *SPNode) {
347 DIE *SPDie = SPCU->getDIE(SPNode);
349 assert(SPDie && "Unable to find subprogram DIE!");
350 DISubprogram SP(SPNode);
352 // If we're updating an abstract DIE, then we will be adding the children and
353 // object pointer later on. But what we don't want to do is process the
354 // concrete DIE twice.
355 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
357 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
358 // Pick up abstract subprogram DIE.
359 SPDie = new DIE(dwarf::DW_TAG_subprogram);
360 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
362 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
363 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
367 DISubprogram SPDecl = SP.getFunctionDeclaration();
368 if (!SPDecl.isSubprogram()) {
369 // There is not any need to generate specification DIE for a function
370 // defined at compile unit level. If a function is defined inside another
371 // function then gdb prefers the definition at top level and but does not
372 // expect specification DIE in parent function. So avoid creating
373 // specification DIE for a function defined inside a function.
374 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
375 !SP.getContext().isFile() &&
376 !isSubprogramContext(SP.getContext())) {
377 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
380 DICompositeType SPTy = SP.getType();
381 DIArray Args = SPTy.getTypeArray();
382 unsigned SPTag = SPTy.getTag();
383 if (SPTag == dwarf::DW_TAG_subroutine_type)
384 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
385 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
386 DIType ATy = DIType(Args.getElement(i));
387 SPCU->addType(Arg, ATy);
388 if (ATy.isArtificial())
389 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
390 if (ATy.isObjectPointer())
391 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
392 dwarf::DW_FORM_ref4, Arg);
393 SPDie->addChild(Arg);
395 DIE *SPDeclDie = SPDie;
396 SPDie = new DIE(dwarf::DW_TAG_subprogram);
397 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
398 dwarf::DW_FORM_ref4, SPDeclDie);
404 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
405 Asm->GetTempSymbol("func_begin",
406 Asm->getFunctionNumber()));
407 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
408 Asm->GetTempSymbol("func_end",
409 Asm->getFunctionNumber()));
410 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
411 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
412 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
414 // Add name to the name table, we do this here because we're guaranteed
415 // to have concrete versions of our DW_TAG_subprogram nodes.
416 addSubprogramNames(SPCU, SP, SPDie);
421 // Construct new DW_TAG_lexical_block for this scope and attach
422 // DW_AT_low_pc/DW_AT_high_pc labels.
423 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
424 LexicalScope *Scope) {
425 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
426 if (Scope->isAbstractScope())
429 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
433 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
434 if (Ranges.size() > 1) {
435 // .debug_range section has not been laid out yet. Emit offset in
436 // .debug_range as a uint, size 4, for now. emitDIE will handle
437 // DW_AT_ranges appropriately.
438 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
439 DebugRangeSymbols.size()
440 * Asm->getDataLayout().getPointerSize());
441 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
442 RE = Ranges.end(); RI != RE; ++RI) {
443 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
444 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
446 DebugRangeSymbols.push_back(NULL);
447 DebugRangeSymbols.push_back(NULL);
451 MCSymbol *Start = getLabelBeforeInsn(RI->first);
452 MCSymbol *End = getLabelAfterInsn(RI->second);
454 if (End == 0) return 0;
456 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
457 assert(End->isDefined() && "Invalid end label for an inlined scope!");
459 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
460 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
465 // This scope represents inlined body of a function. Construct DIE to
466 // represent this concrete inlined copy of the function.
467 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
468 LexicalScope *Scope) {
469 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
470 assert(Ranges.empty() == false &&
471 "LexicalScope does not have instruction markers!");
473 if (!Scope->getScopeNode())
475 DIScope DS(Scope->getScopeNode());
476 DISubprogram InlinedSP = getDISubprogram(DS);
477 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
479 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
483 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
484 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
485 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
487 if (StartLabel == 0 || EndLabel == 0) {
488 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
490 assert(StartLabel->isDefined() &&
491 "Invalid starting label for an inlined scope!");
492 assert(EndLabel->isDefined() &&
493 "Invalid end label for an inlined scope!");
495 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
496 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
497 dwarf::DW_FORM_ref4, OriginDIE);
499 if (Ranges.size() > 1) {
500 // .debug_range section has not been laid out yet. Emit offset in
501 // .debug_range as a uint, size 4, for now. emitDIE will handle
502 // DW_AT_ranges appropriately.
503 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
504 DebugRangeSymbols.size()
505 * Asm->getDataLayout().getPointerSize());
506 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
507 RE = Ranges.end(); RI != RE; ++RI) {
508 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
509 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
511 DebugRangeSymbols.push_back(NULL);
512 DebugRangeSymbols.push_back(NULL);
514 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
515 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
518 InlinedSubprogramDIEs.insert(OriginDIE);
520 // Track the start label for this inlined function.
521 //.debug_inlined section specification does not clearly state how
522 // to emit inlined scope that is split into multiple instruction ranges.
523 // For now, use first instruction range and emit low_pc/high_pc pair and
524 // corresponding .debug_inlined section entry for this pair.
525 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
526 I = InlineInfo.find(InlinedSP);
528 if (I == InlineInfo.end()) {
529 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
530 InlinedSPNodes.push_back(InlinedSP);
532 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
534 DILocation DL(Scope->getInlinedAt());
535 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
536 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
537 TheCU->getUniqueID()));
538 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
540 // Add name to the name table, we do this here because we're guaranteed
541 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
542 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
547 // Construct a DIE for this scope.
548 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
549 if (!Scope || !Scope->getScopeNode())
552 DIScope DS(Scope->getScopeNode());
553 // Early return to avoid creating dangling variable|scope DIEs.
554 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
558 SmallVector<DIE *, 8> Children;
559 DIE *ObjectPointer = NULL;
561 // Collect arguments for current function.
562 if (LScopes.isCurrentFunctionScope(Scope))
563 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
564 if (DbgVariable *ArgDV = CurrentFnArguments[i])
566 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
567 Children.push_back(Arg);
568 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
571 // Collect lexical scope children first.
572 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
573 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
575 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
576 Children.push_back(Variable);
577 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
579 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
580 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
581 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
582 Children.push_back(Nested);
583 DIE *ScopeDIE = NULL;
584 if (Scope->getInlinedAt())
585 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
586 else if (DS.isSubprogram()) {
587 ProcessedSPNodes.insert(DS);
588 if (Scope->isAbstractScope()) {
589 ScopeDIE = TheCU->getDIE(DS);
590 // Note down abstract DIE.
592 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
595 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
598 // There is no need to emit empty lexical block DIE.
599 if (Children.empty())
601 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
604 if (!ScopeDIE) return NULL;
607 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
608 E = Children.end(); I != E; ++I)
609 ScopeDIE->addChild(*I);
611 if (DS.isSubprogram() && ObjectPointer != NULL)
612 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
613 dwarf::DW_FORM_ref4, ObjectPointer);
615 if (DS.isSubprogram())
616 TheCU->addPubTypes(DISubprogram(DS));
621 // Look up the source id with the given directory and source file names.
622 // If none currently exists, create a new id and insert it in the
623 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
625 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
626 StringRef DirName, unsigned CUID) {
627 // If we use .loc in assembly, we can't separate .file entries according to
628 // compile units. Thus all files will belong to the default compile unit.
629 if (Asm->TM.hasMCUseLoc() &&
630 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
633 // If FE did not provide a file name, then assume stdin.
634 if (FileName.empty())
635 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
637 // TODO: this might not belong here. See if we can factor this better.
638 if (DirName == CompilationDir)
641 // FileIDCUMap stores the current ID for the given compile unit.
642 unsigned SrcId = FileIDCUMap[CUID] + 1;
644 // We look up the CUID/file/dir by concatenating them with a zero byte.
645 SmallString<128> NamePair;
649 NamePair += '\0'; // Zero bytes are not allowed in paths.
650 NamePair += FileName;
652 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
653 if (Ent.getValue() != SrcId)
654 return Ent.getValue();
656 FileIDCUMap[CUID] = SrcId;
657 // Print out a .file directive to specify files for .loc directives.
658 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
663 // Create new CompileUnit for the given metadata node with tag
664 // DW_TAG_compile_unit.
665 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
666 DICompileUnit DIUnit(N);
667 StringRef FN = DIUnit.getFilename();
668 CompilationDir = DIUnit.getDirectory();
670 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
671 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
672 DIUnit.getLanguage(), Die, Asm,
675 FileIDCUMap[NewCU->getUniqueID()] = 0;
676 // Call this to emit a .file directive if it wasn't emitted for the source
677 // file this CU comes from yet.
678 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
680 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
681 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
682 DIUnit.getLanguage());
683 NewCU->addString(Die, dwarf::DW_AT_name, FN);
684 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
685 // into an entity. We're using 0 (or a NULL label) for this.
686 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
688 // Define start line table label for each Compile Unit.
689 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
690 NewCU->getUniqueID());
691 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
692 NewCU->getUniqueID());
694 // DW_AT_stmt_list is a offset of line number information for this
695 // compile unit in debug_line section.
696 // The line table entries are not always emitted in assembly, so it
697 // is not okay to use line_table_start here.
698 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
699 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
700 NewCU->getUniqueID() == 0 ?
701 Asm->GetTempSymbol("section_line") : LineTableStartSym);
702 else if (NewCU->getUniqueID() == 0)
703 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
705 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
706 LineTableStartSym, DwarfLineSectionSym);
708 if (!CompilationDir.empty())
709 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
710 if (DIUnit.isOptimized())
711 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
713 StringRef Flags = DIUnit.getFlags();
715 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
717 if (unsigned RVer = DIUnit.getRunTimeVersion())
718 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
719 dwarf::DW_FORM_data1, RVer);
724 InfoHolder.addUnit(NewCU);
726 CUMap.insert(std::make_pair(N, NewCU));
730 // Construct subprogram DIE.
731 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
733 CompileUnit *&CURef = SPMap[N];
739 if (!SP.isDefinition())
740 // This is a method declaration which will be handled while constructing
744 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
747 TheCU->insertDIE(N, SubprogramDie);
749 // Add to context owner.
750 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
752 // Expose as global, if requested.
753 if (GenerateDwarfPubNamesSection)
754 TheCU->addGlobalName(SP.getName(), SubprogramDie);
757 // Emit all Dwarf sections that should come prior to the content. Create
758 // global DIEs and emit initial debug info sections. This is invoked by
759 // the target AsmPrinter.
760 void DwarfDebug::beginModule() {
761 if (DisableDebugInfoPrinting)
764 const Module *M = MMI->getModule();
766 // If module has named metadata anchors then use them, otherwise scan the
767 // module using debug info finder to collect debug info.
768 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
772 // Emit initial sections so we can reference labels later.
775 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
776 DICompileUnit CUNode(CU_Nodes->getOperand(i));
777 CompileUnit *CU = constructCompileUnit(CUNode);
778 DIArray GVs = CUNode.getGlobalVariables();
779 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
780 CU->createGlobalVariableDIE(GVs.getElement(i));
781 DIArray SPs = CUNode.getSubprograms();
782 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
783 constructSubprogramDIE(CU, SPs.getElement(i));
784 DIArray EnumTypes = CUNode.getEnumTypes();
785 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
786 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
787 DIArray RetainedTypes = CUNode.getRetainedTypes();
788 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
789 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
790 // If we're splitting the dwarf out now that we've got the entire
791 // CU then construct a skeleton CU based upon it.
792 if (useSplitDwarf()) {
793 // This should be a unique identifier when we want to build .dwp files.
794 CU->addUInt(CU->getCUDie(), dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
795 // Now construct the skeleton CU associated.
796 constructSkeletonCU(CUNode);
800 // Tell MMI that we have debug info.
801 MMI->setDebugInfoAvailability(true);
803 // Prime section data.
804 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
807 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
808 void DwarfDebug::computeInlinedDIEs() {
809 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
810 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
811 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
813 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
815 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
816 AE = AbstractSPDies.end(); AI != AE; ++AI) {
817 DIE *ISP = AI->second;
818 if (InlinedSubprogramDIEs.count(ISP))
820 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
824 // Collect info for variables that were optimized out.
825 void DwarfDebug::collectDeadVariables() {
826 const Module *M = MMI->getModule();
827 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
829 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
830 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
831 DICompileUnit TheCU(CU_Nodes->getOperand(i));
832 DIArray Subprograms = TheCU.getSubprograms();
833 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
834 DISubprogram SP(Subprograms.getElement(i));
835 if (ProcessedSPNodes.count(SP) != 0) continue;
836 if (!SP.Verify()) continue;
837 if (!SP.isDefinition()) continue;
838 DIArray Variables = SP.getVariables();
839 if (Variables.getNumElements() == 0) continue;
841 LexicalScope *Scope =
842 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
843 DeadFnScopeMap[SP] = Scope;
845 // Construct subprogram DIE and add variables DIEs.
846 CompileUnit *SPCU = CUMap.lookup(TheCU);
847 assert(SPCU && "Unable to find Compile Unit!");
848 constructSubprogramDIE(SPCU, SP);
849 DIE *ScopeDIE = SPCU->getDIE(SP);
850 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
851 DIVariable DV(Variables.getElement(vi));
852 if (!DV.Verify()) continue;
853 DbgVariable *NewVar = new DbgVariable(DV, NULL);
854 if (DIE *VariableDIE =
855 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
856 ScopeDIE->addChild(VariableDIE);
861 DeleteContainerSeconds(DeadFnScopeMap);
864 void DwarfDebug::finalizeModuleInfo() {
865 // Collect info for variables that were optimized out.
866 collectDeadVariables();
868 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
869 computeInlinedDIEs();
871 // Emit DW_AT_containing_type attribute to connect types with their
872 // vtable holding type.
873 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
874 CUE = CUMap.end(); CUI != CUE; ++CUI) {
875 CompileUnit *TheCU = CUI->second;
876 TheCU->constructContainingTypeDIEs();
879 // Compute DIE offsets and sizes.
880 InfoHolder.computeSizeAndOffsets();
882 SkeletonHolder.computeSizeAndOffsets();
885 void DwarfDebug::endSections() {
886 // Standard sections final addresses.
887 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
888 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
889 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
890 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
892 // End text sections.
893 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
894 Asm->OutStreamer.SwitchSection(SectionMap[I]);
895 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
899 // Emit all Dwarf sections that should come after the content.
900 void DwarfDebug::endModule() {
902 if (!FirstCU) return;
904 // End any existing sections.
905 // TODO: Does this need to happen?
908 // Finalize the debug info for the module.
909 finalizeModuleInfo();
911 if (!useSplitDwarf()) {
912 // Emit all the DIEs into a debug info section.
915 // Corresponding abbreviations into a abbrev section.
918 // Emit info into a debug loc section.
921 // Emit info into a debug aranges section.
924 // Emit info into a debug ranges section.
927 // Emit info into a debug macinfo section.
931 // TODO: When we don't need the option anymore we
932 // can remove all of the code that this section
934 if (useDarwinGDBCompat())
935 emitDebugInlineInfo();
937 // TODO: Fill this in for separated debug sections and separate
938 // out information into new sections.
940 // Emit the debug info section and compile units.
944 // Corresponding abbreviations into a abbrev section.
946 emitDebugAbbrevDWO();
948 // Emit info into a debug loc section.
951 // Emit info into a debug aranges section.
954 // Emit info into a debug ranges section.
957 // Emit info into a debug macinfo section.
960 // Emit DWO addresses.
961 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
964 // TODO: When we don't need the option anymore we
965 // can remove all of the code that this section
967 if (useDarwinGDBCompat())
968 emitDebugInlineInfo();
971 // Emit info into the dwarf accelerator table sections.
972 if (useDwarfAccelTables()) {
975 emitAccelNamespaces();
979 // Emit info into a debug pubnames section, if requested.
980 if (GenerateDwarfPubNamesSection)
983 // Emit info into a debug pubtypes section.
984 // TODO: When we don't need the option anymore we can
985 // remove all of the code that adds to the table.
986 if (useDarwinGDBCompat())
989 // Finally emit string information into a string table.
996 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
997 E = CUMap.end(); I != E; ++I)
1000 for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
1001 E = SkeletonCUs.end(); I != E; ++I)
1004 // Reset these for the next Module if we have one.
1008 // Find abstract variable, if any, associated with Var.
1009 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1010 DebugLoc ScopeLoc) {
1011 LLVMContext &Ctx = DV->getContext();
1012 // More then one inlined variable corresponds to one abstract variable.
1013 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1014 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1016 return AbsDbgVariable;
1018 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1022 AbsDbgVariable = new DbgVariable(Var, NULL);
1023 addScopeVariable(Scope, AbsDbgVariable);
1024 AbstractVariables[Var] = AbsDbgVariable;
1025 return AbsDbgVariable;
1028 // If Var is a current function argument then add it to CurrentFnArguments list.
1029 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1030 DbgVariable *Var, LexicalScope *Scope) {
1031 if (!LScopes.isCurrentFunctionScope(Scope))
1033 DIVariable DV = Var->getVariable();
1034 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1036 unsigned ArgNo = DV.getArgNumber();
1040 size_t Size = CurrentFnArguments.size();
1042 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1043 // llvm::Function argument size is not good indicator of how many
1044 // arguments does the function have at source level.
1046 CurrentFnArguments.resize(ArgNo * 2);
1047 CurrentFnArguments[ArgNo - 1] = Var;
1051 // Collect variable information from side table maintained by MMI.
1053 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1054 SmallPtrSet<const MDNode *, 16> &Processed) {
1055 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1056 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1057 VE = VMap.end(); VI != VE; ++VI) {
1058 const MDNode *Var = VI->first;
1060 Processed.insert(Var);
1062 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1064 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1066 // If variable scope is not found then skip this variable.
1070 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1071 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1072 RegVar->setFrameIndex(VP.first);
1073 if (!addCurrentFnArgument(MF, RegVar, Scope))
1074 addScopeVariable(Scope, RegVar);
1076 AbsDbgVariable->setFrameIndex(VP.first);
1080 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1082 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1083 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1084 return MI->getNumOperands() == 3 &&
1085 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1086 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1089 // Get .debug_loc entry for the instruction range starting at MI.
1090 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1091 const MCSymbol *FLabel,
1092 const MCSymbol *SLabel,
1093 const MachineInstr *MI) {
1094 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1096 if (MI->getNumOperands() != 3) {
1097 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1098 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1100 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1101 MachineLocation MLoc;
1102 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1103 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1105 if (MI->getOperand(0).isImm())
1106 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1107 if (MI->getOperand(0).isFPImm())
1108 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1109 if (MI->getOperand(0).isCImm())
1110 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1112 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1115 // Find variables for each lexical scope.
1117 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1118 SmallPtrSet<const MDNode *, 16> &Processed) {
1120 // collection info from MMI table.
1121 collectVariableInfoFromMMITable(MF, Processed);
1123 for (SmallVectorImpl<const MDNode*>::const_iterator
1124 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1126 const MDNode *Var = *UVI;
1127 if (Processed.count(Var))
1130 // History contains relevant DBG_VALUE instructions for Var and instructions
1132 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1133 if (History.empty())
1135 const MachineInstr *MInsn = History.front();
1138 LexicalScope *Scope = NULL;
1139 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1140 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1141 Scope = LScopes.getCurrentFunctionScope();
1142 else if (MDNode *IA = DV.getInlinedAt())
1143 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1145 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1146 // If variable scope is not found then skip this variable.
1150 Processed.insert(DV);
1151 assert(MInsn->isDebugValue() && "History must begin with debug value");
1152 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1153 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1154 if (!addCurrentFnArgument(MF, RegVar, Scope))
1155 addScopeVariable(Scope, RegVar);
1157 AbsVar->setMInsn(MInsn);
1159 // Simplify ranges that are fully coalesced.
1160 if (History.size() <= 1 || (History.size() == 2 &&
1161 MInsn->isIdenticalTo(History.back()))) {
1162 RegVar->setMInsn(MInsn);
1166 // Handle multiple DBG_VALUE instructions describing one variable.
1167 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1169 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1170 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1171 const MachineInstr *Begin = *HI;
1172 assert(Begin->isDebugValue() && "Invalid History entry");
1174 // Check if DBG_VALUE is truncating a range.
1175 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1176 && !Begin->getOperand(0).getReg())
1179 // Compute the range for a register location.
1180 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1181 const MCSymbol *SLabel = 0;
1184 // If Begin is the last instruction in History then its value is valid
1185 // until the end of the function.
1186 SLabel = FunctionEndSym;
1188 const MachineInstr *End = HI[1];
1189 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1190 << "\t" << *Begin << "\t" << *End << "\n");
1191 if (End->isDebugValue())
1192 SLabel = getLabelBeforeInsn(End);
1194 // End is a normal instruction clobbering the range.
1195 SLabel = getLabelAfterInsn(End);
1196 assert(SLabel && "Forgot label after clobber instruction");
1201 // The value is valid until the next DBG_VALUE or clobber.
1202 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1205 DotDebugLocEntries.push_back(DotDebugLocEntry());
1208 // Collect info for variables that were optimized out.
1209 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1210 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1211 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1212 DIVariable DV(Variables.getElement(i));
1213 if (!DV || !DV.Verify() || !Processed.insert(DV))
1215 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1216 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1220 // Return Label preceding the instruction.
1221 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1222 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1223 assert(Label && "Didn't insert label before instruction");
1227 // Return Label immediately following the instruction.
1228 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1229 return LabelsAfterInsn.lookup(MI);
1232 // Process beginning of an instruction.
1233 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1234 // Check if source location changes, but ignore DBG_VALUE locations.
1235 if (!MI->isDebugValue()) {
1236 DebugLoc DL = MI->getDebugLoc();
1237 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1240 if (DL == PrologEndLoc) {
1241 Flags |= DWARF2_FLAG_PROLOGUE_END;
1242 PrologEndLoc = DebugLoc();
1244 if (PrologEndLoc.isUnknown())
1245 Flags |= DWARF2_FLAG_IS_STMT;
1247 if (!DL.isUnknown()) {
1248 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1249 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1251 recordSourceLine(0, 0, 0, 0);
1255 // Insert labels where requested.
1256 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1257 LabelsBeforeInsn.find(MI);
1260 if (I == LabelsBeforeInsn.end())
1263 // Label already assigned.
1268 PrevLabel = MMI->getContext().CreateTempSymbol();
1269 Asm->OutStreamer.EmitLabel(PrevLabel);
1271 I->second = PrevLabel;
1274 // Process end of an instruction.
1275 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1276 // Don't create a new label after DBG_VALUE instructions.
1277 // They don't generate code.
1278 if (!MI->isDebugValue())
1281 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1282 LabelsAfterInsn.find(MI);
1285 if (I == LabelsAfterInsn.end())
1288 // Label already assigned.
1292 // We need a label after this instruction.
1294 PrevLabel = MMI->getContext().CreateTempSymbol();
1295 Asm->OutStreamer.EmitLabel(PrevLabel);
1297 I->second = PrevLabel;
1300 // Each LexicalScope has first instruction and last instruction to mark
1301 // beginning and end of a scope respectively. Create an inverse map that list
1302 // scopes starts (and ends) with an instruction. One instruction may start (or
1303 // end) multiple scopes. Ignore scopes that are not reachable.
1304 void DwarfDebug::identifyScopeMarkers() {
1305 SmallVector<LexicalScope *, 4> WorkList;
1306 WorkList.push_back(LScopes.getCurrentFunctionScope());
1307 while (!WorkList.empty()) {
1308 LexicalScope *S = WorkList.pop_back_val();
1310 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1311 if (!Children.empty())
1312 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1313 SE = Children.end(); SI != SE; ++SI)
1314 WorkList.push_back(*SI);
1316 if (S->isAbstractScope())
1319 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1322 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1323 RE = Ranges.end(); RI != RE; ++RI) {
1324 assert(RI->first && "InsnRange does not have first instruction!");
1325 assert(RI->second && "InsnRange does not have second instruction!");
1326 requestLabelBeforeInsn(RI->first);
1327 requestLabelAfterInsn(RI->second);
1332 // Get MDNode for DebugLoc's scope.
1333 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1334 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1335 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1336 return DL.getScope(Ctx);
1339 // Walk up the scope chain of given debug loc and find line number info
1340 // for the function.
1341 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1342 const MDNode *Scope = getScopeNode(DL, Ctx);
1343 DISubprogram SP = getDISubprogram(Scope);
1345 // Check for number of operands since the compatibility is
1347 if (SP->getNumOperands() > 19)
1348 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1350 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1356 // Gather pre-function debug information. Assumes being called immediately
1357 // after the function entry point has been emitted.
1358 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1359 if (!MMI->hasDebugInfo()) return;
1360 LScopes.initialize(*MF);
1361 if (LScopes.empty()) return;
1362 identifyScopeMarkers();
1364 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1366 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1367 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1368 assert(TheCU && "Unable to find compile unit!");
1369 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
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);
1555 // Set DwarfCompileUnitID in MCContext to default value.
1556 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1558 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1559 collectVariableInfo(MF, ProcessedVars);
1561 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1562 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1563 assert(TheCU && "Unable to find compile unit!");
1565 // Construct abstract scopes.
1566 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1567 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1568 LexicalScope *AScope = AList[i];
1569 DISubprogram SP(AScope->getScopeNode());
1571 // Collect info for variables that were optimized out.
1572 DIArray Variables = SP.getVariables();
1573 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1574 DIVariable DV(Variables.getElement(i));
1575 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1577 // Check that DbgVariable for DV wasn't created earlier, when
1578 // findAbstractVariable() was called for inlined instance of DV.
1579 LLVMContext &Ctx = DV->getContext();
1580 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1581 if (AbstractVariables.lookup(CleanDV))
1583 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1584 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1587 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1588 constructScopeDIE(TheCU, AScope);
1591 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1593 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1594 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1596 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1597 MMI->getFrameMoves()));
1600 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1601 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1602 DeleteContainerPointers(I->second);
1603 ScopeVariables.clear();
1604 DeleteContainerPointers(CurrentFnArguments);
1605 UserVariables.clear();
1607 AbstractVariables.clear();
1608 LabelsBeforeInsn.clear();
1609 LabelsAfterInsn.clear();
1613 // Register a source line with debug info. Returns the unique label that was
1614 // emitted and which provides correspondence to the source line list.
1615 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1621 DIDescriptor Scope(S);
1623 if (Scope.isCompileUnit()) {
1624 DICompileUnit CU(S);
1625 Fn = CU.getFilename();
1626 Dir = CU.getDirectory();
1627 } else if (Scope.isFile()) {
1629 Fn = F.getFilename();
1630 Dir = F.getDirectory();
1631 } else if (Scope.isSubprogram()) {
1633 Fn = SP.getFilename();
1634 Dir = SP.getDirectory();
1635 } else if (Scope.isLexicalBlockFile()) {
1636 DILexicalBlockFile DBF(S);
1637 Fn = DBF.getFilename();
1638 Dir = DBF.getDirectory();
1639 } else if (Scope.isLexicalBlock()) {
1640 DILexicalBlock DB(S);
1641 Fn = DB.getFilename();
1642 Dir = DB.getDirectory();
1644 llvm_unreachable("Unexpected scope info");
1646 Src = getOrCreateSourceID(Fn, Dir,
1647 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1649 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1652 //===----------------------------------------------------------------------===//
1654 //===----------------------------------------------------------------------===//
1656 // Compute the size and offset of a DIE.
1658 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1659 // Get the children.
1660 const std::vector<DIE *> &Children = Die->getChildren();
1662 // Record the abbreviation.
1663 assignAbbrevNumber(Die->getAbbrev());
1665 // Get the abbreviation for this DIE.
1666 unsigned AbbrevNumber = Die->getAbbrevNumber();
1667 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1670 Die->setOffset(Offset);
1672 // Start the size with the size of abbreviation code.
1673 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1675 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1676 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1678 // Size the DIE attribute values.
1679 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1680 // Size attribute value.
1681 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1683 // Size the DIE children if any.
1684 if (!Children.empty()) {
1685 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1686 "Children flag not set");
1688 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1689 Offset = computeSizeAndOffset(Children[j], Offset);
1691 // End of children marker.
1692 Offset += sizeof(int8_t);
1695 Die->setSize(Offset - Die->getOffset());
1699 // Compute the size and offset of all the DIEs.
1700 void DwarfUnits::computeSizeAndOffsets() {
1701 // Offset from the beginning of debug info section.
1702 unsigned AccuOffset = 0;
1703 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1704 E = CUs.end(); I != E; ++I) {
1705 (*I)->setDebugInfoOffset(AccuOffset);
1707 sizeof(int32_t) + // Length of Compilation Unit Info
1708 sizeof(int16_t) + // DWARF version number
1709 sizeof(int32_t) + // Offset Into Abbrev. Section
1710 sizeof(int8_t); // Pointer Size (in bytes)
1712 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1713 AccuOffset += EndOffset;
1717 // Emit initial Dwarf sections with a label at the start of each one.
1718 void DwarfDebug::emitSectionLabels() {
1719 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1721 // Dwarf sections base addresses.
1722 DwarfInfoSectionSym =
1723 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1724 DwarfAbbrevSectionSym =
1725 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1726 if (useSplitDwarf())
1727 DwarfAbbrevDWOSectionSym =
1728 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1729 "section_abbrev_dwo");
1730 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1732 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1733 emitSectionSym(Asm, MacroInfo);
1735 DwarfLineSectionSym =
1736 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1737 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1738 if (GenerateDwarfPubNamesSection)
1739 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1740 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1741 DwarfStrSectionSym =
1742 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1743 if (useSplitDwarf())
1744 DwarfStrDWOSectionSym =
1745 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1746 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1749 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1750 "section_debug_loc");
1752 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1753 emitSectionSym(Asm, TLOF.getDataSection());
1756 // Recursively emits a debug information entry.
1757 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1758 // Get the abbreviation for this DIE.
1759 unsigned AbbrevNumber = Die->getAbbrevNumber();
1760 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1762 // Emit the code (index) for the abbreviation.
1763 if (Asm->isVerbose())
1764 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1765 Twine::utohexstr(Die->getOffset()) + ":0x" +
1766 Twine::utohexstr(Die->getSize()) + " " +
1767 dwarf::TagString(Abbrev->getTag()));
1768 Asm->EmitULEB128(AbbrevNumber);
1770 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1771 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1773 // Emit the DIE attribute values.
1774 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1775 unsigned Attr = AbbrevData[i].getAttribute();
1776 unsigned Form = AbbrevData[i].getForm();
1777 assert(Form && "Too many attributes for DIE (check abbreviation)");
1779 if (Asm->isVerbose())
1780 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1783 case dwarf::DW_AT_abstract_origin: {
1784 DIEEntry *E = cast<DIEEntry>(Values[i]);
1785 DIE *Origin = E->getEntry();
1786 unsigned Addr = Origin->getOffset();
1787 if (Form == dwarf::DW_FORM_ref_addr) {
1788 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1789 // section. Origin->getOffset() returns the offset from start of the
1791 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1792 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1794 // DWARF4: References that use the attribute form DW_FORM_ref_addr are
1795 // specified to be four bytes in the DWARF 32-bit format and eight bytes
1796 // in the DWARF 64-bit format, while DWARF Version 2 specifies that such
1797 // references have the same size as an address on the target system.
1798 // Our current version is version 2.
1799 Asm->OutStreamer.EmitIntValue(Addr,
1800 Form == dwarf::DW_FORM_ref_addr ?
1801 Asm->getDataLayout().getPointerSize() : 4);
1804 case dwarf::DW_AT_ranges: {
1805 // DW_AT_range Value encodes offset in debug_range section.
1806 DIEInteger *V = cast<DIEInteger>(Values[i]);
1808 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1809 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1813 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1815 DwarfDebugRangeSectionSym,
1820 case dwarf::DW_AT_location: {
1821 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1822 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1823 Asm->EmitLabelReference(L->getValue(), 4);
1825 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1827 Values[i]->EmitValue(Asm, Form);
1831 case dwarf::DW_AT_accessibility: {
1832 if (Asm->isVerbose()) {
1833 DIEInteger *V = cast<DIEInteger>(Values[i]);
1834 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1836 Values[i]->EmitValue(Asm, Form);
1840 // Emit an attribute using the defined form.
1841 Values[i]->EmitValue(Asm, Form);
1846 // Emit the DIE children if any.
1847 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1848 const std::vector<DIE *> &Children = Die->getChildren();
1850 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1851 emitDIE(Children[j], Abbrevs);
1853 if (Asm->isVerbose())
1854 Asm->OutStreamer.AddComment("End Of Children Mark");
1859 // Emit the various dwarf units to the unit section USection with
1860 // the abbreviations going into ASection.
1861 void DwarfUnits::emitUnits(DwarfDebug *DD,
1862 const MCSection *USection,
1863 const MCSection *ASection,
1864 const MCSymbol *ASectionSym) {
1865 Asm->OutStreamer.SwitchSection(USection);
1866 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1867 E = CUs.end(); I != E; ++I) {
1868 CompileUnit *TheCU = *I;
1869 DIE *Die = TheCU->getCUDie();
1871 // Emit the compile units header.
1873 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1874 TheCU->getUniqueID()));
1876 // Emit size of content not including length itself
1877 unsigned ContentSize = Die->getSize() +
1878 sizeof(int16_t) + // DWARF version number
1879 sizeof(int32_t) + // Offset Into Abbrev. Section
1880 sizeof(int8_t); // Pointer Size (in bytes)
1882 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1883 Asm->EmitInt32(ContentSize);
1884 Asm->OutStreamer.AddComment("DWARF version number");
1885 Asm->EmitInt16(dwarf::DWARF_VERSION);
1886 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1887 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1889 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1890 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1892 DD->emitDIE(Die, Abbreviations);
1893 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1894 TheCU->getUniqueID()));
1898 /// For a given compile unit DIE, returns offset from beginning of debug info.
1899 unsigned DwarfUnits::getCUOffset(DIE *Die) {
1900 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
1901 "Input DIE should be compile unit in getCUOffset.");
1902 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1903 E = CUs.end(); I != E; ++I) {
1904 CompileUnit *TheCU = *I;
1905 if (TheCU->getCUDie() == Die)
1906 return TheCU->getDebugInfoOffset();
1908 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
1911 // Emit the debug info section.
1912 void DwarfDebug::emitDebugInfo() {
1913 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1915 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
1916 Asm->getObjFileLowering().getDwarfAbbrevSection(),
1917 DwarfAbbrevSectionSym);
1920 // Emit the abbreviation section.
1921 void DwarfDebug::emitAbbreviations() {
1922 if (!useSplitDwarf())
1923 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
1926 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1929 void DwarfDebug::emitAbbrevs(const MCSection *Section,
1930 std::vector<DIEAbbrev *> *Abbrevs) {
1931 // Check to see if it is worth the effort.
1932 if (!Abbrevs->empty()) {
1933 // Start the debug abbrev section.
1934 Asm->OutStreamer.SwitchSection(Section);
1936 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
1937 Asm->OutStreamer.EmitLabel(Begin);
1939 // For each abbrevation.
1940 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
1941 // Get abbreviation data
1942 const DIEAbbrev *Abbrev = Abbrevs->at(i);
1944 // Emit the abbrevations code (base 1 index.)
1945 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1947 // Emit the abbreviations data.
1951 // Mark end of abbreviations.
1952 Asm->EmitULEB128(0, "EOM(3)");
1954 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
1955 Asm->OutStreamer.EmitLabel(End);
1959 // Emit the last address of the section and the end of the line matrix.
1960 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1961 // Define last address of section.
1962 Asm->OutStreamer.AddComment("Extended Op");
1965 Asm->OutStreamer.AddComment("Op size");
1966 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1967 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1968 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1970 Asm->OutStreamer.AddComment("Section end label");
1972 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1973 Asm->getDataLayout().getPointerSize());
1975 // Mark end of matrix.
1976 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1982 // Emit visible names into a hashed accelerator table section.
1983 void DwarfDebug::emitAccelNames() {
1984 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1985 dwarf::DW_FORM_data4));
1986 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1987 E = CUMap.end(); I != E; ++I) {
1988 CompileUnit *TheCU = I->second;
1989 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1990 for (StringMap<std::vector<DIE*> >::const_iterator
1991 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1992 const char *Name = GI->getKeyData();
1993 const std::vector<DIE *> &Entities = GI->second;
1994 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1995 DE = Entities.end(); DI != DE; ++DI)
1996 AT.AddName(Name, (*DI));
2000 AT.FinalizeTable(Asm, "Names");
2001 Asm->OutStreamer.SwitchSection(
2002 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2003 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2004 Asm->OutStreamer.EmitLabel(SectionBegin);
2006 // Emit the full data.
2007 AT.Emit(Asm, SectionBegin, &InfoHolder);
2010 // Emit objective C classes and categories into a hashed accelerator table
2012 void DwarfDebug::emitAccelObjC() {
2013 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2014 dwarf::DW_FORM_data4));
2015 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2016 E = CUMap.end(); I != E; ++I) {
2017 CompileUnit *TheCU = I->second;
2018 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2019 for (StringMap<std::vector<DIE*> >::const_iterator
2020 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2021 const char *Name = GI->getKeyData();
2022 const std::vector<DIE *> &Entities = GI->second;
2023 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2024 DE = Entities.end(); DI != DE; ++DI)
2025 AT.AddName(Name, (*DI));
2029 AT.FinalizeTable(Asm, "ObjC");
2030 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2031 .getDwarfAccelObjCSection());
2032 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2033 Asm->OutStreamer.EmitLabel(SectionBegin);
2035 // Emit the full data.
2036 AT.Emit(Asm, SectionBegin, &InfoHolder);
2039 // Emit namespace dies into a hashed accelerator table.
2040 void DwarfDebug::emitAccelNamespaces() {
2041 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2042 dwarf::DW_FORM_data4));
2043 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2044 E = CUMap.end(); I != E; ++I) {
2045 CompileUnit *TheCU = I->second;
2046 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2047 for (StringMap<std::vector<DIE*> >::const_iterator
2048 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2049 const char *Name = GI->getKeyData();
2050 const std::vector<DIE *> &Entities = GI->second;
2051 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2052 DE = Entities.end(); DI != DE; ++DI)
2053 AT.AddName(Name, (*DI));
2057 AT.FinalizeTable(Asm, "namespac");
2058 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2059 .getDwarfAccelNamespaceSection());
2060 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2061 Asm->OutStreamer.EmitLabel(SectionBegin);
2063 // Emit the full data.
2064 AT.Emit(Asm, SectionBegin, &InfoHolder);
2067 // Emit type dies into a hashed accelerator table.
2068 void DwarfDebug::emitAccelTypes() {
2069 std::vector<DwarfAccelTable::Atom> Atoms;
2070 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2071 dwarf::DW_FORM_data4));
2072 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2073 dwarf::DW_FORM_data2));
2074 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2075 dwarf::DW_FORM_data1));
2076 DwarfAccelTable AT(Atoms);
2077 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2078 E = CUMap.end(); I != E; ++I) {
2079 CompileUnit *TheCU = I->second;
2080 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2081 = TheCU->getAccelTypes();
2082 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2083 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2084 const char *Name = GI->getKeyData();
2085 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2086 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2087 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2088 AT.AddName(Name, (*DI).first, (*DI).second);
2092 AT.FinalizeTable(Asm, "types");
2093 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2094 .getDwarfAccelTypesSection());
2095 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2096 Asm->OutStreamer.EmitLabel(SectionBegin);
2098 // Emit the full data.
2099 AT.Emit(Asm, SectionBegin, &InfoHolder);
2102 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2104 void DwarfDebug::emitDebugPubnames() {
2105 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2107 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2108 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2109 CompileUnit *TheCU = I->second;
2110 unsigned ID = TheCU->getUniqueID();
2112 if (TheCU->getGlobalNames().empty())
2115 // Start the dwarf pubnames section.
2116 Asm->OutStreamer.SwitchSection(
2117 Asm->getObjFileLowering().getDwarfPubNamesSection());
2119 Asm->OutStreamer.AddComment("Length of Public Names Info");
2120 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2121 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2123 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2125 Asm->OutStreamer.AddComment("DWARF Version");
2126 Asm->EmitInt16(dwarf::DWARF_VERSION);
2128 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2129 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2130 DwarfInfoSectionSym);
2132 Asm->OutStreamer.AddComment("Compilation Unit Length");
2133 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2134 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2137 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2138 for (StringMap<DIE*>::const_iterator
2139 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2140 const char *Name = GI->getKeyData();
2141 const DIE *Entity = GI->second;
2143 Asm->OutStreamer.AddComment("DIE offset");
2144 Asm->EmitInt32(Entity->getOffset());
2146 if (Asm->isVerbose())
2147 Asm->OutStreamer.AddComment("External Name");
2148 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2151 Asm->OutStreamer.AddComment("End Mark");
2153 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2157 void DwarfDebug::emitDebugPubTypes() {
2158 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2159 E = CUMap.end(); I != E; ++I) {
2160 CompileUnit *TheCU = I->second;
2161 // Start the dwarf pubtypes section.
2162 Asm->OutStreamer.SwitchSection(
2163 Asm->getObjFileLowering().getDwarfPubTypesSection());
2164 Asm->OutStreamer.AddComment("Length of Public Types Info");
2165 Asm->EmitLabelDifference(
2166 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2167 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2169 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2170 TheCU->getUniqueID()));
2172 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2173 Asm->EmitInt16(dwarf::DWARF_VERSION);
2175 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2176 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2177 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2178 TheCU->getUniqueID()),
2179 DwarfInfoSectionSym);
2181 Asm->OutStreamer.AddComment("Compilation Unit Length");
2182 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2183 TheCU->getUniqueID()),
2184 Asm->GetTempSymbol(ISec->getLabelBeginName(),
2185 TheCU->getUniqueID()),
2188 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2189 for (StringMap<DIE*>::const_iterator
2190 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2191 const char *Name = GI->getKeyData();
2192 DIE *Entity = GI->second;
2194 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2195 Asm->EmitInt32(Entity->getOffset());
2197 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2198 // Emit the name with a terminating null byte.
2199 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2202 Asm->OutStreamer.AddComment("End Mark");
2204 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2205 TheCU->getUniqueID()));
2209 // Emit strings into a string section.
2210 void DwarfUnits::emitStrings(const MCSection *StrSection,
2211 const MCSection *OffsetSection = NULL,
2212 const MCSymbol *StrSecSym = NULL) {
2214 if (StringPool.empty()) return;
2216 // Start the dwarf str section.
2217 Asm->OutStreamer.SwitchSection(StrSection);
2219 // Get all of the string pool entries and put them in an array by their ID so
2220 // we can sort them.
2221 SmallVector<std::pair<unsigned,
2222 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2224 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2225 I = StringPool.begin(), E = StringPool.end();
2227 Entries.push_back(std::make_pair(I->second.second, &*I));
2229 array_pod_sort(Entries.begin(), Entries.end());
2231 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2232 // Emit a label for reference from debug information entries.
2233 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2235 // Emit the string itself with a terminating null byte.
2236 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2237 Entries[i].second->getKeyLength()+1));
2240 // If we've got an offset section go ahead and emit that now as well.
2241 if (OffsetSection) {
2242 Asm->OutStreamer.SwitchSection(OffsetSection);
2243 unsigned offset = 0;
2244 unsigned size = 4; // FIXME: DWARF64 is 8.
2245 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2246 Asm->OutStreamer.EmitIntValue(offset, size);
2247 offset += Entries[i].second->getKeyLength() + 1;
2252 // Emit strings into a string section.
2253 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2255 if (AddressPool.empty()) return;
2257 // Start the dwarf addr section.
2258 Asm->OutStreamer.SwitchSection(AddrSection);
2260 // Get all of the string pool entries and put them in an array by their ID so
2261 // we can sort them.
2262 SmallVector<std::pair<unsigned,
2263 std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2265 for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2266 I = AddressPool.begin(), E = AddressPool.end();
2268 Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2270 array_pod_sort(Entries.begin(), Entries.end());
2272 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2273 // Emit a label for reference from debug information entries.
2274 MCSymbol *Sym = Entries[i].second->first;
2276 Asm->EmitLabelReference(Entries[i].second->first,
2277 Asm->getDataLayout().getPointerSize());
2279 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2284 // Emit visible names into a debug str section.
2285 void DwarfDebug::emitDebugStr() {
2286 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2287 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2290 // Emit visible names into a debug loc section.
2291 void DwarfDebug::emitDebugLoc() {
2292 if (DotDebugLocEntries.empty())
2295 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2296 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2298 DotDebugLocEntry &Entry = *I;
2299 if (I + 1 != DotDebugLocEntries.end())
2303 // Start the dwarf loc section.
2304 Asm->OutStreamer.SwitchSection(
2305 Asm->getObjFileLowering().getDwarfLocSection());
2306 unsigned char Size = Asm->getDataLayout().getPointerSize();
2307 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2309 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2310 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2311 I != E; ++I, ++index) {
2312 DotDebugLocEntry &Entry = *I;
2313 if (Entry.isMerged()) continue;
2314 if (Entry.isEmpty()) {
2315 Asm->OutStreamer.EmitIntValue(0, Size);
2316 Asm->OutStreamer.EmitIntValue(0, Size);
2317 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2319 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2320 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
2321 DIVariable DV(Entry.Variable);
2322 Asm->OutStreamer.AddComment("Loc expr size");
2323 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2324 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2325 Asm->EmitLabelDifference(end, begin, 2);
2326 Asm->OutStreamer.EmitLabel(begin);
2327 if (Entry.isInt()) {
2328 DIBasicType BTy(DV.getType());
2330 (BTy.getEncoding() == dwarf::DW_ATE_signed
2331 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2332 Asm->OutStreamer.AddComment("DW_OP_consts");
2333 Asm->EmitInt8(dwarf::DW_OP_consts);
2334 Asm->EmitSLEB128(Entry.getInt());
2336 Asm->OutStreamer.AddComment("DW_OP_constu");
2337 Asm->EmitInt8(dwarf::DW_OP_constu);
2338 Asm->EmitULEB128(Entry.getInt());
2340 } else if (Entry.isLocation()) {
2341 if (!DV.hasComplexAddress())
2343 Asm->EmitDwarfRegOp(Entry.Loc);
2345 // Complex address entry.
2346 unsigned N = DV.getNumAddrElements();
2348 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2349 if (Entry.Loc.getOffset()) {
2351 Asm->EmitDwarfRegOp(Entry.Loc);
2352 Asm->OutStreamer.AddComment("DW_OP_deref");
2353 Asm->EmitInt8(dwarf::DW_OP_deref);
2354 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2355 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2356 Asm->EmitSLEB128(DV.getAddrElement(1));
2358 // If first address element is OpPlus then emit
2359 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2360 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2361 Asm->EmitDwarfRegOp(Loc);
2365 Asm->EmitDwarfRegOp(Entry.Loc);
2368 // Emit remaining complex address elements.
2369 for (; i < N; ++i) {
2370 uint64_t Element = DV.getAddrElement(i);
2371 if (Element == DIBuilder::OpPlus) {
2372 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2373 Asm->EmitULEB128(DV.getAddrElement(++i));
2374 } else if (Element == DIBuilder::OpDeref) {
2375 if (!Entry.Loc.isReg())
2376 Asm->EmitInt8(dwarf::DW_OP_deref);
2378 llvm_unreachable("unknown Opcode found in complex address");
2382 // else ... ignore constant fp. There is not any good way to
2383 // to represent them here in dwarf.
2384 Asm->OutStreamer.EmitLabel(end);
2389 // Emit visible names into a debug aranges section.
2390 void DwarfDebug::emitDebugARanges() {
2391 // Start the dwarf aranges section.
2392 Asm->OutStreamer.SwitchSection(
2393 Asm->getObjFileLowering().getDwarfARangesSection());
2396 // Emit visible names into a debug ranges section.
2397 void DwarfDebug::emitDebugRanges() {
2398 // Start the dwarf ranges section.
2399 Asm->OutStreamer.SwitchSection(
2400 Asm->getObjFileLowering().getDwarfRangesSection());
2401 unsigned char Size = Asm->getDataLayout().getPointerSize();
2402 for (SmallVectorImpl<const MCSymbol *>::iterator
2403 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2406 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2408 Asm->OutStreamer.EmitIntValue(0, Size);
2412 // Emit visible names into a debug macinfo section.
2413 void DwarfDebug::emitDebugMacInfo() {
2414 if (const MCSection *LineInfo =
2415 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2416 // Start the dwarf macinfo section.
2417 Asm->OutStreamer.SwitchSection(LineInfo);
2421 // Emit inline info using following format.
2423 // 1. length of section
2424 // 2. Dwarf version number
2427 // Entries (one "entry" for each function that was inlined):
2429 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2430 // otherwise offset into __debug_str for regular function name.
2431 // 2. offset into __debug_str section for regular function name.
2432 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2433 // instances for the function.
2435 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2436 // inlined instance; the die_offset points to the inlined_subroutine die in the
2437 // __debug_info section, and the low_pc is the starting address for the
2438 // inlining instance.
2439 void DwarfDebug::emitDebugInlineInfo() {
2440 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2446 Asm->OutStreamer.SwitchSection(
2447 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2449 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2450 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2451 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2453 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2455 Asm->OutStreamer.AddComment("Dwarf Version");
2456 Asm->EmitInt16(dwarf::DWARF_VERSION);
2457 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2458 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2460 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2461 E = InlinedSPNodes.end(); I != E; ++I) {
2463 const MDNode *Node = *I;
2464 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2465 = InlineInfo.find(Node);
2466 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2467 DISubprogram SP(Node);
2468 StringRef LName = SP.getLinkageName();
2469 StringRef Name = SP.getName();
2471 Asm->OutStreamer.AddComment("MIPS linkage name");
2473 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2474 DwarfStrSectionSym);
2476 Asm->EmitSectionOffset(InfoHolder
2477 .getStringPoolEntry(getRealLinkageName(LName)),
2478 DwarfStrSectionSym);
2480 Asm->OutStreamer.AddComment("Function name");
2481 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2482 DwarfStrSectionSym);
2483 Asm->EmitULEB128(Labels.size(), "Inline count");
2485 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2486 LE = Labels.end(); LI != LE; ++LI) {
2487 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2488 Asm->EmitInt32(LI->second->getOffset());
2490 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2491 Asm->OutStreamer.EmitSymbolValue(LI->first,
2492 Asm->getDataLayout().getPointerSize());
2496 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2499 // DWARF5 Experimental Separate Dwarf emitters.
2501 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2502 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2503 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2504 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2505 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2506 DICompileUnit DIUnit(N);
2507 CompilationDir = DIUnit.getDirectory();
2509 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2510 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2511 DIUnit.getLanguage(), Die, Asm,
2512 this, &SkeletonHolder);
2514 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2515 DIUnit.getSplitDebugFilename());
2517 // This should be a unique identifier when we want to build .dwp files.
2518 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2520 // FIXME: The addr base should be relative for each compile unit, however,
2521 // this one is going to be 0 anyhow.
2522 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset, 0);
2524 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2525 // into an entity. We're using 0, or a NULL label for this.
2526 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2528 // DW_AT_stmt_list is a offset of line number information for this
2529 // compile unit in debug_line section.
2530 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2531 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2532 DwarfLineSectionSym);
2534 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2536 if (!CompilationDir.empty())
2537 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2539 SkeletonHolder.addUnit(NewCU);
2540 SkeletonCUs.push_back(NewCU);
2545 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2546 assert(useSplitDwarf() && "No split dwarf debug info?");
2547 emitAbbrevs(Section, &SkeletonAbbrevs);
2550 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2551 // compile units that would normally be in debug_info.
2552 void DwarfDebug::emitDebugInfoDWO() {
2553 assert(useSplitDwarf() && "No split dwarf debug info?");
2554 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2555 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2556 DwarfAbbrevDWOSectionSym);
2559 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2560 // abbreviations for the .debug_info.dwo section.
2561 void DwarfDebug::emitDebugAbbrevDWO() {
2562 assert(useSplitDwarf() && "No split dwarf?");
2563 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2567 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2568 // string section and is identical in format to traditional .debug_str
2570 void DwarfDebug::emitDebugStrDWO() {
2571 assert(useSplitDwarf() && "No split dwarf?");
2572 const MCSection *OffSec = Asm->getObjFileLowering()
2573 .getDwarfStrOffDWOSection();
2574 const MCSymbol *StrSym = DwarfStrSectionSym;
2575 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),