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 "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineModuleInfo.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/MC/MCSection.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/MC/MCSymbol.h"
25 #include "llvm/Target/Mangler.h"
26 #include "llvm/Target/TargetData.h"
27 #include "llvm/Target/TargetFrameInfo.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetRegisterInfo.h"
31 #include "llvm/Target/TargetOptions.h"
32 #include "llvm/Analysis/DebugInfo.h"
33 #include "llvm/ADT/STLExtras.h"
34 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/ValueHandle.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/System/Path.h"
44 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
45 cl::desc("Print DbgScope information for each machine instruction"));
47 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
48 cl::desc("Disable debug info printing"));
50 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
51 cl::desc("Make an absense of debug location information explicit."),
55 const char *DWARFGroupName = "DWARF Emission";
56 const char *DbgTimerName = "DWARF Debug Writer";
57 } // end anonymous namespace
59 //===----------------------------------------------------------------------===//
61 /// Configuration values for initial hash set sizes (log2).
63 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
67 //===----------------------------------------------------------------------===//
68 /// CompileUnit - This dwarf writer support class manages information associate
69 /// with a source file.
71 /// ID - File identifier for source.
75 /// Die - Compile unit debug information entry.
77 const OwningPtr<DIE> CUDie;
79 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
82 /// GVToDieMap - Tracks the mapping of unit level debug informaton
83 /// variables to debug information entries.
84 /// FIXME : Rename GVToDieMap -> NodeToDieMap
85 DenseMap<const MDNode *, DIE *> GVToDieMap;
87 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
88 /// descriptors to debug information entries using a DIEEntry proxy.
90 DenseMap<const MDNode *, DIEEntry *> GVToDIEEntryMap;
92 /// Globals - A map of globally visible named entities for this unit.
94 StringMap<DIE*> Globals;
96 /// GlobalTypes - A map of globally visible types for this unit.
98 StringMap<DIE*> GlobalTypes;
101 CompileUnit(unsigned I, DIE *D)
102 : ID(I), CUDie(D), IndexTyDie(0) {}
105 unsigned getID() const { return ID; }
106 DIE* getCUDie() const { return CUDie.get(); }
107 const StringMap<DIE*> &getGlobals() const { return Globals; }
108 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
110 /// hasContent - Return true if this compile unit has something to write out.
112 bool hasContent() const { return !CUDie->getChildren().empty(); }
114 /// addGlobal - Add a new global entity to the compile unit.
116 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
118 /// addGlobalType - Add a new global type to the compile unit.
120 void addGlobalType(StringRef Name, DIE *Die) {
121 GlobalTypes[Name] = Die;
124 /// getDIE - Returns the debug information entry map slot for the
125 /// specified debug variable.
126 DIE *getDIE(const MDNode *N) { return GVToDieMap.lookup(N); }
128 /// insertDIE - Insert DIE into the map.
129 void insertDIE(const MDNode *N, DIE *D) {
130 GVToDieMap.insert(std::make_pair(N, D));
133 /// getDIEEntry - Returns the debug information entry for the speciefied
135 DIEEntry *getDIEEntry(const MDNode *N) {
136 DenseMap<const MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
137 if (I == GVToDIEEntryMap.end())
142 /// insertDIEEntry - Insert debug information entry into the map.
143 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
144 GVToDIEEntryMap.insert(std::make_pair(N, E));
147 /// addDie - Adds or interns the DIE to the compile unit.
149 void addDie(DIE *Buffer) {
150 this->CUDie->addChild(Buffer);
153 // getIndexTyDie - Get an anonymous type for index type.
154 DIE *getIndexTyDie() {
158 // setIndexTyDie - Set D as anonymous type for index which can be reused
160 void setIndexTyDie(DIE *D) {
166 //===----------------------------------------------------------------------===//
167 /// DbgVariable - This class is used to track local variable information.
170 DIVariable Var; // Variable Descriptor.
171 DIE *TheDIE; // Variable DIE.
172 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
174 // AbsVar may be NULL.
175 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
178 DIVariable getVariable() const { return Var; }
179 void setDIE(DIE *D) { TheDIE = D; }
180 DIE *getDIE() const { return TheDIE; }
181 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
182 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
185 //===----------------------------------------------------------------------===//
186 /// DbgRange - This is used to track range of instructions with identical
187 /// debug info scope.
189 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
191 //===----------------------------------------------------------------------===//
192 /// DbgScope - This class is used to track scope information.
195 DbgScope *Parent; // Parent to this scope.
196 DIDescriptor Desc; // Debug info descriptor for scope.
197 // Location at which this scope is inlined.
198 AssertingVH<const MDNode> InlinedAtLocation;
199 bool AbstractScope; // Abstract Scope
200 const MachineInstr *LastInsn; // Last instruction of this scope.
201 const MachineInstr *FirstInsn; // First instruction of this scope.
202 unsigned DFSIn, DFSOut;
203 // Scopes defined in scope. Contents not owned.
204 SmallVector<DbgScope *, 4> Scopes;
205 // Variables declared in scope. Contents owned.
206 SmallVector<DbgVariable *, 8> Variables;
207 SmallVector<DbgRange, 4> Ranges;
208 // Private state for dump()
209 mutable unsigned IndentLevel;
211 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
212 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
213 LastInsn(0), FirstInsn(0),
214 DFSIn(0), DFSOut(0), IndentLevel(0) {}
218 DbgScope *getParent() const { return Parent; }
219 void setParent(DbgScope *P) { Parent = P; }
220 DIDescriptor getDesc() const { return Desc; }
221 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
222 const MDNode *getScopeNode() const { return Desc; }
223 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
224 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
225 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
227 /// openInsnRange - This scope covers instruction range starting from MI.
228 void openInsnRange(const MachineInstr *MI) {
233 Parent->openInsnRange(MI);
236 /// extendInsnRange - Extend the current instruction range covered by
238 void extendInsnRange(const MachineInstr *MI) {
239 assert (FirstInsn && "MI Range is not open!");
242 Parent->extendInsnRange(MI);
245 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
246 /// until now. This is used when a new scope is encountered while walking
247 /// machine instructions.
248 void closeInsnRange(DbgScope *NewScope = NULL) {
249 assert (LastInsn && "Last insn missing!");
250 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
253 // If Parent dominates NewScope then do not close Parent's instruction
255 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
256 Parent->closeInsnRange(NewScope);
259 void setAbstractScope() { AbstractScope = true; }
260 bool isAbstractScope() const { return AbstractScope; }
262 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
263 unsigned getDFSOut() const { return DFSOut; }
264 void setDFSOut(unsigned O) { DFSOut = O; }
265 unsigned getDFSIn() const { return DFSIn; }
266 void setDFSIn(unsigned I) { DFSIn = I; }
267 bool dominates(const DbgScope *S) {
270 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
275 /// addScope - Add a scope to the scope.
277 void addScope(DbgScope *S) { Scopes.push_back(S); }
279 /// addVariable - Add a variable to the scope.
281 void addVariable(DbgVariable *V) { Variables.push_back(V); }
288 } // end llvm namespace
291 void DbgScope::dump() const {
292 raw_ostream &err = dbgs();
293 err.indent(IndentLevel);
294 const MDNode *N = Desc;
297 err << "Abstract Scope\n";
301 err << "Children ...\n";
302 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
303 if (Scopes[i] != this)
310 DbgScope::~DbgScope() {
311 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
315 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
316 : Asm(A), MMI(Asm->MMI), FirstCU(0),
317 AbbreviationsSet(InitAbbreviationsSetSize),
318 CurrentFnDbgScope(0), PrevLabel(NULL) {
319 NextStringPoolNumber = 0;
321 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
322 DwarfStrSectionSym = TextSectionSym = 0;
323 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
324 FunctionBeginSym = FunctionEndSym = 0;
325 if (TimePassesIsEnabled) {
326 NamedRegionTimer T(DbgTimerName, DWARFGroupName);
332 DwarfDebug::~DwarfDebug() {
333 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
334 DIEBlocks[j]->~DIEBlock();
337 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
338 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
339 if (Entry.first) return Entry.first;
341 Entry.second = NextStringPoolNumber++;
342 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
346 /// assignAbbrevNumber - Define a unique number for the abbreviation.
348 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
349 // Profile the node so that we can make it unique.
353 // Check the set for priors.
354 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
356 // If it's newly added.
357 if (InSet == &Abbrev) {
358 // Add to abbreviation list.
359 Abbreviations.push_back(&Abbrev);
361 // Assign the vector position + 1 as its number.
362 Abbrev.setNumber(Abbreviations.size());
364 // Assign existing abbreviation number.
365 Abbrev.setNumber(InSet->getNumber());
369 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
370 /// information entry.
371 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
372 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
376 /// addUInt - Add an unsigned integer attribute data and value.
378 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
379 unsigned Form, uint64_t Integer) {
380 if (!Form) Form = DIEInteger::BestForm(false, Integer);
381 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
382 Die->addValue(Attribute, Form, Value);
385 /// addSInt - Add an signed integer attribute data and value.
387 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
388 unsigned Form, int64_t Integer) {
389 if (!Form) Form = DIEInteger::BestForm(true, Integer);
390 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
391 Die->addValue(Attribute, Form, Value);
394 /// addString - Add a string attribute data and value. DIEString only
395 /// keeps string reference.
396 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
398 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
399 Die->addValue(Attribute, Form, Value);
402 /// addLabel - Add a Dwarf label attribute data and value.
404 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
405 const MCSymbol *Label) {
406 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
407 Die->addValue(Attribute, Form, Value);
410 /// addDelta - Add a label delta attribute data and value.
412 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
413 const MCSymbol *Hi, const MCSymbol *Lo) {
414 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
415 Die->addValue(Attribute, Form, Value);
418 /// addDIEEntry - Add a DIE attribute data and value.
420 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
422 Die->addValue(Attribute, Form, createDIEEntry(Entry));
426 /// addBlock - Add block data.
428 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
430 Block->ComputeSize(Asm);
431 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
432 Die->addValue(Attribute, Block->BestForm(), Block);
435 /// addSourceLine - Add location information to specified debug information
437 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
442 unsigned Line = V->getLineNumber();
443 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
444 V->getContext().getFilename());
445 assert(FileID && "Invalid file id");
446 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
447 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
450 /// addSourceLine - Add location information to specified debug information
452 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
453 // Verify global variable.
457 unsigned Line = G->getLineNumber();
458 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
459 G->getContext().getFilename());
460 assert(FileID && "Invalid file id");
461 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
462 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
465 /// addSourceLine - Add location information to specified debug information
467 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
468 // Verify subprogram.
471 // If the line number is 0, don't add it.
472 if (SP->getLineNumber() == 0)
475 unsigned Line = SP->getLineNumber();
476 if (!SP->getContext().Verify())
478 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
480 assert(FileID && "Invalid file id");
481 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
482 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
485 /// addSourceLine - Add location information to specified debug information
487 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
492 unsigned Line = Ty->getLineNumber();
493 if (!Ty->getContext().Verify())
495 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
496 Ty->getContext().getFilename());
497 assert(FileID && "Invalid file id");
498 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
499 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
502 /// addSourceLine - Add location information to specified debug information
504 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
509 unsigned Line = NS->getLineNumber();
510 StringRef FN = NS->getFilename();
511 StringRef Dir = NS->getDirectory();
513 unsigned FileID = GetOrCreateSourceID(Dir, FN);
514 assert(FileID && "Invalid file id");
515 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
516 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
519 /* Byref variables, in Blocks, are declared by the programmer as
520 "SomeType VarName;", but the compiler creates a
521 __Block_byref_x_VarName struct, and gives the variable VarName
522 either the struct, or a pointer to the struct, as its type. This
523 is necessary for various behind-the-scenes things the compiler
524 needs to do with by-reference variables in blocks.
526 However, as far as the original *programmer* is concerned, the
527 variable should still have type 'SomeType', as originally declared.
529 The following function dives into the __Block_byref_x_VarName
530 struct to find the original type of the variable. This will be
531 passed back to the code generating the type for the Debug
532 Information Entry for the variable 'VarName'. 'VarName' will then
533 have the original type 'SomeType' in its debug information.
535 The original type 'SomeType' will be the type of the field named
536 'VarName' inside the __Block_byref_x_VarName struct.
538 NOTE: In order for this to not completely fail on the debugger
539 side, the Debug Information Entry for the variable VarName needs to
540 have a DW_AT_location that tells the debugger how to unwind through
541 the pointers and __Block_byref_x_VarName struct to find the actual
542 value of the variable. The function addBlockByrefType does this. */
544 /// Find the type the programmer originally declared the variable to be
545 /// and return that type.
547 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
550 unsigned tag = Ty.getTag();
552 if (tag == dwarf::DW_TAG_pointer_type) {
553 DIDerivedType DTy = DIDerivedType(Ty);
554 subType = DTy.getTypeDerivedFrom();
557 DICompositeType blockStruct = DICompositeType(subType);
558 DIArray Elements = blockStruct.getTypeArray();
560 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
561 DIDescriptor Element = Elements.getElement(i);
562 DIDerivedType DT = DIDerivedType(Element);
563 if (Name == DT.getName())
564 return (DT.getTypeDerivedFrom());
570 /// addComplexAddress - Start with the address based on the location provided,
571 /// and generate the DWARF information necessary to find the actual variable
572 /// given the extra address information encoded in the DIVariable, starting from
573 /// the starting location. Add the DWARF information to the die.
575 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
577 const MachineLocation &Location) {
578 const DIVariable &VD = DV->getVariable();
579 DIType Ty = VD.getType();
581 // Decode the original location, and use that as the start of the byref
582 // variable's location.
583 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
584 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
585 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
587 if (Location.isReg()) {
589 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
591 Reg = Reg - dwarf::DW_OP_reg0;
592 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
593 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
597 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
599 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
600 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
603 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
606 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
607 uint64_t Element = VD.getAddrElement(i);
609 if (Element == DIFactory::OpPlus) {
610 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
611 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
612 } else if (Element == DIFactory::OpDeref) {
613 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
614 } else llvm_unreachable("unknown DIFactory Opcode");
617 // Now attach the location information to the DIE.
618 addBlock(Die, Attribute, 0, Block);
621 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
622 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
623 gives the variable VarName either the struct, or a pointer to the struct, as
624 its type. This is necessary for various behind-the-scenes things the
625 compiler needs to do with by-reference variables in Blocks.
627 However, as far as the original *programmer* is concerned, the variable
628 should still have type 'SomeType', as originally declared.
630 The function getBlockByrefType dives into the __Block_byref_x_VarName
631 struct to find the original type of the variable, which is then assigned to
632 the variable's Debug Information Entry as its real type. So far, so good.
633 However now the debugger will expect the variable VarName to have the type
634 SomeType. So we need the location attribute for the variable to be an
635 expression that explains to the debugger how to navigate through the
636 pointers and struct to find the actual variable of type SomeType.
638 The following function does just that. We start by getting
639 the "normal" location for the variable. This will be the location
640 of either the struct __Block_byref_x_VarName or the pointer to the
641 struct __Block_byref_x_VarName.
643 The struct will look something like:
645 struct __Block_byref_x_VarName {
647 struct __Block_byref_x_VarName *forwarding;
648 ... <various other fields>
650 ... <maybe more fields>
653 If we are given the struct directly (as our starting point) we
654 need to tell the debugger to:
656 1). Add the offset of the forwarding field.
658 2). Follow that pointer to get the real __Block_byref_x_VarName
659 struct to use (the real one may have been copied onto the heap).
661 3). Add the offset for the field VarName, to find the actual variable.
663 If we started with a pointer to the struct, then we need to
664 dereference that pointer first, before the other steps.
665 Translating this into DWARF ops, we will need to append the following
666 to the current location description for the variable:
668 DW_OP_deref -- optional, if we start with a pointer
669 DW_OP_plus_uconst <forward_fld_offset>
671 DW_OP_plus_uconst <varName_fld_offset>
673 That is what this function does. */
675 /// addBlockByrefAddress - Start with the address based on the location
676 /// provided, and generate the DWARF information necessary to find the
677 /// actual Block variable (navigating the Block struct) based on the
678 /// starting location. Add the DWARF information to the die. For
679 /// more information, read large comment just above here.
681 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
683 const MachineLocation &Location) {
684 const DIVariable &VD = DV->getVariable();
685 DIType Ty = VD.getType();
687 unsigned Tag = Ty.getTag();
688 bool isPointer = false;
690 StringRef varName = VD.getName();
692 if (Tag == dwarf::DW_TAG_pointer_type) {
693 DIDerivedType DTy = DIDerivedType(Ty);
694 TmpTy = DTy.getTypeDerivedFrom();
698 DICompositeType blockStruct = DICompositeType(TmpTy);
700 // Find the __forwarding field and the variable field in the __Block_byref
702 DIArray Fields = blockStruct.getTypeArray();
703 DIDescriptor varField = DIDescriptor();
704 DIDescriptor forwardingField = DIDescriptor();
706 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
707 DIDescriptor Element = Fields.getElement(i);
708 DIDerivedType DT = DIDerivedType(Element);
709 StringRef fieldName = DT.getName();
710 if (fieldName == "__forwarding")
711 forwardingField = Element;
712 else if (fieldName == varName)
716 // Get the offsets for the forwarding field and the variable field.
717 unsigned forwardingFieldOffset =
718 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
719 unsigned varFieldOffset =
720 DIDerivedType(varField).getOffsetInBits() >> 3;
722 // Decode the original location, and use that as the start of the byref
723 // variable's location.
724 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
725 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
726 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
728 if (Location.isReg()) {
730 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
732 Reg = Reg - dwarf::DW_OP_reg0;
733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
734 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
738 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
741 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
744 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
747 // If we started with a pointer to the __Block_byref... struct, then
748 // the first thing we need to do is dereference the pointer (DW_OP_deref).
750 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
752 // Next add the offset for the '__forwarding' field:
753 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
754 // adding the offset if it's 0.
755 if (forwardingFieldOffset > 0) {
756 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
757 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
760 // Now dereference the __forwarding field to get to the real __Block_byref
761 // struct: DW_OP_deref.
762 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
764 // Now that we've got the real __Block_byref... struct, add the offset
765 // for the variable's field to get to the location of the actual variable:
766 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
767 if (varFieldOffset > 0) {
768 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
769 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
772 // Now attach the location information to the DIE.
773 addBlock(Die, Attribute, 0, Block);
776 /// addAddress - Add an address attribute to a die based on the location
778 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
779 const MachineLocation &Location) {
780 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
781 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
782 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
784 if (Location.isReg()) {
786 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
788 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
789 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
795 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
796 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
799 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
802 addBlock(Die, Attribute, 0, Block);
805 /// addRegisterAddress - Add register location entry in variable DIE.
806 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
807 const MachineOperand &MO) {
808 assert (MO.isReg() && "Invalid machine operand!");
811 MachineLocation Location;
812 Location.set(MO.getReg());
813 addAddress(Die, dwarf::DW_AT_location, Location);
815 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
819 /// addConstantValue - Add constant value entry in variable DIE.
820 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
821 const MachineOperand &MO) {
822 assert (MO.isImm() && "Invalid machine operand!");
823 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
824 unsigned Imm = MO.getImm();
825 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
826 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
828 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
832 /// addConstantFPValue - Add constant value entry in variable DIE.
833 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
834 const MachineOperand &MO) {
835 assert (MO.isFPImm() && "Invalid machine operand!");
836 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
837 APFloat FPImm = MO.getFPImm()->getValueAPF();
839 // Get the raw data form of the floating point.
840 const APInt FltVal = FPImm.bitcastToAPInt();
841 const char *FltPtr = (const char*)FltVal.getRawData();
843 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
844 bool LittleEndian = Asm->getTargetData().isLittleEndian();
845 int Incr = (LittleEndian ? 1 : -1);
846 int Start = (LittleEndian ? 0 : NumBytes - 1);
847 int Stop = (LittleEndian ? NumBytes : -1);
849 // Output the constant to DWARF one byte at a time.
850 for (; Start != Stop; Start += Incr)
851 addUInt(Block, 0, dwarf::DW_FORM_data1,
852 (unsigned char)0xFF & FltPtr[Start]);
854 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
856 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
861 /// addToContextOwner - Add Die into the list of its context owner's children.
862 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
863 if (Context.isType()) {
864 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
865 ContextDIE->addChild(Die);
866 } else if (Context.isNameSpace()) {
867 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
868 ContextDIE->addChild(Die);
869 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
870 ContextDIE->addChild(Die);
872 getCompileUnit(Context)->addDie(Die);
875 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
877 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
878 CompileUnit *TypeCU = getCompileUnit(Ty);
879 DIE *TyDIE = TypeCU->getDIE(Ty);
884 TyDIE = new DIE(dwarf::DW_TAG_base_type);
885 TypeCU->insertDIE(Ty, TyDIE);
886 if (Ty.isBasicType())
887 constructTypeDIE(*TyDIE, DIBasicType(Ty));
888 else if (Ty.isCompositeType())
889 constructTypeDIE(*TyDIE, DICompositeType(Ty));
891 assert(Ty.isDerivedType() && "Unknown kind of DIType");
892 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
895 addToContextOwner(TyDIE, Ty.getContext());
899 /// addType - Add a new type attribute to the specified entity.
900 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
904 // Check for pre-existence.
905 CompileUnit *TypeCU = getCompileUnit(Ty);
906 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
907 // If it exists then use the existing value.
909 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
914 DIE *Buffer = getOrCreateTypeDIE(Ty);
917 Entry = createDIEEntry(Buffer);
918 TypeCU->insertDIEEntry(Ty, Entry);
920 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
923 /// constructTypeDIE - Construct basic type die from DIBasicType.
924 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
925 // Get core information.
926 StringRef Name = BTy.getName();
927 Buffer.setTag(dwarf::DW_TAG_base_type);
928 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
931 // Add name if not anonymous or intermediate type.
933 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
934 uint64_t Size = BTy.getSizeInBits() >> 3;
935 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
938 /// constructTypeDIE - Construct derived type die from DIDerivedType.
939 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
940 // Get core information.
941 StringRef Name = DTy.getName();
942 uint64_t Size = DTy.getSizeInBits() >> 3;
943 unsigned Tag = DTy.getTag();
945 // FIXME - Workaround for templates.
946 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
950 // Map to main type, void will not have a type.
951 DIType FromTy = DTy.getTypeDerivedFrom();
952 addType(&Buffer, FromTy);
954 // Add name if not anonymous or intermediate type.
956 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
958 // Add size if non-zero (derived types might be zero-sized.)
960 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
962 // Add source line info if available and TyDesc is not a forward declaration.
963 if (!DTy.isForwardDecl())
964 addSourceLine(&Buffer, &DTy);
967 /// constructTypeDIE - Construct type DIE from DICompositeType.
968 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
969 // Get core information.
970 StringRef Name = CTy.getName();
972 uint64_t Size = CTy.getSizeInBits() >> 3;
973 unsigned Tag = CTy.getTag();
977 case dwarf::DW_TAG_vector_type:
978 case dwarf::DW_TAG_array_type:
979 constructArrayTypeDIE(Buffer, &CTy);
981 case dwarf::DW_TAG_enumeration_type: {
982 DIArray Elements = CTy.getTypeArray();
984 // Add enumerators to enumeration type.
985 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
987 DIDescriptor Enum(Elements.getElement(i));
988 if (Enum.isEnumerator()) {
989 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
990 Buffer.addChild(ElemDie);
995 case dwarf::DW_TAG_subroutine_type: {
997 DIArray Elements = CTy.getTypeArray();
998 DIDescriptor RTy = Elements.getElement(0);
999 addType(&Buffer, DIType(RTy));
1001 // Add prototype flag.
1002 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1005 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1006 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1007 DIDescriptor Ty = Elements.getElement(i);
1008 addType(Arg, DIType(Ty));
1009 Buffer.addChild(Arg);
1013 case dwarf::DW_TAG_structure_type:
1014 case dwarf::DW_TAG_union_type:
1015 case dwarf::DW_TAG_class_type: {
1016 // Add elements to structure type.
1017 DIArray Elements = CTy.getTypeArray();
1019 // A forward struct declared type may not have elements available.
1020 unsigned N = Elements.getNumElements();
1024 // Add elements to structure type.
1025 for (unsigned i = 0; i < N; ++i) {
1026 DIDescriptor Element = Elements.getElement(i);
1027 DIE *ElemDie = NULL;
1028 if (Element.isSubprogram())
1029 ElemDie = createSubprogramDIE(DISubprogram(Element));
1030 else if (Element.isVariable()) {
1031 DIVariable DV(Element);
1032 ElemDie = new DIE(dwarf::DW_TAG_variable);
1033 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1035 addType(ElemDie, DV.getType());
1036 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1037 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1038 addSourceLine(ElemDie, &DV);
1039 } else if (Element.isDerivedType())
1040 ElemDie = createMemberDIE(DIDerivedType(Element));
1043 Buffer.addChild(ElemDie);
1046 if (CTy.isAppleBlockExtension())
1047 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1049 unsigned RLang = CTy.getRunTimeLang();
1051 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1052 dwarf::DW_FORM_data1, RLang);
1054 DICompositeType ContainingType = CTy.getContainingType();
1055 if (DIDescriptor(ContainingType).isCompositeType())
1056 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1057 getOrCreateTypeDIE(DIType(ContainingType)));
1064 // Add name if not anonymous or intermediate type.
1066 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1068 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
1069 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
1070 // Add size if non-zero (derived types might be zero-sized.)
1072 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1074 // Add zero size if it is not a forward declaration.
1075 if (CTy.isForwardDecl())
1076 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1078 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1081 // Add source line info if available.
1082 if (!CTy.isForwardDecl())
1083 addSourceLine(&Buffer, &CTy);
1087 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1088 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1089 int64_t L = SR.getLo();
1090 int64_t H = SR.getHi();
1091 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1093 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1095 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1096 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1098 Buffer.addChild(DW_Subrange);
1101 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1102 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1103 DICompositeType *CTy) {
1104 Buffer.setTag(dwarf::DW_TAG_array_type);
1105 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1106 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1108 // Emit derived type.
1109 addType(&Buffer, CTy->getTypeDerivedFrom());
1110 DIArray Elements = CTy->getTypeArray();
1112 // Get an anonymous type for index type.
1113 CompileUnit *TheCU = getCompileUnit(*CTy);
1114 DIE *IdxTy = TheCU->getIndexTyDie();
1116 // Construct an anonymous type for index type.
1117 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1118 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1119 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1120 dwarf::DW_ATE_signed);
1121 TheCU->addDie(IdxTy);
1122 TheCU->setIndexTyDie(IdxTy);
1125 // Add subranges to array type.
1126 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1127 DIDescriptor Element = Elements.getElement(i);
1128 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1129 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1133 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1134 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1135 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1136 StringRef Name = ETy.getName();
1137 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1138 int64_t Value = ETy.getEnumValue();
1139 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1143 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1144 /// printer to not emit usual symbol prefix before the symbol name is used then
1145 /// return linkage name after skipping this special LLVM prefix.
1146 static StringRef getRealLinkageName(StringRef LinkageName) {
1148 if (LinkageName.startswith(StringRef(&One, 1)))
1149 return LinkageName.substr(1);
1153 /// createGlobalVariableDIE - Create new DIE using GV.
1154 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1155 // If the global variable was optmized out then no need to create debug info
1157 if (!GV.getGlobal()) return NULL;
1158 if (GV.getDisplayName().empty()) return NULL;
1160 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1161 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1162 GV.getDisplayName());
1164 StringRef LinkageName = GV.getLinkageName();
1165 if (!LinkageName.empty())
1166 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1167 getRealLinkageName(LinkageName));
1169 addType(GVDie, GV.getType());
1170 if (!GV.isLocalToUnit())
1171 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1172 addSourceLine(GVDie, &GV);
1177 /// createMemberDIE - Create new member DIE.
1178 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1179 DIE *MemberDie = new DIE(DT.getTag());
1180 StringRef Name = DT.getName();
1182 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1184 addType(MemberDie, DT.getTypeDerivedFrom());
1186 addSourceLine(MemberDie, &DT);
1188 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1189 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1191 uint64_t Size = DT.getSizeInBits();
1192 uint64_t FieldSize = DT.getOriginalTypeSize();
1194 if (Size != FieldSize) {
1196 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1197 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1199 uint64_t Offset = DT.getOffsetInBits();
1200 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1201 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1202 uint64_t FieldOffset = (HiMark - FieldSize);
1203 Offset -= FieldOffset;
1205 // Maybe we need to work from the other end.
1206 if (Asm->getTargetData().isLittleEndian())
1207 Offset = FieldSize - (Offset + Size);
1208 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1210 // Here WD_AT_data_member_location points to the anonymous
1211 // field that includes this bit field.
1212 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1215 // This is not a bitfield.
1216 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1218 if (DT.getTag() == dwarf::DW_TAG_inheritance
1219 && DT.isVirtual()) {
1221 // For C++, virtual base classes are not at fixed offset. Use following
1222 // expression to extract appropriate offset from vtable.
1223 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1225 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1226 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1227 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1228 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1229 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1230 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1231 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1232 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1234 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1237 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1239 if (DT.isProtected())
1240 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1241 dwarf::DW_ACCESS_protected);
1242 else if (DT.isPrivate())
1243 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1244 dwarf::DW_ACCESS_private);
1245 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1246 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1247 dwarf::DW_ACCESS_public);
1249 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1250 dwarf::DW_VIRTUALITY_virtual);
1254 /// createSubprogramDIE - Create new DIE using SP.
1255 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1256 CompileUnit *SPCU = getCompileUnit(SP);
1257 DIE *SPDie = SPCU->getDIE(SP);
1261 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1262 // Constructors and operators for anonymous aggregates do not have names.
1263 if (!SP.getName().empty())
1264 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1266 StringRef LinkageName = SP.getLinkageName();
1267 if (!LinkageName.empty())
1268 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1269 getRealLinkageName(LinkageName));
1271 addSourceLine(SPDie, &SP);
1273 // Add prototyped tag, if C or ObjC.
1274 unsigned Lang = SP.getCompileUnit().getLanguage();
1275 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1276 Lang == dwarf::DW_LANG_ObjC)
1277 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1280 DICompositeType SPTy = SP.getType();
1281 DIArray Args = SPTy.getTypeArray();
1282 unsigned SPTag = SPTy.getTag();
1284 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1285 addType(SPDie, SPTy);
1287 addType(SPDie, DIType(Args.getElement(0)));
1289 unsigned VK = SP.getVirtuality();
1291 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1292 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1293 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1294 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1295 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1296 ContainingTypeMap.insert(std::make_pair(SPDie,
1297 SP.getContainingType()));
1300 if (MakeDecl || !SP.isDefinition()) {
1301 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1303 // Add arguments. Do not add arguments for subprogram definition. They will
1304 // be handled while processing variables.
1305 DICompositeType SPTy = SP.getType();
1306 DIArray Args = SPTy.getTypeArray();
1307 unsigned SPTag = SPTy.getTag();
1309 if (SPTag == dwarf::DW_TAG_subroutine_type)
1310 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1311 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1312 DIType ATy = DIType(DIType(Args.getElement(i)));
1314 if (ATy.isArtificial())
1315 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1316 SPDie->addChild(Arg);
1320 if (SP.isArtificial())
1321 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1323 if (!SP.isLocalToUnit())
1324 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1326 if (SP.isOptimized())
1327 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1329 // DW_TAG_inlined_subroutine may refer to this DIE.
1330 SPCU->insertDIE(SP, SPDie);
1335 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1336 assert(N && "Invalid Scope encoding!");
1338 DbgScope *AScope = AbstractScopes.lookup(N);
1342 DbgScope *Parent = NULL;
1344 DIDescriptor Scope(N);
1345 if (Scope.isLexicalBlock()) {
1346 DILexicalBlock DB(N);
1347 DIDescriptor ParentDesc = DB.getContext();
1348 Parent = getOrCreateAbstractScope(ParentDesc);
1351 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1354 Parent->addScope(AScope);
1355 AScope->setAbstractScope();
1356 AbstractScopes[N] = AScope;
1357 if (DIDescriptor(N).isSubprogram())
1358 AbstractScopesList.push_back(AScope);
1362 /// isSubprogramContext - Return true if Context is either a subprogram
1363 /// or another context nested inside a subprogram.
1364 static bool isSubprogramContext(const MDNode *Context) {
1367 DIDescriptor D(Context);
1368 if (D.isSubprogram())
1371 return isSubprogramContext(DIType(Context).getContext());
1375 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1376 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1377 /// If there are global variables in this scope then create and insert
1378 /// DIEs for these variables.
1379 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1380 CompileUnit *SPCU = getCompileUnit(SPNode);
1381 DIE *SPDie = SPCU->getDIE(SPNode);
1382 assert(SPDie && "Unable to find subprogram DIE!");
1383 DISubprogram SP(SPNode);
1385 // There is not any need to generate specification DIE for a function
1386 // defined at compile unit level. If a function is defined inside another
1387 // function then gdb prefers the definition at top level and but does not
1388 // expect specification DIE in parent function. So avoid creating
1389 // specification DIE for a function defined inside a function.
1390 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1391 !SP.getContext().isFile() &&
1392 !isSubprogramContext(SP.getContext())) {
1393 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1396 DICompositeType SPTy = SP.getType();
1397 DIArray Args = SPTy.getTypeArray();
1398 unsigned SPTag = SPTy.getTag();
1399 if (SPTag == dwarf::DW_TAG_subroutine_type)
1400 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1401 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1402 DIType ATy = DIType(DIType(Args.getElement(i)));
1404 if (ATy.isArtificial())
1405 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1406 SPDie->addChild(Arg);
1408 DIE *SPDeclDie = SPDie;
1409 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1410 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1412 SPCU->addDie(SPDie);
1415 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1416 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1417 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1418 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1419 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1420 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1421 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1426 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1427 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1428 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1430 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1431 if (Scope->isAbstractScope())
1434 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1438 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1439 if (Ranges.size() > 1) {
1440 // .debug_range section has not been laid out yet. Emit offset in
1441 // .debug_range as a uint, size 4, for now. emitDIE will handle
1442 // DW_AT_ranges appropriately.
1443 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1444 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1445 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1446 RE = Ranges.end(); RI != RE; ++RI) {
1447 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1448 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1450 DebugRangeSymbols.push_back(NULL);
1451 DebugRangeSymbols.push_back(NULL);
1455 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1456 const MCSymbol *End = getLabelAfterInsn(RI->second);
1458 if (End == 0) return 0;
1460 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1461 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1463 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1464 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1469 /// constructInlinedScopeDIE - This scope represents inlined body of
1470 /// a function. Construct DIE to represent this concrete inlined copy
1471 /// of the function.
1472 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1474 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1475 assert (Ranges.empty() == false
1476 && "DbgScope does not have instruction markers!");
1478 // FIXME : .debug_inlined section specification does not clearly state how
1479 // to emit inlined scope that is split into multiple instruction ranges.
1480 // For now, use first instruction range and emit low_pc/high_pc pair and
1481 // corresponding .debug_inlined section entry for this pair.
1482 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1483 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1484 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1486 if (StartLabel == FunctionBeginSym || EndLabel == 0) {
1487 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1490 assert(StartLabel->isDefined() &&
1491 "Invalid starting label for an inlined scope!");
1492 assert(EndLabel->isDefined() &&
1493 "Invalid end label for an inlined scope!");
1495 if (!Scope->getScopeNode())
1497 DIScope DS(Scope->getScopeNode());
1498 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1500 DISubprogram InlinedSP = getDISubprogram(DS);
1501 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1502 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1503 assert(OriginDIE && "Unable to find Origin DIE!");
1504 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1505 dwarf::DW_FORM_ref4, OriginDIE);
1507 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1508 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1510 InlinedSubprogramDIEs.insert(OriginDIE);
1512 // Track the start label for this inlined function.
1513 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1514 I = InlineInfo.find(InlinedSP);
1516 if (I == InlineInfo.end()) {
1517 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1519 InlinedSPNodes.push_back(InlinedSP);
1521 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1523 DILocation DL(Scope->getInlinedAt());
1524 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1525 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1531 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1532 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1533 // Get the descriptor.
1534 const DIVariable &VD = DV->getVariable();
1535 StringRef Name = VD.getName();
1539 // Translate tag to proper Dwarf tag. The result variable is dropped for
1542 switch (VD.getTag()) {
1543 case dwarf::DW_TAG_return_variable:
1545 case dwarf::DW_TAG_arg_variable:
1546 Tag = dwarf::DW_TAG_formal_parameter;
1548 case dwarf::DW_TAG_auto_variable: // fall thru
1550 Tag = dwarf::DW_TAG_variable;
1554 // Define variable debug information entry.
1555 DIE *VariableDie = new DIE(Tag);
1558 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1559 V2AVI = VarToAbstractVarMap.find(DV);
1560 if (V2AVI != VarToAbstractVarMap.end())
1561 AbsDIE = V2AVI->second->getDIE();
1564 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1565 dwarf::DW_FORM_ref4, AbsDIE);
1567 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1568 addSourceLine(VariableDie, &VD);
1570 // Add variable type.
1571 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1572 // addresses instead.
1573 if (VD.isBlockByrefVariable())
1574 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1576 addType(VariableDie, VD.getType());
1579 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1580 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1582 if (Scope->isAbstractScope()) {
1583 DV->setDIE(VariableDie);
1587 // Add variable address.
1589 unsigned Offset = DV->getDotDebugLocOffset();
1590 if (Offset != ~0U) {
1591 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1592 Asm->GetTempSymbol("debug_loc", Offset));
1593 DV->setDIE(VariableDie);
1594 UseDotDebugLocEntry.insert(VariableDie);
1598 // Check if variable is described by a DBG_VALUE instruction.
1599 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1600 DbgVariableToDbgInstMap.find(DV);
1601 if (DVI != DbgVariableToDbgInstMap.end()) {
1602 const MachineInstr *DVInsn = DVI->second;
1603 const MCSymbol *DVLabel = findVariableLabel(DV);
1604 bool updated = false;
1605 // FIXME : Handle getNumOperands != 3
1606 if (DVInsn->getNumOperands() == 3) {
1607 if (DVInsn->getOperand(0).isReg())
1608 updated = addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1609 else if (DVInsn->getOperand(0).isImm())
1610 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1611 else if (DVInsn->getOperand(0).isFPImm())
1612 updated = addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1614 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1615 if (Location.getReg()) {
1616 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1618 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1624 // If variableDie is not updated then DBG_VALUE instruction does not
1625 // have valid variable info.
1629 DV->setDIE(VariableDie);
1633 // .. else use frame index, if available.
1634 MachineLocation Location;
1636 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1638 if (findVariableFrameIndex(DV, &FI)) {
1639 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1640 Location.set(FrameReg, Offset);
1642 if (VD.hasComplexAddress())
1643 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1644 else if (VD.isBlockByrefVariable())
1645 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1647 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1649 DV->setDIE(VariableDie);
1654 void DwarfDebug::addPubTypes(DISubprogram SP) {
1655 DICompositeType SPTy = SP.getType();
1656 unsigned SPTag = SPTy.getTag();
1657 if (SPTag != dwarf::DW_TAG_subroutine_type)
1660 DIArray Args = SPTy.getTypeArray();
1661 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1662 DIType ATy(Args.getElement(i));
1665 DICompositeType CATy = getDICompositeType(ATy);
1666 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1667 && !CATy.isForwardDecl()) {
1668 CompileUnit *TheCU = getCompileUnit(CATy);
1669 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1670 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1675 /// constructScopeDIE - Construct a DIE for this scope.
1676 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1677 if (!Scope || !Scope->getScopeNode())
1680 DIScope DS(Scope->getScopeNode());
1681 DIE *ScopeDIE = NULL;
1682 if (Scope->getInlinedAt())
1683 ScopeDIE = constructInlinedScopeDIE(Scope);
1684 else if (DS.isSubprogram()) {
1685 if (Scope->isAbstractScope())
1686 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1688 ScopeDIE = updateSubprogramScopeDIE(DS);
1691 ScopeDIE = constructLexicalScopeDIE(Scope);
1692 if (!ScopeDIE) return NULL;
1694 // Add variables to scope.
1695 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1696 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1697 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1699 ScopeDIE->addChild(VariableDIE);
1702 // Add nested scopes.
1703 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1704 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1705 // Define the Scope debug information entry.
1706 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1708 ScopeDIE->addChild(NestedDIE);
1711 if (DS.isSubprogram())
1712 addPubTypes(DISubprogram(DS));
1717 /// GetOrCreateSourceID - Look up the source id with the given directory and
1718 /// source file names. If none currently exists, create a new id and insert it
1719 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1721 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1723 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1724 if (DI != DirectoryIdMap.end()) {
1725 DId = DI->getValue();
1727 DId = DirectoryNames.size() + 1;
1728 DirectoryIdMap[DirName] = DId;
1729 DirectoryNames.push_back(DirName);
1733 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1734 if (FI != SourceFileIdMap.end()) {
1735 FId = FI->getValue();
1737 FId = SourceFileNames.size() + 1;
1738 SourceFileIdMap[FileName] = FId;
1739 SourceFileNames.push_back(FileName);
1742 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1743 SourceIdMap.find(std::make_pair(DId, FId));
1744 if (SI != SourceIdMap.end())
1747 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1748 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1749 SourceIds.push_back(std::make_pair(DId, FId));
1754 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1755 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1756 CompileUnit *TheCU = getCompileUnit(NS);
1757 DIE *NDie = TheCU->getDIE(NS);
1760 NDie = new DIE(dwarf::DW_TAG_namespace);
1761 TheCU->insertDIE(NS, NDie);
1762 if (!NS.getName().empty())
1763 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1764 addSourceLine(NDie, &NS);
1765 addToContextOwner(NDie, NS.getContext());
1769 /// constructCompileUnit - Create new CompileUnit for the given
1770 /// metadata node with tag DW_TAG_compile_unit.
1771 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1772 DICompileUnit DIUnit(N);
1773 StringRef FN = DIUnit.getFilename();
1774 StringRef Dir = DIUnit.getDirectory();
1775 unsigned ID = GetOrCreateSourceID(Dir, FN);
1777 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1778 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1779 DIUnit.getProducer());
1780 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1781 DIUnit.getLanguage());
1782 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1783 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1784 // simplifies debug range entries.
1785 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_data4, 0);
1786 // DW_AT_stmt_list is a offset of line number information for this
1787 // compile unit in debug_line section. It is always zero when only one
1788 // compile unit is emitted in one object file.
1789 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1792 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1793 if (DIUnit.isOptimized())
1794 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1796 StringRef Flags = DIUnit.getFlags();
1798 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1800 unsigned RVer = DIUnit.getRunTimeVersion();
1802 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1803 dwarf::DW_FORM_data1, RVer);
1805 CompileUnit *NewCU = new CompileUnit(ID, Die);
1808 CUMap.insert(std::make_pair(N, NewCU));
1811 /// getCompielUnit - Get CompileUnit DIE.
1812 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1813 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1815 const MDNode *CUNode = NULL;
1816 if (D.isCompileUnit())
1818 else if (D.isSubprogram())
1819 CUNode = DISubprogram(N).getCompileUnit();
1820 else if (D.isType())
1821 CUNode = DIType(N).getCompileUnit();
1822 else if (D.isGlobalVariable())
1823 CUNode = DIGlobalVariable(N).getCompileUnit();
1824 else if (D.isVariable())
1825 CUNode = DIVariable(N).getCompileUnit();
1826 else if (D.isNameSpace())
1827 CUNode = DINameSpace(N).getCompileUnit();
1828 else if (D.isFile())
1829 CUNode = DIFile(N).getCompileUnit();
1833 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1834 = CUMap.find(CUNode);
1835 if (I == CUMap.end())
1841 /// constructGlobalVariableDIE - Construct global variable DIE.
1842 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1843 DIGlobalVariable DI_GV(N);
1845 // If debug information is malformed then ignore it.
1846 if (DI_GV.Verify() == false)
1849 // Check for pre-existence.
1850 CompileUnit *TheCU = getCompileUnit(N);
1851 if (TheCU->getDIE(DI_GV))
1854 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1859 TheCU->insertDIE(N, VariableDie);
1861 // Add to context owner.
1862 DIDescriptor GVContext = DI_GV.getContext();
1863 // Do not create specification DIE if context is either compile unit
1865 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1866 !GVContext.isFile() &&
1867 !isSubprogramContext(GVContext)) {
1868 // Create specification DIE.
1869 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1870 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1871 dwarf::DW_FORM_ref4, VariableDie);
1872 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1873 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1874 addLabel(Block, 0, dwarf::DW_FORM_udata,
1875 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1876 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1877 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1878 TheCU->addDie(VariableSpecDIE);
1880 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1881 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1882 addLabel(Block, 0, dwarf::DW_FORM_udata,
1883 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1884 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1886 addToContextOwner(VariableDie, GVContext);
1888 // Expose as global. FIXME - need to check external flag.
1889 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1891 DIType GTy = DI_GV.getType();
1892 if (GTy.isCompositeType() && !GTy.getName().empty()
1893 && !GTy.isForwardDecl()) {
1894 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1895 assert(Entry && "Missing global type!");
1896 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1901 /// construct SubprogramDIE - Construct subprogram DIE.
1902 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1905 // Check for pre-existence.
1906 CompileUnit *TheCU = getCompileUnit(N);
1907 if (TheCU->getDIE(N))
1910 if (!SP.isDefinition())
1911 // This is a method declaration which will be handled while constructing
1915 DIE *SubprogramDie = createSubprogramDIE(SP);
1918 TheCU->insertDIE(N, SubprogramDie);
1920 // Add to context owner.
1921 addToContextOwner(SubprogramDie, SP.getContext());
1923 // Expose as global.
1924 TheCU->addGlobal(SP.getName(), SubprogramDie);
1929 /// beginModule - Emit all Dwarf sections that should come prior to the
1930 /// content. Create global DIEs and emit initial debug info sections.
1931 /// This is inovked by the target AsmPrinter.
1932 void DwarfDebug::beginModule(Module *M) {
1933 if (DisableDebugInfoPrinting)
1936 DebugInfoFinder DbgFinder;
1937 DbgFinder.processModule(*M);
1939 bool HasDebugInfo = false;
1941 // Scan all the compile-units to see if there are any marked as the main unit.
1942 // if not, we do not generate debug info.
1943 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1944 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1945 if (DICompileUnit(*I).isMain()) {
1946 HasDebugInfo = true;
1951 if (!HasDebugInfo) return;
1953 // Tell MMI that we have debug info.
1954 MMI->setDebugInfoAvailability(true);
1956 // Emit initial sections.
1957 EmitSectionLabels();
1959 // Create all the compile unit DIEs.
1960 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1961 E = DbgFinder.compile_unit_end(); I != E; ++I)
1962 constructCompileUnit(*I);
1964 // Create DIEs for each subprogram.
1965 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1966 E = DbgFinder.subprogram_end(); I != E; ++I)
1967 constructSubprogramDIE(*I);
1969 // Create DIEs for each global variable.
1970 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1971 E = DbgFinder.global_variable_end(); I != E; ++I)
1972 constructGlobalVariableDIE(*I);
1974 // Prime section data.
1975 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1977 // Print out .file directives to specify files for .loc directives. These are
1978 // printed out early so that they precede any .loc directives.
1979 if (Asm->MAI->hasDotLocAndDotFile()) {
1980 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1981 // Remember source id starts at 1.
1982 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1983 // FIXME: don't use sys::path for this! This should not depend on the
1985 sys::Path FullPath(getSourceDirectoryName(Id.first));
1987 FullPath.appendComponent(getSourceFileName(Id.second));
1988 assert(AppendOk && "Could not append filename to directory!");
1990 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1995 /// endModule - Emit all Dwarf sections that should come after the content.
1997 void DwarfDebug::endModule() {
1998 if (!FirstCU) return;
2000 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2001 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2002 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2004 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2007 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2008 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2009 DIE *SPDie = CI->first;
2010 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2012 DIE *NDie = getCompileUnit(N)->getDIE(N);
2013 if (!NDie) continue;
2014 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2017 // Standard sections final addresses.
2018 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2019 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2020 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2021 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2023 // End text sections.
2024 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2025 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2026 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2029 // Emit common frame information.
2030 emitCommonDebugFrame();
2032 // Emit function debug frame information
2033 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2034 E = DebugFrames.end(); I != E; ++I)
2035 emitFunctionDebugFrame(*I);
2037 // Compute DIE offsets and sizes.
2038 computeSizeAndOffsets();
2040 // Emit all the DIEs into a debug info section
2043 // Corresponding abbreviations into a abbrev section.
2044 emitAbbreviations();
2046 // Emit source line correspondence into a debug line section.
2049 // Emit info into a debug pubnames section.
2050 emitDebugPubNames();
2052 // Emit info into a debug pubtypes section.
2053 emitDebugPubTypes();
2055 // Emit info into a debug loc section.
2058 // Emit info into a debug aranges section.
2061 // Emit info into a debug ranges section.
2064 // Emit info into a debug macinfo section.
2067 // Emit inline info.
2068 emitDebugInlineInfo();
2070 // Emit info into a debug str section.
2073 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2074 E = CUMap.end(); I != E; ++I)
2076 FirstCU = NULL; // Reset for the next Module, if any.
2079 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2080 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2081 DebugLoc ScopeLoc) {
2083 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2085 return AbsDbgVariable;
2087 LLVMContext &Ctx = Var->getContext();
2088 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2092 AbsDbgVariable = new DbgVariable(Var);
2093 Scope->addVariable(AbsDbgVariable);
2094 AbstractVariables[Var] = AbsDbgVariable;
2095 return AbsDbgVariable;
2098 /// collectVariableInfoFromMMITable - Collect variable information from
2099 /// side table maintained by MMI.
2101 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2102 SmallPtrSet<const MDNode *, 16> &Processed) {
2103 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2104 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2105 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2106 VE = VMap.end(); VI != VE; ++VI) {
2107 const MDNode *Var = VI->first;
2109 Processed.insert(Var);
2111 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2113 DbgScope *Scope = 0;
2114 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2115 Scope = ConcreteScopes.lookup(IA);
2117 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2119 // If variable scope is not found then skip this variable.
2123 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2124 DbgVariable *RegVar = new DbgVariable(DV);
2125 recordVariableFrameIndex(RegVar, VP.first);
2126 Scope->addVariable(RegVar);
2127 if (AbsDbgVariable) {
2128 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2129 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2134 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2135 /// DBG_VALUE instruction, is in undefined reg.
2136 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2137 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2138 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2143 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2144 /// DBG_VALUE instruction, is in a defined reg.
2145 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2146 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2147 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2152 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2153 void DwarfDebug::collectVariableInfo(const MachineFunction *MF) {
2154 SmallPtrSet<const MDNode *, 16> Processed;
2156 /// collection info from MMI table.
2157 collectVariableInfoFromMMITable(MF, Processed);
2159 SmallVector<const MachineInstr *, 8> DbgValues;
2160 // Collect variable information from DBG_VALUE machine instructions;
2161 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2163 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2165 const MachineInstr *MInsn = II;
2166 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2168 DbgValues.push_back(MInsn);
2171 // This is a collection of DBV_VALUE instructions describing same variable.
2172 SmallVector<const MachineInstr *, 4> MultipleValues;
2173 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2174 E = DbgValues.end(); I != E; ++I) {
2175 const MachineInstr *MInsn = *I;
2176 MultipleValues.clear();
2177 if (isDbgValueInDefinedReg(MInsn))
2178 MultipleValues.push_back(MInsn);
2179 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2180 if (Processed.count(DV) != 0)
2183 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2184 ME = DbgValues.end(); MI != ME; ++MI) {
2186 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2187 if (Var == DV && isDbgValueInDefinedReg(*MI))
2188 MultipleValues.push_back(*MI);
2191 DbgScope *Scope = findDbgScope(MInsn);
2192 bool CurFnArg = false;
2193 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2194 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2196 if (!Scope && CurFnArg)
2197 Scope = CurrentFnDbgScope;
2198 // If variable scope is not found then skip this variable.
2202 Processed.insert(DV);
2203 DbgVariable *RegVar = new DbgVariable(DV);
2204 Scope->addVariable(RegVar);
2206 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2207 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2208 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2209 VarToAbstractVarMap[RegVar] = AbsVar;
2211 if (MultipleValues.size() <= 1) {
2212 DbgVariableToDbgInstMap[RegVar] = MInsn;
2216 // handle multiple DBG_VALUE instructions describing one variable.
2217 if (DotDebugLocEntries.empty())
2218 RegVar->setDotDebugLocOffset(0);
2220 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2221 const MachineInstr *Begin = NULL;
2222 const MachineInstr *End = NULL;
2223 for (SmallVector<const MachineInstr *, 4>::iterator
2224 MVI = MultipleValues.begin(), MVE = MultipleValues.end(); MVI != MVE; ++MVI) {
2230 MachineLocation MLoc;
2231 MLoc.set(Begin->getOperand(0).getReg(), 0);
2232 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2233 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2234 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2236 if (MVI + 1 == MVE) {
2237 // If End is the last instruction then its value is valid
2238 // until the end of the funtion.
2239 MLoc.set(End->getOperand(0).getReg(), 0);
2241 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2244 DotDebugLocEntries.push_back(DotDebugLocEntry());
2247 // Collect info for variables that were optimized out.
2248 if (NamedMDNode *NMD =
2249 MF->getFunction()->getParent()->getNamedMetadata("llvm.dbg.lv")) {
2250 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2251 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2252 if (!DV || !Processed.insert(DV))
2254 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2256 Scope->addVariable(new DbgVariable(DV));
2261 /// getLabelBeforeInsn - Return Label preceding the instruction.
2262 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2263 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2264 LabelsBeforeInsn.find(MI);
2265 if (I == LabelsBeforeInsn.end())
2266 // FunctionBeginSym always preceeds all the instruction in current function.
2267 return FunctionBeginSym;
2271 /// getLabelAfterInsn - Return Label immediately following the instruction.
2272 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2273 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2274 LabelsAfterInsn.find(MI);
2275 if (I == LabelsAfterInsn.end())
2280 /// beginScope - Process beginning of a scope.
2281 void DwarfDebug::beginScope(const MachineInstr *MI) {
2282 if (InsnNeedsLabel.count(MI) == 0) {
2283 LabelsBeforeInsn[MI] = PrevLabel;
2288 DebugLoc DL = MI->getDebugLoc();
2289 if (!DL.isUnknown()) {
2290 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2291 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2293 LabelsBeforeInsn[MI] = PrevLabel;
2297 // If location is unknown then use temp label for this DBG_VALUE
2299 if (MI->isDebugValue()) {
2300 PrevLabel = MMI->getContext().CreateTempSymbol();
2301 Asm->OutStreamer.EmitLabel(PrevLabel);
2302 LabelsBeforeInsn[MI] = PrevLabel;
2306 if (UnknownLocations) {
2307 PrevLabel = recordSourceLine(0, 0, 0);
2308 LabelsBeforeInsn[MI] = PrevLabel;
2312 assert (0 && "Instruction is not processed!");
2315 /// endScope - Process end of a scope.
2316 void DwarfDebug::endScope(const MachineInstr *MI) {
2317 if (InsnsEndScopeSet.count(MI) != 0) {
2318 // Emit a label if this instruction ends a scope.
2319 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2320 Asm->OutStreamer.EmitLabel(Label);
2321 LabelsAfterInsn[MI] = Label;
2325 /// getOrCreateDbgScope - Create DbgScope for the scope.
2326 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, const MDNode *InlinedAt) {
2328 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2331 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2332 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2333 if (DIDescriptor(Scope).isLexicalBlock()) {
2335 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2336 WScope->setParent(Parent);
2337 Parent->addScope(WScope);
2340 if (!WScope->getParent()) {
2341 StringRef SPName = DISubprogram(Scope).getLinkageName();
2342 if (SPName == Asm->MF->getFunction()->getName())
2343 CurrentFnDbgScope = WScope;
2349 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2353 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2354 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2355 DILocation DL(InlinedAt);
2357 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2358 WScope->setParent(Parent);
2359 Parent->addScope(WScope);
2361 ConcreteScopes[InlinedAt] = WScope;
2362 getOrCreateAbstractScope(Scope);
2367 /// hasValidLocation - Return true if debug location entry attached with
2368 /// machine instruction encodes valid location info.
2369 static bool hasValidLocation(LLVMContext &Ctx,
2370 const MachineInstr *MInsn,
2371 const MDNode *&Scope, const MDNode *&InlinedAt) {
2372 if (MInsn->isDebugValue())
2374 DebugLoc DL = MInsn->getDebugLoc();
2375 if (DL.isUnknown()) return false;
2377 const MDNode *S = DL.getScope(Ctx);
2379 // There is no need to create another DIE for compile unit. For all
2380 // other scopes, create one DbgScope now. This will be translated
2381 // into a scope DIE at the end.
2382 if (DIScope(S).isCompileUnit()) return false;
2385 InlinedAt = DL.getInlinedAt(Ctx);
2389 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2391 static void calculateDominanceGraph(DbgScope *Scope) {
2392 assert (Scope && "Unable to calculate scop edominance graph!");
2393 SmallVector<DbgScope *, 4> WorkStack;
2394 WorkStack.push_back(Scope);
2395 unsigned Counter = 0;
2396 while (!WorkStack.empty()) {
2397 DbgScope *WS = WorkStack.back();
2398 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2399 bool visitedChildren = false;
2400 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2401 SE = Children.end(); SI != SE; ++SI) {
2402 DbgScope *ChildScope = *SI;
2403 if (!ChildScope->getDFSOut()) {
2404 WorkStack.push_back(ChildScope);
2405 visitedChildren = true;
2406 ChildScope->setDFSIn(++Counter);
2410 if (!visitedChildren) {
2411 WorkStack.pop_back();
2412 WS->setDFSOut(++Counter);
2417 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2419 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2420 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2423 unsigned PrevDFSIn = 0;
2424 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2426 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2428 const MachineInstr *MInsn = II;
2429 const MDNode *Scope = NULL;
2430 const MDNode *InlinedAt = NULL;
2432 // Check if instruction has valid location information.
2433 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2437 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2438 MI2ScopeMap.find(MInsn);
2439 if (DI != MI2ScopeMap.end()) {
2440 DbgScope *S = DI->second;
2441 dbgs() << S->getDFSIn();
2442 PrevDFSIn = S->getDFSIn();
2444 dbgs() << PrevDFSIn;
2446 dbgs() << " [ x" << PrevDFSIn;
2454 /// extractScopeInformation - Scan machine instructions in this function
2455 /// and collect DbgScopes. Return true, if at least one scope was found.
2456 bool DwarfDebug::extractScopeInformation() {
2457 // If scope information was extracted using .dbg intrinsics then there is not
2458 // any need to extract these information by scanning each instruction.
2459 if (!DbgScopeMap.empty())
2462 // Scan each instruction and create scopes. First build working set of scopes.
2463 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2464 SmallVector<DbgRange, 4> MIRanges;
2465 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2466 const MDNode *PrevScope = NULL;
2467 const MDNode *PrevInlinedAt = NULL;
2468 const MachineInstr *RangeBeginMI = NULL;
2469 const MachineInstr *PrevMI = NULL;
2470 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2472 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2474 const MachineInstr *MInsn = II;
2475 const MDNode *Scope = NULL;
2476 const MDNode *InlinedAt = NULL;
2478 // Check if instruction has valid location information.
2479 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2484 // If scope has not changed then skip this instruction.
2485 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2491 // If we have alread seen a beginning of a instruction range and
2492 // current instruction scope does not match scope of first instruction
2493 // in this range then create a new instruction range.
2494 DbgRange R(RangeBeginMI, PrevMI);
2495 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2496 MIRanges.push_back(R);
2499 // This is a beginning of a new instruction range.
2500 RangeBeginMI = MInsn;
2502 // Reset previous markers.
2505 PrevInlinedAt = InlinedAt;
2509 // Create last instruction range.
2510 if (RangeBeginMI && PrevMI && PrevScope) {
2511 DbgRange R(RangeBeginMI, PrevMI);
2512 MIRanges.push_back(R);
2513 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2516 if (!CurrentFnDbgScope)
2519 calculateDominanceGraph(CurrentFnDbgScope);
2521 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2523 // Find ranges of instructions covered by each DbgScope;
2524 DbgScope *PrevDbgScope = NULL;
2525 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2526 RE = MIRanges.end(); RI != RE; ++RI) {
2527 const DbgRange &R = *RI;
2528 DbgScope *S = MI2ScopeMap.lookup(R.first);
2529 assert (S && "Lost DbgScope for a machine instruction!");
2530 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2531 PrevDbgScope->closeInsnRange(S);
2532 S->openInsnRange(R.first);
2533 S->extendInsnRange(R.second);
2538 PrevDbgScope->closeInsnRange();
2540 identifyScopeMarkers();
2542 return !DbgScopeMap.empty();
2545 /// identifyScopeMarkers() -
2546 /// Each DbgScope has first instruction and last instruction to mark beginning
2547 /// and end of a scope respectively. Create an inverse map that list scopes
2548 /// starts (and ends) with an instruction. One instruction may start (or end)
2549 /// multiple scopes. Ignore scopes that are not reachable.
2550 void DwarfDebug::identifyScopeMarkers() {
2551 SmallVector<DbgScope *, 4> WorkList;
2552 WorkList.push_back(CurrentFnDbgScope);
2553 while (!WorkList.empty()) {
2554 DbgScope *S = WorkList.pop_back_val();
2556 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2557 if (!Children.empty())
2558 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2559 SE = Children.end(); SI != SE; ++SI)
2560 WorkList.push_back(*SI);
2562 if (S->isAbstractScope())
2565 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2568 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2569 RE = Ranges.end(); RI != RE; ++RI) {
2570 assert(RI->first && "DbgRange does not have first instruction!");
2571 assert(RI->second && "DbgRange does not have second instruction!");
2572 InsnsBeginScopeSet.insert(RI->first);
2573 InsnsEndScopeSet.insert(RI->second);
2578 /// FindFirstDebugLoc - Find the first debug location in the function. This
2579 /// is intended to be an approximation for the source position of the
2580 /// beginning of the function.
2581 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2582 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2584 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2585 MBBI != MBBE; ++MBBI) {
2586 DebugLoc DL = MBBI->getDebugLoc();
2587 if (!DL.isUnknown())
2593 /// beginFunction - Gather pre-function debug information. Assumes being
2594 /// emitted immediately after the function entry point.
2595 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2596 if (!MMI->hasDebugInfo()) return;
2597 if (!extractScopeInformation()) return;
2599 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2600 Asm->getFunctionNumber());
2601 // Assumes in correct section after the entry point.
2602 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2604 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2606 DebugLoc FDL = FindFirstDebugLoc(MF);
2607 if (FDL.isUnknown()) return;
2609 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2611 DISubprogram SP = getDISubprogram(Scope);
2614 Line = SP.getLineNumber();
2617 Line = FDL.getLine();
2621 recordSourceLine(Line, Col, Scope);
2624 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2626 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2628 const MachineInstr *MI = II;
2629 DebugLoc DL = MI->getDebugLoc();
2630 if (MI->isDebugValue()) {
2631 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2632 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2633 if (!DV.Verify()) continue;
2634 // If DBG_VALUE is for a local variable then it needs a label.
2635 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2636 InsnNeedsLabel.insert(MI);
2637 // DBG_VALUE for inlined functions argument needs a label.
2638 else if (!DISubprogram(DV.getContext()).describes(MF->getFunction()))
2639 InsnNeedsLabel.insert(MI);
2640 // DBG_VALUE indicating argument location change needs a label.
2641 else if (!ProcessedArgs.insert(DV))
2642 InsnNeedsLabel.insert(MI);
2644 // If location is unknown then instruction needs a location only if
2645 // UnknownLocations flag is set.
2646 if (DL.isUnknown()) {
2647 if (UnknownLocations && !PrevLoc.isUnknown())
2648 InsnNeedsLabel.insert(MI);
2649 } else if (DL != PrevLoc)
2650 // Otherwise, instruction needs a location only if it is new location.
2651 InsnNeedsLabel.insert(MI);
2654 if (!DL.isUnknown() || UnknownLocations)
2658 PrevLabel = FunctionBeginSym;
2661 /// endFunction - Gather and emit post-function debug information.
2663 void DwarfDebug::endFunction(const MachineFunction *MF) {
2664 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2666 if (CurrentFnDbgScope) {
2668 // Define end label for subprogram.
2669 FunctionEndSym = Asm->GetTempSymbol("func_end",
2670 Asm->getFunctionNumber());
2671 // Assumes in correct section after the entry point.
2672 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2674 collectVariableInfo(MF);
2676 // Get function line info.
2677 if (!Lines.empty()) {
2678 // Get section line info.
2679 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2680 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2681 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2682 // Append the function info to section info.
2683 SectionLineInfos.insert(SectionLineInfos.end(),
2684 Lines.begin(), Lines.end());
2687 // Construct abstract scopes.
2688 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2689 AE = AbstractScopesList.end(); AI != AE; ++AI)
2690 constructScopeDIE(*AI);
2692 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2694 if (!DisableFramePointerElim(*MF))
2695 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2696 dwarf::DW_FORM_flag, 1);
2699 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2700 MMI->getFrameMoves()));
2704 CurrentFnDbgScope = NULL;
2705 InsnNeedsLabel.clear();
2706 ProcessedArgs.clear();
2707 DbgVariableToFrameIndexMap.clear();
2708 VarToAbstractVarMap.clear();
2709 DbgVariableToDbgInstMap.clear();
2710 DbgVariableLabelsMap.clear();
2711 DeleteContainerSeconds(DbgScopeMap);
2712 InsnsBeginScopeSet.clear();
2713 InsnsEndScopeSet.clear();
2714 ConcreteScopes.clear();
2715 DeleteContainerSeconds(AbstractScopes);
2716 AbstractScopesList.clear();
2717 AbstractVariables.clear();
2718 LabelsBeforeInsn.clear();
2719 LabelsAfterInsn.clear();
2724 /// recordVariableFrameIndex - Record a variable's index.
2725 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2726 assert (V && "Invalid DbgVariable!");
2727 DbgVariableToFrameIndexMap[V] = Index;
2730 /// findVariableFrameIndex - Return true if frame index for the variable
2731 /// is found. Update FI to hold value of the index.
2732 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2733 assert (V && "Invalid DbgVariable!");
2734 DenseMap<const DbgVariable *, int>::iterator I =
2735 DbgVariableToFrameIndexMap.find(V);
2736 if (I == DbgVariableToFrameIndexMap.end())
2742 /// findVariableLabel - Find MCSymbol for the variable.
2743 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2744 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2745 = DbgVariableLabelsMap.find(V);
2746 if (I == DbgVariableLabelsMap.end())
2748 else return I->second;
2751 /// findDbgScope - Find DbgScope for the debug loc attached with an
2753 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2754 DbgScope *Scope = NULL;
2756 MInsn->getParent()->getParent()->getFunction()->getContext();
2757 DebugLoc DL = MInsn->getDebugLoc();
2762 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2763 Scope = ConcreteScopes.lookup(IA);
2765 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2771 /// recordSourceLine - Register a source line with debug info. Returns the
2772 /// unique label that was emitted and which provides correspondence to
2773 /// the source line list.
2774 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S) {
2780 DIDescriptor Scope(S);
2782 if (Scope.isCompileUnit()) {
2783 DICompileUnit CU(S);
2784 Dir = CU.getDirectory();
2785 Fn = CU.getFilename();
2786 } else if (Scope.isSubprogram()) {
2788 Dir = SP.getDirectory();
2789 Fn = SP.getFilename();
2790 } else if (Scope.isLexicalBlock()) {
2791 DILexicalBlock DB(S);
2792 Dir = DB.getDirectory();
2793 Fn = DB.getFilename();
2795 assert(0 && "Unexpected scope info");
2797 Src = GetOrCreateSourceID(Dir, Fn);
2800 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2801 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2803 Asm->OutStreamer.EmitLabel(Label);
2807 //===----------------------------------------------------------------------===//
2809 //===----------------------------------------------------------------------===//
2811 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2814 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2815 // Get the children.
2816 const std::vector<DIE *> &Children = Die->getChildren();
2818 // If not last sibling and has children then add sibling offset attribute.
2819 if (!Last && !Children.empty())
2820 Die->addSiblingOffset(DIEValueAllocator);
2822 // Record the abbreviation.
2823 assignAbbrevNumber(Die->getAbbrev());
2825 // Get the abbreviation for this DIE.
2826 unsigned AbbrevNumber = Die->getAbbrevNumber();
2827 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2830 Die->setOffset(Offset);
2832 // Start the size with the size of abbreviation code.
2833 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2835 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2836 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2838 // Size the DIE attribute values.
2839 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2840 // Size attribute value.
2841 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2843 // Size the DIE children if any.
2844 if (!Children.empty()) {
2845 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2846 "Children flag not set");
2848 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2849 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2851 // End of children marker.
2852 Offset += sizeof(int8_t);
2855 Die->setSize(Offset - Die->getOffset());
2859 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2861 void DwarfDebug::computeSizeAndOffsets() {
2862 unsigned PrevOffset = 0;
2863 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2864 E = CUMap.end(); I != E; ++I) {
2865 // Compute size of compile unit header.
2866 static unsigned Offset = PrevOffset +
2867 sizeof(int32_t) + // Length of Compilation Unit Info
2868 sizeof(int16_t) + // DWARF version number
2869 sizeof(int32_t) + // Offset Into Abbrev. Section
2870 sizeof(int8_t); // Pointer Size (in bytes)
2871 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2872 PrevOffset = Offset;
2876 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2877 /// temporary label to it if SymbolStem is specified.
2878 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2879 const char *SymbolStem = 0) {
2880 Asm->OutStreamer.SwitchSection(Section);
2881 if (!SymbolStem) return 0;
2883 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2884 Asm->OutStreamer.EmitLabel(TmpSym);
2888 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2889 /// the start of each one.
2890 void DwarfDebug::EmitSectionLabels() {
2891 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2893 // Dwarf sections base addresses.
2894 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2895 DwarfFrameSectionSym =
2896 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2899 DwarfInfoSectionSym =
2900 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2901 DwarfAbbrevSectionSym =
2902 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2903 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2905 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2906 EmitSectionSym(Asm, MacroInfo);
2908 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2909 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2910 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2911 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2912 DwarfStrSectionSym =
2913 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2914 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2917 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2918 "section_debug_loc");
2920 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2921 EmitSectionSym(Asm, TLOF.getDataSection());
2924 /// emitDIE - Recusively Emits a debug information entry.
2926 void DwarfDebug::emitDIE(DIE *Die) {
2927 // Get the abbreviation for this DIE.
2928 unsigned AbbrevNumber = Die->getAbbrevNumber();
2929 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2931 // Emit the code (index) for the abbreviation.
2932 if (Asm->isVerbose())
2933 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2934 Twine::utohexstr(Die->getOffset()) + ":0x" +
2935 Twine::utohexstr(Die->getSize()) + " " +
2936 dwarf::TagString(Abbrev->getTag()));
2937 Asm->EmitULEB128(AbbrevNumber);
2939 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2940 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2942 // Emit the DIE attribute values.
2943 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2944 unsigned Attr = AbbrevData[i].getAttribute();
2945 unsigned Form = AbbrevData[i].getForm();
2946 assert(Form && "Too many attributes for DIE (check abbreviation)");
2948 if (Asm->isVerbose())
2949 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2952 case dwarf::DW_AT_sibling:
2953 Asm->EmitInt32(Die->getSiblingOffset());
2955 case dwarf::DW_AT_abstract_origin: {
2956 DIEEntry *E = cast<DIEEntry>(Values[i]);
2957 DIE *Origin = E->getEntry();
2958 unsigned Addr = Origin->getOffset();
2959 Asm->EmitInt32(Addr);
2962 case dwarf::DW_AT_ranges: {
2963 // DW_AT_range Value encodes offset in debug_range section.
2964 DIEInteger *V = cast<DIEInteger>(Values[i]);
2965 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2967 DwarfDebugRangeSectionSym,
2971 case dwarf::DW_AT_location: {
2972 if (UseDotDebugLocEntry.count(Die) != 0) {
2973 DIELabel *L = cast<DIELabel>(Values[i]);
2974 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2976 Values[i]->EmitValue(Asm, Form);
2980 // Emit an attribute using the defined form.
2981 Values[i]->EmitValue(Asm, Form);
2986 // Emit the DIE children if any.
2987 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2988 const std::vector<DIE *> &Children = Die->getChildren();
2990 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2991 emitDIE(Children[j]);
2993 if (Asm->isVerbose())
2994 Asm->OutStreamer.AddComment("End Of Children Mark");
2999 /// emitDebugInfo - Emit the debug info section.
3001 void DwarfDebug::emitDebugInfo() {
3002 // Start debug info section.
3003 Asm->OutStreamer.SwitchSection(
3004 Asm->getObjFileLowering().getDwarfInfoSection());
3005 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3006 E = CUMap.end(); I != E; ++I) {
3007 CompileUnit *TheCU = I->second;
3008 DIE *Die = TheCU->getCUDie();
3010 // Emit the compile units header.
3011 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3014 // Emit size of content not including length itself
3015 unsigned ContentSize = Die->getSize() +
3016 sizeof(int16_t) + // DWARF version number
3017 sizeof(int32_t) + // Offset Into Abbrev. Section
3018 sizeof(int8_t) + // Pointer Size (in bytes)
3019 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3021 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3022 Asm->EmitInt32(ContentSize);
3023 Asm->OutStreamer.AddComment("DWARF version number");
3024 Asm->EmitInt16(dwarf::DWARF_VERSION);
3025 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3026 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3027 DwarfAbbrevSectionSym);
3028 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3029 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3032 // FIXME - extra padding for gdb bug.
3033 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3038 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3042 /// emitAbbreviations - Emit the abbreviation section.
3044 void DwarfDebug::emitAbbreviations() const {
3045 // Check to see if it is worth the effort.
3046 if (!Abbreviations.empty()) {
3047 // Start the debug abbrev section.
3048 Asm->OutStreamer.SwitchSection(
3049 Asm->getObjFileLowering().getDwarfAbbrevSection());
3051 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3053 // For each abbrevation.
3054 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3055 // Get abbreviation data
3056 const DIEAbbrev *Abbrev = Abbreviations[i];
3058 // Emit the abbrevations code (base 1 index.)
3059 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3061 // Emit the abbreviations data.
3065 // Mark end of abbreviations.
3066 Asm->EmitULEB128(0, "EOM(3)");
3068 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3072 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3073 /// the line matrix.
3075 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3076 // Define last address of section.
3077 Asm->OutStreamer.AddComment("Extended Op");
3080 Asm->OutStreamer.AddComment("Op size");
3081 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3082 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3083 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3085 Asm->OutStreamer.AddComment("Section end label");
3087 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3088 Asm->getTargetData().getPointerSize(),
3091 // Mark end of matrix.
3092 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3098 /// emitDebugLines - Emit source line information.
3100 void DwarfDebug::emitDebugLines() {
3101 // If the target is using .loc/.file, the assembler will be emitting the
3102 // .debug_line table automatically.
3103 if (Asm->MAI->hasDotLocAndDotFile())
3106 // Minimum line delta, thus ranging from -10..(255-10).
3107 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3108 // Maximum line delta, thus ranging from -10..(255-10).
3109 const int MaxLineDelta = 255 + MinLineDelta;
3111 // Start the dwarf line section.
3112 Asm->OutStreamer.SwitchSection(
3113 Asm->getObjFileLowering().getDwarfLineSection());
3115 // Construct the section header.
3116 Asm->OutStreamer.AddComment("Length of Source Line Info");
3117 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3118 Asm->GetTempSymbol("line_begin"), 4);
3119 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3121 Asm->OutStreamer.AddComment("DWARF version number");
3122 Asm->EmitInt16(dwarf::DWARF_VERSION);
3124 Asm->OutStreamer.AddComment("Prolog Length");
3125 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3126 Asm->GetTempSymbol("line_prolog_begin"), 4);
3127 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3129 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3131 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3133 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3134 Asm->EmitInt8(MinLineDelta);
3135 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3136 Asm->EmitInt8(MaxLineDelta);
3137 Asm->OutStreamer.AddComment("Special Opcode Base");
3138 Asm->EmitInt8(-MinLineDelta);
3140 // Line number standard opcode encodings argument count
3141 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3143 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3145 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3147 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3149 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3151 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3153 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3155 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3157 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3160 // Emit directories.
3161 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3162 const std::string &Dir = getSourceDirectoryName(DI);
3163 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3164 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3167 Asm->OutStreamer.AddComment("End of directories");
3171 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3172 // Remember source id starts at 1.
3173 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3174 const std::string &FN = getSourceFileName(Id.second);
3175 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3176 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3178 Asm->EmitULEB128(Id.first, "Directory #");
3179 Asm->EmitULEB128(0, "Mod date");
3180 Asm->EmitULEB128(0, "File size");
3183 Asm->OutStreamer.AddComment("End of files");
3186 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3188 // A sequence for each text section.
3189 unsigned SecSrcLinesSize = SectionSourceLines.size();
3191 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3192 // Isolate current sections line info.
3193 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3195 // Dwarf assumes we start with first line of first source file.
3196 unsigned Source = 1;
3199 // Construct rows of the address, source, line, column matrix.
3200 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3201 const SrcLineInfo &LineInfo = LineInfos[i];
3202 MCSymbol *Label = LineInfo.getLabel();
3203 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3205 if (Asm->isVerbose()) {
3206 std::pair<unsigned, unsigned> SrcID =
3207 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3208 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3210 Twine(getSourceFileName(SrcID.second)) +
3211 ":" + Twine(LineInfo.getLine()));
3214 // Define the line address.
3215 Asm->OutStreamer.AddComment("Extended Op");
3217 Asm->OutStreamer.AddComment("Op size");
3218 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3220 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3221 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3223 Asm->OutStreamer.AddComment("Location label");
3224 Asm->OutStreamer.EmitSymbolValue(Label,
3225 Asm->getTargetData().getPointerSize(),
3228 // If change of source, then switch to the new source.
3229 if (Source != LineInfo.getSourceID()) {
3230 Source = LineInfo.getSourceID();
3231 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3232 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3233 Asm->EmitULEB128(Source, "New Source");
3236 // If change of line.
3237 if (Line != LineInfo.getLine()) {
3238 // Determine offset.
3239 int Offset = LineInfo.getLine() - Line;
3240 int Delta = Offset - MinLineDelta;
3243 Line = LineInfo.getLine();
3245 // If delta is small enough and in range...
3246 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3247 // ... then use fast opcode.
3248 Asm->OutStreamer.AddComment("Line Delta");
3249 Asm->EmitInt8(Delta - MinLineDelta);
3251 // ... otherwise use long hand.
3252 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3253 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3254 Asm->EmitSLEB128(Offset, "Line Offset");
3255 Asm->OutStreamer.AddComment("DW_LNS_copy");
3256 Asm->EmitInt8(dwarf::DW_LNS_copy);
3259 // Copy the previous row (different address or source)
3260 Asm->OutStreamer.AddComment("DW_LNS_copy");
3261 Asm->EmitInt8(dwarf::DW_LNS_copy);
3265 emitEndOfLineMatrix(j + 1);
3268 if (SecSrcLinesSize == 0)
3269 // Because we're emitting a debug_line section, we still need a line
3270 // table. The linker and friends expect it to exist. If there's nothing to
3271 // put into it, emit an empty table.
3272 emitEndOfLineMatrix(1);
3274 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3277 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3279 void DwarfDebug::emitCommonDebugFrame() {
3280 if (!Asm->MAI->doesDwarfRequireFrameSection())
3283 int stackGrowth = Asm->getTargetData().getPointerSize();
3284 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3285 TargetFrameInfo::StackGrowsDown)
3288 // Start the dwarf frame section.
3289 Asm->OutStreamer.SwitchSection(
3290 Asm->getObjFileLowering().getDwarfFrameSection());
3292 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3293 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3294 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3295 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3297 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3298 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3299 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3300 Asm->OutStreamer.AddComment("CIE Version");
3301 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3302 Asm->OutStreamer.AddComment("CIE Augmentation");
3303 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3304 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3305 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3306 Asm->OutStreamer.AddComment("CIE RA Column");
3307 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3308 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3310 std::vector<MachineMove> Moves;
3311 RI->getInitialFrameState(Moves);
3313 Asm->EmitFrameMoves(Moves, 0, false);
3315 Asm->EmitAlignment(2);
3316 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3319 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3322 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3323 if (!Asm->MAI->doesDwarfRequireFrameSection())
3326 // Start the dwarf frame section.
3327 Asm->OutStreamer.SwitchSection(
3328 Asm->getObjFileLowering().getDwarfFrameSection());
3330 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3331 MCSymbol *DebugFrameBegin =
3332 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3333 MCSymbol *DebugFrameEnd =
3334 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3335 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3337 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3339 Asm->OutStreamer.AddComment("FDE CIE offset");
3340 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3341 DwarfFrameSectionSym);
3343 Asm->OutStreamer.AddComment("FDE initial location");
3344 MCSymbol *FuncBeginSym =
3345 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3346 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3347 Asm->getTargetData().getPointerSize(),
3351 Asm->OutStreamer.AddComment("FDE address range");
3352 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3353 FuncBeginSym, Asm->getTargetData().getPointerSize());
3355 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3357 Asm->EmitAlignment(2);
3358 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3361 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3363 void DwarfDebug::emitDebugPubNames() {
3364 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3365 E = CUMap.end(); I != E; ++I) {
3366 CompileUnit *TheCU = I->second;
3367 // Start the dwarf pubnames section.
3368 Asm->OutStreamer.SwitchSection(
3369 Asm->getObjFileLowering().getDwarfPubNamesSection());
3371 Asm->OutStreamer.AddComment("Length of Public Names Info");
3372 Asm->EmitLabelDifference(
3373 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3374 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3376 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3379 Asm->OutStreamer.AddComment("DWARF Version");
3380 Asm->EmitInt16(dwarf::DWARF_VERSION);
3382 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3383 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3384 DwarfInfoSectionSym);
3386 Asm->OutStreamer.AddComment("Compilation Unit Length");
3387 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3388 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3391 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3392 for (StringMap<DIE*>::const_iterator
3393 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3394 const char *Name = GI->getKeyData();
3395 DIE *Entity = GI->second;
3397 Asm->OutStreamer.AddComment("DIE offset");
3398 Asm->EmitInt32(Entity->getOffset());
3400 if (Asm->isVerbose())
3401 Asm->OutStreamer.AddComment("External Name");
3402 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3405 Asm->OutStreamer.AddComment("End Mark");
3407 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3412 void DwarfDebug::emitDebugPubTypes() {
3413 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3414 E = CUMap.end(); I != E; ++I) {
3415 CompileUnit *TheCU = I->second;
3416 // Start the dwarf pubnames section.
3417 Asm->OutStreamer.SwitchSection(
3418 Asm->getObjFileLowering().getDwarfPubTypesSection());
3419 Asm->OutStreamer.AddComment("Length of Public Types Info");
3420 Asm->EmitLabelDifference(
3421 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3422 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3424 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3427 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3428 Asm->EmitInt16(dwarf::DWARF_VERSION);
3430 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3431 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3432 DwarfInfoSectionSym);
3434 Asm->OutStreamer.AddComment("Compilation Unit Length");
3435 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3436 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3439 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3440 for (StringMap<DIE*>::const_iterator
3441 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3442 const char *Name = GI->getKeyData();
3443 DIE * Entity = GI->second;
3445 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3446 Asm->EmitInt32(Entity->getOffset());
3448 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3449 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3452 Asm->OutStreamer.AddComment("End Mark");
3454 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3459 /// emitDebugStr - Emit visible names into a debug str section.
3461 void DwarfDebug::emitDebugStr() {
3462 // Check to see if it is worth the effort.
3463 if (StringPool.empty()) return;
3465 // Start the dwarf str section.
3466 Asm->OutStreamer.SwitchSection(
3467 Asm->getObjFileLowering().getDwarfStrSection());
3469 // Get all of the string pool entries and put them in an array by their ID so
3470 // we can sort them.
3471 SmallVector<std::pair<unsigned,
3472 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3474 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3475 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3476 Entries.push_back(std::make_pair(I->second.second, &*I));
3478 array_pod_sort(Entries.begin(), Entries.end());
3480 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3481 // Emit a label for reference from debug information entries.
3482 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3484 // Emit the string itself.
3485 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3489 /// emitDebugLoc - Emit visible names into a debug loc section.
3491 void DwarfDebug::emitDebugLoc() {
3492 if (DotDebugLocEntries.empty())
3495 // Start the dwarf loc section.
3496 Asm->OutStreamer.SwitchSection(
3497 Asm->getObjFileLowering().getDwarfLocSection());
3498 unsigned char Size = Asm->getTargetData().getPointerSize();
3499 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3501 for (SmallVector<DotDebugLocEntry, 4>::iterator I = DotDebugLocEntries.begin(),
3502 E = DotDebugLocEntries.end(); I != E; ++I, ++index) {
3503 DotDebugLocEntry Entry = *I;
3504 if (Entry.isEmpty()) {
3505 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3506 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3507 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3509 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3510 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3511 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3512 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3514 Asm->OutStreamer.AddComment("Loc expr size");
3516 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3518 Asm->OutStreamer.AddComment("Loc expr size");
3519 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3520 Asm->EmitInt8(dwarf::DW_OP_regx);
3521 Asm->EmitULEB128(Reg);
3527 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3529 void DwarfDebug::EmitDebugARanges() {
3530 // Start the dwarf aranges section.
3531 Asm->OutStreamer.SwitchSection(
3532 Asm->getObjFileLowering().getDwarfARangesSection());
3535 /// emitDebugRanges - Emit visible names into a debug ranges section.
3537 void DwarfDebug::emitDebugRanges() {
3538 // Start the dwarf ranges section.
3539 Asm->OutStreamer.SwitchSection(
3540 Asm->getObjFileLowering().getDwarfRangesSection());
3541 unsigned char Size = Asm->getTargetData().getPointerSize();
3542 for (SmallVector<const MCSymbol *, 8>::iterator
3543 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3546 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3548 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3552 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3554 void DwarfDebug::emitDebugMacInfo() {
3555 if (const MCSection *LineInfo =
3556 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3557 // Start the dwarf macinfo section.
3558 Asm->OutStreamer.SwitchSection(LineInfo);
3562 /// emitDebugInlineInfo - Emit inline info using following format.
3564 /// 1. length of section
3565 /// 2. Dwarf version number
3566 /// 3. address size.
3568 /// Entries (one "entry" for each function that was inlined):
3570 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3571 /// otherwise offset into __debug_str for regular function name.
3572 /// 2. offset into __debug_str section for regular function name.
3573 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3574 /// instances for the function.
3576 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3577 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3578 /// __debug_info section, and the low_pc is the starting address for the
3579 /// inlining instance.
3580 void DwarfDebug::emitDebugInlineInfo() {
3581 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3587 Asm->OutStreamer.SwitchSection(
3588 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3590 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3591 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3592 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3594 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3596 Asm->OutStreamer.AddComment("Dwarf Version");
3597 Asm->EmitInt16(dwarf::DWARF_VERSION);
3598 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3599 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3601 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3602 E = InlinedSPNodes.end(); I != E; ++I) {
3604 const MDNode *Node = *I;
3605 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3606 = InlineInfo.find(Node);
3607 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3608 DISubprogram SP(Node);
3609 StringRef LName = SP.getLinkageName();
3610 StringRef Name = SP.getName();
3612 Asm->OutStreamer.AddComment("MIPS linkage name");
3613 if (LName.empty()) {
3614 Asm->OutStreamer.EmitBytes(Name, 0);
3615 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3617 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3618 DwarfStrSectionSym);
3620 Asm->OutStreamer.AddComment("Function name");
3621 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3622 Asm->EmitULEB128(Labels.size(), "Inline count");
3624 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3625 LE = Labels.end(); LI != LE; ++LI) {
3626 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3627 Asm->EmitInt32(LI->second->getOffset());
3629 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3630 Asm->OutStreamer.EmitSymbolValue(LI->first,
3631 Asm->getTargetData().getPointerSize(),0);
3635 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));