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;
242 unsigned CurrentLastInsnIndex = 0;
243 if (const MachineInstr *CL = getLastInsn())
244 CurrentLastInsnIndex = MIIndexMap[CL];
245 unsigned FIndex = MIIndexMap[getFirstInsn()];
247 // Set LastInsn as the last instruction for this scope only if
249 // 1) this scope's first instruction and
250 // 2) current last instruction for this scope, if any.
251 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
252 setLastInsn(LastInsn);
261 void DbgScope::dump() const {
262 raw_ostream &err = dbgs();
263 err.indent(IndentLevel);
264 MDNode *N = Desc.getNode();
266 err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
268 err << "Abstract Scope\n";
272 err << "Children ...\n";
273 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
274 if (Scopes[i] != this)
281 DbgScope::~DbgScope() {
282 for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
284 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
288 } // end llvm namespace
290 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
291 : DwarfPrinter(OS, A, T, "dbg"), ModuleCU(0),
292 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
293 DIEValues(), StringPool(),
294 SectionSourceLines(), didInitial(false), shouldEmit(false),
295 CurrentFnDbgScope(0), DebugTimer(0) {
296 if (TimePassesIsEnabled)
297 DebugTimer = new Timer("Dwarf Debug Writer");
299 DwarfDebug::~DwarfDebug() {
300 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
306 /// assignAbbrevNumber - Define a unique number for the abbreviation.
308 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
309 // Profile the node so that we can make it unique.
313 // Check the set for priors.
314 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
316 // If it's newly added.
317 if (InSet == &Abbrev) {
318 // Add to abbreviation list.
319 Abbreviations.push_back(&Abbrev);
321 // Assign the vector position + 1 as its number.
322 Abbrev.setNumber(Abbreviations.size());
324 // Assign existing abbreviation number.
325 Abbrev.setNumber(InSet->getNumber());
329 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
330 /// information entry.
331 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
332 DIEEntry *Value = new DIEEntry(Entry);
333 DIEValues.push_back(Value);
337 /// addUInt - Add an unsigned integer attribute data and value.
339 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
340 unsigned Form, uint64_t Integer) {
341 if (!Form) Form = DIEInteger::BestForm(false, Integer);
342 DIEValue *Value = new DIEInteger(Integer);
343 DIEValues.push_back(Value);
344 Die->addValue(Attribute, Form, Value);
347 /// addSInt - Add an signed integer attribute data and value.
349 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
350 unsigned Form, int64_t Integer) {
351 if (!Form) Form = DIEInteger::BestForm(true, Integer);
352 DIEValue *Value = new DIEInteger(Integer);
353 DIEValues.push_back(Value);
354 Die->addValue(Attribute, Form, Value);
357 /// addString - Add a string attribute data and value. DIEString only
358 /// keeps string reference.
359 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
361 DIEValue *Value = new DIEString(String);
362 DIEValues.push_back(Value);
363 Die->addValue(Attribute, Form, Value);
366 /// addLabel - Add a Dwarf label attribute data and value.
368 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
369 const DWLabel &Label) {
370 DIEValue *Value = new DIEDwarfLabel(Label);
371 DIEValues.push_back(Value);
372 Die->addValue(Attribute, Form, Value);
375 /// addObjectLabel - Add an non-Dwarf label attribute data and value.
377 void DwarfDebug::addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
378 const MCSymbol *Sym) {
379 DIEValue *Value = new DIEObjectLabel(Sym);
380 DIEValues.push_back(Value);
381 Die->addValue(Attribute, Form, Value);
384 /// addSectionOffset - Add a section offset label attribute data and value.
386 void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
387 const DWLabel &Label, const DWLabel &Section,
388 bool isEH, bool useSet) {
389 DIEValue *Value = new DIESectionOffset(Label, Section, isEH, useSet);
390 DIEValues.push_back(Value);
391 Die->addValue(Attribute, Form, Value);
394 /// addDelta - Add a label delta attribute data and value.
396 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
397 const DWLabel &Hi, const DWLabel &Lo) {
398 DIEValue *Value = new DIEDelta(Hi, Lo);
399 DIEValues.push_back(Value);
400 Die->addValue(Attribute, Form, Value);
403 /// addBlock - Add block data.
405 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
407 Block->ComputeSize(TD);
408 DIEValues.push_back(Block);
409 Die->addValue(Attribute, Block->BestForm(), Block);
412 /// addSourceLine - Add location information to specified debug information
414 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
415 // If there is no compile unit specified, don't add a line #.
416 if (V->getCompileUnit().isNull())
419 unsigned Line = V->getLineNumber();
420 unsigned FileID = findCompileUnit(V->getCompileUnit())->getID();
421 assert(FileID && "Invalid file id");
422 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
423 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
426 /// addSourceLine - Add location information to specified debug information
428 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
429 // If there is no compile unit specified, don't add a line #.
430 if (G->getCompileUnit().isNull())
433 unsigned Line = G->getLineNumber();
434 unsigned FileID = findCompileUnit(G->getCompileUnit())->getID();
435 assert(FileID && "Invalid file id");
436 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
437 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
440 /// addSourceLine - Add location information to specified debug information
442 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
443 // If there is no compile unit specified, don't add a line #.
444 if (SP->getCompileUnit().isNull())
446 // If the line number is 0, don't add it.
447 if (SP->getLineNumber() == 0)
451 unsigned Line = SP->getLineNumber();
452 unsigned FileID = findCompileUnit(SP->getCompileUnit())->getID();
453 assert(FileID && "Invalid file id");
454 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
455 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
458 /// addSourceLine - Add location information to specified debug information
460 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
461 // If there is no compile unit specified, don't add a line #.
462 DICompileUnit CU = Ty->getCompileUnit();
466 unsigned Line = Ty->getLineNumber();
467 unsigned FileID = findCompileUnit(CU)->getID();
468 assert(FileID && "Invalid file id");
469 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
470 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
473 /// addSourceLine - Add location information to specified debug information
475 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
476 // If there is no compile unit specified, don't add a line #.
477 if (NS->getCompileUnit().isNull())
480 unsigned Line = NS->getLineNumber();
481 StringRef FN = NS->getFilename();
482 StringRef Dir = NS->getDirectory();
484 unsigned FileID = GetOrCreateSourceID(Dir, FN);
485 assert(FileID && "Invalid file id");
486 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
487 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
490 /* Byref variables, in Blocks, are declared by the programmer as
491 "SomeType VarName;", but the compiler creates a
492 __Block_byref_x_VarName struct, and gives the variable VarName
493 either the struct, or a pointer to the struct, as its type. This
494 is necessary for various behind-the-scenes things the compiler
495 needs to do with by-reference variables in blocks.
497 However, as far as the original *programmer* is concerned, the
498 variable should still have type 'SomeType', as originally declared.
500 The following function dives into the __Block_byref_x_VarName
501 struct to find the original type of the variable. This will be
502 passed back to the code generating the type for the Debug
503 Information Entry for the variable 'VarName'. 'VarName' will then
504 have the original type 'SomeType' in its debug information.
506 The original type 'SomeType' will be the type of the field named
507 'VarName' inside the __Block_byref_x_VarName struct.
509 NOTE: In order for this to not completely fail on the debugger
510 side, the Debug Information Entry for the variable VarName needs to
511 have a DW_AT_location that tells the debugger how to unwind through
512 the pointers and __Block_byref_x_VarName struct to find the actual
513 value of the variable. The function addBlockByrefType does this. */
515 /// Find the type the programmer originally declared the variable to be
516 /// and return that type.
518 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
521 unsigned tag = Ty.getTag();
523 if (tag == dwarf::DW_TAG_pointer_type) {
524 DIDerivedType DTy = DIDerivedType(Ty.getNode());
525 subType = DTy.getTypeDerivedFrom();
528 DICompositeType blockStruct = DICompositeType(subType.getNode());
530 DIArray Elements = blockStruct.getTypeArray();
532 if (Elements.isNull())
535 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
536 DIDescriptor Element = Elements.getElement(i);
537 DIDerivedType DT = DIDerivedType(Element.getNode());
538 if (Name == DT.getName())
539 return (DT.getTypeDerivedFrom());
545 /// addComplexAddress - Start with the address based on the location provided,
546 /// and generate the DWARF information necessary to find the actual variable
547 /// given the extra address information encoded in the DIVariable, starting from
548 /// the starting location. Add the DWARF information to the die.
550 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
552 const MachineLocation &Location) {
553 const DIVariable &VD = DV->getVariable();
554 DIType Ty = VD.getType();
556 // Decode the original location, and use that as the start of the byref
557 // variable's location.
558 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
559 DIEBlock *Block = new DIEBlock();
561 if (Location.isReg()) {
563 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
565 Reg = Reg - dwarf::DW_OP_reg0;
566 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
567 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
571 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
573 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
574 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
577 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
580 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
581 uint64_t Element = VD.getAddrElement(i);
583 if (Element == DIFactory::OpPlus) {
584 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
585 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
586 } else if (Element == DIFactory::OpDeref) {
587 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
588 } else llvm_unreachable("unknown DIFactory Opcode");
591 // Now attach the location information to the DIE.
592 addBlock(Die, Attribute, 0, Block);
595 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
596 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
597 gives the variable VarName either the struct, or a pointer to the struct, as
598 its type. This is necessary for various behind-the-scenes things the
599 compiler needs to do with by-reference variables in Blocks.
601 However, as far as the original *programmer* is concerned, the variable
602 should still have type 'SomeType', as originally declared.
604 The function getBlockByrefType dives into the __Block_byref_x_VarName
605 struct to find the original type of the variable, which is then assigned to
606 the variable's Debug Information Entry as its real type. So far, so good.
607 However now the debugger will expect the variable VarName to have the type
608 SomeType. So we need the location attribute for the variable to be an
609 expression that explains to the debugger how to navigate through the
610 pointers and struct to find the actual variable of type SomeType.
612 The following function does just that. We start by getting
613 the "normal" location for the variable. This will be the location
614 of either the struct __Block_byref_x_VarName or the pointer to the
615 struct __Block_byref_x_VarName.
617 The struct will look something like:
619 struct __Block_byref_x_VarName {
621 struct __Block_byref_x_VarName *forwarding;
622 ... <various other fields>
624 ... <maybe more fields>
627 If we are given the struct directly (as our starting point) we
628 need to tell the debugger to:
630 1). Add the offset of the forwarding field.
632 2). Follow that pointer to get the real __Block_byref_x_VarName
633 struct to use (the real one may have been copied onto the heap).
635 3). Add the offset for the field VarName, to find the actual variable.
637 If we started with a pointer to the struct, then we need to
638 dereference that pointer first, before the other steps.
639 Translating this into DWARF ops, we will need to append the following
640 to the current location description for the variable:
642 DW_OP_deref -- optional, if we start with a pointer
643 DW_OP_plus_uconst <forward_fld_offset>
645 DW_OP_plus_uconst <varName_fld_offset>
647 That is what this function does. */
649 /// addBlockByrefAddress - Start with the address based on the location
650 /// provided, and generate the DWARF information necessary to find the
651 /// actual Block variable (navigating the Block struct) based on the
652 /// starting location. Add the DWARF information to the die. For
653 /// more information, read large comment just above here.
655 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
657 const MachineLocation &Location) {
658 const DIVariable &VD = DV->getVariable();
659 DIType Ty = VD.getType();
661 unsigned Tag = Ty.getTag();
662 bool isPointer = false;
664 StringRef varName = VD.getName();
666 if (Tag == dwarf::DW_TAG_pointer_type) {
667 DIDerivedType DTy = DIDerivedType(Ty.getNode());
668 TmpTy = DTy.getTypeDerivedFrom();
672 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
674 // Find the __forwarding field and the variable field in the __Block_byref
676 DIArray Fields = blockStruct.getTypeArray();
677 DIDescriptor varField = DIDescriptor();
678 DIDescriptor forwardingField = DIDescriptor();
681 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
682 DIDescriptor Element = Fields.getElement(i);
683 DIDerivedType DT = DIDerivedType(Element.getNode());
684 StringRef fieldName = DT.getName();
685 if (fieldName == "__forwarding")
686 forwardingField = Element;
687 else if (fieldName == varName)
691 assert(!varField.isNull() && "Can't find byref variable in Block struct");
692 assert(!forwardingField.isNull()
693 && "Can't find forwarding field in Block struct");
695 // Get the offsets for the forwarding field and the variable field.
696 unsigned int forwardingFieldOffset =
697 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
698 unsigned int varFieldOffset =
699 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
701 // Decode the original location, and use that as the start of the byref
702 // variable's location.
703 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
704 DIEBlock *Block = new DIEBlock();
706 if (Location.isReg()) {
708 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
710 Reg = Reg - dwarf::DW_OP_reg0;
711 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
712 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
716 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
718 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
719 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
722 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
725 // If we started with a pointer to the __Block_byref... struct, then
726 // the first thing we need to do is dereference the pointer (DW_OP_deref).
728 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
730 // Next add the offset for the '__forwarding' field:
731 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
732 // adding the offset if it's 0.
733 if (forwardingFieldOffset > 0) {
734 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
735 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
738 // Now dereference the __forwarding field to get to the real __Block_byref
739 // struct: DW_OP_deref.
740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
742 // Now that we've got the real __Block_byref... struct, add the offset
743 // for the variable's field to get to the location of the actual variable:
744 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
745 if (varFieldOffset > 0) {
746 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
747 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
750 // Now attach the location information to the DIE.
751 addBlock(Die, Attribute, 0, Block);
754 /// addAddress - Add an address attribute to a die based on the location
756 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
757 const MachineLocation &Location) {
758 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
759 DIEBlock *Block = new DIEBlock();
761 if (Location.isReg()) {
763 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
765 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
766 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
770 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
772 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
773 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
776 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
779 addBlock(Die, Attribute, 0, Block);
782 /// addToContextOwner - Add Die into the list of its context owner's children.
783 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
784 if (Context.isNull())
785 ModuleCU->addDie(Die);
786 else if (Context.isType()) {
787 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
788 ContextDIE->addChild(Die);
789 } else if (Context.isNameSpace()) {
790 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
791 ContextDIE->addChild(Die);
792 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
793 ContextDIE->addChild(Die);
795 ModuleCU->addDie(Die);
798 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
800 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
801 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
806 TyDIE = new DIE(dwarf::DW_TAG_base_type);
807 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
808 if (Ty.isBasicType())
809 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
810 else if (Ty.isCompositeType())
811 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
813 assert(Ty.isDerivedType() && "Unknown kind of DIType");
814 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
817 addToContextOwner(TyDIE, Ty.getContext());
821 /// addType - Add a new type attribute to the specified entity.
822 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
826 // Check for pre-existence.
827 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
828 // If it exists then use the existing value.
830 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
835 Entry = createDIEEntry();
836 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
839 DIE *Buffer = getOrCreateTypeDIE(Ty);
841 Entry->setEntry(Buffer);
842 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
845 /// constructTypeDIE - Construct basic type die from DIBasicType.
846 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
847 // Get core information.
848 StringRef Name = BTy.getName();
849 Buffer.setTag(dwarf::DW_TAG_base_type);
850 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
853 // Add name if not anonymous or intermediate type.
855 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
856 uint64_t Size = BTy.getSizeInBits() >> 3;
857 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
860 /// constructTypeDIE - Construct derived type die from DIDerivedType.
861 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
862 // Get core information.
863 StringRef Name = DTy.getName();
864 uint64_t Size = DTy.getSizeInBits() >> 3;
865 unsigned Tag = DTy.getTag();
867 // FIXME - Workaround for templates.
868 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
872 // Map to main type, void will not have a type.
873 DIType FromTy = DTy.getTypeDerivedFrom();
874 addType(&Buffer, FromTy);
876 // Add name if not anonymous or intermediate type.
878 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
880 // Add size if non-zero (derived types might be zero-sized.)
882 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
884 // Add source line info if available and TyDesc is not a forward declaration.
885 if (!DTy.isForwardDecl())
886 addSourceLine(&Buffer, &DTy);
889 /// constructTypeDIE - Construct type DIE from DICompositeType.
890 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
891 // Get core information.
892 StringRef Name = CTy.getName();
894 uint64_t Size = CTy.getSizeInBits() >> 3;
895 unsigned Tag = CTy.getTag();
899 case dwarf::DW_TAG_vector_type:
900 case dwarf::DW_TAG_array_type:
901 constructArrayTypeDIE(Buffer, &CTy);
903 case dwarf::DW_TAG_enumeration_type: {
904 DIArray Elements = CTy.getTypeArray();
906 // Add enumerators to enumeration type.
907 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
909 DIEnumerator Enum(Elements.getElement(i).getNode());
910 if (!Enum.isNull()) {
911 ElemDie = constructEnumTypeDIE(&Enum);
912 Buffer.addChild(ElemDie);
917 case dwarf::DW_TAG_subroutine_type: {
919 DIArray Elements = CTy.getTypeArray();
920 DIDescriptor RTy = Elements.getElement(0);
921 addType(&Buffer, DIType(RTy.getNode()));
923 // Add prototype flag.
924 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
927 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
928 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
929 DIDescriptor Ty = Elements.getElement(i);
930 addType(Arg, DIType(Ty.getNode()));
931 Buffer.addChild(Arg);
935 case dwarf::DW_TAG_structure_type:
936 case dwarf::DW_TAG_union_type:
937 case dwarf::DW_TAG_class_type: {
938 // Add elements to structure type.
939 DIArray Elements = CTy.getTypeArray();
941 // A forward struct declared type may not have elements available.
942 if (Elements.isNull())
945 // Add elements to structure type.
946 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
947 DIDescriptor Element = Elements.getElement(i);
948 if (Element.isNull())
951 if (Element.getTag() == dwarf::DW_TAG_subprogram)
952 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
953 else if (Element.getTag() == dwarf::DW_TAG_auto_variable) {
954 DIVariable DV(Element.getNode());
955 ElemDie = new DIE(dwarf::DW_TAG_variable);
956 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
958 addType(ElemDie, DV.getType());
959 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
960 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
961 addSourceLine(ElemDie, &DV);
963 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
964 Buffer.addChild(ElemDie);
967 if (CTy.isAppleBlockExtension())
968 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
970 unsigned RLang = CTy.getRunTimeLang();
972 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
973 dwarf::DW_FORM_data1, RLang);
975 DICompositeType ContainingType = CTy.getContainingType();
976 if (!ContainingType.isNull())
977 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
978 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
985 // Add name if not anonymous or intermediate type.
987 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
989 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
990 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
991 // Add size if non-zero (derived types might be zero-sized.)
993 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
995 // Add zero size if it is not a forward declaration.
996 if (CTy.isForwardDecl())
997 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
999 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1002 // Add source line info if available.
1003 if (!CTy.isForwardDecl())
1004 addSourceLine(&Buffer, &CTy);
1008 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1009 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1010 int64_t L = SR.getLo();
1011 int64_t H = SR.getHi();
1012 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1014 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1016 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1017 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1019 Buffer.addChild(DW_Subrange);
1022 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1023 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1024 DICompositeType *CTy) {
1025 Buffer.setTag(dwarf::DW_TAG_array_type);
1026 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1027 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1029 // Emit derived type.
1030 addType(&Buffer, CTy->getTypeDerivedFrom());
1031 DIArray Elements = CTy->getTypeArray();
1033 // Get an anonymous type for index type.
1034 DIE *IdxTy = ModuleCU->getIndexTyDie();
1036 // Construct an anonymous type for index type.
1037 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1038 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1039 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1040 dwarf::DW_ATE_signed);
1041 ModuleCU->addDie(IdxTy);
1042 ModuleCU->setIndexTyDie(IdxTy);
1045 // Add subranges to array type.
1046 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1047 DIDescriptor Element = Elements.getElement(i);
1048 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1049 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1053 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1054 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator *ETy) {
1055 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1056 StringRef Name = ETy->getName();
1057 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1058 int64_t Value = ETy->getEnumValue();
1059 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1063 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1064 /// printer to not emit usual symbol prefix before the symbol name is used then
1065 /// return linkage name after skipping this special LLVM prefix.
1066 static StringRef getRealLinkageName(StringRef LinkageName) {
1068 if (LinkageName.startswith(StringRef(&One, 1)))
1069 return LinkageName.substr(1);
1073 /// createGlobalVariableDIE - Create new DIE using GV.
1074 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1075 // If the global variable was optmized out then no need to create debug info
1077 if (!GV.getGlobal()) return NULL;
1078 if (GV.getDisplayName().empty()) return NULL;
1080 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1081 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1082 GV.getDisplayName());
1084 StringRef LinkageName = GV.getLinkageName();
1085 if (!LinkageName.empty())
1086 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1087 getRealLinkageName(LinkageName));
1089 addType(GVDie, GV.getType());
1090 if (!GV.isLocalToUnit())
1091 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1092 addSourceLine(GVDie, &GV);
1097 /// createMemberDIE - Create new member DIE.
1098 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1099 DIE *MemberDie = new DIE(DT.getTag());
1100 StringRef Name = DT.getName();
1102 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1104 addType(MemberDie, DT.getTypeDerivedFrom());
1106 addSourceLine(MemberDie, &DT);
1108 DIEBlock *MemLocationDie = new DIEBlock();
1109 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1111 uint64_t Size = DT.getSizeInBits();
1112 uint64_t FieldSize = DT.getOriginalTypeSize();
1114 if (Size != FieldSize) {
1116 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1117 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1119 uint64_t Offset = DT.getOffsetInBits();
1120 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1121 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1122 uint64_t FieldOffset = (HiMark - FieldSize);
1123 Offset -= FieldOffset;
1125 // Maybe we need to work from the other end.
1126 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1127 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1129 // Here WD_AT_data_member_location points to the anonymous
1130 // field that includes this bit field.
1131 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1134 // This is not a bitfield.
1135 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1137 if (DT.getTag() == dwarf::DW_TAG_inheritance
1138 && DT.isVirtual()) {
1140 // For C++, virtual base classes are not at fixed offset. Use following
1141 // expression to extract appropriate offset from vtable.
1142 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1144 DIEBlock *VBaseLocationDie = new DIEBlock();
1145 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1146 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1147 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1148 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1149 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1150 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1151 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1153 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1156 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1158 if (DT.isProtected())
1159 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1160 dwarf::DW_ACCESS_protected);
1161 else if (DT.isPrivate())
1162 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1163 dwarf::DW_ACCESS_private);
1164 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1165 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1166 dwarf::DW_ACCESS_public);
1168 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1169 dwarf::DW_VIRTUALITY_virtual);
1173 /// createSubprogramDIE - Create new DIE using SP.
1174 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1175 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1179 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1180 // constructors and operators for anonymous aggregates does not names.
1181 if (!SP.getName().empty())
1182 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1184 StringRef LinkageName = SP.getLinkageName();
1185 if (!LinkageName.empty())
1186 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1187 getRealLinkageName(LinkageName));
1189 addSourceLine(SPDie, &SP);
1191 // Add prototyped tag, if C or ObjC.
1192 unsigned Lang = SP.getCompileUnit().getLanguage();
1193 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1194 Lang == dwarf::DW_LANG_ObjC)
1195 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1198 DICompositeType SPTy = SP.getType();
1199 DIArray Args = SPTy.getTypeArray();
1200 unsigned SPTag = SPTy.getTag();
1202 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1203 addType(SPDie, SPTy);
1205 addType(SPDie, DIType(Args.getElement(0).getNode()));
1207 unsigned VK = SP.getVirtuality();
1209 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1210 DIEBlock *Block = new DIEBlock();
1211 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1212 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1213 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1214 ContainingTypeMap.insert(std::make_pair(SPDie,
1215 SP.getContainingType().getNode()));
1218 if (MakeDecl || !SP.isDefinition()) {
1219 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1221 // Add arguments. Do not add arguments for subprogram definition. They will
1222 // be handled while processing variables.
1223 DICompositeType SPTy = SP.getType();
1224 DIArray Args = SPTy.getTypeArray();
1225 unsigned SPTag = SPTy.getTag();
1227 if (SPTag == dwarf::DW_TAG_subroutine_type)
1228 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1229 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1230 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1232 if (ATy.isArtificial())
1233 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1234 SPDie->addChild(Arg);
1238 if (SP.isArtificial())
1239 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1241 // DW_TAG_inlined_subroutine may refer to this DIE.
1242 ModuleCU->insertDIE(SP.getNode(), SPDie);
1246 /// findCompileUnit - Get the compile unit for the given descriptor.
1248 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1249 DenseMap<Value *, CompileUnit *>::const_iterator I =
1250 CompileUnitMap.find(Unit.getNode());
1251 if (I == CompileUnitMap.end())
1252 return constructCompileUnit(Unit.getNode());
1256 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1257 /// Initialize scope and update scope hierarchy.
1258 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1259 MDNode *InlinedAt) {
1260 assert (N && "Invalid Scope encoding!");
1261 assert (MI && "Missing machine instruction!");
1262 bool GetConcreteScope = (MI && InlinedAt);
1264 DbgScope *NScope = NULL;
1267 NScope = DbgScopeMap.lookup(InlinedAt);
1269 NScope = DbgScopeMap.lookup(N);
1270 assert (NScope && "Unable to find working scope!");
1272 if (NScope->getFirstInsn())
1275 DbgScope *Parent = NULL;
1276 if (GetConcreteScope) {
1277 DILocation IL(InlinedAt);
1278 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1279 IL.getOrigLocation().getNode());
1280 assert (Parent && "Unable to find Parent scope!");
1281 NScope->setParent(Parent);
1282 Parent->addScope(NScope);
1283 } else if (DIDescriptor(N).isLexicalBlock()) {
1284 DILexicalBlock DB(N);
1285 if (!DB.getContext().isNull()) {
1286 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1287 NScope->setParent(Parent);
1288 Parent->addScope(NScope);
1292 NScope->setFirstInsn(MI);
1294 if (!Parent && !InlinedAt) {
1295 StringRef SPName = DISubprogram(N).getLinkageName();
1296 if (SPName == MF->getFunction()->getName())
1297 CurrentFnDbgScope = NScope;
1300 if (GetConcreteScope) {
1301 ConcreteScopes[InlinedAt] = NScope;
1302 getOrCreateAbstractScope(N);
1308 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1309 assert (N && "Invalid Scope encoding!");
1311 DbgScope *AScope = AbstractScopes.lookup(N);
1315 DbgScope *Parent = NULL;
1317 DIDescriptor Scope(N);
1318 if (Scope.isLexicalBlock()) {
1319 DILexicalBlock DB(N);
1320 DIDescriptor ParentDesc = DB.getContext();
1321 if (!ParentDesc.isNull())
1322 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1325 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1328 Parent->addScope(AScope);
1329 AScope->setAbstractScope();
1330 AbstractScopes[N] = AScope;
1331 if (DIDescriptor(N).isSubprogram())
1332 AbstractScopesList.push_back(AScope);
1336 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1337 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1338 /// If there are global variables in this scope then create and insert
1339 /// DIEs for these variables.
1340 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1342 DIE *SPDie = ModuleCU->getDIE(SPNode);
1343 assert (SPDie && "Unable to find subprogram DIE!");
1344 DISubprogram SP(SPNode);
1345 // There is not any need to generate specification DIE for a function
1346 // defined at compile unit level. If a function is defined inside another
1347 // function then gdb prefers the definition at top level and but does not
1348 // expect specification DIE in parent function. So avoid creating
1349 // specification DIE for a function defined inside a function.
1350 if (SP.isDefinition() && !SP.getContext().isCompileUnit()
1351 && !SP.getContext().isSubprogram()) {
1352 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1354 DICompositeType SPTy = SP.getType();
1355 DIArray Args = SPTy.getTypeArray();
1356 unsigned SPTag = SPTy.getTag();
1357 if (SPTag == dwarf::DW_TAG_subroutine_type)
1358 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1359 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1360 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1362 if (ATy.isArtificial())
1363 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1364 SPDie->addChild(Arg);
1366 DIE *SPDeclDie = SPDie;
1367 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1368 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1370 ModuleCU->addDie(SPDie);
1373 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1374 DWLabel("func_begin", SubprogramCount));
1375 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1376 DWLabel("func_end", SubprogramCount));
1377 MachineLocation Location(RI->getFrameRegister(*MF));
1378 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1380 if (!DISubprogram(SPNode).isLocalToUnit())
1381 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1386 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1387 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1388 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1389 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1390 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1392 // Ignore empty scopes.
1393 if (StartID == EndID && StartID != 0)
1396 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1397 if (Scope->isAbstractScope())
1400 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1402 DWLabel("label", StartID)
1403 : DWLabel("func_begin", SubprogramCount));
1404 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1406 DWLabel("label", EndID)
1407 : DWLabel("func_end", SubprogramCount));
1414 /// constructInlinedScopeDIE - This scope represents inlined body of
1415 /// a function. Construct DIE to represent this concrete inlined copy
1416 /// of the function.
1417 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1418 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1419 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1420 assert (StartID && "Invalid starting label for an inlined scope!");
1421 assert (EndID && "Invalid end label for an inlined scope!");
1422 // Ignore empty scopes.
1423 if (StartID == EndID && StartID != 0)
1426 DIScope DS(Scope->getScopeNode());
1429 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1431 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1432 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1433 assert (OriginDIE && "Unable to find Origin DIE!");
1434 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1435 dwarf::DW_FORM_ref4, OriginDIE);
1437 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1438 DWLabel("label", StartID));
1439 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1440 DWLabel("label", EndID));
1442 InlinedSubprogramDIEs.insert(OriginDIE);
1444 // Track the start label for this inlined function.
1445 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1446 I = InlineInfo.find(InlinedSP.getNode());
1448 if (I == InlineInfo.end()) {
1449 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1451 InlinedSPNodes.push_back(InlinedSP.getNode());
1453 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1455 StringPool.insert(InlinedSP.getName());
1456 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1458 DILocation DL(Scope->getInlinedAt());
1459 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1460 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1466 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1467 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1468 // Get the descriptor.
1469 const DIVariable &VD = DV->getVariable();
1470 StringRef Name = VD.getName();
1474 // Translate tag to proper Dwarf tag. The result variable is dropped for
1477 switch (VD.getTag()) {
1478 case dwarf::DW_TAG_return_variable:
1480 case dwarf::DW_TAG_arg_variable:
1481 Tag = dwarf::DW_TAG_formal_parameter;
1483 case dwarf::DW_TAG_auto_variable: // fall thru
1485 Tag = dwarf::DW_TAG_variable;
1489 // Define variable debug information entry.
1490 DIE *VariableDie = new DIE(Tag);
1494 if (DbgVariable *AV = DV->getAbstractVariable())
1495 AbsDIE = AV->getDIE();
1498 DIScope DS(Scope->getScopeNode());
1499 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1500 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1502 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1503 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1504 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1505 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1506 dwarf::DW_FORM_ref4, AbsDIE);
1509 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1510 addSourceLine(VariableDie, &VD);
1512 // Add variable type.
1513 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1514 // addresses instead.
1515 if (VD.isBlockByrefVariable())
1516 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1518 addType(VariableDie, VD.getType());
1521 // Add variable address.
1522 if (!Scope->isAbstractScope()) {
1523 MachineLocation Location;
1525 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1526 Location.set(FrameReg, Offset);
1528 if (VD.hasComplexAddress())
1529 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1530 else if (VD.isBlockByrefVariable())
1531 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1533 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1536 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1537 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1538 DV->setDIE(VariableDie);
1543 void DwarfDebug::addPubTypes(DISubprogram SP) {
1544 DICompositeType SPTy = SP.getType();
1545 unsigned SPTag = SPTy.getTag();
1546 if (SPTag != dwarf::DW_TAG_subroutine_type)
1549 DIArray Args = SPTy.getTypeArray();
1553 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1554 DIType ATy(Args.getElement(i).getNode());
1557 DICompositeType CATy = getDICompositeType(ATy);
1558 if (!CATy.isNull() && !CATy.getName().empty()) {
1559 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1560 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1565 /// constructScopeDIE - Construct a DIE for this scope.
1566 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1569 DIScope DS(Scope->getScopeNode());
1573 DIE *ScopeDIE = NULL;
1574 if (Scope->getInlinedAt())
1575 ScopeDIE = constructInlinedScopeDIE(Scope);
1576 else if (DS.isSubprogram()) {
1577 if (Scope->isAbstractScope())
1578 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1580 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1583 ScopeDIE = constructLexicalScopeDIE(Scope);
1584 if (!ScopeDIE) return NULL;
1587 // Add variables to scope.
1588 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1589 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1590 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1592 ScopeDIE->addChild(VariableDIE);
1595 // Add nested scopes.
1596 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1597 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1598 // Define the Scope debug information entry.
1599 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1601 ScopeDIE->addChild(NestedDIE);
1604 if (DS.isSubprogram())
1605 addPubTypes(DISubprogram(DS.getNode()));
1610 /// GetOrCreateSourceID - Look up the source id with the given directory and
1611 /// source file names. If none currently exists, create a new id and insert it
1612 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1614 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1616 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1617 if (DI != DirectoryIdMap.end()) {
1618 DId = DI->getValue();
1620 DId = DirectoryNames.size() + 1;
1621 DirectoryIdMap[DirName] = DId;
1622 DirectoryNames.push_back(DirName);
1626 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1627 if (FI != SourceFileIdMap.end()) {
1628 FId = FI->getValue();
1630 FId = SourceFileNames.size() + 1;
1631 SourceFileIdMap[FileName] = FId;
1632 SourceFileNames.push_back(FileName);
1635 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1636 SourceIdMap.find(std::make_pair(DId, FId));
1637 if (SI != SourceIdMap.end())
1640 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1641 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1642 SourceIds.push_back(std::make_pair(DId, FId));
1647 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1648 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1649 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1652 NDie = new DIE(dwarf::DW_TAG_namespace);
1653 ModuleCU->insertDIE(NS.getNode(), NDie);
1654 if (!NS.getName().empty())
1655 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1656 addSourceLine(NDie, &NS);
1657 addToContextOwner(NDie, NS.getContext());
1661 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1662 DICompileUnit DIUnit(N);
1663 StringRef FN = DIUnit.getFilename();
1664 StringRef Dir = DIUnit.getDirectory();
1665 unsigned ID = GetOrCreateSourceID(Dir, FN);
1667 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1668 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1669 DWLabel("section_line", 0), DWLabel("section_line", 0),
1671 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1672 DIUnit.getProducer());
1673 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1674 DIUnit.getLanguage());
1675 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1678 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1679 if (DIUnit.isOptimized())
1680 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1682 StringRef Flags = DIUnit.getFlags();
1684 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1686 unsigned RVer = DIUnit.getRunTimeVersion();
1688 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1689 dwarf::DW_FORM_data1, RVer);
1691 CompileUnit *Unit = new CompileUnit(ID, Die);
1692 if (!ModuleCU && DIUnit.isMain()) {
1693 // Use first compile unit marked as isMain as the compile unit
1698 CompileUnitMap[DIUnit.getNode()] = Unit;
1699 CompileUnits.push_back(Unit);
1703 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1704 DIGlobalVariable DI_GV(N);
1706 // If debug information is malformed then ignore it.
1707 if (DI_GV.Verify() == false)
1710 // Check for pre-existence.
1711 if (ModuleCU->getDIE(DI_GV.getNode()))
1714 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1719 ModuleCU->insertDIE(N, VariableDie);
1721 // Add to context owner.
1722 DIDescriptor GVContext = DI_GV.getContext();
1723 // Do not create specification DIE if context is either compile unit
1725 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1726 && !GVContext.isSubprogram()) {
1727 // Create specification DIE.
1728 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1729 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1730 dwarf::DW_FORM_ref4, VariableDie);
1731 DIEBlock *Block = new DIEBlock();
1732 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1733 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1734 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1735 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1736 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1737 ModuleCU->addDie(VariableSpecDIE);
1739 DIEBlock *Block = new DIEBlock();
1740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1741 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1742 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1743 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1745 addToContextOwner(VariableDie, GVContext);
1747 // Expose as global. FIXME - need to check external flag.
1748 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1750 DIType GTy = DI_GV.getType();
1751 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1752 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1753 assert (Entry && "Missing global type!");
1754 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1759 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1762 // Check for pre-existence.
1763 if (ModuleCU->getDIE(N))
1766 if (!SP.isDefinition())
1767 // This is a method declaration which will be handled while constructing
1771 DIE *SubprogramDie = createSubprogramDIE(SP);
1774 ModuleCU->insertDIE(N, SubprogramDie);
1776 // Add to context owner.
1777 addToContextOwner(SubprogramDie, SP.getContext());
1779 // Expose as global.
1780 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1785 /// beginModule - Emit all Dwarf sections that should come prior to the
1786 /// content. Create global DIEs and emit initial debug info sections.
1787 /// This is inovked by the target AsmPrinter.
1788 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1791 if (TimePassesIsEnabled)
1792 DebugTimer->startTimer();
1794 if (!MAI->doesSupportDebugInformation())
1797 DebugInfoFinder DbgFinder;
1798 DbgFinder.processModule(*M);
1800 // Create all the compile unit DIEs.
1801 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1802 E = DbgFinder.compile_unit_end(); I != E; ++I)
1803 constructCompileUnit(*I);
1805 if (CompileUnits.empty()) {
1806 if (TimePassesIsEnabled)
1807 DebugTimer->stopTimer();
1812 // If main compile unit for this module is not seen than randomly
1813 // select first compile unit.
1815 ModuleCU = CompileUnits[0];
1817 // Create DIEs for each subprogram.
1818 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1819 E = DbgFinder.subprogram_end(); I != E; ++I)
1820 constructSubprogramDIE(*I);
1822 // Create DIEs for each global variable.
1823 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1824 E = DbgFinder.global_variable_end(); I != E; ++I)
1825 constructGlobalVariableDIE(*I);
1829 MMI->setDebugInfoAvailability(true);
1831 // Prime section data.
1832 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1834 // Print out .file directives to specify files for .loc directives. These are
1835 // printed out early so that they precede any .loc directives.
1836 if (MAI->hasDotLocAndDotFile()) {
1837 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1838 // Remember source id starts at 1.
1839 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1840 // FIXME: don't use sys::path for this! This should not depend on the
1842 sys::Path FullPath(getSourceDirectoryName(Id.first));
1844 FullPath.appendComponent(getSourceFileName(Id.second));
1845 assert(AppendOk && "Could not append filename to directory!");
1847 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1851 // Emit initial sections
1854 if (TimePassesIsEnabled)
1855 DebugTimer->stopTimer();
1858 /// endModule - Emit all Dwarf sections that should come after the content.
1860 void DwarfDebug::endModule() {
1864 if (TimePassesIsEnabled)
1865 DebugTimer->startTimer();
1867 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1868 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1869 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1871 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1874 // Insert top level DIEs.
1875 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1876 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1877 ModuleCU->getCUDie()->addChild(*TI);
1879 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1880 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1881 DIE *SPDie = CI->first;
1882 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1884 DIE *NDie = ModuleCU->getDIE(N);
1885 if (!NDie) continue;
1886 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1887 // FIXME - This is not the correct approach.
1888 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1891 // Standard sections final addresses.
1892 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1893 EmitLabel("text_end", 0);
1894 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1895 EmitLabel("data_end", 0);
1897 // End text sections.
1898 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1899 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1900 EmitLabel("section_end", i);
1903 // Emit common frame information.
1904 emitCommonDebugFrame();
1906 // Emit function debug frame information
1907 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1908 E = DebugFrames.end(); I != E; ++I)
1909 emitFunctionDebugFrame(*I);
1911 // Compute DIE offsets and sizes.
1912 computeSizeAndOffsets();
1914 // Emit all the DIEs into a debug info section
1917 // Corresponding abbreviations into a abbrev section.
1918 emitAbbreviations();
1920 // Emit source line correspondence into a debug line section.
1923 // Emit info into a debug pubnames section.
1924 emitDebugPubNames();
1926 // Emit info into a debug pubtypes section.
1927 emitDebugPubTypes();
1929 // Emit info into a debug str section.
1932 // Emit info into a debug loc section.
1935 // Emit info into a debug aranges section.
1938 // Emit info into a debug ranges section.
1941 // Emit info into a debug macinfo section.
1944 // Emit inline info.
1945 emitDebugInlineInfo();
1947 if (TimePassesIsEnabled)
1948 DebugTimer->stopTimer();
1951 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1952 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1954 DILocation &ScopeLoc) {
1956 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1958 return AbsDbgVariable;
1960 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1964 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1965 Scope->addVariable(AbsDbgVariable);
1966 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1967 return AbsDbgVariable;
1970 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1971 void DwarfDebug::collectVariableInfo() {
1974 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1975 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1976 VE = VMap.end(); VI != VE; ++VI) {
1977 MDNode *Var = VI->first;
1979 DIVariable DV (Var);
1980 std::pair< unsigned, MDNode *> VP = VI->second;
1981 DILocation ScopeLoc(VP.second);
1984 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1986 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1987 // If variable scope is not found then skip this variable.
1991 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1992 Scope->addVariable(RegVar);
1993 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1995 RegVar->setAbstractVariable(AbsDbgVariable);
1999 /// beginScope - Process beginning of a scope starting at Label.
2000 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
2001 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2002 if (I == DbgScopeBeginMap.end())
2004 ScopeVector &SD = I->second;
2005 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
2007 (*SDI)->setStartLabelID(Label);
2010 /// endScope - Process end of a scope.
2011 void DwarfDebug::endScope(const MachineInstr *MI) {
2012 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2013 if (I == DbgScopeEndMap.end())
2016 unsigned Label = MMI->NextLabelID();
2017 Asm->printLabel(Label);
2020 SmallVector<DbgScope *, 2> &SD = I->second;
2021 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2023 (*SDI)->setEndLabelID(Label);
2027 /// createDbgScope - Create DbgScope for the scope.
2028 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2031 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2034 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2035 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2036 if (DIDescriptor(Scope).isLexicalBlock())
2037 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2041 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2045 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2046 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2047 DILocation DL(InlinedAt);
2048 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2051 /// extractScopeInformation - Scan machine instructions in this function
2052 /// and collect DbgScopes. Return true, if atleast one scope was found.
2053 bool DwarfDebug::extractScopeInformation() {
2054 // If scope information was extracted using .dbg intrinsics then there is not
2055 // any need to extract these information by scanning each instruction.
2056 if (!DbgScopeMap.empty())
2059 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2060 unsigned MIIndex = 0;
2061 // Scan each instruction and create scopes. First build working set of scopes.
2062 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2064 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2066 const MachineInstr *MInsn = II;
2067 MIIndexMap[MInsn] = MIIndex++;
2068 DebugLoc DL = MInsn->getDebugLoc();
2069 if (DL.isUnknown()) continue;
2070 DILocation DLT = MF->getDILocation(DL);
2071 DIScope DLTScope = DLT.getScope();
2072 if (DLTScope.isNull()) continue;
2073 // There is no need to create another DIE for compile unit. For all
2074 // other scopes, create one DbgScope now. This will be translated
2075 // into a scope DIE at the end.
2076 if (DLTScope.isCompileUnit()) continue;
2077 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2082 // Build scope hierarchy using working set of scopes.
2083 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2085 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2087 const MachineInstr *MInsn = II;
2088 DebugLoc DL = MInsn->getDebugLoc();
2089 if (DL.isUnknown()) continue;
2090 DILocation DLT = MF->getDILocation(DL);
2091 DIScope DLTScope = DLT.getScope();
2092 if (DLTScope.isNull()) continue;
2093 // There is no need to create another DIE for compile unit. For all
2094 // other scopes, create one DbgScope now. This will be translated
2095 // into a scope DIE at the end.
2096 if (DLTScope.isCompileUnit()) continue;
2097 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2098 DLT.getOrigLocation().getNode());
2099 Scope->setLastInsn(MInsn);
2103 if (!CurrentFnDbgScope)
2106 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2108 // Each scope has first instruction and last instruction to mark beginning
2109 // and end of a scope respectively. Create an inverse map that list scopes
2110 // starts (and ends) with an instruction. One instruction may start (or end)
2111 // multiple scopes. Ignore scopes that are not reachable.
2112 SmallVector<DbgScope *, 4> WorkList;
2113 WorkList.push_back(CurrentFnDbgScope);
2114 while (!WorkList.empty()) {
2115 DbgScope *S = WorkList.back(); WorkList.pop_back();
2117 SmallVector<DbgScope *, 4> &Children = S->getScopes();
2118 if (!Children.empty())
2119 for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2120 SE = Children.end(); SI != SE; ++SI)
2121 WorkList.push_back(*SI);
2123 if (S->isAbstractScope())
2125 const MachineInstr *MI = S->getFirstInsn();
2126 assert (MI && "DbgScope does not have first instruction!");
2128 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2129 if (IDI != DbgScopeBeginMap.end())
2130 IDI->second.push_back(S);
2132 DbgScopeBeginMap[MI].push_back(S);
2134 MI = S->getLastInsn();
2135 assert (MI && "DbgScope does not have last instruction!");
2136 IDI = DbgScopeEndMap.find(MI);
2137 if (IDI != DbgScopeEndMap.end())
2138 IDI->second.push_back(S);
2140 DbgScopeEndMap[MI].push_back(S);
2143 return !DbgScopeMap.empty();
2146 /// beginFunction - Gather pre-function debug information. Assumes being
2147 /// emitted immediately after the function entry point.
2148 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2151 if (!ShouldEmitDwarfDebug()) return;
2153 if (TimePassesIsEnabled)
2154 DebugTimer->startTimer();
2156 if (!extractScopeInformation())
2159 collectVariableInfo();
2161 // Assumes in correct section after the entry point.
2162 EmitLabel("func_begin", ++SubprogramCount);
2164 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2166 DebugLoc FDL = MF->getDefaultDebugLoc();
2167 if (!FDL.isUnknown()) {
2168 DILocation DLT = MF->getDILocation(FDL);
2169 unsigned LabelID = 0;
2170 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2172 LabelID = recordSourceLine(SP.getLineNumber(), 0,
2173 DLT.getScope().getNode());
2175 LabelID = recordSourceLine(DLT.getLineNumber(),
2176 DLT.getColumnNumber(),
2177 DLT.getScope().getNode());
2178 Asm->printLabel(LabelID);
2181 if (TimePassesIsEnabled)
2182 DebugTimer->stopTimer();
2185 /// endFunction - Gather and emit post-function debug information.
2187 void DwarfDebug::endFunction(const MachineFunction *MF) {
2188 if (!ShouldEmitDwarfDebug()) return;
2190 if (TimePassesIsEnabled)
2191 DebugTimer->startTimer();
2193 if (DbgScopeMap.empty())
2196 if (CurrentFnDbgScope) {
2197 // Define end label for subprogram.
2198 EmitLabel("func_end", SubprogramCount);
2200 // Get function line info.
2201 if (!Lines.empty()) {
2202 // Get section line info.
2203 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2204 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2205 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2206 // Append the function info to section info.
2207 SectionLineInfos.insert(SectionLineInfos.end(),
2208 Lines.begin(), Lines.end());
2211 // Construct abstract scopes.
2212 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2213 AE = AbstractScopesList.end(); AI != AE; ++AI)
2214 constructScopeDIE(*AI);
2216 constructScopeDIE(CurrentFnDbgScope);
2218 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2219 MMI->getFrameMoves()));
2223 CurrentFnDbgScope = NULL;
2224 DbgScopeMap.clear();
2225 DbgScopeBeginMap.clear();
2226 DbgScopeEndMap.clear();
2227 ConcreteScopes.clear();
2228 AbstractScopesList.clear();
2231 if (TimePassesIsEnabled)
2232 DebugTimer->stopTimer();
2235 /// recordSourceLine - Records location information and associates it with a
2236 /// label. Returns a unique label ID used to generate a label and provide
2237 /// correspondence to the source line list.
2238 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2243 if (TimePassesIsEnabled)
2244 DebugTimer->startTimer();
2249 DIDescriptor Scope(S);
2250 if (Scope.isCompileUnit()) {
2251 DICompileUnit CU(S);
2252 Dir = CU.getDirectory();
2253 Fn = CU.getFilename();
2254 } else if (Scope.isSubprogram()) {
2256 Dir = SP.getDirectory();
2257 Fn = SP.getFilename();
2258 } else if (Scope.isLexicalBlock()) {
2259 DILexicalBlock DB(S);
2260 Dir = DB.getDirectory();
2261 Fn = DB.getFilename();
2263 assert (0 && "Unexpected scope info");
2265 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2266 unsigned ID = MMI->NextLabelID();
2267 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2269 if (TimePassesIsEnabled)
2270 DebugTimer->stopTimer();
2275 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2276 /// timed. Look up the source id with the given directory and source file
2277 /// names. If none currently exists, create a new id and insert it in the
2278 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2280 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2281 const std::string &FileName) {
2282 if (TimePassesIsEnabled)
2283 DebugTimer->startTimer();
2285 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2287 if (TimePassesIsEnabled)
2288 DebugTimer->stopTimer();
2293 //===----------------------------------------------------------------------===//
2295 //===----------------------------------------------------------------------===//
2297 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2300 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2301 // Get the children.
2302 const std::vector<DIE *> &Children = Die->getChildren();
2304 // If not last sibling and has children then add sibling offset attribute.
2305 if (!Last && !Children.empty()) Die->addSiblingOffset();
2307 // Record the abbreviation.
2308 assignAbbrevNumber(Die->getAbbrev());
2310 // Get the abbreviation for this DIE.
2311 unsigned AbbrevNumber = Die->getAbbrevNumber();
2312 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2315 Die->setOffset(Offset);
2317 // Start the size with the size of abbreviation code.
2318 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2320 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2321 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2323 // Size the DIE attribute values.
2324 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2325 // Size attribute value.
2326 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2328 // Size the DIE children if any.
2329 if (!Children.empty()) {
2330 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2331 "Children flag not set");
2333 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2334 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2336 // End of children marker.
2337 Offset += sizeof(int8_t);
2340 Die->setSize(Offset - Die->getOffset());
2344 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2346 void DwarfDebug::computeSizeAndOffsets() {
2347 // Compute size of compile unit header.
2348 static unsigned Offset =
2349 sizeof(int32_t) + // Length of Compilation Unit Info
2350 sizeof(int16_t) + // DWARF version number
2351 sizeof(int32_t) + // Offset Into Abbrev. Section
2352 sizeof(int8_t); // Pointer Size (in bytes)
2354 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2355 CompileUnitOffsets[ModuleCU] = 0;
2358 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2359 /// tools to recognize the object file contains Dwarf information.
2360 void DwarfDebug::emitInitial() {
2361 // Check to see if we already emitted intial headers.
2362 if (didInitial) return;
2365 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2367 // Dwarf sections base addresses.
2368 if (MAI->doesDwarfRequireFrameSection()) {
2369 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2370 EmitLabel("section_debug_frame", 0);
2373 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2374 EmitLabel("section_info", 0);
2375 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2376 EmitLabel("section_abbrev", 0);
2377 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2378 EmitLabel("section_aranges", 0);
2380 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2381 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2382 EmitLabel("section_macinfo", 0);
2385 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2386 EmitLabel("section_line", 0);
2387 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2388 EmitLabel("section_loc", 0);
2389 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2390 EmitLabel("section_pubnames", 0);
2391 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2392 EmitLabel("section_pubtypes", 0);
2393 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2394 EmitLabel("section_str", 0);
2395 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2396 EmitLabel("section_ranges", 0);
2398 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2399 EmitLabel("text_begin", 0);
2400 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2401 EmitLabel("data_begin", 0);
2404 /// emitDIE - Recusively Emits a debug information entry.
2406 void DwarfDebug::emitDIE(DIE *Die) {
2407 // Get the abbreviation for this DIE.
2408 unsigned AbbrevNumber = Die->getAbbrevNumber();
2409 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2413 // Emit the code (index) for the abbreviation.
2414 if (Asm->VerboseAsm)
2415 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2416 Twine::utohexstr(Die->getOffset()) + ":0x" +
2417 Twine::utohexstr(Die->getSize()) + " " +
2418 dwarf::TagString(Abbrev->getTag()));
2419 EmitULEB128(AbbrevNumber);
2421 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2422 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2424 // Emit the DIE attribute values.
2425 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2426 unsigned Attr = AbbrevData[i].getAttribute();
2427 unsigned Form = AbbrevData[i].getForm();
2428 assert(Form && "Too many attributes for DIE (check abbreviation)");
2430 if (Asm->VerboseAsm)
2431 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2434 case dwarf::DW_AT_sibling:
2435 Asm->EmitInt32(Die->getSiblingOffset());
2437 case dwarf::DW_AT_abstract_origin: {
2438 DIEEntry *E = cast<DIEEntry>(Values[i]);
2439 DIE *Origin = E->getEntry();
2440 unsigned Addr = Origin->getOffset();
2441 Asm->EmitInt32(Addr);
2445 // Emit an attribute using the defined form.
2446 Values[i]->EmitValue(this, Form);
2447 O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2452 // Emit the DIE children if any.
2453 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2454 const std::vector<DIE *> &Children = Die->getChildren();
2456 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2457 emitDIE(Children[j]);
2459 Asm->EmitInt8(0); EOL("End Of Children Mark");
2463 /// emitDebugInfo - Emit the debug info section.
2465 void DwarfDebug::emitDebugInfo() {
2466 // Start debug info section.
2467 Asm->OutStreamer.SwitchSection(
2468 Asm->getObjFileLowering().getDwarfInfoSection());
2469 DIE *Die = ModuleCU->getCUDie();
2471 // Emit the compile units header.
2472 EmitLabel("info_begin", ModuleCU->getID());
2474 // Emit size of content not including length itself
2475 unsigned ContentSize = Die->getSize() +
2476 sizeof(int16_t) + // DWARF version number
2477 sizeof(int32_t) + // Offset Into Abbrev. Section
2478 sizeof(int8_t) + // Pointer Size (in bytes)
2479 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2481 Asm->EmitInt32(ContentSize); EOL("Length of Compilation Unit Info");
2482 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2483 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2484 EOL("Offset Into Abbrev. Section");
2485 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2488 // FIXME - extra padding for gdb bug.
2489 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2490 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2491 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2492 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2493 EmitLabel("info_end", ModuleCU->getID());
2497 /// emitAbbreviations - Emit the abbreviation section.
2499 void DwarfDebug::emitAbbreviations() const {
2500 // Check to see if it is worth the effort.
2501 if (!Abbreviations.empty()) {
2502 // Start the debug abbrev section.
2503 Asm->OutStreamer.SwitchSection(
2504 Asm->getObjFileLowering().getDwarfAbbrevSection());
2506 EmitLabel("abbrev_begin", 0);
2508 // For each abbrevation.
2509 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2510 // Get abbreviation data
2511 const DIEAbbrev *Abbrev = Abbreviations[i];
2513 // Emit the abbrevations code (base 1 index.)
2514 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2516 // Emit the abbreviations data.
2521 // Mark end of abbreviations.
2522 EmitULEB128(0, "EOM(3)");
2524 EmitLabel("abbrev_end", 0);
2529 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2530 /// the line matrix.
2532 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2533 // Define last address of section.
2534 Asm->EmitInt8(0); EOL("Extended Op");
2535 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2536 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2537 EmitReference("section_end", SectionEnd); EOL("Section end label");
2539 // Mark end of matrix.
2540 Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2545 /// emitDebugLines - Emit source line information.
2547 void DwarfDebug::emitDebugLines() {
2548 // If the target is using .loc/.file, the assembler will be emitting the
2549 // .debug_line table automatically.
2550 if (MAI->hasDotLocAndDotFile())
2553 // Minimum line delta, thus ranging from -10..(255-10).
2554 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2555 // Maximum line delta, thus ranging from -10..(255-10).
2556 const int MaxLineDelta = 255 + MinLineDelta;
2558 // Start the dwarf line section.
2559 Asm->OutStreamer.SwitchSection(
2560 Asm->getObjFileLowering().getDwarfLineSection());
2562 // Construct the section header.
2563 EmitDifference("line_end", 0, "line_begin", 0, true);
2564 EOL("Length of Source Line Info");
2565 EmitLabel("line_begin", 0);
2567 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2569 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2570 EOL("Prolog Length");
2571 EmitLabel("line_prolog_begin", 0);
2573 Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2574 Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2575 Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2576 Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2577 Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2579 // Line number standard opcode encodings argument count
2580 Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2581 Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2582 Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2583 Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2584 Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2585 Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2586 Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2587 Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2588 Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2590 // Emit directories.
2591 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2592 const std::string &Dir = getSourceDirectoryName(DI);
2593 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2594 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2597 Asm->EmitInt8(0); EOL("End of directories");
2600 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2601 // Remember source id starts at 1.
2602 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2603 const std::string &FN = getSourceFileName(Id.second);
2604 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2605 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2607 EmitULEB128(Id.first, "Directory #");
2608 EmitULEB128(0, "Mod date");
2609 EmitULEB128(0, "File size");
2612 Asm->EmitInt8(0); EOL("End of files");
2614 EmitLabel("line_prolog_end", 0);
2616 // A sequence for each text section.
2617 unsigned SecSrcLinesSize = SectionSourceLines.size();
2619 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2620 // Isolate current sections line info.
2621 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2623 /*if (Asm->isVerbose()) {
2624 const MCSection *S = SectionMap[j + 1];
2625 O << '\t' << MAI->getCommentString() << " Section"
2626 << S->getName() << '\n';
2630 // Dwarf assumes we start with first line of first source file.
2631 unsigned Source = 1;
2634 // Construct rows of the address, source, line, column matrix.
2635 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2636 const SrcLineInfo &LineInfo = LineInfos[i];
2637 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2638 if (!LabelID) continue;
2640 if (LineInfo.getLine() == 0) continue;
2642 if (!Asm->isVerbose())
2645 std::pair<unsigned, unsigned> SourceID =
2646 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2647 O << '\t' << MAI->getCommentString() << ' '
2648 << getSourceDirectoryName(SourceID.first) << '/'
2649 << getSourceFileName(SourceID.second)
2650 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2653 // Define the line address.
2654 Asm->EmitInt8(0); EOL("Extended Op");
2655 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2656 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2657 EmitReference("label", LabelID); EOL("Location label");
2659 // If change of source, then switch to the new source.
2660 if (Source != LineInfo.getSourceID()) {
2661 Source = LineInfo.getSourceID();
2662 Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2663 EmitULEB128(Source, "New Source");
2666 // If change of line.
2667 if (Line != LineInfo.getLine()) {
2668 // Determine offset.
2669 int Offset = LineInfo.getLine() - Line;
2670 int Delta = Offset - MinLineDelta;
2673 Line = LineInfo.getLine();
2675 // If delta is small enough and in range...
2676 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2677 // ... then use fast opcode.
2678 Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2680 // ... otherwise use long hand.
2681 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2682 EOL("DW_LNS_advance_line");
2683 EmitSLEB128(Offset, "Line Offset");
2684 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2687 // Copy the previous row (different address or source)
2688 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2692 emitEndOfLineMatrix(j + 1);
2695 if (SecSrcLinesSize == 0)
2696 // Because we're emitting a debug_line section, we still need a line
2697 // table. The linker and friends expect it to exist. If there's nothing to
2698 // put into it, emit an empty table.
2699 emitEndOfLineMatrix(1);
2701 EmitLabel("line_end", 0);
2705 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2707 void DwarfDebug::emitCommonDebugFrame() {
2708 if (!MAI->doesDwarfRequireFrameSection())
2712 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2713 TargetFrameInfo::StackGrowsUp ?
2714 TD->getPointerSize() : -TD->getPointerSize();
2716 // Start the dwarf frame section.
2717 Asm->OutStreamer.SwitchSection(
2718 Asm->getObjFileLowering().getDwarfFrameSection());
2720 EmitLabel("debug_frame_common", 0);
2721 EmitDifference("debug_frame_common_end", 0,
2722 "debug_frame_common_begin", 0, true);
2723 EOL("Length of Common Information Entry");
2725 EmitLabel("debug_frame_common_begin", 0);
2726 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2727 EOL("CIE Identifier Tag");
2728 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2730 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2731 EOL("CIE Augmentation");
2732 EmitULEB128(1, "CIE Code Alignment Factor");
2733 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2734 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2735 EOL("CIE RA Column");
2737 std::vector<MachineMove> Moves;
2738 RI->getInitialFrameState(Moves);
2740 EmitFrameMoves(NULL, 0, Moves, false);
2742 Asm->EmitAlignment(2, 0, 0, false);
2743 EmitLabel("debug_frame_common_end", 0);
2747 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2750 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2751 if (!MAI->doesDwarfRequireFrameSection())
2754 // Start the dwarf frame section.
2755 Asm->OutStreamer.SwitchSection(
2756 Asm->getObjFileLowering().getDwarfFrameSection());
2758 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2759 "debug_frame_begin", DebugFrameInfo.Number, true);
2760 EOL("Length of Frame Information Entry");
2762 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2764 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2766 EOL("FDE CIE offset");
2768 EmitReference("func_begin", DebugFrameInfo.Number);
2769 EOL("FDE initial location");
2770 EmitDifference("func_end", DebugFrameInfo.Number,
2771 "func_begin", DebugFrameInfo.Number);
2772 EOL("FDE address range");
2774 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2777 Asm->EmitAlignment(2, 0, 0, false);
2778 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2782 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2784 void DwarfDebug::emitDebugPubNames() {
2785 // Start the dwarf pubnames section.
2786 Asm->OutStreamer.SwitchSection(
2787 Asm->getObjFileLowering().getDwarfPubNamesSection());
2789 EmitDifference("pubnames_end", ModuleCU->getID(),
2790 "pubnames_begin", ModuleCU->getID(), true);
2791 EOL("Length of Public Names Info");
2793 EmitLabel("pubnames_begin", ModuleCU->getID());
2795 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2797 EmitSectionOffset("info_begin", "section_info",
2798 ModuleCU->getID(), 0, true, false);
2799 EOL("Offset of Compilation Unit Info");
2801 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2803 EOL("Compilation Unit Length");
2805 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2806 for (StringMap<DIE*>::const_iterator
2807 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2808 const char *Name = GI->getKeyData();
2809 DIE * Entity = GI->second;
2811 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2813 if (Asm->VerboseAsm)
2814 Asm->OutStreamer.AddComment("External Name");
2815 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2818 Asm->EmitInt32(0); EOL("End Mark");
2819 EmitLabel("pubnames_end", ModuleCU->getID());
2823 void DwarfDebug::emitDebugPubTypes() {
2824 // Start the dwarf pubnames section.
2825 Asm->OutStreamer.SwitchSection(
2826 Asm->getObjFileLowering().getDwarfPubTypesSection());
2827 EmitDifference("pubtypes_end", ModuleCU->getID(),
2828 "pubtypes_begin", ModuleCU->getID(), true);
2829 EOL("Length of Public Types Info");
2831 EmitLabel("pubtypes_begin", ModuleCU->getID());
2833 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2834 Asm->EmitInt16(dwarf::DWARF_VERSION);
2836 EmitSectionOffset("info_begin", "section_info",
2837 ModuleCU->getID(), 0, true, false);
2838 EOL("Offset of Compilation ModuleCU Info");
2840 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2842 EOL("Compilation ModuleCU Length");
2844 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2845 for (StringMap<DIE*>::const_iterator
2846 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2847 const char *Name = GI->getKeyData();
2848 DIE * Entity = GI->second;
2850 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2851 Asm->EmitInt32(Entity->getOffset());
2853 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2854 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2857 Asm->EmitInt32(0); EOL("End Mark");
2858 EmitLabel("pubtypes_end", ModuleCU->getID());
2862 /// emitDebugStr - Emit visible names into a debug str section.
2864 void DwarfDebug::emitDebugStr() {
2865 // Check to see if it is worth the effort.
2866 if (!StringPool.empty()) {
2867 // Start the dwarf str section.
2868 Asm->OutStreamer.SwitchSection(
2869 Asm->getObjFileLowering().getDwarfStrSection());
2871 // For each of strings in the string pool.
2872 for (unsigned StringID = 1, N = StringPool.size();
2873 StringID <= N; ++StringID) {
2874 // Emit a label for reference from debug information entries.
2875 EmitLabel("string", StringID);
2877 // Emit the string itself.
2878 const std::string &String = StringPool[StringID];
2879 Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2886 /// emitDebugLoc - Emit visible names into a debug loc section.
2888 void DwarfDebug::emitDebugLoc() {
2889 // Start the dwarf loc section.
2890 Asm->OutStreamer.SwitchSection(
2891 Asm->getObjFileLowering().getDwarfLocSection());
2894 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2896 void DwarfDebug::EmitDebugARanges() {
2897 // Start the dwarf aranges section.
2898 Asm->OutStreamer.SwitchSection(
2899 Asm->getObjFileLowering().getDwarfARangesSection());
2903 CompileUnit *Unit = GetBaseCompileUnit();
2905 // Don't include size of length
2906 Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2908 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2910 EmitReference("info_begin", Unit->getID());
2911 EOL("Offset of Compilation Unit Info");
2913 Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2915 Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2917 Asm->EmitInt16(0); EOL("Pad (1)");
2918 Asm->EmitInt16(0); EOL("Pad (2)");
2921 EmitReference("text_begin", 0); EOL("Address");
2922 EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
2924 Asm->EmitInt32(0); EOL("EOM (1)");
2925 Asm->EmitInt32(0); EOL("EOM (2)");
2929 /// emitDebugRanges - Emit visible names into a debug ranges section.
2931 void DwarfDebug::emitDebugRanges() {
2932 // Start the dwarf ranges section.
2933 Asm->OutStreamer.SwitchSection(
2934 Asm->getObjFileLowering().getDwarfRangesSection());
2937 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2939 void DwarfDebug::emitDebugMacInfo() {
2940 if (const MCSection *LineInfo =
2941 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2942 // Start the dwarf macinfo section.
2943 Asm->OutStreamer.SwitchSection(LineInfo);
2947 /// emitDebugInlineInfo - Emit inline info using following format.
2949 /// 1. length of section
2950 /// 2. Dwarf version number
2951 /// 3. address size.
2953 /// Entries (one "entry" for each function that was inlined):
2955 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2956 /// otherwise offset into __debug_str for regular function name.
2957 /// 2. offset into __debug_str section for regular function name.
2958 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2959 /// instances for the function.
2961 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2962 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2963 /// __debug_info section, and the low_pc is the starting address for the
2964 /// inlining instance.
2965 void DwarfDebug::emitDebugInlineInfo() {
2966 if (!MAI->doesDwarfUsesInlineInfoSection())
2972 Asm->OutStreamer.SwitchSection(
2973 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2975 EmitDifference("debug_inlined_end", 1,
2976 "debug_inlined_begin", 1, true);
2977 EOL("Length of Debug Inlined Information Entry");
2979 EmitLabel("debug_inlined_begin", 1);
2981 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2982 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2984 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2985 E = InlinedSPNodes.end(); I != E; ++I) {
2988 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2989 = InlineInfo.find(Node);
2990 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2991 DISubprogram SP(Node);
2992 StringRef LName = SP.getLinkageName();
2993 StringRef Name = SP.getName();
2995 if (LName.empty()) {
2996 Asm->OutStreamer.EmitBytes(Name, 0);
2997 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2999 EmitSectionOffset("string", "section_str",
3000 StringPool.idFor(getRealLinkageName(LName)), false, true);
3002 EOL("MIPS linkage name");
3003 EmitSectionOffset("string", "section_str",
3004 StringPool.idFor(Name), false, true);
3005 EOL("Function name");
3006 EmitULEB128(Labels.size(), "Inline count");
3008 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3009 LE = Labels.end(); LI != LE; ++LI) {
3010 DIE *SP = LI->second;
3011 Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
3013 if (TD->getPointerSize() == sizeof(int32_t))
3014 O << MAI->getData32bitsDirective();
3016 O << MAI->getData64bitsDirective();
3018 PrintLabelName("label", LI->first); EOL("low_pc");
3022 EmitLabel("debug_inlined_end", 1);