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 llvm_unreachable("Unexpected Start and End labels for a inlined scope!");
394 assert(StartLabel->isDefined() &&
395 "Invalid starting label for an inlined scope!");
396 assert(EndLabel->isDefined() &&
397 "Invalid end label for an inlined scope!");
399 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
400 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
401 dwarf::DW_FORM_ref4, OriginDIE);
403 if (Ranges.size() > 1) {
404 // .debug_range section has not been laid out yet. Emit offset in
405 // .debug_range as a uint, size 4, for now. emitDIE will handle
406 // DW_AT_ranges appropriately.
407 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
408 DebugRangeSymbols.size()
409 * Asm->getTargetData().getPointerSize());
410 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
411 RE = Ranges.end(); RI != RE; ++RI) {
412 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
413 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
415 DebugRangeSymbols.push_back(NULL);
416 DebugRangeSymbols.push_back(NULL);
418 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
420 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
424 InlinedSubprogramDIEs.insert(OriginDIE);
426 // Track the start label for this inlined function.
427 //.debug_inlined section specification does not clearly state how
428 // to emit inlined scope that is split into multiple instruction ranges.
429 // For now, use first instruction range and emit low_pc/high_pc pair and
430 // corresponding .debug_inlined section entry for this pair.
431 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
432 I = InlineInfo.find(InlinedSP);
434 if (I == InlineInfo.end()) {
435 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
436 InlinedSPNodes.push_back(InlinedSP);
438 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
440 DILocation DL(Scope->getInlinedAt());
441 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
442 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
444 // Add name to the name table, we do this here because we're guaranteed
445 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
446 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
451 /// constructScopeDIE - Construct a DIE for this scope.
452 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
453 if (!Scope || !Scope->getScopeNode())
456 SmallVector<DIE *, 8> Children;
458 // Collect arguments for current function.
459 if (LScopes.isCurrentFunctionScope(Scope))
460 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
461 if (DbgVariable *ArgDV = CurrentFnArguments[i])
463 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
464 Children.push_back(Arg);
466 // Collect lexical scope children first.
467 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
468 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
470 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
471 Children.push_back(Variable);
472 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
473 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
474 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
475 Children.push_back(Nested);
476 DIScope DS(Scope->getScopeNode());
477 DIE *ScopeDIE = NULL;
478 if (Scope->getInlinedAt())
479 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
480 else if (DS.isSubprogram()) {
481 ProcessedSPNodes.insert(DS);
482 if (Scope->isAbstractScope()) {
483 ScopeDIE = TheCU->getDIE(DS);
484 // Note down abstract DIE.
486 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
489 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
492 // There is no need to emit empty lexical block DIE.
493 if (Children.empty())
495 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
498 if (!ScopeDIE) return NULL;
501 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
502 E = Children.end(); I != E; ++I)
503 ScopeDIE->addChild(*I);
505 if (DS.isSubprogram())
506 TheCU->addPubTypes(DISubprogram(DS));
511 /// GetOrCreateSourceID - Look up the source id with the given directory and
512 /// source file names. If none currently exists, create a new id and insert it
513 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
515 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
517 // If FE did not provide a file name, then assume stdin.
518 if (FileName.empty())
519 return GetOrCreateSourceID("<stdin>", StringRef());
521 // TODO: this might not belong here. See if we can factor this better.
522 if (DirName == CompilationDir)
525 unsigned SrcId = SourceIdMap.size()+1;
527 // We look up the file/dir pair by concatenating them with a zero byte.
528 SmallString<128> NamePair;
530 NamePair += '\0'; // Zero bytes are not allowed in paths.
531 NamePair += FileName;
533 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
534 if (Ent.getValue() != SrcId)
535 return Ent.getValue();
537 // Print out a .file directive to specify files for .loc directives.
538 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
543 /// constructCompileUnit - Create new CompileUnit for the given
544 /// metadata node with tag DW_TAG_compile_unit.
545 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
546 DICompileUnit DIUnit(N);
547 StringRef FN = DIUnit.getFilename();
548 CompilationDir = DIUnit.getDirectory();
549 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
551 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
552 CompileUnit *NewCU = new CompileUnit(ID, DIUnit.getLanguage(), Die, Asm, this);
553 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
554 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
555 DIUnit.getLanguage());
556 NewCU->addString(Die, dwarf::DW_AT_name, FN);
557 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
558 // simplifies debug range entries.
559 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
560 // DW_AT_stmt_list is a offset of line number information for this
561 // compile unit in debug_line section.
562 if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
563 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
564 Asm->GetTempSymbol("section_line"));
566 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
568 if (!CompilationDir.empty())
569 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
570 if (DIUnit.isOptimized())
571 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
573 StringRef Flags = DIUnit.getFlags();
575 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
577 if (unsigned RVer = DIUnit.getRunTimeVersion())
578 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
579 dwarf::DW_FORM_data1, RVer);
583 CUMap.insert(std::make_pair(N, NewCU));
587 /// construct SubprogramDIE - Construct subprogram DIE.
588 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
590 CompileUnit *&CURef = SPMap[N];
596 if (!SP.isDefinition())
597 // This is a method declaration which will be handled while constructing
601 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
604 TheCU->insertDIE(N, SubprogramDie);
606 // Add to context owner.
607 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
612 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
613 /// as llvm.dbg.enum and llvm.dbg.ty
614 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
615 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
616 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
617 const MDNode *N = NMD->getOperand(i);
618 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
619 constructSubprogramDIE(CU, N);
622 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
623 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
624 const MDNode *N = NMD->getOperand(i);
625 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
626 CU->createGlobalVariableDIE(N);
629 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
630 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
631 DIType Ty(NMD->getOperand(i));
632 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
633 CU->getOrCreateTypeDIE(Ty);
636 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
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);
644 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
645 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
646 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
647 DebugInfoFinder DbgFinder;
648 DbgFinder.processModule(*M);
650 bool HasDebugInfo = false;
651 // Scan all the compile-units to see if there are any marked as the main
652 // unit. If not, we do not generate debug info.
653 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
654 E = DbgFinder.compile_unit_end(); I != E; ++I) {
655 if (DICompileUnit(*I).isMain()) {
660 if (!HasDebugInfo) return false;
662 // Create all the compile unit DIEs.
663 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
664 E = DbgFinder.compile_unit_end(); I != E; ++I)
665 constructCompileUnit(*I);
667 // Create DIEs for each global variable.
668 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
669 E = DbgFinder.global_variable_end(); I != E; ++I) {
670 const MDNode *N = *I;
671 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
672 CU->createGlobalVariableDIE(N);
675 // Create DIEs for each subprogram.
676 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
677 E = DbgFinder.subprogram_end(); I != E; ++I) {
678 const MDNode *N = *I;
679 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
680 constructSubprogramDIE(CU, N);
686 /// beginModule - Emit all Dwarf sections that should come prior to the
687 /// content. Create global DIEs and emit initial debug info sections.
688 /// This is invoked by the target AsmPrinter.
689 void DwarfDebug::beginModule(Module *M) {
690 if (DisableDebugInfoPrinting)
693 // If module has named metadata anchors then use them, otherwise scan the
694 // module using debug info finder to collect debug info.
695 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
697 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
698 DICompileUnit CUNode(CU_Nodes->getOperand(i));
699 CompileUnit *CU = constructCompileUnit(CUNode);
700 DIArray GVs = CUNode.getGlobalVariables();
701 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
702 CU->createGlobalVariableDIE(GVs.getElement(i));
703 DIArray SPs = CUNode.getSubprograms();
704 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
705 constructSubprogramDIE(CU, SPs.getElement(i));
706 DIArray EnumTypes = CUNode.getEnumTypes();
707 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
708 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
709 DIArray RetainedTypes = CUNode.getRetainedTypes();
710 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
711 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
713 } else if (!collectLegacyDebugInfo(M))
716 collectInfoFromNamedMDNodes(M);
718 // Tell MMI that we have debug info.
719 MMI->setDebugInfoAvailability(true);
721 // Emit initial sections.
724 // Prime section data.
725 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
728 /// endModule - Emit all Dwarf sections that should come after the content.
730 void DwarfDebug::endModule() {
731 if (!FirstCU) return;
732 const Module *M = MMI->getModule();
733 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
735 // Collect info for variables that were optimized out.
736 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
737 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
738 DICompileUnit TheCU(CU_Nodes->getOperand(i));
739 DIArray Subprograms = TheCU.getSubprograms();
740 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
741 DISubprogram SP(Subprograms.getElement(i));
742 if (ProcessedSPNodes.count(SP) != 0) continue;
743 if (!SP.Verify()) continue;
744 if (!SP.isDefinition()) continue;
745 DIArray Variables = SP.getVariables();
746 if (Variables.getNumElements() == 0) continue;
748 LexicalScope *Scope =
749 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
750 DeadFnScopeMap[SP] = Scope;
752 // Construct subprogram DIE and add variables DIEs.
753 CompileUnit *SPCU = CUMap.lookup(TheCU);
754 assert(SPCU && "Unable to find Compile Unit!");
755 constructSubprogramDIE(SPCU, SP);
756 DIE *ScopeDIE = SPCU->getDIE(SP);
757 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
758 DIVariable DV(Variables.getElement(vi));
759 if (!DV.Verify()) continue;
760 DbgVariable *NewVar = new DbgVariable(DV, NULL);
761 if (DIE *VariableDIE =
762 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
763 ScopeDIE->addChild(VariableDIE);
769 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
770 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
771 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
773 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
775 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
776 AE = AbstractSPDies.end(); AI != AE; ++AI) {
777 DIE *ISP = AI->second;
778 if (InlinedSubprogramDIEs.count(ISP))
780 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
783 // Emit DW_AT_containing_type attribute to connect types with their
784 // vtable holding type.
785 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
786 CUE = CUMap.end(); CUI != CUE; ++CUI) {
787 CompileUnit *TheCU = CUI->second;
788 TheCU->constructContainingTypeDIEs();
791 // Standard sections final addresses.
792 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
793 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
794 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
795 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
797 // End text sections.
798 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
799 Asm->OutStreamer.SwitchSection(SectionMap[i]);
800 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
803 // Compute DIE offsets and sizes.
804 computeSizeAndOffsets();
806 // Emit all the DIEs into a debug info section
809 // Corresponding abbreviations into a abbrev section.
812 // Emit info into a dwarf accelerator table sections.
813 if (DwarfAccelTables) {
816 emitAccelNamespaces();
820 // Emit info into a debug pubtypes section.
823 // Emit info into a debug loc section.
826 // Emit info into a debug aranges section.
829 // Emit info into a debug ranges section.
832 // Emit info into a debug macinfo section.
836 emitDebugInlineInfo();
838 // Emit info into a debug str section.
842 DeleteContainerSeconds(DeadFnScopeMap);
844 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
845 E = CUMap.end(); I != E; ++I)
847 FirstCU = NULL; // Reset for the next Module, if any.
850 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
851 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
853 LLVMContext &Ctx = DV->getContext();
854 // More then one inlined variable corresponds to one abstract variable.
855 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
856 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
858 return AbsDbgVariable;
860 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
864 AbsDbgVariable = new DbgVariable(Var, NULL);
865 addScopeVariable(Scope, AbsDbgVariable);
866 AbstractVariables[Var] = AbsDbgVariable;
867 return AbsDbgVariable;
870 /// addCurrentFnArgument - If Var is a current function argument then add
871 /// it to CurrentFnArguments list.
872 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
873 DbgVariable *Var, LexicalScope *Scope) {
874 if (!LScopes.isCurrentFunctionScope(Scope))
876 DIVariable DV = Var->getVariable();
877 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
879 unsigned ArgNo = DV.getArgNumber();
883 size_t Size = CurrentFnArguments.size();
885 CurrentFnArguments.resize(MF->getFunction()->arg_size());
886 // llvm::Function argument size is not good indicator of how many
887 // arguments does the function have at source level.
889 CurrentFnArguments.resize(ArgNo * 2);
890 CurrentFnArguments[ArgNo - 1] = Var;
894 /// collectVariableInfoFromMMITable - Collect variable information from
895 /// side table maintained by MMI.
897 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
898 SmallPtrSet<const MDNode *, 16> &Processed) {
899 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
900 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
901 VE = VMap.end(); VI != VE; ++VI) {
902 const MDNode *Var = VI->first;
904 Processed.insert(Var);
906 const std::pair<unsigned, DebugLoc> &VP = VI->second;
908 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
910 // If variable scope is not found then skip this variable.
914 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
915 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
916 RegVar->setFrameIndex(VP.first);
917 if (!addCurrentFnArgument(MF, RegVar, Scope))
918 addScopeVariable(Scope, RegVar);
920 AbsDbgVariable->setFrameIndex(VP.first);
924 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
925 /// DBG_VALUE instruction, is in a defined reg.
926 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
927 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
928 return MI->getNumOperands() == 3 &&
929 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
930 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
933 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
935 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
936 const MCSymbol *FLabel,
937 const MCSymbol *SLabel,
938 const MachineInstr *MI) {
939 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
941 if (MI->getNumOperands() != 3) {
942 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
943 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
945 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
946 MachineLocation MLoc;
947 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
948 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
950 if (MI->getOperand(0).isImm())
951 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
952 if (MI->getOperand(0).isFPImm())
953 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
954 if (MI->getOperand(0).isCImm())
955 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
957 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
960 /// collectVariableInfo - Find variables for each lexical scope.
962 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
963 SmallPtrSet<const MDNode *, 16> &Processed) {
965 /// collection info from MMI table.
966 collectVariableInfoFromMMITable(MF, Processed);
968 for (SmallVectorImpl<const MDNode*>::const_iterator
969 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
971 const MDNode *Var = *UVI;
972 if (Processed.count(Var))
975 // History contains relevant DBG_VALUE instructions for Var and instructions
977 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
980 const MachineInstr *MInsn = History.front();
983 LexicalScope *Scope = NULL;
984 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
985 DISubprogram(DV.getContext()).describes(MF->getFunction()))
986 Scope = LScopes.getCurrentFunctionScope();
988 if (DV.getVersion() <= LLVMDebugVersion9)
989 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
991 if (MDNode *IA = DV.getInlinedAt())
992 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
994 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
997 // If variable scope is not found then skip this variable.
1001 Processed.insert(DV);
1002 assert(MInsn->isDebugValue() && "History must begin with debug value");
1003 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1004 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1005 if (!addCurrentFnArgument(MF, RegVar, Scope))
1006 addScopeVariable(Scope, RegVar);
1008 AbsVar->setMInsn(MInsn);
1010 // Simple ranges that are fully coalesced.
1011 if (History.size() <= 1 || (History.size() == 2 &&
1012 MInsn->isIdenticalTo(History.back()))) {
1013 RegVar->setMInsn(MInsn);
1017 // handle multiple DBG_VALUE instructions describing one variable.
1018 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1020 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1021 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1022 const MachineInstr *Begin = *HI;
1023 assert(Begin->isDebugValue() && "Invalid History entry");
1025 // Check if DBG_VALUE is truncating a range.
1026 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1027 && !Begin->getOperand(0).getReg())
1030 // Compute the range for a register location.
1031 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1032 const MCSymbol *SLabel = 0;
1035 // If Begin is the last instruction in History then its value is valid
1036 // until the end of the function.
1037 SLabel = FunctionEndSym;
1039 const MachineInstr *End = HI[1];
1040 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1041 << "\t" << *Begin << "\t" << *End << "\n");
1042 if (End->isDebugValue())
1043 SLabel = getLabelBeforeInsn(End);
1045 // End is a normal instruction clobbering the range.
1046 SLabel = getLabelAfterInsn(End);
1047 assert(SLabel && "Forgot label after clobber instruction");
1052 // The value is valid until the next DBG_VALUE or clobber.
1053 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1056 DotDebugLocEntries.push_back(DotDebugLocEntry());
1059 // Collect info for variables that were optimized out.
1060 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1061 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1062 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1063 DIVariable DV(Variables.getElement(i));
1064 if (!DV || !DV.Verify() || !Processed.insert(DV))
1066 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1067 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1071 /// getLabelBeforeInsn - Return Label preceding the instruction.
1072 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1073 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1074 assert(Label && "Didn't insert label before instruction");
1078 /// getLabelAfterInsn - Return Label immediately following the instruction.
1079 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1080 return LabelsAfterInsn.lookup(MI);
1083 /// beginInstruction - Process beginning of an instruction.
1084 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1085 // Check if source location changes, but ignore DBG_VALUE locations.
1086 if (!MI->isDebugValue()) {
1087 DebugLoc DL = MI->getDebugLoc();
1088 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1089 unsigned Flags = DWARF2_FLAG_IS_STMT;
1091 if (DL == PrologEndLoc) {
1092 Flags |= DWARF2_FLAG_PROLOGUE_END;
1093 PrologEndLoc = DebugLoc();
1095 if (!DL.isUnknown()) {
1096 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1097 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1099 recordSourceLine(0, 0, 0, 0);
1103 // Insert labels where requested.
1104 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1105 LabelsBeforeInsn.find(MI);
1108 if (I == LabelsBeforeInsn.end())
1111 // Label already assigned.
1116 PrevLabel = MMI->getContext().CreateTempSymbol();
1117 Asm->OutStreamer.EmitLabel(PrevLabel);
1119 I->second = PrevLabel;
1122 /// endInstruction - Process end of an instruction.
1123 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1124 // Don't create a new label after DBG_VALUE instructions.
1125 // They don't generate code.
1126 if (!MI->isDebugValue())
1129 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1130 LabelsAfterInsn.find(MI);
1133 if (I == LabelsAfterInsn.end())
1136 // Label already assigned.
1140 // We need a label after this instruction.
1142 PrevLabel = MMI->getContext().CreateTempSymbol();
1143 Asm->OutStreamer.EmitLabel(PrevLabel);
1145 I->second = PrevLabel;
1148 /// identifyScopeMarkers() -
1149 /// Each LexicalScope has first instruction and last instruction to mark
1150 /// beginning and end of a scope respectively. Create an inverse map that list
1151 /// scopes starts (and ends) with an instruction. One instruction may start (or
1152 /// end) multiple scopes. Ignore scopes that are not reachable.
1153 void DwarfDebug::identifyScopeMarkers() {
1154 SmallVector<LexicalScope *, 4> WorkList;
1155 WorkList.push_back(LScopes.getCurrentFunctionScope());
1156 while (!WorkList.empty()) {
1157 LexicalScope *S = WorkList.pop_back_val();
1159 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1160 if (!Children.empty())
1161 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1162 SE = Children.end(); SI != SE; ++SI)
1163 WorkList.push_back(*SI);
1165 if (S->isAbstractScope())
1168 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1171 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1172 RE = Ranges.end(); RI != RE; ++RI) {
1173 assert(RI->first && "InsnRange does not have first instruction!");
1174 assert(RI->second && "InsnRange does not have second instruction!");
1175 requestLabelBeforeInsn(RI->first);
1176 requestLabelAfterInsn(RI->second);
1181 /// getScopeNode - Get MDNode for DebugLoc's scope.
1182 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1183 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1184 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1185 return DL.getScope(Ctx);
1188 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1189 /// line number info for the function.
1190 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1191 const MDNode *Scope = getScopeNode(DL, Ctx);
1192 DISubprogram SP = getDISubprogram(Scope);
1194 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1198 /// beginFunction - Gather pre-function debug information. Assumes being
1199 /// emitted immediately after the function entry point.
1200 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1201 if (!MMI->hasDebugInfo()) return;
1202 LScopes.initialize(*MF);
1203 if (LScopes.empty()) return;
1204 identifyScopeMarkers();
1206 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1207 Asm->getFunctionNumber());
1208 // Assumes in correct section after the entry point.
1209 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1211 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1213 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1214 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1215 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1217 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1219 bool AtBlockEntry = true;
1220 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1222 const MachineInstr *MI = II;
1224 if (MI->isDebugValue()) {
1225 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1227 // Keep track of user variables.
1229 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1231 // Variable is in a register, we need to check for clobbers.
1232 if (isDbgValueInDefinedReg(MI))
1233 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1235 // Check the history of this variable.
1236 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1237 if (History.empty()) {
1238 UserVariables.push_back(Var);
1239 // The first mention of a function argument gets the FunctionBeginSym
1240 // label, so arguments are visible when breaking at function entry.
1242 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1243 DISubprogram(getDISubprogram(DV.getContext()))
1244 .describes(MF->getFunction()))
1245 LabelsBeforeInsn[MI] = FunctionBeginSym;
1247 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1248 const MachineInstr *Prev = History.back();
1249 if (Prev->isDebugValue()) {
1250 // Coalesce identical entries at the end of History.
1251 if (History.size() >= 2 &&
1252 Prev->isIdenticalTo(History[History.size() - 2])) {
1253 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1255 << "\t" << *History[History.size() - 2] << "\n");
1259 // Terminate old register assignments that don't reach MI;
1260 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1261 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1262 isDbgValueInDefinedReg(Prev)) {
1263 // Previous register assignment needs to terminate at the end of
1265 MachineBasicBlock::const_iterator LastMI =
1266 PrevMBB->getLastNonDebugInstr();
1267 if (LastMI == PrevMBB->end()) {
1268 // Drop DBG_VALUE for empty range.
1269 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1270 << "\t" << *Prev << "\n");
1274 // Terminate after LastMI.
1275 History.push_back(LastMI);
1280 History.push_back(MI);
1282 // Not a DBG_VALUE instruction.
1284 AtBlockEntry = false;
1286 // First known non DBG_VALUE location marks beginning of function
1288 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1289 PrologEndLoc = MI->getDebugLoc();
1291 // Check if the instruction clobbers any registers with debug vars.
1292 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1293 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1294 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1296 for (const uint16_t *AI = TRI->getOverlaps(MOI->getReg());
1297 unsigned Reg = *AI; ++AI) {
1298 const MDNode *Var = LiveUserVar[Reg];
1301 // Reg is now clobbered.
1302 LiveUserVar[Reg] = 0;
1304 // Was MD last defined by a DBG_VALUE referring to Reg?
1305 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1306 if (HistI == DbgValues.end())
1308 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1309 if (History.empty())
1311 const MachineInstr *Prev = History.back();
1312 // Sanity-check: Register assignments are terminated at the end of
1314 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1316 // Is the variable still in Reg?
1317 if (!isDbgValueInDefinedReg(Prev) ||
1318 Prev->getOperand(0).getReg() != Reg)
1320 // Var is clobbered. Make sure the next instruction gets a label.
1321 History.push_back(MI);
1328 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1330 SmallVectorImpl<const MachineInstr*> &History = I->second;
1331 if (History.empty())
1334 // Make sure the final register assignments are terminated.
1335 const MachineInstr *Prev = History.back();
1336 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1337 const MachineBasicBlock *PrevMBB = Prev->getParent();
1338 MachineBasicBlock::const_iterator LastMI =
1339 PrevMBB->getLastNonDebugInstr();
1340 if (LastMI == PrevMBB->end())
1341 // Drop DBG_VALUE for empty range.
1344 // Terminate after LastMI.
1345 History.push_back(LastMI);
1348 // Request labels for the full history.
1349 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1350 const MachineInstr *MI = History[i];
1351 if (MI->isDebugValue())
1352 requestLabelBeforeInsn(MI);
1354 requestLabelAfterInsn(MI);
1358 PrevInstLoc = DebugLoc();
1359 PrevLabel = FunctionBeginSym;
1361 // Record beginning of function.
1362 if (!PrologEndLoc.isUnknown()) {
1363 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1364 MF->getFunction()->getContext());
1365 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1366 FnStartDL.getScope(MF->getFunction()->getContext()),
1367 DWARF2_FLAG_IS_STMT);
1371 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1372 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1373 ScopeVariables[LS].push_back(Var);
1374 // Vars.push_back(Var);
1377 /// endFunction - Gather and emit post-function debug information.
1379 void DwarfDebug::endFunction(const MachineFunction *MF) {
1380 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1382 // Define end label for subprogram.
1383 FunctionEndSym = Asm->GetTempSymbol("func_end",
1384 Asm->getFunctionNumber());
1385 // Assumes in correct section after the entry point.
1386 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1388 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1389 collectVariableInfo(MF, ProcessedVars);
1391 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1392 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1393 assert(TheCU && "Unable to find compile unit!");
1395 // Construct abstract scopes.
1396 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1397 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1398 LexicalScope *AScope = AList[i];
1399 DISubprogram SP(AScope->getScopeNode());
1401 // Collect info for variables that were optimized out.
1402 DIArray Variables = SP.getVariables();
1403 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1404 DIVariable DV(Variables.getElement(i));
1405 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1407 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1408 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1411 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1412 constructScopeDIE(TheCU, AScope);
1415 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1417 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1418 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1419 dwarf::DW_FORM_flag, 1);
1421 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1422 MMI->getFrameMoves()));
1425 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1426 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1427 DeleteContainerPointers(I->second);
1428 ScopeVariables.clear();
1429 DeleteContainerPointers(CurrentFnArguments);
1430 UserVariables.clear();
1432 AbstractVariables.clear();
1433 LabelsBeforeInsn.clear();
1434 LabelsAfterInsn.clear();
1438 /// recordSourceLine - Register a source line with debug info. Returns the
1439 /// unique label that was emitted and which provides correspondence to
1440 /// the source line list.
1441 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1447 DIDescriptor Scope(S);
1449 if (Scope.isCompileUnit()) {
1450 DICompileUnit CU(S);
1451 Fn = CU.getFilename();
1452 Dir = CU.getDirectory();
1453 } else if (Scope.isFile()) {
1455 Fn = F.getFilename();
1456 Dir = F.getDirectory();
1457 } else if (Scope.isSubprogram()) {
1459 Fn = SP.getFilename();
1460 Dir = SP.getDirectory();
1461 } else if (Scope.isLexicalBlockFile()) {
1462 DILexicalBlockFile DBF(S);
1463 Fn = DBF.getFilename();
1464 Dir = DBF.getDirectory();
1465 } else if (Scope.isLexicalBlock()) {
1466 DILexicalBlock DB(S);
1467 Fn = DB.getFilename();
1468 Dir = DB.getDirectory();
1470 llvm_unreachable("Unexpected scope info");
1472 Src = GetOrCreateSourceID(Fn, Dir);
1474 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1477 //===----------------------------------------------------------------------===//
1479 //===----------------------------------------------------------------------===//
1481 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1484 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1485 // Get the children.
1486 const std::vector<DIE *> &Children = Die->getChildren();
1488 // Record the abbreviation.
1489 assignAbbrevNumber(Die->getAbbrev());
1491 // Get the abbreviation for this DIE.
1492 unsigned AbbrevNumber = Die->getAbbrevNumber();
1493 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1496 Die->setOffset(Offset);
1498 // Start the size with the size of abbreviation code.
1499 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1501 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1502 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1504 // Size the DIE attribute values.
1505 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1506 // Size attribute value.
1507 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1509 // Size the DIE children if any.
1510 if (!Children.empty()) {
1511 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1512 "Children flag not set");
1514 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1515 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1517 // End of children marker.
1518 Offset += sizeof(int8_t);
1521 Die->setSize(Offset - Die->getOffset());
1525 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1527 void DwarfDebug::computeSizeAndOffsets() {
1528 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1529 E = CUMap.end(); I != E; ++I) {
1530 // Compute size of compile unit header.
1532 sizeof(int32_t) + // Length of Compilation Unit Info
1533 sizeof(int16_t) + // DWARF version number
1534 sizeof(int32_t) + // Offset Into Abbrev. Section
1535 sizeof(int8_t); // Pointer Size (in bytes)
1536 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1540 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1541 /// the start of each one.
1542 void DwarfDebug::EmitSectionLabels() {
1543 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1545 // Dwarf sections base addresses.
1546 DwarfInfoSectionSym =
1547 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1548 DwarfAbbrevSectionSym =
1549 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1550 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1552 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1553 EmitSectionSym(Asm, MacroInfo);
1555 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1556 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1557 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1558 DwarfStrSectionSym =
1559 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1560 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1563 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1564 "section_debug_loc");
1566 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1567 EmitSectionSym(Asm, TLOF.getDataSection());
1570 /// emitDIE - Recursively emits a debug information entry.
1572 void DwarfDebug::emitDIE(DIE *Die) {
1573 // Get the abbreviation for this DIE.
1574 unsigned AbbrevNumber = Die->getAbbrevNumber();
1575 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1577 // Emit the code (index) for the abbreviation.
1578 if (Asm->isVerbose())
1579 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1580 Twine::utohexstr(Die->getOffset()) + ":0x" +
1581 Twine::utohexstr(Die->getSize()) + " " +
1582 dwarf::TagString(Abbrev->getTag()));
1583 Asm->EmitULEB128(AbbrevNumber);
1585 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1586 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1588 // Emit the DIE attribute values.
1589 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1590 unsigned Attr = AbbrevData[i].getAttribute();
1591 unsigned Form = AbbrevData[i].getForm();
1592 assert(Form && "Too many attributes for DIE (check abbreviation)");
1594 if (Asm->isVerbose())
1595 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1598 case dwarf::DW_AT_abstract_origin: {
1599 DIEEntry *E = cast<DIEEntry>(Values[i]);
1600 DIE *Origin = E->getEntry();
1601 unsigned Addr = Origin->getOffset();
1602 Asm->EmitInt32(Addr);
1605 case dwarf::DW_AT_ranges: {
1606 // DW_AT_range Value encodes offset in debug_range section.
1607 DIEInteger *V = cast<DIEInteger>(Values[i]);
1609 if (Asm->MAI->doesDwarfUseLabelOffsetForRanges()) {
1610 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1614 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1616 DwarfDebugRangeSectionSym,
1621 case dwarf::DW_AT_location: {
1622 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1623 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1625 Values[i]->EmitValue(Asm, Form);
1628 case dwarf::DW_AT_accessibility: {
1629 if (Asm->isVerbose()) {
1630 DIEInteger *V = cast<DIEInteger>(Values[i]);
1631 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1633 Values[i]->EmitValue(Asm, Form);
1637 // Emit an attribute using the defined form.
1638 Values[i]->EmitValue(Asm, Form);
1643 // Emit the DIE children if any.
1644 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1645 const std::vector<DIE *> &Children = Die->getChildren();
1647 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1648 emitDIE(Children[j]);
1650 if (Asm->isVerbose())
1651 Asm->OutStreamer.AddComment("End Of Children Mark");
1656 /// emitDebugInfo - Emit the debug info section.
1658 void DwarfDebug::emitDebugInfo() {
1659 // Start debug info section.
1660 Asm->OutStreamer.SwitchSection(
1661 Asm->getObjFileLowering().getDwarfInfoSection());
1662 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1663 E = CUMap.end(); I != E; ++I) {
1664 CompileUnit *TheCU = I->second;
1665 DIE *Die = TheCU->getCUDie();
1667 // Emit the compile units header.
1668 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1671 // Emit size of content not including length itself
1672 unsigned ContentSize = Die->getSize() +
1673 sizeof(int16_t) + // DWARF version number
1674 sizeof(int32_t) + // Offset Into Abbrev. Section
1675 sizeof(int8_t); // Pointer Size (in bytes)
1677 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1678 Asm->EmitInt32(ContentSize);
1679 Asm->OutStreamer.AddComment("DWARF version number");
1680 Asm->EmitInt16(dwarf::DWARF_VERSION);
1681 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1682 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1683 DwarfAbbrevSectionSym);
1684 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1685 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1688 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1692 /// emitAbbreviations - Emit the abbreviation section.
1694 void DwarfDebug::emitAbbreviations() const {
1695 // Check to see if it is worth the effort.
1696 if (!Abbreviations.empty()) {
1697 // Start the debug abbrev section.
1698 Asm->OutStreamer.SwitchSection(
1699 Asm->getObjFileLowering().getDwarfAbbrevSection());
1701 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1703 // For each abbrevation.
1704 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1705 // Get abbreviation data
1706 const DIEAbbrev *Abbrev = Abbreviations[i];
1708 // Emit the abbrevations code (base 1 index.)
1709 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1711 // Emit the abbreviations data.
1715 // Mark end of abbreviations.
1716 Asm->EmitULEB128(0, "EOM(3)");
1718 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1722 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1723 /// the line matrix.
1725 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1726 // Define last address of section.
1727 Asm->OutStreamer.AddComment("Extended Op");
1730 Asm->OutStreamer.AddComment("Op size");
1731 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1732 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1733 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1735 Asm->OutStreamer.AddComment("Section end label");
1737 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1738 Asm->getTargetData().getPointerSize(),
1741 // Mark end of matrix.
1742 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1748 /// emitAccelNames - Emit visible names into a hashed accelerator table
1750 void DwarfDebug::emitAccelNames() {
1751 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1752 dwarf::DW_FORM_data4));
1753 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1754 E = CUMap.end(); I != E; ++I) {
1755 CompileUnit *TheCU = I->second;
1756 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1757 for (StringMap<std::vector<DIE*> >::const_iterator
1758 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1759 const char *Name = GI->getKeyData();
1760 const std::vector<DIE *> &Entities = GI->second;
1761 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1762 DE = Entities.end(); DI != DE; ++DI)
1763 AT.AddName(Name, (*DI));
1767 AT.FinalizeTable(Asm, "Names");
1768 Asm->OutStreamer.SwitchSection(
1769 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1770 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1771 Asm->OutStreamer.EmitLabel(SectionBegin);
1773 // Emit the full data.
1774 AT.Emit(Asm, SectionBegin, this);
1777 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1778 /// accelerator table section.
1779 void DwarfDebug::emitAccelObjC() {
1780 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1781 dwarf::DW_FORM_data4));
1782 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1783 E = CUMap.end(); I != E; ++I) {
1784 CompileUnit *TheCU = I->second;
1785 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1786 for (StringMap<std::vector<DIE*> >::const_iterator
1787 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1788 const char *Name = GI->getKeyData();
1789 const std::vector<DIE *> &Entities = GI->second;
1790 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1791 DE = Entities.end(); DI != DE; ++DI)
1792 AT.AddName(Name, (*DI));
1796 AT.FinalizeTable(Asm, "ObjC");
1797 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1798 .getDwarfAccelObjCSection());
1799 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1800 Asm->OutStreamer.EmitLabel(SectionBegin);
1802 // Emit the full data.
1803 AT.Emit(Asm, SectionBegin, this);
1806 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1808 void DwarfDebug::emitAccelNamespaces() {
1809 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1810 dwarf::DW_FORM_data4));
1811 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1812 E = CUMap.end(); I != E; ++I) {
1813 CompileUnit *TheCU = I->second;
1814 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1815 for (StringMap<std::vector<DIE*> >::const_iterator
1816 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1817 const char *Name = GI->getKeyData();
1818 const std::vector<DIE *> &Entities = GI->second;
1819 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1820 DE = Entities.end(); DI != DE; ++DI)
1821 AT.AddName(Name, (*DI));
1825 AT.FinalizeTable(Asm, "namespac");
1826 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1827 .getDwarfAccelNamespaceSection());
1828 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1829 Asm->OutStreamer.EmitLabel(SectionBegin);
1831 // Emit the full data.
1832 AT.Emit(Asm, SectionBegin, this);
1835 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1836 void DwarfDebug::emitAccelTypes() {
1837 std::vector<DwarfAccelTable::Atom> Atoms;
1838 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1839 dwarf::DW_FORM_data4));
1840 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1841 dwarf::DW_FORM_data2));
1842 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1843 dwarf::DW_FORM_data1));
1844 DwarfAccelTable AT(Atoms);
1845 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1846 E = CUMap.end(); I != E; ++I) {
1847 CompileUnit *TheCU = I->second;
1848 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1849 = TheCU->getAccelTypes();
1850 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1851 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1852 const char *Name = GI->getKeyData();
1853 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1854 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1855 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1856 AT.AddName(Name, (*DI).first, (*DI).second);
1860 AT.FinalizeTable(Asm, "types");
1861 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1862 .getDwarfAccelTypesSection());
1863 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1864 Asm->OutStreamer.EmitLabel(SectionBegin);
1866 // Emit the full data.
1867 AT.Emit(Asm, SectionBegin, this);
1870 void DwarfDebug::emitDebugPubTypes() {
1871 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1872 E = CUMap.end(); I != E; ++I) {
1873 CompileUnit *TheCU = I->second;
1874 // Start the dwarf pubtypes section.
1875 Asm->OutStreamer.SwitchSection(
1876 Asm->getObjFileLowering().getDwarfPubTypesSection());
1877 Asm->OutStreamer.AddComment("Length of Public Types Info");
1878 Asm->EmitLabelDifference(
1879 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1880 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1882 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1885 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1886 Asm->EmitInt16(dwarf::DWARF_VERSION);
1888 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1889 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1890 DwarfInfoSectionSym);
1892 Asm->OutStreamer.AddComment("Compilation Unit Length");
1893 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1894 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1897 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1898 for (StringMap<DIE*>::const_iterator
1899 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1900 const char *Name = GI->getKeyData();
1901 DIE *Entity = GI->second;
1903 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1904 Asm->EmitInt32(Entity->getOffset());
1906 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1907 // Emit the name with a terminating null byte.
1908 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1911 Asm->OutStreamer.AddComment("End Mark");
1913 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1918 /// emitDebugStr - Emit visible names into a debug str section.
1920 void DwarfDebug::emitDebugStr() {
1921 // Check to see if it is worth the effort.
1922 if (StringPool.empty()) return;
1924 // Start the dwarf str section.
1925 Asm->OutStreamer.SwitchSection(
1926 Asm->getObjFileLowering().getDwarfStrSection());
1928 // Get all of the string pool entries and put them in an array by their ID so
1929 // we can sort them.
1930 SmallVector<std::pair<unsigned,
1931 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1933 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1934 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1935 Entries.push_back(std::make_pair(I->second.second, &*I));
1937 array_pod_sort(Entries.begin(), Entries.end());
1939 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1940 // Emit a label for reference from debug information entries.
1941 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1943 // Emit the string itself with a terminating null byte.
1944 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1945 Entries[i].second->getKeyLength()+1),
1950 /// emitDebugLoc - Emit visible names into a debug loc section.
1952 void DwarfDebug::emitDebugLoc() {
1953 if (DotDebugLocEntries.empty())
1956 for (SmallVector<DotDebugLocEntry, 4>::iterator
1957 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1959 DotDebugLocEntry &Entry = *I;
1960 if (I + 1 != DotDebugLocEntries.end())
1964 // Start the dwarf loc section.
1965 Asm->OutStreamer.SwitchSection(
1966 Asm->getObjFileLowering().getDwarfLocSection());
1967 unsigned char Size = Asm->getTargetData().getPointerSize();
1968 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1970 for (SmallVector<DotDebugLocEntry, 4>::iterator
1971 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1972 I != E; ++I, ++index) {
1973 DotDebugLocEntry &Entry = *I;
1974 if (Entry.isMerged()) continue;
1975 if (Entry.isEmpty()) {
1976 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1977 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1978 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1980 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1981 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1982 DIVariable DV(Entry.Variable);
1983 Asm->OutStreamer.AddComment("Loc expr size");
1984 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1985 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1986 Asm->EmitLabelDifference(end, begin, 2);
1987 Asm->OutStreamer.EmitLabel(begin);
1988 if (Entry.isInt()) {
1989 DIBasicType BTy(DV.getType());
1991 (BTy.getEncoding() == dwarf::DW_ATE_signed
1992 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1993 Asm->OutStreamer.AddComment("DW_OP_consts");
1994 Asm->EmitInt8(dwarf::DW_OP_consts);
1995 Asm->EmitSLEB128(Entry.getInt());
1997 Asm->OutStreamer.AddComment("DW_OP_constu");
1998 Asm->EmitInt8(dwarf::DW_OP_constu);
1999 Asm->EmitULEB128(Entry.getInt());
2001 } else if (Entry.isLocation()) {
2002 if (!DV.hasComplexAddress())
2004 Asm->EmitDwarfRegOp(Entry.Loc);
2006 // Complex address entry.
2007 unsigned N = DV.getNumAddrElements();
2009 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2010 if (Entry.Loc.getOffset()) {
2012 Asm->EmitDwarfRegOp(Entry.Loc);
2013 Asm->OutStreamer.AddComment("DW_OP_deref");
2014 Asm->EmitInt8(dwarf::DW_OP_deref);
2015 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2016 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2017 Asm->EmitSLEB128(DV.getAddrElement(1));
2019 // If first address element is OpPlus then emit
2020 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2021 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2022 Asm->EmitDwarfRegOp(Loc);
2026 Asm->EmitDwarfRegOp(Entry.Loc);
2029 // Emit remaining complex address elements.
2030 for (; i < N; ++i) {
2031 uint64_t Element = DV.getAddrElement(i);
2032 if (Element == DIBuilder::OpPlus) {
2033 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2034 Asm->EmitULEB128(DV.getAddrElement(++i));
2035 } else if (Element == DIBuilder::OpDeref)
2036 Asm->EmitInt8(dwarf::DW_OP_deref);
2037 else llvm_unreachable("unknown Opcode found in complex address");
2041 // else ... ignore constant fp. There is not any good way to
2042 // to represent them here in dwarf.
2043 Asm->OutStreamer.EmitLabel(end);
2048 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2050 void DwarfDebug::EmitDebugARanges() {
2051 // Start the dwarf aranges section.
2052 Asm->OutStreamer.SwitchSection(
2053 Asm->getObjFileLowering().getDwarfARangesSection());
2056 /// emitDebugRanges - Emit visible names into a debug ranges section.
2058 void DwarfDebug::emitDebugRanges() {
2059 // Start the dwarf ranges section.
2060 Asm->OutStreamer.SwitchSection(
2061 Asm->getObjFileLowering().getDwarfRangesSection());
2062 unsigned char Size = Asm->getTargetData().getPointerSize();
2063 for (SmallVector<const MCSymbol *, 8>::iterator
2064 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2067 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2069 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2073 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2075 void DwarfDebug::emitDebugMacInfo() {
2076 if (const MCSection *LineInfo =
2077 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2078 // Start the dwarf macinfo section.
2079 Asm->OutStreamer.SwitchSection(LineInfo);
2083 /// emitDebugInlineInfo - Emit inline info using following format.
2085 /// 1. length of section
2086 /// 2. Dwarf version number
2087 /// 3. address size.
2089 /// Entries (one "entry" for each function that was inlined):
2091 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2092 /// otherwise offset into __debug_str for regular function name.
2093 /// 2. offset into __debug_str section for regular function name.
2094 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2095 /// instances for the function.
2097 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2098 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2099 /// __debug_info section, and the low_pc is the starting address for the
2100 /// inlining instance.
2101 void DwarfDebug::emitDebugInlineInfo() {
2102 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2108 Asm->OutStreamer.SwitchSection(
2109 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2111 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2112 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2113 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2115 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2117 Asm->OutStreamer.AddComment("Dwarf Version");
2118 Asm->EmitInt16(dwarf::DWARF_VERSION);
2119 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2120 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2122 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2123 E = InlinedSPNodes.end(); I != E; ++I) {
2125 const MDNode *Node = *I;
2126 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2127 = InlineInfo.find(Node);
2128 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2129 DISubprogram SP(Node);
2130 StringRef LName = SP.getLinkageName();
2131 StringRef Name = SP.getName();
2133 Asm->OutStreamer.AddComment("MIPS linkage name");
2135 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2137 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2138 DwarfStrSectionSym);
2140 Asm->OutStreamer.AddComment("Function name");
2141 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2142 Asm->EmitULEB128(Labels.size(), "Inline count");
2144 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2145 LE = Labels.end(); LI != LE; ++LI) {
2146 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2147 Asm->EmitInt32(LI->second->getOffset());
2149 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2150 Asm->OutStreamer.EmitSymbolValue(LI->first,
2151 Asm->getTargetData().getPointerSize(),0);
2155 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));