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 || Tag == dwarf::DW_TAG_class_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 // Assumes in correct section after the entry point.
2104 EmitLabel("func_begin", ++SubprogramCount);
2106 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2108 DebugLoc FDL = MF->getDefaultDebugLoc();
2109 if (!FDL.isUnknown()) {
2110 DILocation DLT = MF->getDILocation(FDL);
2111 unsigned LabelID = 0;
2112 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2114 LabelID = recordSourceLine(SP.getLineNumber(), 0,
2115 DLT.getScope().getNode());
2117 LabelID = recordSourceLine(DLT.getLineNumber(),
2118 DLT.getColumnNumber(),
2119 DLT.getScope().getNode());
2120 Asm->printLabel(LabelID);
2123 if (TimePassesIsEnabled)
2124 DebugTimer->stopTimer();
2127 /// endFunction - Gather and emit post-function debug information.
2129 void DwarfDebug::endFunction(const MachineFunction *MF) {
2130 if (!ShouldEmitDwarfDebug()) return;
2132 if (TimePassesIsEnabled)
2133 DebugTimer->startTimer();
2135 if (DbgScopeMap.empty())
2138 if (CurrentFnDbgScope) {
2139 // Define end label for subprogram.
2140 EmitLabel("func_end", SubprogramCount);
2142 // Get function line info.
2143 if (!Lines.empty()) {
2144 // Get section line info.
2145 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2146 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2147 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2148 // Append the function info to section info.
2149 SectionLineInfos.insert(SectionLineInfos.end(),
2150 Lines.begin(), Lines.end());
2153 // Construct abstract scopes.
2154 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2155 AE = AbstractScopesList.end(); AI != AE; ++AI)
2156 constructScopeDIE(*AI);
2158 constructScopeDIE(CurrentFnDbgScope);
2160 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2161 MMI->getFrameMoves()));
2165 CurrentFnDbgScope = NULL;
2166 DbgScopeMap.clear();
2167 DbgScopeBeginMap.clear();
2168 DbgScopeEndMap.clear();
2169 ConcreteScopes.clear();
2170 AbstractScopesList.clear();
2173 if (TimePassesIsEnabled)
2174 DebugTimer->stopTimer();
2177 /// recordSourceLine - Records location information and associates it with a
2178 /// label. Returns a unique label ID used to generate a label and provide
2179 /// correspondence to the source line list.
2180 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2185 if (TimePassesIsEnabled)
2186 DebugTimer->startTimer();
2191 DIDescriptor Scope(S);
2192 if (Scope.isCompileUnit()) {
2193 DICompileUnit CU(S);
2194 Dir = CU.getDirectory();
2195 Fn = CU.getFilename();
2196 } else if (Scope.isSubprogram()) {
2198 Dir = SP.getDirectory();
2199 Fn = SP.getFilename();
2200 } else if (Scope.isLexicalBlock()) {
2201 DILexicalBlock DB(S);
2202 Dir = DB.getDirectory();
2203 Fn = DB.getFilename();
2205 assert (0 && "Unexpected scope info");
2207 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2208 unsigned ID = MMI->NextLabelID();
2209 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2211 if (TimePassesIsEnabled)
2212 DebugTimer->stopTimer();
2217 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2218 /// timed. Look up the source id with the given directory and source file
2219 /// names. If none currently exists, create a new id and insert it in the
2220 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2222 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2223 const std::string &FileName) {
2224 if (TimePassesIsEnabled)
2225 DebugTimer->startTimer();
2227 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2229 if (TimePassesIsEnabled)
2230 DebugTimer->stopTimer();
2235 //===----------------------------------------------------------------------===//
2237 //===----------------------------------------------------------------------===//
2239 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2242 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2243 // Get the children.
2244 const std::vector<DIE *> &Children = Die->getChildren();
2246 // If not last sibling and has children then add sibling offset attribute.
2247 if (!Last && !Children.empty()) Die->addSiblingOffset();
2249 // Record the abbreviation.
2250 assignAbbrevNumber(Die->getAbbrev());
2252 // Get the abbreviation for this DIE.
2253 unsigned AbbrevNumber = Die->getAbbrevNumber();
2254 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2257 Die->setOffset(Offset);
2259 // Start the size with the size of abbreviation code.
2260 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2262 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2263 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2265 // Size the DIE attribute values.
2266 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2267 // Size attribute value.
2268 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2270 // Size the DIE children if any.
2271 if (!Children.empty()) {
2272 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2273 "Children flag not set");
2275 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2276 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2278 // End of children marker.
2279 Offset += sizeof(int8_t);
2282 Die->setSize(Offset - Die->getOffset());
2286 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2288 void DwarfDebug::computeSizeAndOffsets() {
2289 // Compute size of compile unit header.
2290 static unsigned Offset =
2291 sizeof(int32_t) + // Length of Compilation Unit Info
2292 sizeof(int16_t) + // DWARF version number
2293 sizeof(int32_t) + // Offset Into Abbrev. Section
2294 sizeof(int8_t); // Pointer Size (in bytes)
2296 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2297 CompileUnitOffsets[ModuleCU] = 0;
2300 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2301 /// tools to recognize the object file contains Dwarf information.
2302 void DwarfDebug::emitInitial() {
2303 // Check to see if we already emitted intial headers.
2304 if (didInitial) return;
2307 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2309 // Dwarf sections base addresses.
2310 if (MAI->doesDwarfRequireFrameSection()) {
2311 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2312 EmitLabel("section_debug_frame", 0);
2315 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2316 EmitLabel("section_info", 0);
2317 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2318 EmitLabel("section_abbrev", 0);
2319 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2320 EmitLabel("section_aranges", 0);
2322 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2323 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2324 EmitLabel("section_macinfo", 0);
2327 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2328 EmitLabel("section_line", 0);
2329 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2330 EmitLabel("section_loc", 0);
2331 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2332 EmitLabel("section_pubnames", 0);
2333 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2334 EmitLabel("section_pubtypes", 0);
2335 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2336 EmitLabel("section_str", 0);
2337 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2338 EmitLabel("section_ranges", 0);
2340 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2341 EmitLabel("text_begin", 0);
2342 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2343 EmitLabel("data_begin", 0);
2346 /// emitDIE - Recusively Emits a debug information entry.
2348 void DwarfDebug::emitDIE(DIE *Die) {
2349 // Get the abbreviation for this DIE.
2350 unsigned AbbrevNumber = Die->getAbbrevNumber();
2351 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2355 // Emit the code (index) for the abbreviation.
2356 if (Asm->VerboseAsm)
2357 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2358 Twine::utohexstr(Die->getOffset()) + ":0x" +
2359 Twine::utohexstr(Die->getSize()) + " " +
2360 dwarf::TagString(Abbrev->getTag()));
2361 EmitULEB128(AbbrevNumber);
2363 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2364 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2366 // Emit the DIE attribute values.
2367 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2368 unsigned Attr = AbbrevData[i].getAttribute();
2369 unsigned Form = AbbrevData[i].getForm();
2370 assert(Form && "Too many attributes for DIE (check abbreviation)");
2372 if (Asm->VerboseAsm)
2373 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2376 case dwarf::DW_AT_sibling:
2377 Asm->EmitInt32(Die->getSiblingOffset());
2379 case dwarf::DW_AT_abstract_origin: {
2380 DIEEntry *E = cast<DIEEntry>(Values[i]);
2381 DIE *Origin = E->getEntry();
2382 unsigned Addr = Origin->getOffset();
2383 Asm->EmitInt32(Addr);
2387 // Emit an attribute using the defined form.
2388 Values[i]->EmitValue(this, Form);
2389 O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2394 // Emit the DIE children if any.
2395 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2396 const std::vector<DIE *> &Children = Die->getChildren();
2398 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2399 emitDIE(Children[j]);
2401 Asm->EmitInt8(0); EOL("End Of Children Mark");
2405 /// emitDebugInfo - Emit the debug info section.
2407 void DwarfDebug::emitDebugInfo() {
2408 // Start debug info section.
2409 Asm->OutStreamer.SwitchSection(
2410 Asm->getObjFileLowering().getDwarfInfoSection());
2411 DIE *Die = ModuleCU->getCUDie();
2413 // Emit the compile units header.
2414 EmitLabel("info_begin", ModuleCU->getID());
2416 // Emit size of content not including length itself
2417 unsigned ContentSize = Die->getSize() +
2418 sizeof(int16_t) + // DWARF version number
2419 sizeof(int32_t) + // Offset Into Abbrev. Section
2420 sizeof(int8_t) + // Pointer Size (in bytes)
2421 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2423 Asm->EmitInt32(ContentSize); EOL("Length of Compilation Unit Info");
2424 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2425 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2426 EOL("Offset Into Abbrev. Section");
2427 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2430 // FIXME - extra padding for gdb bug.
2431 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2432 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2433 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2434 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2435 EmitLabel("info_end", ModuleCU->getID());
2439 /// emitAbbreviations - Emit the abbreviation section.
2441 void DwarfDebug::emitAbbreviations() const {
2442 // Check to see if it is worth the effort.
2443 if (!Abbreviations.empty()) {
2444 // Start the debug abbrev section.
2445 Asm->OutStreamer.SwitchSection(
2446 Asm->getObjFileLowering().getDwarfAbbrevSection());
2448 EmitLabel("abbrev_begin", 0);
2450 // For each abbrevation.
2451 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2452 // Get abbreviation data
2453 const DIEAbbrev *Abbrev = Abbreviations[i];
2455 // Emit the abbrevations code (base 1 index.)
2456 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2458 // Emit the abbreviations data.
2463 // Mark end of abbreviations.
2464 EmitULEB128(0, "EOM(3)");
2466 EmitLabel("abbrev_end", 0);
2471 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2472 /// the line matrix.
2474 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2475 // Define last address of section.
2476 Asm->EmitInt8(0); EOL("Extended Op");
2477 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2478 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2479 EmitReference("section_end", SectionEnd); EOL("Section end label");
2481 // Mark end of matrix.
2482 Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2487 /// emitDebugLines - Emit source line information.
2489 void DwarfDebug::emitDebugLines() {
2490 // If the target is using .loc/.file, the assembler will be emitting the
2491 // .debug_line table automatically.
2492 if (MAI->hasDotLocAndDotFile())
2495 // Minimum line delta, thus ranging from -10..(255-10).
2496 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2497 // Maximum line delta, thus ranging from -10..(255-10).
2498 const int MaxLineDelta = 255 + MinLineDelta;
2500 // Start the dwarf line section.
2501 Asm->OutStreamer.SwitchSection(
2502 Asm->getObjFileLowering().getDwarfLineSection());
2504 // Construct the section header.
2505 EmitDifference("line_end", 0, "line_begin", 0, true);
2506 EOL("Length of Source Line Info");
2507 EmitLabel("line_begin", 0);
2509 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2511 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2512 EOL("Prolog Length");
2513 EmitLabel("line_prolog_begin", 0);
2515 Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2516 Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2517 Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2518 Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2519 Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2521 // Line number standard opcode encodings argument count
2522 Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2523 Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2524 Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2525 Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2526 Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2527 Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2528 Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2529 Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2530 Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2532 // Emit directories.
2533 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2534 const std::string &Dir = getSourceDirectoryName(DI);
2535 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2536 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2539 Asm->EmitInt8(0); EOL("End of directories");
2542 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2543 // Remember source id starts at 1.
2544 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2545 const std::string &FN = getSourceFileName(Id.second);
2546 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2547 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2549 EmitULEB128(Id.first, "Directory #");
2550 EmitULEB128(0, "Mod date");
2551 EmitULEB128(0, "File size");
2554 Asm->EmitInt8(0); EOL("End of files");
2556 EmitLabel("line_prolog_end", 0);
2558 // A sequence for each text section.
2559 unsigned SecSrcLinesSize = SectionSourceLines.size();
2561 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2562 // Isolate current sections line info.
2563 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2565 /*if (Asm->isVerbose()) {
2566 const MCSection *S = SectionMap[j + 1];
2567 O << '\t' << MAI->getCommentString() << " Section"
2568 << S->getName() << '\n';
2572 // Dwarf assumes we start with first line of first source file.
2573 unsigned Source = 1;
2576 // Construct rows of the address, source, line, column matrix.
2577 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2578 const SrcLineInfo &LineInfo = LineInfos[i];
2579 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2580 if (!LabelID) continue;
2582 if (LineInfo.getLine() == 0) continue;
2584 if (!Asm->isVerbose())
2587 std::pair<unsigned, unsigned> SourceID =
2588 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2589 O << '\t' << MAI->getCommentString() << ' '
2590 << getSourceDirectoryName(SourceID.first) << '/'
2591 << getSourceFileName(SourceID.second)
2592 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2595 // Define the line address.
2596 Asm->EmitInt8(0); EOL("Extended Op");
2597 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2598 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2599 EmitReference("label", LabelID); EOL("Location label");
2601 // If change of source, then switch to the new source.
2602 if (Source != LineInfo.getSourceID()) {
2603 Source = LineInfo.getSourceID();
2604 Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2605 EmitULEB128(Source, "New Source");
2608 // If change of line.
2609 if (Line != LineInfo.getLine()) {
2610 // Determine offset.
2611 int Offset = LineInfo.getLine() - Line;
2612 int Delta = Offset - MinLineDelta;
2615 Line = LineInfo.getLine();
2617 // If delta is small enough and in range...
2618 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2619 // ... then use fast opcode.
2620 Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2622 // ... otherwise use long hand.
2623 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2624 EOL("DW_LNS_advance_line");
2625 EmitSLEB128(Offset, "Line Offset");
2626 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2629 // Copy the previous row (different address or source)
2630 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2634 emitEndOfLineMatrix(j + 1);
2637 if (SecSrcLinesSize == 0)
2638 // Because we're emitting a debug_line section, we still need a line
2639 // table. The linker and friends expect it to exist. If there's nothing to
2640 // put into it, emit an empty table.
2641 emitEndOfLineMatrix(1);
2643 EmitLabel("line_end", 0);
2647 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2649 void DwarfDebug::emitCommonDebugFrame() {
2650 if (!MAI->doesDwarfRequireFrameSection())
2654 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2655 TargetFrameInfo::StackGrowsUp ?
2656 TD->getPointerSize() : -TD->getPointerSize();
2658 // Start the dwarf frame section.
2659 Asm->OutStreamer.SwitchSection(
2660 Asm->getObjFileLowering().getDwarfFrameSection());
2662 EmitLabel("debug_frame_common", 0);
2663 EmitDifference("debug_frame_common_end", 0,
2664 "debug_frame_common_begin", 0, true);
2665 EOL("Length of Common Information Entry");
2667 EmitLabel("debug_frame_common_begin", 0);
2668 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2669 EOL("CIE Identifier Tag");
2670 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2672 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2673 EOL("CIE Augmentation");
2674 EmitULEB128(1, "CIE Code Alignment Factor");
2675 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2676 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2677 EOL("CIE RA Column");
2679 std::vector<MachineMove> Moves;
2680 RI->getInitialFrameState(Moves);
2682 EmitFrameMoves(NULL, 0, Moves, false);
2684 Asm->EmitAlignment(2, 0, 0, false);
2685 EmitLabel("debug_frame_common_end", 0);
2689 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2692 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2693 if (!MAI->doesDwarfRequireFrameSection())
2696 // Start the dwarf frame section.
2697 Asm->OutStreamer.SwitchSection(
2698 Asm->getObjFileLowering().getDwarfFrameSection());
2700 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2701 "debug_frame_begin", DebugFrameInfo.Number, true);
2702 EOL("Length of Frame Information Entry");
2704 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2706 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2708 EOL("FDE CIE offset");
2710 EmitReference("func_begin", DebugFrameInfo.Number);
2711 EOL("FDE initial location");
2712 EmitDifference("func_end", DebugFrameInfo.Number,
2713 "func_begin", DebugFrameInfo.Number);
2714 EOL("FDE address range");
2716 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2719 Asm->EmitAlignment(2, 0, 0, false);
2720 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2724 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2726 void DwarfDebug::emitDebugPubNames() {
2727 // Start the dwarf pubnames section.
2728 Asm->OutStreamer.SwitchSection(
2729 Asm->getObjFileLowering().getDwarfPubNamesSection());
2731 EmitDifference("pubnames_end", ModuleCU->getID(),
2732 "pubnames_begin", ModuleCU->getID(), true);
2733 EOL("Length of Public Names Info");
2735 EmitLabel("pubnames_begin", ModuleCU->getID());
2737 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2739 EmitSectionOffset("info_begin", "section_info",
2740 ModuleCU->getID(), 0, true, false);
2741 EOL("Offset of Compilation Unit Info");
2743 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2745 EOL("Compilation Unit Length");
2747 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2748 for (StringMap<DIE*>::const_iterator
2749 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2750 const char *Name = GI->getKeyData();
2751 DIE * Entity = GI->second;
2753 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2755 if (Asm->VerboseAsm)
2756 Asm->OutStreamer.AddComment("External Name");
2757 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2760 Asm->EmitInt32(0); EOL("End Mark");
2761 EmitLabel("pubnames_end", ModuleCU->getID());
2765 void DwarfDebug::emitDebugPubTypes() {
2766 // Start the dwarf pubnames section.
2767 Asm->OutStreamer.SwitchSection(
2768 Asm->getObjFileLowering().getDwarfPubTypesSection());
2769 EmitDifference("pubtypes_end", ModuleCU->getID(),
2770 "pubtypes_begin", ModuleCU->getID(), true);
2771 EOL("Length of Public Types Info");
2773 EmitLabel("pubtypes_begin", ModuleCU->getID());
2775 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2777 EmitSectionOffset("info_begin", "section_info",
2778 ModuleCU->getID(), 0, true, false);
2779 EOL("Offset of Compilation ModuleCU Info");
2781 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2783 EOL("Compilation ModuleCU Length");
2785 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2786 for (StringMap<DIE*>::const_iterator
2787 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2788 const char *Name = GI->getKeyData();
2789 DIE * Entity = GI->second;
2791 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2793 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2794 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)), 0);
2797 Asm->EmitInt32(0); EOL("End Mark");
2798 EmitLabel("pubtypes_end", ModuleCU->getID());
2802 /// emitDebugStr - Emit visible names into a debug str section.
2804 void DwarfDebug::emitDebugStr() {
2805 // Check to see if it is worth the effort.
2806 if (!StringPool.empty()) {
2807 // Start the dwarf str section.
2808 Asm->OutStreamer.SwitchSection(
2809 Asm->getObjFileLowering().getDwarfStrSection());
2811 // For each of strings in the string pool.
2812 for (unsigned StringID = 1, N = StringPool.size();
2813 StringID <= N; ++StringID) {
2814 // Emit a label for reference from debug information entries.
2815 EmitLabel("string", StringID);
2817 // Emit the string itself.
2818 const std::string &String = StringPool[StringID];
2819 Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2826 /// emitDebugLoc - Emit visible names into a debug loc section.
2828 void DwarfDebug::emitDebugLoc() {
2829 // Start the dwarf loc section.
2830 Asm->OutStreamer.SwitchSection(
2831 Asm->getObjFileLowering().getDwarfLocSection());
2834 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2836 void DwarfDebug::EmitDebugARanges() {
2837 // Start the dwarf aranges section.
2838 Asm->OutStreamer.SwitchSection(
2839 Asm->getObjFileLowering().getDwarfARangesSection());
2843 CompileUnit *Unit = GetBaseCompileUnit();
2845 // Don't include size of length
2846 Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2848 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2850 EmitReference("info_begin", Unit->getID());
2851 EOL("Offset of Compilation Unit Info");
2853 Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2855 Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2857 Asm->EmitInt16(0); EOL("Pad (1)");
2858 Asm->EmitInt16(0); EOL("Pad (2)");
2861 EmitReference("text_begin", 0); EOL("Address");
2862 EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
2864 Asm->EmitInt32(0); EOL("EOM (1)");
2865 Asm->EmitInt32(0); EOL("EOM (2)");
2869 /// emitDebugRanges - Emit visible names into a debug ranges section.
2871 void DwarfDebug::emitDebugRanges() {
2872 // Start the dwarf ranges section.
2873 Asm->OutStreamer.SwitchSection(
2874 Asm->getObjFileLowering().getDwarfRangesSection());
2877 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2879 void DwarfDebug::emitDebugMacInfo() {
2880 if (const MCSection *LineInfo =
2881 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2882 // Start the dwarf macinfo section.
2883 Asm->OutStreamer.SwitchSection(LineInfo);
2887 /// emitDebugInlineInfo - Emit inline info using following format.
2889 /// 1. length of section
2890 /// 2. Dwarf version number
2891 /// 3. address size.
2893 /// Entries (one "entry" for each function that was inlined):
2895 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2896 /// otherwise offset into __debug_str for regular function name.
2897 /// 2. offset into __debug_str section for regular function name.
2898 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2899 /// instances for the function.
2901 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2902 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2903 /// __debug_info section, and the low_pc is the starting address for the
2904 /// inlining instance.
2905 void DwarfDebug::emitDebugInlineInfo() {
2906 if (!MAI->doesDwarfUsesInlineInfoSection())
2912 Asm->OutStreamer.SwitchSection(
2913 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2915 EmitDifference("debug_inlined_end", 1,
2916 "debug_inlined_begin", 1, true);
2917 EOL("Length of Debug Inlined Information Entry");
2919 EmitLabel("debug_inlined_begin", 1);
2921 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2922 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2924 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2925 E = InlinedSPNodes.end(); I != E; ++I) {
2928 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2929 = InlineInfo.find(Node);
2930 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2931 DISubprogram SP(Node);
2932 StringRef LName = SP.getLinkageName();
2933 StringRef Name = SP.getName();
2935 if (LName.empty()) {
2936 Asm->OutStreamer.EmitBytes(Name, 0);
2937 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2939 EmitSectionOffset("string", "section_str",
2940 StringPool.idFor(getRealLinkageName(LName)), false, true);
2942 EOL("MIPS linkage name");
2943 EmitSectionOffset("string", "section_str",
2944 StringPool.idFor(Name), false, true);
2945 EOL("Function name");
2946 EmitULEB128(Labels.size(), "Inline count");
2948 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2949 LE = Labels.end(); LI != LE; ++LI) {
2950 DIE *SP = LI->second;
2951 Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
2953 if (TD->getPointerSize() == sizeof(int32_t))
2954 O << MAI->getData32bitsDirective();
2956 O << MAI->getData64bitsDirective();
2958 PrintLabelName("label", LI->first); EOL("low_pc");
2962 EmitLabel("debug_inlined_end", 1);