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 "DwarfCompileUnit.h"
18 #include "llvm/Constants.h"
19 #include "llvm/Module.h"
20 #include "llvm/Instructions.h"
21 #include "llvm/CodeGen/MachineFunction.h"
22 #include "llvm/CodeGen/MachineModuleInfo.h"
23 #include "llvm/MC/MCAsmInfo.h"
24 #include "llvm/MC/MCSection.h"
25 #include "llvm/MC/MCStreamer.h"
26 #include "llvm/MC/MCSymbol.h"
27 #include "llvm/Target/TargetData.h"
28 #include "llvm/Target/TargetFrameLowering.h"
29 #include "llvm/Target/TargetLoweringObjectFile.h"
30 #include "llvm/Target/TargetMachine.h"
31 #include "llvm/Target/TargetRegisterInfo.h"
32 #include "llvm/Target/TargetOptions.h"
33 #include "llvm/Analysis/DebugInfo.h"
34 #include "llvm/Analysis/DIBuilder.h"
35 #include "llvm/ADT/Statistic.h"
36 #include "llvm/ADT/STLExtras.h"
37 #include "llvm/ADT/StringExtras.h"
38 #include "llvm/Support/CommandLine.h"
39 #include "llvm/Support/Debug.h"
40 #include "llvm/Support/ErrorHandling.h"
41 #include "llvm/Support/ValueHandle.h"
42 #include "llvm/Support/FormattedStream.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/Path.h"
47 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
49 cl::desc("Disable debug info printing"));
51 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
52 cl::desc("Make an absence of debug location information explicit."),
56 const char *DWARFGroupName = "DWARF Emission";
57 const char *DbgTimerName = "DWARF Debug Writer";
58 } // end anonymous namespace
60 //===----------------------------------------------------------------------===//
62 /// Configuration values for initial hash set sizes (log2).
64 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
68 DIType DbgVariable::getType() const {
69 DIType Ty = Var.getType();
70 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
72 if (Var.isBlockByrefVariable()) {
73 /* Byref variables, in Blocks, are declared by the programmer as
74 "SomeType VarName;", but the compiler creates a
75 __Block_byref_x_VarName struct, and gives the variable VarName
76 either the struct, or a pointer to the struct, as its type. This
77 is necessary for various behind-the-scenes things the compiler
78 needs to do with by-reference variables in blocks.
80 However, as far as the original *programmer* is concerned, the
81 variable should still have type 'SomeType', as originally declared.
83 The following function dives into the __Block_byref_x_VarName
84 struct to find the original type of the variable. This will be
85 passed back to the code generating the type for the Debug
86 Information Entry for the variable 'VarName'. 'VarName' will then
87 have the original type 'SomeType' in its debug information.
89 The original type 'SomeType' will be the type of the field named
90 'VarName' inside the __Block_byref_x_VarName struct.
92 NOTE: In order for this to not completely fail on the debugger
93 side, the Debug Information Entry for the variable VarName needs to
94 have a DW_AT_location that tells the debugger how to unwind through
95 the pointers and __Block_byref_x_VarName struct to find the actual
96 value of the variable. The function addBlockByrefType does this. */
98 unsigned tag = Ty.getTag();
100 if (tag == dwarf::DW_TAG_pointer_type) {
101 DIDerivedType DTy = DIDerivedType(Ty);
102 subType = DTy.getTypeDerivedFrom();
105 DICompositeType blockStruct = DICompositeType(subType);
106 DIArray Elements = blockStruct.getTypeArray();
108 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
109 DIDescriptor Element = Elements.getElement(i);
110 DIDerivedType DT = DIDerivedType(Element);
111 if (getName() == DT.getName())
112 return (DT.getTypeDerivedFrom());
119 } // end llvm namespace
121 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
122 : Asm(A), MMI(Asm->MMI), FirstCU(0),
123 AbbreviationsSet(InitAbbreviationsSetSize),
125 NextStringPoolNumber = 0;
127 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
128 DwarfStrSectionSym = TextSectionSym = 0;
129 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
130 FunctionBeginSym = FunctionEndSym = 0;
132 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
136 DwarfDebug::~DwarfDebug() {
139 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
140 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
141 if (Entry.first) return Entry.first;
143 Entry.second = NextStringPoolNumber++;
144 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
148 /// assignAbbrevNumber - Define a unique number for the abbreviation.
150 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
151 // Profile the node so that we can make it unique.
155 // Check the set for priors.
156 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
158 // If it's newly added.
159 if (InSet == &Abbrev) {
160 // Add to abbreviation list.
161 Abbreviations.push_back(&Abbrev);
163 // Assign the vector position + 1 as its number.
164 Abbrev.setNumber(Abbreviations.size());
166 // Assign existing abbreviation number.
167 Abbrev.setNumber(InSet->getNumber());
171 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
172 /// printer to not emit usual symbol prefix before the symbol name is used then
173 /// return linkage name after skipping this special LLVM prefix.
174 static StringRef getRealLinkageName(StringRef LinkageName) {
176 if (LinkageName.startswith(StringRef(&One, 1)))
177 return LinkageName.substr(1);
181 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
182 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
183 /// If there are global variables in this scope then create and insert
184 /// DIEs for these variables.
185 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
186 const MDNode *SPNode) {
187 DIE *SPDie = SPCU->getDIE(SPNode);
189 assert(SPDie && "Unable to find subprogram DIE!");
190 DISubprogram SP(SPNode);
192 DISubprogram SPDecl = SP.getFunctionDeclaration();
193 if (SPDecl.isSubprogram())
194 // Refer function declaration directly.
195 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
196 SPCU->getOrCreateSubprogramDIE(SPDecl));
198 // There is not any need to generate specification DIE for a function
199 // defined at compile unit level. If a function is defined inside another
200 // function then gdb prefers the definition at top level and but does not
201 // expect specification DIE in parent function. So avoid creating
202 // specification DIE for a function defined inside a function.
203 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
204 !SP.getContext().isFile() &&
205 !isSubprogramContext(SP.getContext())) {
206 SPCU-> addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
209 DICompositeType SPTy = SP.getType();
210 DIArray Args = SPTy.getTypeArray();
211 unsigned SPTag = SPTy.getTag();
212 if (SPTag == dwarf::DW_TAG_subroutine_type)
213 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
214 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
215 DIType ATy = DIType(DIType(Args.getElement(i)));
216 SPCU->addType(Arg, ATy);
217 if (ATy.isArtificial())
218 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
219 SPDie->addChild(Arg);
221 DIE *SPDeclDie = SPDie;
222 SPDie = new DIE(dwarf::DW_TAG_subprogram);
223 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
228 // Pick up abstract subprogram DIE.
229 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
230 SPDie = new DIE(dwarf::DW_TAG_subprogram);
231 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
232 dwarf::DW_FORM_ref4, AbsSPDIE);
236 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
237 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
238 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
239 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
240 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
241 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
242 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
247 /// constructLexicalScope - Construct new DW_TAG_lexical_block
248 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
249 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
250 LexicalScope *Scope) {
252 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
253 if (Scope->isAbstractScope())
256 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
260 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
261 if (Ranges.size() > 1) {
262 // .debug_range section has not been laid out yet. Emit offset in
263 // .debug_range as a uint, size 4, for now. emitDIE will handle
264 // DW_AT_ranges appropriately.
265 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
266 DebugRangeSymbols.size()
267 * Asm->getTargetData().getPointerSize());
268 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
269 RE = Ranges.end(); RI != RE; ++RI) {
270 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
271 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
273 DebugRangeSymbols.push_back(NULL);
274 DebugRangeSymbols.push_back(NULL);
278 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
279 const MCSymbol *End = getLabelAfterInsn(RI->second);
281 if (End == 0) return 0;
283 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
284 assert(End->isDefined() && "Invalid end label for an inlined scope!");
286 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
287 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
292 /// constructInlinedScopeDIE - This scope represents inlined body of
293 /// a function. Construct DIE to represent this concrete inlined copy
295 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
296 LexicalScope *Scope) {
298 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
299 assert (Ranges.empty() == false
300 && "LexicalScope does not have instruction markers!");
302 if (!Scope->getScopeNode())
304 DIScope DS(Scope->getScopeNode());
305 DISubprogram InlinedSP = getDISubprogram(DS);
306 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
308 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
312 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
313 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
314 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
316 if (StartLabel == 0 || EndLabel == 0) {
317 assert (0 && "Unexpected Start and End labels for a inlined scope!");
320 assert(StartLabel->isDefined() &&
321 "Invalid starting label for an inlined scope!");
322 assert(EndLabel->isDefined() &&
323 "Invalid end label for an inlined scope!");
325 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
326 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
327 dwarf::DW_FORM_ref4, OriginDIE);
329 if (Ranges.size() > 1) {
330 // .debug_range section has not been laid out yet. Emit offset in
331 // .debug_range as a uint, size 4, for now. emitDIE will handle
332 // DW_AT_ranges appropriately.
333 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
334 DebugRangeSymbols.size()
335 * Asm->getTargetData().getPointerSize());
336 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
337 RE = Ranges.end(); RI != RE; ++RI) {
338 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
339 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
341 DebugRangeSymbols.push_back(NULL);
342 DebugRangeSymbols.push_back(NULL);
344 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
346 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
350 InlinedSubprogramDIEs.insert(OriginDIE);
352 // Track the start label for this inlined function.
353 //.debug_inlined section specification does not clearly state how
354 // to emit inlined scope that is split into multiple instruction ranges.
355 // For now, use first instruction range and emit low_pc/high_pc pair and
356 // corresponding .debug_inlined section entry for this pair.
357 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
358 I = InlineInfo.find(InlinedSP);
360 if (I == InlineInfo.end()) {
361 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
363 InlinedSPNodes.push_back(InlinedSP);
365 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
367 DILocation DL(Scope->getInlinedAt());
368 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
369 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
374 /// constructScopeDIE - Construct a DIE for this scope.
375 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
376 if (!Scope || !Scope->getScopeNode())
379 SmallVector <DIE *, 8> Children;
381 // Collect arguments for current function.
382 if (LScopes.isCurrentFunctionScope(Scope))
383 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
384 if (DbgVariable *ArgDV = CurrentFnArguments[i])
386 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
387 Children.push_back(Arg);
389 // Collect lexical scope children first.
390 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
391 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
393 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
394 Children.push_back(Variable);
395 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
396 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
397 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
398 Children.push_back(Nested);
399 DIScope DS(Scope->getScopeNode());
400 DIE *ScopeDIE = NULL;
401 if (Scope->getInlinedAt())
402 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
403 else if (DS.isSubprogram()) {
404 ProcessedSPNodes.insert(DS);
405 if (Scope->isAbstractScope()) {
406 ScopeDIE = TheCU->getDIE(DS);
407 // Note down abstract DIE.
409 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
412 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
415 // There is no need to emit empty lexical block DIE.
416 if (Children.empty())
418 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
421 if (!ScopeDIE) return NULL;
424 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
425 E = Children.end(); I != E; ++I)
426 ScopeDIE->addChild(*I);
428 if (DS.isSubprogram())
429 TheCU->addPubTypes(DISubprogram(DS));
434 /// GetOrCreateSourceID - Look up the source id with the given directory and
435 /// source file names. If none currently exists, create a new id and insert it
436 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
439 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
441 // If FE did not provide a file name, then assume stdin.
442 if (FileName.empty())
443 return GetOrCreateSourceID("<stdin>", StringRef());
445 // MCStream expects full path name as filename.
446 if (!DirName.empty() && !sys::path::is_absolute(FileName)) {
447 SmallString<128> FullPathName = DirName;
448 sys::path::append(FullPathName, FileName);
449 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
450 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
453 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
454 if (Entry.getValue())
455 return Entry.getValue();
457 unsigned SrcId = SourceIdMap.size();
458 Entry.setValue(SrcId);
460 // Print out a .file directive to specify files for .loc directives.
461 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
466 /// constructCompileUnit - Create new CompileUnit for the given
467 /// metadata node with tag DW_TAG_compile_unit.
468 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
469 DICompileUnit DIUnit(N);
470 StringRef FN = DIUnit.getFilename();
471 StringRef Dir = DIUnit.getDirectory();
472 unsigned ID = GetOrCreateSourceID(FN, Dir);
474 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
475 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
476 NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
477 DIUnit.getProducer());
478 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
479 DIUnit.getLanguage());
480 NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
481 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
482 // simplifies debug range entries.
483 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
484 // DW_AT_stmt_list is a offset of line number information for this
485 // compile unit in debug_line section.
486 if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
487 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
488 Asm->GetTempSymbol("section_line"));
490 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
493 NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
494 if (DIUnit.isOptimized())
495 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
497 StringRef Flags = DIUnit.getFlags();
499 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string,
502 unsigned RVer = DIUnit.getRunTimeVersion();
504 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
505 dwarf::DW_FORM_data1, RVer);
509 CUMap.insert(std::make_pair(N, NewCU));
513 /// construct SubprogramDIE - Construct subprogram DIE.
514 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
517 if (!SP.isDefinition())
518 // This is a method declaration which will be handled while constructing
522 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
525 TheCU->insertDIE(N, SubprogramDie);
527 // Add to context owner.
528 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
531 TheCU->addGlobal(SP.getName(), SubprogramDie);
537 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
538 /// as llvm.dbg.enum and llvm.dbg.ty
539 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
540 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
541 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
542 const MDNode *N = NMD->getOperand(i);
543 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
544 constructSubprogramDIE(CU, N);
547 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
548 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
549 const MDNode *N = NMD->getOperand(i);
550 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
551 CU->createGlobalVariableDIE(N);
554 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
555 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
556 DIType Ty(NMD->getOperand(i));
557 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
558 CU->getOrCreateTypeDIE(Ty);
561 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
562 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
563 DIType Ty(NMD->getOperand(i));
564 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
565 CU->getOrCreateTypeDIE(Ty);
569 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
570 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
571 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
572 DebugInfoFinder DbgFinder;
573 DbgFinder.processModule(*M);
575 bool HasDebugInfo = false;
576 // Scan all the compile-units to see if there are any marked as the main
577 // unit. If not, we do not generate debug info.
578 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
579 E = DbgFinder.compile_unit_end(); I != E; ++I) {
580 if (DICompileUnit(*I).isMain()) {
585 if (!HasDebugInfo) return false;
587 // Create all the compile unit DIEs.
588 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
589 E = DbgFinder.compile_unit_end(); I != E; ++I)
590 constructCompileUnit(*I);
592 // Create DIEs for each global variable.
593 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
594 E = DbgFinder.global_variable_end(); I != E; ++I) {
595 const MDNode *N = *I;
596 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
597 CU->createGlobalVariableDIE(N);
600 // Create DIEs for each subprogram.
601 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
602 E = DbgFinder.subprogram_end(); I != E; ++I) {
603 const MDNode *N = *I;
604 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
605 constructSubprogramDIE(CU, N);
611 /// beginModule - Emit all Dwarf sections that should come prior to the
612 /// content. Create global DIEs and emit initial debug info sections.
613 /// This is invoked by the target AsmPrinter.
614 void DwarfDebug::beginModule(Module *M) {
615 if (DisableDebugInfoPrinting)
618 // If module has named metadata anchors then use them, otherwise scan the
619 // module using debug info finder to collect debug info.
620 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
622 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
623 DICompileUnit CUNode(CU_Nodes->getOperand(i));
624 CompileUnit *CU = constructCompileUnit(CUNode);
625 DIArray GVs = CUNode.getGlobalVariables();
626 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
627 CU->createGlobalVariableDIE(GVs.getElement(i));
628 DIArray SPs = CUNode.getSubprograms();
629 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
630 constructSubprogramDIE(CU, SPs.getElement(i));
631 DIArray EnumTypes = CUNode.getEnumTypes();
632 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
633 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
634 DIArray RetainedTypes = CUNode.getRetainedTypes();
635 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
636 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
638 } else if (!collectLegacyDebugInfo(M))
641 collectInfoFromNamedMDNodes(M);
643 // Tell MMI that we have debug info.
644 MMI->setDebugInfoAvailability(true);
646 // Emit initial sections.
649 // Prime section data.
650 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
653 /// endModule - Emit all Dwarf sections that should come after the content.
655 void DwarfDebug::endModule() {
656 if (!FirstCU) return;
657 const Module *M = MMI->getModule();
658 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
660 // Collect info for variables that were optimized out.
661 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
662 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
663 DICompileUnit TheCU(CU_Nodes->getOperand(i));
664 DIArray Subprograms = TheCU.getSubprograms();
665 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
666 DISubprogram SP(Subprograms.getElement(i));
667 if (ProcessedSPNodes.count(SP) != 0) continue;
668 if (!SP.Verify()) continue;
669 if (!SP.isDefinition()) continue;
670 DIArray Variables = SP.getVariables();
671 if (Variables.getNumElements() == 0) continue;
673 LexicalScope *Scope =
674 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
675 DeadFnScopeMap[SP] = Scope;
677 // Construct subprogram DIE and add variables DIEs.
678 CompileUnit *SPCU = CUMap.lookup(TheCU);
679 assert (SPCU && "Unable to find Compile Unit!");
680 constructSubprogramDIE(SPCU, SP);
681 DIE *ScopeDIE = SPCU->getDIE(SP);
682 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
683 DIVariable DV(Variables.getElement(vi));
684 if (!DV.Verify()) continue;
685 DbgVariable *NewVar = new DbgVariable(DV, NULL);
686 if (DIE *VariableDIE =
687 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
688 ScopeDIE->addChild(VariableDIE);
694 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
695 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
696 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
698 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
701 // Emit DW_AT_containing_type attribute to connect types with their
702 // vtable holding type.
703 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
704 CUE = CUMap.end(); CUI != CUE; ++CUI) {
705 CompileUnit *TheCU = CUI->second;
706 TheCU->constructContainingTypeDIEs();
709 // Standard sections final addresses.
710 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
711 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
712 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
713 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
715 // End text sections.
716 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
717 Asm->OutStreamer.SwitchSection(SectionMap[i]);
718 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
721 // Compute DIE offsets and sizes.
722 computeSizeAndOffsets();
724 // Emit all the DIEs into a debug info section
727 // Corresponding abbreviations into a abbrev section.
730 // Emit info into a debug pubnames section.
733 // Emit info into a debug pubtypes section.
736 // Emit info into a debug loc section.
739 // Emit info into a debug aranges section.
742 // Emit info into a debug ranges section.
745 // Emit info into a debug macinfo section.
749 emitDebugInlineInfo();
751 // Emit info into a debug str section.
755 DeleteContainerSeconds(DeadFnScopeMap);
757 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
758 E = CUMap.end(); I != E; ++I)
760 FirstCU = NULL; // Reset for the next Module, if any.
763 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
764 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
766 LLVMContext &Ctx = DV->getContext();
767 // More then one inlined variable corresponds to one abstract variable.
768 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
769 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
771 return AbsDbgVariable;
773 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
777 AbsDbgVariable = new DbgVariable(Var, NULL);
778 addScopeVariable(Scope, AbsDbgVariable);
779 AbstractVariables[Var] = AbsDbgVariable;
780 return AbsDbgVariable;
783 /// addCurrentFnArgument - If Var is a current function argument then add
784 /// it to CurrentFnArguments list.
785 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
786 DbgVariable *Var, LexicalScope *Scope) {
787 if (!LScopes.isCurrentFunctionScope(Scope))
789 DIVariable DV = Var->getVariable();
790 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
792 unsigned ArgNo = DV.getArgNumber();
796 size_t Size = CurrentFnArguments.size();
798 CurrentFnArguments.resize(MF->getFunction()->arg_size());
799 // llvm::Function argument size is not good indicator of how many
800 // arguments does the function have at source level.
802 CurrentFnArguments.resize(ArgNo * 2);
803 CurrentFnArguments[ArgNo - 1] = Var;
807 /// collectVariableInfoFromMMITable - Collect variable information from
808 /// side table maintained by MMI.
810 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
811 SmallPtrSet<const MDNode *, 16> &Processed) {
812 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
813 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
814 VE = VMap.end(); VI != VE; ++VI) {
815 const MDNode *Var = VI->first;
817 Processed.insert(Var);
819 const std::pair<unsigned, DebugLoc> &VP = VI->second;
821 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
823 // If variable scope is not found then skip this variable.
827 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
828 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
829 RegVar->setFrameIndex(VP.first);
830 if (!addCurrentFnArgument(MF, RegVar, Scope))
831 addScopeVariable(Scope, RegVar);
833 AbsDbgVariable->setFrameIndex(VP.first);
837 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
838 /// DBG_VALUE instruction, is in a defined reg.
839 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
840 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
841 return MI->getNumOperands() == 3 &&
842 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
843 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
846 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
848 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
849 const MCSymbol *FLabel,
850 const MCSymbol *SLabel,
851 const MachineInstr *MI) {
852 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
854 if (MI->getNumOperands() != 3) {
855 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
856 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
858 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
859 MachineLocation MLoc;
860 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
861 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
863 if (MI->getOperand(0).isImm())
864 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
865 if (MI->getOperand(0).isFPImm())
866 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
867 if (MI->getOperand(0).isCImm())
868 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
870 assert (0 && "Unexpected 3 operand DBG_VALUE instruction!");
871 return DotDebugLocEntry();
874 /// collectVariableInfo - Find variables for each lexical scope.
876 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
877 SmallPtrSet<const MDNode *, 16> &Processed) {
879 /// collection info from MMI table.
880 collectVariableInfoFromMMITable(MF, Processed);
882 for (SmallVectorImpl<const MDNode*>::const_iterator
883 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
885 const MDNode *Var = *UVI;
886 if (Processed.count(Var))
889 // History contains relevant DBG_VALUE instructions for Var and instructions
891 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
894 const MachineInstr *MInsn = History.front();
897 LexicalScope *Scope = NULL;
898 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
899 DISubprogram(DV.getContext()).describes(MF->getFunction()))
900 Scope = LScopes.getCurrentFunctionScope();
902 if (DV.getVersion() <= LLVMDebugVersion9)
903 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
905 if (MDNode *IA = DV.getInlinedAt())
906 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
908 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
911 // If variable scope is not found then skip this variable.
915 Processed.insert(DV);
916 assert(MInsn->isDebugValue() && "History must begin with debug value");
917 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
918 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
919 if (!addCurrentFnArgument(MF, RegVar, Scope))
920 addScopeVariable(Scope, RegVar);
922 AbsVar->setMInsn(MInsn);
924 // Simple ranges that are fully coalesced.
925 if (History.size() <= 1 || (History.size() == 2 &&
926 MInsn->isIdenticalTo(History.back()))) {
927 RegVar->setMInsn(MInsn);
931 // handle multiple DBG_VALUE instructions describing one variable.
932 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
934 for (SmallVectorImpl<const MachineInstr*>::const_iterator
935 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
936 const MachineInstr *Begin = *HI;
937 assert(Begin->isDebugValue() && "Invalid History entry");
939 // Check if DBG_VALUE is truncating a range.
940 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
941 && !Begin->getOperand(0).getReg())
944 // Compute the range for a register location.
945 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
946 const MCSymbol *SLabel = 0;
949 // If Begin is the last instruction in History then its value is valid
950 // until the end of the function.
951 SLabel = FunctionEndSym;
953 const MachineInstr *End = HI[1];
954 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
955 << "\t" << *Begin << "\t" << *End << "\n");
956 if (End->isDebugValue())
957 SLabel = getLabelBeforeInsn(End);
959 // End is a normal instruction clobbering the range.
960 SLabel = getLabelAfterInsn(End);
961 assert(SLabel && "Forgot label after clobber instruction");
966 // The value is valid until the next DBG_VALUE or clobber.
967 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
969 DotDebugLocEntries.push_back(DotDebugLocEntry());
972 // Collect info for variables that were optimized out.
973 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
974 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
975 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
976 DIVariable DV(Variables.getElement(i));
977 if (!DV || !DV.Verify() || !Processed.insert(DV))
979 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
980 addScopeVariable(Scope, new DbgVariable(DV, NULL));
984 /// getLabelBeforeInsn - Return Label preceding the instruction.
985 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
986 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
987 assert(Label && "Didn't insert label before instruction");
991 /// getLabelAfterInsn - Return Label immediately following the instruction.
992 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
993 return LabelsAfterInsn.lookup(MI);
996 /// beginInstruction - Process beginning of an instruction.
997 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
998 // Check if source location changes, but ignore DBG_VALUE locations.
999 if (!MI->isDebugValue()) {
1000 DebugLoc DL = MI->getDebugLoc();
1001 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1002 unsigned Flags = DWARF2_FLAG_IS_STMT;
1004 if (DL == PrologEndLoc) {
1005 Flags |= DWARF2_FLAG_PROLOGUE_END;
1006 PrologEndLoc = DebugLoc();
1008 if (!DL.isUnknown()) {
1009 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1010 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1012 recordSourceLine(0, 0, 0, 0);
1016 // Insert labels where requested.
1017 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1018 LabelsBeforeInsn.find(MI);
1021 if (I == LabelsBeforeInsn.end())
1024 // Label already assigned.
1029 PrevLabel = MMI->getContext().CreateTempSymbol();
1030 Asm->OutStreamer.EmitLabel(PrevLabel);
1032 I->second = PrevLabel;
1035 /// endInstruction - Process end of an instruction.
1036 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1037 // Don't create a new label after DBG_VALUE instructions.
1038 // They don't generate code.
1039 if (!MI->isDebugValue())
1042 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1043 LabelsAfterInsn.find(MI);
1046 if (I == LabelsAfterInsn.end())
1049 // Label already assigned.
1053 // We need a label after this instruction.
1055 PrevLabel = MMI->getContext().CreateTempSymbol();
1056 Asm->OutStreamer.EmitLabel(PrevLabel);
1058 I->second = PrevLabel;
1061 /// identifyScopeMarkers() -
1062 /// Each LexicalScope has first instruction and last instruction to mark
1063 /// beginning and end of a scope respectively. Create an inverse map that list
1064 /// scopes starts (and ends) with an instruction. One instruction may start (or
1065 /// end) multiple scopes. Ignore scopes that are not reachable.
1066 void DwarfDebug::identifyScopeMarkers() {
1067 SmallVector<LexicalScope *, 4> WorkList;
1068 WorkList.push_back(LScopes.getCurrentFunctionScope());
1069 while (!WorkList.empty()) {
1070 LexicalScope *S = WorkList.pop_back_val();
1072 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1073 if (!Children.empty())
1074 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1075 SE = Children.end(); SI != SE; ++SI)
1076 WorkList.push_back(*SI);
1078 if (S->isAbstractScope())
1081 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1084 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1085 RE = Ranges.end(); RI != RE; ++RI) {
1086 assert(RI->first && "InsnRange does not have first instruction!");
1087 assert(RI->second && "InsnRange does not have second instruction!");
1088 requestLabelBeforeInsn(RI->first);
1089 requestLabelAfterInsn(RI->second);
1094 /// getScopeNode - Get MDNode for DebugLoc's scope.
1095 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1096 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1097 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1098 return DL.getScope(Ctx);
1101 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1102 /// line number info for the function.
1103 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1104 const MDNode *Scope = getScopeNode(DL, Ctx);
1105 DISubprogram SP = getDISubprogram(Scope);
1107 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1111 /// beginFunction - Gather pre-function debug information. Assumes being
1112 /// emitted immediately after the function entry point.
1113 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1114 if (!MMI->hasDebugInfo()) return;
1115 LScopes.initialize(*MF);
1116 if (LScopes.empty()) return;
1117 identifyScopeMarkers();
1119 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1120 Asm->getFunctionNumber());
1121 // Assumes in correct section after the entry point.
1122 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1124 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1126 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1127 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1128 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1130 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1132 bool AtBlockEntry = true;
1133 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1135 const MachineInstr *MI = II;
1137 if (MI->isDebugValue()) {
1138 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1140 // Keep track of user variables.
1142 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1144 // Variable is in a register, we need to check for clobbers.
1145 if (isDbgValueInDefinedReg(MI))
1146 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1148 // Check the history of this variable.
1149 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1150 if (History.empty()) {
1151 UserVariables.push_back(Var);
1152 // The first mention of a function argument gets the FunctionBeginSym
1153 // label, so arguments are visible when breaking at function entry.
1155 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1156 DISubprogram(getDISubprogram(DV.getContext()))
1157 .describes(MF->getFunction()))
1158 LabelsBeforeInsn[MI] = FunctionBeginSym;
1160 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1161 const MachineInstr *Prev = History.back();
1162 if (Prev->isDebugValue()) {
1163 // Coalesce identical entries at the end of History.
1164 if (History.size() >= 2 &&
1165 Prev->isIdenticalTo(History[History.size() - 2])) {
1166 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1168 << "\t" << *History[History.size() - 2] << "\n");
1172 // Terminate old register assignments that don't reach MI;
1173 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1174 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1175 isDbgValueInDefinedReg(Prev)) {
1176 // Previous register assignment needs to terminate at the end of
1178 MachineBasicBlock::const_iterator LastMI =
1179 PrevMBB->getLastNonDebugInstr();
1180 if (LastMI == PrevMBB->end()) {
1181 // Drop DBG_VALUE for empty range.
1182 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1183 << "\t" << *Prev << "\n");
1187 // Terminate after LastMI.
1188 History.push_back(LastMI);
1193 History.push_back(MI);
1195 // Not a DBG_VALUE instruction.
1197 AtBlockEntry = false;
1199 // First known non DBG_VALUE location marks beginning of function
1201 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1202 PrologEndLoc = MI->getDebugLoc();
1204 // Check if the instruction clobbers any registers with debug vars.
1205 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1206 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1207 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1209 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1210 unsigned Reg = *AI; ++AI) {
1211 const MDNode *Var = LiveUserVar[Reg];
1214 // Reg is now clobbered.
1215 LiveUserVar[Reg] = 0;
1217 // Was MD last defined by a DBG_VALUE referring to Reg?
1218 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1219 if (HistI == DbgValues.end())
1221 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1222 if (History.empty())
1224 const MachineInstr *Prev = History.back();
1225 // Sanity-check: Register assignments are terminated at the end of
1227 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1229 // Is the variable still in Reg?
1230 if (!isDbgValueInDefinedReg(Prev) ||
1231 Prev->getOperand(0).getReg() != Reg)
1233 // Var is clobbered. Make sure the next instruction gets a label.
1234 History.push_back(MI);
1241 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1243 SmallVectorImpl<const MachineInstr*> &History = I->second;
1244 if (History.empty())
1247 // Make sure the final register assignments are terminated.
1248 const MachineInstr *Prev = History.back();
1249 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1250 const MachineBasicBlock *PrevMBB = Prev->getParent();
1251 MachineBasicBlock::const_iterator LastMI =
1252 PrevMBB->getLastNonDebugInstr();
1253 if (LastMI == PrevMBB->end())
1254 // Drop DBG_VALUE for empty range.
1257 // Terminate after LastMI.
1258 History.push_back(LastMI);
1261 // Request labels for the full history.
1262 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1263 const MachineInstr *MI = History[i];
1264 if (MI->isDebugValue())
1265 requestLabelBeforeInsn(MI);
1267 requestLabelAfterInsn(MI);
1271 PrevInstLoc = DebugLoc();
1272 PrevLabel = FunctionBeginSym;
1274 // Record beginning of function.
1275 if (!PrologEndLoc.isUnknown()) {
1276 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1277 MF->getFunction()->getContext());
1278 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1279 FnStartDL.getScope(MF->getFunction()->getContext()),
1280 DWARF2_FLAG_IS_STMT);
1284 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1285 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1286 ScopeVariables[LS].push_back(Var);
1287 // Vars.push_back(Var);
1290 /// endFunction - Gather and emit post-function debug information.
1292 void DwarfDebug::endFunction(const MachineFunction *MF) {
1293 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1295 // Define end label for subprogram.
1296 FunctionEndSym = Asm->GetTempSymbol("func_end",
1297 Asm->getFunctionNumber());
1298 // Assumes in correct section after the entry point.
1299 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1301 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1302 collectVariableInfo(MF, ProcessedVars);
1304 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1305 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1306 assert (TheCU && "Unable to find compile unit!");
1308 // Construct abstract scopes.
1309 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1310 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1311 LexicalScope *AScope = AList[i];
1312 DISubprogram SP(AScope->getScopeNode());
1314 // Collect info for variables that were optimized out.
1315 DIArray Variables = SP.getVariables();
1316 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1317 DIVariable DV(Variables.getElement(i));
1318 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1320 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1321 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1324 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1325 constructScopeDIE(TheCU, AScope);
1328 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1330 if (!DisableFramePointerElim(*MF))
1331 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1332 dwarf::DW_FORM_flag, 1);
1334 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1335 MMI->getFrameMoves()));
1338 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1339 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1340 DeleteContainerPointers(I->second);
1341 ScopeVariables.clear();
1342 DeleteContainerPointers(CurrentFnArguments);
1343 UserVariables.clear();
1345 AbstractVariables.clear();
1346 LabelsBeforeInsn.clear();
1347 LabelsAfterInsn.clear();
1351 /// recordSourceLine - Register a source line with debug info. Returns the
1352 /// unique label that was emitted and which provides correspondence to
1353 /// the source line list.
1354 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1360 DIDescriptor Scope(S);
1362 if (Scope.isCompileUnit()) {
1363 DICompileUnit CU(S);
1364 Fn = CU.getFilename();
1365 Dir = CU.getDirectory();
1366 } else if (Scope.isFile()) {
1368 Fn = F.getFilename();
1369 Dir = F.getDirectory();
1370 } else if (Scope.isSubprogram()) {
1372 Fn = SP.getFilename();
1373 Dir = SP.getDirectory();
1374 } else if (Scope.isLexicalBlockFile()) {
1375 DILexicalBlockFile DBF(S);
1376 Fn = DBF.getFilename();
1377 Dir = DBF.getDirectory();
1378 } else if (Scope.isLexicalBlock()) {
1379 DILexicalBlock DB(S);
1380 Fn = DB.getFilename();
1381 Dir = DB.getDirectory();
1383 assert(0 && "Unexpected scope info");
1385 Src = GetOrCreateSourceID(Fn, Dir);
1387 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1390 //===----------------------------------------------------------------------===//
1392 //===----------------------------------------------------------------------===//
1394 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1397 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1398 // Get the children.
1399 const std::vector<DIE *> &Children = Die->getChildren();
1401 // If not last sibling and has children then add sibling offset attribute.
1402 if (!Last && !Children.empty())
1403 Die->addSiblingOffset(DIEValueAllocator);
1405 // Record the abbreviation.
1406 assignAbbrevNumber(Die->getAbbrev());
1408 // Get the abbreviation for this DIE.
1409 unsigned AbbrevNumber = Die->getAbbrevNumber();
1410 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1413 Die->setOffset(Offset);
1415 // Start the size with the size of abbreviation code.
1416 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1418 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1419 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1421 // Size the DIE attribute values.
1422 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1423 // Size attribute value.
1424 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1426 // Size the DIE children if any.
1427 if (!Children.empty()) {
1428 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1429 "Children flag not set");
1431 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1432 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1434 // End of children marker.
1435 Offset += sizeof(int8_t);
1438 Die->setSize(Offset - Die->getOffset());
1442 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1444 void DwarfDebug::computeSizeAndOffsets() {
1445 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1446 E = CUMap.end(); I != E; ++I) {
1447 // Compute size of compile unit header.
1449 sizeof(int32_t) + // Length of Compilation Unit Info
1450 sizeof(int16_t) + // DWARF version number
1451 sizeof(int32_t) + // Offset Into Abbrev. Section
1452 sizeof(int8_t); // Pointer Size (in bytes)
1453 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1457 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
1458 /// temporary label to it if SymbolStem is specified.
1459 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
1460 const char *SymbolStem = 0) {
1461 Asm->OutStreamer.SwitchSection(Section);
1462 if (!SymbolStem) return 0;
1464 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
1465 Asm->OutStreamer.EmitLabel(TmpSym);
1469 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1470 /// the start of each one.
1471 void DwarfDebug::EmitSectionLabels() {
1472 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1474 // Dwarf sections base addresses.
1475 DwarfInfoSectionSym =
1476 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1477 DwarfAbbrevSectionSym =
1478 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1479 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1481 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1482 EmitSectionSym(Asm, MacroInfo);
1484 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1485 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1486 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1487 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1488 DwarfStrSectionSym =
1489 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1490 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1493 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1494 "section_debug_loc");
1496 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1497 EmitSectionSym(Asm, TLOF.getDataSection());
1500 /// emitDIE - Recursively emits a debug information entry.
1502 void DwarfDebug::emitDIE(DIE *Die) {
1503 // Get the abbreviation for this DIE.
1504 unsigned AbbrevNumber = Die->getAbbrevNumber();
1505 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1507 // Emit the code (index) for the abbreviation.
1508 if (Asm->isVerbose())
1509 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1510 Twine::utohexstr(Die->getOffset()) + ":0x" +
1511 Twine::utohexstr(Die->getSize()) + " " +
1512 dwarf::TagString(Abbrev->getTag()));
1513 Asm->EmitULEB128(AbbrevNumber);
1515 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1516 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1518 // Emit the DIE attribute values.
1519 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1520 unsigned Attr = AbbrevData[i].getAttribute();
1521 unsigned Form = AbbrevData[i].getForm();
1522 assert(Form && "Too many attributes for DIE (check abbreviation)");
1524 if (Asm->isVerbose())
1525 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1528 case dwarf::DW_AT_sibling:
1529 Asm->EmitInt32(Die->getSiblingOffset());
1531 case dwarf::DW_AT_abstract_origin: {
1532 DIEEntry *E = cast<DIEEntry>(Values[i]);
1533 DIE *Origin = E->getEntry();
1534 unsigned Addr = Origin->getOffset();
1535 Asm->EmitInt32(Addr);
1538 case dwarf::DW_AT_ranges: {
1539 // DW_AT_range Value encodes offset in debug_range section.
1540 DIEInteger *V = cast<DIEInteger>(Values[i]);
1542 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1543 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1547 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1549 DwarfDebugRangeSectionSym,
1554 case dwarf::DW_AT_location: {
1555 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1556 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1558 Values[i]->EmitValue(Asm, Form);
1561 case dwarf::DW_AT_accessibility: {
1562 if (Asm->isVerbose()) {
1563 DIEInteger *V = cast<DIEInteger>(Values[i]);
1564 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1566 Values[i]->EmitValue(Asm, Form);
1570 // Emit an attribute using the defined form.
1571 Values[i]->EmitValue(Asm, Form);
1576 // Emit the DIE children if any.
1577 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1578 const std::vector<DIE *> &Children = Die->getChildren();
1580 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1581 emitDIE(Children[j]);
1583 if (Asm->isVerbose())
1584 Asm->OutStreamer.AddComment("End Of Children Mark");
1589 /// emitDebugInfo - Emit the debug info section.
1591 void DwarfDebug::emitDebugInfo() {
1592 // Start debug info section.
1593 Asm->OutStreamer.SwitchSection(
1594 Asm->getObjFileLowering().getDwarfInfoSection());
1595 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1596 E = CUMap.end(); I != E; ++I) {
1597 CompileUnit *TheCU = I->second;
1598 DIE *Die = TheCU->getCUDie();
1600 // Emit the compile units header.
1601 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1604 // Emit size of content not including length itself
1605 unsigned ContentSize = Die->getSize() +
1606 sizeof(int16_t) + // DWARF version number
1607 sizeof(int32_t) + // Offset Into Abbrev. Section
1608 sizeof(int8_t); // Pointer Size (in bytes)
1610 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1611 Asm->EmitInt32(ContentSize);
1612 Asm->OutStreamer.AddComment("DWARF version number");
1613 Asm->EmitInt16(dwarf::DWARF_VERSION);
1614 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1615 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1616 DwarfAbbrevSectionSym);
1617 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1618 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1621 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1625 /// emitAbbreviations - Emit the abbreviation section.
1627 void DwarfDebug::emitAbbreviations() const {
1628 // Check to see if it is worth the effort.
1629 if (!Abbreviations.empty()) {
1630 // Start the debug abbrev section.
1631 Asm->OutStreamer.SwitchSection(
1632 Asm->getObjFileLowering().getDwarfAbbrevSection());
1634 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1636 // For each abbrevation.
1637 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1638 // Get abbreviation data
1639 const DIEAbbrev *Abbrev = Abbreviations[i];
1641 // Emit the abbrevations code (base 1 index.)
1642 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1644 // Emit the abbreviations data.
1648 // Mark end of abbreviations.
1649 Asm->EmitULEB128(0, "EOM(3)");
1651 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1655 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1656 /// the line matrix.
1658 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1659 // Define last address of section.
1660 Asm->OutStreamer.AddComment("Extended Op");
1663 Asm->OutStreamer.AddComment("Op size");
1664 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1665 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1666 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1668 Asm->OutStreamer.AddComment("Section end label");
1670 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1671 Asm->getTargetData().getPointerSize(),
1674 // Mark end of matrix.
1675 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1681 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1683 void DwarfDebug::emitDebugPubNames() {
1684 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1685 E = CUMap.end(); I != E; ++I) {
1686 CompileUnit *TheCU = I->second;
1687 // Start the dwarf pubnames section.
1688 Asm->OutStreamer.SwitchSection(
1689 Asm->getObjFileLowering().getDwarfPubNamesSection());
1691 Asm->OutStreamer.AddComment("Length of Public Names Info");
1692 Asm->EmitLabelDifference(
1693 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
1694 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
1696 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
1699 Asm->OutStreamer.AddComment("DWARF Version");
1700 Asm->EmitInt16(dwarf::DWARF_VERSION);
1702 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1703 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1704 DwarfInfoSectionSym);
1706 Asm->OutStreamer.AddComment("Compilation Unit Length");
1707 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1708 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1711 const StringMap<DIE*> &Globals = TheCU->getGlobals();
1712 for (StringMap<DIE*>::const_iterator
1713 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1714 const char *Name = GI->getKeyData();
1715 DIE *Entity = GI->second;
1717 Asm->OutStreamer.AddComment("DIE offset");
1718 Asm->EmitInt32(Entity->getOffset());
1720 if (Asm->isVerbose())
1721 Asm->OutStreamer.AddComment("External Name");
1722 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
1725 Asm->OutStreamer.AddComment("End Mark");
1727 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
1732 void DwarfDebug::emitDebugPubTypes() {
1733 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1734 E = CUMap.end(); I != E; ++I) {
1735 CompileUnit *TheCU = I->second;
1736 // Start the dwarf pubnames section.
1737 Asm->OutStreamer.SwitchSection(
1738 Asm->getObjFileLowering().getDwarfPubTypesSection());
1739 Asm->OutStreamer.AddComment("Length of Public Types Info");
1740 Asm->EmitLabelDifference(
1741 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1742 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1744 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1747 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1748 Asm->EmitInt16(dwarf::DWARF_VERSION);
1750 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1751 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1752 DwarfInfoSectionSym);
1754 Asm->OutStreamer.AddComment("Compilation Unit Length");
1755 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1756 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1759 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1760 for (StringMap<DIE*>::const_iterator
1761 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1762 const char *Name = GI->getKeyData();
1763 DIE *Entity = GI->second;
1765 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1766 Asm->EmitInt32(Entity->getOffset());
1768 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1769 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1772 Asm->OutStreamer.AddComment("End Mark");
1774 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1779 /// emitDebugStr - Emit visible names into a debug str section.
1781 void DwarfDebug::emitDebugStr() {
1782 // Check to see if it is worth the effort.
1783 if (StringPool.empty()) return;
1785 // Start the dwarf str section.
1786 Asm->OutStreamer.SwitchSection(
1787 Asm->getObjFileLowering().getDwarfStrSection());
1789 // Get all of the string pool entries and put them in an array by their ID so
1790 // we can sort them.
1791 SmallVector<std::pair<unsigned,
1792 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1794 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1795 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1796 Entries.push_back(std::make_pair(I->second.second, &*I));
1798 array_pod_sort(Entries.begin(), Entries.end());
1800 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1801 // Emit a label for reference from debug information entries.
1802 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1804 // Emit the string itself.
1805 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
1809 /// emitDebugLoc - Emit visible names into a debug loc section.
1811 void DwarfDebug::emitDebugLoc() {
1812 if (DotDebugLocEntries.empty())
1815 for (SmallVector<DotDebugLocEntry, 4>::iterator
1816 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1818 DotDebugLocEntry &Entry = *I;
1819 if (I + 1 != DotDebugLocEntries.end())
1823 // Start the dwarf loc section.
1824 Asm->OutStreamer.SwitchSection(
1825 Asm->getObjFileLowering().getDwarfLocSection());
1826 unsigned char Size = Asm->getTargetData().getPointerSize();
1827 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1829 for (SmallVector<DotDebugLocEntry, 4>::iterator
1830 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1831 I != E; ++I, ++index) {
1832 DotDebugLocEntry &Entry = *I;
1833 if (Entry.isMerged()) continue;
1834 if (Entry.isEmpty()) {
1835 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1836 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1837 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1839 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1840 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1841 DIVariable DV(Entry.Variable);
1842 Asm->OutStreamer.AddComment("Loc expr size");
1843 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1844 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1845 Asm->EmitLabelDifference(end, begin, 2);
1846 Asm->OutStreamer.EmitLabel(begin);
1847 if (Entry.isInt()) {
1848 DIBasicType BTy(DV.getType());
1850 (BTy.getEncoding() == dwarf::DW_ATE_signed
1851 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1852 Asm->OutStreamer.AddComment("DW_OP_consts");
1853 Asm->EmitInt8(dwarf::DW_OP_consts);
1854 Asm->EmitSLEB128(Entry.getInt());
1856 Asm->OutStreamer.AddComment("DW_OP_constu");
1857 Asm->EmitInt8(dwarf::DW_OP_constu);
1858 Asm->EmitULEB128(Entry.getInt());
1860 } else if (Entry.isLocation()) {
1861 if (!DV.hasComplexAddress())
1863 Asm->EmitDwarfRegOp(Entry.Loc);
1865 // Complex address entry.
1866 unsigned N = DV.getNumAddrElements();
1868 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1869 if (Entry.Loc.getOffset()) {
1871 Asm->EmitDwarfRegOp(Entry.Loc);
1872 Asm->OutStreamer.AddComment("DW_OP_deref");
1873 Asm->EmitInt8(dwarf::DW_OP_deref);
1874 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
1875 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
1876 Asm->EmitSLEB128(DV.getAddrElement(1));
1878 // If first address element is OpPlus then emit
1879 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
1880 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
1881 Asm->EmitDwarfRegOp(Loc);
1885 Asm->EmitDwarfRegOp(Entry.Loc);
1888 // Emit remaining complex address elements.
1889 for (; i < N; ++i) {
1890 uint64_t Element = DV.getAddrElement(i);
1891 if (Element == DIBuilder::OpPlus) {
1892 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
1893 Asm->EmitULEB128(DV.getAddrElement(++i));
1894 } else if (Element == DIBuilder::OpDeref)
1895 Asm->EmitInt8(dwarf::DW_OP_deref);
1896 else llvm_unreachable("unknown Opcode found in complex address");
1900 // else ... ignore constant fp. There is not any good way to
1901 // to represent them here in dwarf.
1902 Asm->OutStreamer.EmitLabel(end);
1907 /// EmitDebugARanges - Emit visible names into a debug aranges section.
1909 void DwarfDebug::EmitDebugARanges() {
1910 // Start the dwarf aranges section.
1911 Asm->OutStreamer.SwitchSection(
1912 Asm->getObjFileLowering().getDwarfARangesSection());
1915 /// emitDebugRanges - Emit visible names into a debug ranges section.
1917 void DwarfDebug::emitDebugRanges() {
1918 // Start the dwarf ranges section.
1919 Asm->OutStreamer.SwitchSection(
1920 Asm->getObjFileLowering().getDwarfRangesSection());
1921 unsigned char Size = Asm->getTargetData().getPointerSize();
1922 for (SmallVector<const MCSymbol *, 8>::iterator
1923 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
1926 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
1928 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1932 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
1934 void DwarfDebug::emitDebugMacInfo() {
1935 if (const MCSection *LineInfo =
1936 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
1937 // Start the dwarf macinfo section.
1938 Asm->OutStreamer.SwitchSection(LineInfo);
1942 /// emitDebugInlineInfo - Emit inline info using following format.
1944 /// 1. length of section
1945 /// 2. Dwarf version number
1946 /// 3. address size.
1948 /// Entries (one "entry" for each function that was inlined):
1950 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
1951 /// otherwise offset into __debug_str for regular function name.
1952 /// 2. offset into __debug_str section for regular function name.
1953 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
1954 /// instances for the function.
1956 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
1957 /// inlined instance; the die_offset points to the inlined_subroutine die in the
1958 /// __debug_info section, and the low_pc is the starting address for the
1959 /// inlining instance.
1960 void DwarfDebug::emitDebugInlineInfo() {
1961 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
1967 Asm->OutStreamer.SwitchSection(
1968 Asm->getObjFileLowering().getDwarfDebugInlineSection());
1970 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
1971 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
1972 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
1974 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
1976 Asm->OutStreamer.AddComment("Dwarf Version");
1977 Asm->EmitInt16(dwarf::DWARF_VERSION);
1978 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1979 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1981 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
1982 E = InlinedSPNodes.end(); I != E; ++I) {
1984 const MDNode *Node = *I;
1985 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
1986 = InlineInfo.find(Node);
1987 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
1988 DISubprogram SP(Node);
1989 StringRef LName = SP.getLinkageName();
1990 StringRef Name = SP.getName();
1992 Asm->OutStreamer.AddComment("MIPS linkage name");
1993 if (LName.empty()) {
1994 Asm->OutStreamer.EmitBytes(Name, 0);
1995 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
1997 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
1998 DwarfStrSectionSym);
2000 Asm->OutStreamer.AddComment("Function name");
2001 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2002 Asm->EmitULEB128(Labels.size(), "Inline count");
2004 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2005 LE = Labels.end(); LI != LE; ++LI) {
2006 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2007 Asm->EmitInt32(LI->second->getOffset());
2009 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2010 Asm->OutStreamer.EmitSymbolValue(LI->first,
2011 Asm->getTargetData().getPointerSize(),0);
2015 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));