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/DebugInfo.h"
21 #include "llvm/DIBuilder.h"
22 #include "llvm/Module.h"
23 #include "llvm/Instructions.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCSection.h"
28 #include "llvm/MC/MCStreamer.h"
29 #include "llvm/MC/MCSymbol.h"
30 #include "llvm/Target/TargetData.h"
31 #include "llvm/Target/TargetFrameLowering.h"
32 #include "llvm/Target/TargetLoweringObjectFile.h"
33 #include "llvm/Target/TargetMachine.h"
34 #include "llvm/Target/TargetRegisterInfo.h"
35 #include "llvm/Target/TargetOptions.h"
36 #include "llvm/ADT/Statistic.h"
37 #include "llvm/ADT/STLExtras.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/ADT/Triple.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),
129 SourceIdMap(DIEValueAllocator), StringPool(DIEValueAllocator),
131 NextStringPoolNumber = 0;
133 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
134 DwarfStrSectionSym = TextSectionSym = 0;
135 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
136 FunctionBeginSym = FunctionEndSym = 0;
138 // Turn on accelerator tables for Darwin.
139 if (Triple(M->getTargetTriple()).isOSDarwin())
140 DwarfAccelTables = true;
143 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
147 DwarfDebug::~DwarfDebug() {
150 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
151 /// temporary label to it if SymbolStem is specified.
152 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
153 const char *SymbolStem = 0) {
154 Asm->OutStreamer.SwitchSection(Section);
155 if (!SymbolStem) return 0;
157 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
158 Asm->OutStreamer.EmitLabel(TmpSym);
162 MCSymbol *DwarfDebug::getStringPool() {
163 return Asm->GetTempSymbol("section_str");
166 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
167 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
168 if (Entry.first) return Entry.first;
170 Entry.second = NextStringPoolNumber++;
171 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
174 /// assignAbbrevNumber - Define a unique number for the abbreviation.
176 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
177 // Profile the node so that we can make it unique.
181 // Check the set for priors.
182 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
184 // If it's newly added.
185 if (InSet == &Abbrev) {
186 // Add to abbreviation list.
187 Abbreviations.push_back(&Abbrev);
189 // Assign the vector position + 1 as its number.
190 Abbrev.setNumber(Abbreviations.size());
192 // Assign existing abbreviation number.
193 Abbrev.setNumber(InSet->getNumber());
197 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
198 /// printer to not emit usual symbol prefix before the symbol name is used then
199 /// return linkage name after skipping this special LLVM prefix.
200 static StringRef getRealLinkageName(StringRef LinkageName) {
202 if (LinkageName.startswith(StringRef(&One, 1)))
203 return LinkageName.substr(1);
207 static bool isObjCClass(StringRef Name) {
208 return Name.startswith("+") || Name.startswith("-");
211 static bool hasObjCCategory(StringRef Name) {
212 if (!isObjCClass(Name)) return false;
214 size_t pos = Name.find(')');
215 if (pos != std::string::npos) {
216 if (Name[pos+1] != ' ') return false;
222 static void getObjCClassCategory(StringRef In, StringRef &Class,
223 StringRef &Category) {
224 if (!hasObjCCategory(In)) {
225 Class = In.slice(In.find('[') + 1, In.find(' '));
230 Class = In.slice(In.find('[') + 1, In.find('('));
231 Category = In.slice(In.find('[') + 1, In.find(' '));
235 static StringRef getObjCMethodName(StringRef In) {
236 return In.slice(In.find(' ') + 1, In.find(']'));
239 // Add the various names to the Dwarf accelerator table names.
240 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
242 if (!SP.isDefinition()) return;
244 TheCU->addAccelName(SP.getName(), Die);
246 // If the linkage name is different than the name, go ahead and output
247 // that as well into the name table.
248 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
249 TheCU->addAccelName(SP.getLinkageName(), Die);
251 // If this is an Objective-C selector name add it to the ObjC accelerator
253 if (isObjCClass(SP.getName())) {
254 StringRef Class, Category;
255 getObjCClassCategory(SP.getName(), Class, Category);
256 TheCU->addAccelObjC(Class, Die);
258 TheCU->addAccelObjC(Category, Die);
259 // Also add the base method name to the name table.
260 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
264 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
265 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
266 /// If there are global variables in this scope then create and insert
267 /// DIEs for these variables.
268 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
269 const MDNode *SPNode) {
270 DIE *SPDie = SPCU->getDIE(SPNode);
272 assert(SPDie && "Unable to find subprogram DIE!");
273 DISubprogram SP(SPNode);
275 DISubprogram SPDecl = SP.getFunctionDeclaration();
276 if (!SPDecl.isSubprogram()) {
277 // There is not any need to generate specification DIE for a function
278 // defined at compile unit level. If a function is defined inside another
279 // function then gdb prefers the definition at top level and but does not
280 // expect specification DIE in parent function. So avoid creating
281 // specification DIE for a function defined inside a function.
282 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
283 !SP.getContext().isFile() &&
284 !isSubprogramContext(SP.getContext())) {
285 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
288 DICompositeType SPTy = SP.getType();
289 DIArray Args = SPTy.getTypeArray();
290 unsigned SPTag = SPTy.getTag();
291 if (SPTag == dwarf::DW_TAG_subroutine_type)
292 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
293 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
294 DIType ATy = DIType(DIType(Args.getElement(i)));
295 SPCU->addType(Arg, ATy);
296 if (ATy.isArtificial())
297 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
298 SPDie->addChild(Arg);
300 DIE *SPDeclDie = SPDie;
301 SPDie = new DIE(dwarf::DW_TAG_subprogram);
302 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
307 // Pick up abstract subprogram DIE.
308 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
309 SPDie = new DIE(dwarf::DW_TAG_subprogram);
310 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
311 dwarf::DW_FORM_ref4, AbsSPDIE);
315 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
316 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
317 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
318 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
319 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
320 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
321 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
323 // Add name to the name table, we do this here because we're guaranteed
324 // to have concrete versions of our DW_TAG_subprogram nodes.
325 addSubprogramNames(SPCU, SP, SPDie);
330 /// constructLexicalScope - Construct new DW_TAG_lexical_block
331 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
332 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
333 LexicalScope *Scope) {
334 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
335 if (Scope->isAbstractScope())
338 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
342 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
343 if (Ranges.size() > 1) {
344 // .debug_range section has not been laid out yet. Emit offset in
345 // .debug_range as a uint, size 4, for now. emitDIE will handle
346 // DW_AT_ranges appropriately.
347 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
348 DebugRangeSymbols.size()
349 * Asm->getTargetData().getPointerSize());
350 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
351 RE = Ranges.end(); RI != RE; ++RI) {
352 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
353 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
355 DebugRangeSymbols.push_back(NULL);
356 DebugRangeSymbols.push_back(NULL);
360 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
361 const MCSymbol *End = getLabelAfterInsn(RI->second);
363 if (End == 0) return 0;
365 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
366 assert(End->isDefined() && "Invalid end label for an inlined scope!");
368 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
369 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
374 /// constructInlinedScopeDIE - This scope represents inlined body of
375 /// a function. Construct DIE to represent this concrete inlined copy
377 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
378 LexicalScope *Scope) {
379 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
380 assert(Ranges.empty() == false &&
381 "LexicalScope does not have instruction markers!");
383 if (!Scope->getScopeNode())
385 DIScope DS(Scope->getScopeNode());
386 DISubprogram InlinedSP = getDISubprogram(DS);
387 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
389 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
393 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
394 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
395 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
397 if (StartLabel == 0 || EndLabel == 0) {
398 llvm_unreachable("Unexpected Start and End labels for a inlined scope!");
400 assert(StartLabel->isDefined() &&
401 "Invalid starting label for an inlined scope!");
402 assert(EndLabel->isDefined() &&
403 "Invalid end label for an inlined scope!");
405 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
406 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
407 dwarf::DW_FORM_ref4, OriginDIE);
409 if (Ranges.size() > 1) {
410 // .debug_range section has not been laid out yet. Emit offset in
411 // .debug_range as a uint, size 4, for now. emitDIE will handle
412 // DW_AT_ranges appropriately.
413 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
414 DebugRangeSymbols.size()
415 * Asm->getTargetData().getPointerSize());
416 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
417 RE = Ranges.end(); RI != RE; ++RI) {
418 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
419 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
421 DebugRangeSymbols.push_back(NULL);
422 DebugRangeSymbols.push_back(NULL);
424 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
426 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
430 InlinedSubprogramDIEs.insert(OriginDIE);
432 // Track the start label for this inlined function.
433 //.debug_inlined section specification does not clearly state how
434 // to emit inlined scope that is split into multiple instruction ranges.
435 // For now, use first instruction range and emit low_pc/high_pc pair and
436 // corresponding .debug_inlined section entry for this pair.
437 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
438 I = InlineInfo.find(InlinedSP);
440 if (I == InlineInfo.end()) {
441 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
442 InlinedSPNodes.push_back(InlinedSP);
444 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
446 DILocation DL(Scope->getInlinedAt());
447 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
448 GetOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
449 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
451 // Add name to the name table, we do this here because we're guaranteed
452 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
453 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
458 /// constructScopeDIE - Construct a DIE for this scope.
459 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
460 if (!Scope || !Scope->getScopeNode())
463 SmallVector<DIE *, 8> Children;
465 // Collect arguments for current function.
466 if (LScopes.isCurrentFunctionScope(Scope))
467 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
468 if (DbgVariable *ArgDV = CurrentFnArguments[i])
470 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
471 Children.push_back(Arg);
473 // Collect lexical scope children first.
474 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
475 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
477 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
478 Children.push_back(Variable);
479 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
480 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
481 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
482 Children.push_back(Nested);
483 DIScope DS(Scope->getScopeNode());
484 DIE *ScopeDIE = NULL;
485 if (Scope->getInlinedAt())
486 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
487 else if (DS.isSubprogram()) {
488 ProcessedSPNodes.insert(DS);
489 if (Scope->isAbstractScope()) {
490 ScopeDIE = TheCU->getDIE(DS);
491 // Note down abstract DIE.
493 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
496 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
499 // There is no need to emit empty lexical block DIE.
500 if (Children.empty())
502 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
505 if (!ScopeDIE) return NULL;
508 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
509 E = Children.end(); I != E; ++I)
510 ScopeDIE->addChild(*I);
512 if (DS.isSubprogram())
513 TheCU->addPubTypes(DISubprogram(DS));
518 /// GetOrCreateSourceID - Look up the source id with the given directory and
519 /// source file names. If none currently exists, create a new id and insert it
520 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
522 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
524 // If FE did not provide a file name, then assume stdin.
525 if (FileName.empty())
526 return GetOrCreateSourceID("<stdin>", StringRef());
528 // TODO: this might not belong here. See if we can factor this better.
529 if (DirName == CompilationDir)
532 unsigned SrcId = SourceIdMap.size()+1;
534 // We look up the file/dir pair by concatenating them with a zero byte.
535 SmallString<128> NamePair;
537 NamePair += '\0'; // Zero bytes are not allowed in paths.
538 NamePair += FileName;
540 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
541 if (Ent.getValue() != SrcId)
542 return Ent.getValue();
544 // Print out a .file directive to specify files for .loc directives.
545 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
550 /// constructCompileUnit - Create new CompileUnit for the given
551 /// metadata node with tag DW_TAG_compile_unit.
552 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
553 DICompileUnit DIUnit(N);
554 StringRef FN = DIUnit.getFilename();
555 CompilationDir = DIUnit.getDirectory();
556 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
558 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
559 CompileUnit *NewCU = new CompileUnit(ID, DIUnit.getLanguage(), Die, Asm, this);
560 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
561 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
562 DIUnit.getLanguage());
563 NewCU->addString(Die, dwarf::DW_AT_name, FN);
564 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
566 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
567 // DW_AT_stmt_list is a offset of line number information for this
568 // compile unit in debug_line section.
569 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
570 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
571 Asm->GetTempSymbol("section_line"));
573 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
575 if (!CompilationDir.empty())
576 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
577 if (DIUnit.isOptimized())
578 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
580 StringRef Flags = DIUnit.getFlags();
582 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
584 if (unsigned RVer = DIUnit.getRunTimeVersion())
585 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
586 dwarf::DW_FORM_data1, RVer);
590 CUMap.insert(std::make_pair(N, NewCU));
594 /// construct SubprogramDIE - Construct subprogram DIE.
595 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
597 CompileUnit *&CURef = SPMap[N];
603 if (!SP.isDefinition())
604 // This is a method declaration which will be handled while constructing
608 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
611 TheCU->insertDIE(N, SubprogramDie);
613 // Add to context owner.
614 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
619 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
620 /// as llvm.dbg.enum and llvm.dbg.ty
621 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
622 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
623 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
624 const MDNode *N = NMD->getOperand(i);
625 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
626 constructSubprogramDIE(CU, N);
629 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
630 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
631 const MDNode *N = NMD->getOperand(i);
632 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
633 CU->createGlobalVariableDIE(N);
636 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
637 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
638 DIType Ty(NMD->getOperand(i));
639 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
640 CU->getOrCreateTypeDIE(Ty);
643 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
644 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
645 DIType Ty(NMD->getOperand(i));
646 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
647 CU->getOrCreateTypeDIE(Ty);
651 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
652 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
653 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
654 DebugInfoFinder DbgFinder;
655 DbgFinder.processModule(*M);
657 bool HasDebugInfo = false;
658 // Scan all the compile-units to see if there are any marked as the main
659 // unit. If not, we do not generate debug info.
660 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
661 E = DbgFinder.compile_unit_end(); I != E; ++I) {
662 if (DICompileUnit(*I).isMain()) {
667 if (!HasDebugInfo) return false;
669 // Create all the compile unit DIEs.
670 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
671 E = DbgFinder.compile_unit_end(); I != E; ++I)
672 constructCompileUnit(*I);
674 // Create DIEs for each global variable.
675 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
676 E = DbgFinder.global_variable_end(); I != E; ++I) {
677 const MDNode *N = *I;
678 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
679 CU->createGlobalVariableDIE(N);
682 // Create DIEs for each subprogram.
683 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
684 E = DbgFinder.subprogram_end(); I != E; ++I) {
685 const MDNode *N = *I;
686 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
687 constructSubprogramDIE(CU, N);
693 /// beginModule - Emit all Dwarf sections that should come prior to the
694 /// content. Create global DIEs and emit initial debug info sections.
695 /// This is invoked by the target AsmPrinter.
696 void DwarfDebug::beginModule(Module *M) {
697 if (DisableDebugInfoPrinting)
700 // If module has named metadata anchors then use them, otherwise scan the
701 // module using debug info finder to collect debug info.
702 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
704 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
705 DICompileUnit CUNode(CU_Nodes->getOperand(i));
706 CompileUnit *CU = constructCompileUnit(CUNode);
707 DIArray GVs = CUNode.getGlobalVariables();
708 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
709 CU->createGlobalVariableDIE(GVs.getElement(i));
710 DIArray SPs = CUNode.getSubprograms();
711 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
712 constructSubprogramDIE(CU, SPs.getElement(i));
713 DIArray EnumTypes = CUNode.getEnumTypes();
714 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
715 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
716 DIArray RetainedTypes = CUNode.getRetainedTypes();
717 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
718 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
720 } else if (!collectLegacyDebugInfo(M))
723 collectInfoFromNamedMDNodes(M);
725 // Tell MMI that we have debug info.
726 MMI->setDebugInfoAvailability(true);
728 // Emit initial sections.
731 // Prime section data.
732 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
735 /// endModule - Emit all Dwarf sections that should come after the content.
737 void DwarfDebug::endModule() {
738 if (!FirstCU) return;
739 const Module *M = MMI->getModule();
740 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
742 // Collect info for variables that were optimized out.
743 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
744 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
745 DICompileUnit TheCU(CU_Nodes->getOperand(i));
746 DIArray Subprograms = TheCU.getSubprograms();
747 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
748 DISubprogram SP(Subprograms.getElement(i));
749 if (ProcessedSPNodes.count(SP) != 0) continue;
750 if (!SP.Verify()) continue;
751 if (!SP.isDefinition()) continue;
752 DIArray Variables = SP.getVariables();
753 if (Variables.getNumElements() == 0) continue;
755 LexicalScope *Scope =
756 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
757 DeadFnScopeMap[SP] = Scope;
759 // Construct subprogram DIE and add variables DIEs.
760 CompileUnit *SPCU = CUMap.lookup(TheCU);
761 assert(SPCU && "Unable to find Compile Unit!");
762 constructSubprogramDIE(SPCU, SP);
763 DIE *ScopeDIE = SPCU->getDIE(SP);
764 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
765 DIVariable DV(Variables.getElement(vi));
766 if (!DV.Verify()) continue;
767 DbgVariable *NewVar = new DbgVariable(DV, NULL);
768 if (DIE *VariableDIE =
769 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
770 ScopeDIE->addChild(VariableDIE);
776 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
777 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
778 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
780 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
782 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
783 AE = AbstractSPDies.end(); AI != AE; ++AI) {
784 DIE *ISP = AI->second;
785 if (InlinedSubprogramDIEs.count(ISP))
787 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
790 // Emit DW_AT_containing_type attribute to connect types with their
791 // vtable holding type.
792 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
793 CUE = CUMap.end(); CUI != CUE; ++CUI) {
794 CompileUnit *TheCU = CUI->second;
795 TheCU->constructContainingTypeDIEs();
798 // Standard sections final addresses.
799 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
800 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
801 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
802 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
804 // End text sections.
805 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
806 Asm->OutStreamer.SwitchSection(SectionMap[i]);
807 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
810 // Compute DIE offsets and sizes.
811 computeSizeAndOffsets();
813 // Emit all the DIEs into a debug info section
816 // Corresponding abbreviations into a abbrev section.
819 // Emit info into a dwarf accelerator table sections.
820 if (DwarfAccelTables) {
823 emitAccelNamespaces();
827 // Emit info into a debug pubtypes section.
830 // Emit info into a debug loc section.
833 // Emit info into a debug aranges section.
836 // Emit info into a debug ranges section.
839 // Emit info into a debug macinfo section.
843 emitDebugInlineInfo();
845 // Emit info into a debug str section.
849 DeleteContainerSeconds(DeadFnScopeMap);
851 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
852 E = CUMap.end(); I != E; ++I)
854 FirstCU = NULL; // Reset for the next Module, if any.
857 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
858 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
860 LLVMContext &Ctx = DV->getContext();
861 // More then one inlined variable corresponds to one abstract variable.
862 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
863 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
865 return AbsDbgVariable;
867 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
871 AbsDbgVariable = new DbgVariable(Var, NULL);
872 addScopeVariable(Scope, AbsDbgVariable);
873 AbstractVariables[Var] = AbsDbgVariable;
874 return AbsDbgVariable;
877 /// addCurrentFnArgument - If Var is a current function argument then add
878 /// it to CurrentFnArguments list.
879 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
880 DbgVariable *Var, LexicalScope *Scope) {
881 if (!LScopes.isCurrentFunctionScope(Scope))
883 DIVariable DV = Var->getVariable();
884 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
886 unsigned ArgNo = DV.getArgNumber();
890 size_t Size = CurrentFnArguments.size();
892 CurrentFnArguments.resize(MF->getFunction()->arg_size());
893 // llvm::Function argument size is not good indicator of how many
894 // arguments does the function have at source level.
896 CurrentFnArguments.resize(ArgNo * 2);
897 CurrentFnArguments[ArgNo - 1] = Var;
901 /// collectVariableInfoFromMMITable - Collect variable information from
902 /// side table maintained by MMI.
904 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
905 SmallPtrSet<const MDNode *, 16> &Processed) {
906 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
907 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
908 VE = VMap.end(); VI != VE; ++VI) {
909 const MDNode *Var = VI->first;
911 Processed.insert(Var);
913 const std::pair<unsigned, DebugLoc> &VP = VI->second;
915 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
917 // If variable scope is not found then skip this variable.
921 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
922 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
923 RegVar->setFrameIndex(VP.first);
924 if (!addCurrentFnArgument(MF, RegVar, Scope))
925 addScopeVariable(Scope, RegVar);
927 AbsDbgVariable->setFrameIndex(VP.first);
931 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
932 /// DBG_VALUE instruction, is in a defined reg.
933 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
934 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
935 return MI->getNumOperands() == 3 &&
936 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
937 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
940 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
942 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
943 const MCSymbol *FLabel,
944 const MCSymbol *SLabel,
945 const MachineInstr *MI) {
946 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
948 if (MI->getNumOperands() != 3) {
949 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
950 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
952 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
953 MachineLocation MLoc;
954 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
955 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
957 if (MI->getOperand(0).isImm())
958 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
959 if (MI->getOperand(0).isFPImm())
960 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
961 if (MI->getOperand(0).isCImm())
962 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
964 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
967 /// collectVariableInfo - Find variables for each lexical scope.
969 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
970 SmallPtrSet<const MDNode *, 16> &Processed) {
972 /// collection info from MMI table.
973 collectVariableInfoFromMMITable(MF, Processed);
975 for (SmallVectorImpl<const MDNode*>::const_iterator
976 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
978 const MDNode *Var = *UVI;
979 if (Processed.count(Var))
982 // History contains relevant DBG_VALUE instructions for Var and instructions
984 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
987 const MachineInstr *MInsn = History.front();
990 LexicalScope *Scope = NULL;
991 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
992 DISubprogram(DV.getContext()).describes(MF->getFunction()))
993 Scope = LScopes.getCurrentFunctionScope();
995 if (DV.getVersion() <= LLVMDebugVersion9)
996 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
998 if (MDNode *IA = DV.getInlinedAt())
999 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1001 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1004 // If variable scope is not found then skip this variable.
1008 Processed.insert(DV);
1009 assert(MInsn->isDebugValue() && "History must begin with debug value");
1010 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1011 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1012 if (!addCurrentFnArgument(MF, RegVar, Scope))
1013 addScopeVariable(Scope, RegVar);
1015 AbsVar->setMInsn(MInsn);
1017 // Simple ranges that are fully coalesced.
1018 if (History.size() <= 1 || (History.size() == 2 &&
1019 MInsn->isIdenticalTo(History.back()))) {
1020 RegVar->setMInsn(MInsn);
1024 // handle multiple DBG_VALUE instructions describing one variable.
1025 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1027 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1028 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1029 const MachineInstr *Begin = *HI;
1030 assert(Begin->isDebugValue() && "Invalid History entry");
1032 // Check if DBG_VALUE is truncating a range.
1033 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1034 && !Begin->getOperand(0).getReg())
1037 // Compute the range for a register location.
1038 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1039 const MCSymbol *SLabel = 0;
1042 // If Begin is the last instruction in History then its value is valid
1043 // until the end of the function.
1044 SLabel = FunctionEndSym;
1046 const MachineInstr *End = HI[1];
1047 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1048 << "\t" << *Begin << "\t" << *End << "\n");
1049 if (End->isDebugValue())
1050 SLabel = getLabelBeforeInsn(End);
1052 // End is a normal instruction clobbering the range.
1053 SLabel = getLabelAfterInsn(End);
1054 assert(SLabel && "Forgot label after clobber instruction");
1059 // The value is valid until the next DBG_VALUE or clobber.
1060 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1063 DotDebugLocEntries.push_back(DotDebugLocEntry());
1066 // Collect info for variables that were optimized out.
1067 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1068 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1069 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1070 DIVariable DV(Variables.getElement(i));
1071 if (!DV || !DV.Verify() || !Processed.insert(DV))
1073 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1074 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1078 /// getLabelBeforeInsn - Return Label preceding the instruction.
1079 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1080 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1081 assert(Label && "Didn't insert label before instruction");
1085 /// getLabelAfterInsn - Return Label immediately following the instruction.
1086 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1087 return LabelsAfterInsn.lookup(MI);
1090 /// beginInstruction - Process beginning of an instruction.
1091 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1092 // Check if source location changes, but ignore DBG_VALUE locations.
1093 if (!MI->isDebugValue()) {
1094 DebugLoc DL = MI->getDebugLoc();
1095 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1098 if (DL == PrologEndLoc) {
1099 Flags |= DWARF2_FLAG_PROLOGUE_END;
1100 PrologEndLoc = DebugLoc();
1102 if (PrologEndLoc.isUnknown())
1103 Flags |= DWARF2_FLAG_IS_STMT;
1105 if (!DL.isUnknown()) {
1106 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1107 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1109 recordSourceLine(0, 0, 0, 0);
1113 // Insert labels where requested.
1114 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1115 LabelsBeforeInsn.find(MI);
1118 if (I == LabelsBeforeInsn.end())
1121 // Label already assigned.
1126 PrevLabel = MMI->getContext().CreateTempSymbol();
1127 Asm->OutStreamer.EmitLabel(PrevLabel);
1129 I->second = PrevLabel;
1132 /// endInstruction - Process end of an instruction.
1133 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1134 // Don't create a new label after DBG_VALUE instructions.
1135 // They don't generate code.
1136 if (!MI->isDebugValue())
1139 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1140 LabelsAfterInsn.find(MI);
1143 if (I == LabelsAfterInsn.end())
1146 // Label already assigned.
1150 // We need a label after this instruction.
1152 PrevLabel = MMI->getContext().CreateTempSymbol();
1153 Asm->OutStreamer.EmitLabel(PrevLabel);
1155 I->second = PrevLabel;
1158 /// identifyScopeMarkers() -
1159 /// Each LexicalScope has first instruction and last instruction to mark
1160 /// beginning and end of a scope respectively. Create an inverse map that list
1161 /// scopes starts (and ends) with an instruction. One instruction may start (or
1162 /// end) multiple scopes. Ignore scopes that are not reachable.
1163 void DwarfDebug::identifyScopeMarkers() {
1164 SmallVector<LexicalScope *, 4> WorkList;
1165 WorkList.push_back(LScopes.getCurrentFunctionScope());
1166 while (!WorkList.empty()) {
1167 LexicalScope *S = WorkList.pop_back_val();
1169 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1170 if (!Children.empty())
1171 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1172 SE = Children.end(); SI != SE; ++SI)
1173 WorkList.push_back(*SI);
1175 if (S->isAbstractScope())
1178 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1181 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1182 RE = Ranges.end(); RI != RE; ++RI) {
1183 assert(RI->first && "InsnRange does not have first instruction!");
1184 assert(RI->second && "InsnRange does not have second instruction!");
1185 requestLabelBeforeInsn(RI->first);
1186 requestLabelAfterInsn(RI->second);
1191 /// getScopeNode - Get MDNode for DebugLoc's scope.
1192 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1193 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1194 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1195 return DL.getScope(Ctx);
1198 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1199 /// line number info for the function.
1200 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1201 const MDNode *Scope = getScopeNode(DL, Ctx);
1202 DISubprogram SP = getDISubprogram(Scope);
1204 // Check for number of operands since the compatibility is
1206 if (SP->getNumOperands() > 19)
1207 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1209 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1215 /// beginFunction - Gather pre-function debug information. Assumes being
1216 /// emitted immediately after the function entry point.
1217 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1218 if (!MMI->hasDebugInfo()) return;
1219 LScopes.initialize(*MF);
1220 if (LScopes.empty()) return;
1221 identifyScopeMarkers();
1223 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1224 Asm->getFunctionNumber());
1225 // Assumes in correct section after the entry point.
1226 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1228 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1230 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1231 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1232 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1234 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1236 bool AtBlockEntry = true;
1237 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1239 const MachineInstr *MI = II;
1241 if (MI->isDebugValue()) {
1242 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1244 // Keep track of user variables.
1246 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1248 // Variable is in a register, we need to check for clobbers.
1249 if (isDbgValueInDefinedReg(MI))
1250 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1252 // Check the history of this variable.
1253 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1254 if (History.empty()) {
1255 UserVariables.push_back(Var);
1256 // The first mention of a function argument gets the FunctionBeginSym
1257 // label, so arguments are visible when breaking at function entry.
1259 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1260 DISubprogram(getDISubprogram(DV.getContext()))
1261 .describes(MF->getFunction()))
1262 LabelsBeforeInsn[MI] = FunctionBeginSym;
1264 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1265 const MachineInstr *Prev = History.back();
1266 if (Prev->isDebugValue()) {
1267 // Coalesce identical entries at the end of History.
1268 if (History.size() >= 2 &&
1269 Prev->isIdenticalTo(History[History.size() - 2])) {
1270 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1272 << "\t" << *History[History.size() - 2] << "\n");
1276 // Terminate old register assignments that don't reach MI;
1277 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1278 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1279 isDbgValueInDefinedReg(Prev)) {
1280 // Previous register assignment needs to terminate at the end of
1282 MachineBasicBlock::const_iterator LastMI =
1283 PrevMBB->getLastNonDebugInstr();
1284 if (LastMI == PrevMBB->end()) {
1285 // Drop DBG_VALUE for empty range.
1286 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1287 << "\t" << *Prev << "\n");
1291 // Terminate after LastMI.
1292 History.push_back(LastMI);
1297 History.push_back(MI);
1299 // Not a DBG_VALUE instruction.
1301 AtBlockEntry = false;
1303 // First known non DBG_VALUE location marks beginning of function
1305 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1306 PrologEndLoc = MI->getDebugLoc();
1308 // Check if the instruction clobbers any registers with debug vars.
1309 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1310 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1311 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1313 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1314 AI.isValid(); ++AI) {
1316 const MDNode *Var = LiveUserVar[Reg];
1319 // Reg is now clobbered.
1320 LiveUserVar[Reg] = 0;
1322 // Was MD last defined by a DBG_VALUE referring to Reg?
1323 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1324 if (HistI == DbgValues.end())
1326 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1327 if (History.empty())
1329 const MachineInstr *Prev = History.back();
1330 // Sanity-check: Register assignments are terminated at the end of
1332 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1334 // Is the variable still in Reg?
1335 if (!isDbgValueInDefinedReg(Prev) ||
1336 Prev->getOperand(0).getReg() != Reg)
1338 // Var is clobbered. Make sure the next instruction gets a label.
1339 History.push_back(MI);
1346 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1348 SmallVectorImpl<const MachineInstr*> &History = I->second;
1349 if (History.empty())
1352 // Make sure the final register assignments are terminated.
1353 const MachineInstr *Prev = History.back();
1354 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1355 const MachineBasicBlock *PrevMBB = Prev->getParent();
1356 MachineBasicBlock::const_iterator LastMI =
1357 PrevMBB->getLastNonDebugInstr();
1358 if (LastMI == PrevMBB->end())
1359 // Drop DBG_VALUE for empty range.
1362 // Terminate after LastMI.
1363 History.push_back(LastMI);
1366 // Request labels for the full history.
1367 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1368 const MachineInstr *MI = History[i];
1369 if (MI->isDebugValue())
1370 requestLabelBeforeInsn(MI);
1372 requestLabelAfterInsn(MI);
1376 PrevInstLoc = DebugLoc();
1377 PrevLabel = FunctionBeginSym;
1379 // Record beginning of function.
1380 if (!PrologEndLoc.isUnknown()) {
1381 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1382 MF->getFunction()->getContext());
1383 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1384 FnStartDL.getScope(MF->getFunction()->getContext()),
1389 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1390 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1391 ScopeVariables[LS].push_back(Var);
1392 // Vars.push_back(Var);
1395 /// endFunction - Gather and emit post-function debug information.
1397 void DwarfDebug::endFunction(const MachineFunction *MF) {
1398 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1400 // Define end label for subprogram.
1401 FunctionEndSym = Asm->GetTempSymbol("func_end",
1402 Asm->getFunctionNumber());
1403 // Assumes in correct section after the entry point.
1404 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1406 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1407 collectVariableInfo(MF, ProcessedVars);
1409 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1410 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1411 assert(TheCU && "Unable to find compile unit!");
1413 // Construct abstract scopes.
1414 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1415 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1416 LexicalScope *AScope = AList[i];
1417 DISubprogram SP(AScope->getScopeNode());
1419 // Collect info for variables that were optimized out.
1420 DIArray Variables = SP.getVariables();
1421 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1422 DIVariable DV(Variables.getElement(i));
1423 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1425 // Check that DbgVariable for DV wasn't created earlier, when
1426 // findAbstractVariable() was called for inlined instance of DV.
1427 LLVMContext &Ctx = DV->getContext();
1428 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1429 if (AbstractVariables.lookup(CleanDV))
1431 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1432 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1435 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1436 constructScopeDIE(TheCU, AScope);
1439 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1441 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1442 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1443 dwarf::DW_FORM_flag, 1);
1445 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1446 MMI->getFrameMoves()));
1449 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1450 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1451 DeleteContainerPointers(I->second);
1452 ScopeVariables.clear();
1453 DeleteContainerPointers(CurrentFnArguments);
1454 UserVariables.clear();
1456 AbstractVariables.clear();
1457 LabelsBeforeInsn.clear();
1458 LabelsAfterInsn.clear();
1462 /// recordSourceLine - Register a source line with debug info. Returns the
1463 /// unique label that was emitted and which provides correspondence to
1464 /// the source line list.
1465 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1471 DIDescriptor Scope(S);
1473 if (Scope.isCompileUnit()) {
1474 DICompileUnit CU(S);
1475 Fn = CU.getFilename();
1476 Dir = CU.getDirectory();
1477 } else if (Scope.isFile()) {
1479 Fn = F.getFilename();
1480 Dir = F.getDirectory();
1481 } else if (Scope.isSubprogram()) {
1483 Fn = SP.getFilename();
1484 Dir = SP.getDirectory();
1485 } else if (Scope.isLexicalBlockFile()) {
1486 DILexicalBlockFile DBF(S);
1487 Fn = DBF.getFilename();
1488 Dir = DBF.getDirectory();
1489 } else if (Scope.isLexicalBlock()) {
1490 DILexicalBlock DB(S);
1491 Fn = DB.getFilename();
1492 Dir = DB.getDirectory();
1494 llvm_unreachable("Unexpected scope info");
1496 Src = GetOrCreateSourceID(Fn, Dir);
1498 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1501 //===----------------------------------------------------------------------===//
1503 //===----------------------------------------------------------------------===//
1505 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1508 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1509 // Get the children.
1510 const std::vector<DIE *> &Children = Die->getChildren();
1512 // Record the abbreviation.
1513 assignAbbrevNumber(Die->getAbbrev());
1515 // Get the abbreviation for this DIE.
1516 unsigned AbbrevNumber = Die->getAbbrevNumber();
1517 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1520 Die->setOffset(Offset);
1522 // Start the size with the size of abbreviation code.
1523 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1525 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1526 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1528 // Size the DIE attribute values.
1529 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1530 // Size attribute value.
1531 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1533 // Size the DIE children if any.
1534 if (!Children.empty()) {
1535 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1536 "Children flag not set");
1538 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1539 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1541 // End of children marker.
1542 Offset += sizeof(int8_t);
1545 Die->setSize(Offset - Die->getOffset());
1549 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1551 void DwarfDebug::computeSizeAndOffsets() {
1552 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1553 E = CUMap.end(); I != E; ++I) {
1554 // Compute size of compile unit header.
1556 sizeof(int32_t) + // Length of Compilation Unit Info
1557 sizeof(int16_t) + // DWARF version number
1558 sizeof(int32_t) + // Offset Into Abbrev. Section
1559 sizeof(int8_t); // Pointer Size (in bytes)
1560 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1564 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1565 /// the start of each one.
1566 void DwarfDebug::EmitSectionLabels() {
1567 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1569 // Dwarf sections base addresses.
1570 DwarfInfoSectionSym =
1571 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1572 DwarfAbbrevSectionSym =
1573 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1574 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1576 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1577 EmitSectionSym(Asm, MacroInfo);
1579 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1580 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1581 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1582 DwarfStrSectionSym =
1583 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1584 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1587 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1588 "section_debug_loc");
1590 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1591 EmitSectionSym(Asm, TLOF.getDataSection());
1594 /// emitDIE - Recursively emits a debug information entry.
1596 void DwarfDebug::emitDIE(DIE *Die) {
1597 // Get the abbreviation for this DIE.
1598 unsigned AbbrevNumber = Die->getAbbrevNumber();
1599 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1601 // Emit the code (index) for the abbreviation.
1602 if (Asm->isVerbose())
1603 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1604 Twine::utohexstr(Die->getOffset()) + ":0x" +
1605 Twine::utohexstr(Die->getSize()) + " " +
1606 dwarf::TagString(Abbrev->getTag()));
1607 Asm->EmitULEB128(AbbrevNumber);
1609 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1610 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1612 // Emit the DIE attribute values.
1613 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1614 unsigned Attr = AbbrevData[i].getAttribute();
1615 unsigned Form = AbbrevData[i].getForm();
1616 assert(Form && "Too many attributes for DIE (check abbreviation)");
1618 if (Asm->isVerbose())
1619 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1622 case dwarf::DW_AT_abstract_origin: {
1623 DIEEntry *E = cast<DIEEntry>(Values[i]);
1624 DIE *Origin = E->getEntry();
1625 unsigned Addr = Origin->getOffset();
1626 Asm->EmitInt32(Addr);
1629 case dwarf::DW_AT_ranges: {
1630 // DW_AT_range Value encodes offset in debug_range section.
1631 DIEInteger *V = cast<DIEInteger>(Values[i]);
1633 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1634 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1638 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1640 DwarfDebugRangeSectionSym,
1645 case dwarf::DW_AT_location: {
1646 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1647 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1648 Asm->EmitLabelReference(L->getValue(), 4);
1650 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1652 Values[i]->EmitValue(Asm, Form);
1656 case dwarf::DW_AT_accessibility: {
1657 if (Asm->isVerbose()) {
1658 DIEInteger *V = cast<DIEInteger>(Values[i]);
1659 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1661 Values[i]->EmitValue(Asm, Form);
1665 // Emit an attribute using the defined form.
1666 Values[i]->EmitValue(Asm, Form);
1671 // Emit the DIE children if any.
1672 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1673 const std::vector<DIE *> &Children = Die->getChildren();
1675 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1676 emitDIE(Children[j]);
1678 if (Asm->isVerbose())
1679 Asm->OutStreamer.AddComment("End Of Children Mark");
1684 /// emitDebugInfo - Emit the debug info section.
1686 void DwarfDebug::emitDebugInfo() {
1687 // Start debug info section.
1688 Asm->OutStreamer.SwitchSection(
1689 Asm->getObjFileLowering().getDwarfInfoSection());
1690 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1691 E = CUMap.end(); I != E; ++I) {
1692 CompileUnit *TheCU = I->second;
1693 DIE *Die = TheCU->getCUDie();
1695 // Emit the compile units header.
1696 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1699 // Emit size of content not including length itself
1700 unsigned ContentSize = Die->getSize() +
1701 sizeof(int16_t) + // DWARF version number
1702 sizeof(int32_t) + // Offset Into Abbrev. Section
1703 sizeof(int8_t); // Pointer Size (in bytes)
1705 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1706 Asm->EmitInt32(ContentSize);
1707 Asm->OutStreamer.AddComment("DWARF version number");
1708 Asm->EmitInt16(dwarf::DWARF_VERSION);
1709 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1710 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1711 DwarfAbbrevSectionSym);
1712 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1713 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1716 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1720 /// emitAbbreviations - Emit the abbreviation section.
1722 void DwarfDebug::emitAbbreviations() const {
1723 // Check to see if it is worth the effort.
1724 if (!Abbreviations.empty()) {
1725 // Start the debug abbrev section.
1726 Asm->OutStreamer.SwitchSection(
1727 Asm->getObjFileLowering().getDwarfAbbrevSection());
1729 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1731 // For each abbrevation.
1732 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1733 // Get abbreviation data
1734 const DIEAbbrev *Abbrev = Abbreviations[i];
1736 // Emit the abbrevations code (base 1 index.)
1737 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1739 // Emit the abbreviations data.
1743 // Mark end of abbreviations.
1744 Asm->EmitULEB128(0, "EOM(3)");
1746 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1750 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1751 /// the line matrix.
1753 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1754 // Define last address of section.
1755 Asm->OutStreamer.AddComment("Extended Op");
1758 Asm->OutStreamer.AddComment("Op size");
1759 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1760 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1761 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1763 Asm->OutStreamer.AddComment("Section end label");
1765 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1766 Asm->getTargetData().getPointerSize(),
1769 // Mark end of matrix.
1770 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1776 /// emitAccelNames - Emit visible names into a hashed accelerator table
1778 void DwarfDebug::emitAccelNames() {
1779 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1780 dwarf::DW_FORM_data4));
1781 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1782 E = CUMap.end(); I != E; ++I) {
1783 CompileUnit *TheCU = I->second;
1784 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1785 for (StringMap<std::vector<DIE*> >::const_iterator
1786 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1787 const char *Name = GI->getKeyData();
1788 const std::vector<DIE *> &Entities = GI->second;
1789 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1790 DE = Entities.end(); DI != DE; ++DI)
1791 AT.AddName(Name, (*DI));
1795 AT.FinalizeTable(Asm, "Names");
1796 Asm->OutStreamer.SwitchSection(
1797 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1798 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1799 Asm->OutStreamer.EmitLabel(SectionBegin);
1801 // Emit the full data.
1802 AT.Emit(Asm, SectionBegin, this);
1805 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1806 /// accelerator table section.
1807 void DwarfDebug::emitAccelObjC() {
1808 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1809 dwarf::DW_FORM_data4));
1810 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1811 E = CUMap.end(); I != E; ++I) {
1812 CompileUnit *TheCU = I->second;
1813 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1814 for (StringMap<std::vector<DIE*> >::const_iterator
1815 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1816 const char *Name = GI->getKeyData();
1817 const std::vector<DIE *> &Entities = GI->second;
1818 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1819 DE = Entities.end(); DI != DE; ++DI)
1820 AT.AddName(Name, (*DI));
1824 AT.FinalizeTable(Asm, "ObjC");
1825 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1826 .getDwarfAccelObjCSection());
1827 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1828 Asm->OutStreamer.EmitLabel(SectionBegin);
1830 // Emit the full data.
1831 AT.Emit(Asm, SectionBegin, this);
1834 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1836 void DwarfDebug::emitAccelNamespaces() {
1837 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1838 dwarf::DW_FORM_data4));
1839 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1840 E = CUMap.end(); I != E; ++I) {
1841 CompileUnit *TheCU = I->second;
1842 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1843 for (StringMap<std::vector<DIE*> >::const_iterator
1844 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1845 const char *Name = GI->getKeyData();
1846 const std::vector<DIE *> &Entities = GI->second;
1847 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1848 DE = Entities.end(); DI != DE; ++DI)
1849 AT.AddName(Name, (*DI));
1853 AT.FinalizeTable(Asm, "namespac");
1854 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1855 .getDwarfAccelNamespaceSection());
1856 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1857 Asm->OutStreamer.EmitLabel(SectionBegin);
1859 // Emit the full data.
1860 AT.Emit(Asm, SectionBegin, this);
1863 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1864 void DwarfDebug::emitAccelTypes() {
1865 std::vector<DwarfAccelTable::Atom> Atoms;
1866 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1867 dwarf::DW_FORM_data4));
1868 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1869 dwarf::DW_FORM_data2));
1870 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1871 dwarf::DW_FORM_data1));
1872 DwarfAccelTable AT(Atoms);
1873 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1874 E = CUMap.end(); I != E; ++I) {
1875 CompileUnit *TheCU = I->second;
1876 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1877 = TheCU->getAccelTypes();
1878 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1879 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1880 const char *Name = GI->getKeyData();
1881 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1882 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1883 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1884 AT.AddName(Name, (*DI).first, (*DI).second);
1888 AT.FinalizeTable(Asm, "types");
1889 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1890 .getDwarfAccelTypesSection());
1891 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1892 Asm->OutStreamer.EmitLabel(SectionBegin);
1894 // Emit the full data.
1895 AT.Emit(Asm, SectionBegin, this);
1898 void DwarfDebug::emitDebugPubTypes() {
1899 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1900 E = CUMap.end(); I != E; ++I) {
1901 CompileUnit *TheCU = I->second;
1902 // Start the dwarf pubtypes section.
1903 Asm->OutStreamer.SwitchSection(
1904 Asm->getObjFileLowering().getDwarfPubTypesSection());
1905 Asm->OutStreamer.AddComment("Length of Public Types Info");
1906 Asm->EmitLabelDifference(
1907 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1908 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1910 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1913 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1914 Asm->EmitInt16(dwarf::DWARF_VERSION);
1916 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1917 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1918 DwarfInfoSectionSym);
1920 Asm->OutStreamer.AddComment("Compilation Unit Length");
1921 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1922 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1925 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1926 for (StringMap<DIE*>::const_iterator
1927 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1928 const char *Name = GI->getKeyData();
1929 DIE *Entity = GI->second;
1931 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1932 Asm->EmitInt32(Entity->getOffset());
1934 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1935 // Emit the name with a terminating null byte.
1936 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1939 Asm->OutStreamer.AddComment("End Mark");
1941 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1946 /// emitDebugStr - Emit visible names into a debug str section.
1948 void DwarfDebug::emitDebugStr() {
1949 // Check to see if it is worth the effort.
1950 if (StringPool.empty()) return;
1952 // Start the dwarf str section.
1953 Asm->OutStreamer.SwitchSection(
1954 Asm->getObjFileLowering().getDwarfStrSection());
1956 // Get all of the string pool entries and put them in an array by their ID so
1957 // we can sort them.
1958 SmallVector<std::pair<unsigned,
1959 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1961 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1962 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1963 Entries.push_back(std::make_pair(I->second.second, &*I));
1965 array_pod_sort(Entries.begin(), Entries.end());
1967 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1968 // Emit a label for reference from debug information entries.
1969 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1971 // Emit the string itself with a terminating null byte.
1972 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1973 Entries[i].second->getKeyLength()+1),
1978 /// emitDebugLoc - Emit visible names into a debug loc section.
1980 void DwarfDebug::emitDebugLoc() {
1981 if (DotDebugLocEntries.empty())
1984 for (SmallVector<DotDebugLocEntry, 4>::iterator
1985 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1987 DotDebugLocEntry &Entry = *I;
1988 if (I + 1 != DotDebugLocEntries.end())
1992 // Start the dwarf loc section.
1993 Asm->OutStreamer.SwitchSection(
1994 Asm->getObjFileLowering().getDwarfLocSection());
1995 unsigned char Size = Asm->getTargetData().getPointerSize();
1996 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1998 for (SmallVector<DotDebugLocEntry, 4>::iterator
1999 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2000 I != E; ++I, ++index) {
2001 DotDebugLocEntry &Entry = *I;
2002 if (Entry.isMerged()) continue;
2003 if (Entry.isEmpty()) {
2004 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2005 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2006 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2008 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2009 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2010 DIVariable DV(Entry.Variable);
2011 Asm->OutStreamer.AddComment("Loc expr size");
2012 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2013 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2014 Asm->EmitLabelDifference(end, begin, 2);
2015 Asm->OutStreamer.EmitLabel(begin);
2016 if (Entry.isInt()) {
2017 DIBasicType BTy(DV.getType());
2019 (BTy.getEncoding() == dwarf::DW_ATE_signed
2020 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2021 Asm->OutStreamer.AddComment("DW_OP_consts");
2022 Asm->EmitInt8(dwarf::DW_OP_consts);
2023 Asm->EmitSLEB128(Entry.getInt());
2025 Asm->OutStreamer.AddComment("DW_OP_constu");
2026 Asm->EmitInt8(dwarf::DW_OP_constu);
2027 Asm->EmitULEB128(Entry.getInt());
2029 } else if (Entry.isLocation()) {
2030 if (!DV.hasComplexAddress())
2032 Asm->EmitDwarfRegOp(Entry.Loc);
2034 // Complex address entry.
2035 unsigned N = DV.getNumAddrElements();
2037 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2038 if (Entry.Loc.getOffset()) {
2040 Asm->EmitDwarfRegOp(Entry.Loc);
2041 Asm->OutStreamer.AddComment("DW_OP_deref");
2042 Asm->EmitInt8(dwarf::DW_OP_deref);
2043 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2044 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2045 Asm->EmitSLEB128(DV.getAddrElement(1));
2047 // If first address element is OpPlus then emit
2048 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2049 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2050 Asm->EmitDwarfRegOp(Loc);
2054 Asm->EmitDwarfRegOp(Entry.Loc);
2057 // Emit remaining complex address elements.
2058 for (; i < N; ++i) {
2059 uint64_t Element = DV.getAddrElement(i);
2060 if (Element == DIBuilder::OpPlus) {
2061 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2062 Asm->EmitULEB128(DV.getAddrElement(++i));
2063 } else if (Element == DIBuilder::OpDeref) {
2064 if (!Entry.Loc.isReg())
2065 Asm->EmitInt8(dwarf::DW_OP_deref);
2067 llvm_unreachable("unknown Opcode found in complex address");
2071 // else ... ignore constant fp. There is not any good way to
2072 // to represent them here in dwarf.
2073 Asm->OutStreamer.EmitLabel(end);
2078 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2080 void DwarfDebug::EmitDebugARanges() {
2081 // Start the dwarf aranges section.
2082 Asm->OutStreamer.SwitchSection(
2083 Asm->getObjFileLowering().getDwarfARangesSection());
2086 /// emitDebugRanges - Emit visible names into a debug ranges section.
2088 void DwarfDebug::emitDebugRanges() {
2089 // Start the dwarf ranges section.
2090 Asm->OutStreamer.SwitchSection(
2091 Asm->getObjFileLowering().getDwarfRangesSection());
2092 unsigned char Size = Asm->getTargetData().getPointerSize();
2093 for (SmallVector<const MCSymbol *, 8>::iterator
2094 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2097 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2099 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2103 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2105 void DwarfDebug::emitDebugMacInfo() {
2106 if (const MCSection *LineInfo =
2107 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2108 // Start the dwarf macinfo section.
2109 Asm->OutStreamer.SwitchSection(LineInfo);
2113 /// emitDebugInlineInfo - Emit inline info using following format.
2115 /// 1. length of section
2116 /// 2. Dwarf version number
2117 /// 3. address size.
2119 /// Entries (one "entry" for each function that was inlined):
2121 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2122 /// otherwise offset into __debug_str for regular function name.
2123 /// 2. offset into __debug_str section for regular function name.
2124 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2125 /// instances for the function.
2127 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2128 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2129 /// __debug_info section, and the low_pc is the starting address for the
2130 /// inlining instance.
2131 void DwarfDebug::emitDebugInlineInfo() {
2132 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2138 Asm->OutStreamer.SwitchSection(
2139 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2141 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2142 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2143 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2145 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2147 Asm->OutStreamer.AddComment("Dwarf Version");
2148 Asm->EmitInt16(dwarf::DWARF_VERSION);
2149 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2150 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2152 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2153 E = InlinedSPNodes.end(); I != E; ++I) {
2155 const MDNode *Node = *I;
2156 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2157 = InlineInfo.find(Node);
2158 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2159 DISubprogram SP(Node);
2160 StringRef LName = SP.getLinkageName();
2161 StringRef Name = SP.getName();
2163 Asm->OutStreamer.AddComment("MIPS linkage name");
2165 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2167 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2168 DwarfStrSectionSym);
2170 Asm->OutStreamer.AddComment("Function name");
2171 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2172 Asm->EmitULEB128(Labels.size(), "Inline count");
2174 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2175 LE = Labels.end(); LI != LE; ++LI) {
2176 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2177 Asm->EmitInt32(LI->second->getOffset());
2179 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2180 Asm->OutStreamer.EmitSymbolValue(LI->first,
2181 Asm->getTargetData().getPointerSize(),0);
2185 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));