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/CodeGen/MachineFunction.h"
23 #include "llvm/CodeGen/MachineModuleInfo.h"
24 #include "llvm/MC/MCAsmInfo.h"
25 #include "llvm/MC/MCSection.h"
26 #include "llvm/MC/MCStreamer.h"
27 #include "llvm/MC/MCSymbol.h"
28 #include "llvm/Target/TargetData.h"
29 #include "llvm/Target/TargetFrameLowering.h"
30 #include "llvm/Target/TargetLoweringObjectFile.h"
31 #include "llvm/Target/TargetMachine.h"
32 #include "llvm/Target/TargetRegisterInfo.h"
33 #include "llvm/Target/TargetOptions.h"
34 #include "llvm/Analysis/DebugInfo.h"
35 #include "llvm/Analysis/DIBuilder.h"
36 #include "llvm/ADT/Statistic.h"
37 #include "llvm/ADT/STLExtras.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/Support/CommandLine.h"
40 #include "llvm/Support/Debug.h"
41 #include "llvm/Support/ErrorHandling.h"
42 #include "llvm/Support/ValueHandle.h"
43 #include "llvm/Support/FormattedStream.h"
44 #include "llvm/Support/Timer.h"
45 #include "llvm/Support/Path.h"
48 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
50 cl::desc("Disable debug info printing"));
52 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
53 cl::desc("Make an absence of debug location information explicit."),
56 static cl::opt<bool> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
57 cl::desc("Output prototype dwarf accelerator tables."),
61 const char *DWARFGroupName = "DWARF Emission";
62 const char *DbgTimerName = "DWARF Debug Writer";
63 } // end anonymous namespace
65 //===----------------------------------------------------------------------===//
67 /// Configuration values for initial hash set sizes (log2).
69 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
73 DIType DbgVariable::getType() const {
74 DIType Ty = Var.getType();
75 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
77 if (Var.isBlockByrefVariable()) {
78 /* Byref variables, in Blocks, are declared by the programmer as
79 "SomeType VarName;", but the compiler creates a
80 __Block_byref_x_VarName struct, and gives the variable VarName
81 either the struct, or a pointer to the struct, as its type. This
82 is necessary for various behind-the-scenes things the compiler
83 needs to do with by-reference variables in blocks.
85 However, as far as the original *programmer* is concerned, the
86 variable should still have type 'SomeType', as originally declared.
88 The following function dives into the __Block_byref_x_VarName
89 struct to find the original type of the variable. This will be
90 passed back to the code generating the type for the Debug
91 Information Entry for the variable 'VarName'. 'VarName' will then
92 have the original type 'SomeType' in its debug information.
94 The original type 'SomeType' will be the type of the field named
95 'VarName' inside the __Block_byref_x_VarName struct.
97 NOTE: In order for this to not completely fail on the debugger
98 side, the Debug Information Entry for the variable VarName needs to
99 have a DW_AT_location that tells the debugger how to unwind through
100 the pointers and __Block_byref_x_VarName struct to find the actual
101 value of the variable. The function addBlockByrefType does this. */
103 unsigned tag = Ty.getTag();
105 if (tag == dwarf::DW_TAG_pointer_type) {
106 DIDerivedType DTy = DIDerivedType(Ty);
107 subType = DTy.getTypeDerivedFrom();
110 DICompositeType blockStruct = DICompositeType(subType);
111 DIArray Elements = blockStruct.getTypeArray();
113 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
114 DIDescriptor Element = Elements.getElement(i);
115 DIDerivedType DT = DIDerivedType(Element);
116 if (getName() == DT.getName())
117 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 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
141 DwarfDebug::~DwarfDebug() {
144 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
145 /// temporary label to it if SymbolStem is specified.
146 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
147 const char *SymbolStem = 0) {
148 Asm->OutStreamer.SwitchSection(Section);
149 if (!SymbolStem) return 0;
151 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
152 Asm->OutStreamer.EmitLabel(TmpSym);
156 MCSymbol *DwarfDebug::getStringPool() {
157 return Asm->GetTempSymbol("section_str");
160 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
161 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
162 if (Entry.first) return Entry.first;
164 Entry.second = NextStringPoolNumber++;
165 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
168 /// assignAbbrevNumber - Define a unique number for the abbreviation.
170 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
171 // Profile the node so that we can make it unique.
175 // Check the set for priors.
176 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
178 // If it's newly added.
179 if (InSet == &Abbrev) {
180 // Add to abbreviation list.
181 Abbreviations.push_back(&Abbrev);
183 // Assign the vector position + 1 as its number.
184 Abbrev.setNumber(Abbreviations.size());
186 // Assign existing abbreviation number.
187 Abbrev.setNumber(InSet->getNumber());
191 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
192 /// printer to not emit usual symbol prefix before the symbol name is used then
193 /// return linkage name after skipping this special LLVM prefix.
194 static StringRef getRealLinkageName(StringRef LinkageName) {
196 if (LinkageName.startswith(StringRef(&One, 1)))
197 return LinkageName.substr(1);
201 static bool isObjCClass(StringRef Name) {
202 return Name.startswith("+") || Name.startswith("-");
205 static bool hasObjCCategory(StringRef Name) {
206 if (!isObjCClass(Name)) return false;
208 size_t pos = Name.find(')');
209 if (pos != std::string::npos) {
210 if (Name[pos+1] != ' ') return false;
216 static void getObjCClassCategory(StringRef In, StringRef &Class,
217 StringRef &Category) {
218 if (!hasObjCCategory(In)) {
219 Class = In.slice(In.find('[') + 1, In.find(' '));
224 Class = In.slice(In.find('[') + 1, In.find('('));
225 Category = In.slice(In.find('[') + 1, In.find(' '));
229 static StringRef getObjCMethodName(StringRef In) {
230 return In.slice(In.find(' ') + 1, In.find(']'));
233 // Add the various names to the Dwarf accelerator table names.
234 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
236 if (!SP.isDefinition()) return;
238 TheCU->addAccelName(SP.getName(), Die);
240 // If the linkage name is different than the name, go ahead and output
241 // that as well into the name table.
242 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
243 TheCU->addAccelName(SP.getLinkageName(), Die);
245 // If this is an Objective-C selector name add it to the ObjC accelerator
247 if (isObjCClass(SP.getName())) {
248 StringRef Class, Category;
249 getObjCClassCategory(SP.getName(), Class, Category);
250 TheCU->addAccelObjC(Class, Die);
252 TheCU->addAccelObjC(Category, Die);
253 // Also add the base method name to the name table.
254 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
258 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
259 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
260 /// If there are global variables in this scope then create and insert
261 /// DIEs for these variables.
262 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
263 const MDNode *SPNode) {
264 DIE *SPDie = SPCU->getDIE(SPNode);
266 assert(SPDie && "Unable to find subprogram DIE!");
267 DISubprogram SP(SPNode);
269 DISubprogram SPDecl = SP.getFunctionDeclaration();
270 if (!SPDecl.isSubprogram()) {
271 // There is not any need to generate specification DIE for a function
272 // defined at compile unit level. If a function is defined inside another
273 // function then gdb prefers the definition at top level and but does not
274 // expect specification DIE in parent function. So avoid creating
275 // specification DIE for a function defined inside a function.
276 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
277 !SP.getContext().isFile() &&
278 !isSubprogramContext(SP.getContext())) {
279 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
282 DICompositeType SPTy = SP.getType();
283 DIArray Args = SPTy.getTypeArray();
284 unsigned SPTag = SPTy.getTag();
285 if (SPTag == dwarf::DW_TAG_subroutine_type)
286 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
287 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
288 DIType ATy = DIType(DIType(Args.getElement(i)));
289 SPCU->addType(Arg, ATy);
290 if (ATy.isArtificial())
291 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
292 SPDie->addChild(Arg);
294 DIE *SPDeclDie = SPDie;
295 SPDie = new DIE(dwarf::DW_TAG_subprogram);
296 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
301 // Pick up abstract subprogram DIE.
302 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
303 SPDie = new DIE(dwarf::DW_TAG_subprogram);
304 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
305 dwarf::DW_FORM_ref4, AbsSPDIE);
309 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
310 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
311 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
312 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
313 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
314 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
315 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
317 // Add name to the name table, we do this here because we're guaranteed
318 // to have concrete versions of our DW_TAG_subprogram nodes.
319 addSubprogramNames(SPCU, SP, SPDie);
324 /// constructLexicalScope - Construct new DW_TAG_lexical_block
325 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
326 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
327 LexicalScope *Scope) {
328 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
329 if (Scope->isAbstractScope())
332 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
336 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
337 if (Ranges.size() > 1) {
338 // .debug_range section has not been laid out yet. Emit offset in
339 // .debug_range as a uint, size 4, for now. emitDIE will handle
340 // DW_AT_ranges appropriately.
341 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
342 DebugRangeSymbols.size()
343 * Asm->getTargetData().getPointerSize());
344 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
345 RE = Ranges.end(); RI != RE; ++RI) {
346 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
347 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
349 DebugRangeSymbols.push_back(NULL);
350 DebugRangeSymbols.push_back(NULL);
354 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
355 const MCSymbol *End = getLabelAfterInsn(RI->second);
357 if (End == 0) return 0;
359 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
360 assert(End->isDefined() && "Invalid end label for an inlined scope!");
362 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
363 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
368 /// constructInlinedScopeDIE - This scope represents inlined body of
369 /// a function. Construct DIE to represent this concrete inlined copy
371 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
372 LexicalScope *Scope) {
373 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
374 assert(Ranges.empty() == false &&
375 "LexicalScope does not have instruction markers!");
377 if (!Scope->getScopeNode())
379 DIScope DS(Scope->getScopeNode());
380 DISubprogram InlinedSP = getDISubprogram(DS);
381 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
383 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
387 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
388 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
389 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
391 if (StartLabel == 0 || EndLabel == 0) {
392 assert(0 && "Unexpected Start and End labels for a inlined scope!");
395 assert(StartLabel->isDefined() &&
396 "Invalid starting label for an inlined scope!");
397 assert(EndLabel->isDefined() &&
398 "Invalid end label for an inlined scope!");
400 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
401 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
402 dwarf::DW_FORM_ref4, OriginDIE);
404 if (Ranges.size() > 1) {
405 // .debug_range section has not been laid out yet. Emit offset in
406 // .debug_range as a uint, size 4, for now. emitDIE will handle
407 // DW_AT_ranges appropriately.
408 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
409 DebugRangeSymbols.size()
410 * Asm->getTargetData().getPointerSize());
411 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
412 RE = Ranges.end(); RI != RE; ++RI) {
413 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
414 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
416 DebugRangeSymbols.push_back(NULL);
417 DebugRangeSymbols.push_back(NULL);
419 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
421 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
425 InlinedSubprogramDIEs.insert(OriginDIE);
427 // Track the start label for this inlined function.
428 //.debug_inlined section specification does not clearly state how
429 // to emit inlined scope that is split into multiple instruction ranges.
430 // For now, use first instruction range and emit low_pc/high_pc pair and
431 // corresponding .debug_inlined section entry for this pair.
432 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
433 I = InlineInfo.find(InlinedSP);
435 if (I == InlineInfo.end()) {
436 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
437 InlinedSPNodes.push_back(InlinedSP);
439 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
441 DILocation DL(Scope->getInlinedAt());
442 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
443 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
445 // Add name to the name table, we do this here because we're guaranteed
446 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
447 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
452 /// constructScopeDIE - Construct a DIE for this scope.
453 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
454 if (!Scope || !Scope->getScopeNode())
457 SmallVector<DIE *, 8> Children;
459 // Collect arguments for current function.
460 if (LScopes.isCurrentFunctionScope(Scope))
461 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
462 if (DbgVariable *ArgDV = CurrentFnArguments[i])
464 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
465 Children.push_back(Arg);
467 // Collect lexical scope children first.
468 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
469 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
471 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
472 Children.push_back(Variable);
473 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
474 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
475 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
476 Children.push_back(Nested);
477 DIScope DS(Scope->getScopeNode());
478 DIE *ScopeDIE = NULL;
479 if (Scope->getInlinedAt())
480 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
481 else if (DS.isSubprogram()) {
482 ProcessedSPNodes.insert(DS);
483 if (Scope->isAbstractScope()) {
484 ScopeDIE = TheCU->getDIE(DS);
485 // Note down abstract DIE.
487 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
490 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
493 // There is no need to emit empty lexical block DIE.
494 if (Children.empty())
496 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
499 if (!ScopeDIE) return NULL;
502 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
503 E = Children.end(); I != E; ++I)
504 ScopeDIE->addChild(*I);
506 if (DS.isSubprogram())
507 TheCU->addPubTypes(DISubprogram(DS));
512 /// GetOrCreateSourceID - Look up the source id with the given directory and
513 /// source file names. If none currently exists, create a new id and insert it
514 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
516 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
518 // If FE did not provide a file name, then assume stdin.
519 if (FileName.empty())
520 return GetOrCreateSourceID("<stdin>", StringRef());
522 // TODO: this might not belong here. See if we can factor this better.
523 if (DirName == CompilationDir)
526 unsigned SrcId = SourceIdMap.size()+1;
527 std::pair<std::string, std::string> SourceName =
528 std::make_pair(FileName, DirName);
529 std::pair<std::pair<std::string, std::string>, unsigned> Entry =
530 make_pair(SourceName, SrcId);
532 std::map<std::pair<std::string, std::string>, unsigned>::iterator I;
534 tie(I, NewlyInserted) = SourceIdMap.insert(Entry);
538 // Print out a .file directive to specify files for .loc directives.
539 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.first.second,
545 /// constructCompileUnit - Create new CompileUnit for the given
546 /// metadata node with tag DW_TAG_compile_unit.
547 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
548 DICompileUnit DIUnit(N);
549 StringRef FN = DIUnit.getFilename();
550 CompilationDir = DIUnit.getDirectory();
551 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
553 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
554 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
555 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
556 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
557 DIUnit.getLanguage());
558 NewCU->addString(Die, dwarf::DW_AT_name, FN);
559 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
560 // simplifies debug range entries.
561 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
562 // DW_AT_stmt_list is a offset of line number information for this
563 // compile unit in debug_line section.
564 if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
565 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
566 Asm->GetTempSymbol("section_line"));
568 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
570 if (!CompilationDir.empty())
571 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
572 if (DIUnit.isOptimized())
573 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
575 StringRef Flags = DIUnit.getFlags();
577 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
579 if (unsigned RVer = DIUnit.getRunTimeVersion())
580 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
581 dwarf::DW_FORM_data1, RVer);
585 CUMap.insert(std::make_pair(N, NewCU));
589 /// construct SubprogramDIE - Construct subprogram DIE.
590 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
592 CompileUnit *&CURef = SPMap[N];
598 if (!SP.isDefinition())
599 // This is a method declaration which will be handled while constructing
603 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
606 TheCU->insertDIE(N, SubprogramDie);
608 // Add to context owner.
609 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
614 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
615 /// as llvm.dbg.enum and llvm.dbg.ty
616 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
617 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
618 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
619 const MDNode *N = NMD->getOperand(i);
620 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
621 constructSubprogramDIE(CU, N);
624 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
625 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
626 const MDNode *N = NMD->getOperand(i);
627 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
628 CU->createGlobalVariableDIE(N);
631 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
632 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
633 DIType Ty(NMD->getOperand(i));
634 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
635 CU->getOrCreateTypeDIE(Ty);
638 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
639 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
640 DIType Ty(NMD->getOperand(i));
641 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
642 CU->getOrCreateTypeDIE(Ty);
646 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
647 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
648 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
649 DebugInfoFinder DbgFinder;
650 DbgFinder.processModule(*M);
652 bool HasDebugInfo = false;
653 // Scan all the compile-units to see if there are any marked as the main
654 // unit. If not, we do not generate debug info.
655 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
656 E = DbgFinder.compile_unit_end(); I != E; ++I) {
657 if (DICompileUnit(*I).isMain()) {
662 if (!HasDebugInfo) return false;
664 // Create all the compile unit DIEs.
665 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
666 E = DbgFinder.compile_unit_end(); I != E; ++I)
667 constructCompileUnit(*I);
669 // Create DIEs for each global variable.
670 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
671 E = DbgFinder.global_variable_end(); I != E; ++I) {
672 const MDNode *N = *I;
673 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
674 CU->createGlobalVariableDIE(N);
677 // Create DIEs for each subprogram.
678 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
679 E = DbgFinder.subprogram_end(); I != E; ++I) {
680 const MDNode *N = *I;
681 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
682 constructSubprogramDIE(CU, N);
688 /// beginModule - Emit all Dwarf sections that should come prior to the
689 /// content. Create global DIEs and emit initial debug info sections.
690 /// This is invoked by the target AsmPrinter.
691 void DwarfDebug::beginModule(Module *M) {
692 if (DisableDebugInfoPrinting)
695 // If module has named metadata anchors then use them, otherwise scan the
696 // module using debug info finder to collect debug info.
697 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
699 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
700 DICompileUnit CUNode(CU_Nodes->getOperand(i));
701 CompileUnit *CU = constructCompileUnit(CUNode);
702 DIArray GVs = CUNode.getGlobalVariables();
703 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
704 CU->createGlobalVariableDIE(GVs.getElement(i));
705 DIArray SPs = CUNode.getSubprograms();
706 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
707 constructSubprogramDIE(CU, SPs.getElement(i));
708 DIArray EnumTypes = CUNode.getEnumTypes();
709 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
710 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
711 DIArray RetainedTypes = CUNode.getRetainedTypes();
712 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
713 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
715 } else if (!collectLegacyDebugInfo(M))
718 collectInfoFromNamedMDNodes(M);
720 // Tell MMI that we have debug info.
721 MMI->setDebugInfoAvailability(true);
723 // Emit initial sections.
726 // Prime section data.
727 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
730 /// endModule - Emit all Dwarf sections that should come after the content.
732 void DwarfDebug::endModule() {
733 if (!FirstCU) return;
734 const Module *M = MMI->getModule();
735 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
737 // Collect info for variables that were optimized out.
738 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
739 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
740 DICompileUnit TheCU(CU_Nodes->getOperand(i));
741 DIArray Subprograms = TheCU.getSubprograms();
742 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
743 DISubprogram SP(Subprograms.getElement(i));
744 if (ProcessedSPNodes.count(SP) != 0) continue;
745 if (!SP.Verify()) continue;
746 if (!SP.isDefinition()) continue;
747 DIArray Variables = SP.getVariables();
748 if (Variables.getNumElements() == 0) continue;
750 LexicalScope *Scope =
751 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
752 DeadFnScopeMap[SP] = Scope;
754 // Construct subprogram DIE and add variables DIEs.
755 CompileUnit *SPCU = CUMap.lookup(TheCU);
756 assert(SPCU && "Unable to find Compile Unit!");
757 constructSubprogramDIE(SPCU, SP);
758 DIE *ScopeDIE = SPCU->getDIE(SP);
759 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
760 DIVariable DV(Variables.getElement(vi));
761 if (!DV.Verify()) continue;
762 DbgVariable *NewVar = new DbgVariable(DV, NULL);
763 if (DIE *VariableDIE =
764 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
765 ScopeDIE->addChild(VariableDIE);
771 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
772 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
773 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
775 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
777 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
778 AE = AbstractSPDies.end(); AI != AE; ++AI) {
779 DIE *ISP = AI->second;
780 if (InlinedSubprogramDIEs.count(ISP))
782 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
785 // Emit DW_AT_containing_type attribute to connect types with their
786 // vtable holding type.
787 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
788 CUE = CUMap.end(); CUI != CUE; ++CUI) {
789 CompileUnit *TheCU = CUI->second;
790 TheCU->constructContainingTypeDIEs();
793 // Standard sections final addresses.
794 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
795 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
796 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
797 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
799 // End text sections.
800 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
801 Asm->OutStreamer.SwitchSection(SectionMap[i]);
802 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
805 // Compute DIE offsets and sizes.
806 computeSizeAndOffsets();
808 // Emit all the DIEs into a debug info section
811 // Corresponding abbreviations into a abbrev section.
814 // Emit info into a dwarf accelerator table sections.
815 if (DwarfAccelTables) {
818 emitAccelNamespaces();
822 // Emit info into a debug pubtypes section.
825 // Emit info into a debug loc section.
828 // Emit info into a debug aranges section.
831 // Emit info into a debug ranges section.
834 // Emit info into a debug macinfo section.
838 emitDebugInlineInfo();
840 // Emit info into a debug str section.
844 DeleteContainerSeconds(DeadFnScopeMap);
846 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
847 E = CUMap.end(); I != E; ++I)
849 FirstCU = NULL; // Reset for the next Module, if any.
852 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
853 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
855 LLVMContext &Ctx = DV->getContext();
856 // More then one inlined variable corresponds to one abstract variable.
857 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
858 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
860 return AbsDbgVariable;
862 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
866 AbsDbgVariable = new DbgVariable(Var, NULL);
867 addScopeVariable(Scope, AbsDbgVariable);
868 AbstractVariables[Var] = AbsDbgVariable;
869 return AbsDbgVariable;
872 /// addCurrentFnArgument - If Var is a current function argument then add
873 /// it to CurrentFnArguments list.
874 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
875 DbgVariable *Var, LexicalScope *Scope) {
876 if (!LScopes.isCurrentFunctionScope(Scope))
878 DIVariable DV = Var->getVariable();
879 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
881 unsigned ArgNo = DV.getArgNumber();
885 size_t Size = CurrentFnArguments.size();
887 CurrentFnArguments.resize(MF->getFunction()->arg_size());
888 // llvm::Function argument size is not good indicator of how many
889 // arguments does the function have at source level.
891 CurrentFnArguments.resize(ArgNo * 2);
892 CurrentFnArguments[ArgNo - 1] = Var;
896 /// collectVariableInfoFromMMITable - Collect variable information from
897 /// side table maintained by MMI.
899 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
900 SmallPtrSet<const MDNode *, 16> &Processed) {
901 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
902 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
903 VE = VMap.end(); VI != VE; ++VI) {
904 const MDNode *Var = VI->first;
906 Processed.insert(Var);
908 const std::pair<unsigned, DebugLoc> &VP = VI->second;
910 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
912 // If variable scope is not found then skip this variable.
916 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
917 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
918 RegVar->setFrameIndex(VP.first);
919 if (!addCurrentFnArgument(MF, RegVar, Scope))
920 addScopeVariable(Scope, RegVar);
922 AbsDbgVariable->setFrameIndex(VP.first);
926 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
927 /// DBG_VALUE instruction, is in a defined reg.
928 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
929 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
930 return MI->getNumOperands() == 3 &&
931 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
932 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
935 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
937 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
938 const MCSymbol *FLabel,
939 const MCSymbol *SLabel,
940 const MachineInstr *MI) {
941 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
943 if (MI->getNumOperands() != 3) {
944 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
945 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
947 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
948 MachineLocation MLoc;
949 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
950 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
952 if (MI->getOperand(0).isImm())
953 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
954 if (MI->getOperand(0).isFPImm())
955 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
956 if (MI->getOperand(0).isCImm())
957 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
959 assert(0 && "Unexpected 3 operand DBG_VALUE instruction!");
960 return DotDebugLocEntry();
963 /// collectVariableInfo - Find variables for each lexical scope.
965 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
966 SmallPtrSet<const MDNode *, 16> &Processed) {
968 /// collection info from MMI table.
969 collectVariableInfoFromMMITable(MF, Processed);
971 for (SmallVectorImpl<const MDNode*>::const_iterator
972 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
974 const MDNode *Var = *UVI;
975 if (Processed.count(Var))
978 // History contains relevant DBG_VALUE instructions for Var and instructions
980 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
983 const MachineInstr *MInsn = History.front();
986 LexicalScope *Scope = NULL;
987 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
988 DISubprogram(DV.getContext()).describes(MF->getFunction()))
989 Scope = LScopes.getCurrentFunctionScope();
991 if (DV.getVersion() <= LLVMDebugVersion9)
992 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
994 if (MDNode *IA = DV.getInlinedAt())
995 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
997 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1000 // If variable scope is not found then skip this variable.
1004 Processed.insert(DV);
1005 assert(MInsn->isDebugValue() && "History must begin with debug value");
1006 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1007 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1008 if (!addCurrentFnArgument(MF, RegVar, Scope))
1009 addScopeVariable(Scope, RegVar);
1011 AbsVar->setMInsn(MInsn);
1013 // Simple ranges that are fully coalesced.
1014 if (History.size() <= 1 || (History.size() == 2 &&
1015 MInsn->isIdenticalTo(History.back()))) {
1016 RegVar->setMInsn(MInsn);
1020 // handle multiple DBG_VALUE instructions describing one variable.
1021 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1023 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1024 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1025 const MachineInstr *Begin = *HI;
1026 assert(Begin->isDebugValue() && "Invalid History entry");
1028 // Check if DBG_VALUE is truncating a range.
1029 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1030 && !Begin->getOperand(0).getReg())
1033 // Compute the range for a register location.
1034 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1035 const MCSymbol *SLabel = 0;
1038 // If Begin is the last instruction in History then its value is valid
1039 // until the end of the function.
1040 SLabel = FunctionEndSym;
1042 const MachineInstr *End = HI[1];
1043 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1044 << "\t" << *Begin << "\t" << *End << "\n");
1045 if (End->isDebugValue())
1046 SLabel = getLabelBeforeInsn(End);
1048 // End is a normal instruction clobbering the range.
1049 SLabel = getLabelAfterInsn(End);
1050 assert(SLabel && "Forgot label after clobber instruction");
1055 // The value is valid until the next DBG_VALUE or clobber.
1056 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1059 DotDebugLocEntries.push_back(DotDebugLocEntry());
1062 // Collect info for variables that were optimized out.
1063 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1064 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1065 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1066 DIVariable DV(Variables.getElement(i));
1067 if (!DV || !DV.Verify() || !Processed.insert(DV))
1069 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1070 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1074 /// getLabelBeforeInsn - Return Label preceding the instruction.
1075 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1076 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1077 assert(Label && "Didn't insert label before instruction");
1081 /// getLabelAfterInsn - Return Label immediately following the instruction.
1082 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1083 return LabelsAfterInsn.lookup(MI);
1086 /// beginInstruction - Process beginning of an instruction.
1087 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1088 // Check if source location changes, but ignore DBG_VALUE locations.
1089 if (!MI->isDebugValue()) {
1090 DebugLoc DL = MI->getDebugLoc();
1091 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1092 unsigned Flags = DWARF2_FLAG_IS_STMT;
1094 if (DL == PrologEndLoc) {
1095 Flags |= DWARF2_FLAG_PROLOGUE_END;
1096 PrologEndLoc = DebugLoc();
1098 if (!DL.isUnknown()) {
1099 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1100 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1102 recordSourceLine(0, 0, 0, 0);
1106 // Insert labels where requested.
1107 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1108 LabelsBeforeInsn.find(MI);
1111 if (I == LabelsBeforeInsn.end())
1114 // Label already assigned.
1119 PrevLabel = MMI->getContext().CreateTempSymbol();
1120 Asm->OutStreamer.EmitLabel(PrevLabel);
1122 I->second = PrevLabel;
1125 /// endInstruction - Process end of an instruction.
1126 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1127 // Don't create a new label after DBG_VALUE instructions.
1128 // They don't generate code.
1129 if (!MI->isDebugValue())
1132 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1133 LabelsAfterInsn.find(MI);
1136 if (I == LabelsAfterInsn.end())
1139 // Label already assigned.
1143 // We need a label after this instruction.
1145 PrevLabel = MMI->getContext().CreateTempSymbol();
1146 Asm->OutStreamer.EmitLabel(PrevLabel);
1148 I->second = PrevLabel;
1151 /// identifyScopeMarkers() -
1152 /// Each LexicalScope has first instruction and last instruction to mark
1153 /// beginning and end of a scope respectively. Create an inverse map that list
1154 /// scopes starts (and ends) with an instruction. One instruction may start (or
1155 /// end) multiple scopes. Ignore scopes that are not reachable.
1156 void DwarfDebug::identifyScopeMarkers() {
1157 SmallVector<LexicalScope *, 4> WorkList;
1158 WorkList.push_back(LScopes.getCurrentFunctionScope());
1159 while (!WorkList.empty()) {
1160 LexicalScope *S = WorkList.pop_back_val();
1162 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1163 if (!Children.empty())
1164 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1165 SE = Children.end(); SI != SE; ++SI)
1166 WorkList.push_back(*SI);
1168 if (S->isAbstractScope())
1171 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1174 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1175 RE = Ranges.end(); RI != RE; ++RI) {
1176 assert(RI->first && "InsnRange does not have first instruction!");
1177 assert(RI->second && "InsnRange does not have second instruction!");
1178 requestLabelBeforeInsn(RI->first);
1179 requestLabelAfterInsn(RI->second);
1184 /// getScopeNode - Get MDNode for DebugLoc's scope.
1185 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1186 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1187 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1188 return DL.getScope(Ctx);
1191 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1192 /// line number info for the function.
1193 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1194 const MDNode *Scope = getScopeNode(DL, Ctx);
1195 DISubprogram SP = getDISubprogram(Scope);
1197 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1201 /// beginFunction - Gather pre-function debug information. Assumes being
1202 /// emitted immediately after the function entry point.
1203 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1204 if (!MMI->hasDebugInfo()) return;
1205 LScopes.initialize(*MF);
1206 if (LScopes.empty()) return;
1207 identifyScopeMarkers();
1209 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1210 Asm->getFunctionNumber());
1211 // Assumes in correct section after the entry point.
1212 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1214 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1216 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1217 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1218 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1220 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1222 bool AtBlockEntry = true;
1223 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1225 const MachineInstr *MI = II;
1227 if (MI->isDebugValue()) {
1228 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1230 // Keep track of user variables.
1232 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1234 // Variable is in a register, we need to check for clobbers.
1235 if (isDbgValueInDefinedReg(MI))
1236 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1238 // Check the history of this variable.
1239 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1240 if (History.empty()) {
1241 UserVariables.push_back(Var);
1242 // The first mention of a function argument gets the FunctionBeginSym
1243 // label, so arguments are visible when breaking at function entry.
1245 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1246 DISubprogram(getDISubprogram(DV.getContext()))
1247 .describes(MF->getFunction()))
1248 LabelsBeforeInsn[MI] = FunctionBeginSym;
1250 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1251 const MachineInstr *Prev = History.back();
1252 if (Prev->isDebugValue()) {
1253 // Coalesce identical entries at the end of History.
1254 if (History.size() >= 2 &&
1255 Prev->isIdenticalTo(History[History.size() - 2])) {
1256 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1258 << "\t" << *History[History.size() - 2] << "\n");
1262 // Terminate old register assignments that don't reach MI;
1263 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1264 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1265 isDbgValueInDefinedReg(Prev)) {
1266 // Previous register assignment needs to terminate at the end of
1268 MachineBasicBlock::const_iterator LastMI =
1269 PrevMBB->getLastNonDebugInstr();
1270 if (LastMI == PrevMBB->end()) {
1271 // Drop DBG_VALUE for empty range.
1272 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1273 << "\t" << *Prev << "\n");
1277 // Terminate after LastMI.
1278 History.push_back(LastMI);
1283 History.push_back(MI);
1285 // Not a DBG_VALUE instruction.
1287 AtBlockEntry = false;
1289 // First known non DBG_VALUE location marks beginning of function
1291 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1292 PrologEndLoc = MI->getDebugLoc();
1294 // Check if the instruction clobbers any registers with debug vars.
1295 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1296 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1297 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1299 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1300 unsigned Reg = *AI; ++AI) {
1301 const MDNode *Var = LiveUserVar[Reg];
1304 // Reg is now clobbered.
1305 LiveUserVar[Reg] = 0;
1307 // Was MD last defined by a DBG_VALUE referring to Reg?
1308 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1309 if (HistI == DbgValues.end())
1311 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1312 if (History.empty())
1314 const MachineInstr *Prev = History.back();
1315 // Sanity-check: Register assignments are terminated at the end of
1317 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1319 // Is the variable still in Reg?
1320 if (!isDbgValueInDefinedReg(Prev) ||
1321 Prev->getOperand(0).getReg() != Reg)
1323 // Var is clobbered. Make sure the next instruction gets a label.
1324 History.push_back(MI);
1331 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1333 SmallVectorImpl<const MachineInstr*> &History = I->second;
1334 if (History.empty())
1337 // Make sure the final register assignments are terminated.
1338 const MachineInstr *Prev = History.back();
1339 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1340 const MachineBasicBlock *PrevMBB = Prev->getParent();
1341 MachineBasicBlock::const_iterator LastMI =
1342 PrevMBB->getLastNonDebugInstr();
1343 if (LastMI == PrevMBB->end())
1344 // Drop DBG_VALUE for empty range.
1347 // Terminate after LastMI.
1348 History.push_back(LastMI);
1351 // Request labels for the full history.
1352 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1353 const MachineInstr *MI = History[i];
1354 if (MI->isDebugValue())
1355 requestLabelBeforeInsn(MI);
1357 requestLabelAfterInsn(MI);
1361 PrevInstLoc = DebugLoc();
1362 PrevLabel = FunctionBeginSym;
1364 // Record beginning of function.
1365 if (!PrologEndLoc.isUnknown()) {
1366 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1367 MF->getFunction()->getContext());
1368 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1369 FnStartDL.getScope(MF->getFunction()->getContext()),
1370 DWARF2_FLAG_IS_STMT);
1374 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1375 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1376 ScopeVariables[LS].push_back(Var);
1377 // Vars.push_back(Var);
1380 /// endFunction - Gather and emit post-function debug information.
1382 void DwarfDebug::endFunction(const MachineFunction *MF) {
1383 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1385 // Define end label for subprogram.
1386 FunctionEndSym = Asm->GetTempSymbol("func_end",
1387 Asm->getFunctionNumber());
1388 // Assumes in correct section after the entry point.
1389 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1391 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1392 collectVariableInfo(MF, ProcessedVars);
1394 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1395 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1396 assert(TheCU && "Unable to find compile unit!");
1398 // Construct abstract scopes.
1399 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1400 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1401 LexicalScope *AScope = AList[i];
1402 DISubprogram SP(AScope->getScopeNode());
1404 // Collect info for variables that were optimized out.
1405 DIArray Variables = SP.getVariables();
1406 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1407 DIVariable DV(Variables.getElement(i));
1408 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1410 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1411 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1414 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1415 constructScopeDIE(TheCU, AScope);
1418 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1420 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1421 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1422 dwarf::DW_FORM_flag, 1);
1424 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1425 MMI->getFrameMoves()));
1428 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1429 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1430 DeleteContainerPointers(I->second);
1431 ScopeVariables.clear();
1432 DeleteContainerPointers(CurrentFnArguments);
1433 UserVariables.clear();
1435 AbstractVariables.clear();
1436 LabelsBeforeInsn.clear();
1437 LabelsAfterInsn.clear();
1441 /// recordSourceLine - Register a source line with debug info. Returns the
1442 /// unique label that was emitted and which provides correspondence to
1443 /// the source line list.
1444 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1450 DIDescriptor Scope(S);
1452 if (Scope.isCompileUnit()) {
1453 DICompileUnit CU(S);
1454 Fn = CU.getFilename();
1455 Dir = CU.getDirectory();
1456 } else if (Scope.isFile()) {
1458 Fn = F.getFilename();
1459 Dir = F.getDirectory();
1460 } else if (Scope.isSubprogram()) {
1462 Fn = SP.getFilename();
1463 Dir = SP.getDirectory();
1464 } else if (Scope.isLexicalBlockFile()) {
1465 DILexicalBlockFile DBF(S);
1466 Fn = DBF.getFilename();
1467 Dir = DBF.getDirectory();
1468 } else if (Scope.isLexicalBlock()) {
1469 DILexicalBlock DB(S);
1470 Fn = DB.getFilename();
1471 Dir = DB.getDirectory();
1473 assert(0 && "Unexpected scope info");
1475 Src = GetOrCreateSourceID(Fn, Dir);
1477 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1480 //===----------------------------------------------------------------------===//
1482 //===----------------------------------------------------------------------===//
1484 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1487 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1488 // Get the children.
1489 const std::vector<DIE *> &Children = Die->getChildren();
1491 // If not last sibling and has children then add sibling offset attribute.
1492 if (!Last && !Children.empty())
1493 Die->addSiblingOffset(DIEValueAllocator);
1495 // Record the abbreviation.
1496 assignAbbrevNumber(Die->getAbbrev());
1498 // Get the abbreviation for this DIE.
1499 unsigned AbbrevNumber = Die->getAbbrevNumber();
1500 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1503 Die->setOffset(Offset);
1505 // Start the size with the size of abbreviation code.
1506 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1508 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1509 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1511 // Size the DIE attribute values.
1512 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1513 // Size attribute value.
1514 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1516 // Size the DIE children if any.
1517 if (!Children.empty()) {
1518 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1519 "Children flag not set");
1521 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1522 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1524 // End of children marker.
1525 Offset += sizeof(int8_t);
1528 Die->setSize(Offset - Die->getOffset());
1532 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1534 void DwarfDebug::computeSizeAndOffsets() {
1535 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1536 E = CUMap.end(); I != E; ++I) {
1537 // Compute size of compile unit header.
1539 sizeof(int32_t) + // Length of Compilation Unit Info
1540 sizeof(int16_t) + // DWARF version number
1541 sizeof(int32_t) + // Offset Into Abbrev. Section
1542 sizeof(int8_t); // Pointer Size (in bytes)
1543 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1547 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1548 /// the start of each one.
1549 void DwarfDebug::EmitSectionLabels() {
1550 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1552 // Dwarf sections base addresses.
1553 DwarfInfoSectionSym =
1554 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1555 DwarfAbbrevSectionSym =
1556 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1557 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1559 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1560 EmitSectionSym(Asm, MacroInfo);
1562 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1563 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1564 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1565 DwarfStrSectionSym =
1566 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1567 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1570 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1571 "section_debug_loc");
1573 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1574 EmitSectionSym(Asm, TLOF.getDataSection());
1577 /// emitDIE - Recursively emits a debug information entry.
1579 void DwarfDebug::emitDIE(DIE *Die) {
1580 // Get the abbreviation for this DIE.
1581 unsigned AbbrevNumber = Die->getAbbrevNumber();
1582 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1584 // Emit the code (index) for the abbreviation.
1585 if (Asm->isVerbose())
1586 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1587 Twine::utohexstr(Die->getOffset()) + ":0x" +
1588 Twine::utohexstr(Die->getSize()) + " " +
1589 dwarf::TagString(Abbrev->getTag()));
1590 Asm->EmitULEB128(AbbrevNumber);
1592 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1593 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1595 // Emit the DIE attribute values.
1596 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1597 unsigned Attr = AbbrevData[i].getAttribute();
1598 unsigned Form = AbbrevData[i].getForm();
1599 assert(Form && "Too many attributes for DIE (check abbreviation)");
1601 if (Asm->isVerbose())
1602 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1605 case dwarf::DW_AT_sibling:
1606 Asm->EmitInt32(Die->getSiblingOffset());
1608 case dwarf::DW_AT_abstract_origin: {
1609 DIEEntry *E = cast<DIEEntry>(Values[i]);
1610 DIE *Origin = E->getEntry();
1611 unsigned Addr = Origin->getOffset();
1612 Asm->EmitInt32(Addr);
1615 case dwarf::DW_AT_ranges: {
1616 // DW_AT_range Value encodes offset in debug_range section.
1617 DIEInteger *V = cast<DIEInteger>(Values[i]);
1619 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1620 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1624 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1626 DwarfDebugRangeSectionSym,
1631 case dwarf::DW_AT_location: {
1632 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1633 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1635 Values[i]->EmitValue(Asm, Form);
1638 case dwarf::DW_AT_accessibility: {
1639 if (Asm->isVerbose()) {
1640 DIEInteger *V = cast<DIEInteger>(Values[i]);
1641 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1643 Values[i]->EmitValue(Asm, Form);
1647 // Emit an attribute using the defined form.
1648 Values[i]->EmitValue(Asm, Form);
1653 // Emit the DIE children if any.
1654 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1655 const std::vector<DIE *> &Children = Die->getChildren();
1657 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1658 emitDIE(Children[j]);
1660 if (Asm->isVerbose())
1661 Asm->OutStreamer.AddComment("End Of Children Mark");
1666 /// emitDebugInfo - Emit the debug info section.
1668 void DwarfDebug::emitDebugInfo() {
1669 // Start debug info section.
1670 Asm->OutStreamer.SwitchSection(
1671 Asm->getObjFileLowering().getDwarfInfoSection());
1672 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1673 E = CUMap.end(); I != E; ++I) {
1674 CompileUnit *TheCU = I->second;
1675 DIE *Die = TheCU->getCUDie();
1677 // Emit the compile units header.
1678 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1681 // Emit size of content not including length itself
1682 unsigned ContentSize = Die->getSize() +
1683 sizeof(int16_t) + // DWARF version number
1684 sizeof(int32_t) + // Offset Into Abbrev. Section
1685 sizeof(int8_t); // Pointer Size (in bytes)
1687 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1688 Asm->EmitInt32(ContentSize);
1689 Asm->OutStreamer.AddComment("DWARF version number");
1690 Asm->EmitInt16(dwarf::DWARF_VERSION);
1691 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1692 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1693 DwarfAbbrevSectionSym);
1694 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1695 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1698 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1702 /// emitAbbreviations - Emit the abbreviation section.
1704 void DwarfDebug::emitAbbreviations() const {
1705 // Check to see if it is worth the effort.
1706 if (!Abbreviations.empty()) {
1707 // Start the debug abbrev section.
1708 Asm->OutStreamer.SwitchSection(
1709 Asm->getObjFileLowering().getDwarfAbbrevSection());
1711 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1713 // For each abbrevation.
1714 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1715 // Get abbreviation data
1716 const DIEAbbrev *Abbrev = Abbreviations[i];
1718 // Emit the abbrevations code (base 1 index.)
1719 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1721 // Emit the abbreviations data.
1725 // Mark end of abbreviations.
1726 Asm->EmitULEB128(0, "EOM(3)");
1728 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1732 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1733 /// the line matrix.
1735 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1736 // Define last address of section.
1737 Asm->OutStreamer.AddComment("Extended Op");
1740 Asm->OutStreamer.AddComment("Op size");
1741 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1742 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1743 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1745 Asm->OutStreamer.AddComment("Section end label");
1747 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1748 Asm->getTargetData().getPointerSize(),
1751 // Mark end of matrix.
1752 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1758 /// emitAccelNames - Emit visible names into a hashed accelerator table
1760 void DwarfDebug::emitAccelNames() {
1761 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1762 dwarf::DW_FORM_data4));
1763 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1764 E = CUMap.end(); I != E; ++I) {
1765 CompileUnit *TheCU = I->second;
1766 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1767 for (StringMap<std::vector<DIE*> >::const_iterator
1768 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1769 const char *Name = GI->getKeyData();
1770 std::vector<DIE *> Entities = GI->second;
1771 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1772 DE = Entities.end(); DI != DE; ++DI)
1773 AT.AddName(Name, (*DI));
1777 AT.FinalizeTable(Asm, "Names");
1778 Asm->OutStreamer.SwitchSection(
1779 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1780 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1781 Asm->OutStreamer.EmitLabel(SectionBegin);
1783 // Emit the full data.
1784 AT.Emit(Asm, SectionBegin, this);
1787 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1788 /// accelerator table section.
1789 void DwarfDebug::emitAccelObjC() {
1790 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1791 dwarf::DW_FORM_data4));
1792 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1793 E = CUMap.end(); I != E; ++I) {
1794 CompileUnit *TheCU = I->second;
1795 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1796 for (StringMap<std::vector<DIE*> >::const_iterator
1797 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1798 const char *Name = GI->getKeyData();
1799 std::vector<DIE *> Entities = GI->second;
1800 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1801 DE = Entities.end(); DI != DE; ++DI)
1802 AT.AddName(Name, (*DI));
1806 AT.FinalizeTable(Asm, "ObjC");
1807 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1808 .getDwarfAccelObjCSection());
1809 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1810 Asm->OutStreamer.EmitLabel(SectionBegin);
1812 // Emit the full data.
1813 AT.Emit(Asm, SectionBegin, this);
1816 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1818 void DwarfDebug::emitAccelNamespaces() {
1819 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1820 dwarf::DW_FORM_data4));
1821 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1822 E = CUMap.end(); I != E; ++I) {
1823 CompileUnit *TheCU = I->second;
1824 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1825 for (StringMap<std::vector<DIE*> >::const_iterator
1826 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1827 const char *Name = GI->getKeyData();
1828 std::vector<DIE *> Entities = GI->second;
1829 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1830 DE = Entities.end(); DI != DE; ++DI)
1831 AT.AddName(Name, (*DI));
1835 AT.FinalizeTable(Asm, "namespac");
1836 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1837 .getDwarfAccelNamespaceSection());
1838 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1839 Asm->OutStreamer.EmitLabel(SectionBegin);
1841 // Emit the full data.
1842 AT.Emit(Asm, SectionBegin, this);
1845 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1846 void DwarfDebug::emitAccelTypes() {
1847 std::vector<DwarfAccelTable::Atom> Atoms;
1848 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1849 dwarf::DW_FORM_data4));
1850 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1851 dwarf::DW_FORM_data2));
1852 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1853 dwarf::DW_FORM_data1));
1854 DwarfAccelTable AT(Atoms);
1855 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1856 E = CUMap.end(); I != E; ++I) {
1857 CompileUnit *TheCU = I->second;
1858 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1859 = TheCU->getAccelTypes();
1860 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1861 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1862 const char *Name = GI->getKeyData();
1863 std::vector<std::pair<DIE *, unsigned> > Entities = GI->second;
1864 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1865 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1866 AT.AddName(Name, (*DI).first, (*DI).second);
1870 AT.FinalizeTable(Asm, "types");
1871 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1872 .getDwarfAccelTypesSection());
1873 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1874 Asm->OutStreamer.EmitLabel(SectionBegin);
1876 // Emit the full data.
1877 AT.Emit(Asm, SectionBegin, this);
1880 void DwarfDebug::emitDebugPubTypes() {
1881 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1882 E = CUMap.end(); I != E; ++I) {
1883 CompileUnit *TheCU = I->second;
1884 // Start the dwarf pubtypes section.
1885 Asm->OutStreamer.SwitchSection(
1886 Asm->getObjFileLowering().getDwarfPubTypesSection());
1887 Asm->OutStreamer.AddComment("Length of Public Types Info");
1888 Asm->EmitLabelDifference(
1889 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1890 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1892 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1895 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1896 Asm->EmitInt16(dwarf::DWARF_VERSION);
1898 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1899 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1900 DwarfInfoSectionSym);
1902 Asm->OutStreamer.AddComment("Compilation Unit Length");
1903 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1904 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1907 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1908 for (StringMap<DIE*>::const_iterator
1909 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1910 const char *Name = GI->getKeyData();
1911 DIE *Entity = GI->second;
1913 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1914 Asm->EmitInt32(Entity->getOffset());
1916 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1917 // Emit the name with a terminating null byte.
1918 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1921 Asm->OutStreamer.AddComment("End Mark");
1923 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1928 /// emitDebugStr - Emit visible names into a debug str section.
1930 void DwarfDebug::emitDebugStr() {
1931 // Check to see if it is worth the effort.
1932 if (StringPool.empty()) return;
1934 // Start the dwarf str section.
1935 Asm->OutStreamer.SwitchSection(
1936 Asm->getObjFileLowering().getDwarfStrSection());
1938 // Get all of the string pool entries and put them in an array by their ID so
1939 // we can sort them.
1940 SmallVector<std::pair<unsigned,
1941 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1943 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1944 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1945 Entries.push_back(std::make_pair(I->second.second, &*I));
1947 array_pod_sort(Entries.begin(), Entries.end());
1949 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1950 // Emit a label for reference from debug information entries.
1951 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1953 // Emit the string itself with a terminating null byte.
1954 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1955 Entries[i].second->getKeyLength()+1),
1960 /// emitDebugLoc - Emit visible names into a debug loc section.
1962 void DwarfDebug::emitDebugLoc() {
1963 if (DotDebugLocEntries.empty())
1966 for (SmallVector<DotDebugLocEntry, 4>::iterator
1967 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1969 DotDebugLocEntry &Entry = *I;
1970 if (I + 1 != DotDebugLocEntries.end())
1974 // Start the dwarf loc section.
1975 Asm->OutStreamer.SwitchSection(
1976 Asm->getObjFileLowering().getDwarfLocSection());
1977 unsigned char Size = Asm->getTargetData().getPointerSize();
1978 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1980 for (SmallVector<DotDebugLocEntry, 4>::iterator
1981 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1982 I != E; ++I, ++index) {
1983 DotDebugLocEntry &Entry = *I;
1984 if (Entry.isMerged()) continue;
1985 if (Entry.isEmpty()) {
1986 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1987 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1988 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1990 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1991 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1992 DIVariable DV(Entry.Variable);
1993 Asm->OutStreamer.AddComment("Loc expr size");
1994 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1995 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1996 Asm->EmitLabelDifference(end, begin, 2);
1997 Asm->OutStreamer.EmitLabel(begin);
1998 if (Entry.isInt()) {
1999 DIBasicType BTy(DV.getType());
2001 (BTy.getEncoding() == dwarf::DW_ATE_signed
2002 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2003 Asm->OutStreamer.AddComment("DW_OP_consts");
2004 Asm->EmitInt8(dwarf::DW_OP_consts);
2005 Asm->EmitSLEB128(Entry.getInt());
2007 Asm->OutStreamer.AddComment("DW_OP_constu");
2008 Asm->EmitInt8(dwarf::DW_OP_constu);
2009 Asm->EmitULEB128(Entry.getInt());
2011 } else if (Entry.isLocation()) {
2012 if (!DV.hasComplexAddress())
2014 Asm->EmitDwarfRegOp(Entry.Loc);
2016 // Complex address entry.
2017 unsigned N = DV.getNumAddrElements();
2019 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2020 if (Entry.Loc.getOffset()) {
2022 Asm->EmitDwarfRegOp(Entry.Loc);
2023 Asm->OutStreamer.AddComment("DW_OP_deref");
2024 Asm->EmitInt8(dwarf::DW_OP_deref);
2025 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2026 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2027 Asm->EmitSLEB128(DV.getAddrElement(1));
2029 // If first address element is OpPlus then emit
2030 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2031 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2032 Asm->EmitDwarfRegOp(Loc);
2036 Asm->EmitDwarfRegOp(Entry.Loc);
2039 // Emit remaining complex address elements.
2040 for (; i < N; ++i) {
2041 uint64_t Element = DV.getAddrElement(i);
2042 if (Element == DIBuilder::OpPlus) {
2043 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2044 Asm->EmitULEB128(DV.getAddrElement(++i));
2045 } else if (Element == DIBuilder::OpDeref)
2046 Asm->EmitInt8(dwarf::DW_OP_deref);
2047 else llvm_unreachable("unknown Opcode found in complex address");
2051 // else ... ignore constant fp. There is not any good way to
2052 // to represent them here in dwarf.
2053 Asm->OutStreamer.EmitLabel(end);
2058 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2060 void DwarfDebug::EmitDebugARanges() {
2061 // Start the dwarf aranges section.
2062 Asm->OutStreamer.SwitchSection(
2063 Asm->getObjFileLowering().getDwarfARangesSection());
2066 /// emitDebugRanges - Emit visible names into a debug ranges section.
2068 void DwarfDebug::emitDebugRanges() {
2069 // Start the dwarf ranges section.
2070 Asm->OutStreamer.SwitchSection(
2071 Asm->getObjFileLowering().getDwarfRangesSection());
2072 unsigned char Size = Asm->getTargetData().getPointerSize();
2073 for (SmallVector<const MCSymbol *, 8>::iterator
2074 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2077 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2079 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2083 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2085 void DwarfDebug::emitDebugMacInfo() {
2086 if (const MCSection *LineInfo =
2087 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2088 // Start the dwarf macinfo section.
2089 Asm->OutStreamer.SwitchSection(LineInfo);
2093 /// emitDebugInlineInfo - Emit inline info using following format.
2095 /// 1. length of section
2096 /// 2. Dwarf version number
2097 /// 3. address size.
2099 /// Entries (one "entry" for each function that was inlined):
2101 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2102 /// otherwise offset into __debug_str for regular function name.
2103 /// 2. offset into __debug_str section for regular function name.
2104 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2105 /// instances for the function.
2107 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2108 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2109 /// __debug_info section, and the low_pc is the starting address for the
2110 /// inlining instance.
2111 void DwarfDebug::emitDebugInlineInfo() {
2112 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2118 Asm->OutStreamer.SwitchSection(
2119 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2121 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2122 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2123 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2125 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2127 Asm->OutStreamer.AddComment("Dwarf Version");
2128 Asm->EmitInt16(dwarf::DWARF_VERSION);
2129 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2130 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2132 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2133 E = InlinedSPNodes.end(); I != E; ++I) {
2135 const MDNode *Node = *I;
2136 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2137 = InlineInfo.find(Node);
2138 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2139 DISubprogram SP(Node);
2140 StringRef LName = SP.getLinkageName();
2141 StringRef Name = SP.getName();
2143 Asm->OutStreamer.AddComment("MIPS linkage name");
2144 if (LName.empty()) {
2145 Asm->OutStreamer.EmitBytes(Name, 0);
2146 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2148 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2149 DwarfStrSectionSym);
2151 Asm->OutStreamer.AddComment("Function name");
2152 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2153 Asm->EmitULEB128(Labels.size(), "Inline count");
2155 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2156 LE = Labels.end(); LI != LE; ++LI) {
2157 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2158 Asm->EmitInt32(LI->second->getOffset());
2160 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2161 Asm->OutStreamer.EmitSymbolValue(LI->first,
2162 Asm->getTargetData().getPointerSize(),0);
2166 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));