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/Constants.h"
20 #include "llvm/Module.h"
21 #include "llvm/Instructions.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/MC/MCAsmInfo.h"
26 #include "llvm/MC/MCSection.h"
27 #include "llvm/MC/MCStreamer.h"
28 #include "llvm/MC/MCSymbol.h"
29 #include "llvm/Target/TargetData.h"
30 #include "llvm/Target/TargetFrameLowering.h"
31 #include "llvm/Target/TargetLoweringObjectFile.h"
32 #include "llvm/Target/TargetMachine.h"
33 #include "llvm/Target/TargetRegisterInfo.h"
34 #include "llvm/Target/TargetOptions.h"
35 #include "llvm/Analysis/DebugInfo.h"
36 #include "llvm/Analysis/DIBuilder.h"
37 #include "llvm/ADT/Statistic.h"
38 #include "llvm/ADT/STLExtras.h"
39 #include "llvm/ADT/StringExtras.h"
40 #include "llvm/Support/CommandLine.h"
41 #include "llvm/Support/Debug.h"
42 #include "llvm/Support/ErrorHandling.h"
43 #include "llvm/Support/ValueHandle.h"
44 #include "llvm/Support/FormattedStream.h"
45 #include "llvm/Support/Timer.h"
46 #include "llvm/Support/Path.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> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
58 cl::desc("Output prototype dwarf accelerator tables."),
62 const char *DWARFGroupName = "DWARF Emission";
63 const char *DbgTimerName = "DWARF Debug Writer";
64 } // end anonymous namespace
66 //===----------------------------------------------------------------------===//
68 /// Configuration values for initial hash set sizes (log2).
70 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
74 DIType DbgVariable::getType() const {
75 DIType Ty = Var.getType();
76 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
78 if (Var.isBlockByrefVariable()) {
79 /* Byref variables, in Blocks, are declared by the programmer as
80 "SomeType VarName;", but the compiler creates a
81 __Block_byref_x_VarName struct, and gives the variable VarName
82 either the struct, or a pointer to the struct, as its type. This
83 is necessary for various behind-the-scenes things the compiler
84 needs to do with by-reference variables in blocks.
86 However, as far as the original *programmer* is concerned, the
87 variable should still have type 'SomeType', as originally declared.
89 The following function dives into the __Block_byref_x_VarName
90 struct to find the original type of the variable. This will be
91 passed back to the code generating the type for the Debug
92 Information Entry for the variable 'VarName'. 'VarName' will then
93 have the original type 'SomeType' in its debug information.
95 The original type 'SomeType' will be the type of the field named
96 'VarName' inside the __Block_byref_x_VarName struct.
98 NOTE: In order for this to not completely fail on the debugger
99 side, the Debug Information Entry for the variable VarName needs to
100 have a DW_AT_location that tells the debugger how to unwind through
101 the pointers and __Block_byref_x_VarName struct to find the actual
102 value of the variable. The function addBlockByrefType does this. */
104 unsigned tag = Ty.getTag();
106 if (tag == dwarf::DW_TAG_pointer_type) {
107 DIDerivedType DTy = DIDerivedType(Ty);
108 subType = DTy.getTypeDerivedFrom();
111 DICompositeType blockStruct = DICompositeType(subType);
112 DIArray Elements = blockStruct.getTypeArray();
114 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
115 DIDescriptor Element = Elements.getElement(i);
116 DIDerivedType DT = DIDerivedType(Element);
117 if (getName() == DT.getName())
118 return (DT.getTypeDerivedFrom());
124 } // end llvm namespace
126 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
127 : Asm(A), MMI(Asm->MMI), FirstCU(0),
128 AbbreviationsSet(InitAbbreviationsSetSize),
130 NextStringPoolNumber = 0;
132 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
133 DwarfStrSectionSym = TextSectionSym = 0;
134 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
135 FunctionBeginSym = FunctionEndSym = 0;
137 // Turn on accelerator tables for Darwin.
138 if (Triple(M->getTargetTriple()).isOSDarwin())
139 DwarfAccelTables = true;
142 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
146 DwarfDebug::~DwarfDebug() {
149 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
150 /// temporary label to it if SymbolStem is specified.
151 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
152 const char *SymbolStem = 0) {
153 Asm->OutStreamer.SwitchSection(Section);
154 if (!SymbolStem) return 0;
156 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
157 Asm->OutStreamer.EmitLabel(TmpSym);
161 MCSymbol *DwarfDebug::getStringPool() {
162 return Asm->GetTempSymbol("section_str");
165 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
166 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
167 if (Entry.first) return Entry.first;
169 Entry.second = NextStringPoolNumber++;
170 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
173 /// assignAbbrevNumber - Define a unique number for the abbreviation.
175 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
176 // Profile the node so that we can make it unique.
180 // Check the set for priors.
181 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
183 // If it's newly added.
184 if (InSet == &Abbrev) {
185 // Add to abbreviation list.
186 Abbreviations.push_back(&Abbrev);
188 // Assign the vector position + 1 as its number.
189 Abbrev.setNumber(Abbreviations.size());
191 // Assign existing abbreviation number.
192 Abbrev.setNumber(InSet->getNumber());
196 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
197 /// printer to not emit usual symbol prefix before the symbol name is used then
198 /// return linkage name after skipping this special LLVM prefix.
199 static StringRef getRealLinkageName(StringRef LinkageName) {
201 if (LinkageName.startswith(StringRef(&One, 1)))
202 return LinkageName.substr(1);
206 static bool isObjCClass(StringRef Name) {
207 return Name.startswith("+") || Name.startswith("-");
210 static bool hasObjCCategory(StringRef Name) {
211 if (!isObjCClass(Name)) return false;
213 size_t pos = Name.find(')');
214 if (pos != std::string::npos) {
215 if (Name[pos+1] != ' ') return false;
221 static void getObjCClassCategory(StringRef In, StringRef &Class,
222 StringRef &Category) {
223 if (!hasObjCCategory(In)) {
224 Class = In.slice(In.find('[') + 1, In.find(' '));
229 Class = In.slice(In.find('[') + 1, In.find('('));
230 Category = In.slice(In.find('[') + 1, In.find(' '));
234 static StringRef getObjCMethodName(StringRef In) {
235 return In.slice(In.find(' ') + 1, In.find(']'));
238 // Add the various names to the Dwarf accelerator table names.
239 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
241 if (!SP.isDefinition()) return;
243 TheCU->addAccelName(SP.getName(), Die);
245 // If the linkage name is different than the name, go ahead and output
246 // that as well into the name table.
247 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
248 TheCU->addAccelName(SP.getLinkageName(), Die);
250 // If this is an Objective-C selector name add it to the ObjC accelerator
252 if (isObjCClass(SP.getName())) {
253 StringRef Class, Category;
254 getObjCClassCategory(SP.getName(), Class, Category);
255 TheCU->addAccelObjC(Class, Die);
257 TheCU->addAccelObjC(Category, Die);
258 // Also add the base method name to the name table.
259 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
263 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
264 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
265 /// If there are global variables in this scope then create and insert
266 /// DIEs for these variables.
267 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
268 const MDNode *SPNode) {
269 DIE *SPDie = SPCU->getDIE(SPNode);
271 assert(SPDie && "Unable to find subprogram DIE!");
272 DISubprogram SP(SPNode);
274 DISubprogram SPDecl = SP.getFunctionDeclaration();
275 if (!SPDecl.isSubprogram()) {
276 // There is not any need to generate specification DIE for a function
277 // defined at compile unit level. If a function is defined inside another
278 // function then gdb prefers the definition at top level and but does not
279 // expect specification DIE in parent function. So avoid creating
280 // specification DIE for a function defined inside a function.
281 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
282 !SP.getContext().isFile() &&
283 !isSubprogramContext(SP.getContext())) {
284 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
287 DICompositeType SPTy = SP.getType();
288 DIArray Args = SPTy.getTypeArray();
289 unsigned SPTag = SPTy.getTag();
290 if (SPTag == dwarf::DW_TAG_subroutine_type)
291 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
292 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
293 DIType ATy = DIType(DIType(Args.getElement(i)));
294 SPCU->addType(Arg, ATy);
295 if (ATy.isArtificial())
296 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
297 SPDie->addChild(Arg);
299 DIE *SPDeclDie = SPDie;
300 SPDie = new DIE(dwarf::DW_TAG_subprogram);
301 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
306 // Pick up abstract subprogram DIE.
307 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
308 SPDie = new DIE(dwarf::DW_TAG_subprogram);
309 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
310 dwarf::DW_FORM_ref4, AbsSPDIE);
314 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
315 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
316 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
317 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
318 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
319 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
320 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
322 // Add name to the name table, we do this here because we're guaranteed
323 // to have concrete versions of our DW_TAG_subprogram nodes.
324 addSubprogramNames(SPCU, SP, SPDie);
329 /// constructLexicalScope - Construct new DW_TAG_lexical_block
330 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
331 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
332 LexicalScope *Scope) {
333 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
334 if (Scope->isAbstractScope())
337 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
341 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
342 if (Ranges.size() > 1) {
343 // .debug_range section has not been laid out yet. Emit offset in
344 // .debug_range as a uint, size 4, for now. emitDIE will handle
345 // DW_AT_ranges appropriately.
346 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
347 DebugRangeSymbols.size()
348 * Asm->getTargetData().getPointerSize());
349 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
350 RE = Ranges.end(); RI != RE; ++RI) {
351 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
352 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
354 DebugRangeSymbols.push_back(NULL);
355 DebugRangeSymbols.push_back(NULL);
359 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
360 const MCSymbol *End = getLabelAfterInsn(RI->second);
362 if (End == 0) return 0;
364 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
365 assert(End->isDefined() && "Invalid end label for an inlined scope!");
367 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
368 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
373 /// constructInlinedScopeDIE - This scope represents inlined body of
374 /// a function. Construct DIE to represent this concrete inlined copy
376 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
377 LexicalScope *Scope) {
378 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
379 assert(Ranges.empty() == false &&
380 "LexicalScope does not have instruction markers!");
382 if (!Scope->getScopeNode())
384 DIScope DS(Scope->getScopeNode());
385 DISubprogram InlinedSP = getDISubprogram(DS);
386 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
388 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
392 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
393 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
394 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
396 if (StartLabel == 0 || EndLabel == 0) {
397 llvm_unreachable("Unexpected Start and End labels for a inlined scope!");
399 assert(StartLabel->isDefined() &&
400 "Invalid starting label for an inlined scope!");
401 assert(EndLabel->isDefined() &&
402 "Invalid end label for an inlined scope!");
404 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
405 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
406 dwarf::DW_FORM_ref4, OriginDIE);
408 if (Ranges.size() > 1) {
409 // .debug_range section has not been laid out yet. Emit offset in
410 // .debug_range as a uint, size 4, for now. emitDIE will handle
411 // DW_AT_ranges appropriately.
412 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
413 DebugRangeSymbols.size()
414 * Asm->getTargetData().getPointerSize());
415 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
416 RE = Ranges.end(); RI != RE; ++RI) {
417 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
418 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
420 DebugRangeSymbols.push_back(NULL);
421 DebugRangeSymbols.push_back(NULL);
423 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
425 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
429 InlinedSubprogramDIEs.insert(OriginDIE);
431 // Track the start label for this inlined function.
432 //.debug_inlined section specification does not clearly state how
433 // to emit inlined scope that is split into multiple instruction ranges.
434 // For now, use first instruction range and emit low_pc/high_pc pair and
435 // corresponding .debug_inlined section entry for this pair.
436 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
437 I = InlineInfo.find(InlinedSP);
439 if (I == InlineInfo.end()) {
440 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
441 InlinedSPNodes.push_back(InlinedSP);
443 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
445 DILocation DL(Scope->getInlinedAt());
446 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
447 GetOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
448 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
450 // Add name to the name table, we do this here because we're guaranteed
451 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
452 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
457 /// constructScopeDIE - Construct a DIE for this scope.
458 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
459 if (!Scope || !Scope->getScopeNode())
462 SmallVector<DIE *, 8> Children;
464 // Collect arguments for current function.
465 if (LScopes.isCurrentFunctionScope(Scope))
466 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
467 if (DbgVariable *ArgDV = CurrentFnArguments[i])
469 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
470 Children.push_back(Arg);
472 // Collect lexical scope children first.
473 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
474 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
476 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
477 Children.push_back(Variable);
478 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
479 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
480 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
481 Children.push_back(Nested);
482 DIScope DS(Scope->getScopeNode());
483 DIE *ScopeDIE = NULL;
484 if (Scope->getInlinedAt())
485 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
486 else if (DS.isSubprogram()) {
487 ProcessedSPNodes.insert(DS);
488 if (Scope->isAbstractScope()) {
489 ScopeDIE = TheCU->getDIE(DS);
490 // Note down abstract DIE.
492 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
495 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
498 // There is no need to emit empty lexical block DIE.
499 if (Children.empty())
501 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
504 if (!ScopeDIE) return NULL;
507 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
508 E = Children.end(); I != E; ++I)
509 ScopeDIE->addChild(*I);
511 if (DS.isSubprogram())
512 TheCU->addPubTypes(DISubprogram(DS));
517 /// GetOrCreateSourceID - Look up the source id with the given directory and
518 /// source file names. If none currently exists, create a new id and insert it
519 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
521 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
523 // If FE did not provide a file name, then assume stdin.
524 if (FileName.empty())
525 return GetOrCreateSourceID("<stdin>", StringRef());
527 // TODO: this might not belong here. See if we can factor this better.
528 if (DirName == CompilationDir)
531 unsigned SrcId = SourceIdMap.size()+1;
533 // We look up the file/dir pair by concatenating them with a zero byte.
534 SmallString<128> NamePair;
536 NamePair += '\0'; // Zero bytes are not allowed in paths.
537 NamePair += FileName;
539 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
540 if (Ent.getValue() != SrcId)
541 return Ent.getValue();
543 // Print out a .file directive to specify files for .loc directives.
544 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
549 /// constructCompileUnit - Create new CompileUnit for the given
550 /// metadata node with tag DW_TAG_compile_unit.
551 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
552 DICompileUnit DIUnit(N);
553 StringRef FN = DIUnit.getFilename();
554 CompilationDir = DIUnit.getDirectory();
555 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
557 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
558 CompileUnit *NewCU = new CompileUnit(ID, DIUnit.getLanguage(), Die, Asm, this);
559 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
560 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
561 DIUnit.getLanguage());
562 NewCU->addString(Die, dwarf::DW_AT_name, FN);
563 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
565 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
566 // DW_AT_stmt_list is a offset of line number information for this
567 // compile unit in debug_line section.
568 if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
569 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
570 Asm->GetTempSymbol("section_line"));
572 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
574 if (!CompilationDir.empty())
575 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
576 if (DIUnit.isOptimized())
577 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
579 StringRef Flags = DIUnit.getFlags();
581 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
583 if (unsigned RVer = DIUnit.getRunTimeVersion())
584 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
585 dwarf::DW_FORM_data1, RVer);
589 CUMap.insert(std::make_pair(N, NewCU));
593 /// construct SubprogramDIE - Construct subprogram DIE.
594 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
596 CompileUnit *&CURef = SPMap[N];
602 if (!SP.isDefinition())
603 // This is a method declaration which will be handled while constructing
607 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
610 TheCU->insertDIE(N, SubprogramDie);
612 // Add to context owner.
613 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
618 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
619 /// as llvm.dbg.enum and llvm.dbg.ty
620 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
621 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
622 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
623 const MDNode *N = NMD->getOperand(i);
624 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
625 constructSubprogramDIE(CU, N);
628 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
629 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
630 const MDNode *N = NMD->getOperand(i);
631 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
632 CU->createGlobalVariableDIE(N);
635 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
636 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
637 DIType Ty(NMD->getOperand(i));
638 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
639 CU->getOrCreateTypeDIE(Ty);
642 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
643 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
644 DIType Ty(NMD->getOperand(i));
645 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
646 CU->getOrCreateTypeDIE(Ty);
650 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
651 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
652 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
653 DebugInfoFinder DbgFinder;
654 DbgFinder.processModule(*M);
656 bool HasDebugInfo = false;
657 // Scan all the compile-units to see if there are any marked as the main
658 // unit. If not, we do not generate debug info.
659 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
660 E = DbgFinder.compile_unit_end(); I != E; ++I) {
661 if (DICompileUnit(*I).isMain()) {
666 if (!HasDebugInfo) return false;
668 // Create all the compile unit DIEs.
669 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
670 E = DbgFinder.compile_unit_end(); I != E; ++I)
671 constructCompileUnit(*I);
673 // Create DIEs for each global variable.
674 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
675 E = DbgFinder.global_variable_end(); I != E; ++I) {
676 const MDNode *N = *I;
677 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
678 CU->createGlobalVariableDIE(N);
681 // Create DIEs for each subprogram.
682 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
683 E = DbgFinder.subprogram_end(); I != E; ++I) {
684 const MDNode *N = *I;
685 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
686 constructSubprogramDIE(CU, N);
692 /// beginModule - Emit all Dwarf sections that should come prior to the
693 /// content. Create global DIEs and emit initial debug info sections.
694 /// This is invoked by the target AsmPrinter.
695 void DwarfDebug::beginModule(Module *M) {
696 if (DisableDebugInfoPrinting)
699 // If module has named metadata anchors then use them, otherwise scan the
700 // module using debug info finder to collect debug info.
701 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
703 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
704 DICompileUnit CUNode(CU_Nodes->getOperand(i));
705 CompileUnit *CU = constructCompileUnit(CUNode);
706 DIArray GVs = CUNode.getGlobalVariables();
707 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
708 CU->createGlobalVariableDIE(GVs.getElement(i));
709 DIArray SPs = CUNode.getSubprograms();
710 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
711 constructSubprogramDIE(CU, SPs.getElement(i));
712 DIArray EnumTypes = CUNode.getEnumTypes();
713 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
714 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
715 DIArray RetainedTypes = CUNode.getRetainedTypes();
716 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
717 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
719 } else if (!collectLegacyDebugInfo(M))
722 collectInfoFromNamedMDNodes(M);
724 // Tell MMI that we have debug info.
725 MMI->setDebugInfoAvailability(true);
727 // Emit initial sections.
730 // Prime section data.
731 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
734 /// endModule - Emit all Dwarf sections that should come after the content.
736 void DwarfDebug::endModule() {
737 if (!FirstCU) return;
738 const Module *M = MMI->getModule();
739 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
741 // Collect info for variables that were optimized out.
742 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
743 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
744 DICompileUnit TheCU(CU_Nodes->getOperand(i));
745 DIArray Subprograms = TheCU.getSubprograms();
746 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
747 DISubprogram SP(Subprograms.getElement(i));
748 if (ProcessedSPNodes.count(SP) != 0) continue;
749 if (!SP.Verify()) continue;
750 if (!SP.isDefinition()) continue;
751 DIArray Variables = SP.getVariables();
752 if (Variables.getNumElements() == 0) continue;
754 LexicalScope *Scope =
755 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
756 DeadFnScopeMap[SP] = Scope;
758 // Construct subprogram DIE and add variables DIEs.
759 CompileUnit *SPCU = CUMap.lookup(TheCU);
760 assert(SPCU && "Unable to find Compile Unit!");
761 constructSubprogramDIE(SPCU, SP);
762 DIE *ScopeDIE = SPCU->getDIE(SP);
763 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
764 DIVariable DV(Variables.getElement(vi));
765 if (!DV.Verify()) continue;
766 DbgVariable *NewVar = new DbgVariable(DV, NULL);
767 if (DIE *VariableDIE =
768 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
769 ScopeDIE->addChild(VariableDIE);
775 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
776 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
777 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
779 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
781 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
782 AE = AbstractSPDies.end(); AI != AE; ++AI) {
783 DIE *ISP = AI->second;
784 if (InlinedSubprogramDIEs.count(ISP))
786 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
789 // Emit DW_AT_containing_type attribute to connect types with their
790 // vtable holding type.
791 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
792 CUE = CUMap.end(); CUI != CUE; ++CUI) {
793 CompileUnit *TheCU = CUI->second;
794 TheCU->constructContainingTypeDIEs();
797 // Standard sections final addresses.
798 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
799 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
800 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
801 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
803 // End text sections.
804 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
805 Asm->OutStreamer.SwitchSection(SectionMap[i]);
806 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
809 // Compute DIE offsets and sizes.
810 computeSizeAndOffsets();
812 // Emit all the DIEs into a debug info section
815 // Corresponding abbreviations into a abbrev section.
818 // Emit info into a dwarf accelerator table sections.
819 if (DwarfAccelTables) {
822 emitAccelNamespaces();
826 // Emit info into a debug pubtypes section.
829 // Emit info into a debug loc section.
832 // Emit info into a debug aranges section.
835 // Emit info into a debug ranges section.
838 // Emit info into a debug macinfo section.
842 emitDebugInlineInfo();
844 // Emit info into a debug str section.
848 DeleteContainerSeconds(DeadFnScopeMap);
850 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
851 E = CUMap.end(); I != E; ++I)
853 FirstCU = NULL; // Reset for the next Module, if any.
856 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
857 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
859 LLVMContext &Ctx = DV->getContext();
860 // More then one inlined variable corresponds to one abstract variable.
861 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
862 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
864 return AbsDbgVariable;
866 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
870 AbsDbgVariable = new DbgVariable(Var, NULL);
871 addScopeVariable(Scope, AbsDbgVariable);
872 AbstractVariables[Var] = AbsDbgVariable;
873 return AbsDbgVariable;
876 /// addCurrentFnArgument - If Var is a current function argument then add
877 /// it to CurrentFnArguments list.
878 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
879 DbgVariable *Var, LexicalScope *Scope) {
880 if (!LScopes.isCurrentFunctionScope(Scope))
882 DIVariable DV = Var->getVariable();
883 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
885 unsigned ArgNo = DV.getArgNumber();
889 size_t Size = CurrentFnArguments.size();
891 CurrentFnArguments.resize(MF->getFunction()->arg_size());
892 // llvm::Function argument size is not good indicator of how many
893 // arguments does the function have at source level.
895 CurrentFnArguments.resize(ArgNo * 2);
896 CurrentFnArguments[ArgNo - 1] = Var;
900 /// collectVariableInfoFromMMITable - Collect variable information from
901 /// side table maintained by MMI.
903 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
904 SmallPtrSet<const MDNode *, 16> &Processed) {
905 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
906 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
907 VE = VMap.end(); VI != VE; ++VI) {
908 const MDNode *Var = VI->first;
910 Processed.insert(Var);
912 const std::pair<unsigned, DebugLoc> &VP = VI->second;
914 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
916 // If variable scope is not found then skip this variable.
920 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
921 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
922 RegVar->setFrameIndex(VP.first);
923 if (!addCurrentFnArgument(MF, RegVar, Scope))
924 addScopeVariable(Scope, RegVar);
926 AbsDbgVariable->setFrameIndex(VP.first);
930 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
931 /// DBG_VALUE instruction, is in a defined reg.
932 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
933 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
934 return MI->getNumOperands() == 3 &&
935 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
936 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
939 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
941 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
942 const MCSymbol *FLabel,
943 const MCSymbol *SLabel,
944 const MachineInstr *MI) {
945 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
947 if (MI->getNumOperands() != 3) {
948 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
949 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
951 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
952 MachineLocation MLoc;
953 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
954 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
956 if (MI->getOperand(0).isImm())
957 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
958 if (MI->getOperand(0).isFPImm())
959 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
960 if (MI->getOperand(0).isCImm())
961 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
963 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
966 /// collectVariableInfo - Find variables for each lexical scope.
968 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
969 SmallPtrSet<const MDNode *, 16> &Processed) {
971 /// collection info from MMI table.
972 collectVariableInfoFromMMITable(MF, Processed);
974 for (SmallVectorImpl<const MDNode*>::const_iterator
975 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
977 const MDNode *Var = *UVI;
978 if (Processed.count(Var))
981 // History contains relevant DBG_VALUE instructions for Var and instructions
983 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
986 const MachineInstr *MInsn = History.front();
989 LexicalScope *Scope = NULL;
990 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
991 DISubprogram(DV.getContext()).describes(MF->getFunction()))
992 Scope = LScopes.getCurrentFunctionScope();
994 if (DV.getVersion() <= LLVMDebugVersion9)
995 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
997 if (MDNode *IA = DV.getInlinedAt())
998 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1000 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1003 // If variable scope is not found then skip this variable.
1007 Processed.insert(DV);
1008 assert(MInsn->isDebugValue() && "History must begin with debug value");
1009 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1010 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1011 if (!addCurrentFnArgument(MF, RegVar, Scope))
1012 addScopeVariable(Scope, RegVar);
1014 AbsVar->setMInsn(MInsn);
1016 // Simple ranges that are fully coalesced.
1017 if (History.size() <= 1 || (History.size() == 2 &&
1018 MInsn->isIdenticalTo(History.back()))) {
1019 RegVar->setMInsn(MInsn);
1023 // handle multiple DBG_VALUE instructions describing one variable.
1024 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1026 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1027 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1028 const MachineInstr *Begin = *HI;
1029 assert(Begin->isDebugValue() && "Invalid History entry");
1031 // Check if DBG_VALUE is truncating a range.
1032 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1033 && !Begin->getOperand(0).getReg())
1036 // Compute the range for a register location.
1037 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1038 const MCSymbol *SLabel = 0;
1041 // If Begin is the last instruction in History then its value is valid
1042 // until the end of the function.
1043 SLabel = FunctionEndSym;
1045 const MachineInstr *End = HI[1];
1046 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1047 << "\t" << *Begin << "\t" << *End << "\n");
1048 if (End->isDebugValue())
1049 SLabel = getLabelBeforeInsn(End);
1051 // End is a normal instruction clobbering the range.
1052 SLabel = getLabelAfterInsn(End);
1053 assert(SLabel && "Forgot label after clobber instruction");
1058 // The value is valid until the next DBG_VALUE or clobber.
1059 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1062 DotDebugLocEntries.push_back(DotDebugLocEntry());
1065 // Collect info for variables that were optimized out.
1066 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1067 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1068 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1069 DIVariable DV(Variables.getElement(i));
1070 if (!DV || !DV.Verify() || !Processed.insert(DV))
1072 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1073 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1077 /// getLabelBeforeInsn - Return Label preceding the instruction.
1078 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1079 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1080 assert(Label && "Didn't insert label before instruction");
1084 /// getLabelAfterInsn - Return Label immediately following the instruction.
1085 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1086 return LabelsAfterInsn.lookup(MI);
1089 /// beginInstruction - Process beginning of an instruction.
1090 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1091 // Check if source location changes, but ignore DBG_VALUE locations.
1092 if (!MI->isDebugValue()) {
1093 DebugLoc DL = MI->getDebugLoc();
1094 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1097 if (DL == PrologEndLoc) {
1098 Flags |= DWARF2_FLAG_PROLOGUE_END;
1099 PrologEndLoc = DebugLoc();
1101 if (PrologEndLoc.isUnknown())
1102 Flags |= DWARF2_FLAG_IS_STMT;
1104 if (!DL.isUnknown()) {
1105 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1106 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1108 recordSourceLine(0, 0, 0, 0);
1112 // Insert labels where requested.
1113 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1114 LabelsBeforeInsn.find(MI);
1117 if (I == LabelsBeforeInsn.end())
1120 // Label already assigned.
1125 PrevLabel = MMI->getContext().CreateTempSymbol();
1126 Asm->OutStreamer.EmitLabel(PrevLabel);
1128 I->second = PrevLabel;
1131 /// endInstruction - Process end of an instruction.
1132 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1133 // Don't create a new label after DBG_VALUE instructions.
1134 // They don't generate code.
1135 if (!MI->isDebugValue())
1138 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1139 LabelsAfterInsn.find(MI);
1142 if (I == LabelsAfterInsn.end())
1145 // Label already assigned.
1149 // We need a label after this instruction.
1151 PrevLabel = MMI->getContext().CreateTempSymbol();
1152 Asm->OutStreamer.EmitLabel(PrevLabel);
1154 I->second = PrevLabel;
1157 /// identifyScopeMarkers() -
1158 /// Each LexicalScope has first instruction and last instruction to mark
1159 /// beginning and end of a scope respectively. Create an inverse map that list
1160 /// scopes starts (and ends) with an instruction. One instruction may start (or
1161 /// end) multiple scopes. Ignore scopes that are not reachable.
1162 void DwarfDebug::identifyScopeMarkers() {
1163 SmallVector<LexicalScope *, 4> WorkList;
1164 WorkList.push_back(LScopes.getCurrentFunctionScope());
1165 while (!WorkList.empty()) {
1166 LexicalScope *S = WorkList.pop_back_val();
1168 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1169 if (!Children.empty())
1170 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1171 SE = Children.end(); SI != SE; ++SI)
1172 WorkList.push_back(*SI);
1174 if (S->isAbstractScope())
1177 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1180 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1181 RE = Ranges.end(); RI != RE; ++RI) {
1182 assert(RI->first && "InsnRange does not have first instruction!");
1183 assert(RI->second && "InsnRange does not have second instruction!");
1184 requestLabelBeforeInsn(RI->first);
1185 requestLabelAfterInsn(RI->second);
1190 /// getScopeNode - Get MDNode for DebugLoc's scope.
1191 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1192 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1193 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1194 return DL.getScope(Ctx);
1197 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1198 /// line number info for the function.
1199 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1200 const MDNode *Scope = getScopeNode(DL, Ctx);
1201 DISubprogram SP = getDISubprogram(Scope);
1203 // Check for number of operands since the compatibility is
1205 if (SP->getNumOperands() > 19)
1206 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1208 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1214 /// beginFunction - Gather pre-function debug information. Assumes being
1215 /// emitted immediately after the function entry point.
1216 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1217 if (!MMI->hasDebugInfo()) return;
1218 LScopes.initialize(*MF);
1219 if (LScopes.empty()) return;
1220 identifyScopeMarkers();
1222 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1223 Asm->getFunctionNumber());
1224 // Assumes in correct section after the entry point.
1225 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1227 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1229 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1230 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1231 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1233 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1235 bool AtBlockEntry = true;
1236 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1238 const MachineInstr *MI = II;
1240 if (MI->isDebugValue()) {
1241 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1243 // Keep track of user variables.
1245 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1247 // Variable is in a register, we need to check for clobbers.
1248 if (isDbgValueInDefinedReg(MI))
1249 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1251 // Check the history of this variable.
1252 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1253 if (History.empty()) {
1254 UserVariables.push_back(Var);
1255 // The first mention of a function argument gets the FunctionBeginSym
1256 // label, so arguments are visible when breaking at function entry.
1258 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1259 DISubprogram(getDISubprogram(DV.getContext()))
1260 .describes(MF->getFunction()))
1261 LabelsBeforeInsn[MI] = FunctionBeginSym;
1263 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1264 const MachineInstr *Prev = History.back();
1265 if (Prev->isDebugValue()) {
1266 // Coalesce identical entries at the end of History.
1267 if (History.size() >= 2 &&
1268 Prev->isIdenticalTo(History[History.size() - 2])) {
1269 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1271 << "\t" << *History[History.size() - 2] << "\n");
1275 // Terminate old register assignments that don't reach MI;
1276 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1277 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1278 isDbgValueInDefinedReg(Prev)) {
1279 // Previous register assignment needs to terminate at the end of
1281 MachineBasicBlock::const_iterator LastMI =
1282 PrevMBB->getLastNonDebugInstr();
1283 if (LastMI == PrevMBB->end()) {
1284 // Drop DBG_VALUE for empty range.
1285 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1286 << "\t" << *Prev << "\n");
1290 // Terminate after LastMI.
1291 History.push_back(LastMI);
1296 History.push_back(MI);
1298 // Not a DBG_VALUE instruction.
1300 AtBlockEntry = false;
1302 // First known non DBG_VALUE location marks beginning of function
1304 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1305 PrologEndLoc = MI->getDebugLoc();
1307 // Check if the instruction clobbers any registers with debug vars.
1308 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1309 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1310 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1312 for (const uint16_t *AI = TRI->getOverlaps(MOI->getReg());
1313 unsigned Reg = *AI; ++AI) {
1314 const MDNode *Var = LiveUserVar[Reg];
1317 // Reg is now clobbered.
1318 LiveUserVar[Reg] = 0;
1320 // Was MD last defined by a DBG_VALUE referring to Reg?
1321 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1322 if (HistI == DbgValues.end())
1324 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1325 if (History.empty())
1327 const MachineInstr *Prev = History.back();
1328 // Sanity-check: Register assignments are terminated at the end of
1330 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1332 // Is the variable still in Reg?
1333 if (!isDbgValueInDefinedReg(Prev) ||
1334 Prev->getOperand(0).getReg() != Reg)
1336 // Var is clobbered. Make sure the next instruction gets a label.
1337 History.push_back(MI);
1344 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1346 SmallVectorImpl<const MachineInstr*> &History = I->second;
1347 if (History.empty())
1350 // Make sure the final register assignments are terminated.
1351 const MachineInstr *Prev = History.back();
1352 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1353 const MachineBasicBlock *PrevMBB = Prev->getParent();
1354 MachineBasicBlock::const_iterator LastMI =
1355 PrevMBB->getLastNonDebugInstr();
1356 if (LastMI == PrevMBB->end())
1357 // Drop DBG_VALUE for empty range.
1360 // Terminate after LastMI.
1361 History.push_back(LastMI);
1364 // Request labels for the full history.
1365 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1366 const MachineInstr *MI = History[i];
1367 if (MI->isDebugValue())
1368 requestLabelBeforeInsn(MI);
1370 requestLabelAfterInsn(MI);
1374 PrevInstLoc = DebugLoc();
1375 PrevLabel = FunctionBeginSym;
1377 // Record beginning of function.
1378 if (!PrologEndLoc.isUnknown()) {
1379 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1380 MF->getFunction()->getContext());
1381 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1382 FnStartDL.getScope(MF->getFunction()->getContext()),
1387 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1388 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1389 ScopeVariables[LS].push_back(Var);
1390 // Vars.push_back(Var);
1393 /// endFunction - Gather and emit post-function debug information.
1395 void DwarfDebug::endFunction(const MachineFunction *MF) {
1396 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1398 // Define end label for subprogram.
1399 FunctionEndSym = Asm->GetTempSymbol("func_end",
1400 Asm->getFunctionNumber());
1401 // Assumes in correct section after the entry point.
1402 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1404 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1405 collectVariableInfo(MF, ProcessedVars);
1407 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1408 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1409 assert(TheCU && "Unable to find compile unit!");
1411 // Construct abstract scopes.
1412 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1413 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1414 LexicalScope *AScope = AList[i];
1415 DISubprogram SP(AScope->getScopeNode());
1417 // Collect info for variables that were optimized out.
1418 DIArray Variables = SP.getVariables();
1419 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1420 DIVariable DV(Variables.getElement(i));
1421 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1423 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1424 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1427 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1428 constructScopeDIE(TheCU, AScope);
1431 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1433 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1434 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1435 dwarf::DW_FORM_flag, 1);
1437 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1438 MMI->getFrameMoves()));
1441 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1442 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1443 DeleteContainerPointers(I->second);
1444 ScopeVariables.clear();
1445 DeleteContainerPointers(CurrentFnArguments);
1446 UserVariables.clear();
1448 AbstractVariables.clear();
1449 LabelsBeforeInsn.clear();
1450 LabelsAfterInsn.clear();
1454 /// recordSourceLine - Register a source line with debug info. Returns the
1455 /// unique label that was emitted and which provides correspondence to
1456 /// the source line list.
1457 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1463 DIDescriptor Scope(S);
1465 if (Scope.isCompileUnit()) {
1466 DICompileUnit CU(S);
1467 Fn = CU.getFilename();
1468 Dir = CU.getDirectory();
1469 } else if (Scope.isFile()) {
1471 Fn = F.getFilename();
1472 Dir = F.getDirectory();
1473 } else if (Scope.isSubprogram()) {
1475 Fn = SP.getFilename();
1476 Dir = SP.getDirectory();
1477 } else if (Scope.isLexicalBlockFile()) {
1478 DILexicalBlockFile DBF(S);
1479 Fn = DBF.getFilename();
1480 Dir = DBF.getDirectory();
1481 } else if (Scope.isLexicalBlock()) {
1482 DILexicalBlock DB(S);
1483 Fn = DB.getFilename();
1484 Dir = DB.getDirectory();
1486 llvm_unreachable("Unexpected scope info");
1488 Src = GetOrCreateSourceID(Fn, Dir);
1490 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1493 //===----------------------------------------------------------------------===//
1495 //===----------------------------------------------------------------------===//
1497 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1500 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1501 // Get the children.
1502 const std::vector<DIE *> &Children = Die->getChildren();
1504 // Record the abbreviation.
1505 assignAbbrevNumber(Die->getAbbrev());
1507 // Get the abbreviation for this DIE.
1508 unsigned AbbrevNumber = Die->getAbbrevNumber();
1509 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1512 Die->setOffset(Offset);
1514 // Start the size with the size of abbreviation code.
1515 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1517 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1518 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1520 // Size the DIE attribute values.
1521 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1522 // Size attribute value.
1523 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1525 // Size the DIE children if any.
1526 if (!Children.empty()) {
1527 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1528 "Children flag not set");
1530 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1531 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1533 // End of children marker.
1534 Offset += sizeof(int8_t);
1537 Die->setSize(Offset - Die->getOffset());
1541 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1543 void DwarfDebug::computeSizeAndOffsets() {
1544 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1545 E = CUMap.end(); I != E; ++I) {
1546 // Compute size of compile unit header.
1548 sizeof(int32_t) + // Length of Compilation Unit Info
1549 sizeof(int16_t) + // DWARF version number
1550 sizeof(int32_t) + // Offset Into Abbrev. Section
1551 sizeof(int8_t); // Pointer Size (in bytes)
1552 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1556 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1557 /// the start of each one.
1558 void DwarfDebug::EmitSectionLabels() {
1559 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1561 // Dwarf sections base addresses.
1562 DwarfInfoSectionSym =
1563 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1564 DwarfAbbrevSectionSym =
1565 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1566 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1568 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1569 EmitSectionSym(Asm, MacroInfo);
1571 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1572 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1573 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1574 DwarfStrSectionSym =
1575 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1576 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1579 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1580 "section_debug_loc");
1582 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1583 EmitSectionSym(Asm, TLOF.getDataSection());
1586 /// emitDIE - Recursively emits a debug information entry.
1588 void DwarfDebug::emitDIE(DIE *Die) {
1589 // Get the abbreviation for this DIE.
1590 unsigned AbbrevNumber = Die->getAbbrevNumber();
1591 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1593 // Emit the code (index) for the abbreviation.
1594 if (Asm->isVerbose())
1595 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1596 Twine::utohexstr(Die->getOffset()) + ":0x" +
1597 Twine::utohexstr(Die->getSize()) + " " +
1598 dwarf::TagString(Abbrev->getTag()));
1599 Asm->EmitULEB128(AbbrevNumber);
1601 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1602 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1604 // Emit the DIE attribute values.
1605 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1606 unsigned Attr = AbbrevData[i].getAttribute();
1607 unsigned Form = AbbrevData[i].getForm();
1608 assert(Form && "Too many attributes for DIE (check abbreviation)");
1610 if (Asm->isVerbose())
1611 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1614 case dwarf::DW_AT_abstract_origin: {
1615 DIEEntry *E = cast<DIEEntry>(Values[i]);
1616 DIE *Origin = E->getEntry();
1617 unsigned Addr = Origin->getOffset();
1618 Asm->EmitInt32(Addr);
1621 case dwarf::DW_AT_ranges: {
1622 // DW_AT_range Value encodes offset in debug_range section.
1623 DIEInteger *V = cast<DIEInteger>(Values[i]);
1625 if (Asm->MAI->doesDwarfUseLabelOffsetForRanges()) {
1626 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1630 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1632 DwarfDebugRangeSectionSym,
1637 case dwarf::DW_AT_location: {
1638 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1639 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1641 Values[i]->EmitValue(Asm, Form);
1644 case dwarf::DW_AT_accessibility: {
1645 if (Asm->isVerbose()) {
1646 DIEInteger *V = cast<DIEInteger>(Values[i]);
1647 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1649 Values[i]->EmitValue(Asm, Form);
1653 // Emit an attribute using the defined form.
1654 Values[i]->EmitValue(Asm, Form);
1659 // Emit the DIE children if any.
1660 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1661 const std::vector<DIE *> &Children = Die->getChildren();
1663 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1664 emitDIE(Children[j]);
1666 if (Asm->isVerbose())
1667 Asm->OutStreamer.AddComment("End Of Children Mark");
1672 /// emitDebugInfo - Emit the debug info section.
1674 void DwarfDebug::emitDebugInfo() {
1675 // Start debug info section.
1676 Asm->OutStreamer.SwitchSection(
1677 Asm->getObjFileLowering().getDwarfInfoSection());
1678 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1679 E = CUMap.end(); I != E; ++I) {
1680 CompileUnit *TheCU = I->second;
1681 DIE *Die = TheCU->getCUDie();
1683 // Emit the compile units header.
1684 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1687 // Emit size of content not including length itself
1688 unsigned ContentSize = Die->getSize() +
1689 sizeof(int16_t) + // DWARF version number
1690 sizeof(int32_t) + // Offset Into Abbrev. Section
1691 sizeof(int8_t); // Pointer Size (in bytes)
1693 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1694 Asm->EmitInt32(ContentSize);
1695 Asm->OutStreamer.AddComment("DWARF version number");
1696 Asm->EmitInt16(dwarf::DWARF_VERSION);
1697 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1698 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1699 DwarfAbbrevSectionSym);
1700 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1701 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1704 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1708 /// emitAbbreviations - Emit the abbreviation section.
1710 void DwarfDebug::emitAbbreviations() const {
1711 // Check to see if it is worth the effort.
1712 if (!Abbreviations.empty()) {
1713 // Start the debug abbrev section.
1714 Asm->OutStreamer.SwitchSection(
1715 Asm->getObjFileLowering().getDwarfAbbrevSection());
1717 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1719 // For each abbrevation.
1720 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1721 // Get abbreviation data
1722 const DIEAbbrev *Abbrev = Abbreviations[i];
1724 // Emit the abbrevations code (base 1 index.)
1725 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1727 // Emit the abbreviations data.
1731 // Mark end of abbreviations.
1732 Asm->EmitULEB128(0, "EOM(3)");
1734 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1738 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1739 /// the line matrix.
1741 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1742 // Define last address of section.
1743 Asm->OutStreamer.AddComment("Extended Op");
1746 Asm->OutStreamer.AddComment("Op size");
1747 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1748 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1749 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1751 Asm->OutStreamer.AddComment("Section end label");
1753 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1754 Asm->getTargetData().getPointerSize(),
1757 // Mark end of matrix.
1758 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1764 /// emitAccelNames - Emit visible names into a hashed accelerator table
1766 void DwarfDebug::emitAccelNames() {
1767 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1768 dwarf::DW_FORM_data4));
1769 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1770 E = CUMap.end(); I != E; ++I) {
1771 CompileUnit *TheCU = I->second;
1772 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1773 for (StringMap<std::vector<DIE*> >::const_iterator
1774 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1775 const char *Name = GI->getKeyData();
1776 const std::vector<DIE *> &Entities = GI->second;
1777 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1778 DE = Entities.end(); DI != DE; ++DI)
1779 AT.AddName(Name, (*DI));
1783 AT.FinalizeTable(Asm, "Names");
1784 Asm->OutStreamer.SwitchSection(
1785 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1786 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1787 Asm->OutStreamer.EmitLabel(SectionBegin);
1789 // Emit the full data.
1790 AT.Emit(Asm, SectionBegin, this);
1793 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1794 /// accelerator table section.
1795 void DwarfDebug::emitAccelObjC() {
1796 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1797 dwarf::DW_FORM_data4));
1798 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1799 E = CUMap.end(); I != E; ++I) {
1800 CompileUnit *TheCU = I->second;
1801 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1802 for (StringMap<std::vector<DIE*> >::const_iterator
1803 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1804 const char *Name = GI->getKeyData();
1805 const std::vector<DIE *> &Entities = GI->second;
1806 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1807 DE = Entities.end(); DI != DE; ++DI)
1808 AT.AddName(Name, (*DI));
1812 AT.FinalizeTable(Asm, "ObjC");
1813 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1814 .getDwarfAccelObjCSection());
1815 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1816 Asm->OutStreamer.EmitLabel(SectionBegin);
1818 // Emit the full data.
1819 AT.Emit(Asm, SectionBegin, this);
1822 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1824 void DwarfDebug::emitAccelNamespaces() {
1825 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1826 dwarf::DW_FORM_data4));
1827 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1828 E = CUMap.end(); I != E; ++I) {
1829 CompileUnit *TheCU = I->second;
1830 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1831 for (StringMap<std::vector<DIE*> >::const_iterator
1832 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1833 const char *Name = GI->getKeyData();
1834 const std::vector<DIE *> &Entities = GI->second;
1835 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1836 DE = Entities.end(); DI != DE; ++DI)
1837 AT.AddName(Name, (*DI));
1841 AT.FinalizeTable(Asm, "namespac");
1842 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1843 .getDwarfAccelNamespaceSection());
1844 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1845 Asm->OutStreamer.EmitLabel(SectionBegin);
1847 // Emit the full data.
1848 AT.Emit(Asm, SectionBegin, this);
1851 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1852 void DwarfDebug::emitAccelTypes() {
1853 std::vector<DwarfAccelTable::Atom> Atoms;
1854 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1855 dwarf::DW_FORM_data4));
1856 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1857 dwarf::DW_FORM_data2));
1858 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1859 dwarf::DW_FORM_data1));
1860 DwarfAccelTable AT(Atoms);
1861 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1862 E = CUMap.end(); I != E; ++I) {
1863 CompileUnit *TheCU = I->second;
1864 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1865 = TheCU->getAccelTypes();
1866 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1867 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1868 const char *Name = GI->getKeyData();
1869 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1870 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1871 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1872 AT.AddName(Name, (*DI).first, (*DI).second);
1876 AT.FinalizeTable(Asm, "types");
1877 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1878 .getDwarfAccelTypesSection());
1879 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1880 Asm->OutStreamer.EmitLabel(SectionBegin);
1882 // Emit the full data.
1883 AT.Emit(Asm, SectionBegin, this);
1886 void DwarfDebug::emitDebugPubTypes() {
1887 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1888 E = CUMap.end(); I != E; ++I) {
1889 CompileUnit *TheCU = I->second;
1890 // Start the dwarf pubtypes section.
1891 Asm->OutStreamer.SwitchSection(
1892 Asm->getObjFileLowering().getDwarfPubTypesSection());
1893 Asm->OutStreamer.AddComment("Length of Public Types Info");
1894 Asm->EmitLabelDifference(
1895 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1896 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1898 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1901 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1902 Asm->EmitInt16(dwarf::DWARF_VERSION);
1904 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1905 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1906 DwarfInfoSectionSym);
1908 Asm->OutStreamer.AddComment("Compilation Unit Length");
1909 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1910 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1913 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1914 for (StringMap<DIE*>::const_iterator
1915 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1916 const char *Name = GI->getKeyData();
1917 DIE *Entity = GI->second;
1919 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1920 Asm->EmitInt32(Entity->getOffset());
1922 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1923 // Emit the name with a terminating null byte.
1924 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1927 Asm->OutStreamer.AddComment("End Mark");
1929 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1934 /// emitDebugStr - Emit visible names into a debug str section.
1936 void DwarfDebug::emitDebugStr() {
1937 // Check to see if it is worth the effort.
1938 if (StringPool.empty()) return;
1940 // Start the dwarf str section.
1941 Asm->OutStreamer.SwitchSection(
1942 Asm->getObjFileLowering().getDwarfStrSection());
1944 // Get all of the string pool entries and put them in an array by their ID so
1945 // we can sort them.
1946 SmallVector<std::pair<unsigned,
1947 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1949 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1950 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1951 Entries.push_back(std::make_pair(I->second.second, &*I));
1953 array_pod_sort(Entries.begin(), Entries.end());
1955 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1956 // Emit a label for reference from debug information entries.
1957 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1959 // Emit the string itself with a terminating null byte.
1960 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1961 Entries[i].second->getKeyLength()+1),
1966 /// emitDebugLoc - Emit visible names into a debug loc section.
1968 void DwarfDebug::emitDebugLoc() {
1969 if (DotDebugLocEntries.empty())
1972 for (SmallVector<DotDebugLocEntry, 4>::iterator
1973 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1975 DotDebugLocEntry &Entry = *I;
1976 if (I + 1 != DotDebugLocEntries.end())
1980 // Start the dwarf loc section.
1981 Asm->OutStreamer.SwitchSection(
1982 Asm->getObjFileLowering().getDwarfLocSection());
1983 unsigned char Size = Asm->getTargetData().getPointerSize();
1984 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1986 for (SmallVector<DotDebugLocEntry, 4>::iterator
1987 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1988 I != E; ++I, ++index) {
1989 DotDebugLocEntry &Entry = *I;
1990 if (Entry.isMerged()) continue;
1991 if (Entry.isEmpty()) {
1992 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1993 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1994 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1996 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1997 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1998 DIVariable DV(Entry.Variable);
1999 Asm->OutStreamer.AddComment("Loc expr size");
2000 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2001 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2002 Asm->EmitLabelDifference(end, begin, 2);
2003 Asm->OutStreamer.EmitLabel(begin);
2004 if (Entry.isInt()) {
2005 DIBasicType BTy(DV.getType());
2007 (BTy.getEncoding() == dwarf::DW_ATE_signed
2008 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2009 Asm->OutStreamer.AddComment("DW_OP_consts");
2010 Asm->EmitInt8(dwarf::DW_OP_consts);
2011 Asm->EmitSLEB128(Entry.getInt());
2013 Asm->OutStreamer.AddComment("DW_OP_constu");
2014 Asm->EmitInt8(dwarf::DW_OP_constu);
2015 Asm->EmitULEB128(Entry.getInt());
2017 } else if (Entry.isLocation()) {
2018 if (!DV.hasComplexAddress())
2020 Asm->EmitDwarfRegOp(Entry.Loc);
2022 // Complex address entry.
2023 unsigned N = DV.getNumAddrElements();
2025 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2026 if (Entry.Loc.getOffset()) {
2028 Asm->EmitDwarfRegOp(Entry.Loc);
2029 Asm->OutStreamer.AddComment("DW_OP_deref");
2030 Asm->EmitInt8(dwarf::DW_OP_deref);
2031 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2032 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2033 Asm->EmitSLEB128(DV.getAddrElement(1));
2035 // If first address element is OpPlus then emit
2036 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2037 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2038 Asm->EmitDwarfRegOp(Loc);
2042 Asm->EmitDwarfRegOp(Entry.Loc);
2045 // Emit remaining complex address elements.
2046 for (; i < N; ++i) {
2047 uint64_t Element = DV.getAddrElement(i);
2048 if (Element == DIBuilder::OpPlus) {
2049 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2050 Asm->EmitULEB128(DV.getAddrElement(++i));
2051 } else if (Element == DIBuilder::OpDeref) {
2052 if (!Entry.Loc.isReg())
2053 Asm->EmitInt8(dwarf::DW_OP_deref);
2055 llvm_unreachable("unknown Opcode found in complex address");
2059 // else ... ignore constant fp. There is not any good way to
2060 // to represent them here in dwarf.
2061 Asm->OutStreamer.EmitLabel(end);
2066 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2068 void DwarfDebug::EmitDebugARanges() {
2069 // Start the dwarf aranges section.
2070 Asm->OutStreamer.SwitchSection(
2071 Asm->getObjFileLowering().getDwarfARangesSection());
2074 /// emitDebugRanges - Emit visible names into a debug ranges section.
2076 void DwarfDebug::emitDebugRanges() {
2077 // Start the dwarf ranges section.
2078 Asm->OutStreamer.SwitchSection(
2079 Asm->getObjFileLowering().getDwarfRangesSection());
2080 unsigned char Size = Asm->getTargetData().getPointerSize();
2081 for (SmallVector<const MCSymbol *, 8>::iterator
2082 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2085 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2087 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2091 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2093 void DwarfDebug::emitDebugMacInfo() {
2094 if (const MCSection *LineInfo =
2095 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2096 // Start the dwarf macinfo section.
2097 Asm->OutStreamer.SwitchSection(LineInfo);
2101 /// emitDebugInlineInfo - Emit inline info using following format.
2103 /// 1. length of section
2104 /// 2. Dwarf version number
2105 /// 3. address size.
2107 /// Entries (one "entry" for each function that was inlined):
2109 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2110 /// otherwise offset into __debug_str for regular function name.
2111 /// 2. offset into __debug_str section for regular function name.
2112 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2113 /// instances for the function.
2115 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2116 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2117 /// __debug_info section, and the low_pc is the starting address for the
2118 /// inlining instance.
2119 void DwarfDebug::emitDebugInlineInfo() {
2120 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2126 Asm->OutStreamer.SwitchSection(
2127 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2129 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2130 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2131 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2133 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2135 Asm->OutStreamer.AddComment("Dwarf Version");
2136 Asm->EmitInt16(dwarf::DWARF_VERSION);
2137 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2138 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2140 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2141 E = InlinedSPNodes.end(); I != E; ++I) {
2143 const MDNode *Node = *I;
2144 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2145 = InlineInfo.find(Node);
2146 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2147 DISubprogram SP(Node);
2148 StringRef LName = SP.getLinkageName();
2149 StringRef Name = SP.getName();
2151 Asm->OutStreamer.AddComment("MIPS linkage name");
2153 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2155 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2156 DwarfStrSectionSym);
2158 Asm->OutStreamer.AddComment("Function name");
2159 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2160 Asm->EmitULEB128(Labels.size(), "Inline count");
2162 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2163 LE = Labels.end(); LI != LE; ++LI) {
2164 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2165 Asm->EmitInt32(LI->second->getOffset());
2167 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2168 Asm->OutStreamer.EmitSymbolValue(LI->first,
2169 Asm->getTargetData().getPointerSize(),0);
2173 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));