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;
526 std::pair<std::string, std::string> SourceName =
527 std::make_pair(FileName, DirName);
528 std::pair<std::pair<std::string, std::string>, unsigned> Entry =
529 make_pair(SourceName, SrcId);
531 std::map<std::pair<std::string, std::string>, unsigned>::iterator I;
533 tie(I, NewlyInserted) = SourceIdMap.insert(Entry);
537 // Print out a .file directive to specify files for .loc directives.
538 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.first.second,
544 /// constructCompileUnit - Create new CompileUnit for the given
545 /// metadata node with tag DW_TAG_compile_unit.
546 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
547 DICompileUnit DIUnit(N);
548 StringRef FN = DIUnit.getFilename();
549 CompilationDir = DIUnit.getDirectory();
550 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
552 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
553 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
554 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
555 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
556 DIUnit.getLanguage());
557 NewCU->addString(Die, dwarf::DW_AT_name, FN);
558 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
559 // simplifies debug range entries.
560 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
561 // DW_AT_stmt_list is a offset of line number information for this
562 // compile unit in debug_line section.
563 if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
564 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
565 Asm->GetTempSymbol("section_line"));
567 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
569 if (!CompilationDir.empty())
570 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
571 if (DIUnit.isOptimized())
572 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
574 StringRef Flags = DIUnit.getFlags();
576 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
578 if (unsigned RVer = DIUnit.getRunTimeVersion())
579 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
580 dwarf::DW_FORM_data1, RVer);
584 CUMap.insert(std::make_pair(N, NewCU));
588 /// construct SubprogramDIE - Construct subprogram DIE.
589 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
591 CompileUnit *&CURef = SPMap[N];
597 if (!SP.isDefinition())
598 // This is a method declaration which will be handled while constructing
602 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
605 TheCU->insertDIE(N, SubprogramDie);
607 // Add to context owner.
608 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
613 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
614 /// as llvm.dbg.enum and llvm.dbg.ty
615 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
616 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
617 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
618 const MDNode *N = NMD->getOperand(i);
619 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
620 constructSubprogramDIE(CU, N);
623 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
624 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
625 const MDNode *N = NMD->getOperand(i);
626 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
627 CU->createGlobalVariableDIE(N);
630 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
631 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
632 DIType Ty(NMD->getOperand(i));
633 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
634 CU->getOrCreateTypeDIE(Ty);
637 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
638 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
639 DIType Ty(NMD->getOperand(i));
640 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
641 CU->getOrCreateTypeDIE(Ty);
645 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
646 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
647 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
648 DebugInfoFinder DbgFinder;
649 DbgFinder.processModule(*M);
651 bool HasDebugInfo = false;
652 // Scan all the compile-units to see if there are any marked as the main
653 // unit. If not, we do not generate debug info.
654 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
655 E = DbgFinder.compile_unit_end(); I != E; ++I) {
656 if (DICompileUnit(*I).isMain()) {
661 if (!HasDebugInfo) return false;
663 // Create all the compile unit DIEs.
664 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
665 E = DbgFinder.compile_unit_end(); I != E; ++I)
666 constructCompileUnit(*I);
668 // Create DIEs for each global variable.
669 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
670 E = DbgFinder.global_variable_end(); I != E; ++I) {
671 const MDNode *N = *I;
672 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
673 CU->createGlobalVariableDIE(N);
676 // Create DIEs for each subprogram.
677 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
678 E = DbgFinder.subprogram_end(); I != E; ++I) {
679 const MDNode *N = *I;
680 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
681 constructSubprogramDIE(CU, N);
687 /// beginModule - Emit all Dwarf sections that should come prior to the
688 /// content. Create global DIEs and emit initial debug info sections.
689 /// This is invoked by the target AsmPrinter.
690 void DwarfDebug::beginModule(Module *M) {
691 if (DisableDebugInfoPrinting)
694 // If module has named metadata anchors then use them, otherwise scan the
695 // module using debug info finder to collect debug info.
696 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
698 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
699 DICompileUnit CUNode(CU_Nodes->getOperand(i));
700 CompileUnit *CU = constructCompileUnit(CUNode);
701 DIArray GVs = CUNode.getGlobalVariables();
702 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
703 CU->createGlobalVariableDIE(GVs.getElement(i));
704 DIArray SPs = CUNode.getSubprograms();
705 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
706 constructSubprogramDIE(CU, SPs.getElement(i));
707 DIArray EnumTypes = CUNode.getEnumTypes();
708 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
709 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
710 DIArray RetainedTypes = CUNode.getRetainedTypes();
711 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
712 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
714 } else if (!collectLegacyDebugInfo(M))
717 collectInfoFromNamedMDNodes(M);
719 // Tell MMI that we have debug info.
720 MMI->setDebugInfoAvailability(true);
722 // Emit initial sections.
725 // Prime section data.
726 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
729 /// endModule - Emit all Dwarf sections that should come after the content.
731 void DwarfDebug::endModule() {
732 if (!FirstCU) return;
733 const Module *M = MMI->getModule();
734 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
736 // Collect info for variables that were optimized out.
737 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
738 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
739 DICompileUnit TheCU(CU_Nodes->getOperand(i));
740 DIArray Subprograms = TheCU.getSubprograms();
741 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
742 DISubprogram SP(Subprograms.getElement(i));
743 if (ProcessedSPNodes.count(SP) != 0) continue;
744 if (!SP.Verify()) continue;
745 if (!SP.isDefinition()) continue;
746 DIArray Variables = SP.getVariables();
747 if (Variables.getNumElements() == 0) continue;
749 LexicalScope *Scope =
750 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
751 DeadFnScopeMap[SP] = Scope;
753 // Construct subprogram DIE and add variables DIEs.
754 CompileUnit *SPCU = CUMap.lookup(TheCU);
755 assert(SPCU && "Unable to find Compile Unit!");
756 constructSubprogramDIE(SPCU, SP);
757 DIE *ScopeDIE = SPCU->getDIE(SP);
758 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
759 DIVariable DV(Variables.getElement(vi));
760 if (!DV.Verify()) continue;
761 DbgVariable *NewVar = new DbgVariable(DV, NULL);
762 if (DIE *VariableDIE =
763 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
764 ScopeDIE->addChild(VariableDIE);
770 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
771 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
772 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
774 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
776 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
777 AE = AbstractSPDies.end(); AI != AE; ++AI) {
778 DIE *ISP = AI->second;
779 if (InlinedSubprogramDIEs.count(ISP))
781 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
784 // Emit DW_AT_containing_type attribute to connect types with their
785 // vtable holding type.
786 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
787 CUE = CUMap.end(); CUI != CUE; ++CUI) {
788 CompileUnit *TheCU = CUI->second;
789 TheCU->constructContainingTypeDIEs();
792 // Standard sections final addresses.
793 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
794 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
795 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
796 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
798 // End text sections.
799 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
800 Asm->OutStreamer.SwitchSection(SectionMap[i]);
801 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
804 // Compute DIE offsets and sizes.
805 computeSizeAndOffsets();
807 // Emit all the DIEs into a debug info section
810 // Corresponding abbreviations into a abbrev section.
813 // Emit info into a dwarf accelerator table sections.
814 if (DwarfAccelTables) {
817 emitAccelNamespaces();
821 // Emit info into a debug pubtypes section.
824 // Emit info into a debug loc section.
827 // Emit info into a debug aranges section.
830 // Emit info into a debug ranges section.
833 // Emit info into a debug macinfo section.
837 emitDebugInlineInfo();
839 // Emit info into a debug str section.
843 DeleteContainerSeconds(DeadFnScopeMap);
845 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
846 E = CUMap.end(); I != E; ++I)
848 FirstCU = NULL; // Reset for the next Module, if any.
851 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
852 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
854 LLVMContext &Ctx = DV->getContext();
855 // More then one inlined variable corresponds to one abstract variable.
856 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
857 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
859 return AbsDbgVariable;
861 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
865 AbsDbgVariable = new DbgVariable(Var, NULL);
866 addScopeVariable(Scope, AbsDbgVariable);
867 AbstractVariables[Var] = AbsDbgVariable;
868 return AbsDbgVariable;
871 /// addCurrentFnArgument - If Var is a current function argument then add
872 /// it to CurrentFnArguments list.
873 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
874 DbgVariable *Var, LexicalScope *Scope) {
875 if (!LScopes.isCurrentFunctionScope(Scope))
877 DIVariable DV = Var->getVariable();
878 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
880 unsigned ArgNo = DV.getArgNumber();
884 size_t Size = CurrentFnArguments.size();
886 CurrentFnArguments.resize(MF->getFunction()->arg_size());
887 // llvm::Function argument size is not good indicator of how many
888 // arguments does the function have at source level.
890 CurrentFnArguments.resize(ArgNo * 2);
891 CurrentFnArguments[ArgNo - 1] = Var;
895 /// collectVariableInfoFromMMITable - Collect variable information from
896 /// side table maintained by MMI.
898 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
899 SmallPtrSet<const MDNode *, 16> &Processed) {
900 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
901 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
902 VE = VMap.end(); VI != VE; ++VI) {
903 const MDNode *Var = VI->first;
905 Processed.insert(Var);
907 const std::pair<unsigned, DebugLoc> &VP = VI->second;
909 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
911 // If variable scope is not found then skip this variable.
915 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
916 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
917 RegVar->setFrameIndex(VP.first);
918 if (!addCurrentFnArgument(MF, RegVar, Scope))
919 addScopeVariable(Scope, RegVar);
921 AbsDbgVariable->setFrameIndex(VP.first);
925 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
926 /// DBG_VALUE instruction, is in a defined reg.
927 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
928 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
929 return MI->getNumOperands() == 3 &&
930 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
931 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
934 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
936 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
937 const MCSymbol *FLabel,
938 const MCSymbol *SLabel,
939 const MachineInstr *MI) {
940 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
942 if (MI->getNumOperands() != 3) {
943 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
944 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
946 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
947 MachineLocation MLoc;
948 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
949 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
951 if (MI->getOperand(0).isImm())
952 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
953 if (MI->getOperand(0).isFPImm())
954 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
955 if (MI->getOperand(0).isCImm())
956 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
958 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
961 /// collectVariableInfo - Find variables for each lexical scope.
963 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
964 SmallPtrSet<const MDNode *, 16> &Processed) {
966 /// collection info from MMI table.
967 collectVariableInfoFromMMITable(MF, Processed);
969 for (SmallVectorImpl<const MDNode*>::const_iterator
970 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
972 const MDNode *Var = *UVI;
973 if (Processed.count(Var))
976 // History contains relevant DBG_VALUE instructions for Var and instructions
978 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
981 const MachineInstr *MInsn = History.front();
984 LexicalScope *Scope = NULL;
985 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
986 DISubprogram(DV.getContext()).describes(MF->getFunction()))
987 Scope = LScopes.getCurrentFunctionScope();
989 if (DV.getVersion() <= LLVMDebugVersion9)
990 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
992 if (MDNode *IA = DV.getInlinedAt())
993 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
995 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
998 // If variable scope is not found then skip this variable.
1002 Processed.insert(DV);
1003 assert(MInsn->isDebugValue() && "History must begin with debug value");
1004 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1005 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1006 if (!addCurrentFnArgument(MF, RegVar, Scope))
1007 addScopeVariable(Scope, RegVar);
1009 AbsVar->setMInsn(MInsn);
1011 // Simple ranges that are fully coalesced.
1012 if (History.size() <= 1 || (History.size() == 2 &&
1013 MInsn->isIdenticalTo(History.back()))) {
1014 RegVar->setMInsn(MInsn);
1018 // handle multiple DBG_VALUE instructions describing one variable.
1019 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1021 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1022 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1023 const MachineInstr *Begin = *HI;
1024 assert(Begin->isDebugValue() && "Invalid History entry");
1026 // Check if DBG_VALUE is truncating a range.
1027 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1028 && !Begin->getOperand(0).getReg())
1031 // Compute the range for a register location.
1032 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1033 const MCSymbol *SLabel = 0;
1036 // If Begin is the last instruction in History then its value is valid
1037 // until the end of the function.
1038 SLabel = FunctionEndSym;
1040 const MachineInstr *End = HI[1];
1041 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1042 << "\t" << *Begin << "\t" << *End << "\n");
1043 if (End->isDebugValue())
1044 SLabel = getLabelBeforeInsn(End);
1046 // End is a normal instruction clobbering the range.
1047 SLabel = getLabelAfterInsn(End);
1048 assert(SLabel && "Forgot label after clobber instruction");
1053 // The value is valid until the next DBG_VALUE or clobber.
1054 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1057 DotDebugLocEntries.push_back(DotDebugLocEntry());
1060 // Collect info for variables that were optimized out.
1061 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1062 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1063 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1064 DIVariable DV(Variables.getElement(i));
1065 if (!DV || !DV.Verify() || !Processed.insert(DV))
1067 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1068 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1072 /// getLabelBeforeInsn - Return Label preceding the instruction.
1073 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1074 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1075 assert(Label && "Didn't insert label before instruction");
1079 /// getLabelAfterInsn - Return Label immediately following the instruction.
1080 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1081 return LabelsAfterInsn.lookup(MI);
1084 /// beginInstruction - Process beginning of an instruction.
1085 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1086 // Check if source location changes, but ignore DBG_VALUE locations.
1087 if (!MI->isDebugValue()) {
1088 DebugLoc DL = MI->getDebugLoc();
1089 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1090 unsigned Flags = DWARF2_FLAG_IS_STMT;
1092 if (DL == PrologEndLoc) {
1093 Flags |= DWARF2_FLAG_PROLOGUE_END;
1094 PrologEndLoc = DebugLoc();
1096 if (!DL.isUnknown()) {
1097 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1098 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1100 recordSourceLine(0, 0, 0, 0);
1104 // Insert labels where requested.
1105 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1106 LabelsBeforeInsn.find(MI);
1109 if (I == LabelsBeforeInsn.end())
1112 // Label already assigned.
1117 PrevLabel = MMI->getContext().CreateTempSymbol();
1118 Asm->OutStreamer.EmitLabel(PrevLabel);
1120 I->second = PrevLabel;
1123 /// endInstruction - Process end of an instruction.
1124 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1125 // Don't create a new label after DBG_VALUE instructions.
1126 // They don't generate code.
1127 if (!MI->isDebugValue())
1130 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1131 LabelsAfterInsn.find(MI);
1134 if (I == LabelsAfterInsn.end())
1137 // Label already assigned.
1141 // We need a label after this instruction.
1143 PrevLabel = MMI->getContext().CreateTempSymbol();
1144 Asm->OutStreamer.EmitLabel(PrevLabel);
1146 I->second = PrevLabel;
1149 /// identifyScopeMarkers() -
1150 /// Each LexicalScope has first instruction and last instruction to mark
1151 /// beginning and end of a scope respectively. Create an inverse map that list
1152 /// scopes starts (and ends) with an instruction. One instruction may start (or
1153 /// end) multiple scopes. Ignore scopes that are not reachable.
1154 void DwarfDebug::identifyScopeMarkers() {
1155 SmallVector<LexicalScope *, 4> WorkList;
1156 WorkList.push_back(LScopes.getCurrentFunctionScope());
1157 while (!WorkList.empty()) {
1158 LexicalScope *S = WorkList.pop_back_val();
1160 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1161 if (!Children.empty())
1162 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1163 SE = Children.end(); SI != SE; ++SI)
1164 WorkList.push_back(*SI);
1166 if (S->isAbstractScope())
1169 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1172 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1173 RE = Ranges.end(); RI != RE; ++RI) {
1174 assert(RI->first && "InsnRange does not have first instruction!");
1175 assert(RI->second && "InsnRange does not have second instruction!");
1176 requestLabelBeforeInsn(RI->first);
1177 requestLabelAfterInsn(RI->second);
1182 /// getScopeNode - Get MDNode for DebugLoc's scope.
1183 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1184 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1185 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1186 return DL.getScope(Ctx);
1189 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1190 /// line number info for the function.
1191 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1192 const MDNode *Scope = getScopeNode(DL, Ctx);
1193 DISubprogram SP = getDISubprogram(Scope);
1195 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1199 /// beginFunction - Gather pre-function debug information. Assumes being
1200 /// emitted immediately after the function entry point.
1201 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1202 if (!MMI->hasDebugInfo()) return;
1203 LScopes.initialize(*MF);
1204 if (LScopes.empty()) return;
1205 identifyScopeMarkers();
1207 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1208 Asm->getFunctionNumber());
1209 // Assumes in correct section after the entry point.
1210 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1212 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1214 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1215 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1216 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1218 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1220 bool AtBlockEntry = true;
1221 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1223 const MachineInstr *MI = II;
1225 if (MI->isDebugValue()) {
1226 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1228 // Keep track of user variables.
1230 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1232 // Variable is in a register, we need to check for clobbers.
1233 if (isDbgValueInDefinedReg(MI))
1234 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1236 // Check the history of this variable.
1237 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1238 if (History.empty()) {
1239 UserVariables.push_back(Var);
1240 // The first mention of a function argument gets the FunctionBeginSym
1241 // label, so arguments are visible when breaking at function entry.
1243 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1244 DISubprogram(getDISubprogram(DV.getContext()))
1245 .describes(MF->getFunction()))
1246 LabelsBeforeInsn[MI] = FunctionBeginSym;
1248 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1249 const MachineInstr *Prev = History.back();
1250 if (Prev->isDebugValue()) {
1251 // Coalesce identical entries at the end of History.
1252 if (History.size() >= 2 &&
1253 Prev->isIdenticalTo(History[History.size() - 2])) {
1254 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1256 << "\t" << *History[History.size() - 2] << "\n");
1260 // Terminate old register assignments that don't reach MI;
1261 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1262 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1263 isDbgValueInDefinedReg(Prev)) {
1264 // Previous register assignment needs to terminate at the end of
1266 MachineBasicBlock::const_iterator LastMI =
1267 PrevMBB->getLastNonDebugInstr();
1268 if (LastMI == PrevMBB->end()) {
1269 // Drop DBG_VALUE for empty range.
1270 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1271 << "\t" << *Prev << "\n");
1275 // Terminate after LastMI.
1276 History.push_back(LastMI);
1281 History.push_back(MI);
1283 // Not a DBG_VALUE instruction.
1285 AtBlockEntry = false;
1287 // First known non DBG_VALUE location marks beginning of function
1289 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1290 PrologEndLoc = MI->getDebugLoc();
1292 // Check if the instruction clobbers any registers with debug vars.
1293 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1294 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1295 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1297 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1298 unsigned Reg = *AI; ++AI) {
1299 const MDNode *Var = LiveUserVar[Reg];
1302 // Reg is now clobbered.
1303 LiveUserVar[Reg] = 0;
1305 // Was MD last defined by a DBG_VALUE referring to Reg?
1306 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1307 if (HistI == DbgValues.end())
1309 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1310 if (History.empty())
1312 const MachineInstr *Prev = History.back();
1313 // Sanity-check: Register assignments are terminated at the end of
1315 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1317 // Is the variable still in Reg?
1318 if (!isDbgValueInDefinedReg(Prev) ||
1319 Prev->getOperand(0).getReg() != Reg)
1321 // Var is clobbered. Make sure the next instruction gets a label.
1322 History.push_back(MI);
1329 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1331 SmallVectorImpl<const MachineInstr*> &History = I->second;
1332 if (History.empty())
1335 // Make sure the final register assignments are terminated.
1336 const MachineInstr *Prev = History.back();
1337 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1338 const MachineBasicBlock *PrevMBB = Prev->getParent();
1339 MachineBasicBlock::const_iterator LastMI =
1340 PrevMBB->getLastNonDebugInstr();
1341 if (LastMI == PrevMBB->end())
1342 // Drop DBG_VALUE for empty range.
1345 // Terminate after LastMI.
1346 History.push_back(LastMI);
1349 // Request labels for the full history.
1350 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1351 const MachineInstr *MI = History[i];
1352 if (MI->isDebugValue())
1353 requestLabelBeforeInsn(MI);
1355 requestLabelAfterInsn(MI);
1359 PrevInstLoc = DebugLoc();
1360 PrevLabel = FunctionBeginSym;
1362 // Record beginning of function.
1363 if (!PrologEndLoc.isUnknown()) {
1364 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1365 MF->getFunction()->getContext());
1366 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1367 FnStartDL.getScope(MF->getFunction()->getContext()),
1368 DWARF2_FLAG_IS_STMT);
1372 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1373 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1374 ScopeVariables[LS].push_back(Var);
1375 // Vars.push_back(Var);
1378 /// endFunction - Gather and emit post-function debug information.
1380 void DwarfDebug::endFunction(const MachineFunction *MF) {
1381 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1383 // Define end label for subprogram.
1384 FunctionEndSym = Asm->GetTempSymbol("func_end",
1385 Asm->getFunctionNumber());
1386 // Assumes in correct section after the entry point.
1387 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1389 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1390 collectVariableInfo(MF, ProcessedVars);
1392 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1393 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1394 assert(TheCU && "Unable to find compile unit!");
1396 // Construct abstract scopes.
1397 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1398 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1399 LexicalScope *AScope = AList[i];
1400 DISubprogram SP(AScope->getScopeNode());
1402 // Collect info for variables that were optimized out.
1403 DIArray Variables = SP.getVariables();
1404 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1405 DIVariable DV(Variables.getElement(i));
1406 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1408 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1409 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1412 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1413 constructScopeDIE(TheCU, AScope);
1416 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1418 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1419 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1420 dwarf::DW_FORM_flag, 1);
1422 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1423 MMI->getFrameMoves()));
1426 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1427 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1428 DeleteContainerPointers(I->second);
1429 ScopeVariables.clear();
1430 DeleteContainerPointers(CurrentFnArguments);
1431 UserVariables.clear();
1433 AbstractVariables.clear();
1434 LabelsBeforeInsn.clear();
1435 LabelsAfterInsn.clear();
1439 /// recordSourceLine - Register a source line with debug info. Returns the
1440 /// unique label that was emitted and which provides correspondence to
1441 /// the source line list.
1442 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1448 DIDescriptor Scope(S);
1450 if (Scope.isCompileUnit()) {
1451 DICompileUnit CU(S);
1452 Fn = CU.getFilename();
1453 Dir = CU.getDirectory();
1454 } else if (Scope.isFile()) {
1456 Fn = F.getFilename();
1457 Dir = F.getDirectory();
1458 } else if (Scope.isSubprogram()) {
1460 Fn = SP.getFilename();
1461 Dir = SP.getDirectory();
1462 } else if (Scope.isLexicalBlockFile()) {
1463 DILexicalBlockFile DBF(S);
1464 Fn = DBF.getFilename();
1465 Dir = DBF.getDirectory();
1466 } else if (Scope.isLexicalBlock()) {
1467 DILexicalBlock DB(S);
1468 Fn = DB.getFilename();
1469 Dir = DB.getDirectory();
1471 llvm_unreachable("Unexpected scope info");
1473 Src = GetOrCreateSourceID(Fn, Dir);
1475 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1478 //===----------------------------------------------------------------------===//
1480 //===----------------------------------------------------------------------===//
1482 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1485 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1486 // Get the children.
1487 const std::vector<DIE *> &Children = Die->getChildren();
1489 // Record the abbreviation.
1490 assignAbbrevNumber(Die->getAbbrev());
1492 // Get the abbreviation for this DIE.
1493 unsigned AbbrevNumber = Die->getAbbrevNumber();
1494 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1497 Die->setOffset(Offset);
1499 // Start the size with the size of abbreviation code.
1500 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1502 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1503 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1505 // Size the DIE attribute values.
1506 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1507 // Size attribute value.
1508 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1510 // Size the DIE children if any.
1511 if (!Children.empty()) {
1512 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1513 "Children flag not set");
1515 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1516 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1518 // End of children marker.
1519 Offset += sizeof(int8_t);
1522 Die->setSize(Offset - Die->getOffset());
1526 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1528 void DwarfDebug::computeSizeAndOffsets() {
1529 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1530 E = CUMap.end(); I != E; ++I) {
1531 // Compute size of compile unit header.
1533 sizeof(int32_t) + // Length of Compilation Unit Info
1534 sizeof(int16_t) + // DWARF version number
1535 sizeof(int32_t) + // Offset Into Abbrev. Section
1536 sizeof(int8_t); // Pointer Size (in bytes)
1537 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1541 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1542 /// the start of each one.
1543 void DwarfDebug::EmitSectionLabels() {
1544 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1546 // Dwarf sections base addresses.
1547 DwarfInfoSectionSym =
1548 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1549 DwarfAbbrevSectionSym =
1550 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1551 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1553 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1554 EmitSectionSym(Asm, MacroInfo);
1556 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1557 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1558 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1559 DwarfStrSectionSym =
1560 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1561 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1564 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1565 "section_debug_loc");
1567 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1568 EmitSectionSym(Asm, TLOF.getDataSection());
1571 /// emitDIE - Recursively emits a debug information entry.
1573 void DwarfDebug::emitDIE(DIE *Die) {
1574 // Get the abbreviation for this DIE.
1575 unsigned AbbrevNumber = Die->getAbbrevNumber();
1576 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1578 // Emit the code (index) for the abbreviation.
1579 if (Asm->isVerbose())
1580 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1581 Twine::utohexstr(Die->getOffset()) + ":0x" +
1582 Twine::utohexstr(Die->getSize()) + " " +
1583 dwarf::TagString(Abbrev->getTag()));
1584 Asm->EmitULEB128(AbbrevNumber);
1586 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1587 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1589 // Emit the DIE attribute values.
1590 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1591 unsigned Attr = AbbrevData[i].getAttribute();
1592 unsigned Form = AbbrevData[i].getForm();
1593 assert(Form && "Too many attributes for DIE (check abbreviation)");
1595 if (Asm->isVerbose())
1596 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1599 case dwarf::DW_AT_abstract_origin: {
1600 DIEEntry *E = cast<DIEEntry>(Values[i]);
1601 DIE *Origin = E->getEntry();
1602 unsigned Addr = Origin->getOffset();
1603 Asm->EmitInt32(Addr);
1606 case dwarf::DW_AT_ranges: {
1607 // DW_AT_range Value encodes offset in debug_range section.
1608 DIEInteger *V = cast<DIEInteger>(Values[i]);
1610 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1611 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1615 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1617 DwarfDebugRangeSectionSym,
1622 case dwarf::DW_AT_location: {
1623 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1624 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1626 Values[i]->EmitValue(Asm, Form);
1629 case dwarf::DW_AT_accessibility: {
1630 if (Asm->isVerbose()) {
1631 DIEInteger *V = cast<DIEInteger>(Values[i]);
1632 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1634 Values[i]->EmitValue(Asm, Form);
1638 // Emit an attribute using the defined form.
1639 Values[i]->EmitValue(Asm, Form);
1644 // Emit the DIE children if any.
1645 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1646 const std::vector<DIE *> &Children = Die->getChildren();
1648 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1649 emitDIE(Children[j]);
1651 if (Asm->isVerbose())
1652 Asm->OutStreamer.AddComment("End Of Children Mark");
1657 /// emitDebugInfo - Emit the debug info section.
1659 void DwarfDebug::emitDebugInfo() {
1660 // Start debug info section.
1661 Asm->OutStreamer.SwitchSection(
1662 Asm->getObjFileLowering().getDwarfInfoSection());
1663 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1664 E = CUMap.end(); I != E; ++I) {
1665 CompileUnit *TheCU = I->second;
1666 DIE *Die = TheCU->getCUDie();
1668 // Emit the compile units header.
1669 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1672 // Emit size of content not including length itself
1673 unsigned ContentSize = Die->getSize() +
1674 sizeof(int16_t) + // DWARF version number
1675 sizeof(int32_t) + // Offset Into Abbrev. Section
1676 sizeof(int8_t); // Pointer Size (in bytes)
1678 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1679 Asm->EmitInt32(ContentSize);
1680 Asm->OutStreamer.AddComment("DWARF version number");
1681 Asm->EmitInt16(dwarf::DWARF_VERSION);
1682 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1683 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1684 DwarfAbbrevSectionSym);
1685 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1686 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1689 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1693 /// emitAbbreviations - Emit the abbreviation section.
1695 void DwarfDebug::emitAbbreviations() const {
1696 // Check to see if it is worth the effort.
1697 if (!Abbreviations.empty()) {
1698 // Start the debug abbrev section.
1699 Asm->OutStreamer.SwitchSection(
1700 Asm->getObjFileLowering().getDwarfAbbrevSection());
1702 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1704 // For each abbrevation.
1705 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1706 // Get abbreviation data
1707 const DIEAbbrev *Abbrev = Abbreviations[i];
1709 // Emit the abbrevations code (base 1 index.)
1710 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1712 // Emit the abbreviations data.
1716 // Mark end of abbreviations.
1717 Asm->EmitULEB128(0, "EOM(3)");
1719 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1723 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1724 /// the line matrix.
1726 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1727 // Define last address of section.
1728 Asm->OutStreamer.AddComment("Extended Op");
1731 Asm->OutStreamer.AddComment("Op size");
1732 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1733 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1734 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1736 Asm->OutStreamer.AddComment("Section end label");
1738 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1739 Asm->getTargetData().getPointerSize(),
1742 // Mark end of matrix.
1743 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1749 /// emitAccelNames - Emit visible names into a hashed accelerator table
1751 void DwarfDebug::emitAccelNames() {
1752 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1753 dwarf::DW_FORM_data4));
1754 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1755 E = CUMap.end(); I != E; ++I) {
1756 CompileUnit *TheCU = I->second;
1757 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1758 for (StringMap<std::vector<DIE*> >::const_iterator
1759 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1760 const char *Name = GI->getKeyData();
1761 const std::vector<DIE *> &Entities = GI->second;
1762 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1763 DE = Entities.end(); DI != DE; ++DI)
1764 AT.AddName(Name, (*DI));
1768 AT.FinalizeTable(Asm, "Names");
1769 Asm->OutStreamer.SwitchSection(
1770 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1771 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1772 Asm->OutStreamer.EmitLabel(SectionBegin);
1774 // Emit the full data.
1775 AT.Emit(Asm, SectionBegin, this);
1778 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1779 /// accelerator table section.
1780 void DwarfDebug::emitAccelObjC() {
1781 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1782 dwarf::DW_FORM_data4));
1783 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1784 E = CUMap.end(); I != E; ++I) {
1785 CompileUnit *TheCU = I->second;
1786 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1787 for (StringMap<std::vector<DIE*> >::const_iterator
1788 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1789 const char *Name = GI->getKeyData();
1790 const std::vector<DIE *> &Entities = GI->second;
1791 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1792 DE = Entities.end(); DI != DE; ++DI)
1793 AT.AddName(Name, (*DI));
1797 AT.FinalizeTable(Asm, "ObjC");
1798 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1799 .getDwarfAccelObjCSection());
1800 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1801 Asm->OutStreamer.EmitLabel(SectionBegin);
1803 // Emit the full data.
1804 AT.Emit(Asm, SectionBegin, this);
1807 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1809 void DwarfDebug::emitAccelNamespaces() {
1810 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1811 dwarf::DW_FORM_data4));
1812 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1813 E = CUMap.end(); I != E; ++I) {
1814 CompileUnit *TheCU = I->second;
1815 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1816 for (StringMap<std::vector<DIE*> >::const_iterator
1817 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1818 const char *Name = GI->getKeyData();
1819 const std::vector<DIE *> &Entities = GI->second;
1820 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1821 DE = Entities.end(); DI != DE; ++DI)
1822 AT.AddName(Name, (*DI));
1826 AT.FinalizeTable(Asm, "namespac");
1827 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1828 .getDwarfAccelNamespaceSection());
1829 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1830 Asm->OutStreamer.EmitLabel(SectionBegin);
1832 // Emit the full data.
1833 AT.Emit(Asm, SectionBegin, this);
1836 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1837 void DwarfDebug::emitAccelTypes() {
1838 std::vector<DwarfAccelTable::Atom> Atoms;
1839 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1840 dwarf::DW_FORM_data4));
1841 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1842 dwarf::DW_FORM_data2));
1843 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1844 dwarf::DW_FORM_data1));
1845 DwarfAccelTable AT(Atoms);
1846 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1847 E = CUMap.end(); I != E; ++I) {
1848 CompileUnit *TheCU = I->second;
1849 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1850 = TheCU->getAccelTypes();
1851 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1852 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1853 const char *Name = GI->getKeyData();
1854 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1855 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1856 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1857 AT.AddName(Name, (*DI).first, (*DI).second);
1861 AT.FinalizeTable(Asm, "types");
1862 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1863 .getDwarfAccelTypesSection());
1864 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1865 Asm->OutStreamer.EmitLabel(SectionBegin);
1867 // Emit the full data.
1868 AT.Emit(Asm, SectionBegin, this);
1871 void DwarfDebug::emitDebugPubTypes() {
1872 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1873 E = CUMap.end(); I != E; ++I) {
1874 CompileUnit *TheCU = I->second;
1875 // Start the dwarf pubtypes section.
1876 Asm->OutStreamer.SwitchSection(
1877 Asm->getObjFileLowering().getDwarfPubTypesSection());
1878 Asm->OutStreamer.AddComment("Length of Public Types Info");
1879 Asm->EmitLabelDifference(
1880 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1881 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1883 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1886 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1887 Asm->EmitInt16(dwarf::DWARF_VERSION);
1889 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1890 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1891 DwarfInfoSectionSym);
1893 Asm->OutStreamer.AddComment("Compilation Unit Length");
1894 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1895 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1898 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1899 for (StringMap<DIE*>::const_iterator
1900 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1901 const char *Name = GI->getKeyData();
1902 DIE *Entity = GI->second;
1904 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1905 Asm->EmitInt32(Entity->getOffset());
1907 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1908 // Emit the name with a terminating null byte.
1909 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1912 Asm->OutStreamer.AddComment("End Mark");
1914 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1919 /// emitDebugStr - Emit visible names into a debug str section.
1921 void DwarfDebug::emitDebugStr() {
1922 // Check to see if it is worth the effort.
1923 if (StringPool.empty()) return;
1925 // Start the dwarf str section.
1926 Asm->OutStreamer.SwitchSection(
1927 Asm->getObjFileLowering().getDwarfStrSection());
1929 // Get all of the string pool entries and put them in an array by their ID so
1930 // we can sort them.
1931 SmallVector<std::pair<unsigned,
1932 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1934 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1935 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1936 Entries.push_back(std::make_pair(I->second.second, &*I));
1938 array_pod_sort(Entries.begin(), Entries.end());
1940 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1941 // Emit a label for reference from debug information entries.
1942 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1944 // Emit the string itself with a terminating null byte.
1945 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1946 Entries[i].second->getKeyLength()+1),
1951 /// emitDebugLoc - Emit visible names into a debug loc section.
1953 void DwarfDebug::emitDebugLoc() {
1954 if (DotDebugLocEntries.empty())
1957 for (SmallVector<DotDebugLocEntry, 4>::iterator
1958 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1960 DotDebugLocEntry &Entry = *I;
1961 if (I + 1 != DotDebugLocEntries.end())
1965 // Start the dwarf loc section.
1966 Asm->OutStreamer.SwitchSection(
1967 Asm->getObjFileLowering().getDwarfLocSection());
1968 unsigned char Size = Asm->getTargetData().getPointerSize();
1969 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1971 for (SmallVector<DotDebugLocEntry, 4>::iterator
1972 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1973 I != E; ++I, ++index) {
1974 DotDebugLocEntry &Entry = *I;
1975 if (Entry.isMerged()) continue;
1976 if (Entry.isEmpty()) {
1977 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1978 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1979 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1981 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1982 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1983 DIVariable DV(Entry.Variable);
1984 Asm->OutStreamer.AddComment("Loc expr size");
1985 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1986 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1987 Asm->EmitLabelDifference(end, begin, 2);
1988 Asm->OutStreamer.EmitLabel(begin);
1989 if (Entry.isInt()) {
1990 DIBasicType BTy(DV.getType());
1992 (BTy.getEncoding() == dwarf::DW_ATE_signed
1993 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1994 Asm->OutStreamer.AddComment("DW_OP_consts");
1995 Asm->EmitInt8(dwarf::DW_OP_consts);
1996 Asm->EmitSLEB128(Entry.getInt());
1998 Asm->OutStreamer.AddComment("DW_OP_constu");
1999 Asm->EmitInt8(dwarf::DW_OP_constu);
2000 Asm->EmitULEB128(Entry.getInt());
2002 } else if (Entry.isLocation()) {
2003 if (!DV.hasComplexAddress())
2005 Asm->EmitDwarfRegOp(Entry.Loc);
2007 // Complex address entry.
2008 unsigned N = DV.getNumAddrElements();
2010 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2011 if (Entry.Loc.getOffset()) {
2013 Asm->EmitDwarfRegOp(Entry.Loc);
2014 Asm->OutStreamer.AddComment("DW_OP_deref");
2015 Asm->EmitInt8(dwarf::DW_OP_deref);
2016 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2017 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2018 Asm->EmitSLEB128(DV.getAddrElement(1));
2020 // If first address element is OpPlus then emit
2021 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2022 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2023 Asm->EmitDwarfRegOp(Loc);
2027 Asm->EmitDwarfRegOp(Entry.Loc);
2030 // Emit remaining complex address elements.
2031 for (; i < N; ++i) {
2032 uint64_t Element = DV.getAddrElement(i);
2033 if (Element == DIBuilder::OpPlus) {
2034 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2035 Asm->EmitULEB128(DV.getAddrElement(++i));
2036 } else if (Element == DIBuilder::OpDeref)
2037 Asm->EmitInt8(dwarf::DW_OP_deref);
2038 else llvm_unreachable("unknown Opcode found in complex address");
2042 // else ... ignore constant fp. There is not any good way to
2043 // to represent them here in dwarf.
2044 Asm->OutStreamer.EmitLabel(end);
2049 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2051 void DwarfDebug::EmitDebugARanges() {
2052 // Start the dwarf aranges section.
2053 Asm->OutStreamer.SwitchSection(
2054 Asm->getObjFileLowering().getDwarfARangesSection());
2057 /// emitDebugRanges - Emit visible names into a debug ranges section.
2059 void DwarfDebug::emitDebugRanges() {
2060 // Start the dwarf ranges section.
2061 Asm->OutStreamer.SwitchSection(
2062 Asm->getObjFileLowering().getDwarfRangesSection());
2063 unsigned char Size = Asm->getTargetData().getPointerSize();
2064 for (SmallVector<const MCSymbol *, 8>::iterator
2065 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2068 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2070 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2074 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2076 void DwarfDebug::emitDebugMacInfo() {
2077 if (const MCSection *LineInfo =
2078 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2079 // Start the dwarf macinfo section.
2080 Asm->OutStreamer.SwitchSection(LineInfo);
2084 /// emitDebugInlineInfo - Emit inline info using following format.
2086 /// 1. length of section
2087 /// 2. Dwarf version number
2088 /// 3. address size.
2090 /// Entries (one "entry" for each function that was inlined):
2092 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2093 /// otherwise offset into __debug_str for regular function name.
2094 /// 2. offset into __debug_str section for regular function name.
2095 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2096 /// instances for the function.
2098 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2099 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2100 /// __debug_info section, and the low_pc is the starting address for the
2101 /// inlining instance.
2102 void DwarfDebug::emitDebugInlineInfo() {
2103 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2109 Asm->OutStreamer.SwitchSection(
2110 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2112 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2113 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2114 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2116 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2118 Asm->OutStreamer.AddComment("Dwarf Version");
2119 Asm->EmitInt16(dwarf::DWARF_VERSION);
2120 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2121 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2123 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2124 E = InlinedSPNodes.end(); I != E; ++I) {
2126 const MDNode *Node = *I;
2127 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2128 = InlineInfo.find(Node);
2129 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2130 DISubprogram SP(Node);
2131 StringRef LName = SP.getLinkageName();
2132 StringRef Name = SP.getName();
2134 Asm->OutStreamer.AddComment("MIPS linkage name");
2135 if (LName.empty()) {
2136 Asm->OutStreamer.EmitBytes(Name, 0);
2137 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2139 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2140 DwarfStrSectionSym);
2142 Asm->OutStreamer.AddComment("Function name");
2143 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2144 Asm->EmitULEB128(Labels.size(), "Inline count");
2146 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2147 LE = Labels.end(); LI != LE; ++LI) {
2148 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2149 Asm->EmitInt32(LI->second->getOffset());
2151 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2152 Asm->OutStreamer.EmitSymbolValue(LI->first,
2153 Asm->getTargetData().getPointerSize(),0);
2157 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));