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 if (DT.getTag() == dwarf::DW_TAG_inheritance
1127 && DT.isVirtual()) {
1129 // For C++, virtual base classes are not at fixed offset. Use following
1130 // expression to extract appropriate offset from vtable.
1131 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1133 DIEBlock *VBaseLocationDie = new DIEBlock();
1134 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1135 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1136 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1137 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1138 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1139 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1140 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1142 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1145 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1147 if (DT.isProtected())
1148 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1149 dwarf::DW_ACCESS_protected);
1150 else if (DT.isPrivate())
1151 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1152 dwarf::DW_ACCESS_private);
1153 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1154 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1155 dwarf::DW_ACCESS_public);
1157 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1158 dwarf::DW_VIRTUALITY_virtual);
1162 /// createSubprogramDIE - Create new DIE using SP.
1163 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1164 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1168 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1169 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1171 StringRef LinkageName = SP.getLinkageName();
1172 if (!LinkageName.empty())
1173 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1174 getRealLinkageName(LinkageName));
1176 addSourceLine(SPDie, &SP);
1178 // Add prototyped tag, if C or ObjC.
1179 unsigned Lang = SP.getCompileUnit().getLanguage();
1180 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1181 Lang == dwarf::DW_LANG_ObjC)
1182 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1185 DICompositeType SPTy = SP.getType();
1186 DIArray Args = SPTy.getTypeArray();
1187 unsigned SPTag = SPTy.getTag();
1189 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1190 addType(SPDie, SPTy);
1192 addType(SPDie, DIType(Args.getElement(0).getNode()));
1194 unsigned VK = SP.getVirtuality();
1196 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1197 DIEBlock *Block = new DIEBlock();
1198 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1199 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1200 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1201 ContainingTypeMap.insert(std::make_pair(SPDie,
1202 SP.getContainingType().getNode()));
1205 if (MakeDecl || !SP.isDefinition()) {
1206 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1208 // Add arguments. Do not add arguments for subprogram definition. They will
1209 // be handled while processing variables.
1210 DICompositeType SPTy = SP.getType();
1211 DIArray Args = SPTy.getTypeArray();
1212 unsigned SPTag = SPTy.getTag();
1214 if (SPTag == dwarf::DW_TAG_subroutine_type)
1215 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1216 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1217 addType(Arg, DIType(Args.getElement(i).getNode()));
1218 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1219 SPDie->addChild(Arg);
1223 if (SP.isArtificial())
1224 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1226 // DW_TAG_inlined_subroutine may refer to this DIE.
1227 ModuleCU->insertDIE(SP.getNode(), SPDie);
1231 /// findCompileUnit - Get the compile unit for the given descriptor.
1233 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1234 DenseMap<Value *, CompileUnit *>::const_iterator I =
1235 CompileUnitMap.find(Unit.getNode());
1236 if (I == CompileUnitMap.end())
1237 return constructCompileUnit(Unit.getNode());
1241 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1242 /// Initialize scope and update scope hierarchy.
1243 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1244 MDNode *InlinedAt) {
1245 assert (N && "Invalid Scope encoding!");
1246 assert (MI && "Missing machine instruction!");
1247 bool GetConcreteScope = (MI && InlinedAt);
1249 DbgScope *NScope = NULL;
1252 NScope = DbgScopeMap.lookup(InlinedAt);
1254 NScope = DbgScopeMap.lookup(N);
1255 assert (NScope && "Unable to find working scope!");
1257 if (NScope->getFirstInsn())
1260 DbgScope *Parent = NULL;
1261 if (GetConcreteScope) {
1262 DILocation IL(InlinedAt);
1263 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1264 IL.getOrigLocation().getNode());
1265 assert (Parent && "Unable to find Parent scope!");
1266 NScope->setParent(Parent);
1267 Parent->addScope(NScope);
1268 } else if (DIDescriptor(N).isLexicalBlock()) {
1269 DILexicalBlock DB(N);
1270 if (!DB.getContext().isNull()) {
1271 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1272 NScope->setParent(Parent);
1273 Parent->addScope(NScope);
1277 NScope->setFirstInsn(MI);
1279 if (!Parent && !InlinedAt) {
1280 StringRef SPName = DISubprogram(N).getLinkageName();
1281 if (SPName == MF->getFunction()->getName())
1282 CurrentFnDbgScope = NScope;
1285 if (GetConcreteScope) {
1286 ConcreteScopes[InlinedAt] = NScope;
1287 getOrCreateAbstractScope(N);
1293 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1294 assert (N && "Invalid Scope encoding!");
1296 DbgScope *AScope = AbstractScopes.lookup(N);
1300 DbgScope *Parent = NULL;
1302 DIDescriptor Scope(N);
1303 if (Scope.isLexicalBlock()) {
1304 DILexicalBlock DB(N);
1305 DIDescriptor ParentDesc = DB.getContext();
1306 if (!ParentDesc.isNull())
1307 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1310 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1313 Parent->addScope(AScope);
1314 AScope->setAbstractScope();
1315 AbstractScopes[N] = AScope;
1316 if (DIDescriptor(N).isSubprogram())
1317 AbstractScopesList.push_back(AScope);
1321 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1322 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1323 /// If there are global variables in this scope then create and insert
1324 /// DIEs for these variables.
1325 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1327 DIE *SPDie = ModuleCU->getDIE(SPNode);
1328 assert (SPDie && "Unable to find subprogram DIE!");
1329 DISubprogram SP(SPNode);
1330 // There is not any need to generate specification DIE for a function
1331 // defined at compile unit level. If a function is defined inside another
1332 // function then gdb prefers the definition at top level and but does not
1333 // expect specification DIE in parent function. So avoid creating
1334 // specification DIE for a function defined inside a function.
1335 if (SP.isDefinition() && !SP.getContext().isCompileUnit()
1336 && !SP.getContext().isSubprogram()) {
1337 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1339 DICompositeType SPTy = SP.getType();
1340 DIArray Args = SPTy.getTypeArray();
1341 unsigned SPTag = SPTy.getTag();
1342 if (SPTag == dwarf::DW_TAG_subroutine_type)
1343 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1344 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1345 addType(Arg, DIType(Args.getElement(i).getNode()));
1346 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1347 SPDie->addChild(Arg);
1349 DIE *SPDeclDie = SPDie;
1350 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1351 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1353 ModuleCU->addDie(SPDie);
1356 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1357 DWLabel("func_begin", SubprogramCount));
1358 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1359 DWLabel("func_end", SubprogramCount));
1360 MachineLocation Location(RI->getFrameRegister(*MF));
1361 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1363 if (!DISubprogram(SPNode).isLocalToUnit())
1364 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1369 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1370 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1371 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1372 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1373 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1375 // Ignore empty scopes.
1376 if (StartID == EndID && StartID != 0)
1379 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1380 if (Scope->isAbstractScope())
1383 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1385 DWLabel("label", StartID)
1386 : DWLabel("func_begin", SubprogramCount));
1387 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1389 DWLabel("label", EndID)
1390 : DWLabel("func_end", SubprogramCount));
1397 /// constructInlinedScopeDIE - This scope represents inlined body of
1398 /// a function. Construct DIE to represent this concrete inlined copy
1399 /// of the function.
1400 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1401 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1402 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1403 assert (StartID && "Invalid starting label for an inlined scope!");
1404 assert (EndID && "Invalid end label for an inlined scope!");
1405 // Ignore empty scopes.
1406 if (StartID == EndID && StartID != 0)
1409 DIScope DS(Scope->getScopeNode());
1412 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1414 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1415 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1416 assert (OriginDIE && "Unable to find Origin DIE!");
1417 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1418 dwarf::DW_FORM_ref4, OriginDIE);
1420 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1421 DWLabel("label", StartID));
1422 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1423 DWLabel("label", EndID));
1425 InlinedSubprogramDIEs.insert(OriginDIE);
1427 // Track the start label for this inlined function.
1428 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1429 I = InlineInfo.find(InlinedSP.getNode());
1431 if (I == InlineInfo.end()) {
1432 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1434 InlinedSPNodes.push_back(InlinedSP.getNode());
1436 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1438 StringPool.insert(InlinedSP.getName());
1439 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1441 DILocation DL(Scope->getInlinedAt());
1442 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1443 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1449 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1450 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1451 // Get the descriptor.
1452 const DIVariable &VD = DV->getVariable();
1453 StringRef Name = VD.getName();
1457 // Translate tag to proper Dwarf tag. The result variable is dropped for
1460 switch (VD.getTag()) {
1461 case dwarf::DW_TAG_return_variable:
1463 case dwarf::DW_TAG_arg_variable:
1464 Tag = dwarf::DW_TAG_formal_parameter;
1466 case dwarf::DW_TAG_auto_variable: // fall thru
1468 Tag = dwarf::DW_TAG_variable;
1472 // Define variable debug information entry.
1473 DIE *VariableDie = new DIE(Tag);
1477 if (DbgVariable *AV = DV->getAbstractVariable())
1478 AbsDIE = AV->getDIE();
1481 DIScope DS(Scope->getScopeNode());
1482 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1483 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1485 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1486 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1487 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1488 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1489 dwarf::DW_FORM_ref4, AbsDIE);
1492 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1493 addSourceLine(VariableDie, &VD);
1495 // Add variable type.
1496 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1497 // addresses instead.
1498 if (VD.isBlockByrefVariable())
1499 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1501 addType(VariableDie, VD.getType());
1504 // Add variable address.
1505 if (!Scope->isAbstractScope()) {
1506 MachineLocation Location;
1508 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1509 Location.set(FrameReg, Offset);
1511 if (VD.hasComplexAddress())
1512 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1513 else if (VD.isBlockByrefVariable())
1514 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1516 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1518 DV->setDIE(VariableDie);
1523 void DwarfDebug::addPubTypes(DISubprogram SP) {
1524 DICompositeType SPTy = SP.getType();
1525 unsigned SPTag = SPTy.getTag();
1526 if (SPTag != dwarf::DW_TAG_subroutine_type)
1529 DIArray Args = SPTy.getTypeArray();
1533 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1534 DIType ATy(Args.getElement(i).getNode());
1537 DICompositeType CATy = getDICompositeType(ATy);
1538 if (!CATy.isNull() && !CATy.getName().empty()) {
1539 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1540 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1545 /// constructScopeDIE - Construct a DIE for this scope.
1546 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1549 DIScope DS(Scope->getScopeNode());
1553 DIE *ScopeDIE = NULL;
1554 if (Scope->getInlinedAt())
1555 ScopeDIE = constructInlinedScopeDIE(Scope);
1556 else if (DS.isSubprogram()) {
1557 if (Scope->isAbstractScope())
1558 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1560 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1563 ScopeDIE = constructLexicalScopeDIE(Scope);
1564 if (!ScopeDIE) return NULL;
1567 // Add variables to scope.
1568 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1569 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1570 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1572 ScopeDIE->addChild(VariableDIE);
1575 // Add nested scopes.
1576 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1577 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1578 // Define the Scope debug information entry.
1579 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1581 ScopeDIE->addChild(NestedDIE);
1584 if (DS.isSubprogram())
1585 addPubTypes(DISubprogram(DS.getNode()));
1590 /// GetOrCreateSourceID - Look up the source id with the given directory and
1591 /// source file names. If none currently exists, create a new id and insert it
1592 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1594 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1596 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1597 if (DI != DirectoryIdMap.end()) {
1598 DId = DI->getValue();
1600 DId = DirectoryNames.size() + 1;
1601 DirectoryIdMap[DirName] = DId;
1602 DirectoryNames.push_back(DirName);
1606 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1607 if (FI != SourceFileIdMap.end()) {
1608 FId = FI->getValue();
1610 FId = SourceFileNames.size() + 1;
1611 SourceFileIdMap[FileName] = FId;
1612 SourceFileNames.push_back(FileName);
1615 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1616 SourceIdMap.find(std::make_pair(DId, FId));
1617 if (SI != SourceIdMap.end())
1620 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1621 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1622 SourceIds.push_back(std::make_pair(DId, FId));
1627 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1628 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1629 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1632 NDie = new DIE(dwarf::DW_TAG_namespace);
1633 ModuleCU->insertDIE(NS.getNode(), NDie);
1634 if (!NS.getName().empty())
1635 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1636 addSourceLine(NDie, &NS);
1637 addToContextOwner(NDie, NS.getContext());
1641 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1642 DICompileUnit DIUnit(N);
1643 StringRef FN = DIUnit.getFilename();
1644 StringRef Dir = DIUnit.getDirectory();
1645 unsigned ID = GetOrCreateSourceID(Dir, FN);
1647 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1648 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1649 DWLabel("section_line", 0), DWLabel("section_line", 0),
1651 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1652 DIUnit.getProducer());
1653 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1654 DIUnit.getLanguage());
1655 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1658 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1659 if (DIUnit.isOptimized())
1660 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1662 StringRef Flags = DIUnit.getFlags();
1664 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1666 unsigned RVer = DIUnit.getRunTimeVersion();
1668 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1669 dwarf::DW_FORM_data1, RVer);
1671 CompileUnit *Unit = new CompileUnit(ID, Die);
1672 if (!ModuleCU && DIUnit.isMain()) {
1673 // Use first compile unit marked as isMain as the compile unit
1678 CompileUnitMap[DIUnit.getNode()] = Unit;
1679 CompileUnits.push_back(Unit);
1683 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1684 DIGlobalVariable DI_GV(N);
1686 // If debug information is malformed then ignore it.
1687 if (DI_GV.Verify() == false)
1690 // Check for pre-existence.
1691 if (ModuleCU->getDIE(DI_GV.getNode()))
1694 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1699 ModuleCU->insertDIE(N, VariableDie);
1701 // Add to context owner.
1702 DIDescriptor GVContext = DI_GV.getContext();
1703 // Do not create specification DIE if context is either compile unit
1705 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1706 && !GVContext.isSubprogram()) {
1707 // Create specification DIE.
1708 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1709 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1710 dwarf::DW_FORM_ref4, VariableDie);
1711 DIEBlock *Block = new DIEBlock();
1712 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1713 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1714 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1715 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1716 ModuleCU->addDie(VariableSpecDIE);
1718 DIEBlock *Block = new DIEBlock();
1719 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1720 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1721 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1722 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1724 addToContextOwner(VariableDie, GVContext);
1726 // Expose as global. FIXME - need to check external flag.
1727 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1729 DIType GTy = DI_GV.getType();
1730 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1731 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1732 assert (Entry && "Missing global type!");
1733 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1738 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1741 // Check for pre-existence.
1742 if (ModuleCU->getDIE(N))
1745 if (!SP.isDefinition())
1746 // This is a method declaration which will be handled while constructing
1750 DIE *SubprogramDie = createSubprogramDIE(SP);
1753 ModuleCU->insertDIE(N, SubprogramDie);
1755 // Add to context owner.
1756 addToContextOwner(SubprogramDie, SP.getContext());
1758 // Expose as global.
1759 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1764 /// beginModule - Emit all Dwarf sections that should come prior to the
1765 /// content. Create global DIEs and emit initial debug info sections.
1766 /// This is inovked by the target AsmPrinter.
1767 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1770 if (TimePassesIsEnabled)
1771 DebugTimer->startTimer();
1773 if (!MAI->doesSupportDebugInformation())
1776 DebugInfoFinder DbgFinder;
1777 DbgFinder.processModule(*M);
1779 // Create all the compile unit DIEs.
1780 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1781 E = DbgFinder.compile_unit_end(); I != E; ++I)
1782 constructCompileUnit(*I);
1784 if (CompileUnits.empty()) {
1785 if (TimePassesIsEnabled)
1786 DebugTimer->stopTimer();
1791 // If main compile unit for this module is not seen than randomly
1792 // select first compile unit.
1794 ModuleCU = CompileUnits[0];
1796 // Create DIEs for each subprogram.
1797 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1798 E = DbgFinder.subprogram_end(); I != E; ++I)
1799 constructSubprogramDIE(*I);
1801 // Create DIEs for each global variable.
1802 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1803 E = DbgFinder.global_variable_end(); I != E; ++I)
1804 constructGlobalVariableDIE(*I);
1808 MMI->setDebugInfoAvailability(true);
1810 // Prime section data.
1811 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1813 // Print out .file directives to specify files for .loc directives. These are
1814 // printed out early so that they precede any .loc directives.
1815 if (MAI->hasDotLocAndDotFile()) {
1816 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1817 // Remember source id starts at 1.
1818 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1819 // FIXME: don't use sys::path for this! This should not depend on the
1821 sys::Path FullPath(getSourceDirectoryName(Id.first));
1823 FullPath.appendComponent(getSourceFileName(Id.second));
1824 assert(AppendOk && "Could not append filename to directory!");
1826 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1830 // Emit initial sections
1833 if (TimePassesIsEnabled)
1834 DebugTimer->stopTimer();
1837 /// endModule - Emit all Dwarf sections that should come after the content.
1839 void DwarfDebug::endModule() {
1843 if (TimePassesIsEnabled)
1844 DebugTimer->startTimer();
1846 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1847 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1848 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1850 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1853 // Insert top level DIEs.
1854 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1855 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1856 ModuleCU->getCUDie()->addChild(*TI);
1858 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1859 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1860 DIE *SPDie = CI->first;
1861 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1863 DIE *NDie = ModuleCU->getDIE(N);
1864 if (!NDie) continue;
1865 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1866 // FIXME - This is not the correct approach.
1867 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1870 // Standard sections final addresses.
1871 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1872 EmitLabel("text_end", 0);
1873 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1874 EmitLabel("data_end", 0);
1876 // End text sections.
1877 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1878 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1879 EmitLabel("section_end", i);
1882 // Emit common frame information.
1883 emitCommonDebugFrame();
1885 // Emit function debug frame information
1886 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1887 E = DebugFrames.end(); I != E; ++I)
1888 emitFunctionDebugFrame(*I);
1890 // Compute DIE offsets and sizes.
1891 computeSizeAndOffsets();
1893 // Emit all the DIEs into a debug info section
1896 // Corresponding abbreviations into a abbrev section.
1897 emitAbbreviations();
1899 // Emit source line correspondence into a debug line section.
1902 // Emit info into a debug pubnames section.
1903 emitDebugPubNames();
1905 // Emit info into a debug pubtypes section.
1906 emitDebugPubTypes();
1908 // Emit info into a debug str section.
1911 // Emit info into a debug loc section.
1914 // Emit info into a debug aranges section.
1917 // Emit info into a debug ranges section.
1920 // Emit info into a debug macinfo section.
1923 // Emit inline info.
1924 emitDebugInlineInfo();
1926 if (TimePassesIsEnabled)
1927 DebugTimer->stopTimer();
1930 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1931 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1933 DILocation &ScopeLoc) {
1935 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1937 return AbsDbgVariable;
1939 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1943 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1944 Scope->addVariable(AbsDbgVariable);
1945 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1946 return AbsDbgVariable;
1949 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1950 void DwarfDebug::collectVariableInfo() {
1953 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1954 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1955 VE = VMap.end(); VI != VE; ++VI) {
1956 MDNode *Var = VI->first;
1958 DIVariable DV (Var);
1959 std::pair< unsigned, MDNode *> VP = VI->second;
1960 DILocation ScopeLoc(VP.second);
1963 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1965 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1966 // If variable scope is not found then skip this variable.
1970 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1971 Scope->addVariable(RegVar);
1972 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1974 RegVar->setAbstractVariable(AbsDbgVariable);
1978 /// beginScope - Process beginning of a scope starting at Label.
1979 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1980 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1981 if (I == DbgScopeBeginMap.end())
1983 ScopeVector &SD = I->second;
1984 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1986 (*SDI)->setStartLabelID(Label);
1989 /// endScope - Process end of a scope.
1990 void DwarfDebug::endScope(const MachineInstr *MI) {
1991 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1992 if (I == DbgScopeEndMap.end())
1995 unsigned Label = MMI->NextLabelID();
1996 Asm->printLabel(Label);
1999 SmallVector<DbgScope *, 2> &SD = I->second;
2000 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2002 (*SDI)->setEndLabelID(Label);
2006 /// createDbgScope - Create DbgScope for the scope.
2007 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2010 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2013 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2014 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2015 if (DIDescriptor(Scope).isLexicalBlock())
2016 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2020 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2024 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2025 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2026 DILocation DL(InlinedAt);
2027 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2030 /// extractScopeInformation - Scan machine instructions in this function
2031 /// and collect DbgScopes. Return true, if atleast one scope was found.
2032 bool DwarfDebug::extractScopeInformation() {
2033 // If scope information was extracted using .dbg intrinsics then there is not
2034 // any need to extract these information by scanning each instruction.
2035 if (!DbgScopeMap.empty())
2038 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2039 unsigned MIIndex = 0;
2040 // Scan each instruction and create scopes. First build working set of scopes.
2041 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2043 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2045 const MachineInstr *MInsn = II;
2046 MIIndexMap[MInsn] = MIIndex++;
2047 DebugLoc DL = MInsn->getDebugLoc();
2048 if (DL.isUnknown()) continue;
2049 DILocation DLT = MF->getDILocation(DL);
2050 DIScope DLTScope = DLT.getScope();
2051 if (DLTScope.isNull()) continue;
2052 // There is no need to create another DIE for compile unit. For all
2053 // other scopes, create one DbgScope now. This will be translated
2054 // into a scope DIE at the end.
2055 if (DLTScope.isCompileUnit()) continue;
2056 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2061 // Build scope hierarchy using working set of scopes.
2062 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2064 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2066 const MachineInstr *MInsn = II;
2067 DebugLoc DL = MInsn->getDebugLoc();
2068 if (DL.isUnknown()) continue;
2069 DILocation DLT = MF->getDILocation(DL);
2070 DIScope DLTScope = DLT.getScope();
2071 if (DLTScope.isNull()) continue;
2072 // There is no need to create another DIE for compile unit. For all
2073 // other scopes, create one DbgScope now. This will be translated
2074 // into a scope DIE at the end.
2075 if (DLTScope.isCompileUnit()) continue;
2076 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2077 DLT.getOrigLocation().getNode());
2078 Scope->setLastInsn(MInsn);
2082 if (!CurrentFnDbgScope)
2085 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2087 // Each scope has first instruction and last instruction to mark beginning
2088 // and end of a scope respectively. Create an inverse map that list scopes
2089 // starts (and ends) with an instruction. One instruction may start (or end)
2090 // multiple scopes. Ignore scopes that are not reachable.
2091 SmallVector<DbgScope *, 4> WorkList;
2092 WorkList.push_back(CurrentFnDbgScope);
2093 while (!WorkList.empty()) {
2094 DbgScope *S = WorkList.back(); WorkList.pop_back();
2096 SmallVector<DbgScope *, 4> &Children = S->getScopes();
2097 if (!Children.empty())
2098 for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2099 SE = Children.end(); SI != SE; ++SI)
2100 WorkList.push_back(*SI);
2102 if (S->isAbstractScope())
2104 const MachineInstr *MI = S->getFirstInsn();
2105 assert (MI && "DbgScope does not have first instruction!");
2107 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2108 if (IDI != DbgScopeBeginMap.end())
2109 IDI->second.push_back(S);
2111 DbgScopeBeginMap[MI].push_back(S);
2113 MI = S->getLastInsn();
2114 assert (MI && "DbgScope does not have last instruction!");
2115 IDI = DbgScopeEndMap.find(MI);
2116 if (IDI != DbgScopeEndMap.end())
2117 IDI->second.push_back(S);
2119 DbgScopeEndMap[MI].push_back(S);
2122 return !DbgScopeMap.empty();
2125 /// beginFunction - Gather pre-function debug information. Assumes being
2126 /// emitted immediately after the function entry point.
2127 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2130 if (!ShouldEmitDwarfDebug()) return;
2132 if (TimePassesIsEnabled)
2133 DebugTimer->startTimer();
2135 if (!extractScopeInformation())
2138 collectVariableInfo();
2140 // Assumes in correct section after the entry point.
2141 EmitLabel("func_begin", ++SubprogramCount);
2143 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2145 DebugLoc FDL = MF->getDefaultDebugLoc();
2146 if (!FDL.isUnknown()) {
2147 DILocation DLT = MF->getDILocation(FDL);
2148 unsigned LabelID = 0;
2149 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2151 LabelID = recordSourceLine(SP.getLineNumber(), 0,
2152 DLT.getScope().getNode());
2154 LabelID = recordSourceLine(DLT.getLineNumber(),
2155 DLT.getColumnNumber(),
2156 DLT.getScope().getNode());
2157 Asm->printLabel(LabelID);
2160 if (TimePassesIsEnabled)
2161 DebugTimer->stopTimer();
2164 /// endFunction - Gather and emit post-function debug information.
2166 void DwarfDebug::endFunction(const MachineFunction *MF) {
2167 if (!ShouldEmitDwarfDebug()) return;
2169 if (TimePassesIsEnabled)
2170 DebugTimer->startTimer();
2172 if (DbgScopeMap.empty())
2175 if (CurrentFnDbgScope) {
2176 // Define end label for subprogram.
2177 EmitLabel("func_end", SubprogramCount);
2179 // Get function line info.
2180 if (!Lines.empty()) {
2181 // Get section line info.
2182 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2183 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2184 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2185 // Append the function info to section info.
2186 SectionLineInfos.insert(SectionLineInfos.end(),
2187 Lines.begin(), Lines.end());
2190 // Construct abstract scopes.
2191 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2192 AE = AbstractScopesList.end(); AI != AE; ++AI)
2193 constructScopeDIE(*AI);
2195 constructScopeDIE(CurrentFnDbgScope);
2197 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2198 MMI->getFrameMoves()));
2202 CurrentFnDbgScope = NULL;
2203 DbgScopeMap.clear();
2204 DbgScopeBeginMap.clear();
2205 DbgScopeEndMap.clear();
2206 ConcreteScopes.clear();
2207 AbstractScopesList.clear();
2210 if (TimePassesIsEnabled)
2211 DebugTimer->stopTimer();
2214 /// recordSourceLine - Records location information and associates it with a
2215 /// label. Returns a unique label ID used to generate a label and provide
2216 /// correspondence to the source line list.
2217 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2222 if (TimePassesIsEnabled)
2223 DebugTimer->startTimer();
2228 DIDescriptor Scope(S);
2229 if (Scope.isCompileUnit()) {
2230 DICompileUnit CU(S);
2231 Dir = CU.getDirectory();
2232 Fn = CU.getFilename();
2233 } else if (Scope.isSubprogram()) {
2235 Dir = SP.getDirectory();
2236 Fn = SP.getFilename();
2237 } else if (Scope.isLexicalBlock()) {
2238 DILexicalBlock DB(S);
2239 Dir = DB.getDirectory();
2240 Fn = DB.getFilename();
2242 assert (0 && "Unexpected scope info");
2244 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2245 unsigned ID = MMI->NextLabelID();
2246 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2248 if (TimePassesIsEnabled)
2249 DebugTimer->stopTimer();
2254 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2255 /// timed. Look up the source id with the given directory and source file
2256 /// names. If none currently exists, create a new id and insert it in the
2257 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2259 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2260 const std::string &FileName) {
2261 if (TimePassesIsEnabled)
2262 DebugTimer->startTimer();
2264 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2266 if (TimePassesIsEnabled)
2267 DebugTimer->stopTimer();
2272 //===----------------------------------------------------------------------===//
2274 //===----------------------------------------------------------------------===//
2276 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2279 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2280 // Get the children.
2281 const std::vector<DIE *> &Children = Die->getChildren();
2283 // If not last sibling and has children then add sibling offset attribute.
2284 if (!Last && !Children.empty()) Die->addSiblingOffset();
2286 // Record the abbreviation.
2287 assignAbbrevNumber(Die->getAbbrev());
2289 // Get the abbreviation for this DIE.
2290 unsigned AbbrevNumber = Die->getAbbrevNumber();
2291 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2294 Die->setOffset(Offset);
2296 // Start the size with the size of abbreviation code.
2297 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2299 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2300 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2302 // Size the DIE attribute values.
2303 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2304 // Size attribute value.
2305 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2307 // Size the DIE children if any.
2308 if (!Children.empty()) {
2309 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2310 "Children flag not set");
2312 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2313 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2315 // End of children marker.
2316 Offset += sizeof(int8_t);
2319 Die->setSize(Offset - Die->getOffset());
2323 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2325 void DwarfDebug::computeSizeAndOffsets() {
2326 // Compute size of compile unit header.
2327 static unsigned Offset =
2328 sizeof(int32_t) + // Length of Compilation Unit Info
2329 sizeof(int16_t) + // DWARF version number
2330 sizeof(int32_t) + // Offset Into Abbrev. Section
2331 sizeof(int8_t); // Pointer Size (in bytes)
2333 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2334 CompileUnitOffsets[ModuleCU] = 0;
2337 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2338 /// tools to recognize the object file contains Dwarf information.
2339 void DwarfDebug::emitInitial() {
2340 // Check to see if we already emitted intial headers.
2341 if (didInitial) return;
2344 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2346 // Dwarf sections base addresses.
2347 if (MAI->doesDwarfRequireFrameSection()) {
2348 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2349 EmitLabel("section_debug_frame", 0);
2352 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2353 EmitLabel("section_info", 0);
2354 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2355 EmitLabel("section_abbrev", 0);
2356 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2357 EmitLabel("section_aranges", 0);
2359 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2360 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2361 EmitLabel("section_macinfo", 0);
2364 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2365 EmitLabel("section_line", 0);
2366 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2367 EmitLabel("section_loc", 0);
2368 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2369 EmitLabel("section_pubnames", 0);
2370 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2371 EmitLabel("section_pubtypes", 0);
2372 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2373 EmitLabel("section_str", 0);
2374 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2375 EmitLabel("section_ranges", 0);
2377 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2378 EmitLabel("text_begin", 0);
2379 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2380 EmitLabel("data_begin", 0);
2383 /// emitDIE - Recusively Emits a debug information entry.
2385 void DwarfDebug::emitDIE(DIE *Die) {
2386 // Get the abbreviation for this DIE.
2387 unsigned AbbrevNumber = Die->getAbbrevNumber();
2388 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2392 // Emit the code (index) for the abbreviation.
2393 if (Asm->VerboseAsm)
2394 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2395 Twine::utohexstr(Die->getOffset()) + ":0x" +
2396 Twine::utohexstr(Die->getSize()) + " " +
2397 dwarf::TagString(Abbrev->getTag()));
2398 EmitULEB128(AbbrevNumber);
2400 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2401 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2403 // Emit the DIE attribute values.
2404 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2405 unsigned Attr = AbbrevData[i].getAttribute();
2406 unsigned Form = AbbrevData[i].getForm();
2407 assert(Form && "Too many attributes for DIE (check abbreviation)");
2409 if (Asm->VerboseAsm)
2410 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2413 case dwarf::DW_AT_sibling:
2414 Asm->EmitInt32(Die->getSiblingOffset());
2416 case dwarf::DW_AT_abstract_origin: {
2417 DIEEntry *E = cast<DIEEntry>(Values[i]);
2418 DIE *Origin = E->getEntry();
2419 unsigned Addr = Origin->getOffset();
2420 Asm->EmitInt32(Addr);
2424 // Emit an attribute using the defined form.
2425 Values[i]->EmitValue(this, Form);
2426 O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2431 // Emit the DIE children if any.
2432 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2433 const std::vector<DIE *> &Children = Die->getChildren();
2435 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2436 emitDIE(Children[j]);
2438 Asm->EmitInt8(0); EOL("End Of Children Mark");
2442 /// emitDebugInfo - Emit the debug info section.
2444 void DwarfDebug::emitDebugInfo() {
2445 // Start debug info section.
2446 Asm->OutStreamer.SwitchSection(
2447 Asm->getObjFileLowering().getDwarfInfoSection());
2448 DIE *Die = ModuleCU->getCUDie();
2450 // Emit the compile units header.
2451 EmitLabel("info_begin", ModuleCU->getID());
2453 // Emit size of content not including length itself
2454 unsigned ContentSize = Die->getSize() +
2455 sizeof(int16_t) + // DWARF version number
2456 sizeof(int32_t) + // Offset Into Abbrev. Section
2457 sizeof(int8_t) + // Pointer Size (in bytes)
2458 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2460 Asm->EmitInt32(ContentSize); EOL("Length of Compilation Unit Info");
2461 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2462 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2463 EOL("Offset Into Abbrev. Section");
2464 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2467 // FIXME - extra padding for gdb bug.
2468 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2469 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2470 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2471 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2472 EmitLabel("info_end", ModuleCU->getID());
2476 /// emitAbbreviations - Emit the abbreviation section.
2478 void DwarfDebug::emitAbbreviations() const {
2479 // Check to see if it is worth the effort.
2480 if (!Abbreviations.empty()) {
2481 // Start the debug abbrev section.
2482 Asm->OutStreamer.SwitchSection(
2483 Asm->getObjFileLowering().getDwarfAbbrevSection());
2485 EmitLabel("abbrev_begin", 0);
2487 // For each abbrevation.
2488 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2489 // Get abbreviation data
2490 const DIEAbbrev *Abbrev = Abbreviations[i];
2492 // Emit the abbrevations code (base 1 index.)
2493 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2495 // Emit the abbreviations data.
2500 // Mark end of abbreviations.
2501 EmitULEB128(0, "EOM(3)");
2503 EmitLabel("abbrev_end", 0);
2508 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2509 /// the line matrix.
2511 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2512 // Define last address of section.
2513 Asm->EmitInt8(0); EOL("Extended Op");
2514 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2515 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2516 EmitReference("section_end", SectionEnd); EOL("Section end label");
2518 // Mark end of matrix.
2519 Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2524 /// emitDebugLines - Emit source line information.
2526 void DwarfDebug::emitDebugLines() {
2527 // If the target is using .loc/.file, the assembler will be emitting the
2528 // .debug_line table automatically.
2529 if (MAI->hasDotLocAndDotFile())
2532 // Minimum line delta, thus ranging from -10..(255-10).
2533 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2534 // Maximum line delta, thus ranging from -10..(255-10).
2535 const int MaxLineDelta = 255 + MinLineDelta;
2537 // Start the dwarf line section.
2538 Asm->OutStreamer.SwitchSection(
2539 Asm->getObjFileLowering().getDwarfLineSection());
2541 // Construct the section header.
2542 EmitDifference("line_end", 0, "line_begin", 0, true);
2543 EOL("Length of Source Line Info");
2544 EmitLabel("line_begin", 0);
2546 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2548 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2549 EOL("Prolog Length");
2550 EmitLabel("line_prolog_begin", 0);
2552 Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2553 Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2554 Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2555 Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2556 Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2558 // Line number standard opcode encodings argument count
2559 Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2560 Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2561 Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2562 Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2563 Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2564 Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2565 Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2566 Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2567 Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2569 // Emit directories.
2570 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2571 const std::string &Dir = getSourceDirectoryName(DI);
2572 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2573 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2576 Asm->EmitInt8(0); EOL("End of directories");
2579 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2580 // Remember source id starts at 1.
2581 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2582 const std::string &FN = getSourceFileName(Id.second);
2583 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2584 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2586 EmitULEB128(Id.first, "Directory #");
2587 EmitULEB128(0, "Mod date");
2588 EmitULEB128(0, "File size");
2591 Asm->EmitInt8(0); EOL("End of files");
2593 EmitLabel("line_prolog_end", 0);
2595 // A sequence for each text section.
2596 unsigned SecSrcLinesSize = SectionSourceLines.size();
2598 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2599 // Isolate current sections line info.
2600 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2602 /*if (Asm->isVerbose()) {
2603 const MCSection *S = SectionMap[j + 1];
2604 O << '\t' << MAI->getCommentString() << " Section"
2605 << S->getName() << '\n';
2609 // Dwarf assumes we start with first line of first source file.
2610 unsigned Source = 1;
2613 // Construct rows of the address, source, line, column matrix.
2614 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2615 const SrcLineInfo &LineInfo = LineInfos[i];
2616 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2617 if (!LabelID) continue;
2619 if (LineInfo.getLine() == 0) continue;
2621 if (!Asm->isVerbose())
2624 std::pair<unsigned, unsigned> SourceID =
2625 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2626 O << '\t' << MAI->getCommentString() << ' '
2627 << getSourceDirectoryName(SourceID.first) << '/'
2628 << getSourceFileName(SourceID.second)
2629 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2632 // Define the line address.
2633 Asm->EmitInt8(0); EOL("Extended Op");
2634 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2635 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2636 EmitReference("label", LabelID); EOL("Location label");
2638 // If change of source, then switch to the new source.
2639 if (Source != LineInfo.getSourceID()) {
2640 Source = LineInfo.getSourceID();
2641 Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2642 EmitULEB128(Source, "New Source");
2645 // If change of line.
2646 if (Line != LineInfo.getLine()) {
2647 // Determine offset.
2648 int Offset = LineInfo.getLine() - Line;
2649 int Delta = Offset - MinLineDelta;
2652 Line = LineInfo.getLine();
2654 // If delta is small enough and in range...
2655 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2656 // ... then use fast opcode.
2657 Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2659 // ... otherwise use long hand.
2660 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2661 EOL("DW_LNS_advance_line");
2662 EmitSLEB128(Offset, "Line Offset");
2663 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2666 // Copy the previous row (different address or source)
2667 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2671 emitEndOfLineMatrix(j + 1);
2674 if (SecSrcLinesSize == 0)
2675 // Because we're emitting a debug_line section, we still need a line
2676 // table. The linker and friends expect it to exist. If there's nothing to
2677 // put into it, emit an empty table.
2678 emitEndOfLineMatrix(1);
2680 EmitLabel("line_end", 0);
2684 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2686 void DwarfDebug::emitCommonDebugFrame() {
2687 if (!MAI->doesDwarfRequireFrameSection())
2691 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2692 TargetFrameInfo::StackGrowsUp ?
2693 TD->getPointerSize() : -TD->getPointerSize();
2695 // Start the dwarf frame section.
2696 Asm->OutStreamer.SwitchSection(
2697 Asm->getObjFileLowering().getDwarfFrameSection());
2699 EmitLabel("debug_frame_common", 0);
2700 EmitDifference("debug_frame_common_end", 0,
2701 "debug_frame_common_begin", 0, true);
2702 EOL("Length of Common Information Entry");
2704 EmitLabel("debug_frame_common_begin", 0);
2705 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2706 EOL("CIE Identifier Tag");
2707 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2709 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2710 EOL("CIE Augmentation");
2711 EmitULEB128(1, "CIE Code Alignment Factor");
2712 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2713 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2714 EOL("CIE RA Column");
2716 std::vector<MachineMove> Moves;
2717 RI->getInitialFrameState(Moves);
2719 EmitFrameMoves(NULL, 0, Moves, false);
2721 Asm->EmitAlignment(2, 0, 0, false);
2722 EmitLabel("debug_frame_common_end", 0);
2726 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2729 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2730 if (!MAI->doesDwarfRequireFrameSection())
2733 // Start the dwarf frame section.
2734 Asm->OutStreamer.SwitchSection(
2735 Asm->getObjFileLowering().getDwarfFrameSection());
2737 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2738 "debug_frame_begin", DebugFrameInfo.Number, true);
2739 EOL("Length of Frame Information Entry");
2741 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2743 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2745 EOL("FDE CIE offset");
2747 EmitReference("func_begin", DebugFrameInfo.Number);
2748 EOL("FDE initial location");
2749 EmitDifference("func_end", DebugFrameInfo.Number,
2750 "func_begin", DebugFrameInfo.Number);
2751 EOL("FDE address range");
2753 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2756 Asm->EmitAlignment(2, 0, 0, false);
2757 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2761 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2763 void DwarfDebug::emitDebugPubNames() {
2764 // Start the dwarf pubnames section.
2765 Asm->OutStreamer.SwitchSection(
2766 Asm->getObjFileLowering().getDwarfPubNamesSection());
2768 EmitDifference("pubnames_end", ModuleCU->getID(),
2769 "pubnames_begin", ModuleCU->getID(), true);
2770 EOL("Length of Public Names Info");
2772 EmitLabel("pubnames_begin", ModuleCU->getID());
2774 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2776 EmitSectionOffset("info_begin", "section_info",
2777 ModuleCU->getID(), 0, true, false);
2778 EOL("Offset of Compilation Unit Info");
2780 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2782 EOL("Compilation Unit Length");
2784 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2785 for (StringMap<DIE*>::const_iterator
2786 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2787 const char *Name = GI->getKeyData();
2788 DIE * Entity = GI->second;
2790 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2792 if (Asm->VerboseAsm)
2793 Asm->OutStreamer.AddComment("External Name");
2794 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2797 Asm->EmitInt32(0); EOL("End Mark");
2798 EmitLabel("pubnames_end", ModuleCU->getID());
2802 void DwarfDebug::emitDebugPubTypes() {
2803 // Start the dwarf pubnames section.
2804 Asm->OutStreamer.SwitchSection(
2805 Asm->getObjFileLowering().getDwarfPubTypesSection());
2806 EmitDifference("pubtypes_end", ModuleCU->getID(),
2807 "pubtypes_begin", ModuleCU->getID(), true);
2808 EOL("Length of Public Types Info");
2810 EmitLabel("pubtypes_begin", ModuleCU->getID());
2812 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2813 Asm->EmitInt16(dwarf::DWARF_VERSION);
2815 EmitSectionOffset("info_begin", "section_info",
2816 ModuleCU->getID(), 0, true, false);
2817 EOL("Offset of Compilation ModuleCU Info");
2819 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2821 EOL("Compilation ModuleCU Length");
2823 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2824 for (StringMap<DIE*>::const_iterator
2825 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2826 const char *Name = GI->getKeyData();
2827 DIE * Entity = GI->second;
2829 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2830 Asm->EmitInt32(Entity->getOffset());
2832 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2833 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2836 Asm->EmitInt32(0); EOL("End Mark");
2837 EmitLabel("pubtypes_end", ModuleCU->getID());
2841 /// emitDebugStr - Emit visible names into a debug str section.
2843 void DwarfDebug::emitDebugStr() {
2844 // Check to see if it is worth the effort.
2845 if (!StringPool.empty()) {
2846 // Start the dwarf str section.
2847 Asm->OutStreamer.SwitchSection(
2848 Asm->getObjFileLowering().getDwarfStrSection());
2850 // For each of strings in the string pool.
2851 for (unsigned StringID = 1, N = StringPool.size();
2852 StringID <= N; ++StringID) {
2853 // Emit a label for reference from debug information entries.
2854 EmitLabel("string", StringID);
2856 // Emit the string itself.
2857 const std::string &String = StringPool[StringID];
2858 Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2865 /// emitDebugLoc - Emit visible names into a debug loc section.
2867 void DwarfDebug::emitDebugLoc() {
2868 // Start the dwarf loc section.
2869 Asm->OutStreamer.SwitchSection(
2870 Asm->getObjFileLowering().getDwarfLocSection());
2873 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2875 void DwarfDebug::EmitDebugARanges() {
2876 // Start the dwarf aranges section.
2877 Asm->OutStreamer.SwitchSection(
2878 Asm->getObjFileLowering().getDwarfARangesSection());
2882 CompileUnit *Unit = GetBaseCompileUnit();
2884 // Don't include size of length
2885 Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2887 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2889 EmitReference("info_begin", Unit->getID());
2890 EOL("Offset of Compilation Unit Info");
2892 Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2894 Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2896 Asm->EmitInt16(0); EOL("Pad (1)");
2897 Asm->EmitInt16(0); EOL("Pad (2)");
2900 EmitReference("text_begin", 0); EOL("Address");
2901 EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
2903 Asm->EmitInt32(0); EOL("EOM (1)");
2904 Asm->EmitInt32(0); EOL("EOM (2)");
2908 /// emitDebugRanges - Emit visible names into a debug ranges section.
2910 void DwarfDebug::emitDebugRanges() {
2911 // Start the dwarf ranges section.
2912 Asm->OutStreamer.SwitchSection(
2913 Asm->getObjFileLowering().getDwarfRangesSection());
2916 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2918 void DwarfDebug::emitDebugMacInfo() {
2919 if (const MCSection *LineInfo =
2920 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2921 // Start the dwarf macinfo section.
2922 Asm->OutStreamer.SwitchSection(LineInfo);
2926 /// emitDebugInlineInfo - Emit inline info using following format.
2928 /// 1. length of section
2929 /// 2. Dwarf version number
2930 /// 3. address size.
2932 /// Entries (one "entry" for each function that was inlined):
2934 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2935 /// otherwise offset into __debug_str for regular function name.
2936 /// 2. offset into __debug_str section for regular function name.
2937 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2938 /// instances for the function.
2940 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2941 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2942 /// __debug_info section, and the low_pc is the starting address for the
2943 /// inlining instance.
2944 void DwarfDebug::emitDebugInlineInfo() {
2945 if (!MAI->doesDwarfUsesInlineInfoSection())
2951 Asm->OutStreamer.SwitchSection(
2952 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2954 EmitDifference("debug_inlined_end", 1,
2955 "debug_inlined_begin", 1, true);
2956 EOL("Length of Debug Inlined Information Entry");
2958 EmitLabel("debug_inlined_begin", 1);
2960 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2961 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2963 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2964 E = InlinedSPNodes.end(); I != E; ++I) {
2967 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2968 = InlineInfo.find(Node);
2969 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2970 DISubprogram SP(Node);
2971 StringRef LName = SP.getLinkageName();
2972 StringRef Name = SP.getName();
2974 if (LName.empty()) {
2975 Asm->OutStreamer.EmitBytes(Name, 0);
2976 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2978 EmitSectionOffset("string", "section_str",
2979 StringPool.idFor(getRealLinkageName(LName)), false, true);
2981 EOL("MIPS linkage name");
2982 EmitSectionOffset("string", "section_str",
2983 StringPool.idFor(Name), false, true);
2984 EOL("Function name");
2985 EmitULEB128(Labels.size(), "Inline count");
2987 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2988 LE = Labels.end(); LI != LE; ++LI) {
2989 DIE *SP = LI->second;
2990 Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
2992 if (TD->getPointerSize() == sizeof(int32_t))
2993 O << MAI->getData32bitsDirective();
2995 O << MAI->getData64bitsDirective();
2997 PrintLabelName("label", LI->first); EOL("low_pc");
3001 EmitLabel("debug_inlined_end", 1);