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 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 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1219 if (ATy.isArtificial())
1220 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1221 SPDie->addChild(Arg);
1225 if (SP.isArtificial())
1226 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1228 // DW_TAG_inlined_subroutine may refer to this DIE.
1229 ModuleCU->insertDIE(SP.getNode(), SPDie);
1233 /// findCompileUnit - Get the compile unit for the given descriptor.
1235 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1236 DenseMap<Value *, CompileUnit *>::const_iterator I =
1237 CompileUnitMap.find(Unit.getNode());
1238 if (I == CompileUnitMap.end())
1239 return constructCompileUnit(Unit.getNode());
1243 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1244 /// Initialize scope and update scope hierarchy.
1245 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1246 MDNode *InlinedAt) {
1247 assert (N && "Invalid Scope encoding!");
1248 assert (MI && "Missing machine instruction!");
1249 bool GetConcreteScope = (MI && InlinedAt);
1251 DbgScope *NScope = NULL;
1254 NScope = DbgScopeMap.lookup(InlinedAt);
1256 NScope = DbgScopeMap.lookup(N);
1257 assert (NScope && "Unable to find working scope!");
1259 if (NScope->getFirstInsn())
1262 DbgScope *Parent = NULL;
1263 if (GetConcreteScope) {
1264 DILocation IL(InlinedAt);
1265 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1266 IL.getOrigLocation().getNode());
1267 assert (Parent && "Unable to find Parent scope!");
1268 NScope->setParent(Parent);
1269 Parent->addScope(NScope);
1270 } else if (DIDescriptor(N).isLexicalBlock()) {
1271 DILexicalBlock DB(N);
1272 if (!DB.getContext().isNull()) {
1273 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1274 NScope->setParent(Parent);
1275 Parent->addScope(NScope);
1279 NScope->setFirstInsn(MI);
1281 if (!Parent && !InlinedAt) {
1282 StringRef SPName = DISubprogram(N).getLinkageName();
1283 if (SPName == MF->getFunction()->getName())
1284 CurrentFnDbgScope = NScope;
1287 if (GetConcreteScope) {
1288 ConcreteScopes[InlinedAt] = NScope;
1289 getOrCreateAbstractScope(N);
1295 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1296 assert (N && "Invalid Scope encoding!");
1298 DbgScope *AScope = AbstractScopes.lookup(N);
1302 DbgScope *Parent = NULL;
1304 DIDescriptor Scope(N);
1305 if (Scope.isLexicalBlock()) {
1306 DILexicalBlock DB(N);
1307 DIDescriptor ParentDesc = DB.getContext();
1308 if (!ParentDesc.isNull())
1309 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1312 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1315 Parent->addScope(AScope);
1316 AScope->setAbstractScope();
1317 AbstractScopes[N] = AScope;
1318 if (DIDescriptor(N).isSubprogram())
1319 AbstractScopesList.push_back(AScope);
1323 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1324 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1325 /// If there are global variables in this scope then create and insert
1326 /// DIEs for these variables.
1327 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1329 DIE *SPDie = ModuleCU->getDIE(SPNode);
1330 assert (SPDie && "Unable to find subprogram DIE!");
1331 DISubprogram SP(SPNode);
1332 // There is not any need to generate specification DIE for a function
1333 // defined at compile unit level. If a function is defined inside another
1334 // function then gdb prefers the definition at top level and but does not
1335 // expect specification DIE in parent function. So avoid creating
1336 // specification DIE for a function defined inside a function.
1337 if (SP.isDefinition() && !SP.getContext().isCompileUnit()
1338 && !SP.getContext().isSubprogram()) {
1339 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1341 DICompositeType SPTy = SP.getType();
1342 DIArray Args = SPTy.getTypeArray();
1343 unsigned SPTag = SPTy.getTag();
1344 if (SPTag == dwarf::DW_TAG_subroutine_type)
1345 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1346 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1347 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1349 if (ATy.isArtificial())
1350 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1351 SPDie->addChild(Arg);
1353 DIE *SPDeclDie = SPDie;
1354 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1355 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1357 ModuleCU->addDie(SPDie);
1360 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1361 DWLabel("func_begin", SubprogramCount));
1362 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1363 DWLabel("func_end", SubprogramCount));
1364 MachineLocation Location(RI->getFrameRegister(*MF));
1365 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1367 if (!DISubprogram(SPNode).isLocalToUnit())
1368 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1373 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1374 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1375 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1376 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1377 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1379 // Ignore empty scopes.
1380 if (StartID == EndID && StartID != 0)
1383 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1384 if (Scope->isAbstractScope())
1387 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1389 DWLabel("label", StartID)
1390 : DWLabel("func_begin", SubprogramCount));
1391 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1393 DWLabel("label", EndID)
1394 : DWLabel("func_end", SubprogramCount));
1401 /// constructInlinedScopeDIE - This scope represents inlined body of
1402 /// a function. Construct DIE to represent this concrete inlined copy
1403 /// of the function.
1404 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1405 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1406 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1407 assert (StartID && "Invalid starting label for an inlined scope!");
1408 assert (EndID && "Invalid end label for an inlined scope!");
1409 // Ignore empty scopes.
1410 if (StartID == EndID && StartID != 0)
1413 DIScope DS(Scope->getScopeNode());
1416 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1418 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1419 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1420 assert (OriginDIE && "Unable to find Origin DIE!");
1421 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1422 dwarf::DW_FORM_ref4, OriginDIE);
1424 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1425 DWLabel("label", StartID));
1426 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1427 DWLabel("label", EndID));
1429 InlinedSubprogramDIEs.insert(OriginDIE);
1431 // Track the start label for this inlined function.
1432 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1433 I = InlineInfo.find(InlinedSP.getNode());
1435 if (I == InlineInfo.end()) {
1436 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1438 InlinedSPNodes.push_back(InlinedSP.getNode());
1440 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1442 StringPool.insert(InlinedSP.getName());
1443 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1445 DILocation DL(Scope->getInlinedAt());
1446 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1447 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1453 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1454 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1455 // Get the descriptor.
1456 const DIVariable &VD = DV->getVariable();
1457 StringRef Name = VD.getName();
1461 // Translate tag to proper Dwarf tag. The result variable is dropped for
1464 switch (VD.getTag()) {
1465 case dwarf::DW_TAG_return_variable:
1467 case dwarf::DW_TAG_arg_variable:
1468 Tag = dwarf::DW_TAG_formal_parameter;
1470 case dwarf::DW_TAG_auto_variable: // fall thru
1472 Tag = dwarf::DW_TAG_variable;
1476 // Define variable debug information entry.
1477 DIE *VariableDie = new DIE(Tag);
1481 if (DbgVariable *AV = DV->getAbstractVariable())
1482 AbsDIE = AV->getDIE();
1485 DIScope DS(Scope->getScopeNode());
1486 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1487 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1489 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1490 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1491 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1492 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1493 dwarf::DW_FORM_ref4, AbsDIE);
1496 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1497 addSourceLine(VariableDie, &VD);
1499 // Add variable type.
1500 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1501 // addresses instead.
1502 if (VD.isBlockByrefVariable())
1503 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1505 addType(VariableDie, VD.getType());
1508 // Add variable address.
1509 if (!Scope->isAbstractScope()) {
1510 MachineLocation Location;
1512 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1513 Location.set(FrameReg, Offset);
1515 if (VD.hasComplexAddress())
1516 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1517 else if (VD.isBlockByrefVariable())
1518 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1520 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1523 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1524 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1525 DV->setDIE(VariableDie);
1530 void DwarfDebug::addPubTypes(DISubprogram SP) {
1531 DICompositeType SPTy = SP.getType();
1532 unsigned SPTag = SPTy.getTag();
1533 if (SPTag != dwarf::DW_TAG_subroutine_type)
1536 DIArray Args = SPTy.getTypeArray();
1540 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1541 DIType ATy(Args.getElement(i).getNode());
1544 DICompositeType CATy = getDICompositeType(ATy);
1545 if (!CATy.isNull() && !CATy.getName().empty()) {
1546 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1547 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1552 /// constructScopeDIE - Construct a DIE for this scope.
1553 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1556 DIScope DS(Scope->getScopeNode());
1560 DIE *ScopeDIE = NULL;
1561 if (Scope->getInlinedAt())
1562 ScopeDIE = constructInlinedScopeDIE(Scope);
1563 else if (DS.isSubprogram()) {
1564 if (Scope->isAbstractScope())
1565 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1567 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1570 ScopeDIE = constructLexicalScopeDIE(Scope);
1571 if (!ScopeDIE) return NULL;
1574 // Add variables to scope.
1575 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1576 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1577 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1579 ScopeDIE->addChild(VariableDIE);
1582 // Add nested scopes.
1583 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1584 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1585 // Define the Scope debug information entry.
1586 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1588 ScopeDIE->addChild(NestedDIE);
1591 if (DS.isSubprogram())
1592 addPubTypes(DISubprogram(DS.getNode()));
1597 /// GetOrCreateSourceID - Look up the source id with the given directory and
1598 /// source file names. If none currently exists, create a new id and insert it
1599 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1601 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1603 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1604 if (DI != DirectoryIdMap.end()) {
1605 DId = DI->getValue();
1607 DId = DirectoryNames.size() + 1;
1608 DirectoryIdMap[DirName] = DId;
1609 DirectoryNames.push_back(DirName);
1613 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1614 if (FI != SourceFileIdMap.end()) {
1615 FId = FI->getValue();
1617 FId = SourceFileNames.size() + 1;
1618 SourceFileIdMap[FileName] = FId;
1619 SourceFileNames.push_back(FileName);
1622 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1623 SourceIdMap.find(std::make_pair(DId, FId));
1624 if (SI != SourceIdMap.end())
1627 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1628 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1629 SourceIds.push_back(std::make_pair(DId, FId));
1634 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1635 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1636 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1639 NDie = new DIE(dwarf::DW_TAG_namespace);
1640 ModuleCU->insertDIE(NS.getNode(), NDie);
1641 if (!NS.getName().empty())
1642 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1643 addSourceLine(NDie, &NS);
1644 addToContextOwner(NDie, NS.getContext());
1648 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1649 DICompileUnit DIUnit(N);
1650 StringRef FN = DIUnit.getFilename();
1651 StringRef Dir = DIUnit.getDirectory();
1652 unsigned ID = GetOrCreateSourceID(Dir, FN);
1654 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1655 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1656 DWLabel("section_line", 0), DWLabel("section_line", 0),
1658 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1659 DIUnit.getProducer());
1660 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1661 DIUnit.getLanguage());
1662 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1665 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1666 if (DIUnit.isOptimized())
1667 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1669 StringRef Flags = DIUnit.getFlags();
1671 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1673 unsigned RVer = DIUnit.getRunTimeVersion();
1675 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1676 dwarf::DW_FORM_data1, RVer);
1678 CompileUnit *Unit = new CompileUnit(ID, Die);
1679 if (!ModuleCU && DIUnit.isMain()) {
1680 // Use first compile unit marked as isMain as the compile unit
1685 CompileUnitMap[DIUnit.getNode()] = Unit;
1686 CompileUnits.push_back(Unit);
1690 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1691 DIGlobalVariable DI_GV(N);
1693 // If debug information is malformed then ignore it.
1694 if (DI_GV.Verify() == false)
1697 // Check for pre-existence.
1698 if (ModuleCU->getDIE(DI_GV.getNode()))
1701 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1706 ModuleCU->insertDIE(N, VariableDie);
1708 // Add to context owner.
1709 DIDescriptor GVContext = DI_GV.getContext();
1710 // Do not create specification DIE if context is either compile unit
1712 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1713 && !GVContext.isSubprogram()) {
1714 // Create specification DIE.
1715 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1716 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1717 dwarf::DW_FORM_ref4, VariableDie);
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(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1723 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1724 ModuleCU->addDie(VariableSpecDIE);
1726 DIEBlock *Block = new DIEBlock();
1727 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1728 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1729 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1730 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1732 addToContextOwner(VariableDie, GVContext);
1734 // Expose as global. FIXME - need to check external flag.
1735 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1737 DIType GTy = DI_GV.getType();
1738 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1739 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1740 assert (Entry && "Missing global type!");
1741 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1746 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1749 // Check for pre-existence.
1750 if (ModuleCU->getDIE(N))
1753 if (!SP.isDefinition())
1754 // This is a method declaration which will be handled while constructing
1758 DIE *SubprogramDie = createSubprogramDIE(SP);
1761 ModuleCU->insertDIE(N, SubprogramDie);
1763 // Add to context owner.
1764 addToContextOwner(SubprogramDie, SP.getContext());
1766 // Expose as global.
1767 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1772 /// beginModule - Emit all Dwarf sections that should come prior to the
1773 /// content. Create global DIEs and emit initial debug info sections.
1774 /// This is inovked by the target AsmPrinter.
1775 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1778 if (TimePassesIsEnabled)
1779 DebugTimer->startTimer();
1781 if (!MAI->doesSupportDebugInformation())
1784 DebugInfoFinder DbgFinder;
1785 DbgFinder.processModule(*M);
1787 // Create all the compile unit DIEs.
1788 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1789 E = DbgFinder.compile_unit_end(); I != E; ++I)
1790 constructCompileUnit(*I);
1792 if (CompileUnits.empty()) {
1793 if (TimePassesIsEnabled)
1794 DebugTimer->stopTimer();
1799 // If main compile unit for this module is not seen than randomly
1800 // select first compile unit.
1802 ModuleCU = CompileUnits[0];
1804 // Create DIEs for each subprogram.
1805 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1806 E = DbgFinder.subprogram_end(); I != E; ++I)
1807 constructSubprogramDIE(*I);
1809 // Create DIEs for each global variable.
1810 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1811 E = DbgFinder.global_variable_end(); I != E; ++I)
1812 constructGlobalVariableDIE(*I);
1816 MMI->setDebugInfoAvailability(true);
1818 // Prime section data.
1819 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1821 // Print out .file directives to specify files for .loc directives. These are
1822 // printed out early so that they precede any .loc directives.
1823 if (MAI->hasDotLocAndDotFile()) {
1824 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1825 // Remember source id starts at 1.
1826 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1827 // FIXME: don't use sys::path for this! This should not depend on the
1829 sys::Path FullPath(getSourceDirectoryName(Id.first));
1831 FullPath.appendComponent(getSourceFileName(Id.second));
1832 assert(AppendOk && "Could not append filename to directory!");
1834 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1838 // Emit initial sections
1841 if (TimePassesIsEnabled)
1842 DebugTimer->stopTimer();
1845 /// endModule - Emit all Dwarf sections that should come after the content.
1847 void DwarfDebug::endModule() {
1851 if (TimePassesIsEnabled)
1852 DebugTimer->startTimer();
1854 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1855 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1856 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1858 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1861 // Insert top level DIEs.
1862 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1863 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1864 ModuleCU->getCUDie()->addChild(*TI);
1866 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1867 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1868 DIE *SPDie = CI->first;
1869 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1871 DIE *NDie = ModuleCU->getDIE(N);
1872 if (!NDie) continue;
1873 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1874 // FIXME - This is not the correct approach.
1875 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1878 // Standard sections final addresses.
1879 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1880 EmitLabel("text_end", 0);
1881 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1882 EmitLabel("data_end", 0);
1884 // End text sections.
1885 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1886 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1887 EmitLabel("section_end", i);
1890 // Emit common frame information.
1891 emitCommonDebugFrame();
1893 // Emit function debug frame information
1894 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1895 E = DebugFrames.end(); I != E; ++I)
1896 emitFunctionDebugFrame(*I);
1898 // Compute DIE offsets and sizes.
1899 computeSizeAndOffsets();
1901 // Emit all the DIEs into a debug info section
1904 // Corresponding abbreviations into a abbrev section.
1905 emitAbbreviations();
1907 // Emit source line correspondence into a debug line section.
1910 // Emit info into a debug pubnames section.
1911 emitDebugPubNames();
1913 // Emit info into a debug pubtypes section.
1914 emitDebugPubTypes();
1916 // Emit info into a debug str section.
1919 // Emit info into a debug loc section.
1922 // Emit info into a debug aranges section.
1925 // Emit info into a debug ranges section.
1928 // Emit info into a debug macinfo section.
1931 // Emit inline info.
1932 emitDebugInlineInfo();
1934 if (TimePassesIsEnabled)
1935 DebugTimer->stopTimer();
1938 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1939 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1941 DILocation &ScopeLoc) {
1943 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1945 return AbsDbgVariable;
1947 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1951 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1952 Scope->addVariable(AbsDbgVariable);
1953 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1954 return AbsDbgVariable;
1957 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1958 void DwarfDebug::collectVariableInfo() {
1961 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1962 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1963 VE = VMap.end(); VI != VE; ++VI) {
1964 MDNode *Var = VI->first;
1966 DIVariable DV (Var);
1967 std::pair< unsigned, MDNode *> VP = VI->second;
1968 DILocation ScopeLoc(VP.second);
1971 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1973 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1974 // If variable scope is not found then skip this variable.
1978 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1979 Scope->addVariable(RegVar);
1980 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1982 RegVar->setAbstractVariable(AbsDbgVariable);
1986 /// beginScope - Process beginning of a scope starting at Label.
1987 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1988 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1989 if (I == DbgScopeBeginMap.end())
1991 ScopeVector &SD = I->second;
1992 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1994 (*SDI)->setStartLabelID(Label);
1997 /// endScope - Process end of a scope.
1998 void DwarfDebug::endScope(const MachineInstr *MI) {
1999 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2000 if (I == DbgScopeEndMap.end())
2003 unsigned Label = MMI->NextLabelID();
2004 Asm->printLabel(Label);
2007 SmallVector<DbgScope *, 2> &SD = I->second;
2008 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2010 (*SDI)->setEndLabelID(Label);
2014 /// createDbgScope - Create DbgScope for the scope.
2015 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2018 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2021 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2022 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2023 if (DIDescriptor(Scope).isLexicalBlock())
2024 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2028 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2032 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2033 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2034 DILocation DL(InlinedAt);
2035 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2038 /// extractScopeInformation - Scan machine instructions in this function
2039 /// and collect DbgScopes. Return true, if atleast one scope was found.
2040 bool DwarfDebug::extractScopeInformation() {
2041 // If scope information was extracted using .dbg intrinsics then there is not
2042 // any need to extract these information by scanning each instruction.
2043 if (!DbgScopeMap.empty())
2046 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2047 unsigned MIIndex = 0;
2048 // Scan each instruction and create scopes. First build working set of scopes.
2049 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2051 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2053 const MachineInstr *MInsn = II;
2054 MIIndexMap[MInsn] = MIIndex++;
2055 DebugLoc DL = MInsn->getDebugLoc();
2056 if (DL.isUnknown()) continue;
2057 DILocation DLT = MF->getDILocation(DL);
2058 DIScope DLTScope = DLT.getScope();
2059 if (DLTScope.isNull()) continue;
2060 // There is no need to create another DIE for compile unit. For all
2061 // other scopes, create one DbgScope now. This will be translated
2062 // into a scope DIE at the end.
2063 if (DLTScope.isCompileUnit()) continue;
2064 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2069 // Build scope hierarchy using working set of scopes.
2070 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2072 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2074 const MachineInstr *MInsn = II;
2075 DebugLoc DL = MInsn->getDebugLoc();
2076 if (DL.isUnknown()) continue;
2077 DILocation DLT = MF->getDILocation(DL);
2078 DIScope DLTScope = DLT.getScope();
2079 if (DLTScope.isNull()) continue;
2080 // There is no need to create another DIE for compile unit. For all
2081 // other scopes, create one DbgScope now. This will be translated
2082 // into a scope DIE at the end.
2083 if (DLTScope.isCompileUnit()) continue;
2084 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2085 DLT.getOrigLocation().getNode());
2086 Scope->setLastInsn(MInsn);
2090 if (!CurrentFnDbgScope)
2093 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2095 // Each scope has first instruction and last instruction to mark beginning
2096 // and end of a scope respectively. Create an inverse map that list scopes
2097 // starts (and ends) with an instruction. One instruction may start (or end)
2098 // multiple scopes. Ignore scopes that are not reachable.
2099 SmallVector<DbgScope *, 4> WorkList;
2100 WorkList.push_back(CurrentFnDbgScope);
2101 while (!WorkList.empty()) {
2102 DbgScope *S = WorkList.back(); WorkList.pop_back();
2104 SmallVector<DbgScope *, 4> &Children = S->getScopes();
2105 if (!Children.empty())
2106 for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2107 SE = Children.end(); SI != SE; ++SI)
2108 WorkList.push_back(*SI);
2110 if (S->isAbstractScope())
2112 const MachineInstr *MI = S->getFirstInsn();
2113 assert (MI && "DbgScope does not have first instruction!");
2115 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2116 if (IDI != DbgScopeBeginMap.end())
2117 IDI->second.push_back(S);
2119 DbgScopeBeginMap[MI].push_back(S);
2121 MI = S->getLastInsn();
2122 assert (MI && "DbgScope does not have last instruction!");
2123 IDI = DbgScopeEndMap.find(MI);
2124 if (IDI != DbgScopeEndMap.end())
2125 IDI->second.push_back(S);
2127 DbgScopeEndMap[MI].push_back(S);
2130 return !DbgScopeMap.empty();
2133 /// beginFunction - Gather pre-function debug information. Assumes being
2134 /// emitted immediately after the function entry point.
2135 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2138 if (!ShouldEmitDwarfDebug()) return;
2140 if (TimePassesIsEnabled)
2141 DebugTimer->startTimer();
2143 if (!extractScopeInformation())
2146 collectVariableInfo();
2148 // Assumes in correct section after the entry point.
2149 EmitLabel("func_begin", ++SubprogramCount);
2151 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2153 DebugLoc FDL = MF->getDefaultDebugLoc();
2154 if (!FDL.isUnknown()) {
2155 DILocation DLT = MF->getDILocation(FDL);
2156 unsigned LabelID = 0;
2157 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2159 LabelID = recordSourceLine(SP.getLineNumber(), 0,
2160 DLT.getScope().getNode());
2162 LabelID = recordSourceLine(DLT.getLineNumber(),
2163 DLT.getColumnNumber(),
2164 DLT.getScope().getNode());
2165 Asm->printLabel(LabelID);
2168 if (TimePassesIsEnabled)
2169 DebugTimer->stopTimer();
2172 /// endFunction - Gather and emit post-function debug information.
2174 void DwarfDebug::endFunction(const MachineFunction *MF) {
2175 if (!ShouldEmitDwarfDebug()) return;
2177 if (TimePassesIsEnabled)
2178 DebugTimer->startTimer();
2180 if (DbgScopeMap.empty())
2183 if (CurrentFnDbgScope) {
2184 // Define end label for subprogram.
2185 EmitLabel("func_end", SubprogramCount);
2187 // Get function line info.
2188 if (!Lines.empty()) {
2189 // Get section line info.
2190 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2191 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2192 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2193 // Append the function info to section info.
2194 SectionLineInfos.insert(SectionLineInfos.end(),
2195 Lines.begin(), Lines.end());
2198 // Construct abstract scopes.
2199 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2200 AE = AbstractScopesList.end(); AI != AE; ++AI)
2201 constructScopeDIE(*AI);
2203 constructScopeDIE(CurrentFnDbgScope);
2205 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2206 MMI->getFrameMoves()));
2210 CurrentFnDbgScope = NULL;
2211 DbgScopeMap.clear();
2212 DbgScopeBeginMap.clear();
2213 DbgScopeEndMap.clear();
2214 ConcreteScopes.clear();
2215 AbstractScopesList.clear();
2218 if (TimePassesIsEnabled)
2219 DebugTimer->stopTimer();
2222 /// recordSourceLine - Records location information and associates it with a
2223 /// label. Returns a unique label ID used to generate a label and provide
2224 /// correspondence to the source line list.
2225 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2230 if (TimePassesIsEnabled)
2231 DebugTimer->startTimer();
2236 DIDescriptor Scope(S);
2237 if (Scope.isCompileUnit()) {
2238 DICompileUnit CU(S);
2239 Dir = CU.getDirectory();
2240 Fn = CU.getFilename();
2241 } else if (Scope.isSubprogram()) {
2243 Dir = SP.getDirectory();
2244 Fn = SP.getFilename();
2245 } else if (Scope.isLexicalBlock()) {
2246 DILexicalBlock DB(S);
2247 Dir = DB.getDirectory();
2248 Fn = DB.getFilename();
2250 assert (0 && "Unexpected scope info");
2252 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2253 unsigned ID = MMI->NextLabelID();
2254 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2256 if (TimePassesIsEnabled)
2257 DebugTimer->stopTimer();
2262 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2263 /// timed. Look up the source id with the given directory and source file
2264 /// names. If none currently exists, create a new id and insert it in the
2265 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2267 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2268 const std::string &FileName) {
2269 if (TimePassesIsEnabled)
2270 DebugTimer->startTimer();
2272 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2274 if (TimePassesIsEnabled)
2275 DebugTimer->stopTimer();
2280 //===----------------------------------------------------------------------===//
2282 //===----------------------------------------------------------------------===//
2284 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2287 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2288 // Get the children.
2289 const std::vector<DIE *> &Children = Die->getChildren();
2291 // If not last sibling and has children then add sibling offset attribute.
2292 if (!Last && !Children.empty()) Die->addSiblingOffset();
2294 // Record the abbreviation.
2295 assignAbbrevNumber(Die->getAbbrev());
2297 // Get the abbreviation for this DIE.
2298 unsigned AbbrevNumber = Die->getAbbrevNumber();
2299 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2302 Die->setOffset(Offset);
2304 // Start the size with the size of abbreviation code.
2305 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2307 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2308 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2310 // Size the DIE attribute values.
2311 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2312 // Size attribute value.
2313 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2315 // Size the DIE children if any.
2316 if (!Children.empty()) {
2317 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2318 "Children flag not set");
2320 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2321 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2323 // End of children marker.
2324 Offset += sizeof(int8_t);
2327 Die->setSize(Offset - Die->getOffset());
2331 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2333 void DwarfDebug::computeSizeAndOffsets() {
2334 // Compute size of compile unit header.
2335 static unsigned Offset =
2336 sizeof(int32_t) + // Length of Compilation Unit Info
2337 sizeof(int16_t) + // DWARF version number
2338 sizeof(int32_t) + // Offset Into Abbrev. Section
2339 sizeof(int8_t); // Pointer Size (in bytes)
2341 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2342 CompileUnitOffsets[ModuleCU] = 0;
2345 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2346 /// tools to recognize the object file contains Dwarf information.
2347 void DwarfDebug::emitInitial() {
2348 // Check to see if we already emitted intial headers.
2349 if (didInitial) return;
2352 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2354 // Dwarf sections base addresses.
2355 if (MAI->doesDwarfRequireFrameSection()) {
2356 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2357 EmitLabel("section_debug_frame", 0);
2360 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2361 EmitLabel("section_info", 0);
2362 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2363 EmitLabel("section_abbrev", 0);
2364 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2365 EmitLabel("section_aranges", 0);
2367 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2368 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2369 EmitLabel("section_macinfo", 0);
2372 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2373 EmitLabel("section_line", 0);
2374 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2375 EmitLabel("section_loc", 0);
2376 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2377 EmitLabel("section_pubnames", 0);
2378 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2379 EmitLabel("section_pubtypes", 0);
2380 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2381 EmitLabel("section_str", 0);
2382 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2383 EmitLabel("section_ranges", 0);
2385 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2386 EmitLabel("text_begin", 0);
2387 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2388 EmitLabel("data_begin", 0);
2391 /// emitDIE - Recusively Emits a debug information entry.
2393 void DwarfDebug::emitDIE(DIE *Die) {
2394 // Get the abbreviation for this DIE.
2395 unsigned AbbrevNumber = Die->getAbbrevNumber();
2396 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2400 // Emit the code (index) for the abbreviation.
2401 if (Asm->VerboseAsm)
2402 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2403 Twine::utohexstr(Die->getOffset()) + ":0x" +
2404 Twine::utohexstr(Die->getSize()) + " " +
2405 dwarf::TagString(Abbrev->getTag()));
2406 EmitULEB128(AbbrevNumber);
2408 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2409 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2411 // Emit the DIE attribute values.
2412 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2413 unsigned Attr = AbbrevData[i].getAttribute();
2414 unsigned Form = AbbrevData[i].getForm();
2415 assert(Form && "Too many attributes for DIE (check abbreviation)");
2417 if (Asm->VerboseAsm)
2418 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2421 case dwarf::DW_AT_sibling:
2422 Asm->EmitInt32(Die->getSiblingOffset());
2424 case dwarf::DW_AT_abstract_origin: {
2425 DIEEntry *E = cast<DIEEntry>(Values[i]);
2426 DIE *Origin = E->getEntry();
2427 unsigned Addr = Origin->getOffset();
2428 Asm->EmitInt32(Addr);
2432 // Emit an attribute using the defined form.
2433 Values[i]->EmitValue(this, Form);
2434 O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2439 // Emit the DIE children if any.
2440 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2441 const std::vector<DIE *> &Children = Die->getChildren();
2443 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2444 emitDIE(Children[j]);
2446 Asm->EmitInt8(0); EOL("End Of Children Mark");
2450 /// emitDebugInfo - Emit the debug info section.
2452 void DwarfDebug::emitDebugInfo() {
2453 // Start debug info section.
2454 Asm->OutStreamer.SwitchSection(
2455 Asm->getObjFileLowering().getDwarfInfoSection());
2456 DIE *Die = ModuleCU->getCUDie();
2458 // Emit the compile units header.
2459 EmitLabel("info_begin", ModuleCU->getID());
2461 // Emit size of content not including length itself
2462 unsigned ContentSize = Die->getSize() +
2463 sizeof(int16_t) + // DWARF version number
2464 sizeof(int32_t) + // Offset Into Abbrev. Section
2465 sizeof(int8_t) + // Pointer Size (in bytes)
2466 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2468 Asm->EmitInt32(ContentSize); EOL("Length of Compilation Unit Info");
2469 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2470 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2471 EOL("Offset Into Abbrev. Section");
2472 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2475 // FIXME - extra padding for gdb bug.
2476 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2477 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2478 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2479 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2480 EmitLabel("info_end", ModuleCU->getID());
2484 /// emitAbbreviations - Emit the abbreviation section.
2486 void DwarfDebug::emitAbbreviations() const {
2487 // Check to see if it is worth the effort.
2488 if (!Abbreviations.empty()) {
2489 // Start the debug abbrev section.
2490 Asm->OutStreamer.SwitchSection(
2491 Asm->getObjFileLowering().getDwarfAbbrevSection());
2493 EmitLabel("abbrev_begin", 0);
2495 // For each abbrevation.
2496 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2497 // Get abbreviation data
2498 const DIEAbbrev *Abbrev = Abbreviations[i];
2500 // Emit the abbrevations code (base 1 index.)
2501 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2503 // Emit the abbreviations data.
2508 // Mark end of abbreviations.
2509 EmitULEB128(0, "EOM(3)");
2511 EmitLabel("abbrev_end", 0);
2516 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2517 /// the line matrix.
2519 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2520 // Define last address of section.
2521 Asm->EmitInt8(0); EOL("Extended Op");
2522 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2523 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2524 EmitReference("section_end", SectionEnd); EOL("Section end label");
2526 // Mark end of matrix.
2527 Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2532 /// emitDebugLines - Emit source line information.
2534 void DwarfDebug::emitDebugLines() {
2535 // If the target is using .loc/.file, the assembler will be emitting the
2536 // .debug_line table automatically.
2537 if (MAI->hasDotLocAndDotFile())
2540 // Minimum line delta, thus ranging from -10..(255-10).
2541 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2542 // Maximum line delta, thus ranging from -10..(255-10).
2543 const int MaxLineDelta = 255 + MinLineDelta;
2545 // Start the dwarf line section.
2546 Asm->OutStreamer.SwitchSection(
2547 Asm->getObjFileLowering().getDwarfLineSection());
2549 // Construct the section header.
2550 EmitDifference("line_end", 0, "line_begin", 0, true);
2551 EOL("Length of Source Line Info");
2552 EmitLabel("line_begin", 0);
2554 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2556 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2557 EOL("Prolog Length");
2558 EmitLabel("line_prolog_begin", 0);
2560 Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2561 Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2562 Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2563 Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2564 Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2566 // Line number standard opcode encodings argument count
2567 Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2568 Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2569 Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2570 Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2571 Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2572 Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2573 Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2574 Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2575 Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2577 // Emit directories.
2578 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2579 const std::string &Dir = getSourceDirectoryName(DI);
2580 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2581 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2584 Asm->EmitInt8(0); EOL("End of directories");
2587 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2588 // Remember source id starts at 1.
2589 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2590 const std::string &FN = getSourceFileName(Id.second);
2591 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2592 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2594 EmitULEB128(Id.first, "Directory #");
2595 EmitULEB128(0, "Mod date");
2596 EmitULEB128(0, "File size");
2599 Asm->EmitInt8(0); EOL("End of files");
2601 EmitLabel("line_prolog_end", 0);
2603 // A sequence for each text section.
2604 unsigned SecSrcLinesSize = SectionSourceLines.size();
2606 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2607 // Isolate current sections line info.
2608 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2610 /*if (Asm->isVerbose()) {
2611 const MCSection *S = SectionMap[j + 1];
2612 O << '\t' << MAI->getCommentString() << " Section"
2613 << S->getName() << '\n';
2617 // Dwarf assumes we start with first line of first source file.
2618 unsigned Source = 1;
2621 // Construct rows of the address, source, line, column matrix.
2622 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2623 const SrcLineInfo &LineInfo = LineInfos[i];
2624 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2625 if (!LabelID) continue;
2627 if (LineInfo.getLine() == 0) continue;
2629 if (!Asm->isVerbose())
2632 std::pair<unsigned, unsigned> SourceID =
2633 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2634 O << '\t' << MAI->getCommentString() << ' '
2635 << getSourceDirectoryName(SourceID.first) << '/'
2636 << getSourceFileName(SourceID.second)
2637 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2640 // Define the line address.
2641 Asm->EmitInt8(0); EOL("Extended Op");
2642 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2643 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2644 EmitReference("label", LabelID); EOL("Location label");
2646 // If change of source, then switch to the new source.
2647 if (Source != LineInfo.getSourceID()) {
2648 Source = LineInfo.getSourceID();
2649 Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2650 EmitULEB128(Source, "New Source");
2653 // If change of line.
2654 if (Line != LineInfo.getLine()) {
2655 // Determine offset.
2656 int Offset = LineInfo.getLine() - Line;
2657 int Delta = Offset - MinLineDelta;
2660 Line = LineInfo.getLine();
2662 // If delta is small enough and in range...
2663 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2664 // ... then use fast opcode.
2665 Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2667 // ... otherwise use long hand.
2668 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2669 EOL("DW_LNS_advance_line");
2670 EmitSLEB128(Offset, "Line Offset");
2671 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2674 // Copy the previous row (different address or source)
2675 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2679 emitEndOfLineMatrix(j + 1);
2682 if (SecSrcLinesSize == 0)
2683 // Because we're emitting a debug_line section, we still need a line
2684 // table. The linker and friends expect it to exist. If there's nothing to
2685 // put into it, emit an empty table.
2686 emitEndOfLineMatrix(1);
2688 EmitLabel("line_end", 0);
2692 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2694 void DwarfDebug::emitCommonDebugFrame() {
2695 if (!MAI->doesDwarfRequireFrameSection())
2699 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2700 TargetFrameInfo::StackGrowsUp ?
2701 TD->getPointerSize() : -TD->getPointerSize();
2703 // Start the dwarf frame section.
2704 Asm->OutStreamer.SwitchSection(
2705 Asm->getObjFileLowering().getDwarfFrameSection());
2707 EmitLabel("debug_frame_common", 0);
2708 EmitDifference("debug_frame_common_end", 0,
2709 "debug_frame_common_begin", 0, true);
2710 EOL("Length of Common Information Entry");
2712 EmitLabel("debug_frame_common_begin", 0);
2713 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2714 EOL("CIE Identifier Tag");
2715 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2717 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2718 EOL("CIE Augmentation");
2719 EmitULEB128(1, "CIE Code Alignment Factor");
2720 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2721 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2722 EOL("CIE RA Column");
2724 std::vector<MachineMove> Moves;
2725 RI->getInitialFrameState(Moves);
2727 EmitFrameMoves(NULL, 0, Moves, false);
2729 Asm->EmitAlignment(2, 0, 0, false);
2730 EmitLabel("debug_frame_common_end", 0);
2734 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2737 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2738 if (!MAI->doesDwarfRequireFrameSection())
2741 // Start the dwarf frame section.
2742 Asm->OutStreamer.SwitchSection(
2743 Asm->getObjFileLowering().getDwarfFrameSection());
2745 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2746 "debug_frame_begin", DebugFrameInfo.Number, true);
2747 EOL("Length of Frame Information Entry");
2749 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2751 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2753 EOL("FDE CIE offset");
2755 EmitReference("func_begin", DebugFrameInfo.Number);
2756 EOL("FDE initial location");
2757 EmitDifference("func_end", DebugFrameInfo.Number,
2758 "func_begin", DebugFrameInfo.Number);
2759 EOL("FDE address range");
2761 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2764 Asm->EmitAlignment(2, 0, 0, false);
2765 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2769 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2771 void DwarfDebug::emitDebugPubNames() {
2772 // Start the dwarf pubnames section.
2773 Asm->OutStreamer.SwitchSection(
2774 Asm->getObjFileLowering().getDwarfPubNamesSection());
2776 EmitDifference("pubnames_end", ModuleCU->getID(),
2777 "pubnames_begin", ModuleCU->getID(), true);
2778 EOL("Length of Public Names Info");
2780 EmitLabel("pubnames_begin", ModuleCU->getID());
2782 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2784 EmitSectionOffset("info_begin", "section_info",
2785 ModuleCU->getID(), 0, true, false);
2786 EOL("Offset of Compilation Unit Info");
2788 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2790 EOL("Compilation Unit Length");
2792 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2793 for (StringMap<DIE*>::const_iterator
2794 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2795 const char *Name = GI->getKeyData();
2796 DIE * Entity = GI->second;
2798 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2800 if (Asm->VerboseAsm)
2801 Asm->OutStreamer.AddComment("External Name");
2802 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2805 Asm->EmitInt32(0); EOL("End Mark");
2806 EmitLabel("pubnames_end", ModuleCU->getID());
2810 void DwarfDebug::emitDebugPubTypes() {
2811 // Start the dwarf pubnames section.
2812 Asm->OutStreamer.SwitchSection(
2813 Asm->getObjFileLowering().getDwarfPubTypesSection());
2814 EmitDifference("pubtypes_end", ModuleCU->getID(),
2815 "pubtypes_begin", ModuleCU->getID(), true);
2816 EOL("Length of Public Types Info");
2818 EmitLabel("pubtypes_begin", ModuleCU->getID());
2820 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2821 Asm->EmitInt16(dwarf::DWARF_VERSION);
2823 EmitSectionOffset("info_begin", "section_info",
2824 ModuleCU->getID(), 0, true, false);
2825 EOL("Offset of Compilation ModuleCU Info");
2827 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2829 EOL("Compilation ModuleCU Length");
2831 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2832 for (StringMap<DIE*>::const_iterator
2833 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2834 const char *Name = GI->getKeyData();
2835 DIE * Entity = GI->second;
2837 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2838 Asm->EmitInt32(Entity->getOffset());
2840 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2841 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2844 Asm->EmitInt32(0); EOL("End Mark");
2845 EmitLabel("pubtypes_end", ModuleCU->getID());
2849 /// emitDebugStr - Emit visible names into a debug str section.
2851 void DwarfDebug::emitDebugStr() {
2852 // Check to see if it is worth the effort.
2853 if (!StringPool.empty()) {
2854 // Start the dwarf str section.
2855 Asm->OutStreamer.SwitchSection(
2856 Asm->getObjFileLowering().getDwarfStrSection());
2858 // For each of strings in the string pool.
2859 for (unsigned StringID = 1, N = StringPool.size();
2860 StringID <= N; ++StringID) {
2861 // Emit a label for reference from debug information entries.
2862 EmitLabel("string", StringID);
2864 // Emit the string itself.
2865 const std::string &String = StringPool[StringID];
2866 Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2873 /// emitDebugLoc - Emit visible names into a debug loc section.
2875 void DwarfDebug::emitDebugLoc() {
2876 // Start the dwarf loc section.
2877 Asm->OutStreamer.SwitchSection(
2878 Asm->getObjFileLowering().getDwarfLocSection());
2881 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2883 void DwarfDebug::EmitDebugARanges() {
2884 // Start the dwarf aranges section.
2885 Asm->OutStreamer.SwitchSection(
2886 Asm->getObjFileLowering().getDwarfARangesSection());
2890 CompileUnit *Unit = GetBaseCompileUnit();
2892 // Don't include size of length
2893 Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2895 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2897 EmitReference("info_begin", Unit->getID());
2898 EOL("Offset of Compilation Unit Info");
2900 Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2902 Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2904 Asm->EmitInt16(0); EOL("Pad (1)");
2905 Asm->EmitInt16(0); EOL("Pad (2)");
2908 EmitReference("text_begin", 0); EOL("Address");
2909 EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
2911 Asm->EmitInt32(0); EOL("EOM (1)");
2912 Asm->EmitInt32(0); EOL("EOM (2)");
2916 /// emitDebugRanges - Emit visible names into a debug ranges section.
2918 void DwarfDebug::emitDebugRanges() {
2919 // Start the dwarf ranges section.
2920 Asm->OutStreamer.SwitchSection(
2921 Asm->getObjFileLowering().getDwarfRangesSection());
2924 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2926 void DwarfDebug::emitDebugMacInfo() {
2927 if (const MCSection *LineInfo =
2928 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2929 // Start the dwarf macinfo section.
2930 Asm->OutStreamer.SwitchSection(LineInfo);
2934 /// emitDebugInlineInfo - Emit inline info using following format.
2936 /// 1. length of section
2937 /// 2. Dwarf version number
2938 /// 3. address size.
2940 /// Entries (one "entry" for each function that was inlined):
2942 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2943 /// otherwise offset into __debug_str for regular function name.
2944 /// 2. offset into __debug_str section for regular function name.
2945 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2946 /// instances for the function.
2948 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2949 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2950 /// __debug_info section, and the low_pc is the starting address for the
2951 /// inlining instance.
2952 void DwarfDebug::emitDebugInlineInfo() {
2953 if (!MAI->doesDwarfUsesInlineInfoSection())
2959 Asm->OutStreamer.SwitchSection(
2960 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2962 EmitDifference("debug_inlined_end", 1,
2963 "debug_inlined_begin", 1, true);
2964 EOL("Length of Debug Inlined Information Entry");
2966 EmitLabel("debug_inlined_begin", 1);
2968 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2969 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2971 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2972 E = InlinedSPNodes.end(); I != E; ++I) {
2975 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2976 = InlineInfo.find(Node);
2977 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2978 DISubprogram SP(Node);
2979 StringRef LName = SP.getLinkageName();
2980 StringRef Name = SP.getName();
2982 if (LName.empty()) {
2983 Asm->OutStreamer.EmitBytes(Name, 0);
2984 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2986 EmitSectionOffset("string", "section_str",
2987 StringPool.idFor(getRealLinkageName(LName)), false, true);
2989 EOL("MIPS linkage name");
2990 EmitSectionOffset("string", "section_str",
2991 StringPool.idFor(Name), false, true);
2992 EOL("Function name");
2993 EmitULEB128(Labels.size(), "Inline count");
2995 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2996 LE = Labels.end(); LI != LE; ++LI) {
2997 DIE *SP = LI->second;
2998 Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
3000 if (TD->getPointerSize() == sizeof(int32_t))
3001 O << MAI->getData32bitsDirective();
3003 O << MAI->getData64bitsDirective();
3005 PrintLabelName("label", LI->first); EOL("low_pc");
3009 EmitLabel("debug_inlined_end", 1);