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/STLExtras.h"
27 #include "llvm/ADT/StringExtras.h"
28 #include "llvm/Support/Debug.h"
29 #include "llvm/Support/ErrorHandling.h"
30 #include "llvm/Support/ValueHandle.h"
31 #include "llvm/Support/FormattedStream.h"
32 #include "llvm/Support/Timer.h"
33 #include "llvm/System/Path.h"
36 //===----------------------------------------------------------------------===//
38 /// Configuration values for initial hash set sizes (log2).
40 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
44 //===----------------------------------------------------------------------===//
45 /// CompileUnit - This dwarf writer support class manages information associate
46 /// with a source file.
48 /// ID - File identifier for source.
52 /// Die - Compile unit debug information entry.
54 const OwningPtr<DIE> CUDie;
56 /// IndexTyDie - An anonymous type for index type. Owned by CUDie
59 /// GVToDieMap - Tracks the mapping of unit level debug informaton
60 /// variables to debug information entries.
61 /// FIXME : Rename GVToDieMap -> NodeToDieMap
62 DenseMap<MDNode *, DIE *> GVToDieMap;
64 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
65 /// descriptors to debug information entries using a DIEEntry proxy.
67 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
69 /// Globals - A map of globally visible named entities for this unit.
71 StringMap<DIE*> Globals;
73 /// GlobalTypes - A map of globally visible types for this unit.
75 StringMap<DIE*> GlobalTypes;
78 CompileUnit(unsigned I, DIE *D)
79 : ID(I), CUDie(D), IndexTyDie(0) {}
82 unsigned getID() const { return ID; }
83 DIE* getCUDie() const { return CUDie.get(); }
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 // Scopes defined in scope. Contents not owned.
178 SmallVector<DbgScope *, 4> Scopes;
179 // Variables declared in scope. Contents owned.
180 SmallVector<DbgVariable *, 8> Variables;
182 // Private state for dump()
183 mutable unsigned IndentLevel;
185 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
186 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
187 StartLabelID(0), EndLabelID(0),
188 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
192 DbgScope *getParent() const { return Parent; }
193 void setParent(DbgScope *P) { Parent = P; }
194 DIDescriptor getDesc() const { return Desc; }
195 MDNode *getInlinedAt() const {
196 return InlinedAtLocation;
198 MDNode *getScopeNode() const { return Desc.getNode(); }
199 unsigned getStartLabelID() const { return StartLabelID; }
200 unsigned getEndLabelID() const { return EndLabelID; }
201 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
202 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
203 void setStartLabelID(unsigned S) { StartLabelID = S; }
204 void setEndLabelID(unsigned E) { EndLabelID = E; }
205 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
206 const MachineInstr *getLastInsn() { return LastInsn; }
207 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
208 void setAbstractScope() { AbstractScope = true; }
209 bool isAbstractScope() const { return AbstractScope; }
210 const MachineInstr *getFirstInsn() { return FirstInsn; }
212 /// addScope - Add a scope to the scope.
214 void addScope(DbgScope *S) { Scopes.push_back(S); }
216 /// addVariable - Add a variable to the scope.
218 void addVariable(DbgVariable *V) { Variables.push_back(V); }
220 void fixInstructionMarkers(DenseMap<const MachineInstr *,
221 unsigned> &MIIndexMap) {
222 assert (getFirstInsn() && "First instruction is missing!");
224 // Use the end of last child scope as end of this scope.
225 const SmallVector<DbgScope *, 4> &Scopes = getScopes();
226 const MachineInstr *LastInsn = getFirstInsn();
228 if (Scopes.empty()) {
229 assert (getLastInsn() && "Inner most scope does not have last insn!");
232 for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(),
233 SE = Scopes.end(); SI != SE; ++SI) {
235 DS->fixInstructionMarkers(MIIndexMap);
236 const MachineInstr *DSLastInsn = DS->getLastInsn();
237 unsigned DSI = MIIndexMap[DSLastInsn];
239 LastInsn = DSLastInsn;
244 unsigned CurrentLastInsnIndex = 0;
245 if (const MachineInstr *CL = getLastInsn())
246 CurrentLastInsnIndex = MIIndexMap[CL];
247 unsigned FIndex = MIIndexMap[getFirstInsn()];
249 // Set LastInsn as the last instruction for this scope only if
251 // 1) this scope's first instruction and
252 // 2) current last instruction for this scope, if any.
253 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
254 setLastInsn(LastInsn);
263 void DbgScope::dump() const {
264 raw_ostream &err = dbgs();
265 err.indent(IndentLevel);
266 MDNode *N = Desc.getNode();
268 err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
270 err << "Abstract Scope\n";
274 err << "Children ...\n";
275 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
276 if (Scopes[i] != this)
283 DbgScope::~DbgScope() {
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 do not have 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 const 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 const 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;
1702 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1703 DIGlobalVariable DI_GV(N);
1705 // If debug information is malformed then ignore it.
1706 if (DI_GV.Verify() == false)
1709 // Check for pre-existence.
1710 if (ModuleCU->getDIE(DI_GV.getNode()))
1713 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1718 ModuleCU->insertDIE(N, VariableDie);
1720 // Add to context owner.
1721 DIDescriptor GVContext = DI_GV.getContext();
1722 // Do not create specification DIE if context is either compile unit
1724 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1725 && !GVContext.isSubprogram()) {
1726 // Create specification DIE.
1727 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1728 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1729 dwarf::DW_FORM_ref4, VariableDie);
1730 DIEBlock *Block = new DIEBlock();
1731 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1732 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1733 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1734 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1735 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1736 ModuleCU->addDie(VariableSpecDIE);
1738 DIEBlock *Block = new DIEBlock();
1739 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1740 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1741 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1742 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1744 addToContextOwner(VariableDie, GVContext);
1746 // Expose as global. FIXME - need to check external flag.
1747 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1749 DIType GTy = DI_GV.getType();
1750 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1751 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1752 assert (Entry && "Missing global type!");
1753 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1758 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1761 // Check for pre-existence.
1762 if (ModuleCU->getDIE(N))
1765 if (!SP.isDefinition())
1766 // This is a method declaration which will be handled while constructing
1770 DIE *SubprogramDie = createSubprogramDIE(SP);
1773 ModuleCU->insertDIE(N, SubprogramDie);
1775 // Add to context owner.
1776 addToContextOwner(SubprogramDie, SP.getContext());
1778 // Expose as global.
1779 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1784 /// beginModule - Emit all Dwarf sections that should come prior to the
1785 /// content. Create global DIEs and emit initial debug info sections.
1786 /// This is inovked by the target AsmPrinter.
1787 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1790 if (TimePassesIsEnabled)
1791 DebugTimer->startTimer();
1793 if (!MAI->doesSupportDebugInformation())
1796 DebugInfoFinder DbgFinder;
1797 DbgFinder.processModule(*M);
1799 // Create all the compile unit DIEs.
1800 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1801 E = DbgFinder.compile_unit_end(); I != E; ++I)
1802 constructCompileUnit(*I);
1804 if (CompileUnitMap.empty()) {
1805 if (TimePassesIsEnabled)
1806 DebugTimer->stopTimer();
1811 // If main compile unit for this module is not seen than randomly
1812 // select first compile unit.
1814 ModuleCU = CompileUnitMap.begin()->second;
1816 // Create DIEs for each subprogram.
1817 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1818 E = DbgFinder.subprogram_end(); I != E; ++I)
1819 constructSubprogramDIE(*I);
1821 // Create DIEs for each global variable.
1822 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1823 E = DbgFinder.global_variable_end(); I != E; ++I)
1824 constructGlobalVariableDIE(*I);
1828 MMI->setDebugInfoAvailability(true);
1830 // Prime section data.
1831 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1833 // Print out .file directives to specify files for .loc directives. These are
1834 // printed out early so that they precede any .loc directives.
1835 if (MAI->hasDotLocAndDotFile()) {
1836 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1837 // Remember source id starts at 1.
1838 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1839 // FIXME: don't use sys::path for this! This should not depend on the
1841 sys::Path FullPath(getSourceDirectoryName(Id.first));
1843 FullPath.appendComponent(getSourceFileName(Id.second));
1844 assert(AppendOk && "Could not append filename to directory!");
1846 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1850 // Emit initial sections
1853 if (TimePassesIsEnabled)
1854 DebugTimer->stopTimer();
1857 /// endModule - Emit all Dwarf sections that should come after the content.
1859 void DwarfDebug::endModule() {
1863 if (TimePassesIsEnabled)
1864 DebugTimer->startTimer();
1866 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1867 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1868 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1870 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1873 // Insert top level DIEs.
1874 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1875 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1876 ModuleCU->getCUDie()->addChild(*TI);
1878 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1879 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1880 DIE *SPDie = CI->first;
1881 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1883 DIE *NDie = ModuleCU->getDIE(N);
1884 if (!NDie) continue;
1885 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1886 // FIXME - This is not the correct approach.
1887 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1890 // Standard sections final addresses.
1891 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1892 EmitLabel("text_end", 0);
1893 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1894 EmitLabel("data_end", 0);
1896 // End text sections.
1897 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1898 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1899 EmitLabel("section_end", i);
1902 // Emit common frame information.
1903 emitCommonDebugFrame();
1905 // Emit function debug frame information
1906 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1907 E = DebugFrames.end(); I != E; ++I)
1908 emitFunctionDebugFrame(*I);
1910 // Compute DIE offsets and sizes.
1911 computeSizeAndOffsets();
1913 // Emit all the DIEs into a debug info section
1916 // Corresponding abbreviations into a abbrev section.
1917 emitAbbreviations();
1919 // Emit source line correspondence into a debug line section.
1922 // Emit info into a debug pubnames section.
1923 emitDebugPubNames();
1925 // Emit info into a debug pubtypes section.
1926 emitDebugPubTypes();
1928 // Emit info into a debug str section.
1931 // Emit info into a debug loc section.
1934 // Emit info into a debug aranges section.
1937 // Emit info into a debug ranges section.
1940 // Emit info into a debug macinfo section.
1943 // Emit inline info.
1944 emitDebugInlineInfo();
1946 // Clear debug info in preparation for the next Module.
1948 DeleteContainerSeconds(CompileUnitMap);
1950 if (TimePassesIsEnabled)
1951 DebugTimer->stopTimer();
1954 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1955 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1957 DILocation &ScopeLoc) {
1959 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1961 return AbsDbgVariable;
1963 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1967 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1968 Scope->addVariable(AbsDbgVariable);
1969 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1970 return AbsDbgVariable;
1973 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1974 void DwarfDebug::collectVariableInfo() {
1977 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1978 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1979 VE = VMap.end(); VI != VE; ++VI) {
1980 MDNode *Var = VI->first;
1982 DIVariable DV (Var);
1983 std::pair< unsigned, MDNode *> VP = VI->second;
1984 DILocation ScopeLoc(VP.second);
1987 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1989 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1990 // If variable scope is not found then skip this variable.
1994 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1995 Scope->addVariable(RegVar);
1996 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1998 RegVar->setAbstractVariable(AbsDbgVariable);
2002 /// beginScope - Process beginning of a scope starting at Label.
2003 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
2004 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2005 if (I == DbgScopeBeginMap.end())
2007 ScopeVector &SD = I->second;
2008 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
2010 (*SDI)->setStartLabelID(Label);
2013 /// endScope - Process end of a scope.
2014 void DwarfDebug::endScope(const MachineInstr *MI) {
2015 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2016 if (I == DbgScopeEndMap.end())
2019 unsigned Label = MMI->NextLabelID();
2020 Asm->printLabel(Label);
2023 SmallVector<DbgScope *, 2> &SD = I->second;
2024 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2026 (*SDI)->setEndLabelID(Label);
2030 /// createDbgScope - Create DbgScope for the scope.
2031 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2034 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2037 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2038 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2039 if (DIDescriptor(Scope).isLexicalBlock())
2040 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2044 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2048 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2049 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2050 DILocation DL(InlinedAt);
2051 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2054 /// extractScopeInformation - Scan machine instructions in this function
2055 /// and collect DbgScopes. Return true, if atleast one scope was found.
2056 bool DwarfDebug::extractScopeInformation() {
2057 // If scope information was extracted using .dbg intrinsics then there is not
2058 // any need to extract these information by scanning each instruction.
2059 if (!DbgScopeMap.empty())
2062 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2063 unsigned MIIndex = 0;
2064 // Scan each instruction and create scopes. First build working set of scopes.
2065 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2067 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2069 const MachineInstr *MInsn = II;
2070 MIIndexMap[MInsn] = MIIndex++;
2071 DebugLoc DL = MInsn->getDebugLoc();
2072 if (DL.isUnknown()) continue;
2073 DILocation DLT = MF->getDILocation(DL);
2074 DIScope DLTScope = DLT.getScope();
2075 if (DLTScope.isNull()) continue;
2076 // There is no need to create another DIE for compile unit. For all
2077 // other scopes, create one DbgScope now. This will be translated
2078 // into a scope DIE at the end.
2079 if (DLTScope.isCompileUnit()) continue;
2080 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2085 // Build scope hierarchy using working set of scopes.
2086 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2088 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2090 const MachineInstr *MInsn = II;
2091 DebugLoc DL = MInsn->getDebugLoc();
2092 if (DL.isUnknown()) continue;
2093 DILocation DLT = MF->getDILocation(DL);
2094 DIScope DLTScope = DLT.getScope();
2095 if (DLTScope.isNull()) continue;
2096 // There is no need to create another DIE for compile unit. For all
2097 // other scopes, create one DbgScope now. This will be translated
2098 // into a scope DIE at the end.
2099 if (DLTScope.isCompileUnit()) continue;
2100 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2101 DLT.getOrigLocation().getNode());
2102 Scope->setLastInsn(MInsn);
2106 if (!CurrentFnDbgScope)
2109 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2111 // Each scope has first instruction and last instruction to mark beginning
2112 // and end of a scope respectively. Create an inverse map that list scopes
2113 // starts (and ends) with an instruction. One instruction may start (or end)
2114 // multiple scopes. Ignore scopes that are not reachable.
2115 SmallVector<DbgScope *, 4> WorkList;
2116 WorkList.push_back(CurrentFnDbgScope);
2117 while (!WorkList.empty()) {
2118 DbgScope *S = WorkList.back(); WorkList.pop_back();
2120 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2121 if (!Children.empty())
2122 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2123 SE = Children.end(); SI != SE; ++SI)
2124 WorkList.push_back(*SI);
2126 if (S->isAbstractScope())
2128 const MachineInstr *MI = S->getFirstInsn();
2129 assert (MI && "DbgScope does not have first instruction!");
2131 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2132 if (IDI != DbgScopeBeginMap.end())
2133 IDI->second.push_back(S);
2135 DbgScopeBeginMap[MI].push_back(S);
2137 MI = S->getLastInsn();
2138 assert (MI && "DbgScope does not have last instruction!");
2139 IDI = DbgScopeEndMap.find(MI);
2140 if (IDI != DbgScopeEndMap.end())
2141 IDI->second.push_back(S);
2143 DbgScopeEndMap[MI].push_back(S);
2146 return !DbgScopeMap.empty();
2149 /// beginFunction - Gather pre-function debug information. Assumes being
2150 /// emitted immediately after the function entry point.
2151 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2154 if (!ShouldEmitDwarfDebug()) return;
2156 if (TimePassesIsEnabled)
2157 DebugTimer->startTimer();
2159 if (!extractScopeInformation())
2162 collectVariableInfo();
2164 // Assumes in correct section after the entry point.
2165 EmitLabel("func_begin", ++SubprogramCount);
2167 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2169 DebugLoc FDL = MF->getDefaultDebugLoc();
2170 if (!FDL.isUnknown()) {
2171 DILocation DLT = MF->getDILocation(FDL);
2172 unsigned LabelID = 0;
2173 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2175 LabelID = recordSourceLine(SP.getLineNumber(), 0,
2176 DLT.getScope().getNode());
2178 LabelID = recordSourceLine(DLT.getLineNumber(),
2179 DLT.getColumnNumber(),
2180 DLT.getScope().getNode());
2181 Asm->printLabel(LabelID);
2184 if (TimePassesIsEnabled)
2185 DebugTimer->stopTimer();
2188 /// endFunction - Gather and emit post-function debug information.
2190 void DwarfDebug::endFunction(const MachineFunction *MF) {
2191 if (!ShouldEmitDwarfDebug()) return;
2193 if (TimePassesIsEnabled)
2194 DebugTimer->startTimer();
2196 if (DbgScopeMap.empty())
2199 if (CurrentFnDbgScope) {
2200 // Define end label for subprogram.
2201 EmitLabel("func_end", SubprogramCount);
2203 // Get function line info.
2204 if (!Lines.empty()) {
2205 // Get section line info.
2206 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2207 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2208 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2209 // Append the function info to section info.
2210 SectionLineInfos.insert(SectionLineInfos.end(),
2211 Lines.begin(), Lines.end());
2214 // Construct abstract scopes.
2215 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2216 AE = AbstractScopesList.end(); AI != AE; ++AI)
2217 constructScopeDIE(*AI);
2219 constructScopeDIE(CurrentFnDbgScope);
2221 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2222 MMI->getFrameMoves()));
2226 CurrentFnDbgScope = NULL;
2227 DeleteContainerSeconds(DbgScopeMap);
2228 DbgScopeBeginMap.clear();
2229 DbgScopeEndMap.clear();
2230 ConcreteScopes.clear();
2231 DeleteContainerSeconds(AbstractScopes);
2232 AbstractScopesList.clear();
2235 if (TimePassesIsEnabled)
2236 DebugTimer->stopTimer();
2239 /// recordSourceLine - Records location information and associates it with a
2240 /// label. Returns a unique label ID used to generate a label and provide
2241 /// correspondence to the source line list.
2242 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2247 if (TimePassesIsEnabled)
2248 DebugTimer->startTimer();
2253 DIDescriptor Scope(S);
2254 if (Scope.isCompileUnit()) {
2255 DICompileUnit CU(S);
2256 Dir = CU.getDirectory();
2257 Fn = CU.getFilename();
2258 } else if (Scope.isSubprogram()) {
2260 Dir = SP.getDirectory();
2261 Fn = SP.getFilename();
2262 } else if (Scope.isLexicalBlock()) {
2263 DILexicalBlock DB(S);
2264 Dir = DB.getDirectory();
2265 Fn = DB.getFilename();
2267 assert (0 && "Unexpected scope info");
2269 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2270 unsigned ID = MMI->NextLabelID();
2271 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2273 if (TimePassesIsEnabled)
2274 DebugTimer->stopTimer();
2279 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2280 /// timed. Look up the source id with the given directory and source file
2281 /// names. If none currently exists, create a new id and insert it in the
2282 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2284 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2285 const std::string &FileName) {
2286 if (TimePassesIsEnabled)
2287 DebugTimer->startTimer();
2289 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2291 if (TimePassesIsEnabled)
2292 DebugTimer->stopTimer();
2297 //===----------------------------------------------------------------------===//
2299 //===----------------------------------------------------------------------===//
2301 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2304 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2305 // Get the children.
2306 const std::vector<DIE *> &Children = Die->getChildren();
2308 // If not last sibling and has children then add sibling offset attribute.
2309 if (!Last && !Children.empty()) Die->addSiblingOffset();
2311 // Record the abbreviation.
2312 assignAbbrevNumber(Die->getAbbrev());
2314 // Get the abbreviation for this DIE.
2315 unsigned AbbrevNumber = Die->getAbbrevNumber();
2316 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2319 Die->setOffset(Offset);
2321 // Start the size with the size of abbreviation code.
2322 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2324 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2325 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2327 // Size the DIE attribute values.
2328 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2329 // Size attribute value.
2330 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2332 // Size the DIE children if any.
2333 if (!Children.empty()) {
2334 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2335 "Children flag not set");
2337 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2338 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2340 // End of children marker.
2341 Offset += sizeof(int8_t);
2344 Die->setSize(Offset - Die->getOffset());
2348 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2350 void DwarfDebug::computeSizeAndOffsets() {
2351 // Compute size of compile unit header.
2352 static unsigned Offset =
2353 sizeof(int32_t) + // Length of Compilation Unit Info
2354 sizeof(int16_t) + // DWARF version number
2355 sizeof(int32_t) + // Offset Into Abbrev. Section
2356 sizeof(int8_t); // Pointer Size (in bytes)
2358 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2359 CompileUnitOffsets[ModuleCU] = 0;
2362 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2363 /// tools to recognize the object file contains Dwarf information.
2364 void DwarfDebug::emitInitial() {
2365 // Check to see if we already emitted intial headers.
2366 if (didInitial) return;
2369 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2371 // Dwarf sections base addresses.
2372 if (MAI->doesDwarfRequireFrameSection()) {
2373 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2374 EmitLabel("section_debug_frame", 0);
2377 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2378 EmitLabel("section_info", 0);
2379 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2380 EmitLabel("section_abbrev", 0);
2381 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2382 EmitLabel("section_aranges", 0);
2384 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2385 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2386 EmitLabel("section_macinfo", 0);
2389 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2390 EmitLabel("section_line", 0);
2391 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2392 EmitLabel("section_loc", 0);
2393 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2394 EmitLabel("section_pubnames", 0);
2395 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2396 EmitLabel("section_pubtypes", 0);
2397 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2398 EmitLabel("section_str", 0);
2399 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2400 EmitLabel("section_ranges", 0);
2402 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2403 EmitLabel("text_begin", 0);
2404 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2405 EmitLabel("data_begin", 0);
2408 /// emitDIE - Recusively Emits a debug information entry.
2410 void DwarfDebug::emitDIE(DIE *Die) {
2411 // Get the abbreviation for this DIE.
2412 unsigned AbbrevNumber = Die->getAbbrevNumber();
2413 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2417 // Emit the code (index) for the abbreviation.
2418 if (Asm->VerboseAsm)
2419 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2420 Twine::utohexstr(Die->getOffset()) + ":0x" +
2421 Twine::utohexstr(Die->getSize()) + " " +
2422 dwarf::TagString(Abbrev->getTag()));
2423 EmitULEB128(AbbrevNumber);
2425 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2426 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2428 // Emit the DIE attribute values.
2429 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2430 unsigned Attr = AbbrevData[i].getAttribute();
2431 unsigned Form = AbbrevData[i].getForm();
2432 assert(Form && "Too many attributes for DIE (check abbreviation)");
2434 if (Asm->VerboseAsm)
2435 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2438 case dwarf::DW_AT_sibling:
2439 Asm->EmitInt32(Die->getSiblingOffset());
2441 case dwarf::DW_AT_abstract_origin: {
2442 DIEEntry *E = cast<DIEEntry>(Values[i]);
2443 DIE *Origin = E->getEntry();
2444 unsigned Addr = Origin->getOffset();
2445 Asm->EmitInt32(Addr);
2449 // Emit an attribute using the defined form.
2450 Values[i]->EmitValue(this, Form);
2451 O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2456 // Emit the DIE children if any.
2457 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2458 const std::vector<DIE *> &Children = Die->getChildren();
2460 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2461 emitDIE(Children[j]);
2463 Asm->EmitInt8(0); EOL("End Of Children Mark");
2467 /// emitDebugInfo - Emit the debug info section.
2469 void DwarfDebug::emitDebugInfo() {
2470 // Start debug info section.
2471 Asm->OutStreamer.SwitchSection(
2472 Asm->getObjFileLowering().getDwarfInfoSection());
2473 DIE *Die = ModuleCU->getCUDie();
2475 // Emit the compile units header.
2476 EmitLabel("info_begin", ModuleCU->getID());
2478 // Emit size of content not including length itself
2479 unsigned ContentSize = Die->getSize() +
2480 sizeof(int16_t) + // DWARF version number
2481 sizeof(int32_t) + // Offset Into Abbrev. Section
2482 sizeof(int8_t) + // Pointer Size (in bytes)
2483 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2485 Asm->EmitInt32(ContentSize); EOL("Length of Compilation Unit Info");
2486 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2487 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2488 EOL("Offset Into Abbrev. Section");
2489 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2492 // FIXME - extra padding for gdb bug.
2493 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2494 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2495 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2496 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2497 EmitLabel("info_end", ModuleCU->getID());
2501 /// emitAbbreviations - Emit the abbreviation section.
2503 void DwarfDebug::emitAbbreviations() const {
2504 // Check to see if it is worth the effort.
2505 if (!Abbreviations.empty()) {
2506 // Start the debug abbrev section.
2507 Asm->OutStreamer.SwitchSection(
2508 Asm->getObjFileLowering().getDwarfAbbrevSection());
2510 EmitLabel("abbrev_begin", 0);
2512 // For each abbrevation.
2513 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2514 // Get abbreviation data
2515 const DIEAbbrev *Abbrev = Abbreviations[i];
2517 // Emit the abbrevations code (base 1 index.)
2518 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2520 // Emit the abbreviations data.
2525 // Mark end of abbreviations.
2526 EmitULEB128(0, "EOM(3)");
2528 EmitLabel("abbrev_end", 0);
2533 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2534 /// the line matrix.
2536 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2537 // Define last address of section.
2538 Asm->EmitInt8(0); EOL("Extended Op");
2539 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2540 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2541 EmitReference("section_end", SectionEnd); EOL("Section end label");
2543 // Mark end of matrix.
2544 Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2549 /// emitDebugLines - Emit source line information.
2551 void DwarfDebug::emitDebugLines() {
2552 // If the target is using .loc/.file, the assembler will be emitting the
2553 // .debug_line table automatically.
2554 if (MAI->hasDotLocAndDotFile())
2557 // Minimum line delta, thus ranging from -10..(255-10).
2558 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2559 // Maximum line delta, thus ranging from -10..(255-10).
2560 const int MaxLineDelta = 255 + MinLineDelta;
2562 // Start the dwarf line section.
2563 Asm->OutStreamer.SwitchSection(
2564 Asm->getObjFileLowering().getDwarfLineSection());
2566 // Construct the section header.
2567 EmitDifference("line_end", 0, "line_begin", 0, true);
2568 EOL("Length of Source Line Info");
2569 EmitLabel("line_begin", 0);
2571 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2573 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2574 EOL("Prolog Length");
2575 EmitLabel("line_prolog_begin", 0);
2577 Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2578 Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2579 Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2580 Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2581 Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2583 // Line number standard opcode encodings argument count
2584 Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2585 Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2586 Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2587 Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2588 Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2589 Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2590 Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2591 Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2592 Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2594 // Emit directories.
2595 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2596 const std::string &Dir = getSourceDirectoryName(DI);
2597 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2598 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2601 Asm->EmitInt8(0); EOL("End of directories");
2604 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2605 // Remember source id starts at 1.
2606 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2607 const std::string &FN = getSourceFileName(Id.second);
2608 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2609 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2611 EmitULEB128(Id.first, "Directory #");
2612 EmitULEB128(0, "Mod date");
2613 EmitULEB128(0, "File size");
2616 Asm->EmitInt8(0); EOL("End of files");
2618 EmitLabel("line_prolog_end", 0);
2620 // A sequence for each text section.
2621 unsigned SecSrcLinesSize = SectionSourceLines.size();
2623 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2624 // Isolate current sections line info.
2625 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2627 /*if (Asm->isVerbose()) {
2628 const MCSection *S = SectionMap[j + 1];
2629 O << '\t' << MAI->getCommentString() << " Section"
2630 << S->getName() << '\n';
2634 // Dwarf assumes we start with first line of first source file.
2635 unsigned Source = 1;
2638 // Construct rows of the address, source, line, column matrix.
2639 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2640 const SrcLineInfo &LineInfo = LineInfos[i];
2641 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2642 if (!LabelID) continue;
2644 if (LineInfo.getLine() == 0) continue;
2646 if (!Asm->isVerbose())
2649 std::pair<unsigned, unsigned> SourceID =
2650 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2651 O << '\t' << MAI->getCommentString() << ' '
2652 << getSourceDirectoryName(SourceID.first) << '/'
2653 << getSourceFileName(SourceID.second)
2654 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2657 // Define the line address.
2658 Asm->EmitInt8(0); EOL("Extended Op");
2659 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2660 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2661 EmitReference("label", LabelID); EOL("Location label");
2663 // If change of source, then switch to the new source.
2664 if (Source != LineInfo.getSourceID()) {
2665 Source = LineInfo.getSourceID();
2666 Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2667 EmitULEB128(Source, "New Source");
2670 // If change of line.
2671 if (Line != LineInfo.getLine()) {
2672 // Determine offset.
2673 int Offset = LineInfo.getLine() - Line;
2674 int Delta = Offset - MinLineDelta;
2677 Line = LineInfo.getLine();
2679 // If delta is small enough and in range...
2680 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2681 // ... then use fast opcode.
2682 Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2684 // ... otherwise use long hand.
2685 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2686 EOL("DW_LNS_advance_line");
2687 EmitSLEB128(Offset, "Line Offset");
2688 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2691 // Copy the previous row (different address or source)
2692 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2696 emitEndOfLineMatrix(j + 1);
2699 if (SecSrcLinesSize == 0)
2700 // Because we're emitting a debug_line section, we still need a line
2701 // table. The linker and friends expect it to exist. If there's nothing to
2702 // put into it, emit an empty table.
2703 emitEndOfLineMatrix(1);
2705 EmitLabel("line_end", 0);
2709 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2711 void DwarfDebug::emitCommonDebugFrame() {
2712 if (!MAI->doesDwarfRequireFrameSection())
2716 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2717 TargetFrameInfo::StackGrowsUp ?
2718 TD->getPointerSize() : -TD->getPointerSize();
2720 // Start the dwarf frame section.
2721 Asm->OutStreamer.SwitchSection(
2722 Asm->getObjFileLowering().getDwarfFrameSection());
2724 EmitLabel("debug_frame_common", 0);
2725 EmitDifference("debug_frame_common_end", 0,
2726 "debug_frame_common_begin", 0, true);
2727 EOL("Length of Common Information Entry");
2729 EmitLabel("debug_frame_common_begin", 0);
2730 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2731 EOL("CIE Identifier Tag");
2732 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2734 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2735 EOL("CIE Augmentation");
2736 EmitULEB128(1, "CIE Code Alignment Factor");
2737 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2738 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2739 EOL("CIE RA Column");
2741 std::vector<MachineMove> Moves;
2742 RI->getInitialFrameState(Moves);
2744 EmitFrameMoves(NULL, 0, Moves, false);
2746 Asm->EmitAlignment(2, 0, 0, false);
2747 EmitLabel("debug_frame_common_end", 0);
2751 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2754 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2755 if (!MAI->doesDwarfRequireFrameSection())
2758 // Start the dwarf frame section.
2759 Asm->OutStreamer.SwitchSection(
2760 Asm->getObjFileLowering().getDwarfFrameSection());
2762 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2763 "debug_frame_begin", DebugFrameInfo.Number, true);
2764 EOL("Length of Frame Information Entry");
2766 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2768 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2770 EOL("FDE CIE offset");
2772 EmitReference("func_begin", DebugFrameInfo.Number);
2773 EOL("FDE initial location");
2774 EmitDifference("func_end", DebugFrameInfo.Number,
2775 "func_begin", DebugFrameInfo.Number);
2776 EOL("FDE address range");
2778 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2781 Asm->EmitAlignment(2, 0, 0, false);
2782 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2786 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2788 void DwarfDebug::emitDebugPubNames() {
2789 // Start the dwarf pubnames section.
2790 Asm->OutStreamer.SwitchSection(
2791 Asm->getObjFileLowering().getDwarfPubNamesSection());
2793 EmitDifference("pubnames_end", ModuleCU->getID(),
2794 "pubnames_begin", ModuleCU->getID(), true);
2795 EOL("Length of Public Names Info");
2797 EmitLabel("pubnames_begin", ModuleCU->getID());
2799 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2801 EmitSectionOffset("info_begin", "section_info",
2802 ModuleCU->getID(), 0, true, false);
2803 EOL("Offset of Compilation Unit Info");
2805 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2807 EOL("Compilation Unit Length");
2809 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2810 for (StringMap<DIE*>::const_iterator
2811 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2812 const char *Name = GI->getKeyData();
2813 DIE * Entity = GI->second;
2815 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2817 if (Asm->VerboseAsm)
2818 Asm->OutStreamer.AddComment("External Name");
2819 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2822 Asm->EmitInt32(0); EOL("End Mark");
2823 EmitLabel("pubnames_end", ModuleCU->getID());
2827 void DwarfDebug::emitDebugPubTypes() {
2828 // Start the dwarf pubnames section.
2829 Asm->OutStreamer.SwitchSection(
2830 Asm->getObjFileLowering().getDwarfPubTypesSection());
2831 EmitDifference("pubtypes_end", ModuleCU->getID(),
2832 "pubtypes_begin", ModuleCU->getID(), true);
2833 EOL("Length of Public Types Info");
2835 EmitLabel("pubtypes_begin", ModuleCU->getID());
2837 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2838 Asm->EmitInt16(dwarf::DWARF_VERSION);
2840 EmitSectionOffset("info_begin", "section_info",
2841 ModuleCU->getID(), 0, true, false);
2842 EOL("Offset of Compilation ModuleCU Info");
2844 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2846 EOL("Compilation ModuleCU Length");
2848 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2849 for (StringMap<DIE*>::const_iterator
2850 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2851 const char *Name = GI->getKeyData();
2852 DIE * Entity = GI->second;
2854 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2855 Asm->EmitInt32(Entity->getOffset());
2857 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2858 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2861 Asm->EmitInt32(0); EOL("End Mark");
2862 EmitLabel("pubtypes_end", ModuleCU->getID());
2866 /// emitDebugStr - Emit visible names into a debug str section.
2868 void DwarfDebug::emitDebugStr() {
2869 // Check to see if it is worth the effort.
2870 if (!StringPool.empty()) {
2871 // Start the dwarf str section.
2872 Asm->OutStreamer.SwitchSection(
2873 Asm->getObjFileLowering().getDwarfStrSection());
2875 // For each of strings in the string pool.
2876 for (unsigned StringID = 1, N = StringPool.size();
2877 StringID <= N; ++StringID) {
2878 // Emit a label for reference from debug information entries.
2879 EmitLabel("string", StringID);
2881 // Emit the string itself.
2882 const std::string &String = StringPool[StringID];
2883 Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2890 /// emitDebugLoc - Emit visible names into a debug loc section.
2892 void DwarfDebug::emitDebugLoc() {
2893 // Start the dwarf loc section.
2894 Asm->OutStreamer.SwitchSection(
2895 Asm->getObjFileLowering().getDwarfLocSection());
2898 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2900 void DwarfDebug::EmitDebugARanges() {
2901 // Start the dwarf aranges section.
2902 Asm->OutStreamer.SwitchSection(
2903 Asm->getObjFileLowering().getDwarfARangesSection());
2907 CompileUnit *Unit = GetBaseCompileUnit();
2909 // Don't include size of length
2910 Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2912 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2914 EmitReference("info_begin", Unit->getID());
2915 EOL("Offset of Compilation Unit Info");
2917 Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2919 Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2921 Asm->EmitInt16(0); EOL("Pad (1)");
2922 Asm->EmitInt16(0); EOL("Pad (2)");
2925 EmitReference("text_begin", 0); EOL("Address");
2926 EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
2928 Asm->EmitInt32(0); EOL("EOM (1)");
2929 Asm->EmitInt32(0); EOL("EOM (2)");
2933 /// emitDebugRanges - Emit visible names into a debug ranges section.
2935 void DwarfDebug::emitDebugRanges() {
2936 // Start the dwarf ranges section.
2937 Asm->OutStreamer.SwitchSection(
2938 Asm->getObjFileLowering().getDwarfRangesSection());
2941 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2943 void DwarfDebug::emitDebugMacInfo() {
2944 if (const MCSection *LineInfo =
2945 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2946 // Start the dwarf macinfo section.
2947 Asm->OutStreamer.SwitchSection(LineInfo);
2951 /// emitDebugInlineInfo - Emit inline info using following format.
2953 /// 1. length of section
2954 /// 2. Dwarf version number
2955 /// 3. address size.
2957 /// Entries (one "entry" for each function that was inlined):
2959 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2960 /// otherwise offset into __debug_str for regular function name.
2961 /// 2. offset into __debug_str section for regular function name.
2962 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2963 /// instances for the function.
2965 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2966 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2967 /// __debug_info section, and the low_pc is the starting address for the
2968 /// inlining instance.
2969 void DwarfDebug::emitDebugInlineInfo() {
2970 if (!MAI->doesDwarfUsesInlineInfoSection())
2976 Asm->OutStreamer.SwitchSection(
2977 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2979 EmitDifference("debug_inlined_end", 1,
2980 "debug_inlined_begin", 1, true);
2981 EOL("Length of Debug Inlined Information Entry");
2983 EmitLabel("debug_inlined_begin", 1);
2985 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2986 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2988 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2989 E = InlinedSPNodes.end(); I != E; ++I) {
2992 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2993 = InlineInfo.find(Node);
2994 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2995 DISubprogram SP(Node);
2996 StringRef LName = SP.getLinkageName();
2997 StringRef Name = SP.getName();
2999 if (LName.empty()) {
3000 Asm->OutStreamer.EmitBytes(Name, 0);
3001 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3003 EmitSectionOffset("string", "section_str",
3004 StringPool.idFor(getRealLinkageName(LName)), false, true);
3006 EOL("MIPS linkage name");
3007 EmitSectionOffset("string", "section_str",
3008 StringPool.idFor(Name), false, true);
3009 EOL("Function name");
3010 EmitULEB128(Labels.size(), "Inline count");
3012 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3013 LE = Labels.end(); LI != LE; ++LI) {
3014 DIE *SP = LI->second;
3015 Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
3017 if (TD->getPointerSize() == sizeof(int32_t))
3018 O << MAI->getData32bitsDirective();
3020 O << MAI->getData64bitsDirective();
3022 PrintLabelName("label", LI->first); EOL("low_pc");
3026 EmitLabel("debug_inlined_end", 1);