1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "DwarfAccelTable.h"
18 #include "DwarfCompileUnit.h"
19 #include "llvm/Constants.h"
20 #include "llvm/Module.h"
21 #include "llvm/Instructions.h"
22 #include "llvm/CodeGen/MachineFunction.h"
23 #include "llvm/CodeGen/MachineModuleInfo.h"
24 #include "llvm/MC/MCAsmInfo.h"
25 #include "llvm/MC/MCSection.h"
26 #include "llvm/MC/MCStreamer.h"
27 #include "llvm/MC/MCSymbol.h"
28 #include "llvm/Target/TargetData.h"
29 #include "llvm/Target/TargetFrameLowering.h"
30 #include "llvm/Target/TargetLoweringObjectFile.h"
31 #include "llvm/Target/TargetMachine.h"
32 #include "llvm/Target/TargetRegisterInfo.h"
33 #include "llvm/Target/TargetOptions.h"
34 #include "llvm/Analysis/DebugInfo.h"
35 #include "llvm/Analysis/DIBuilder.h"
36 #include "llvm/ADT/Statistic.h"
37 #include "llvm/ADT/STLExtras.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/Support/CommandLine.h"
40 #include "llvm/Support/Debug.h"
41 #include "llvm/Support/ErrorHandling.h"
42 #include "llvm/Support/ValueHandle.h"
43 #include "llvm/Support/FormattedStream.h"
44 #include "llvm/Support/Timer.h"
45 #include "llvm/Support/Path.h"
48 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
50 cl::desc("Disable debug info printing"));
52 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
53 cl::desc("Make an absence of debug location information explicit."),
56 static cl::opt<bool> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
57 cl::desc("Output prototype dwarf accelerator tables."),
61 const char *DWARFGroupName = "DWARF Emission";
62 const char *DbgTimerName = "DWARF Debug Writer";
63 } // end anonymous namespace
65 //===----------------------------------------------------------------------===//
67 /// Configuration values for initial hash set sizes (log2).
69 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
73 DIType DbgVariable::getType() const {
74 DIType Ty = Var.getType();
75 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
77 if (Var.isBlockByrefVariable()) {
78 /* Byref variables, in Blocks, are declared by the programmer as
79 "SomeType VarName;", but the compiler creates a
80 __Block_byref_x_VarName struct, and gives the variable VarName
81 either the struct, or a pointer to the struct, as its type. This
82 is necessary for various behind-the-scenes things the compiler
83 needs to do with by-reference variables in blocks.
85 However, as far as the original *programmer* is concerned, the
86 variable should still have type 'SomeType', as originally declared.
88 The following function dives into the __Block_byref_x_VarName
89 struct to find the original type of the variable. This will be
90 passed back to the code generating the type for the Debug
91 Information Entry for the variable 'VarName'. 'VarName' will then
92 have the original type 'SomeType' in its debug information.
94 The original type 'SomeType' will be the type of the field named
95 'VarName' inside the __Block_byref_x_VarName struct.
97 NOTE: In order for this to not completely fail on the debugger
98 side, the Debug Information Entry for the variable VarName needs to
99 have a DW_AT_location that tells the debugger how to unwind through
100 the pointers and __Block_byref_x_VarName struct to find the actual
101 value of the variable. The function addBlockByrefType does this. */
103 unsigned tag = Ty.getTag();
105 if (tag == dwarf::DW_TAG_pointer_type) {
106 DIDerivedType DTy = DIDerivedType(Ty);
107 subType = DTy.getTypeDerivedFrom();
110 DICompositeType blockStruct = DICompositeType(subType);
111 DIArray Elements = blockStruct.getTypeArray();
113 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
114 DIDescriptor Element = Elements.getElement(i);
115 DIDerivedType DT = DIDerivedType(Element);
116 if (getName() == DT.getName())
117 return (DT.getTypeDerivedFrom());
124 } // end llvm namespace
126 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
127 : Asm(A), MMI(Asm->MMI), FirstCU(0),
128 AbbreviationsSet(InitAbbreviationsSetSize),
130 NextStringPoolNumber = 0;
132 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
133 DwarfStrSectionSym = TextSectionSym = 0;
134 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
135 FunctionBeginSym = FunctionEndSym = 0;
137 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
141 DwarfDebug::~DwarfDebug() {
144 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
145 /// temporary label to it if SymbolStem is specified.
146 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
147 const char *SymbolStem = 0) {
148 Asm->OutStreamer.SwitchSection(Section);
149 if (!SymbolStem) return 0;
151 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
152 Asm->OutStreamer.EmitLabel(TmpSym);
156 MCSymbol *DwarfDebug::getStringPool() {
157 return Asm->GetTempSymbol("section_str");
160 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
161 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
162 if (Entry.first) return Entry.first;
164 Entry.second = NextStringPoolNumber++;
165 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
168 /// assignAbbrevNumber - Define a unique number for the abbreviation.
170 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
171 // Profile the node so that we can make it unique.
175 // Check the set for priors.
176 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
178 // If it's newly added.
179 if (InSet == &Abbrev) {
180 // Add to abbreviation list.
181 Abbreviations.push_back(&Abbrev);
183 // Assign the vector position + 1 as its number.
184 Abbrev.setNumber(Abbreviations.size());
186 // Assign existing abbreviation number.
187 Abbrev.setNumber(InSet->getNumber());
191 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
192 /// printer to not emit usual symbol prefix before the symbol name is used then
193 /// return linkage name after skipping this special LLVM prefix.
194 static StringRef getRealLinkageName(StringRef LinkageName) {
196 if (LinkageName.startswith(StringRef(&One, 1)))
197 return LinkageName.substr(1);
201 static bool isObjCClass(StringRef Name) {
202 return Name.startswith("+") || Name.startswith("-");
205 static bool hasObjCCategory(StringRef Name) {
206 if (!isObjCClass(Name)) return false;
208 size_t pos = Name.find(')');
209 if (pos != std::string::npos) {
210 if (Name[pos+1] != ' ') return false;
216 static void getObjCClassCategory(StringRef In, StringRef &Class,
217 StringRef &Category) {
218 if (!hasObjCCategory(In)) {
219 Class = In.slice(In.find('[') + 1, In.find(' '));
224 Class = In.slice(In.find('[') + 1, In.find('('));
225 Category = In.slice(In.find('[') + 1, In.find(' '));
229 static StringRef getObjCMethodName(StringRef In) {
230 return In.slice(In.find(' ') + 1, In.find(']'));
233 // Add the various names to the Dwarf accelerator table names.
234 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
236 if (!SP.isDefinition()) return;
238 TheCU->addAccelName(SP.getName(), Die);
240 // If the linkage name is different than the name, go ahead and output
241 // that as well into the name table.
242 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
243 TheCU->addAccelName(SP.getLinkageName(), Die);
245 // If this is an Objective-C selector name add it to the ObjC accelerator
247 if (isObjCClass(SP.getName())) {
248 StringRef Class, Category;
249 getObjCClassCategory(SP.getName(), Class, Category);
250 TheCU->addAccelObjC(Class, Die);
252 TheCU->addAccelObjC(Category, Die);
253 // Also add the base method name to the name table.
254 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
258 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
259 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
260 /// If there are global variables in this scope then create and insert
261 /// DIEs for these variables.
262 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
263 const MDNode *SPNode) {
264 DIE *SPDie = SPCU->getDIE(SPNode);
266 assert(SPDie && "Unable to find subprogram DIE!");
267 DISubprogram SP(SPNode);
269 DISubprogram SPDecl = SP.getFunctionDeclaration();
270 if (!SPDecl.isSubprogram()) {
271 // There is not any need to generate specification DIE for a function
272 // defined at compile unit level. If a function is defined inside another
273 // function then gdb prefers the definition at top level and but does not
274 // expect specification DIE in parent function. So avoid creating
275 // specification DIE for a function defined inside a function.
276 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
277 !SP.getContext().isFile() &&
278 !isSubprogramContext(SP.getContext())) {
279 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
282 DICompositeType SPTy = SP.getType();
283 DIArray Args = SPTy.getTypeArray();
284 unsigned SPTag = SPTy.getTag();
285 if (SPTag == dwarf::DW_TAG_subroutine_type)
286 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
287 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
288 DIType ATy = DIType(DIType(Args.getElement(i)));
289 SPCU->addType(Arg, ATy);
290 if (ATy.isArtificial())
291 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
292 SPDie->addChild(Arg);
294 DIE *SPDeclDie = SPDie;
295 SPDie = new DIE(dwarf::DW_TAG_subprogram);
296 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
301 // Pick up abstract subprogram DIE.
302 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
303 SPDie = new DIE(dwarf::DW_TAG_subprogram);
304 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
305 dwarf::DW_FORM_ref4, AbsSPDIE);
309 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
310 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
311 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
312 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
313 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
314 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
315 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
317 // Add name to the name table, we do this here because we're guaranteed
318 // to have concrete versions of our DW_TAG_subprogram nodes.
319 addSubprogramNames(SPCU, SP, SPDie);
324 /// constructLexicalScope - Construct new DW_TAG_lexical_block
325 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
326 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
327 LexicalScope *Scope) {
328 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
329 if (Scope->isAbstractScope())
332 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
336 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
337 if (Ranges.size() > 1) {
338 // .debug_range section has not been laid out yet. Emit offset in
339 // .debug_range as a uint, size 4, for now. emitDIE will handle
340 // DW_AT_ranges appropriately.
341 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
342 DebugRangeSymbols.size()
343 * Asm->getTargetData().getPointerSize());
344 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
345 RE = Ranges.end(); RI != RE; ++RI) {
346 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
347 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
349 DebugRangeSymbols.push_back(NULL);
350 DebugRangeSymbols.push_back(NULL);
354 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
355 const MCSymbol *End = getLabelAfterInsn(RI->second);
357 if (End == 0) return 0;
359 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
360 assert(End->isDefined() && "Invalid end label for an inlined scope!");
362 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
363 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
368 /// constructInlinedScopeDIE - This scope represents inlined body of
369 /// a function. Construct DIE to represent this concrete inlined copy
371 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
372 LexicalScope *Scope) {
373 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
374 assert(Ranges.empty() == false &&
375 "LexicalScope does not have instruction markers!");
377 if (!Scope->getScopeNode())
379 DIScope DS(Scope->getScopeNode());
380 DISubprogram InlinedSP = getDISubprogram(DS);
381 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
383 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
387 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
388 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
389 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
391 if (StartLabel == 0 || EndLabel == 0) {
392 assert(0 && "Unexpected Start and End labels for a inlined scope!");
395 assert(StartLabel->isDefined() &&
396 "Invalid starting label for an inlined scope!");
397 assert(EndLabel->isDefined() &&
398 "Invalid end label for an inlined scope!");
400 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
401 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
402 dwarf::DW_FORM_ref4, OriginDIE);
404 if (Ranges.size() > 1) {
405 // .debug_range section has not been laid out yet. Emit offset in
406 // .debug_range as a uint, size 4, for now. emitDIE will handle
407 // DW_AT_ranges appropriately.
408 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
409 DebugRangeSymbols.size()
410 * Asm->getTargetData().getPointerSize());
411 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
412 RE = Ranges.end(); RI != RE; ++RI) {
413 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
414 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
416 DebugRangeSymbols.push_back(NULL);
417 DebugRangeSymbols.push_back(NULL);
419 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
421 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
425 InlinedSubprogramDIEs.insert(OriginDIE);
427 // Track the start label for this inlined function.
428 //.debug_inlined section specification does not clearly state how
429 // to emit inlined scope that is split into multiple instruction ranges.
430 // For now, use first instruction range and emit low_pc/high_pc pair and
431 // corresponding .debug_inlined section entry for this pair.
432 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
433 I = InlineInfo.find(InlinedSP);
435 if (I == InlineInfo.end()) {
436 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
437 InlinedSPNodes.push_back(InlinedSP);
439 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
441 DILocation DL(Scope->getInlinedAt());
442 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
443 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
445 // Add name to the name table, we do this here because we're guaranteed
446 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
447 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
454 /// constructScopeDIE - Construct a DIE for this scope.
455 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
456 if (!Scope || !Scope->getScopeNode())
459 SmallVector<DIE *, 8> Children;
461 // Collect arguments for current function.
462 if (LScopes.isCurrentFunctionScope(Scope))
463 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
464 if (DbgVariable *ArgDV = CurrentFnArguments[i])
466 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
467 Children.push_back(Arg);
469 // Collect lexical scope children first.
470 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
471 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
473 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
474 Children.push_back(Variable);
475 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
476 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
477 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
478 Children.push_back(Nested);
479 DIScope DS(Scope->getScopeNode());
480 DIE *ScopeDIE = NULL;
481 if (Scope->getInlinedAt())
482 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
483 else if (DS.isSubprogram()) {
484 ProcessedSPNodes.insert(DS);
485 if (Scope->isAbstractScope()) {
486 ScopeDIE = TheCU->getDIE(DS);
487 // Note down abstract DIE.
489 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
492 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
495 // There is no need to emit empty lexical block DIE.
496 if (Children.empty())
498 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
501 if (!ScopeDIE) return NULL;
504 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
505 E = Children.end(); I != E; ++I)
506 ScopeDIE->addChild(*I);
508 if (DS.isSubprogram())
509 TheCU->addPubTypes(DISubprogram(DS));
514 /// GetOrCreateSourceID - Look up the source id with the given directory and
515 /// source file names. If none currently exists, create a new id and insert it
516 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
518 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
520 // If FE did not provide a file name, then assume stdin.
521 if (FileName.empty())
522 return GetOrCreateSourceID("<stdin>", StringRef());
524 // TODO: this might not belong here. See if we can factor this better.
525 if (DirName == CompilationDir)
528 unsigned SrcId = SourceIdMap.size()+1;
529 std::pair<std::string, std::string> SourceName =
530 std::make_pair(FileName, DirName);
531 std::pair<std::pair<std::string, std::string>, unsigned> Entry =
532 make_pair(SourceName, SrcId);
534 std::map<std::pair<std::string, std::string>, unsigned>::iterator I;
536 tie(I, NewlyInserted) = SourceIdMap.insert(Entry);
540 // Print out a .file directive to specify files for .loc directives.
541 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.first.second,
547 /// constructCompileUnit - Create new CompileUnit for the given
548 /// metadata node with tag DW_TAG_compile_unit.
549 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
550 DICompileUnit DIUnit(N);
551 StringRef FN = DIUnit.getFilename();
552 CompilationDir = DIUnit.getDirectory();
553 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
555 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
556 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
557 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
558 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
559 DIUnit.getLanguage());
560 NewCU->addString(Die, dwarf::DW_AT_name, FN);
561 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
562 // simplifies debug range entries.
563 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
564 // DW_AT_stmt_list is a offset of line number information for this
565 // compile unit in debug_line section.
566 if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
567 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
568 Asm->GetTempSymbol("section_line"));
570 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
572 if (!CompilationDir.empty())
573 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
574 if (DIUnit.isOptimized())
575 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
577 StringRef Flags = DIUnit.getFlags();
579 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
581 if (unsigned RVer = DIUnit.getRunTimeVersion())
582 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
583 dwarf::DW_FORM_data1, RVer);
587 CUMap.insert(std::make_pair(N, NewCU));
591 /// construct SubprogramDIE - Construct subprogram DIE.
592 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
594 CompileUnit *&CURef = SPMap[N];
600 if (!SP.isDefinition())
601 // This is a method declaration which will be handled while constructing
605 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
608 TheCU->insertDIE(N, SubprogramDie);
610 // Add to context owner.
611 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
616 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
617 /// as llvm.dbg.enum and llvm.dbg.ty
618 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
619 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
620 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
621 const MDNode *N = NMD->getOperand(i);
622 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
623 constructSubprogramDIE(CU, N);
626 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
627 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
628 const MDNode *N = NMD->getOperand(i);
629 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
630 CU->createGlobalVariableDIE(N);
633 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
634 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
635 DIType Ty(NMD->getOperand(i));
636 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
637 CU->getOrCreateTypeDIE(Ty);
640 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
641 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
642 DIType Ty(NMD->getOperand(i));
643 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
644 CU->getOrCreateTypeDIE(Ty);
648 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
649 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
650 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
651 DebugInfoFinder DbgFinder;
652 DbgFinder.processModule(*M);
654 bool HasDebugInfo = false;
655 // Scan all the compile-units to see if there are any marked as the main
656 // unit. If not, we do not generate debug info.
657 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
658 E = DbgFinder.compile_unit_end(); I != E; ++I) {
659 if (DICompileUnit(*I).isMain()) {
664 if (!HasDebugInfo) return false;
666 // Create all the compile unit DIEs.
667 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
668 E = DbgFinder.compile_unit_end(); I != E; ++I)
669 constructCompileUnit(*I);
671 // Create DIEs for each global variable.
672 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
673 E = DbgFinder.global_variable_end(); I != E; ++I) {
674 const MDNode *N = *I;
675 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
676 CU->createGlobalVariableDIE(N);
679 // Create DIEs for each subprogram.
680 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
681 E = DbgFinder.subprogram_end(); I != E; ++I) {
682 const MDNode *N = *I;
683 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
684 constructSubprogramDIE(CU, N);
690 /// beginModule - Emit all Dwarf sections that should come prior to the
691 /// content. Create global DIEs and emit initial debug info sections.
692 /// This is invoked by the target AsmPrinter.
693 void DwarfDebug::beginModule(Module *M) {
694 if (DisableDebugInfoPrinting)
697 // If module has named metadata anchors then use them, otherwise scan the
698 // module using debug info finder to collect debug info.
699 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
701 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
702 DICompileUnit CUNode(CU_Nodes->getOperand(i));
703 CompileUnit *CU = constructCompileUnit(CUNode);
704 DIArray GVs = CUNode.getGlobalVariables();
705 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
706 CU->createGlobalVariableDIE(GVs.getElement(i));
707 DIArray SPs = CUNode.getSubprograms();
708 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
709 constructSubprogramDIE(CU, SPs.getElement(i));
710 DIArray EnumTypes = CUNode.getEnumTypes();
711 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
712 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
713 DIArray RetainedTypes = CUNode.getRetainedTypes();
714 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
715 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
717 } else if (!collectLegacyDebugInfo(M))
720 collectInfoFromNamedMDNodes(M);
722 // Tell MMI that we have debug info.
723 MMI->setDebugInfoAvailability(true);
725 // Emit initial sections.
728 // Prime section data.
729 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
732 /// endModule - Emit all Dwarf sections that should come after the content.
734 void DwarfDebug::endModule() {
735 if (!FirstCU) return;
736 const Module *M = MMI->getModule();
737 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
739 // Collect info for variables that were optimized out.
740 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
741 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
742 DICompileUnit TheCU(CU_Nodes->getOperand(i));
743 DIArray Subprograms = TheCU.getSubprograms();
744 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
745 DISubprogram SP(Subprograms.getElement(i));
746 if (ProcessedSPNodes.count(SP) != 0) continue;
747 if (!SP.Verify()) continue;
748 if (!SP.isDefinition()) continue;
749 DIArray Variables = SP.getVariables();
750 if (Variables.getNumElements() == 0) continue;
752 LexicalScope *Scope =
753 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
754 DeadFnScopeMap[SP] = Scope;
756 // Construct subprogram DIE and add variables DIEs.
757 CompileUnit *SPCU = CUMap.lookup(TheCU);
758 assert(SPCU && "Unable to find Compile Unit!");
759 constructSubprogramDIE(SPCU, SP);
760 DIE *ScopeDIE = SPCU->getDIE(SP);
761 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
762 DIVariable DV(Variables.getElement(vi));
763 if (!DV.Verify()) continue;
764 DbgVariable *NewVar = new DbgVariable(DV, NULL);
765 if (DIE *VariableDIE =
766 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
767 ScopeDIE->addChild(VariableDIE);
773 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
774 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
775 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
777 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
779 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
780 AE = AbstractSPDies.end(); AI != AE; ++AI) {
781 DIE *ISP = AI->second;
782 if (InlinedSubprogramDIEs.count(ISP))
784 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
787 // Emit DW_AT_containing_type attribute to connect types with their
788 // vtable holding type.
789 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
790 CUE = CUMap.end(); CUI != CUE; ++CUI) {
791 CompileUnit *TheCU = CUI->second;
792 TheCU->constructContainingTypeDIEs();
795 // Standard sections final addresses.
796 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
797 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
798 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
799 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
801 // End text sections.
802 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
803 Asm->OutStreamer.SwitchSection(SectionMap[i]);
804 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
807 // Compute DIE offsets and sizes.
808 computeSizeAndOffsets();
810 // Emit all the DIEs into a debug info section
813 // Corresponding abbreviations into a abbrev section.
816 // Emit info into a dwarf accelerator table sections.
817 if (DwarfAccelTables) {
820 emitAccelNamespaces();
824 // Emit info into a debug pubtypes section.
827 // Emit info into a debug loc section.
830 // Emit info into a debug aranges section.
833 // Emit info into a debug ranges section.
836 // Emit info into a debug macinfo section.
840 emitDebugInlineInfo();
842 // Emit info into a debug str section.
846 DeleteContainerSeconds(DeadFnScopeMap);
848 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
849 E = CUMap.end(); I != E; ++I)
851 FirstCU = NULL; // Reset for the next Module, if any.
854 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
855 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
857 LLVMContext &Ctx = DV->getContext();
858 // More then one inlined variable corresponds to one abstract variable.
859 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
860 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
862 return AbsDbgVariable;
864 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
868 AbsDbgVariable = new DbgVariable(Var, NULL);
869 addScopeVariable(Scope, AbsDbgVariable);
870 AbstractVariables[Var] = AbsDbgVariable;
871 return AbsDbgVariable;
874 /// addCurrentFnArgument - If Var is a current function argument then add
875 /// it to CurrentFnArguments list.
876 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
877 DbgVariable *Var, LexicalScope *Scope) {
878 if (!LScopes.isCurrentFunctionScope(Scope))
880 DIVariable DV = Var->getVariable();
881 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
883 unsigned ArgNo = DV.getArgNumber();
887 size_t Size = CurrentFnArguments.size();
889 CurrentFnArguments.resize(MF->getFunction()->arg_size());
890 // llvm::Function argument size is not good indicator of how many
891 // arguments does the function have at source level.
893 CurrentFnArguments.resize(ArgNo * 2);
894 CurrentFnArguments[ArgNo - 1] = Var;
898 /// collectVariableInfoFromMMITable - Collect variable information from
899 /// side table maintained by MMI.
901 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
902 SmallPtrSet<const MDNode *, 16> &Processed) {
903 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
904 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
905 VE = VMap.end(); VI != VE; ++VI) {
906 const MDNode *Var = VI->first;
908 Processed.insert(Var);
910 const std::pair<unsigned, DebugLoc> &VP = VI->second;
912 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
914 // If variable scope is not found then skip this variable.
918 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
919 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
920 RegVar->setFrameIndex(VP.first);
921 if (!addCurrentFnArgument(MF, RegVar, Scope))
922 addScopeVariable(Scope, RegVar);
924 AbsDbgVariable->setFrameIndex(VP.first);
928 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
929 /// DBG_VALUE instruction, is in a defined reg.
930 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
931 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
932 return MI->getNumOperands() == 3 &&
933 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
934 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
937 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
939 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
940 const MCSymbol *FLabel,
941 const MCSymbol *SLabel,
942 const MachineInstr *MI) {
943 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
945 if (MI->getNumOperands() != 3) {
946 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
947 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
949 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
950 MachineLocation MLoc;
951 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
952 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
954 if (MI->getOperand(0).isImm())
955 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
956 if (MI->getOperand(0).isFPImm())
957 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
958 if (MI->getOperand(0).isCImm())
959 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
961 assert(0 && "Unexpected 3 operand DBG_VALUE instruction!");
962 return DotDebugLocEntry();
965 /// collectVariableInfo - Find variables for each lexical scope.
967 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
968 SmallPtrSet<const MDNode *, 16> &Processed) {
970 /// collection info from MMI table.
971 collectVariableInfoFromMMITable(MF, Processed);
973 for (SmallVectorImpl<const MDNode*>::const_iterator
974 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
976 const MDNode *Var = *UVI;
977 if (Processed.count(Var))
980 // History contains relevant DBG_VALUE instructions for Var and instructions
982 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
985 const MachineInstr *MInsn = History.front();
988 LexicalScope *Scope = NULL;
989 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
990 DISubprogram(DV.getContext()).describes(MF->getFunction()))
991 Scope = LScopes.getCurrentFunctionScope();
993 if (DV.getVersion() <= LLVMDebugVersion9)
994 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
996 if (MDNode *IA = DV.getInlinedAt())
997 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
999 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1002 // If variable scope is not found then skip this variable.
1006 Processed.insert(DV);
1007 assert(MInsn->isDebugValue() && "History must begin with debug value");
1008 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1009 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1010 if (!addCurrentFnArgument(MF, RegVar, Scope))
1011 addScopeVariable(Scope, RegVar);
1013 AbsVar->setMInsn(MInsn);
1015 // Simple ranges that are fully coalesced.
1016 if (History.size() <= 1 || (History.size() == 2 &&
1017 MInsn->isIdenticalTo(History.back()))) {
1018 RegVar->setMInsn(MInsn);
1022 // handle multiple DBG_VALUE instructions describing one variable.
1023 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1025 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1026 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1027 const MachineInstr *Begin = *HI;
1028 assert(Begin->isDebugValue() && "Invalid History entry");
1030 // Check if DBG_VALUE is truncating a range.
1031 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1032 && !Begin->getOperand(0).getReg())
1035 // Compute the range for a register location.
1036 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1037 const MCSymbol *SLabel = 0;
1040 // If Begin is the last instruction in History then its value is valid
1041 // until the end of the function.
1042 SLabel = FunctionEndSym;
1044 const MachineInstr *End = HI[1];
1045 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1046 << "\t" << *Begin << "\t" << *End << "\n");
1047 if (End->isDebugValue())
1048 SLabel = getLabelBeforeInsn(End);
1050 // End is a normal instruction clobbering the range.
1051 SLabel = getLabelAfterInsn(End);
1052 assert(SLabel && "Forgot label after clobber instruction");
1057 // The value is valid until the next DBG_VALUE or clobber.
1058 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1060 DotDebugLocEntries.push_back(DotDebugLocEntry());
1063 // Collect info for variables that were optimized out.
1064 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1065 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1066 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1067 DIVariable DV(Variables.getElement(i));
1068 if (!DV || !DV.Verify() || !Processed.insert(DV))
1070 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1071 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1075 /// getLabelBeforeInsn - Return Label preceding the instruction.
1076 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1077 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1078 assert(Label && "Didn't insert label before instruction");
1082 /// getLabelAfterInsn - Return Label immediately following the instruction.
1083 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1084 return LabelsAfterInsn.lookup(MI);
1087 /// beginInstruction - Process beginning of an instruction.
1088 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1089 // Check if source location changes, but ignore DBG_VALUE locations.
1090 if (!MI->isDebugValue()) {
1091 DebugLoc DL = MI->getDebugLoc();
1092 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1093 unsigned Flags = DWARF2_FLAG_IS_STMT;
1095 if (DL == PrologEndLoc) {
1096 Flags |= DWARF2_FLAG_PROLOGUE_END;
1097 PrologEndLoc = DebugLoc();
1099 if (!DL.isUnknown()) {
1100 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1101 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1103 recordSourceLine(0, 0, 0, 0);
1107 // Insert labels where requested.
1108 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1109 LabelsBeforeInsn.find(MI);
1112 if (I == LabelsBeforeInsn.end())
1115 // Label already assigned.
1120 PrevLabel = MMI->getContext().CreateTempSymbol();
1121 Asm->OutStreamer.EmitLabel(PrevLabel);
1123 I->second = PrevLabel;
1126 /// endInstruction - Process end of an instruction.
1127 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1128 // Don't create a new label after DBG_VALUE instructions.
1129 // They don't generate code.
1130 if (!MI->isDebugValue())
1133 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1134 LabelsAfterInsn.find(MI);
1137 if (I == LabelsAfterInsn.end())
1140 // Label already assigned.
1144 // We need a label after this instruction.
1146 PrevLabel = MMI->getContext().CreateTempSymbol();
1147 Asm->OutStreamer.EmitLabel(PrevLabel);
1149 I->second = PrevLabel;
1152 /// identifyScopeMarkers() -
1153 /// Each LexicalScope has first instruction and last instruction to mark
1154 /// beginning and end of a scope respectively. Create an inverse map that list
1155 /// scopes starts (and ends) with an instruction. One instruction may start (or
1156 /// end) multiple scopes. Ignore scopes that are not reachable.
1157 void DwarfDebug::identifyScopeMarkers() {
1158 SmallVector<LexicalScope *, 4> WorkList;
1159 WorkList.push_back(LScopes.getCurrentFunctionScope());
1160 while (!WorkList.empty()) {
1161 LexicalScope *S = WorkList.pop_back_val();
1163 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1164 if (!Children.empty())
1165 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1166 SE = Children.end(); SI != SE; ++SI)
1167 WorkList.push_back(*SI);
1169 if (S->isAbstractScope())
1172 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1175 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1176 RE = Ranges.end(); RI != RE; ++RI) {
1177 assert(RI->first && "InsnRange does not have first instruction!");
1178 assert(RI->second && "InsnRange does not have second instruction!");
1179 requestLabelBeforeInsn(RI->first);
1180 requestLabelAfterInsn(RI->second);
1185 /// getScopeNode - Get MDNode for DebugLoc's scope.
1186 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1187 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1188 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1189 return DL.getScope(Ctx);
1192 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1193 /// line number info for the function.
1194 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1195 const MDNode *Scope = getScopeNode(DL, Ctx);
1196 DISubprogram SP = getDISubprogram(Scope);
1198 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1202 /// beginFunction - Gather pre-function debug information. Assumes being
1203 /// emitted immediately after the function entry point.
1204 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1205 if (!MMI->hasDebugInfo()) return;
1206 LScopes.initialize(*MF);
1207 if (LScopes.empty()) return;
1208 identifyScopeMarkers();
1210 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1211 Asm->getFunctionNumber());
1212 // Assumes in correct section after the entry point.
1213 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1215 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1217 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1218 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1219 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1221 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1223 bool AtBlockEntry = true;
1224 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1226 const MachineInstr *MI = II;
1228 if (MI->isDebugValue()) {
1229 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1231 // Keep track of user variables.
1233 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1235 // Variable is in a register, we need to check for clobbers.
1236 if (isDbgValueInDefinedReg(MI))
1237 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1239 // Check the history of this variable.
1240 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1241 if (History.empty()) {
1242 UserVariables.push_back(Var);
1243 // The first mention of a function argument gets the FunctionBeginSym
1244 // label, so arguments are visible when breaking at function entry.
1246 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1247 DISubprogram(getDISubprogram(DV.getContext()))
1248 .describes(MF->getFunction()))
1249 LabelsBeforeInsn[MI] = FunctionBeginSym;
1251 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1252 const MachineInstr *Prev = History.back();
1253 if (Prev->isDebugValue()) {
1254 // Coalesce identical entries at the end of History.
1255 if (History.size() >= 2 &&
1256 Prev->isIdenticalTo(History[History.size() - 2])) {
1257 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1259 << "\t" << *History[History.size() - 2] << "\n");
1263 // Terminate old register assignments that don't reach MI;
1264 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1265 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1266 isDbgValueInDefinedReg(Prev)) {
1267 // Previous register assignment needs to terminate at the end of
1269 MachineBasicBlock::const_iterator LastMI =
1270 PrevMBB->getLastNonDebugInstr();
1271 if (LastMI == PrevMBB->end()) {
1272 // Drop DBG_VALUE for empty range.
1273 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1274 << "\t" << *Prev << "\n");
1278 // Terminate after LastMI.
1279 History.push_back(LastMI);
1284 History.push_back(MI);
1286 // Not a DBG_VALUE instruction.
1288 AtBlockEntry = false;
1290 // First known non DBG_VALUE location marks beginning of function
1292 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1293 PrologEndLoc = MI->getDebugLoc();
1295 // Check if the instruction clobbers any registers with debug vars.
1296 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1297 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1298 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1300 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1301 unsigned Reg = *AI; ++AI) {
1302 const MDNode *Var = LiveUserVar[Reg];
1305 // Reg is now clobbered.
1306 LiveUserVar[Reg] = 0;
1308 // Was MD last defined by a DBG_VALUE referring to Reg?
1309 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1310 if (HistI == DbgValues.end())
1312 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1313 if (History.empty())
1315 const MachineInstr *Prev = History.back();
1316 // Sanity-check: Register assignments are terminated at the end of
1318 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1320 // Is the variable still in Reg?
1321 if (!isDbgValueInDefinedReg(Prev) ||
1322 Prev->getOperand(0).getReg() != Reg)
1324 // Var is clobbered. Make sure the next instruction gets a label.
1325 History.push_back(MI);
1332 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1334 SmallVectorImpl<const MachineInstr*> &History = I->second;
1335 if (History.empty())
1338 // Make sure the final register assignments are terminated.
1339 const MachineInstr *Prev = History.back();
1340 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1341 const MachineBasicBlock *PrevMBB = Prev->getParent();
1342 MachineBasicBlock::const_iterator LastMI =
1343 PrevMBB->getLastNonDebugInstr();
1344 if (LastMI == PrevMBB->end())
1345 // Drop DBG_VALUE for empty range.
1348 // Terminate after LastMI.
1349 History.push_back(LastMI);
1352 // Request labels for the full history.
1353 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1354 const MachineInstr *MI = History[i];
1355 if (MI->isDebugValue())
1356 requestLabelBeforeInsn(MI);
1358 requestLabelAfterInsn(MI);
1362 PrevInstLoc = DebugLoc();
1363 PrevLabel = FunctionBeginSym;
1365 // Record beginning of function.
1366 if (!PrologEndLoc.isUnknown()) {
1367 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1368 MF->getFunction()->getContext());
1369 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1370 FnStartDL.getScope(MF->getFunction()->getContext()),
1371 DWARF2_FLAG_IS_STMT);
1375 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1376 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1377 ScopeVariables[LS].push_back(Var);
1378 // Vars.push_back(Var);
1381 /// endFunction - Gather and emit post-function debug information.
1383 void DwarfDebug::endFunction(const MachineFunction *MF) {
1384 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1386 // Define end label for subprogram.
1387 FunctionEndSym = Asm->GetTempSymbol("func_end",
1388 Asm->getFunctionNumber());
1389 // Assumes in correct section after the entry point.
1390 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1392 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1393 collectVariableInfo(MF, ProcessedVars);
1395 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1396 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1397 assert(TheCU && "Unable to find compile unit!");
1399 // Construct abstract scopes.
1400 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1401 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1402 LexicalScope *AScope = AList[i];
1403 DISubprogram SP(AScope->getScopeNode());
1405 // Collect info for variables that were optimized out.
1406 DIArray Variables = SP.getVariables();
1407 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1408 DIVariable DV(Variables.getElement(i));
1409 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1411 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1412 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1415 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1416 constructScopeDIE(TheCU, AScope);
1419 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1421 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1422 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1423 dwarf::DW_FORM_flag, 1);
1425 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1426 MMI->getFrameMoves()));
1429 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1430 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1431 DeleteContainerPointers(I->second);
1432 ScopeVariables.clear();
1433 DeleteContainerPointers(CurrentFnArguments);
1434 UserVariables.clear();
1436 AbstractVariables.clear();
1437 LabelsBeforeInsn.clear();
1438 LabelsAfterInsn.clear();
1442 /// recordSourceLine - Register a source line with debug info. Returns the
1443 /// unique label that was emitted and which provides correspondence to
1444 /// the source line list.
1445 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1451 DIDescriptor Scope(S);
1453 if (Scope.isCompileUnit()) {
1454 DICompileUnit CU(S);
1455 Fn = CU.getFilename();
1456 Dir = CU.getDirectory();
1457 } else if (Scope.isFile()) {
1459 Fn = F.getFilename();
1460 Dir = F.getDirectory();
1461 } else if (Scope.isSubprogram()) {
1463 Fn = SP.getFilename();
1464 Dir = SP.getDirectory();
1465 } else if (Scope.isLexicalBlockFile()) {
1466 DILexicalBlockFile DBF(S);
1467 Fn = DBF.getFilename();
1468 Dir = DBF.getDirectory();
1469 } else if (Scope.isLexicalBlock()) {
1470 DILexicalBlock DB(S);
1471 Fn = DB.getFilename();
1472 Dir = DB.getDirectory();
1474 assert(0 && "Unexpected scope info");
1476 Src = GetOrCreateSourceID(Fn, Dir);
1478 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1481 //===----------------------------------------------------------------------===//
1483 //===----------------------------------------------------------------------===//
1485 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1488 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1489 // Get the children.
1490 const std::vector<DIE *> &Children = Die->getChildren();
1492 // If not last sibling and has children then add sibling offset attribute.
1493 if (!Last && !Children.empty())
1494 Die->addSiblingOffset(DIEValueAllocator);
1496 // Record the abbreviation.
1497 assignAbbrevNumber(Die->getAbbrev());
1499 // Get the abbreviation for this DIE.
1500 unsigned AbbrevNumber = Die->getAbbrevNumber();
1501 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1504 Die->setOffset(Offset);
1506 // Start the size with the size of abbreviation code.
1507 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1509 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1510 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1512 // Size the DIE attribute values.
1513 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1514 // Size attribute value.
1515 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1517 // Size the DIE children if any.
1518 if (!Children.empty()) {
1519 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1520 "Children flag not set");
1522 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1523 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1525 // End of children marker.
1526 Offset += sizeof(int8_t);
1529 Die->setSize(Offset - Die->getOffset());
1533 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1535 void DwarfDebug::computeSizeAndOffsets() {
1536 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1537 E = CUMap.end(); I != E; ++I) {
1538 // Compute size of compile unit header.
1540 sizeof(int32_t) + // Length of Compilation Unit Info
1541 sizeof(int16_t) + // DWARF version number
1542 sizeof(int32_t) + // Offset Into Abbrev. Section
1543 sizeof(int8_t); // Pointer Size (in bytes)
1544 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1548 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1549 /// the start of each one.
1550 void DwarfDebug::EmitSectionLabels() {
1551 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1553 // Dwarf sections base addresses.
1554 DwarfInfoSectionSym =
1555 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1556 DwarfAbbrevSectionSym =
1557 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1558 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1560 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1561 EmitSectionSym(Asm, MacroInfo);
1563 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1564 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1565 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1566 DwarfStrSectionSym =
1567 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1568 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1571 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1572 "section_debug_loc");
1574 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1575 EmitSectionSym(Asm, TLOF.getDataSection());
1578 /// emitDIE - Recursively emits a debug information entry.
1580 void DwarfDebug::emitDIE(DIE *Die) {
1581 // Get the abbreviation for this DIE.
1582 unsigned AbbrevNumber = Die->getAbbrevNumber();
1583 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1585 // Emit the code (index) for the abbreviation.
1586 if (Asm->isVerbose())
1587 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1588 Twine::utohexstr(Die->getOffset()) + ":0x" +
1589 Twine::utohexstr(Die->getSize()) + " " +
1590 dwarf::TagString(Abbrev->getTag()));
1591 Asm->EmitULEB128(AbbrevNumber);
1593 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1594 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1596 // Emit the DIE attribute values.
1597 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1598 unsigned Attr = AbbrevData[i].getAttribute();
1599 unsigned Form = AbbrevData[i].getForm();
1600 assert(Form && "Too many attributes for DIE (check abbreviation)");
1602 if (Asm->isVerbose())
1603 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1606 case dwarf::DW_AT_sibling:
1607 Asm->EmitInt32(Die->getSiblingOffset());
1609 case dwarf::DW_AT_abstract_origin: {
1610 DIEEntry *E = cast<DIEEntry>(Values[i]);
1611 DIE *Origin = E->getEntry();
1612 unsigned Addr = Origin->getOffset();
1613 Asm->EmitInt32(Addr);
1616 case dwarf::DW_AT_ranges: {
1617 // DW_AT_range Value encodes offset in debug_range section.
1618 DIEInteger *V = cast<DIEInteger>(Values[i]);
1620 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1621 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1625 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1627 DwarfDebugRangeSectionSym,
1632 case dwarf::DW_AT_location: {
1633 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1634 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1636 Values[i]->EmitValue(Asm, Form);
1639 case dwarf::DW_AT_accessibility: {
1640 if (Asm->isVerbose()) {
1641 DIEInteger *V = cast<DIEInteger>(Values[i]);
1642 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1644 Values[i]->EmitValue(Asm, Form);
1648 // Emit an attribute using the defined form.
1649 Values[i]->EmitValue(Asm, Form);
1654 // Emit the DIE children if any.
1655 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1656 const std::vector<DIE *> &Children = Die->getChildren();
1658 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1659 emitDIE(Children[j]);
1661 if (Asm->isVerbose())
1662 Asm->OutStreamer.AddComment("End Of Children Mark");
1667 /// emitDebugInfo - Emit the debug info section.
1669 void DwarfDebug::emitDebugInfo() {
1670 // Start debug info section.
1671 Asm->OutStreamer.SwitchSection(
1672 Asm->getObjFileLowering().getDwarfInfoSection());
1673 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1674 E = CUMap.end(); I != E; ++I) {
1675 CompileUnit *TheCU = I->second;
1676 DIE *Die = TheCU->getCUDie();
1678 // Emit the compile units header.
1679 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1682 // Emit size of content not including length itself
1683 unsigned ContentSize = Die->getSize() +
1684 sizeof(int16_t) + // DWARF version number
1685 sizeof(int32_t) + // Offset Into Abbrev. Section
1686 sizeof(int8_t); // Pointer Size (in bytes)
1688 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1689 Asm->EmitInt32(ContentSize);
1690 Asm->OutStreamer.AddComment("DWARF version number");
1691 Asm->EmitInt16(dwarf::DWARF_VERSION);
1692 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1693 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1694 DwarfAbbrevSectionSym);
1695 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1696 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1699 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1703 /// emitAbbreviations - Emit the abbreviation section.
1705 void DwarfDebug::emitAbbreviations() const {
1706 // Check to see if it is worth the effort.
1707 if (!Abbreviations.empty()) {
1708 // Start the debug abbrev section.
1709 Asm->OutStreamer.SwitchSection(
1710 Asm->getObjFileLowering().getDwarfAbbrevSection());
1712 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1714 // For each abbrevation.
1715 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1716 // Get abbreviation data
1717 const DIEAbbrev *Abbrev = Abbreviations[i];
1719 // Emit the abbrevations code (base 1 index.)
1720 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1722 // Emit the abbreviations data.
1726 // Mark end of abbreviations.
1727 Asm->EmitULEB128(0, "EOM(3)");
1729 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1733 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1734 /// the line matrix.
1736 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1737 // Define last address of section.
1738 Asm->OutStreamer.AddComment("Extended Op");
1741 Asm->OutStreamer.AddComment("Op size");
1742 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1743 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1744 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1746 Asm->OutStreamer.AddComment("Section end label");
1748 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1749 Asm->getTargetData().getPointerSize(),
1752 // Mark end of matrix.
1753 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1759 /// emitAccelNames - Emit visible names into a hashed accelerator table
1761 void DwarfDebug::emitAccelNames() {
1762 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1763 dwarf::DW_FORM_data4));
1764 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1765 E = CUMap.end(); I != E; ++I) {
1766 CompileUnit *TheCU = I->second;
1767 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1768 for (StringMap<std::vector<DIE*> >::const_iterator
1769 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1770 const char *Name = GI->getKeyData();
1771 std::vector<DIE *> Entities = GI->second;
1772 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1773 DE = Entities.end(); DI != DE; ++DI)
1774 AT.AddName(Name, (*DI));
1778 AT.FinalizeTable(Asm, "Names");
1779 Asm->OutStreamer.SwitchSection(
1780 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1781 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1782 Asm->OutStreamer.EmitLabel(SectionBegin);
1784 // Emit the full data.
1785 AT.Emit(Asm, SectionBegin, this);
1788 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1789 /// accelerator table section.
1790 void DwarfDebug::emitAccelObjC() {
1791 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1792 dwarf::DW_FORM_data4));
1793 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1794 E = CUMap.end(); I != E; ++I) {
1795 CompileUnit *TheCU = I->second;
1796 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1797 for (StringMap<std::vector<DIE*> >::const_iterator
1798 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1799 const char *Name = GI->getKeyData();
1800 std::vector<DIE *> Entities = GI->second;
1801 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1802 DE = Entities.end(); DI != DE; ++DI)
1803 AT.AddName(Name, (*DI));
1807 AT.FinalizeTable(Asm, "ObjC");
1808 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1809 .getDwarfAccelObjCSection());
1810 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1811 Asm->OutStreamer.EmitLabel(SectionBegin);
1813 // Emit the full data.
1814 AT.Emit(Asm, SectionBegin, this);
1817 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1819 void DwarfDebug::emitAccelNamespaces() {
1820 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1821 dwarf::DW_FORM_data4));
1822 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1823 E = CUMap.end(); I != E; ++I) {
1824 CompileUnit *TheCU = I->second;
1825 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1826 for (StringMap<std::vector<DIE*> >::const_iterator
1827 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1828 const char *Name = GI->getKeyData();
1829 std::vector<DIE *> Entities = GI->second;
1830 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1831 DE = Entities.end(); DI != DE; ++DI)
1832 AT.AddName(Name, (*DI));
1836 AT.FinalizeTable(Asm, "namespac");
1837 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1838 .getDwarfAccelNamespaceSection());
1839 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1840 Asm->OutStreamer.EmitLabel(SectionBegin);
1842 // Emit the full data.
1843 AT.Emit(Asm, SectionBegin, this);
1846 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1847 void DwarfDebug::emitAccelTypes() {
1848 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1849 dwarf::DW_FORM_data4));
1850 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1851 E = CUMap.end(); I != E; ++I) {
1852 CompileUnit *TheCU = I->second;
1853 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelTypes();
1854 for (StringMap<std::vector<DIE*> >::const_iterator
1855 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1856 const char *Name = GI->getKeyData();
1857 std::vector<DIE *> Entities = GI->second;
1858 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1859 DE= Entities.end(); DI !=DE; ++DI)
1860 AT.AddName(Name, (*DI));
1864 AT.FinalizeTable(Asm, "types");
1865 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1866 .getDwarfAccelTypesSection());
1867 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1868 Asm->OutStreamer.EmitLabel(SectionBegin);
1870 // Emit the full data.
1871 AT.Emit(Asm, SectionBegin, this);
1874 void DwarfDebug::emitDebugPubTypes() {
1875 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1876 E = CUMap.end(); I != E; ++I) {
1877 CompileUnit *TheCU = I->second;
1878 // Start the dwarf pubtypes section.
1879 Asm->OutStreamer.SwitchSection(
1880 Asm->getObjFileLowering().getDwarfPubTypesSection());
1881 Asm->OutStreamer.AddComment("Length of Public Types Info");
1882 Asm->EmitLabelDifference(
1883 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1884 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1886 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1889 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1890 Asm->EmitInt16(dwarf::DWARF_VERSION);
1892 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1893 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1894 DwarfInfoSectionSym);
1896 Asm->OutStreamer.AddComment("Compilation Unit Length");
1897 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1898 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1901 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1902 for (StringMap<DIE*>::const_iterator
1903 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1904 const char *Name = GI->getKeyData();
1905 DIE *Entity = GI->second;
1907 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1908 Asm->EmitInt32(Entity->getOffset());
1910 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1911 // Emit the name with a terminating null byte.
1912 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1915 Asm->OutStreamer.AddComment("End Mark");
1917 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1922 /// emitDebugStr - Emit visible names into a debug str section.
1924 void DwarfDebug::emitDebugStr() {
1925 // Check to see if it is worth the effort.
1926 if (StringPool.empty()) return;
1928 // Start the dwarf str section.
1929 Asm->OutStreamer.SwitchSection(
1930 Asm->getObjFileLowering().getDwarfStrSection());
1932 // Get all of the string pool entries and put them in an array by their ID so
1933 // we can sort them.
1934 SmallVector<std::pair<unsigned,
1935 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1937 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1938 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1939 Entries.push_back(std::make_pair(I->second.second, &*I));
1941 array_pod_sort(Entries.begin(), Entries.end());
1943 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1944 // Emit a label for reference from debug information entries.
1945 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1947 // Emit the string itself with a terminating null byte.
1948 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1949 Entries[i].second->getKeyLength()+1),
1954 /// emitDebugLoc - Emit visible names into a debug loc section.
1956 void DwarfDebug::emitDebugLoc() {
1957 if (DotDebugLocEntries.empty())
1960 for (SmallVector<DotDebugLocEntry, 4>::iterator
1961 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1963 DotDebugLocEntry &Entry = *I;
1964 if (I + 1 != DotDebugLocEntries.end())
1968 // Start the dwarf loc section.
1969 Asm->OutStreamer.SwitchSection(
1970 Asm->getObjFileLowering().getDwarfLocSection());
1971 unsigned char Size = Asm->getTargetData().getPointerSize();
1972 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1974 for (SmallVector<DotDebugLocEntry, 4>::iterator
1975 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1976 I != E; ++I, ++index) {
1977 DotDebugLocEntry &Entry = *I;
1978 if (Entry.isMerged()) continue;
1979 if (Entry.isEmpty()) {
1980 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1981 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1982 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1984 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1985 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1986 DIVariable DV(Entry.Variable);
1987 Asm->OutStreamer.AddComment("Loc expr size");
1988 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1989 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1990 Asm->EmitLabelDifference(end, begin, 2);
1991 Asm->OutStreamer.EmitLabel(begin);
1992 if (Entry.isInt()) {
1993 DIBasicType BTy(DV.getType());
1995 (BTy.getEncoding() == dwarf::DW_ATE_signed
1996 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1997 Asm->OutStreamer.AddComment("DW_OP_consts");
1998 Asm->EmitInt8(dwarf::DW_OP_consts);
1999 Asm->EmitSLEB128(Entry.getInt());
2001 Asm->OutStreamer.AddComment("DW_OP_constu");
2002 Asm->EmitInt8(dwarf::DW_OP_constu);
2003 Asm->EmitULEB128(Entry.getInt());
2005 } else if (Entry.isLocation()) {
2006 if (!DV.hasComplexAddress())
2008 Asm->EmitDwarfRegOp(Entry.Loc);
2010 // Complex address entry.
2011 unsigned N = DV.getNumAddrElements();
2013 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2014 if (Entry.Loc.getOffset()) {
2016 Asm->EmitDwarfRegOp(Entry.Loc);
2017 Asm->OutStreamer.AddComment("DW_OP_deref");
2018 Asm->EmitInt8(dwarf::DW_OP_deref);
2019 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2020 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2021 Asm->EmitSLEB128(DV.getAddrElement(1));
2023 // If first address element is OpPlus then emit
2024 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2025 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2026 Asm->EmitDwarfRegOp(Loc);
2030 Asm->EmitDwarfRegOp(Entry.Loc);
2033 // Emit remaining complex address elements.
2034 for (; i < N; ++i) {
2035 uint64_t Element = DV.getAddrElement(i);
2036 if (Element == DIBuilder::OpPlus) {
2037 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2038 Asm->EmitULEB128(DV.getAddrElement(++i));
2039 } else if (Element == DIBuilder::OpDeref)
2040 Asm->EmitInt8(dwarf::DW_OP_deref);
2041 else llvm_unreachable("unknown Opcode found in complex address");
2045 // else ... ignore constant fp. There is not any good way to
2046 // to represent them here in dwarf.
2047 Asm->OutStreamer.EmitLabel(end);
2052 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2054 void DwarfDebug::EmitDebugARanges() {
2055 // Start the dwarf aranges section.
2056 Asm->OutStreamer.SwitchSection(
2057 Asm->getObjFileLowering().getDwarfARangesSection());
2060 /// emitDebugRanges - Emit visible names into a debug ranges section.
2062 void DwarfDebug::emitDebugRanges() {
2063 // Start the dwarf ranges section.
2064 Asm->OutStreamer.SwitchSection(
2065 Asm->getObjFileLowering().getDwarfRangesSection());
2066 unsigned char Size = Asm->getTargetData().getPointerSize();
2067 for (SmallVector<const MCSymbol *, 8>::iterator
2068 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2071 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2073 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2077 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2079 void DwarfDebug::emitDebugMacInfo() {
2080 if (const MCSection *LineInfo =
2081 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2082 // Start the dwarf macinfo section.
2083 Asm->OutStreamer.SwitchSection(LineInfo);
2087 /// emitDebugInlineInfo - Emit inline info using following format.
2089 /// 1. length of section
2090 /// 2. Dwarf version number
2091 /// 3. address size.
2093 /// Entries (one "entry" for each function that was inlined):
2095 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2096 /// otherwise offset into __debug_str for regular function name.
2097 /// 2. offset into __debug_str section for regular function name.
2098 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2099 /// instances for the function.
2101 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2102 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2103 /// __debug_info section, and the low_pc is the starting address for the
2104 /// inlining instance.
2105 void DwarfDebug::emitDebugInlineInfo() {
2106 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2112 Asm->OutStreamer.SwitchSection(
2113 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2115 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2116 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2117 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2119 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2121 Asm->OutStreamer.AddComment("Dwarf Version");
2122 Asm->EmitInt16(dwarf::DWARF_VERSION);
2123 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2124 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2126 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2127 E = InlinedSPNodes.end(); I != E; ++I) {
2129 const MDNode *Node = *I;
2130 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2131 = InlineInfo.find(Node);
2132 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2133 DISubprogram SP(Node);
2134 StringRef LName = SP.getLinkageName();
2135 StringRef Name = SP.getName();
2137 Asm->OutStreamer.AddComment("MIPS linkage name");
2138 if (LName.empty()) {
2139 Asm->OutStreamer.EmitBytes(Name, 0);
2140 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2142 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2143 DwarfStrSectionSym);
2145 Asm->OutStreamer.AddComment("Function name");
2146 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2147 Asm->EmitULEB128(Labels.size(), "Inline count");
2149 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2150 LE = Labels.end(); LI != LE; ++LI) {
2151 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2152 Asm->EmitInt32(LI->second->getOffset());
2154 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2155 Asm->OutStreamer.EmitSymbolValue(LI->first,
2156 Asm->getTargetData().getPointerSize(),0);
2160 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));