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 //===----------------------------------------------------------------------===//
13 #define DEBUG_TYPE "dwarfdebug"
14 #include "DwarfDebug.h"
15 #include "llvm/Module.h"
16 #include "llvm/CodeGen/MachineFunction.h"
17 #include "llvm/CodeGen/MachineModuleInfo.h"
18 #include "llvm/MC/MCSection.h"
19 #include "llvm/MC/MCStreamer.h"
20 #include "llvm/MC/MCAsmInfo.h"
21 #include "llvm/Target/Mangler.h"
22 #include "llvm/Target/TargetData.h"
23 #include "llvm/Target/TargetFrameInfo.h"
24 #include "llvm/Target/TargetLoweringObjectFile.h"
25 #include "llvm/Target/TargetRegisterInfo.h"
26 #include "llvm/ADT/StringExtras.h"
27 #include "llvm/Support/Debug.h"
28 #include "llvm/Support/ErrorHandling.h"
29 #include "llvm/Support/ValueHandle.h"
30 #include "llvm/Support/FormattedStream.h"
31 #include "llvm/Support/Timer.h"
32 #include "llvm/System/Path.h"
35 //===----------------------------------------------------------------------===//
37 /// Configuration values for initial hash set sizes (log2).
39 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
43 //===----------------------------------------------------------------------===//
44 /// CompileUnit - This dwarf writer support class manages information associate
45 /// with a source file.
47 /// ID - File identifier for source.
51 /// Die - Compile unit debug information entry.
55 /// IndexTyDie - An anonymous type for index type.
58 /// GVToDieMap - Tracks the mapping of unit level debug informaton
59 /// variables to debug information entries.
60 /// FIXME : Rename GVToDieMap -> NodeToDieMap
61 DenseMap<MDNode *, DIE *> GVToDieMap;
63 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
64 /// descriptors to debug information entries using a DIEEntry proxy.
66 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
68 /// Globals - A map of globally visible named entities for this unit.
70 StringMap<DIE*> Globals;
72 /// GlobalTypes - A map of globally visible types for this unit.
74 StringMap<DIE*> GlobalTypes;
77 CompileUnit(unsigned I, DIE *D)
78 : ID(I), CUDie(D), IndexTyDie(0) {}
79 ~CompileUnit() { delete CUDie; delete IndexTyDie; }
82 unsigned getID() const { return ID; }
83 DIE* getCUDie() const { return CUDie; }
84 const StringMap<DIE*> &getGlobals() const { return Globals; }
85 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
87 /// hasContent - Return true if this compile unit has something to write out.
89 bool hasContent() const { return !CUDie->getChildren().empty(); }
91 /// addGlobal - Add a new global entity to the compile unit.
93 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
95 /// addGlobalType - Add a new global type to the compile unit.
97 void addGlobalType(const std::string &Name, DIE *Die) {
98 GlobalTypes[Name] = Die;
101 /// getDIE - Returns the debug information entry map slot for the
102 /// specified debug variable.
103 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
105 /// insertDIE - Insert DIE into the map.
106 void insertDIE(MDNode *N, DIE *D) {
107 GVToDieMap.insert(std::make_pair(N, D));
110 /// getDIEEntry - Returns the debug information entry for the speciefied
112 DIEEntry *getDIEEntry(MDNode *N) {
113 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
114 if (I == GVToDIEEntryMap.end())
119 /// insertDIEEntry - Insert debug information entry into the map.
120 void insertDIEEntry(MDNode *N, DIEEntry *E) {
121 GVToDIEEntryMap.insert(std::make_pair(N, E));
124 /// addDie - Adds or interns the DIE to the compile unit.
126 void addDie(DIE *Buffer) {
127 this->CUDie->addChild(Buffer);
130 // getIndexTyDie - Get an anonymous type for index type.
131 DIE *getIndexTyDie() {
135 // setIndexTyDie - Set D as anonymous type for index which can be reused
137 void setIndexTyDie(DIE *D) {
143 //===----------------------------------------------------------------------===//
144 /// DbgVariable - This class is used to track local variable information.
147 DIVariable Var; // Variable Descriptor.
148 unsigned FrameIndex; // Variable frame index.
149 DbgVariable *AbstractVar; // Abstract variable for this variable.
152 DbgVariable(DIVariable V, unsigned I)
153 : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0) {}
156 DIVariable getVariable() const { return Var; }
157 unsigned getFrameIndex() const { return FrameIndex; }
158 void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
159 DbgVariable *getAbstractVariable() const { return AbstractVar; }
160 void setDIE(DIE *D) { TheDIE = D; }
161 DIE *getDIE() const { return TheDIE; }
164 //===----------------------------------------------------------------------===//
165 /// DbgScope - This class is used to track scope information.
168 DbgScope *Parent; // Parent to this scope.
169 DIDescriptor Desc; // Debug info descriptor for scope.
170 // Location at which this scope is inlined.
171 AssertingVH<MDNode> InlinedAtLocation;
172 bool AbstractScope; // Abstract Scope
173 unsigned StartLabelID; // Label ID of the beginning of scope.
174 unsigned EndLabelID; // Label ID of the end of scope.
175 const MachineInstr *LastInsn; // Last instruction of this scope.
176 const MachineInstr *FirstInsn; // First instruction of this scope.
177 SmallVector<DbgScope *, 4> Scopes; // Scopes defined in scope.
178 SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
180 // Private state for dump()
181 mutable unsigned IndentLevel;
183 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
184 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
185 StartLabelID(0), EndLabelID(0),
186 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
190 DbgScope *getParent() const { return Parent; }
191 void setParent(DbgScope *P) { Parent = P; }
192 DIDescriptor getDesc() const { return Desc; }
193 MDNode *getInlinedAt() const {
194 return InlinedAtLocation;
196 MDNode *getScopeNode() const { return Desc.getNode(); }
197 unsigned getStartLabelID() const { return StartLabelID; }
198 unsigned getEndLabelID() const { return EndLabelID; }
199 SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
200 SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
201 void setStartLabelID(unsigned S) { StartLabelID = S; }
202 void setEndLabelID(unsigned E) { EndLabelID = E; }
203 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
204 const MachineInstr *getLastInsn() { return LastInsn; }
205 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
206 void setAbstractScope() { AbstractScope = true; }
207 bool isAbstractScope() const { return AbstractScope; }
208 const MachineInstr *getFirstInsn() { return FirstInsn; }
210 /// addScope - Add a scope to the scope.
212 void addScope(DbgScope *S) { Scopes.push_back(S); }
214 /// addVariable - Add a variable to the scope.
216 void addVariable(DbgVariable *V) { Variables.push_back(V); }
218 void fixInstructionMarkers(DenseMap<const MachineInstr *,
219 unsigned> &MIIndexMap) {
220 assert (getFirstInsn() && "First instruction is missing!");
222 // Use the end of last child scope as end of this scope.
223 SmallVector<DbgScope *, 4> &Scopes = getScopes();
224 const MachineInstr *LastInsn = getFirstInsn();
226 if (Scopes.empty()) {
227 assert (getLastInsn() && "Inner most scope does not have last insn!");
230 for (SmallVector<DbgScope *, 4>::iterator SI = Scopes.begin(),
231 SE = Scopes.end(); SI != SE; ++SI) {
233 DS->fixInstructionMarkers(MIIndexMap);
234 const MachineInstr *DSLastInsn = DS->getLastInsn();
235 unsigned DSI = MIIndexMap[DSLastInsn];
237 LastInsn = DSLastInsn;
241 setLastInsn(LastInsn);
250 void DbgScope::dump() const {
251 raw_ostream &err = dbgs();
252 err.indent(IndentLevel);
253 MDNode *N = Desc.getNode();
255 err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
257 err << "Abstract Scope\n";
261 err << "Children ...\n";
262 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
263 if (Scopes[i] != this)
270 DbgScope::~DbgScope() {
271 for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
273 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
277 } // end llvm namespace
279 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
280 : DwarfPrinter(OS, A, T, "dbg"), ModuleCU(0),
281 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
282 DIEValues(), StringPool(),
283 SectionSourceLines(), didInitial(false), shouldEmit(false),
284 CurrentFnDbgScope(0), DebugTimer(0) {
285 if (TimePassesIsEnabled)
286 DebugTimer = new Timer("Dwarf Debug Writer");
288 DwarfDebug::~DwarfDebug() {
289 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
295 /// assignAbbrevNumber - Define a unique number for the abbreviation.
297 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
298 // Profile the node so that we can make it unique.
302 // Check the set for priors.
303 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
305 // If it's newly added.
306 if (InSet == &Abbrev) {
307 // Add to abbreviation list.
308 Abbreviations.push_back(&Abbrev);
310 // Assign the vector position + 1 as its number.
311 Abbrev.setNumber(Abbreviations.size());
313 // Assign existing abbreviation number.
314 Abbrev.setNumber(InSet->getNumber());
318 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
319 /// information entry.
320 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
321 DIEEntry *Value = new DIEEntry(Entry);
322 DIEValues.push_back(Value);
326 /// addUInt - Add an unsigned integer attribute data and value.
328 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
329 unsigned Form, uint64_t Integer) {
330 if (!Form) Form = DIEInteger::BestForm(false, Integer);
331 DIEValue *Value = new DIEInteger(Integer);
332 DIEValues.push_back(Value);
333 Die->addValue(Attribute, Form, Value);
336 /// addSInt - Add an signed integer attribute data and value.
338 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
339 unsigned Form, int64_t Integer) {
340 if (!Form) Form = DIEInteger::BestForm(true, Integer);
341 DIEValue *Value = new DIEInteger(Integer);
342 DIEValues.push_back(Value);
343 Die->addValue(Attribute, Form, Value);
346 /// addString - Add a string attribute data and value. DIEString only
347 /// keeps string reference.
348 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
350 DIEValue *Value = new DIEString(String);
351 DIEValues.push_back(Value);
352 Die->addValue(Attribute, Form, Value);
355 /// addLabel - Add a Dwarf label attribute data and value.
357 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
358 const DWLabel &Label) {
359 DIEValue *Value = new DIEDwarfLabel(Label);
360 DIEValues.push_back(Value);
361 Die->addValue(Attribute, Form, Value);
364 /// addObjectLabel - Add an non-Dwarf label attribute data and value.
366 void DwarfDebug::addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
367 const MCSymbol *Sym) {
368 DIEValue *Value = new DIEObjectLabel(Sym);
369 DIEValues.push_back(Value);
370 Die->addValue(Attribute, Form, Value);
373 /// addSectionOffset - Add a section offset label attribute data and value.
375 void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
376 const DWLabel &Label, const DWLabel &Section,
377 bool isEH, bool useSet) {
378 DIEValue *Value = new DIESectionOffset(Label, Section, isEH, useSet);
379 DIEValues.push_back(Value);
380 Die->addValue(Attribute, Form, Value);
383 /// addDelta - Add a label delta attribute data and value.
385 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
386 const DWLabel &Hi, const DWLabel &Lo) {
387 DIEValue *Value = new DIEDelta(Hi, Lo);
388 DIEValues.push_back(Value);
389 Die->addValue(Attribute, Form, Value);
392 /// addBlock - Add block data.
394 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
396 Block->ComputeSize(TD);
397 DIEValues.push_back(Block);
398 Die->addValue(Attribute, Block->BestForm(), Block);
401 /// addSourceLine - Add location information to specified debug information
403 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
404 // If there is no compile unit specified, don't add a line #.
405 if (V->getCompileUnit().isNull())
408 unsigned Line = V->getLineNumber();
409 unsigned FileID = findCompileUnit(V->getCompileUnit())->getID();
410 assert(FileID && "Invalid file id");
411 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
412 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
415 /// addSourceLine - Add location information to specified debug information
417 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
418 // If there is no compile unit specified, don't add a line #.
419 if (G->getCompileUnit().isNull())
422 unsigned Line = G->getLineNumber();
423 unsigned FileID = findCompileUnit(G->getCompileUnit())->getID();
424 assert(FileID && "Invalid file id");
425 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
426 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
429 /// addSourceLine - Add location information to specified debug information
431 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
432 // If there is no compile unit specified, don't add a line #.
433 if (SP->getCompileUnit().isNull())
435 // If the line number is 0, don't add it.
436 if (SP->getLineNumber() == 0)
440 unsigned Line = SP->getLineNumber();
441 unsigned FileID = findCompileUnit(SP->getCompileUnit())->getID();
442 assert(FileID && "Invalid file id");
443 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
444 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
447 /// addSourceLine - Add location information to specified debug information
449 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
450 // If there is no compile unit specified, don't add a line #.
451 DICompileUnit CU = Ty->getCompileUnit();
455 unsigned Line = Ty->getLineNumber();
456 unsigned FileID = findCompileUnit(CU)->getID();
457 assert(FileID && "Invalid file id");
458 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
459 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
462 /// addSourceLine - Add location information to specified debug information
464 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
465 // If there is no compile unit specified, don't add a line #.
466 if (NS->getCompileUnit().isNull())
469 unsigned Line = NS->getLineNumber();
470 StringRef FN = NS->getFilename();
471 StringRef Dir = NS->getDirectory();
473 unsigned FileID = GetOrCreateSourceID(Dir, FN);
474 assert(FileID && "Invalid file id");
475 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
476 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
479 /* Byref variables, in Blocks, are declared by the programmer as
480 "SomeType VarName;", but the compiler creates a
481 __Block_byref_x_VarName struct, and gives the variable VarName
482 either the struct, or a pointer to the struct, as its type. This
483 is necessary for various behind-the-scenes things the compiler
484 needs to do with by-reference variables in blocks.
486 However, as far as the original *programmer* is concerned, the
487 variable should still have type 'SomeType', as originally declared.
489 The following function dives into the __Block_byref_x_VarName
490 struct to find the original type of the variable. This will be
491 passed back to the code generating the type for the Debug
492 Information Entry for the variable 'VarName'. 'VarName' will then
493 have the original type 'SomeType' in its debug information.
495 The original type 'SomeType' will be the type of the field named
496 'VarName' inside the __Block_byref_x_VarName struct.
498 NOTE: In order for this to not completely fail on the debugger
499 side, the Debug Information Entry for the variable VarName needs to
500 have a DW_AT_location that tells the debugger how to unwind through
501 the pointers and __Block_byref_x_VarName struct to find the actual
502 value of the variable. The function addBlockByrefType does this. */
504 /// Find the type the programmer originally declared the variable to be
505 /// and return that type.
507 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
510 unsigned tag = Ty.getTag();
512 if (tag == dwarf::DW_TAG_pointer_type) {
513 DIDerivedType DTy = DIDerivedType(Ty.getNode());
514 subType = DTy.getTypeDerivedFrom();
517 DICompositeType blockStruct = DICompositeType(subType.getNode());
519 DIArray Elements = blockStruct.getTypeArray();
521 if (Elements.isNull())
524 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
525 DIDescriptor Element = Elements.getElement(i);
526 DIDerivedType DT = DIDerivedType(Element.getNode());
527 if (Name == DT.getName())
528 return (DT.getTypeDerivedFrom());
534 /// addComplexAddress - Start with the address based on the location provided,
535 /// and generate the DWARF information necessary to find the actual variable
536 /// given the extra address information encoded in the DIVariable, starting from
537 /// the starting location. Add the DWARF information to the die.
539 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
541 const MachineLocation &Location) {
542 const DIVariable &VD = DV->getVariable();
543 DIType Ty = VD.getType();
545 // Decode the original location, and use that as the start of the byref
546 // variable's location.
547 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
548 DIEBlock *Block = new DIEBlock();
550 if (Location.isReg()) {
552 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
554 Reg = Reg - dwarf::DW_OP_reg0;
555 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
556 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
560 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
562 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
563 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
566 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
569 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
570 uint64_t Element = VD.getAddrElement(i);
572 if (Element == DIFactory::OpPlus) {
573 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
574 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
575 } else if (Element == DIFactory::OpDeref) {
576 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
577 } else llvm_unreachable("unknown DIFactory Opcode");
580 // Now attach the location information to the DIE.
581 addBlock(Die, Attribute, 0, Block);
584 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
585 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
586 gives the variable VarName either the struct, or a pointer to the struct, as
587 its type. This is necessary for various behind-the-scenes things the
588 compiler needs to do with by-reference variables in Blocks.
590 However, as far as the original *programmer* is concerned, the variable
591 should still have type 'SomeType', as originally declared.
593 The function getBlockByrefType dives into the __Block_byref_x_VarName
594 struct to find the original type of the variable, which is then assigned to
595 the variable's Debug Information Entry as its real type. So far, so good.
596 However now the debugger will expect the variable VarName to have the type
597 SomeType. So we need the location attribute for the variable to be an
598 expression that explains to the debugger how to navigate through the
599 pointers and struct to find the actual variable of type SomeType.
601 The following function does just that. We start by getting
602 the "normal" location for the variable. This will be the location
603 of either the struct __Block_byref_x_VarName or the pointer to the
604 struct __Block_byref_x_VarName.
606 The struct will look something like:
608 struct __Block_byref_x_VarName {
610 struct __Block_byref_x_VarName *forwarding;
611 ... <various other fields>
613 ... <maybe more fields>
616 If we are given the struct directly (as our starting point) we
617 need to tell the debugger to:
619 1). Add the offset of the forwarding field.
621 2). Follow that pointer to get the the real __Block_byref_x_VarName
622 struct to use (the real one may have been copied onto the heap).
624 3). Add the offset for the field VarName, to find the actual variable.
626 If we started with a pointer to the struct, then we need to
627 dereference that pointer first, before the other steps.
628 Translating this into DWARF ops, we will need to append the following
629 to the current location description for the variable:
631 DW_OP_deref -- optional, if we start with a pointer
632 DW_OP_plus_uconst <forward_fld_offset>
634 DW_OP_plus_uconst <varName_fld_offset>
636 That is what this function does. */
638 /// addBlockByrefAddress - Start with the address based on the location
639 /// provided, and generate the DWARF information necessary to find the
640 /// actual Block variable (navigating the Block struct) based on the
641 /// starting location. Add the DWARF information to the die. For
642 /// more information, read large comment just above here.
644 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
646 const MachineLocation &Location) {
647 const DIVariable &VD = DV->getVariable();
648 DIType Ty = VD.getType();
650 unsigned Tag = Ty.getTag();
651 bool isPointer = false;
653 StringRef varName = VD.getName();
655 if (Tag == dwarf::DW_TAG_pointer_type) {
656 DIDerivedType DTy = DIDerivedType(Ty.getNode());
657 TmpTy = DTy.getTypeDerivedFrom();
661 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
663 // Find the __forwarding field and the variable field in the __Block_byref
665 DIArray Fields = blockStruct.getTypeArray();
666 DIDescriptor varField = DIDescriptor();
667 DIDescriptor forwardingField = DIDescriptor();
670 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
671 DIDescriptor Element = Fields.getElement(i);
672 DIDerivedType DT = DIDerivedType(Element.getNode());
673 StringRef fieldName = DT.getName();
674 if (fieldName == "__forwarding")
675 forwardingField = Element;
676 else if (fieldName == varName)
680 assert(!varField.isNull() && "Can't find byref variable in Block struct");
681 assert(!forwardingField.isNull()
682 && "Can't find forwarding field in Block struct");
684 // Get the offsets for the forwarding field and the variable field.
685 unsigned int forwardingFieldOffset =
686 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
687 unsigned int varFieldOffset =
688 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
690 // Decode the original location, and use that as the start of the byref
691 // variable's location.
692 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
693 DIEBlock *Block = new DIEBlock();
695 if (Location.isReg()) {
697 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
699 Reg = Reg - dwarf::DW_OP_reg0;
700 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
701 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
705 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
707 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
708 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
711 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
714 // If we started with a pointer to the __Block_byref... struct, then
715 // the first thing we need to do is dereference the pointer (DW_OP_deref).
717 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
719 // Next add the offset for the '__forwarding' field:
720 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
721 // adding the offset if it's 0.
722 if (forwardingFieldOffset > 0) {
723 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
724 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
727 // Now dereference the __forwarding field to get to the real __Block_byref
728 // struct: DW_OP_deref.
729 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
731 // Now that we've got the real __Block_byref... struct, add the offset
732 // for the variable's field to get to the location of the actual variable:
733 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
734 if (varFieldOffset > 0) {
735 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
736 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
739 // Now attach the location information to the DIE.
740 addBlock(Die, Attribute, 0, Block);
743 /// addAddress - Add an address attribute to a die based on the location
745 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
746 const MachineLocation &Location) {
747 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
748 DIEBlock *Block = new DIEBlock();
750 if (Location.isReg()) {
752 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
754 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
755 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
759 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
761 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
762 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
765 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
768 addBlock(Die, Attribute, 0, Block);
771 /// addToContextOwner - Add Die into the list of its context owner's children.
772 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
773 if (Context.isNull())
774 ModuleCU->addDie(Die);
775 else if (Context.isType()) {
776 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
777 ContextDIE->addChild(Die);
778 } else if (Context.isNameSpace()) {
779 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
780 ContextDIE->addChild(Die);
781 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
782 ContextDIE->addChild(Die);
784 ModuleCU->addDie(Die);
787 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
789 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
790 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
795 TyDIE = new DIE(dwarf::DW_TAG_base_type);
796 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
797 if (Ty.isBasicType())
798 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
799 else if (Ty.isCompositeType())
800 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
802 assert(Ty.isDerivedType() && "Unknown kind of DIType");
803 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
806 addToContextOwner(TyDIE, Ty.getContext());
810 /// addType - Add a new type attribute to the specified entity.
811 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
815 // Check for pre-existence.
816 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
817 // If it exists then use the existing value.
819 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
824 Entry = createDIEEntry();
825 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
828 DIE *Buffer = getOrCreateTypeDIE(Ty);
830 Entry->setEntry(Buffer);
831 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
834 /// constructTypeDIE - Construct basic type die from DIBasicType.
835 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
836 // Get core information.
837 StringRef Name = BTy.getName();
838 Buffer.setTag(dwarf::DW_TAG_base_type);
839 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
842 // Add name if not anonymous or intermediate type.
844 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
845 uint64_t Size = BTy.getSizeInBits() >> 3;
846 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
849 /// constructTypeDIE - Construct derived type die from DIDerivedType.
850 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
851 // Get core information.
852 StringRef Name = DTy.getName();
853 uint64_t Size = DTy.getSizeInBits() >> 3;
854 unsigned Tag = DTy.getTag();
856 // FIXME - Workaround for templates.
857 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
861 // Map to main type, void will not have a type.
862 DIType FromTy = DTy.getTypeDerivedFrom();
863 addType(&Buffer, FromTy);
865 // Add name if not anonymous or intermediate type.
867 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
869 // Add size if non-zero (derived types might be zero-sized.)
871 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
873 // Add source line info if available and TyDesc is not a forward declaration.
874 if (!DTy.isForwardDecl())
875 addSourceLine(&Buffer, &DTy);
878 /// constructTypeDIE - Construct type DIE from DICompositeType.
879 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
880 // Get core information.
881 StringRef Name = CTy.getName();
883 uint64_t Size = CTy.getSizeInBits() >> 3;
884 unsigned Tag = CTy.getTag();
888 case dwarf::DW_TAG_vector_type:
889 case dwarf::DW_TAG_array_type:
890 constructArrayTypeDIE(Buffer, &CTy);
892 case dwarf::DW_TAG_enumeration_type: {
893 DIArray Elements = CTy.getTypeArray();
895 // Add enumerators to enumeration type.
896 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
898 DIEnumerator Enum(Elements.getElement(i).getNode());
899 if (!Enum.isNull()) {
900 ElemDie = constructEnumTypeDIE(&Enum);
901 Buffer.addChild(ElemDie);
906 case dwarf::DW_TAG_subroutine_type: {
908 DIArray Elements = CTy.getTypeArray();
909 DIDescriptor RTy = Elements.getElement(0);
910 addType(&Buffer, DIType(RTy.getNode()));
912 // Add prototype flag.
913 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
916 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
917 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
918 DIDescriptor Ty = Elements.getElement(i);
919 addType(Arg, DIType(Ty.getNode()));
920 Buffer.addChild(Arg);
924 case dwarf::DW_TAG_structure_type:
925 case dwarf::DW_TAG_union_type:
926 case dwarf::DW_TAG_class_type: {
927 // Add elements to structure type.
928 DIArray Elements = CTy.getTypeArray();
930 // A forward struct declared type may not have elements available.
931 if (Elements.isNull())
934 // Add elements to structure type.
935 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
936 DIDescriptor Element = Elements.getElement(i);
937 if (Element.isNull())
940 if (Element.getTag() == dwarf::DW_TAG_subprogram)
941 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
942 else if (Element.getTag() == dwarf::DW_TAG_auto_variable) {
943 DIVariable DV(Element.getNode());
944 ElemDie = new DIE(dwarf::DW_TAG_variable);
945 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
947 addType(ElemDie, DV.getType());
948 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
949 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
950 addSourceLine(ElemDie, &DV);
952 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
953 Buffer.addChild(ElemDie);
956 if (CTy.isAppleBlockExtension())
957 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
959 unsigned RLang = CTy.getRunTimeLang();
961 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
962 dwarf::DW_FORM_data1, RLang);
964 DICompositeType ContainingType = CTy.getContainingType();
965 if (!ContainingType.isNull())
966 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
967 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
974 // Add name if not anonymous or intermediate type.
976 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
978 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
979 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
980 // Add size if non-zero (derived types might be zero-sized.)
982 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
984 // Add zero size if it is not a forward declaration.
985 if (CTy.isForwardDecl())
986 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
988 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
991 // Add source line info if available.
992 if (!CTy.isForwardDecl())
993 addSourceLine(&Buffer, &CTy);
997 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
998 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
999 int64_t L = SR.getLo();
1000 int64_t H = SR.getHi();
1001 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1003 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1005 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1006 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1008 Buffer.addChild(DW_Subrange);
1011 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1012 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1013 DICompositeType *CTy) {
1014 Buffer.setTag(dwarf::DW_TAG_array_type);
1015 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1016 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1018 // Emit derived type.
1019 addType(&Buffer, CTy->getTypeDerivedFrom());
1020 DIArray Elements = CTy->getTypeArray();
1022 // Get an anonymous type for index type.
1023 DIE *IdxTy = ModuleCU->getIndexTyDie();
1025 // Construct an anonymous type for index type.
1026 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1027 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1028 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1029 dwarf::DW_ATE_signed);
1030 ModuleCU->addDie(IdxTy);
1031 ModuleCU->setIndexTyDie(IdxTy);
1034 // Add subranges to array type.
1035 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1036 DIDescriptor Element = Elements.getElement(i);
1037 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1038 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1042 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1043 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator *ETy) {
1044 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1045 StringRef Name = ETy->getName();
1046 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1047 int64_t Value = ETy->getEnumValue();
1048 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1052 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1053 /// printer to not emit usual symbol prefix before the symbol name is used then
1054 /// return linkage name after skipping this special LLVM prefix.
1055 static StringRef getRealLinkageName(StringRef LinkageName) {
1057 if (LinkageName.startswith(StringRef(&One, 1)))
1058 return LinkageName.substr(1);
1062 /// createGlobalVariableDIE - Create new DIE using GV.
1063 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1064 // If the global variable was optmized out then no need to create debug info
1066 if (!GV.getGlobal()) return NULL;
1067 if (GV.getDisplayName().empty()) return NULL;
1069 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1070 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1071 GV.getDisplayName());
1073 StringRef LinkageName = GV.getLinkageName();
1074 if (!LinkageName.empty())
1075 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1076 getRealLinkageName(LinkageName));
1078 addType(GVDie, GV.getType());
1079 if (!GV.isLocalToUnit())
1080 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1081 addSourceLine(GVDie, &GV);
1086 /// createMemberDIE - Create new member DIE.
1087 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1088 DIE *MemberDie = new DIE(DT.getTag());
1089 StringRef Name = DT.getName();
1091 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1093 addType(MemberDie, DT.getTypeDerivedFrom());
1095 addSourceLine(MemberDie, &DT);
1097 DIEBlock *MemLocationDie = new DIEBlock();
1098 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1100 uint64_t Size = DT.getSizeInBits();
1101 uint64_t FieldSize = DT.getOriginalTypeSize();
1103 if (Size != FieldSize) {
1105 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1106 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1108 uint64_t Offset = DT.getOffsetInBits();
1109 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1110 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1111 uint64_t FieldOffset = (HiMark - FieldSize);
1112 Offset -= FieldOffset;
1114 // Maybe we need to work from the other end.
1115 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1116 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1118 // Here WD_AT_data_member_location points to the anonymous
1119 // field that includes this bit field.
1120 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1123 // This is not a bitfield.
1124 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1126 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1128 if (DT.isProtected())
1129 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1130 dwarf::DW_ACCESS_protected);
1131 else if (DT.isPrivate())
1132 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1133 dwarf::DW_ACCESS_private);
1134 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1135 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1136 dwarf::DW_ACCESS_public);
1138 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1139 dwarf::DW_VIRTUALITY_virtual);
1143 /// createSubprogramDIE - Create new DIE using SP.
1144 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1145 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1149 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1150 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1152 StringRef LinkageName = SP.getLinkageName();
1153 if (!LinkageName.empty())
1154 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1155 getRealLinkageName(LinkageName));
1157 addSourceLine(SPDie, &SP);
1159 // Add prototyped tag, if C or ObjC.
1160 unsigned Lang = SP.getCompileUnit().getLanguage();
1161 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1162 Lang == dwarf::DW_LANG_ObjC)
1163 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1166 DICompositeType SPTy = SP.getType();
1167 DIArray Args = SPTy.getTypeArray();
1168 unsigned SPTag = SPTy.getTag();
1170 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1171 addType(SPDie, SPTy);
1173 addType(SPDie, DIType(Args.getElement(0).getNode()));
1175 unsigned VK = SP.getVirtuality();
1177 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1178 DIEBlock *Block = new DIEBlock();
1179 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1180 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1181 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1182 ContainingTypeMap.insert(std::make_pair(SPDie,
1183 SP.getContainingType().getNode()));
1186 if (MakeDecl || !SP.isDefinition()) {
1187 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1189 // Add arguments. Do not add arguments for subprogram definition. They will
1190 // be handled while processing variables.
1191 DICompositeType SPTy = SP.getType();
1192 DIArray Args = SPTy.getTypeArray();
1193 unsigned SPTag = SPTy.getTag();
1195 if (SPTag == dwarf::DW_TAG_subroutine_type)
1196 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1197 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1198 addType(Arg, DIType(Args.getElement(i).getNode()));
1199 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1200 SPDie->addChild(Arg);
1204 if (SP.isArtificial())
1205 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1207 // DW_TAG_inlined_subroutine may refer to this DIE.
1208 ModuleCU->insertDIE(SP.getNode(), SPDie);
1212 /// findCompileUnit - Get the compile unit for the given descriptor.
1214 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1215 DenseMap<Value *, CompileUnit *>::const_iterator I =
1216 CompileUnitMap.find(Unit.getNode());
1217 if (I == CompileUnitMap.end())
1218 return constructCompileUnit(Unit.getNode());
1222 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1223 /// Initialize scope and update scope hierarchy.
1224 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1225 MDNode *InlinedAt) {
1226 assert (N && "Invalid Scope encoding!");
1227 assert (MI && "Missing machine instruction!");
1228 bool GetConcreteScope = (MI && InlinedAt);
1230 DbgScope *NScope = NULL;
1233 NScope = DbgScopeMap.lookup(InlinedAt);
1235 NScope = DbgScopeMap.lookup(N);
1236 assert (NScope && "Unable to find working scope!");
1238 if (NScope->getFirstInsn())
1241 DbgScope *Parent = NULL;
1242 if (GetConcreteScope) {
1243 DILocation IL(InlinedAt);
1244 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1245 IL.getOrigLocation().getNode());
1246 assert (Parent && "Unable to find Parent scope!");
1247 NScope->setParent(Parent);
1248 Parent->addScope(NScope);
1249 } else if (DIDescriptor(N).isLexicalBlock()) {
1250 DILexicalBlock DB(N);
1251 if (!DB.getContext().isNull()) {
1252 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1253 NScope->setParent(Parent);
1254 Parent->addScope(NScope);
1258 NScope->setFirstInsn(MI);
1260 if (!Parent && !InlinedAt) {
1261 StringRef SPName = DISubprogram(N).getLinkageName();
1262 if (SPName == MF->getFunction()->getName())
1263 CurrentFnDbgScope = NScope;
1266 if (GetConcreteScope) {
1267 ConcreteScopes[InlinedAt] = NScope;
1268 getOrCreateAbstractScope(N);
1274 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1275 assert (N && "Invalid Scope encoding!");
1277 DbgScope *AScope = AbstractScopes.lookup(N);
1281 DbgScope *Parent = NULL;
1283 DIDescriptor Scope(N);
1284 if (Scope.isLexicalBlock()) {
1285 DILexicalBlock DB(N);
1286 DIDescriptor ParentDesc = DB.getContext();
1287 if (!ParentDesc.isNull())
1288 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1291 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1294 Parent->addScope(AScope);
1295 AScope->setAbstractScope();
1296 AbstractScopes[N] = AScope;
1297 if (DIDescriptor(N).isSubprogram())
1298 AbstractScopesList.push_back(AScope);
1302 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1303 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1304 /// If there are global variables in this scope then create and insert
1305 /// DIEs for these variables.
1306 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1308 DIE *SPDie = ModuleCU->getDIE(SPNode);
1309 assert (SPDie && "Unable to find subprogram DIE!");
1310 DISubprogram SP(SPNode);
1311 if (SP.isDefinition() && !SP.getContext().isCompileUnit()) {
1312 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1314 DICompositeType SPTy = SP.getType();
1315 DIArray Args = SPTy.getTypeArray();
1316 unsigned SPTag = SPTy.getTag();
1317 if (SPTag == dwarf::DW_TAG_subroutine_type)
1318 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1319 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1320 addType(Arg, DIType(Args.getElement(i).getNode()));
1321 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1322 SPDie->addChild(Arg);
1324 DIE *SPDeclDie = SPDie;
1325 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1326 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1328 ModuleCU->addDie(SPDie);
1331 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1332 DWLabel("func_begin", SubprogramCount));
1333 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1334 DWLabel("func_end", SubprogramCount));
1335 MachineLocation Location(RI->getFrameRegister(*MF));
1336 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1338 if (!DISubprogram(SPNode).isLocalToUnit())
1339 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1344 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1345 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1346 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1347 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1348 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1350 // Ignore empty scopes.
1351 if (StartID == EndID && StartID != 0)
1354 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1355 if (Scope->isAbstractScope())
1358 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1360 DWLabel("label", StartID)
1361 : DWLabel("func_begin", SubprogramCount));
1362 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1364 DWLabel("label", EndID)
1365 : DWLabel("func_end", SubprogramCount));
1372 /// constructInlinedScopeDIE - This scope represents inlined body of
1373 /// a function. Construct DIE to represent this concrete inlined copy
1374 /// of the function.
1375 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1376 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1377 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1378 assert (StartID && "Invalid starting label for an inlined scope!");
1379 assert (EndID && "Invalid end label for an inlined scope!");
1380 // Ignore empty scopes.
1381 if (StartID == EndID && StartID != 0)
1384 DIScope DS(Scope->getScopeNode());
1387 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1389 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1390 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1391 assert (OriginDIE && "Unable to find Origin DIE!");
1392 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1393 dwarf::DW_FORM_ref4, OriginDIE);
1395 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1396 DWLabel("label", StartID));
1397 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1398 DWLabel("label", EndID));
1400 InlinedSubprogramDIEs.insert(OriginDIE);
1402 // Track the start label for this inlined function.
1403 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1404 I = InlineInfo.find(InlinedSP.getNode());
1406 if (I == InlineInfo.end()) {
1407 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1409 InlinedSPNodes.push_back(InlinedSP.getNode());
1411 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1413 StringPool.insert(InlinedSP.getName());
1414 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1416 DILocation DL(Scope->getInlinedAt());
1417 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1418 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1424 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1425 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1426 // Get the descriptor.
1427 const DIVariable &VD = DV->getVariable();
1428 StringRef Name = VD.getName();
1432 // Translate tag to proper Dwarf tag. The result variable is dropped for
1435 switch (VD.getTag()) {
1436 case dwarf::DW_TAG_return_variable:
1438 case dwarf::DW_TAG_arg_variable:
1439 Tag = dwarf::DW_TAG_formal_parameter;
1441 case dwarf::DW_TAG_auto_variable: // fall thru
1443 Tag = dwarf::DW_TAG_variable;
1447 // Define variable debug information entry.
1448 DIE *VariableDie = new DIE(Tag);
1452 if (DbgVariable *AV = DV->getAbstractVariable())
1453 AbsDIE = AV->getDIE();
1456 DIScope DS(Scope->getScopeNode());
1457 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1458 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1460 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1461 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1462 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1463 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1464 dwarf::DW_FORM_ref4, AbsDIE);
1467 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1468 addSourceLine(VariableDie, &VD);
1470 // Add variable type.
1471 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1472 // addresses instead.
1473 if (VD.isBlockByrefVariable())
1474 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1476 addType(VariableDie, VD.getType());
1479 // Add variable address.
1480 if (!Scope->isAbstractScope()) {
1481 MachineLocation Location;
1483 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1484 Location.set(FrameReg, Offset);
1486 if (VD.hasComplexAddress())
1487 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1488 else if (VD.isBlockByrefVariable())
1489 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1491 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1493 DV->setDIE(VariableDie);
1498 void DwarfDebug::addPubTypes(DISubprogram SP) {
1499 DICompositeType SPTy = SP.getType();
1500 unsigned SPTag = SPTy.getTag();
1501 if (SPTag != dwarf::DW_TAG_subroutine_type)
1504 DIArray Args = SPTy.getTypeArray();
1508 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1509 DIType ATy(Args.getElement(i).getNode());
1512 DICompositeType CATy = getDICompositeType(ATy);
1513 if (!CATy.isNull() && !CATy.getName().empty()) {
1514 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1515 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1520 /// constructScopeDIE - Construct a DIE for this scope.
1521 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1524 DIScope DS(Scope->getScopeNode());
1528 DIE *ScopeDIE = NULL;
1529 if (Scope->getInlinedAt())
1530 ScopeDIE = constructInlinedScopeDIE(Scope);
1531 else if (DS.isSubprogram()) {
1532 if (Scope->isAbstractScope())
1533 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1535 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1538 ScopeDIE = constructLexicalScopeDIE(Scope);
1539 if (!ScopeDIE) return NULL;
1542 // Add variables to scope.
1543 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1544 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1545 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1547 ScopeDIE->addChild(VariableDIE);
1550 // Add nested scopes.
1551 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1552 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1553 // Define the Scope debug information entry.
1554 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1556 ScopeDIE->addChild(NestedDIE);
1559 if (DS.isSubprogram())
1560 addPubTypes(DISubprogram(DS.getNode()));
1565 /// GetOrCreateSourceID - Look up the source id with the given directory and
1566 /// source file names. If none currently exists, create a new id and insert it
1567 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1569 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1571 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1572 if (DI != DirectoryIdMap.end()) {
1573 DId = DI->getValue();
1575 DId = DirectoryNames.size() + 1;
1576 DirectoryIdMap[DirName] = DId;
1577 DirectoryNames.push_back(DirName);
1581 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1582 if (FI != SourceFileIdMap.end()) {
1583 FId = FI->getValue();
1585 FId = SourceFileNames.size() + 1;
1586 SourceFileIdMap[FileName] = FId;
1587 SourceFileNames.push_back(FileName);
1590 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1591 SourceIdMap.find(std::make_pair(DId, FId));
1592 if (SI != SourceIdMap.end())
1595 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1596 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1597 SourceIds.push_back(std::make_pair(DId, FId));
1602 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1603 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1604 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1607 NDie = new DIE(dwarf::DW_TAG_namespace);
1608 ModuleCU->insertDIE(NS.getNode(), NDie);
1609 if (!NS.getName().empty())
1610 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1611 addSourceLine(NDie, &NS);
1612 addToContextOwner(NDie, NS.getContext());
1616 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1617 DICompileUnit DIUnit(N);
1618 StringRef FN = DIUnit.getFilename();
1619 StringRef Dir = DIUnit.getDirectory();
1620 unsigned ID = GetOrCreateSourceID(Dir, FN);
1622 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1623 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1624 DWLabel("section_line", 0), DWLabel("section_line", 0),
1626 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1627 DIUnit.getProducer());
1628 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1629 DIUnit.getLanguage());
1630 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1633 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1634 if (DIUnit.isOptimized())
1635 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1637 StringRef Flags = DIUnit.getFlags();
1639 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1641 unsigned RVer = DIUnit.getRunTimeVersion();
1643 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1644 dwarf::DW_FORM_data1, RVer);
1646 CompileUnit *Unit = new CompileUnit(ID, Die);
1647 if (!ModuleCU && DIUnit.isMain()) {
1648 // Use first compile unit marked as isMain as the compile unit
1653 CompileUnitMap[DIUnit.getNode()] = Unit;
1654 CompileUnits.push_back(Unit);
1658 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1659 DIGlobalVariable DI_GV(N);
1661 // If debug information is malformed then ignore it.
1662 if (DI_GV.Verify() == false)
1665 // Check for pre-existence.
1666 if (ModuleCU->getDIE(DI_GV.getNode()))
1669 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1674 ModuleCU->insertDIE(N, VariableDie);
1676 // Add to context owner.
1677 DIDescriptor GVContext = DI_GV.getContext();
1678 // Do not create specification DIE if context is either compile unit
1680 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1681 && !GVContext.isSubprogram()) {
1682 // Create specification DIE.
1683 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1684 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1685 dwarf::DW_FORM_ref4, VariableDie);
1686 DIEBlock *Block = new DIEBlock();
1687 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1688 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1689 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1690 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1691 ModuleCU->addDie(VariableSpecDIE);
1693 DIEBlock *Block = new DIEBlock();
1694 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1695 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1696 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1697 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1699 addToContextOwner(VariableDie, GVContext);
1701 // Expose as global. FIXME - need to check external flag.
1702 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1704 DIType GTy = DI_GV.getType();
1705 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1706 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1707 assert (Entry && "Missing global type!");
1708 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1713 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1716 // Check for pre-existence.
1717 if (ModuleCU->getDIE(N))
1720 if (!SP.isDefinition())
1721 // This is a method declaration which will be handled while constructing
1725 DIE *SubprogramDie = createSubprogramDIE(SP);
1728 ModuleCU->insertDIE(N, SubprogramDie);
1730 // Add to context owner.
1731 addToContextOwner(SubprogramDie, SP.getContext());
1733 // Expose as global.
1734 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1739 /// beginModule - Emit all Dwarf sections that should come prior to the
1740 /// content. Create global DIEs and emit initial debug info sections.
1741 /// This is inovked by the target AsmPrinter.
1742 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1745 if (TimePassesIsEnabled)
1746 DebugTimer->startTimer();
1748 if (!MAI->doesSupportDebugInformation())
1751 DebugInfoFinder DbgFinder;
1752 DbgFinder.processModule(*M);
1754 // Create all the compile unit DIEs.
1755 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1756 E = DbgFinder.compile_unit_end(); I != E; ++I)
1757 constructCompileUnit(*I);
1759 if (CompileUnits.empty()) {
1760 if (TimePassesIsEnabled)
1761 DebugTimer->stopTimer();
1766 // If main compile unit for this module is not seen than randomly
1767 // select first compile unit.
1769 ModuleCU = CompileUnits[0];
1771 // Create DIEs for each subprogram.
1772 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1773 E = DbgFinder.subprogram_end(); I != E; ++I)
1774 constructSubprogramDIE(*I);
1776 // Create DIEs for each global variable.
1777 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1778 E = DbgFinder.global_variable_end(); I != E; ++I)
1779 constructGlobalVariableDIE(*I);
1783 MMI->setDebugInfoAvailability(true);
1785 // Prime section data.
1786 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1788 // Print out .file directives to specify files for .loc directives. These are
1789 // printed out early so that they precede any .loc directives.
1790 if (MAI->hasDotLocAndDotFile()) {
1791 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1792 // Remember source id starts at 1.
1793 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1794 // FIXME: don't use sys::path for this! This should not depend on the
1796 sys::Path FullPath(getSourceDirectoryName(Id.first));
1798 FullPath.appendComponent(getSourceFileName(Id.second));
1799 assert(AppendOk && "Could not append filename to directory!");
1801 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1805 // Emit initial sections
1808 if (TimePassesIsEnabled)
1809 DebugTimer->stopTimer();
1812 /// endModule - Emit all Dwarf sections that should come after the content.
1814 void DwarfDebug::endModule() {
1818 if (TimePassesIsEnabled)
1819 DebugTimer->startTimer();
1821 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1822 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1823 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1825 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1828 // Insert top level DIEs.
1829 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1830 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1831 ModuleCU->getCUDie()->addChild(*TI);
1833 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1834 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1835 DIE *SPDie = CI->first;
1836 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1838 DIE *NDie = ModuleCU->getDIE(N);
1839 if (!NDie) continue;
1840 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1841 // FIXME - This is not the correct approach.
1842 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1845 // Standard sections final addresses.
1846 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1847 EmitLabel("text_end", 0);
1848 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1849 EmitLabel("data_end", 0);
1851 // End text sections.
1852 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1853 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1854 EmitLabel("section_end", i);
1857 // Emit common frame information.
1858 emitCommonDebugFrame();
1860 // Emit function debug frame information
1861 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1862 E = DebugFrames.end(); I != E; ++I)
1863 emitFunctionDebugFrame(*I);
1865 // Compute DIE offsets and sizes.
1866 computeSizeAndOffsets();
1868 // Emit all the DIEs into a debug info section
1871 // Corresponding abbreviations into a abbrev section.
1872 emitAbbreviations();
1874 // Emit source line correspondence into a debug line section.
1877 // Emit info into a debug pubnames section.
1878 emitDebugPubNames();
1880 // Emit info into a debug pubtypes section.
1881 emitDebugPubTypes();
1883 // Emit info into a debug str section.
1886 // Emit info into a debug loc section.
1889 // Emit info into a debug aranges section.
1892 // Emit info into a debug ranges section.
1895 // Emit info into a debug macinfo section.
1898 // Emit inline info.
1899 emitDebugInlineInfo();
1901 if (TimePassesIsEnabled)
1902 DebugTimer->stopTimer();
1905 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1906 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1908 DILocation &ScopeLoc) {
1910 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1912 return AbsDbgVariable;
1914 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1918 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1919 Scope->addVariable(AbsDbgVariable);
1920 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1921 return AbsDbgVariable;
1924 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1925 void DwarfDebug::collectVariableInfo() {
1928 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1929 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1930 VE = VMap.end(); VI != VE; ++VI) {
1931 MDNode *Var = VI->first;
1933 DIVariable DV (Var);
1934 std::pair< unsigned, MDNode *> VP = VI->second;
1935 DILocation ScopeLoc(VP.second);
1938 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1940 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1941 // If variable scope is not found then skip this variable.
1945 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1946 Scope->addVariable(RegVar);
1947 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1949 RegVar->setAbstractVariable(AbsDbgVariable);
1953 /// beginScope - Process beginning of a scope starting at Label.
1954 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1955 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1956 if (I == DbgScopeBeginMap.end())
1958 ScopeVector &SD = I->second;
1959 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1961 (*SDI)->setStartLabelID(Label);
1964 /// endScope - Process end of a scope.
1965 void DwarfDebug::endScope(const MachineInstr *MI) {
1966 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1967 if (I == DbgScopeEndMap.end())
1970 unsigned Label = MMI->NextLabelID();
1971 Asm->printLabel(Label);
1974 SmallVector<DbgScope *, 2> &SD = I->second;
1975 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1977 (*SDI)->setEndLabelID(Label);
1981 /// createDbgScope - Create DbgScope for the scope.
1982 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1985 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1988 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1989 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1990 if (DIDescriptor(Scope).isLexicalBlock())
1991 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1995 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1999 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2000 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2001 DILocation DL(InlinedAt);
2002 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2005 /// extractScopeInformation - Scan machine instructions in this function
2006 /// and collect DbgScopes. Return true, if atleast one scope was found.
2007 bool DwarfDebug::extractScopeInformation() {
2008 // If scope information was extracted using .dbg intrinsics then there is not
2009 // any need to extract these information by scanning each instruction.
2010 if (!DbgScopeMap.empty())
2013 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2014 unsigned MIIndex = 0;
2015 // Scan each instruction and create scopes. First build working set of scopes.
2016 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2018 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2020 const MachineInstr *MInsn = II;
2021 MIIndexMap[MInsn] = MIIndex++;
2022 DebugLoc DL = MInsn->getDebugLoc();
2023 if (DL.isUnknown()) continue;
2024 DILocation DLT = MF->getDILocation(DL);
2025 DIScope DLTScope = DLT.getScope();
2026 if (DLTScope.isNull()) continue;
2027 // There is no need to create another DIE for compile unit. For all
2028 // other scopes, create one DbgScope now. This will be translated
2029 // into a scope DIE at the end.
2030 if (DLTScope.isCompileUnit()) continue;
2031 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2036 // Build scope hierarchy using working set of scopes.
2037 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2039 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2041 const MachineInstr *MInsn = II;
2042 DebugLoc DL = MInsn->getDebugLoc();
2043 if (DL.isUnknown()) continue;
2044 DILocation DLT = MF->getDILocation(DL);
2045 DIScope DLTScope = DLT.getScope();
2046 if (DLTScope.isNull()) continue;
2047 // There is no need to create another DIE for compile unit. For all
2048 // other scopes, create one DbgScope now. This will be translated
2049 // into a scope DIE at the end.
2050 if (DLTScope.isCompileUnit()) continue;
2051 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2052 DLT.getOrigLocation().getNode());
2053 Scope->setLastInsn(MInsn);
2057 if (!CurrentFnDbgScope)
2060 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2062 // Each scope has first instruction and last instruction to mark beginning
2063 // and end of a scope respectively. Create an inverse map that list scopes
2064 // starts (and ends) with an instruction. One instruction may start (or end)
2065 // multiple scopes. Ignore scopes that are not reachable.
2066 SmallVector<DbgScope *, 4> WorkList;
2067 WorkList.push_back(CurrentFnDbgScope);
2068 while (!WorkList.empty()) {
2069 DbgScope *S = WorkList.back(); WorkList.pop_back();
2071 SmallVector<DbgScope *, 4> &Children = S->getScopes();
2072 if (!Children.empty())
2073 for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2074 SE = Children.end(); SI != SE; ++SI)
2075 WorkList.push_back(*SI);
2077 if (S->isAbstractScope())
2079 const MachineInstr *MI = S->getFirstInsn();
2080 assert (MI && "DbgScope does not have first instruction!");
2082 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2083 if (IDI != DbgScopeBeginMap.end())
2084 IDI->second.push_back(S);
2086 DbgScopeBeginMap[MI].push_back(S);
2088 MI = S->getLastInsn();
2089 assert (MI && "DbgScope does not have last instruction!");
2090 IDI = DbgScopeEndMap.find(MI);
2091 if (IDI != DbgScopeEndMap.end())
2092 IDI->second.push_back(S);
2094 DbgScopeEndMap[MI].push_back(S);
2097 return !DbgScopeMap.empty();
2100 /// beginFunction - Gather pre-function debug information. Assumes being
2101 /// emitted immediately after the function entry point.
2102 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2105 if (!ShouldEmitDwarfDebug()) return;
2107 if (TimePassesIsEnabled)
2108 DebugTimer->startTimer();
2110 if (!extractScopeInformation())
2113 collectVariableInfo();
2115 // Assumes in correct section after the entry point.
2116 EmitLabel("func_begin", ++SubprogramCount);
2118 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2120 DebugLoc FDL = MF->getDefaultDebugLoc();
2121 if (!FDL.isUnknown()) {
2122 DILocation DLT = MF->getDILocation(FDL);
2123 unsigned LabelID = 0;
2124 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2126 LabelID = recordSourceLine(SP.getLineNumber(), 0,
2127 DLT.getScope().getNode());
2129 LabelID = recordSourceLine(DLT.getLineNumber(),
2130 DLT.getColumnNumber(),
2131 DLT.getScope().getNode());
2132 Asm->printLabel(LabelID);
2135 if (TimePassesIsEnabled)
2136 DebugTimer->stopTimer();
2139 /// endFunction - Gather and emit post-function debug information.
2141 void DwarfDebug::endFunction(const MachineFunction *MF) {
2142 if (!ShouldEmitDwarfDebug()) return;
2144 if (TimePassesIsEnabled)
2145 DebugTimer->startTimer();
2147 if (DbgScopeMap.empty())
2150 if (CurrentFnDbgScope) {
2151 // Define end label for subprogram.
2152 EmitLabel("func_end", SubprogramCount);
2154 // Get function line info.
2155 if (!Lines.empty()) {
2156 // Get section line info.
2157 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2158 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2159 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2160 // Append the function info to section info.
2161 SectionLineInfos.insert(SectionLineInfos.end(),
2162 Lines.begin(), Lines.end());
2165 // Construct abstract scopes.
2166 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2167 AE = AbstractScopesList.end(); AI != AE; ++AI)
2168 constructScopeDIE(*AI);
2170 constructScopeDIE(CurrentFnDbgScope);
2172 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2173 MMI->getFrameMoves()));
2177 CurrentFnDbgScope = NULL;
2178 DbgScopeMap.clear();
2179 DbgScopeBeginMap.clear();
2180 DbgScopeEndMap.clear();
2181 ConcreteScopes.clear();
2182 AbstractScopesList.clear();
2185 if (TimePassesIsEnabled)
2186 DebugTimer->stopTimer();
2189 /// recordSourceLine - Records location information and associates it with a
2190 /// label. Returns a unique label ID used to generate a label and provide
2191 /// correspondence to the source line list.
2192 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2197 if (TimePassesIsEnabled)
2198 DebugTimer->startTimer();
2203 DIDescriptor Scope(S);
2204 if (Scope.isCompileUnit()) {
2205 DICompileUnit CU(S);
2206 Dir = CU.getDirectory();
2207 Fn = CU.getFilename();
2208 } else if (Scope.isSubprogram()) {
2210 Dir = SP.getDirectory();
2211 Fn = SP.getFilename();
2212 } else if (Scope.isLexicalBlock()) {
2213 DILexicalBlock DB(S);
2214 Dir = DB.getDirectory();
2215 Fn = DB.getFilename();
2217 assert (0 && "Unexpected scope info");
2219 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2220 unsigned ID = MMI->NextLabelID();
2221 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2223 if (TimePassesIsEnabled)
2224 DebugTimer->stopTimer();
2229 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2230 /// timed. Look up the source id with the given directory and source file
2231 /// names. If none currently exists, create a new id and insert it in the
2232 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2234 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2235 const std::string &FileName) {
2236 if (TimePassesIsEnabled)
2237 DebugTimer->startTimer();
2239 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2241 if (TimePassesIsEnabled)
2242 DebugTimer->stopTimer();
2247 //===----------------------------------------------------------------------===//
2249 //===----------------------------------------------------------------------===//
2251 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2254 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2255 // Get the children.
2256 const std::vector<DIE *> &Children = Die->getChildren();
2258 // If not last sibling and has children then add sibling offset attribute.
2259 if (!Last && !Children.empty()) Die->addSiblingOffset();
2261 // Record the abbreviation.
2262 assignAbbrevNumber(Die->getAbbrev());
2264 // Get the abbreviation for this DIE.
2265 unsigned AbbrevNumber = Die->getAbbrevNumber();
2266 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2269 Die->setOffset(Offset);
2271 // Start the size with the size of abbreviation code.
2272 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2274 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2275 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2277 // Size the DIE attribute values.
2278 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2279 // Size attribute value.
2280 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2282 // Size the DIE children if any.
2283 if (!Children.empty()) {
2284 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2285 "Children flag not set");
2287 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2288 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2290 // End of children marker.
2291 Offset += sizeof(int8_t);
2294 Die->setSize(Offset - Die->getOffset());
2298 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2300 void DwarfDebug::computeSizeAndOffsets() {
2301 // Compute size of compile unit header.
2302 static unsigned Offset =
2303 sizeof(int32_t) + // Length of Compilation Unit Info
2304 sizeof(int16_t) + // DWARF version number
2305 sizeof(int32_t) + // Offset Into Abbrev. Section
2306 sizeof(int8_t); // Pointer Size (in bytes)
2308 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2309 CompileUnitOffsets[ModuleCU] = 0;
2312 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2313 /// tools to recognize the object file contains Dwarf information.
2314 void DwarfDebug::emitInitial() {
2315 // Check to see if we already emitted intial headers.
2316 if (didInitial) return;
2319 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2321 // Dwarf sections base addresses.
2322 if (MAI->doesDwarfRequireFrameSection()) {
2323 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2324 EmitLabel("section_debug_frame", 0);
2327 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2328 EmitLabel("section_info", 0);
2329 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2330 EmitLabel("section_abbrev", 0);
2331 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2332 EmitLabel("section_aranges", 0);
2334 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2335 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2336 EmitLabel("section_macinfo", 0);
2339 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2340 EmitLabel("section_line", 0);
2341 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2342 EmitLabel("section_loc", 0);
2343 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2344 EmitLabel("section_pubnames", 0);
2345 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2346 EmitLabel("section_pubtypes", 0);
2347 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2348 EmitLabel("section_str", 0);
2349 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2350 EmitLabel("section_ranges", 0);
2352 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2353 EmitLabel("text_begin", 0);
2354 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2355 EmitLabel("data_begin", 0);
2358 /// emitDIE - Recusively Emits a debug information entry.
2360 void DwarfDebug::emitDIE(DIE *Die) {
2361 // Get the abbreviation for this DIE.
2362 unsigned AbbrevNumber = Die->getAbbrevNumber();
2363 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2367 // Emit the code (index) for the abbreviation.
2368 if (Asm->VerboseAsm)
2369 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2370 Twine::utohexstr(Die->getOffset()) + ":0x" +
2371 Twine::utohexstr(Die->getSize()) + " " +
2372 dwarf::TagString(Abbrev->getTag()));
2373 EmitULEB128(AbbrevNumber);
2375 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2376 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2378 // Emit the DIE attribute values.
2379 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2380 unsigned Attr = AbbrevData[i].getAttribute();
2381 unsigned Form = AbbrevData[i].getForm();
2382 assert(Form && "Too many attributes for DIE (check abbreviation)");
2384 if (Asm->VerboseAsm)
2385 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2388 case dwarf::DW_AT_sibling:
2389 Asm->EmitInt32(Die->getSiblingOffset());
2391 case dwarf::DW_AT_abstract_origin: {
2392 DIEEntry *E = cast<DIEEntry>(Values[i]);
2393 DIE *Origin = E->getEntry();
2394 unsigned Addr = Origin->getOffset();
2395 Asm->EmitInt32(Addr);
2399 // Emit an attribute using the defined form.
2400 Values[i]->EmitValue(this, Form);
2401 O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2406 // Emit the DIE children if any.
2407 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2408 const std::vector<DIE *> &Children = Die->getChildren();
2410 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2411 emitDIE(Children[j]);
2413 Asm->EmitInt8(0); EOL("End Of Children Mark");
2417 /// emitDebugInfo - Emit the debug info section.
2419 void DwarfDebug::emitDebugInfo() {
2420 // Start debug info section.
2421 Asm->OutStreamer.SwitchSection(
2422 Asm->getObjFileLowering().getDwarfInfoSection());
2423 DIE *Die = ModuleCU->getCUDie();
2425 // Emit the compile units header.
2426 EmitLabel("info_begin", ModuleCU->getID());
2428 // Emit size of content not including length itself
2429 unsigned ContentSize = Die->getSize() +
2430 sizeof(int16_t) + // DWARF version number
2431 sizeof(int32_t) + // Offset Into Abbrev. Section
2432 sizeof(int8_t) + // Pointer Size (in bytes)
2433 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2435 Asm->EmitInt32(ContentSize); EOL("Length of Compilation Unit Info");
2436 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2437 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2438 EOL("Offset Into Abbrev. Section");
2439 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2442 // FIXME - extra padding for gdb bug.
2443 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2444 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2445 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2446 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2447 EmitLabel("info_end", ModuleCU->getID());
2451 /// emitAbbreviations - Emit the abbreviation section.
2453 void DwarfDebug::emitAbbreviations() const {
2454 // Check to see if it is worth the effort.
2455 if (!Abbreviations.empty()) {
2456 // Start the debug abbrev section.
2457 Asm->OutStreamer.SwitchSection(
2458 Asm->getObjFileLowering().getDwarfAbbrevSection());
2460 EmitLabel("abbrev_begin", 0);
2462 // For each abbrevation.
2463 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2464 // Get abbreviation data
2465 const DIEAbbrev *Abbrev = Abbreviations[i];
2467 // Emit the abbrevations code (base 1 index.)
2468 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2470 // Emit the abbreviations data.
2475 // Mark end of abbreviations.
2476 EmitULEB128(0, "EOM(3)");
2478 EmitLabel("abbrev_end", 0);
2483 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2484 /// the line matrix.
2486 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2487 // Define last address of section.
2488 Asm->EmitInt8(0); EOL("Extended Op");
2489 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2490 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2491 EmitReference("section_end", SectionEnd); EOL("Section end label");
2493 // Mark end of matrix.
2494 Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2499 /// emitDebugLines - Emit source line information.
2501 void DwarfDebug::emitDebugLines() {
2502 // If the target is using .loc/.file, the assembler will be emitting the
2503 // .debug_line table automatically.
2504 if (MAI->hasDotLocAndDotFile())
2507 // Minimum line delta, thus ranging from -10..(255-10).
2508 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2509 // Maximum line delta, thus ranging from -10..(255-10).
2510 const int MaxLineDelta = 255 + MinLineDelta;
2512 // Start the dwarf line section.
2513 Asm->OutStreamer.SwitchSection(
2514 Asm->getObjFileLowering().getDwarfLineSection());
2516 // Construct the section header.
2517 EmitDifference("line_end", 0, "line_begin", 0, true);
2518 EOL("Length of Source Line Info");
2519 EmitLabel("line_begin", 0);
2521 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2523 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2524 EOL("Prolog Length");
2525 EmitLabel("line_prolog_begin", 0);
2527 Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2528 Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2529 Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2530 Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2531 Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2533 // Line number standard opcode encodings argument count
2534 Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2535 Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2536 Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2537 Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2538 Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2539 Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2540 Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2541 Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2542 Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2544 // Emit directories.
2545 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2546 const std::string &Dir = getSourceDirectoryName(DI);
2547 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2548 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2551 Asm->EmitInt8(0); EOL("End of directories");
2554 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2555 // Remember source id starts at 1.
2556 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2557 const std::string &FN = getSourceFileName(Id.second);
2558 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2559 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2561 EmitULEB128(Id.first, "Directory #");
2562 EmitULEB128(0, "Mod date");
2563 EmitULEB128(0, "File size");
2566 Asm->EmitInt8(0); EOL("End of files");
2568 EmitLabel("line_prolog_end", 0);
2570 // A sequence for each text section.
2571 unsigned SecSrcLinesSize = SectionSourceLines.size();
2573 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2574 // Isolate current sections line info.
2575 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2577 /*if (Asm->isVerbose()) {
2578 const MCSection *S = SectionMap[j + 1];
2579 O << '\t' << MAI->getCommentString() << " Section"
2580 << S->getName() << '\n';
2584 // Dwarf assumes we start with first line of first source file.
2585 unsigned Source = 1;
2588 // Construct rows of the address, source, line, column matrix.
2589 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2590 const SrcLineInfo &LineInfo = LineInfos[i];
2591 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2592 if (!LabelID) continue;
2594 if (LineInfo.getLine() == 0) continue;
2596 if (!Asm->isVerbose())
2599 std::pair<unsigned, unsigned> SourceID =
2600 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2601 O << '\t' << MAI->getCommentString() << ' '
2602 << getSourceDirectoryName(SourceID.first) << '/'
2603 << getSourceFileName(SourceID.second)
2604 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2607 // Define the line address.
2608 Asm->EmitInt8(0); EOL("Extended Op");
2609 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2610 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2611 EmitReference("label", LabelID); EOL("Location label");
2613 // If change of source, then switch to the new source.
2614 if (Source != LineInfo.getSourceID()) {
2615 Source = LineInfo.getSourceID();
2616 Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2617 EmitULEB128(Source, "New Source");
2620 // If change of line.
2621 if (Line != LineInfo.getLine()) {
2622 // Determine offset.
2623 int Offset = LineInfo.getLine() - Line;
2624 int Delta = Offset - MinLineDelta;
2627 Line = LineInfo.getLine();
2629 // If delta is small enough and in range...
2630 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2631 // ... then use fast opcode.
2632 Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2634 // ... otherwise use long hand.
2635 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2636 EOL("DW_LNS_advance_line");
2637 EmitSLEB128(Offset, "Line Offset");
2638 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2641 // Copy the previous row (different address or source)
2642 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2646 emitEndOfLineMatrix(j + 1);
2649 if (SecSrcLinesSize == 0)
2650 // Because we're emitting a debug_line section, we still need a line
2651 // table. The linker and friends expect it to exist. If there's nothing to
2652 // put into it, emit an empty table.
2653 emitEndOfLineMatrix(1);
2655 EmitLabel("line_end", 0);
2659 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2661 void DwarfDebug::emitCommonDebugFrame() {
2662 if (!MAI->doesDwarfRequireFrameSection())
2666 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2667 TargetFrameInfo::StackGrowsUp ?
2668 TD->getPointerSize() : -TD->getPointerSize();
2670 // Start the dwarf frame section.
2671 Asm->OutStreamer.SwitchSection(
2672 Asm->getObjFileLowering().getDwarfFrameSection());
2674 EmitLabel("debug_frame_common", 0);
2675 EmitDifference("debug_frame_common_end", 0,
2676 "debug_frame_common_begin", 0, true);
2677 EOL("Length of Common Information Entry");
2679 EmitLabel("debug_frame_common_begin", 0);
2680 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2681 EOL("CIE Identifier Tag");
2682 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2684 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2685 EOL("CIE Augmentation");
2686 EmitULEB128(1, "CIE Code Alignment Factor");
2687 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2688 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2689 EOL("CIE RA Column");
2691 std::vector<MachineMove> Moves;
2692 RI->getInitialFrameState(Moves);
2694 EmitFrameMoves(NULL, 0, Moves, false);
2696 Asm->EmitAlignment(2, 0, 0, false);
2697 EmitLabel("debug_frame_common_end", 0);
2701 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2704 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2705 if (!MAI->doesDwarfRequireFrameSection())
2708 // Start the dwarf frame section.
2709 Asm->OutStreamer.SwitchSection(
2710 Asm->getObjFileLowering().getDwarfFrameSection());
2712 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2713 "debug_frame_begin", DebugFrameInfo.Number, true);
2714 EOL("Length of Frame Information Entry");
2716 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2718 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2720 EOL("FDE CIE offset");
2722 EmitReference("func_begin", DebugFrameInfo.Number);
2723 EOL("FDE initial location");
2724 EmitDifference("func_end", DebugFrameInfo.Number,
2725 "func_begin", DebugFrameInfo.Number);
2726 EOL("FDE address range");
2728 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2731 Asm->EmitAlignment(2, 0, 0, false);
2732 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2736 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2738 void DwarfDebug::emitDebugPubNames() {
2739 // Start the dwarf pubnames section.
2740 Asm->OutStreamer.SwitchSection(
2741 Asm->getObjFileLowering().getDwarfPubNamesSection());
2743 EmitDifference("pubnames_end", ModuleCU->getID(),
2744 "pubnames_begin", ModuleCU->getID(), true);
2745 EOL("Length of Public Names Info");
2747 EmitLabel("pubnames_begin", ModuleCU->getID());
2749 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2751 EmitSectionOffset("info_begin", "section_info",
2752 ModuleCU->getID(), 0, true, false);
2753 EOL("Offset of Compilation Unit Info");
2755 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2757 EOL("Compilation Unit Length");
2759 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2760 for (StringMap<DIE*>::const_iterator
2761 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2762 const char *Name = GI->getKeyData();
2763 DIE * Entity = GI->second;
2765 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2767 if (Asm->VerboseAsm)
2768 Asm->OutStreamer.AddComment("External Name");
2769 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2772 Asm->EmitInt32(0); EOL("End Mark");
2773 EmitLabel("pubnames_end", ModuleCU->getID());
2777 void DwarfDebug::emitDebugPubTypes() {
2778 // Start the dwarf pubnames section.
2779 Asm->OutStreamer.SwitchSection(
2780 Asm->getObjFileLowering().getDwarfPubTypesSection());
2781 EmitDifference("pubtypes_end", ModuleCU->getID(),
2782 "pubtypes_begin", ModuleCU->getID(), true);
2783 EOL("Length of Public Types Info");
2785 EmitLabel("pubtypes_begin", ModuleCU->getID());
2787 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2788 Asm->EmitInt16(dwarf::DWARF_VERSION);
2790 EmitSectionOffset("info_begin", "section_info",
2791 ModuleCU->getID(), 0, true, false);
2792 EOL("Offset of Compilation ModuleCU Info");
2794 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2796 EOL("Compilation ModuleCU Length");
2798 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2799 for (StringMap<DIE*>::const_iterator
2800 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2801 const char *Name = GI->getKeyData();
2802 DIE * Entity = GI->second;
2804 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2805 Asm->EmitInt32(Entity->getOffset());
2807 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2808 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2811 Asm->EmitInt32(0); EOL("End Mark");
2812 EmitLabel("pubtypes_end", ModuleCU->getID());
2816 /// emitDebugStr - Emit visible names into a debug str section.
2818 void DwarfDebug::emitDebugStr() {
2819 // Check to see if it is worth the effort.
2820 if (!StringPool.empty()) {
2821 // Start the dwarf str section.
2822 Asm->OutStreamer.SwitchSection(
2823 Asm->getObjFileLowering().getDwarfStrSection());
2825 // For each of strings in the string pool.
2826 for (unsigned StringID = 1, N = StringPool.size();
2827 StringID <= N; ++StringID) {
2828 // Emit a label for reference from debug information entries.
2829 EmitLabel("string", StringID);
2831 // Emit the string itself.
2832 const std::string &String = StringPool[StringID];
2833 Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2840 /// emitDebugLoc - Emit visible names into a debug loc section.
2842 void DwarfDebug::emitDebugLoc() {
2843 // Start the dwarf loc section.
2844 Asm->OutStreamer.SwitchSection(
2845 Asm->getObjFileLowering().getDwarfLocSection());
2848 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2850 void DwarfDebug::EmitDebugARanges() {
2851 // Start the dwarf aranges section.
2852 Asm->OutStreamer.SwitchSection(
2853 Asm->getObjFileLowering().getDwarfARangesSection());
2857 CompileUnit *Unit = GetBaseCompileUnit();
2859 // Don't include size of length
2860 Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2862 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2864 EmitReference("info_begin", Unit->getID());
2865 EOL("Offset of Compilation Unit Info");
2867 Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2869 Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2871 Asm->EmitInt16(0); EOL("Pad (1)");
2872 Asm->EmitInt16(0); EOL("Pad (2)");
2875 EmitReference("text_begin", 0); EOL("Address");
2876 EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
2878 Asm->EmitInt32(0); EOL("EOM (1)");
2879 Asm->EmitInt32(0); EOL("EOM (2)");
2883 /// emitDebugRanges - Emit visible names into a debug ranges section.
2885 void DwarfDebug::emitDebugRanges() {
2886 // Start the dwarf ranges section.
2887 Asm->OutStreamer.SwitchSection(
2888 Asm->getObjFileLowering().getDwarfRangesSection());
2891 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2893 void DwarfDebug::emitDebugMacInfo() {
2894 if (const MCSection *LineInfo =
2895 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2896 // Start the dwarf macinfo section.
2897 Asm->OutStreamer.SwitchSection(LineInfo);
2901 /// emitDebugInlineInfo - Emit inline info using following format.
2903 /// 1. length of section
2904 /// 2. Dwarf version number
2905 /// 3. address size.
2907 /// Entries (one "entry" for each function that was inlined):
2909 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2910 /// otherwise offset into __debug_str for regular function name.
2911 /// 2. offset into __debug_str section for regular function name.
2912 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2913 /// instances for the function.
2915 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2916 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2917 /// __debug_info section, and the low_pc is the starting address for the
2918 /// inlining instance.
2919 void DwarfDebug::emitDebugInlineInfo() {
2920 if (!MAI->doesDwarfUsesInlineInfoSection())
2926 Asm->OutStreamer.SwitchSection(
2927 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2929 EmitDifference("debug_inlined_end", 1,
2930 "debug_inlined_begin", 1, true);
2931 EOL("Length of Debug Inlined Information Entry");
2933 EmitLabel("debug_inlined_begin", 1);
2935 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2936 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2938 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2939 E = InlinedSPNodes.end(); I != E; ++I) {
2942 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2943 = InlineInfo.find(Node);
2944 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2945 DISubprogram SP(Node);
2946 StringRef LName = SP.getLinkageName();
2947 StringRef Name = SP.getName();
2949 if (LName.empty()) {
2950 Asm->OutStreamer.EmitBytes(Name, 0);
2951 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2953 EmitSectionOffset("string", "section_str",
2954 StringPool.idFor(getRealLinkageName(LName)), false, true);
2956 EOL("MIPS linkage name");
2957 EmitSectionOffset("string", "section_str",
2958 StringPool.idFor(Name), false, true);
2959 EOL("Function name");
2960 EmitULEB128(Labels.size(), "Inline count");
2962 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2963 LE = Labels.end(); LI != LE; ++LI) {
2964 DIE *SP = LI->second;
2965 Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
2967 if (TD->getPointerSize() == sizeof(int32_t))
2968 O << MAI->getData32bitsDirective();
2970 O << MAI->getData64bitsDirective();
2972 PrintLabelName("label", LI->first); EOL("low_pc");
2976 EmitLabel("debug_inlined_end", 1);