1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
13 #define DEBUG_TYPE "dwarfdebug"
14 #include "DwarfDebug.h"
15 #include "llvm/Module.h"
16 #include "llvm/CodeGen/MachineFunction.h"
17 #include "llvm/CodeGen/MachineModuleInfo.h"
18 #include "llvm/MC/MCSection.h"
19 #include "llvm/MC/MCStreamer.h"
20 #include "llvm/MC/MCAsmInfo.h"
21 #include "llvm/Target/Mangler.h"
22 #include "llvm/Target/TargetData.h"
23 #include "llvm/Target/TargetFrameInfo.h"
24 #include "llvm/Target/TargetLoweringObjectFile.h"
25 #include "llvm/Target/TargetRegisterInfo.h"
26 #include "llvm/ADT/StringExtras.h"
27 #include "llvm/Support/Debug.h"
28 #include "llvm/Support/ErrorHandling.h"
29 #include "llvm/Support/ValueHandle.h"
30 #include "llvm/Support/FormattedStream.h"
31 #include "llvm/Support/Timer.h"
32 #include "llvm/System/Path.h"
35 //===----------------------------------------------------------------------===//
37 /// Configuration values for initial hash set sizes (log2).
39 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
43 //===----------------------------------------------------------------------===//
44 /// CompileUnit - This dwarf writer support class manages information associate
45 /// with a source file.
47 /// ID - File identifier for source.
51 /// Die - Compile unit debug information entry.
55 /// IndexTyDie - An anonymous type for index type.
58 /// GVToDieMap - Tracks the mapping of unit level debug informaton
59 /// variables to debug information entries.
60 /// FIXME : Rename GVToDieMap -> NodeToDieMap
61 DenseMap<MDNode *, DIE *> GVToDieMap;
63 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
64 /// descriptors to debug information entries using a DIEEntry proxy.
66 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
68 /// Globals - A map of globally visible named entities for this unit.
70 StringMap<DIE*> Globals;
72 /// GlobalTypes - A map of globally visible types for this unit.
74 StringMap<DIE*> GlobalTypes;
77 CompileUnit(unsigned I, DIE *D)
78 : ID(I), CUDie(D), IndexTyDie(0) {}
79 ~CompileUnit() { delete CUDie; delete IndexTyDie; }
82 unsigned getID() const { return ID; }
83 DIE* getCUDie() const { return CUDie; }
84 const StringMap<DIE*> &getGlobals() const { return Globals; }
85 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
87 /// hasContent - Return true if this compile unit has something to write out.
89 bool hasContent() const { return !CUDie->getChildren().empty(); }
91 /// addGlobal - Add a new global entity to the compile unit.
93 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
95 /// addGlobalType - Add a new global type to the compile unit.
97 void addGlobalType(const std::string &Name, DIE *Die) {
98 GlobalTypes[Name] = Die;
101 /// getDIE - Returns the debug information entry map slot for the
102 /// specified debug variable.
103 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
105 /// insertDIE - Insert DIE into the map.
106 void insertDIE(MDNode *N, DIE *D) {
107 GVToDieMap.insert(std::make_pair(N, D));
110 /// getDIEEntry - Returns the debug information entry for the speciefied
112 DIEEntry *getDIEEntry(MDNode *N) {
113 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
114 if (I == GVToDIEEntryMap.end())
119 /// insertDIEEntry - Insert debug information entry into the map.
120 void insertDIEEntry(MDNode *N, DIEEntry *E) {
121 GVToDIEEntryMap.insert(std::make_pair(N, E));
124 /// addDie - Adds or interns the DIE to the compile unit.
126 void addDie(DIE *Buffer) {
127 this->CUDie->addChild(Buffer);
130 // getIndexTyDie - Get an anonymous type for index type.
131 DIE *getIndexTyDie() {
135 // setIndexTyDie - Set D as anonymous type for index which can be reused
137 void setIndexTyDie(DIE *D) {
143 //===----------------------------------------------------------------------===//
144 /// DbgVariable - This class is used to track local variable information.
147 DIVariable Var; // Variable Descriptor.
148 unsigned FrameIndex; // Variable frame index.
149 DbgVariable *AbstractVar; // Abstract variable for this variable.
152 DbgVariable(DIVariable V, unsigned I)
153 : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0) {}
156 DIVariable getVariable() const { return Var; }
157 unsigned getFrameIndex() const { return FrameIndex; }
158 void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
159 DbgVariable *getAbstractVariable() const { return AbstractVar; }
160 void setDIE(DIE *D) { TheDIE = D; }
161 DIE *getDIE() const { return TheDIE; }
164 //===----------------------------------------------------------------------===//
165 /// DbgScope - This class is used to track scope information.
168 DbgScope *Parent; // Parent to this scope.
169 DIDescriptor Desc; // Debug info descriptor for scope.
170 // Location at which this scope is inlined.
171 AssertingVH<MDNode> InlinedAtLocation;
172 bool AbstractScope; // Abstract Scope
173 unsigned StartLabelID; // Label ID of the beginning of scope.
174 unsigned EndLabelID; // Label ID of the end of scope.
175 const MachineInstr *LastInsn; // Last instruction of this scope.
176 const MachineInstr *FirstInsn; // First instruction of this scope.
177 SmallVector<DbgScope *, 4> Scopes; // Scopes defined in scope.
178 SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
180 // Private state for dump()
181 mutable unsigned IndentLevel;
183 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
184 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
185 StartLabelID(0), EndLabelID(0),
186 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
190 DbgScope *getParent() const { return Parent; }
191 void setParent(DbgScope *P) { Parent = P; }
192 DIDescriptor getDesc() const { return Desc; }
193 MDNode *getInlinedAt() const {
194 return InlinedAtLocation;
196 MDNode *getScopeNode() const { return Desc.getNode(); }
197 unsigned getStartLabelID() const { return StartLabelID; }
198 unsigned getEndLabelID() const { return EndLabelID; }
199 SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
200 SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
201 void setStartLabelID(unsigned S) { StartLabelID = S; }
202 void setEndLabelID(unsigned E) { EndLabelID = E; }
203 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
204 const MachineInstr *getLastInsn() { return LastInsn; }
205 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
206 void setAbstractScope() { AbstractScope = true; }
207 bool isAbstractScope() const { return AbstractScope; }
208 const MachineInstr *getFirstInsn() { return FirstInsn; }
210 /// addScope - Add a scope to the scope.
212 void addScope(DbgScope *S) { Scopes.push_back(S); }
214 /// addVariable - Add a variable to the scope.
216 void addVariable(DbgVariable *V) { Variables.push_back(V); }
218 void fixInstructionMarkers(DenseMap<const MachineInstr *,
219 unsigned> &MIIndexMap) {
220 assert (getFirstInsn() && "First instruction is missing!");
222 // Use the end of last child scope as end of this scope.
223 SmallVector<DbgScope *, 4> &Scopes = getScopes();
224 const MachineInstr *LastInsn = getFirstInsn();
226 if (Scopes.empty()) {
227 assert (getLastInsn() && "Inner most scope does not have last insn!");
230 for (SmallVector<DbgScope *, 4>::iterator SI = Scopes.begin(),
231 SE = Scopes.end(); SI != SE; ++SI) {
233 DS->fixInstructionMarkers(MIIndexMap);
234 const MachineInstr *DSLastInsn = DS->getLastInsn();
235 unsigned DSI = MIIndexMap[DSLastInsn];
237 LastInsn = DSLastInsn;
241 setLastInsn(LastInsn);
250 void DbgScope::dump() const {
251 raw_ostream &err = dbgs();
252 err.indent(IndentLevel);
253 MDNode *N = Desc.getNode();
255 err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
257 err << "Abstract Scope\n";
261 err << "Children ...\n";
262 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
263 if (Scopes[i] != this)
270 DbgScope::~DbgScope() {
271 for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
273 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
277 } // end llvm namespace
279 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
280 : DwarfPrinter(OS, A, T, "dbg"), ModuleCU(0),
281 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
282 DIEValues(), StringPool(),
283 SectionSourceLines(), didInitial(false), shouldEmit(false),
284 CurrentFnDbgScope(0), DebugTimer(0) {
285 if (TimePassesIsEnabled)
286 DebugTimer = new Timer("Dwarf Debug Writer");
288 DwarfDebug::~DwarfDebug() {
289 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
295 /// assignAbbrevNumber - Define a unique number for the abbreviation.
297 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
298 // Profile the node so that we can make it unique.
302 // Check the set for priors.
303 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
305 // If it's newly added.
306 if (InSet == &Abbrev) {
307 // Add to abbreviation list.
308 Abbreviations.push_back(&Abbrev);
310 // Assign the vector position + 1 as its number.
311 Abbrev.setNumber(Abbreviations.size());
313 // Assign existing abbreviation number.
314 Abbrev.setNumber(InSet->getNumber());
318 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
319 /// information entry.
320 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
321 DIEEntry *Value = new DIEEntry(Entry);
322 DIEValues.push_back(Value);
326 /// addUInt - Add an unsigned integer attribute data and value.
328 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
329 unsigned Form, uint64_t Integer) {
330 if (!Form) Form = DIEInteger::BestForm(false, Integer);
331 DIEValue *Value = new DIEInteger(Integer);
332 DIEValues.push_back(Value);
333 Die->addValue(Attribute, Form, Value);
336 /// addSInt - Add an signed integer attribute data and value.
338 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
339 unsigned Form, int64_t Integer) {
340 if (!Form) Form = DIEInteger::BestForm(true, Integer);
341 DIEValue *Value = new DIEInteger(Integer);
342 DIEValues.push_back(Value);
343 Die->addValue(Attribute, Form, Value);
346 /// addString - Add a string attribute data and value. DIEString only
347 /// keeps string reference.
348 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
350 DIEValue *Value = new DIEString(String);
351 DIEValues.push_back(Value);
352 Die->addValue(Attribute, Form, Value);
355 /// addLabel - Add a Dwarf label attribute data and value.
357 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
358 const DWLabel &Label) {
359 DIEValue *Value = new DIEDwarfLabel(Label);
360 DIEValues.push_back(Value);
361 Die->addValue(Attribute, Form, Value);
364 /// addObjectLabel - Add an non-Dwarf label attribute data and value.
366 void DwarfDebug::addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
367 const MCSymbol *Sym) {
368 DIEValue *Value = new DIEObjectLabel(Sym);
369 DIEValues.push_back(Value);
370 Die->addValue(Attribute, Form, Value);
373 /// addSectionOffset - Add a section offset label attribute data and value.
375 void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
376 const DWLabel &Label, const DWLabel &Section,
377 bool isEH, bool useSet) {
378 DIEValue *Value = new DIESectionOffset(Label, Section, isEH, useSet);
379 DIEValues.push_back(Value);
380 Die->addValue(Attribute, Form, Value);
383 /// addDelta - Add a label delta attribute data and value.
385 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
386 const DWLabel &Hi, const DWLabel &Lo) {
387 DIEValue *Value = new DIEDelta(Hi, Lo);
388 DIEValues.push_back(Value);
389 Die->addValue(Attribute, Form, Value);
392 /// addBlock - Add block data.
394 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
396 Block->ComputeSize(TD);
397 DIEValues.push_back(Block);
398 Die->addValue(Attribute, Block->BestForm(), Block);
401 /// addSourceLine - Add location information to specified debug information
403 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
404 // If there is no compile unit specified, don't add a line #.
405 if (V->getCompileUnit().isNull())
408 unsigned Line = V->getLineNumber();
409 unsigned FileID = findCompileUnit(V->getCompileUnit())->getID();
410 assert(FileID && "Invalid file id");
411 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
412 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
415 /// addSourceLine - Add location information to specified debug information
417 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
418 // If there is no compile unit specified, don't add a line #.
419 if (G->getCompileUnit().isNull())
422 unsigned Line = G->getLineNumber();
423 unsigned FileID = findCompileUnit(G->getCompileUnit())->getID();
424 assert(FileID && "Invalid file id");
425 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
426 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
429 /// addSourceLine - Add location information to specified debug information
431 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
432 // If there is no compile unit specified, don't add a line #.
433 if (SP->getCompileUnit().isNull())
435 // If the line number is 0, don't add it.
436 if (SP->getLineNumber() == 0)
440 unsigned Line = SP->getLineNumber();
441 unsigned FileID = findCompileUnit(SP->getCompileUnit())->getID();
442 assert(FileID && "Invalid file id");
443 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
444 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
447 /// addSourceLine - Add location information to specified debug information
449 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
450 // If there is no compile unit specified, don't add a line #.
451 DICompileUnit CU = Ty->getCompileUnit();
455 unsigned Line = Ty->getLineNumber();
456 unsigned FileID = findCompileUnit(CU)->getID();
457 assert(FileID && "Invalid file id");
458 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
459 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
462 /// addSourceLine - Add location information to specified debug information
464 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
465 // If there is no compile unit specified, don't add a line #.
466 if (NS->getCompileUnit().isNull())
469 unsigned Line = NS->getLineNumber();
470 StringRef FN = NS->getFilename();
471 StringRef Dir = NS->getDirectory();
473 unsigned FileID = GetOrCreateSourceID(Dir, FN);
474 assert(FileID && "Invalid file id");
475 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
476 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
479 /* Byref variables, in Blocks, are declared by the programmer as
480 "SomeType VarName;", but the compiler creates a
481 __Block_byref_x_VarName struct, and gives the variable VarName
482 either the struct, or a pointer to the struct, as its type. This
483 is necessary for various behind-the-scenes things the compiler
484 needs to do with by-reference variables in blocks.
486 However, as far as the original *programmer* is concerned, the
487 variable should still have type 'SomeType', as originally declared.
489 The following function dives into the __Block_byref_x_VarName
490 struct to find the original type of the variable. This will be
491 passed back to the code generating the type for the Debug
492 Information Entry for the variable 'VarName'. 'VarName' will then
493 have the original type 'SomeType' in its debug information.
495 The original type 'SomeType' will be the type of the field named
496 'VarName' inside the __Block_byref_x_VarName struct.
498 NOTE: In order for this to not completely fail on the debugger
499 side, the Debug Information Entry for the variable VarName needs to
500 have a DW_AT_location that tells the debugger how to unwind through
501 the pointers and __Block_byref_x_VarName struct to find the actual
502 value of the variable. The function addBlockByrefType does this. */
504 /// Find the type the programmer originally declared the variable to be
505 /// and return that type.
507 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
510 unsigned tag = Ty.getTag();
512 if (tag == dwarf::DW_TAG_pointer_type) {
513 DIDerivedType DTy = DIDerivedType(Ty.getNode());
514 subType = DTy.getTypeDerivedFrom();
517 DICompositeType blockStruct = DICompositeType(subType.getNode());
519 DIArray Elements = blockStruct.getTypeArray();
521 if (Elements.isNull())
524 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
525 DIDescriptor Element = Elements.getElement(i);
526 DIDerivedType DT = DIDerivedType(Element.getNode());
527 if (Name == DT.getName())
528 return (DT.getTypeDerivedFrom());
534 /// addComplexAddress - Start with the address based on the location provided,
535 /// and generate the DWARF information necessary to find the actual variable
536 /// given the extra address information encoded in the DIVariable, starting from
537 /// the starting location. Add the DWARF information to the die.
539 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
541 const MachineLocation &Location) {
542 const DIVariable &VD = DV->getVariable();
543 DIType Ty = VD.getType();
545 // Decode the original location, and use that as the start of the byref
546 // variable's location.
547 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
548 DIEBlock *Block = new DIEBlock();
550 if (Location.isReg()) {
552 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
554 Reg = Reg - dwarf::DW_OP_reg0;
555 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
556 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
560 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
562 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
563 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
566 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
569 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
570 uint64_t Element = VD.getAddrElement(i);
572 if (Element == DIFactory::OpPlus) {
573 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
574 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
575 } else if (Element == DIFactory::OpDeref) {
576 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
577 } else llvm_unreachable("unknown DIFactory Opcode");
580 // Now attach the location information to the DIE.
581 addBlock(Die, Attribute, 0, Block);
584 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
585 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
586 gives the variable VarName either the struct, or a pointer to the struct, as
587 its type. This is necessary for various behind-the-scenes things the
588 compiler needs to do with by-reference variables in Blocks.
590 However, as far as the original *programmer* is concerned, the variable
591 should still have type 'SomeType', as originally declared.
593 The function getBlockByrefType dives into the __Block_byref_x_VarName
594 struct to find the original type of the variable, which is then assigned to
595 the variable's Debug Information Entry as its real type. So far, so good.
596 However now the debugger will expect the variable VarName to have the type
597 SomeType. So we need the location attribute for the variable to be an
598 expression that explains to the debugger how to navigate through the
599 pointers and struct to find the actual variable of type SomeType.
601 The following function does just that. We start by getting
602 the "normal" location for the variable. This will be the location
603 of either the struct __Block_byref_x_VarName or the pointer to the
604 struct __Block_byref_x_VarName.
606 The struct will look something like:
608 struct __Block_byref_x_VarName {
610 struct __Block_byref_x_VarName *forwarding;
611 ... <various other fields>
613 ... <maybe more fields>
616 If we are given the struct directly (as our starting point) we
617 need to tell the debugger to:
619 1). Add the offset of the forwarding field.
621 2). Follow that pointer to get the the real __Block_byref_x_VarName
622 struct to use (the real one may have been copied onto the heap).
624 3). Add the offset for the field VarName, to find the actual variable.
626 If we started with a pointer to the struct, then we need to
627 dereference that pointer first, before the other steps.
628 Translating this into DWARF ops, we will need to append the following
629 to the current location description for the variable:
631 DW_OP_deref -- optional, if we start with a pointer
632 DW_OP_plus_uconst <forward_fld_offset>
634 DW_OP_plus_uconst <varName_fld_offset>
636 That is what this function does. */
638 /// addBlockByrefAddress - Start with the address based on the location
639 /// provided, and generate the DWARF information necessary to find the
640 /// actual Block variable (navigating the Block struct) based on the
641 /// starting location. Add the DWARF information to the die. For
642 /// more information, read large comment just above here.
644 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
646 const MachineLocation &Location) {
647 const DIVariable &VD = DV->getVariable();
648 DIType Ty = VD.getType();
650 unsigned Tag = Ty.getTag();
651 bool isPointer = false;
653 StringRef varName = VD.getName();
655 if (Tag == dwarf::DW_TAG_pointer_type) {
656 DIDerivedType DTy = DIDerivedType(Ty.getNode());
657 TmpTy = DTy.getTypeDerivedFrom();
661 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
663 // Find the __forwarding field and the variable field in the __Block_byref
665 DIArray Fields = blockStruct.getTypeArray();
666 DIDescriptor varField = DIDescriptor();
667 DIDescriptor forwardingField = DIDescriptor();
670 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
671 DIDescriptor Element = Fields.getElement(i);
672 DIDerivedType DT = DIDerivedType(Element.getNode());
673 StringRef fieldName = DT.getName();
674 if (fieldName == "__forwarding")
675 forwardingField = Element;
676 else if (fieldName == varName)
680 assert(!varField.isNull() && "Can't find byref variable in Block struct");
681 assert(!forwardingField.isNull()
682 && "Can't find forwarding field in Block struct");
684 // Get the offsets for the forwarding field and the variable field.
685 unsigned int forwardingFieldOffset =
686 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
687 unsigned int varFieldOffset =
688 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
690 // Decode the original location, and use that as the start of the byref
691 // variable's location.
692 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
693 DIEBlock *Block = new DIEBlock();
695 if (Location.isReg()) {
697 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
699 Reg = Reg - dwarf::DW_OP_reg0;
700 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
701 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
705 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
707 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
708 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
711 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
714 // If we started with a pointer to the __Block_byref... struct, then
715 // the first thing we need to do is dereference the pointer (DW_OP_deref).
717 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
719 // Next add the offset for the '__forwarding' field:
720 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
721 // adding the offset if it's 0.
722 if (forwardingFieldOffset > 0) {
723 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
724 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
727 // Now dereference the __forwarding field to get to the real __Block_byref
728 // struct: DW_OP_deref.
729 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
731 // Now that we've got the real __Block_byref... struct, add the offset
732 // for the variable's field to get to the location of the actual variable:
733 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
734 if (varFieldOffset > 0) {
735 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
736 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
739 // Now attach the location information to the DIE.
740 addBlock(Die, Attribute, 0, Block);
743 /// addAddress - Add an address attribute to a die based on the location
745 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
746 const MachineLocation &Location) {
747 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
748 DIEBlock *Block = new DIEBlock();
750 if (Location.isReg()) {
752 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
754 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
755 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
759 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
761 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
762 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
765 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
768 addBlock(Die, Attribute, 0, Block);
771 /// addToContextOwner - Add Die into the list of its context owner's children.
772 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
773 if (Context.isNull())
774 ModuleCU->addDie(Die);
775 else if (Context.isType()) {
776 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
777 ContextDIE->addChild(Die);
778 } else if (Context.isNameSpace()) {
779 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
780 ContextDIE->addChild(Die);
781 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
782 ContextDIE->addChild(Die);
784 ModuleCU->addDie(Die);
787 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
789 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
790 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
795 TyDIE = new DIE(dwarf::DW_TAG_base_type);
796 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
797 if (Ty.isBasicType())
798 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
799 else if (Ty.isCompositeType())
800 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
802 assert(Ty.isDerivedType() && "Unknown kind of DIType");
803 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
806 addToContextOwner(TyDIE, Ty.getContext());
810 /// addType - Add a new type attribute to the specified entity.
811 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
815 // Check for pre-existence.
816 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
817 // If it exists then use the existing value.
819 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
824 Entry = createDIEEntry();
825 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
828 DIE *Buffer = getOrCreateTypeDIE(Ty);
830 Entry->setEntry(Buffer);
831 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
834 /// constructTypeDIE - Construct basic type die from DIBasicType.
835 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
836 // Get core information.
837 StringRef Name = BTy.getName();
838 Buffer.setTag(dwarf::DW_TAG_base_type);
839 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
842 // Add name if not anonymous or intermediate type.
844 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
845 uint64_t Size = BTy.getSizeInBits() >> 3;
846 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
849 /// constructTypeDIE - Construct derived type die from DIDerivedType.
850 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
851 // Get core information.
852 StringRef Name = DTy.getName();
853 uint64_t Size = DTy.getSizeInBits() >> 3;
854 unsigned Tag = DTy.getTag();
856 // FIXME - Workaround for templates.
857 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
861 // Map to main type, void will not have a type.
862 DIType FromTy = DTy.getTypeDerivedFrom();
863 addType(&Buffer, FromTy);
865 // Add name if not anonymous or intermediate type.
867 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
869 // Add size if non-zero (derived types might be zero-sized.)
871 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
873 // Add source line info if available and TyDesc is not a forward declaration.
874 if (!DTy.isForwardDecl())
875 addSourceLine(&Buffer, &DTy);
878 /// constructTypeDIE - Construct type DIE from DICompositeType.
879 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
880 // Get core information.
881 StringRef Name = CTy.getName();
883 uint64_t Size = CTy.getSizeInBits() >> 3;
884 unsigned Tag = CTy.getTag();
888 case dwarf::DW_TAG_vector_type:
889 case dwarf::DW_TAG_array_type:
890 constructArrayTypeDIE(Buffer, &CTy);
892 case dwarf::DW_TAG_enumeration_type: {
893 DIArray Elements = CTy.getTypeArray();
895 // Add enumerators to enumeration type.
896 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
898 DIEnumerator Enum(Elements.getElement(i).getNode());
899 if (!Enum.isNull()) {
900 ElemDie = constructEnumTypeDIE(&Enum);
901 Buffer.addChild(ElemDie);
906 case dwarf::DW_TAG_subroutine_type: {
908 DIArray Elements = CTy.getTypeArray();
909 DIDescriptor RTy = Elements.getElement(0);
910 addType(&Buffer, DIType(RTy.getNode()));
912 // Add prototype flag.
913 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
916 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
917 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
918 DIDescriptor Ty = Elements.getElement(i);
919 addType(Arg, DIType(Ty.getNode()));
920 Buffer.addChild(Arg);
924 case dwarf::DW_TAG_structure_type:
925 case dwarf::DW_TAG_union_type:
926 case dwarf::DW_TAG_class_type: {
927 // Add elements to structure type.
928 DIArray Elements = CTy.getTypeArray();
930 // A forward struct declared type may not have elements available.
931 if (Elements.isNull())
934 // Add elements to structure type.
935 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
936 DIDescriptor Element = Elements.getElement(i);
937 if (Element.isNull())
940 if (Element.getTag() == dwarf::DW_TAG_subprogram)
941 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
943 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
944 Buffer.addChild(ElemDie);
947 if (CTy.isAppleBlockExtension())
948 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
950 unsigned RLang = CTy.getRunTimeLang();
952 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
953 dwarf::DW_FORM_data1, RLang);
955 DICompositeType ContainingType = CTy.getContainingType();
956 if (!ContainingType.isNull())
957 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
958 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
965 // Add name if not anonymous or intermediate type.
967 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
969 if (Tag == dwarf::DW_TAG_enumeration_type ||
970 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
971 // Add size if non-zero (derived types might be zero-sized.)
973 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
975 // Add zero size if it is not a forward declaration.
976 if (CTy.isForwardDecl())
977 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
979 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
982 // Add source line info if available.
983 if (!CTy.isForwardDecl())
984 addSourceLine(&Buffer, &CTy);
988 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
989 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
990 int64_t L = SR.getLo();
991 int64_t H = SR.getHi();
992 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
994 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
996 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
997 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
999 Buffer.addChild(DW_Subrange);
1002 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1003 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1004 DICompositeType *CTy) {
1005 Buffer.setTag(dwarf::DW_TAG_array_type);
1006 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1007 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1009 // Emit derived type.
1010 addType(&Buffer, CTy->getTypeDerivedFrom());
1011 DIArray Elements = CTy->getTypeArray();
1013 // Get an anonymous type for index type.
1014 DIE *IdxTy = ModuleCU->getIndexTyDie();
1016 // Construct an anonymous type for index type.
1017 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1018 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1019 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1020 dwarf::DW_ATE_signed);
1021 ModuleCU->addDie(IdxTy);
1022 ModuleCU->setIndexTyDie(IdxTy);
1025 // Add subranges to array type.
1026 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1027 DIDescriptor Element = Elements.getElement(i);
1028 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1029 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1033 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1034 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator *ETy) {
1035 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1036 StringRef Name = ETy->getName();
1037 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1038 int64_t Value = ETy->getEnumValue();
1039 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1043 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1044 /// printer to not emit usual symbol prefix before the symbol name is used then
1045 /// return linkage name after skipping this special LLVM prefix.
1046 static StringRef getRealLinkageName(StringRef LinkageName) {
1048 if (LinkageName.startswith(StringRef(&One, 1)))
1049 return LinkageName.substr(1);
1053 /// createGlobalVariableDIE - Create new DIE using GV.
1054 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1055 // If the global variable was optmized out then no need to create debug info
1057 if (!GV.getGlobal()) return NULL;
1058 if (GV.getDisplayName().empty()) return NULL;
1060 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1061 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1062 GV.getDisplayName());
1064 StringRef LinkageName = GV.getLinkageName();
1065 if (!LinkageName.empty())
1066 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1067 getRealLinkageName(LinkageName));
1069 addType(GVDie, GV.getType());
1070 if (!GV.isLocalToUnit())
1071 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1072 addSourceLine(GVDie, &GV);
1077 /// createMemberDIE - Create new member DIE.
1078 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1079 DIE *MemberDie = new DIE(DT.getTag());
1080 StringRef Name = DT.getName();
1082 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1084 addType(MemberDie, DT.getTypeDerivedFrom());
1086 addSourceLine(MemberDie, &DT);
1088 DIEBlock *MemLocationDie = new DIEBlock();
1089 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1091 uint64_t Size = DT.getSizeInBits();
1092 uint64_t FieldSize = DT.getOriginalTypeSize();
1094 if (Size != FieldSize) {
1096 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1097 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1099 uint64_t Offset = DT.getOffsetInBits();
1100 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1101 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1102 uint64_t FieldOffset = (HiMark - FieldSize);
1103 Offset -= FieldOffset;
1105 // Maybe we need to work from the other end.
1106 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1107 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1109 // Here WD_AT_data_member_location points to the anonymous
1110 // field that includes this bit field.
1111 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1114 // This is not a bitfield.
1115 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1117 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1119 if (DT.isProtected())
1120 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1121 dwarf::DW_ACCESS_protected);
1122 else if (DT.isPrivate())
1123 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1124 dwarf::DW_ACCESS_private);
1125 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1126 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1127 dwarf::DW_ACCESS_public);
1129 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1130 dwarf::DW_VIRTUALITY_virtual);
1134 /// createSubprogramDIE - Create new DIE using SP.
1135 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1136 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1140 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1141 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1143 StringRef LinkageName = SP.getLinkageName();
1144 if (!LinkageName.empty())
1145 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1146 getRealLinkageName(LinkageName));
1148 addSourceLine(SPDie, &SP);
1150 // Add prototyped tag, if C or ObjC.
1151 unsigned Lang = SP.getCompileUnit().getLanguage();
1152 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1153 Lang == dwarf::DW_LANG_ObjC)
1154 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1157 DICompositeType SPTy = SP.getType();
1158 DIArray Args = SPTy.getTypeArray();
1159 unsigned SPTag = SPTy.getTag();
1161 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1162 addType(SPDie, SPTy);
1164 addType(SPDie, DIType(Args.getElement(0).getNode()));
1166 unsigned VK = SP.getVirtuality();
1168 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1169 DIEBlock *Block = new DIEBlock();
1170 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1171 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1172 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1173 ContainingTypeMap.insert(std::make_pair(SPDie,
1174 SP.getContainingType().getNode()));
1177 if (MakeDecl || !SP.isDefinition()) {
1178 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1180 // Add arguments. Do not add arguments for subprogram definition. They will
1181 // be handled while processing variables.
1182 DICompositeType SPTy = SP.getType();
1183 DIArray Args = SPTy.getTypeArray();
1184 unsigned SPTag = SPTy.getTag();
1186 if (SPTag == dwarf::DW_TAG_subroutine_type)
1187 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1188 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1189 addType(Arg, DIType(Args.getElement(i).getNode()));
1190 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1191 SPDie->addChild(Arg);
1195 // DW_TAG_inlined_subroutine may refer to this DIE.
1196 ModuleCU->insertDIE(SP.getNode(), SPDie);
1200 /// findCompileUnit - Get the compile unit for the given descriptor.
1202 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1203 DenseMap<Value *, CompileUnit *>::const_iterator I =
1204 CompileUnitMap.find(Unit.getNode());
1205 if (I == CompileUnitMap.end())
1206 return constructCompileUnit(Unit.getNode());
1210 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1211 /// Initialize scope and update scope hierarchy.
1212 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1213 MDNode *InlinedAt) {
1214 assert (N && "Invalid Scope encoding!");
1215 assert (MI && "Missing machine instruction!");
1216 bool GetConcreteScope = (MI && InlinedAt);
1218 DbgScope *NScope = NULL;
1221 NScope = DbgScopeMap.lookup(InlinedAt);
1223 NScope = DbgScopeMap.lookup(N);
1224 assert (NScope && "Unable to find working scope!");
1226 if (NScope->getFirstInsn())
1229 DbgScope *Parent = NULL;
1230 if (GetConcreteScope) {
1231 DILocation IL(InlinedAt);
1232 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1233 IL.getOrigLocation().getNode());
1234 assert (Parent && "Unable to find Parent scope!");
1235 NScope->setParent(Parent);
1236 Parent->addScope(NScope);
1237 } else if (DIDescriptor(N).isLexicalBlock()) {
1238 DILexicalBlock DB(N);
1239 if (!DB.getContext().isNull()) {
1240 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1241 NScope->setParent(Parent);
1242 Parent->addScope(NScope);
1246 NScope->setFirstInsn(MI);
1248 if (!Parent && !InlinedAt) {
1249 StringRef SPName = DISubprogram(N).getLinkageName();
1250 if (SPName == MF->getFunction()->getName())
1251 CurrentFnDbgScope = NScope;
1254 if (GetConcreteScope) {
1255 ConcreteScopes[InlinedAt] = NScope;
1256 getOrCreateAbstractScope(N);
1262 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1263 assert (N && "Invalid Scope encoding!");
1265 DbgScope *AScope = AbstractScopes.lookup(N);
1269 DbgScope *Parent = NULL;
1271 DIDescriptor Scope(N);
1272 if (Scope.isLexicalBlock()) {
1273 DILexicalBlock DB(N);
1274 DIDescriptor ParentDesc = DB.getContext();
1275 if (!ParentDesc.isNull())
1276 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1279 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1282 Parent->addScope(AScope);
1283 AScope->setAbstractScope();
1284 AbstractScopes[N] = AScope;
1285 if (DIDescriptor(N).isSubprogram())
1286 AbstractScopesList.push_back(AScope);
1290 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1291 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1292 /// If there are global variables in this scope then create and insert
1293 /// DIEs for these variables.
1294 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1296 DIE *SPDie = ModuleCU->getDIE(SPNode);
1297 assert (SPDie && "Unable to find subprogram DIE!");
1298 DISubprogram SP(SPNode);
1299 if (SP.isDefinition() && !SP.getContext().isCompileUnit()) {
1300 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1302 DICompositeType SPTy = SP.getType();
1303 DIArray Args = SPTy.getTypeArray();
1304 unsigned SPTag = SPTy.getTag();
1305 if (SPTag == dwarf::DW_TAG_subroutine_type)
1306 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1307 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1308 addType(Arg, DIType(Args.getElement(i).getNode()));
1309 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1310 SPDie->addChild(Arg);
1312 DIE *SPDeclDie = SPDie;
1313 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1314 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1316 ModuleCU->addDie(SPDie);
1319 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1320 DWLabel("func_begin", SubprogramCount));
1321 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1322 DWLabel("func_end", SubprogramCount));
1323 MachineLocation Location(RI->getFrameRegister(*MF));
1324 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1326 if (!DISubprogram(SPNode).isLocalToUnit())
1327 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1332 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1333 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1334 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1335 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1336 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1338 // Ignore empty scopes.
1339 if (StartID == EndID && StartID != 0)
1342 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1343 if (Scope->isAbstractScope())
1346 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1348 DWLabel("label", StartID)
1349 : DWLabel("func_begin", SubprogramCount));
1350 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1352 DWLabel("label", EndID)
1353 : DWLabel("func_end", SubprogramCount));
1360 /// constructInlinedScopeDIE - This scope represents inlined body of
1361 /// a function. Construct DIE to represent this concrete inlined copy
1362 /// of the function.
1363 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1364 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1365 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1366 assert (StartID && "Invalid starting label for an inlined scope!");
1367 assert (EndID && "Invalid end label for an inlined scope!");
1368 // Ignore empty scopes.
1369 if (StartID == EndID && StartID != 0)
1372 DIScope DS(Scope->getScopeNode());
1375 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1377 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1378 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1379 assert (OriginDIE && "Unable to find Origin DIE!");
1380 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1381 dwarf::DW_FORM_ref4, OriginDIE);
1383 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1384 DWLabel("label", StartID));
1385 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1386 DWLabel("label", EndID));
1388 InlinedSubprogramDIEs.insert(OriginDIE);
1390 // Track the start label for this inlined function.
1391 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1392 I = InlineInfo.find(InlinedSP.getNode());
1394 if (I == InlineInfo.end()) {
1395 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1397 InlinedSPNodes.push_back(InlinedSP.getNode());
1399 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1401 StringPool.insert(InlinedSP.getName());
1402 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1404 DILocation DL(Scope->getInlinedAt());
1405 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1406 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1412 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1413 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1414 // Get the descriptor.
1415 const DIVariable &VD = DV->getVariable();
1416 StringRef Name = VD.getName();
1420 // Translate tag to proper Dwarf tag. The result variable is dropped for
1423 switch (VD.getTag()) {
1424 case dwarf::DW_TAG_return_variable:
1426 case dwarf::DW_TAG_arg_variable:
1427 Tag = dwarf::DW_TAG_formal_parameter;
1429 case dwarf::DW_TAG_auto_variable: // fall thru
1431 Tag = dwarf::DW_TAG_variable;
1435 // Define variable debug information entry.
1436 DIE *VariableDie = new DIE(Tag);
1440 if (DbgVariable *AV = DV->getAbstractVariable())
1441 AbsDIE = AV->getDIE();
1444 DIScope DS(Scope->getScopeNode());
1445 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1446 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1448 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1449 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1450 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1451 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1452 dwarf::DW_FORM_ref4, AbsDIE);
1455 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1456 addSourceLine(VariableDie, &VD);
1458 // Add variable type.
1459 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1460 // addresses instead.
1461 if (VD.isBlockByrefVariable())
1462 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1464 addType(VariableDie, VD.getType());
1467 // Add variable address.
1468 if (!Scope->isAbstractScope()) {
1469 MachineLocation Location;
1471 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1472 Location.set(FrameReg, Offset);
1474 if (VD.hasComplexAddress())
1475 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1476 else if (VD.isBlockByrefVariable())
1477 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1479 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1481 DV->setDIE(VariableDie);
1486 void DwarfDebug::addPubTypes(DISubprogram SP) {
1487 DICompositeType SPTy = SP.getType();
1488 unsigned SPTag = SPTy.getTag();
1489 if (SPTag != dwarf::DW_TAG_subroutine_type)
1492 DIArray Args = SPTy.getTypeArray();
1496 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1497 DIType ATy(Args.getElement(i).getNode());
1500 DICompositeType CATy = getDICompositeType(ATy);
1501 if (!CATy.isNull() && !CATy.getName().empty()) {
1502 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1503 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1508 /// constructScopeDIE - Construct a DIE for this scope.
1509 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1512 DIScope DS(Scope->getScopeNode());
1516 DIE *ScopeDIE = NULL;
1517 if (Scope->getInlinedAt())
1518 ScopeDIE = constructInlinedScopeDIE(Scope);
1519 else if (DS.isSubprogram()) {
1520 if (Scope->isAbstractScope())
1521 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1523 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1526 ScopeDIE = constructLexicalScopeDIE(Scope);
1527 if (!ScopeDIE) return NULL;
1530 // Add variables to scope.
1531 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1532 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1533 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1535 ScopeDIE->addChild(VariableDIE);
1538 // Add nested scopes.
1539 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1540 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1541 // Define the Scope debug information entry.
1542 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1544 ScopeDIE->addChild(NestedDIE);
1547 if (DS.isSubprogram())
1548 addPubTypes(DISubprogram(DS.getNode()));
1553 /// GetOrCreateSourceID - Look up the source id with the given directory and
1554 /// source file names. If none currently exists, create a new id and insert it
1555 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1557 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1559 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1560 if (DI != DirectoryIdMap.end()) {
1561 DId = DI->getValue();
1563 DId = DirectoryNames.size() + 1;
1564 DirectoryIdMap[DirName] = DId;
1565 DirectoryNames.push_back(DirName);
1569 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1570 if (FI != SourceFileIdMap.end()) {
1571 FId = FI->getValue();
1573 FId = SourceFileNames.size() + 1;
1574 SourceFileIdMap[FileName] = FId;
1575 SourceFileNames.push_back(FileName);
1578 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1579 SourceIdMap.find(std::make_pair(DId, FId));
1580 if (SI != SourceIdMap.end())
1583 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1584 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1585 SourceIds.push_back(std::make_pair(DId, FId));
1590 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1591 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1592 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1595 NDie = new DIE(dwarf::DW_TAG_namespace);
1596 ModuleCU->insertDIE(NS.getNode(), NDie);
1597 if (!NS.getName().empty())
1598 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1599 addSourceLine(NDie, &NS);
1600 addToContextOwner(NDie, NS.getContext());
1604 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1605 DICompileUnit DIUnit(N);
1606 StringRef FN = DIUnit.getFilename();
1607 StringRef Dir = DIUnit.getDirectory();
1608 unsigned ID = GetOrCreateSourceID(Dir, FN);
1610 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1611 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1612 DWLabel("section_line", 0), DWLabel("section_line", 0),
1614 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1615 DIUnit.getProducer());
1616 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1617 DIUnit.getLanguage());
1618 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1621 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1622 if (DIUnit.isOptimized())
1623 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1625 StringRef Flags = DIUnit.getFlags();
1627 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1629 unsigned RVer = DIUnit.getRunTimeVersion();
1631 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1632 dwarf::DW_FORM_data1, RVer);
1634 CompileUnit *Unit = new CompileUnit(ID, Die);
1635 if (!ModuleCU && DIUnit.isMain()) {
1636 // Use first compile unit marked as isMain as the compile unit
1641 CompileUnitMap[DIUnit.getNode()] = Unit;
1642 CompileUnits.push_back(Unit);
1646 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1647 DIGlobalVariable DI_GV(N);
1649 // If debug information is malformed then ignore it.
1650 if (DI_GV.Verify() == false)
1653 // Check for pre-existence.
1654 if (ModuleCU->getDIE(DI_GV.getNode()))
1657 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1662 ModuleCU->insertDIE(N, VariableDie);
1664 // Add to context owner.
1665 DIDescriptor GVContext = DI_GV.getContext();
1666 // Do not create specification DIE if context is either compile unit
1668 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1669 && !GVContext.isSubprogram()) {
1670 // Create specification DIE.
1671 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1672 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1673 dwarf::DW_FORM_ref4, VariableDie);
1674 DIEBlock *Block = new DIEBlock();
1675 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1676 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1677 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1678 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1679 ModuleCU->addDie(VariableSpecDIE);
1681 DIEBlock *Block = new DIEBlock();
1682 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1683 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1684 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1685 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1687 addToContextOwner(VariableDie, GVContext);
1689 // Expose as global. FIXME - need to check external flag.
1690 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1692 DIType GTy = DI_GV.getType();
1693 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1694 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1695 assert (Entry && "Missing global type!");
1696 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1701 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1704 // Check for pre-existence.
1705 if (ModuleCU->getDIE(N))
1708 if (!SP.isDefinition())
1709 // This is a method declaration which will be handled while constructing
1713 DIE *SubprogramDie = createSubprogramDIE(SP);
1716 ModuleCU->insertDIE(N, SubprogramDie);
1718 // Add to context owner.
1719 addToContextOwner(SubprogramDie, SP.getContext());
1721 // Expose as global.
1722 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1727 /// beginModule - Emit all Dwarf sections that should come prior to the
1728 /// content. Create global DIEs and emit initial debug info sections.
1729 /// This is inovked by the target AsmPrinter.
1730 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1733 if (TimePassesIsEnabled)
1734 DebugTimer->startTimer();
1736 if (!MAI->doesSupportDebugInformation())
1739 DebugInfoFinder DbgFinder;
1740 DbgFinder.processModule(*M);
1742 // Create all the compile unit DIEs.
1743 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1744 E = DbgFinder.compile_unit_end(); I != E; ++I)
1745 constructCompileUnit(*I);
1747 if (CompileUnits.empty()) {
1748 if (TimePassesIsEnabled)
1749 DebugTimer->stopTimer();
1754 // If main compile unit for this module is not seen than randomly
1755 // select first compile unit.
1757 ModuleCU = CompileUnits[0];
1759 // Create DIEs for each subprogram.
1760 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1761 E = DbgFinder.subprogram_end(); I != E; ++I)
1762 constructSubprogramDIE(*I);
1764 // Create DIEs for each global variable.
1765 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1766 E = DbgFinder.global_variable_end(); I != E; ++I)
1767 constructGlobalVariableDIE(*I);
1771 MMI->setDebugInfoAvailability(true);
1773 // Prime section data.
1774 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1776 // Print out .file directives to specify files for .loc directives. These are
1777 // printed out early so that they precede any .loc directives.
1778 if (MAI->hasDotLocAndDotFile()) {
1779 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1780 // Remember source id starts at 1.
1781 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1782 // FIXME: don't use sys::path for this! This should not depend on the
1784 sys::Path FullPath(getSourceDirectoryName(Id.first));
1786 FullPath.appendComponent(getSourceFileName(Id.second));
1787 assert(AppendOk && "Could not append filename to directory!");
1789 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1793 // Emit initial sections
1796 if (TimePassesIsEnabled)
1797 DebugTimer->stopTimer();
1800 /// endModule - Emit all Dwarf sections that should come after the content.
1802 void DwarfDebug::endModule() {
1806 if (TimePassesIsEnabled)
1807 DebugTimer->startTimer();
1809 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1810 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1811 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1813 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1816 // Insert top level DIEs.
1817 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1818 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1819 ModuleCU->getCUDie()->addChild(*TI);
1821 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1822 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1823 DIE *SPDie = CI->first;
1824 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1826 DIE *NDie = ModuleCU->getDIE(N);
1827 if (!NDie) continue;
1828 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1829 // FIXME - This is not the correct approach.
1830 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1833 // Standard sections final addresses.
1834 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1835 EmitLabel("text_end", 0);
1836 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1837 EmitLabel("data_end", 0);
1839 // End text sections.
1840 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1841 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1842 EmitLabel("section_end", i);
1845 // Emit common frame information.
1846 emitCommonDebugFrame();
1848 // Emit function debug frame information
1849 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1850 E = DebugFrames.end(); I != E; ++I)
1851 emitFunctionDebugFrame(*I);
1853 // Compute DIE offsets and sizes.
1854 computeSizeAndOffsets();
1856 // Emit all the DIEs into a debug info section
1859 // Corresponding abbreviations into a abbrev section.
1860 emitAbbreviations();
1862 // Emit source line correspondence into a debug line section.
1865 // Emit info into a debug pubnames section.
1866 emitDebugPubNames();
1868 // Emit info into a debug pubtypes section.
1869 emitDebugPubTypes();
1871 // Emit info into a debug str section.
1874 // Emit info into a debug loc section.
1877 // Emit info into a debug aranges section.
1880 // Emit info into a debug ranges section.
1883 // Emit info into a debug macinfo section.
1886 // Emit inline info.
1887 emitDebugInlineInfo();
1889 if (TimePassesIsEnabled)
1890 DebugTimer->stopTimer();
1893 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1894 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1896 DILocation &ScopeLoc) {
1898 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1900 return AbsDbgVariable;
1902 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1906 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1907 Scope->addVariable(AbsDbgVariable);
1908 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1909 return AbsDbgVariable;
1912 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1913 void DwarfDebug::collectVariableInfo() {
1916 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1917 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1918 VE = VMap.end(); VI != VE; ++VI) {
1919 MDNode *Var = VI->first;
1921 DIVariable DV (Var);
1922 std::pair< unsigned, MDNode *> VP = VI->second;
1923 DILocation ScopeLoc(VP.second);
1926 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1928 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1929 // If variable scope is not found then skip this variable.
1933 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1934 Scope->addVariable(RegVar);
1935 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1937 RegVar->setAbstractVariable(AbsDbgVariable);
1941 /// beginScope - Process beginning of a scope starting at Label.
1942 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1943 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1944 if (I == DbgScopeBeginMap.end())
1946 ScopeVector &SD = I->second;
1947 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1949 (*SDI)->setStartLabelID(Label);
1952 /// endScope - Process end of a scope.
1953 void DwarfDebug::endScope(const MachineInstr *MI) {
1954 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1955 if (I == DbgScopeEndMap.end())
1958 unsigned Label = MMI->NextLabelID();
1959 Asm->printLabel(Label);
1962 SmallVector<DbgScope *, 2> &SD = I->second;
1963 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1965 (*SDI)->setEndLabelID(Label);
1969 /// createDbgScope - Create DbgScope for the scope.
1970 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1973 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1976 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1977 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1978 if (DIDescriptor(Scope).isLexicalBlock())
1979 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1983 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1987 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1988 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1989 DILocation DL(InlinedAt);
1990 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1993 /// extractScopeInformation - Scan machine instructions in this function
1994 /// and collect DbgScopes. Return true, if atleast one scope was found.
1995 bool DwarfDebug::extractScopeInformation() {
1996 // If scope information was extracted using .dbg intrinsics then there is not
1997 // any need to extract these information by scanning each instruction.
1998 if (!DbgScopeMap.empty())
2001 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2002 unsigned MIIndex = 0;
2003 // Scan each instruction and create scopes. First build working set of scopes.
2004 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2006 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2008 const MachineInstr *MInsn = II;
2009 MIIndexMap[MInsn] = MIIndex++;
2010 DebugLoc DL = MInsn->getDebugLoc();
2011 if (DL.isUnknown()) continue;
2012 DILocation DLT = MF->getDILocation(DL);
2013 DIScope DLTScope = DLT.getScope();
2014 if (DLTScope.isNull()) continue;
2015 // There is no need to create another DIE for compile unit. For all
2016 // other scopes, create one DbgScope now. This will be translated
2017 // into a scope DIE at the end.
2018 if (DLTScope.isCompileUnit()) continue;
2019 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2024 // Build scope hierarchy using working set of scopes.
2025 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2027 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2029 const MachineInstr *MInsn = II;
2030 DebugLoc DL = MInsn->getDebugLoc();
2031 if (DL.isUnknown()) continue;
2032 DILocation DLT = MF->getDILocation(DL);
2033 DIScope DLTScope = DLT.getScope();
2034 if (DLTScope.isNull()) continue;
2035 // There is no need to create another DIE for compile unit. For all
2036 // other scopes, create one DbgScope now. This will be translated
2037 // into a scope DIE at the end.
2038 if (DLTScope.isCompileUnit()) continue;
2039 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2040 DLT.getOrigLocation().getNode());
2041 Scope->setLastInsn(MInsn);
2045 if (!CurrentFnDbgScope)
2048 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2050 // Each scope has first instruction and last instruction to mark beginning
2051 // and end of a scope respectively. Create an inverse map that list scopes
2052 // starts (and ends) with an instruction. One instruction may start (or end)
2053 // multiple scopes. Ignore scopes that are not reachable.
2054 SmallVector<DbgScope *, 4> WorkList;
2055 WorkList.push_back(CurrentFnDbgScope);
2056 while (!WorkList.empty()) {
2057 DbgScope *S = WorkList.back(); WorkList.pop_back();
2059 SmallVector<DbgScope *, 4> &Children = S->getScopes();
2060 if (!Children.empty())
2061 for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2062 SE = Children.end(); SI != SE; ++SI)
2063 WorkList.push_back(*SI);
2065 if (S->isAbstractScope())
2067 const MachineInstr *MI = S->getFirstInsn();
2068 assert (MI && "DbgScope does not have first instruction!");
2070 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2071 if (IDI != DbgScopeBeginMap.end())
2072 IDI->second.push_back(S);
2074 DbgScopeBeginMap[MI].push_back(S);
2076 MI = S->getLastInsn();
2077 assert (MI && "DbgScope does not have last instruction!");
2078 IDI = DbgScopeEndMap.find(MI);
2079 if (IDI != DbgScopeEndMap.end())
2080 IDI->second.push_back(S);
2082 DbgScopeEndMap[MI].push_back(S);
2085 return !DbgScopeMap.empty();
2088 /// beginFunction - Gather pre-function debug information. Assumes being
2089 /// emitted immediately after the function entry point.
2090 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2093 if (!ShouldEmitDwarfDebug()) return;
2095 if (TimePassesIsEnabled)
2096 DebugTimer->startTimer();
2098 if (!extractScopeInformation())
2101 collectVariableInfo();
2103 // Begin accumulating function debug information.
2104 MMI->BeginFunction((MachineFunction*)MF);
2106 // Assumes in correct section after the entry point.
2107 EmitLabel("func_begin", ++SubprogramCount);
2109 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2111 DebugLoc FDL = MF->getDefaultDebugLoc();
2112 if (!FDL.isUnknown()) {
2113 DILocation DLT = MF->getDILocation(FDL);
2114 unsigned LabelID = 0;
2115 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2117 LabelID = recordSourceLine(SP.getLineNumber(), 0,
2118 DLT.getScope().getNode());
2120 LabelID = recordSourceLine(DLT.getLineNumber(),
2121 DLT.getColumnNumber(),
2122 DLT.getScope().getNode());
2123 Asm->printLabel(LabelID);
2126 if (TimePassesIsEnabled)
2127 DebugTimer->stopTimer();
2130 /// endFunction - Gather and emit post-function debug information.
2132 void DwarfDebug::endFunction(const MachineFunction *MF) {
2133 if (!ShouldEmitDwarfDebug()) return;
2135 if (TimePassesIsEnabled)
2136 DebugTimer->startTimer();
2138 if (DbgScopeMap.empty())
2141 if (CurrentFnDbgScope) {
2142 // Define end label for subprogram.
2143 EmitLabel("func_end", SubprogramCount);
2145 // Get function line info.
2146 if (!Lines.empty()) {
2147 // Get section line info.
2148 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2149 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2150 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2151 // Append the function info to section info.
2152 SectionLineInfos.insert(SectionLineInfos.end(),
2153 Lines.begin(), Lines.end());
2156 // Construct abstract scopes.
2157 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2158 AE = AbstractScopesList.end(); AI != AE; ++AI)
2159 constructScopeDIE(*AI);
2161 constructScopeDIE(CurrentFnDbgScope);
2163 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2164 MMI->getFrameMoves()));
2168 CurrentFnDbgScope = NULL;
2169 DbgScopeMap.clear();
2170 DbgScopeBeginMap.clear();
2171 DbgScopeEndMap.clear();
2172 ConcreteScopes.clear();
2173 AbstractScopesList.clear();
2176 if (TimePassesIsEnabled)
2177 DebugTimer->stopTimer();
2180 /// recordSourceLine - Records location information and associates it with a
2181 /// label. Returns a unique label ID used to generate a label and provide
2182 /// correspondence to the source line list.
2183 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2188 if (TimePassesIsEnabled)
2189 DebugTimer->startTimer();
2194 DIDescriptor Scope(S);
2195 if (Scope.isCompileUnit()) {
2196 DICompileUnit CU(S);
2197 Dir = CU.getDirectory();
2198 Fn = CU.getFilename();
2199 } else if (Scope.isSubprogram()) {
2201 Dir = SP.getDirectory();
2202 Fn = SP.getFilename();
2203 } else if (Scope.isLexicalBlock()) {
2204 DILexicalBlock DB(S);
2205 Dir = DB.getDirectory();
2206 Fn = DB.getFilename();
2208 assert (0 && "Unexpected scope info");
2210 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2211 unsigned ID = MMI->NextLabelID();
2212 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2214 if (TimePassesIsEnabled)
2215 DebugTimer->stopTimer();
2220 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2221 /// timed. Look up the source id with the given directory and source file
2222 /// names. If none currently exists, create a new id and insert it in the
2223 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2225 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2226 const std::string &FileName) {
2227 if (TimePassesIsEnabled)
2228 DebugTimer->startTimer();
2230 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2232 if (TimePassesIsEnabled)
2233 DebugTimer->stopTimer();
2238 //===----------------------------------------------------------------------===//
2240 //===----------------------------------------------------------------------===//
2242 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2245 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2246 // Get the children.
2247 const std::vector<DIE *> &Children = Die->getChildren();
2249 // If not last sibling and has children then add sibling offset attribute.
2250 if (!Last && !Children.empty()) Die->addSiblingOffset();
2252 // Record the abbreviation.
2253 assignAbbrevNumber(Die->getAbbrev());
2255 // Get the abbreviation for this DIE.
2256 unsigned AbbrevNumber = Die->getAbbrevNumber();
2257 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2260 Die->setOffset(Offset);
2262 // Start the size with the size of abbreviation code.
2263 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2265 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2266 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2268 // Size the DIE attribute values.
2269 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2270 // Size attribute value.
2271 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2273 // Size the DIE children if any.
2274 if (!Children.empty()) {
2275 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2276 "Children flag not set");
2278 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2279 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2281 // End of children marker.
2282 Offset += sizeof(int8_t);
2285 Die->setSize(Offset - Die->getOffset());
2289 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2291 void DwarfDebug::computeSizeAndOffsets() {
2292 // Compute size of compile unit header.
2293 static unsigned Offset =
2294 sizeof(int32_t) + // Length of Compilation Unit Info
2295 sizeof(int16_t) + // DWARF version number
2296 sizeof(int32_t) + // Offset Into Abbrev. Section
2297 sizeof(int8_t); // Pointer Size (in bytes)
2299 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2300 CompileUnitOffsets[ModuleCU] = 0;
2303 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2304 /// tools to recognize the object file contains Dwarf information.
2305 void DwarfDebug::emitInitial() {
2306 // Check to see if we already emitted intial headers.
2307 if (didInitial) return;
2310 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2312 // Dwarf sections base addresses.
2313 if (MAI->doesDwarfRequireFrameSection()) {
2314 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2315 EmitLabel("section_debug_frame", 0);
2318 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2319 EmitLabel("section_info", 0);
2320 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2321 EmitLabel("section_abbrev", 0);
2322 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2323 EmitLabel("section_aranges", 0);
2325 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2326 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2327 EmitLabel("section_macinfo", 0);
2330 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2331 EmitLabel("section_line", 0);
2332 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2333 EmitLabel("section_loc", 0);
2334 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2335 EmitLabel("section_pubnames", 0);
2336 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2337 EmitLabel("section_pubtypes", 0);
2338 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2339 EmitLabel("section_str", 0);
2340 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2341 EmitLabel("section_ranges", 0);
2343 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2344 EmitLabel("text_begin", 0);
2345 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2346 EmitLabel("data_begin", 0);
2349 /// emitDIE - Recusively Emits a debug information entry.
2351 void DwarfDebug::emitDIE(DIE *Die) {
2352 // Get the abbreviation for this DIE.
2353 unsigned AbbrevNumber = Die->getAbbrevNumber();
2354 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2358 // Emit the code (index) for the abbreviation.
2359 if (Asm->VerboseAsm)
2360 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2361 Twine::utohexstr(Die->getOffset()) + ":0x" +
2362 Twine::utohexstr(Die->getSize()) + " " +
2363 dwarf::TagString(Abbrev->getTag()));
2364 EmitULEB128(AbbrevNumber);
2366 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2367 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2369 // Emit the DIE attribute values.
2370 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2371 unsigned Attr = AbbrevData[i].getAttribute();
2372 unsigned Form = AbbrevData[i].getForm();
2373 assert(Form && "Too many attributes for DIE (check abbreviation)");
2375 if (Asm->VerboseAsm)
2376 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2379 case dwarf::DW_AT_sibling:
2380 Asm->EmitInt32(Die->getSiblingOffset());
2382 case dwarf::DW_AT_abstract_origin: {
2383 DIEEntry *E = cast<DIEEntry>(Values[i]);
2384 DIE *Origin = E->getEntry();
2385 unsigned Addr = Origin->getOffset();
2386 Asm->EmitInt32(Addr);
2390 // Emit an attribute using the defined form.
2391 Values[i]->EmitValue(this, Form);
2392 O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2397 // Emit the DIE children if any.
2398 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2399 const std::vector<DIE *> &Children = Die->getChildren();
2401 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2402 emitDIE(Children[j]);
2404 Asm->EmitInt8(0); EOL("End Of Children Mark");
2408 /// emitDebugInfo - Emit the debug info section.
2410 void DwarfDebug::emitDebugInfo() {
2411 // Start debug info section.
2412 Asm->OutStreamer.SwitchSection(
2413 Asm->getObjFileLowering().getDwarfInfoSection());
2414 DIE *Die = ModuleCU->getCUDie();
2416 // Emit the compile units header.
2417 EmitLabel("info_begin", ModuleCU->getID());
2419 // Emit size of content not including length itself
2420 unsigned ContentSize = Die->getSize() +
2421 sizeof(int16_t) + // DWARF version number
2422 sizeof(int32_t) + // Offset Into Abbrev. Section
2423 sizeof(int8_t) + // Pointer Size (in bytes)
2424 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2426 Asm->EmitInt32(ContentSize); EOL("Length of Compilation Unit Info");
2427 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2428 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2429 EOL("Offset Into Abbrev. Section");
2430 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2433 // FIXME - extra padding for gdb bug.
2434 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2435 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2436 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2437 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2438 EmitLabel("info_end", ModuleCU->getID());
2442 /// emitAbbreviations - Emit the abbreviation section.
2444 void DwarfDebug::emitAbbreviations() const {
2445 // Check to see if it is worth the effort.
2446 if (!Abbreviations.empty()) {
2447 // Start the debug abbrev section.
2448 Asm->OutStreamer.SwitchSection(
2449 Asm->getObjFileLowering().getDwarfAbbrevSection());
2451 EmitLabel("abbrev_begin", 0);
2453 // For each abbrevation.
2454 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2455 // Get abbreviation data
2456 const DIEAbbrev *Abbrev = Abbreviations[i];
2458 // Emit the abbrevations code (base 1 index.)
2459 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2461 // Emit the abbreviations data.
2466 // Mark end of abbreviations.
2467 EmitULEB128(0, "EOM(3)");
2469 EmitLabel("abbrev_end", 0);
2474 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2475 /// the line matrix.
2477 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2478 // Define last address of section.
2479 Asm->EmitInt8(0); EOL("Extended Op");
2480 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2481 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2482 EmitReference("section_end", SectionEnd); EOL("Section end label");
2484 // Mark end of matrix.
2485 Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2490 /// emitDebugLines - Emit source line information.
2492 void DwarfDebug::emitDebugLines() {
2493 // If the target is using .loc/.file, the assembler will be emitting the
2494 // .debug_line table automatically.
2495 if (MAI->hasDotLocAndDotFile())
2498 // Minimum line delta, thus ranging from -10..(255-10).
2499 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2500 // Maximum line delta, thus ranging from -10..(255-10).
2501 const int MaxLineDelta = 255 + MinLineDelta;
2503 // Start the dwarf line section.
2504 Asm->OutStreamer.SwitchSection(
2505 Asm->getObjFileLowering().getDwarfLineSection());
2507 // Construct the section header.
2508 EmitDifference("line_end", 0, "line_begin", 0, true);
2509 EOL("Length of Source Line Info");
2510 EmitLabel("line_begin", 0);
2512 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2514 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2515 EOL("Prolog Length");
2516 EmitLabel("line_prolog_begin", 0);
2518 Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2519 Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2520 Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2521 Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2522 Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2524 // Line number standard opcode encodings argument count
2525 Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2526 Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2527 Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2528 Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2529 Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2530 Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2531 Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2532 Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2533 Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2535 // Emit directories.
2536 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2537 const std::string &Dir = getSourceDirectoryName(DI);
2538 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2539 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2542 Asm->EmitInt8(0); EOL("End of directories");
2545 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2546 // Remember source id starts at 1.
2547 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2548 const std::string &FN = getSourceFileName(Id.second);
2549 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2550 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2552 EmitULEB128(Id.first, "Directory #");
2553 EmitULEB128(0, "Mod date");
2554 EmitULEB128(0, "File size");
2557 Asm->EmitInt8(0); EOL("End of files");
2559 EmitLabel("line_prolog_end", 0);
2561 // A sequence for each text section.
2562 unsigned SecSrcLinesSize = SectionSourceLines.size();
2564 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2565 // Isolate current sections line info.
2566 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2568 /*if (Asm->isVerbose()) {
2569 const MCSection *S = SectionMap[j + 1];
2570 O << '\t' << MAI->getCommentString() << " Section"
2571 << S->getName() << '\n';
2575 // Dwarf assumes we start with first line of first source file.
2576 unsigned Source = 1;
2579 // Construct rows of the address, source, line, column matrix.
2580 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2581 const SrcLineInfo &LineInfo = LineInfos[i];
2582 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2583 if (!LabelID) continue;
2585 if (LineInfo.getLine() == 0) continue;
2587 if (!Asm->isVerbose())
2590 std::pair<unsigned, unsigned> SourceID =
2591 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2592 O << '\t' << MAI->getCommentString() << ' '
2593 << getSourceDirectoryName(SourceID.first) << '/'
2594 << getSourceFileName(SourceID.second)
2595 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2598 // Define the line address.
2599 Asm->EmitInt8(0); EOL("Extended Op");
2600 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2601 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2602 EmitReference("label", LabelID); EOL("Location label");
2604 // If change of source, then switch to the new source.
2605 if (Source != LineInfo.getSourceID()) {
2606 Source = LineInfo.getSourceID();
2607 Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2608 EmitULEB128(Source, "New Source");
2611 // If change of line.
2612 if (Line != LineInfo.getLine()) {
2613 // Determine offset.
2614 int Offset = LineInfo.getLine() - Line;
2615 int Delta = Offset - MinLineDelta;
2618 Line = LineInfo.getLine();
2620 // If delta is small enough and in range...
2621 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2622 // ... then use fast opcode.
2623 Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2625 // ... otherwise use long hand.
2626 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2627 EOL("DW_LNS_advance_line");
2628 EmitSLEB128(Offset, "Line Offset");
2629 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2632 // Copy the previous row (different address or source)
2633 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2637 emitEndOfLineMatrix(j + 1);
2640 if (SecSrcLinesSize == 0)
2641 // Because we're emitting a debug_line section, we still need a line
2642 // table. The linker and friends expect it to exist. If there's nothing to
2643 // put into it, emit an empty table.
2644 emitEndOfLineMatrix(1);
2646 EmitLabel("line_end", 0);
2650 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2652 void DwarfDebug::emitCommonDebugFrame() {
2653 if (!MAI->doesDwarfRequireFrameSection())
2657 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2658 TargetFrameInfo::StackGrowsUp ?
2659 TD->getPointerSize() : -TD->getPointerSize();
2661 // Start the dwarf frame section.
2662 Asm->OutStreamer.SwitchSection(
2663 Asm->getObjFileLowering().getDwarfFrameSection());
2665 EmitLabel("debug_frame_common", 0);
2666 EmitDifference("debug_frame_common_end", 0,
2667 "debug_frame_common_begin", 0, true);
2668 EOL("Length of Common Information Entry");
2670 EmitLabel("debug_frame_common_begin", 0);
2671 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2672 EOL("CIE Identifier Tag");
2673 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2675 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2676 EOL("CIE Augmentation");
2677 EmitULEB128(1, "CIE Code Alignment Factor");
2678 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2679 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2680 EOL("CIE RA Column");
2682 std::vector<MachineMove> Moves;
2683 RI->getInitialFrameState(Moves);
2685 EmitFrameMoves(NULL, 0, Moves, false);
2687 Asm->EmitAlignment(2, 0, 0, false);
2688 EmitLabel("debug_frame_common_end", 0);
2692 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2695 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2696 if (!MAI->doesDwarfRequireFrameSection())
2699 // Start the dwarf frame section.
2700 Asm->OutStreamer.SwitchSection(
2701 Asm->getObjFileLowering().getDwarfFrameSection());
2703 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2704 "debug_frame_begin", DebugFrameInfo.Number, true);
2705 EOL("Length of Frame Information Entry");
2707 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2709 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2711 EOL("FDE CIE offset");
2713 EmitReference("func_begin", DebugFrameInfo.Number);
2714 EOL("FDE initial location");
2715 EmitDifference("func_end", DebugFrameInfo.Number,
2716 "func_begin", DebugFrameInfo.Number);
2717 EOL("FDE address range");
2719 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2722 Asm->EmitAlignment(2, 0, 0, false);
2723 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2727 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2729 void DwarfDebug::emitDebugPubNames() {
2730 // Start the dwarf pubnames section.
2731 Asm->OutStreamer.SwitchSection(
2732 Asm->getObjFileLowering().getDwarfPubNamesSection());
2734 EmitDifference("pubnames_end", ModuleCU->getID(),
2735 "pubnames_begin", ModuleCU->getID(), true);
2736 EOL("Length of Public Names Info");
2738 EmitLabel("pubnames_begin", ModuleCU->getID());
2740 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2742 EmitSectionOffset("info_begin", "section_info",
2743 ModuleCU->getID(), 0, true, false);
2744 EOL("Offset of Compilation Unit Info");
2746 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2748 EOL("Compilation Unit Length");
2750 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2751 for (StringMap<DIE*>::const_iterator
2752 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2753 const char *Name = GI->getKeyData();
2754 DIE * Entity = GI->second;
2756 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2758 if (Asm->VerboseAsm)
2759 Asm->OutStreamer.AddComment("External Name");
2760 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2763 Asm->EmitInt32(0); EOL("End Mark");
2764 EmitLabel("pubnames_end", ModuleCU->getID());
2768 void DwarfDebug::emitDebugPubTypes() {
2769 // Start the dwarf pubnames section.
2770 Asm->OutStreamer.SwitchSection(
2771 Asm->getObjFileLowering().getDwarfPubTypesSection());
2772 EmitDifference("pubtypes_end", ModuleCU->getID(),
2773 "pubtypes_begin", ModuleCU->getID(), true);
2774 EOL("Length of Public Types Info");
2776 EmitLabel("pubtypes_begin", ModuleCU->getID());
2778 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2780 EmitSectionOffset("info_begin", "section_info",
2781 ModuleCU->getID(), 0, true, false);
2782 EOL("Offset of Compilation ModuleCU Info");
2784 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2786 EOL("Compilation ModuleCU Length");
2788 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2789 for (StringMap<DIE*>::const_iterator
2790 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2791 const char *Name = GI->getKeyData();
2792 DIE * Entity = GI->second;
2794 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2796 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2797 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)), 0);
2800 Asm->EmitInt32(0); EOL("End Mark");
2801 EmitLabel("pubtypes_end", ModuleCU->getID());
2805 /// emitDebugStr - Emit visible names into a debug str section.
2807 void DwarfDebug::emitDebugStr() {
2808 // Check to see if it is worth the effort.
2809 if (!StringPool.empty()) {
2810 // Start the dwarf str section.
2811 Asm->OutStreamer.SwitchSection(
2812 Asm->getObjFileLowering().getDwarfStrSection());
2814 // For each of strings in the string pool.
2815 for (unsigned StringID = 1, N = StringPool.size();
2816 StringID <= N; ++StringID) {
2817 // Emit a label for reference from debug information entries.
2818 EmitLabel("string", StringID);
2820 // Emit the string itself.
2821 const std::string &String = StringPool[StringID];
2822 Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2829 /// emitDebugLoc - Emit visible names into a debug loc section.
2831 void DwarfDebug::emitDebugLoc() {
2832 // Start the dwarf loc section.
2833 Asm->OutStreamer.SwitchSection(
2834 Asm->getObjFileLowering().getDwarfLocSection());
2837 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2839 void DwarfDebug::EmitDebugARanges() {
2840 // Start the dwarf aranges section.
2841 Asm->OutStreamer.SwitchSection(
2842 Asm->getObjFileLowering().getDwarfARangesSection());
2846 CompileUnit *Unit = GetBaseCompileUnit();
2848 // Don't include size of length
2849 Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2851 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2853 EmitReference("info_begin", Unit->getID());
2854 EOL("Offset of Compilation Unit Info");
2856 Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2858 Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2860 Asm->EmitInt16(0); EOL("Pad (1)");
2861 Asm->EmitInt16(0); EOL("Pad (2)");
2864 EmitReference("text_begin", 0); EOL("Address");
2865 EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
2867 Asm->EmitInt32(0); EOL("EOM (1)");
2868 Asm->EmitInt32(0); EOL("EOM (2)");
2872 /// emitDebugRanges - Emit visible names into a debug ranges section.
2874 void DwarfDebug::emitDebugRanges() {
2875 // Start the dwarf ranges section.
2876 Asm->OutStreamer.SwitchSection(
2877 Asm->getObjFileLowering().getDwarfRangesSection());
2880 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2882 void DwarfDebug::emitDebugMacInfo() {
2883 if (const MCSection *LineInfo =
2884 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2885 // Start the dwarf macinfo section.
2886 Asm->OutStreamer.SwitchSection(LineInfo);
2890 /// emitDebugInlineInfo - Emit inline info using following format.
2892 /// 1. length of section
2893 /// 2. Dwarf version number
2894 /// 3. address size.
2896 /// Entries (one "entry" for each function that was inlined):
2898 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2899 /// otherwise offset into __debug_str for regular function name.
2900 /// 2. offset into __debug_str section for regular function name.
2901 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2902 /// instances for the function.
2904 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2905 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2906 /// __debug_info section, and the low_pc is the starting address for the
2907 /// inlining instance.
2908 void DwarfDebug::emitDebugInlineInfo() {
2909 if (!MAI->doesDwarfUsesInlineInfoSection())
2915 Asm->OutStreamer.SwitchSection(
2916 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2918 EmitDifference("debug_inlined_end", 1,
2919 "debug_inlined_begin", 1, true);
2920 EOL("Length of Debug Inlined Information Entry");
2922 EmitLabel("debug_inlined_begin", 1);
2924 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2925 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2927 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2928 E = InlinedSPNodes.end(); I != E; ++I) {
2931 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2932 = InlineInfo.find(Node);
2933 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2934 DISubprogram SP(Node);
2935 StringRef LName = SP.getLinkageName();
2936 StringRef Name = SP.getName();
2938 if (LName.empty()) {
2939 Asm->OutStreamer.EmitBytes(Name, 0);
2940 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2942 EmitSectionOffset("string", "section_str",
2943 StringPool.idFor(getRealLinkageName(LName)), false, true);
2945 EOL("MIPS linkage name");
2946 EmitSectionOffset("string", "section_str",
2947 StringPool.idFor(Name), false, true);
2948 EOL("Function name");
2949 EmitULEB128(Labels.size(), "Inline count");
2951 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2952 LE = Labels.end(); LI != LE; ++LI) {
2953 DIE *SP = LI->second;
2954 Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
2956 if (TD->getPointerSize() == sizeof(int32_t))
2957 O << MAI->getData32bitsDirective();
2959 O << MAI->getData64bitsDirective();
2961 PrintLabelName("label", LI->first); EOL("low_pc");
2965 EmitLabel("debug_inlined_end", 1);