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/TargetData.h"
22 #include "llvm/Target/TargetFrameInfo.h"
23 #include "llvm/Target/TargetLoweringObjectFile.h"
24 #include "llvm/Target/TargetRegisterInfo.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/Support/Debug.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/Mangler.h"
29 #include "llvm/Support/Timer.h"
30 #include "llvm/System/Path.h"
33 //===----------------------------------------------------------------------===//
35 /// Configuration values for initial hash set sizes (log2).
37 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
41 //===----------------------------------------------------------------------===//
42 /// CompileUnit - This dwarf writer support class manages information associate
43 /// with a source file.
45 /// ID - File identifier for source.
49 /// Die - Compile unit debug information entry.
53 /// IndexTyDie - An anonymous type for index type.
56 /// GVToDieMap - Tracks the mapping of unit level debug informaton
57 /// variables to debug information entries.
58 /// FIXME : Rename GVToDieMap -> NodeToDieMap
59 ValueMap<MDNode *, DIE *> GVToDieMap;
61 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
62 /// descriptors to debug information entries using a DIEEntry proxy.
64 ValueMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
66 /// Globals - A map of globally visible named entities for this unit.
68 StringMap<DIE*> Globals;
70 /// GlobalTypes - A map of globally visible types for this unit.
72 StringMap<DIE*> GlobalTypes;
75 CompileUnit(unsigned I, DIE *D)
76 : ID(I), CUDie(D), IndexTyDie(0) {}
77 ~CompileUnit() { delete CUDie; delete IndexTyDie; }
80 unsigned getID() const { return ID; }
81 DIE* getCUDie() const { return CUDie; }
82 const StringMap<DIE*> &getGlobals() const { return Globals; }
83 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
85 /// hasContent - Return true if this compile unit has something to write out.
87 bool hasContent() const { return !CUDie->getChildren().empty(); }
89 /// addGlobal - Add a new global entity to the compile unit.
91 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
93 /// addGlobalType - Add a new global type to the compile unit.
95 void addGlobalType(const std::string &Name, DIE *Die) {
96 GlobalTypes[Name] = Die;
99 /// getDIE - Returns the debug information entry map slot for the
100 /// specified debug variable.
101 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
103 /// insertDIE - Insert DIE into the map.
104 void insertDIE(MDNode *N, DIE *D) {
105 GVToDieMap.insert(std::make_pair(N, D));
108 /// getDIEEntry - Returns the debug information entry for the speciefied
110 DIEEntry *getDIEEntry(MDNode *N) {
111 ValueMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
112 if (I == GVToDIEEntryMap.end())
117 /// insertDIEEntry - Insert debug information entry into the map.
118 void insertDIEEntry(MDNode *N, DIEEntry *E) {
119 GVToDIEEntryMap.insert(std::make_pair(N, E));
122 /// addDie - Adds or interns the DIE to the compile unit.
124 void addDie(DIE *Buffer) {
125 this->CUDie->addChild(Buffer);
128 // getIndexTyDie - Get an anonymous type for index type.
129 DIE *getIndexTyDie() {
133 // setIndexTyDie - Set D as anonymous type for index which can be reused
135 void setIndexTyDie(DIE *D) {
141 //===----------------------------------------------------------------------===//
142 /// DbgVariable - This class is used to track local variable information.
145 DIVariable Var; // Variable Descriptor.
146 unsigned FrameIndex; // Variable frame index.
147 DbgVariable *AbstractVar; // Abstract variable for this variable.
150 DbgVariable(DIVariable V, unsigned I)
151 : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0) {}
154 DIVariable getVariable() const { return Var; }
155 unsigned getFrameIndex() const { return FrameIndex; }
156 void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
157 DbgVariable *getAbstractVariable() const { return AbstractVar; }
158 void setDIE(DIE *D) { TheDIE = D; }
159 DIE *getDIE() const { return TheDIE; }
162 //===----------------------------------------------------------------------===//
163 /// DbgScope - This class is used to track scope information.
166 DbgScope *Parent; // Parent to this scope.
167 DIDescriptor Desc; // Debug info descriptor for scope.
168 WeakVH InlinedAtLocation; // Location at which scope is inlined.
169 bool AbstractScope; // Abstract Scope
170 unsigned StartLabelID; // Label ID of the beginning of scope.
171 unsigned EndLabelID; // Label ID of the end of scope.
172 const MachineInstr *LastInsn; // Last instruction of this scope.
173 const MachineInstr *FirstInsn; // First instruction of this scope.
174 SmallVector<DbgScope *, 4> Scopes; // Scopes defined in scope.
175 SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
177 // Private state for dump()
178 mutable unsigned IndentLevel;
180 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
181 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
182 StartLabelID(0), EndLabelID(0),
183 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
187 DbgScope *getParent() const { return Parent; }
188 void setParent(DbgScope *P) { Parent = P; }
189 DIDescriptor getDesc() const { return Desc; }
190 MDNode *getInlinedAt() const {
191 return dyn_cast_or_null<MDNode>(InlinedAtLocation);
193 MDNode *getScopeNode() const { return Desc.getNode(); }
194 unsigned getStartLabelID() const { return StartLabelID; }
195 unsigned getEndLabelID() const { return EndLabelID; }
196 SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
197 SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
198 void setStartLabelID(unsigned S) { StartLabelID = S; }
199 void setEndLabelID(unsigned E) { EndLabelID = E; }
200 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
201 const MachineInstr *getLastInsn() { return LastInsn; }
202 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
203 void setAbstractScope() { AbstractScope = true; }
204 bool isAbstractScope() const { return AbstractScope; }
205 const MachineInstr *getFirstInsn() { return FirstInsn; }
207 /// addScope - Add a scope to the scope.
209 void addScope(DbgScope *S) { Scopes.push_back(S); }
211 /// addVariable - Add a variable to the scope.
213 void addVariable(DbgVariable *V) { Variables.push_back(V); }
215 void fixInstructionMarkers(DenseMap<const MachineInstr *,
216 unsigned> &MIIndexMap) {
217 assert (getFirstInsn() && "First instruction is missing!");
219 // Use the end of last child scope as end of this scope.
220 SmallVector<DbgScope *, 4> &Scopes = getScopes();
221 const MachineInstr *LastInsn = getFirstInsn();
223 if (Scopes.empty()) {
224 assert (getLastInsn() && "Inner most scope does not have last insn!");
227 for (SmallVector<DbgScope *, 4>::iterator SI = Scopes.begin(),
228 SE = Scopes.end(); SI != SE; ++SI) {
230 DS->fixInstructionMarkers(MIIndexMap);
231 const MachineInstr *DSLastInsn = DS->getLastInsn();
232 unsigned DSI = MIIndexMap[DSLastInsn];
234 LastInsn = DSLastInsn;
238 setLastInsn(LastInsn);
247 void DbgScope::dump() const {
248 raw_ostream &err = dbgs();
249 err.indent(IndentLevel);
250 MDNode *N = Desc.getNode();
252 err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
254 err << "Abstract Scope\n";
258 err << "Children ...\n";
259 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
260 if (Scopes[i] != this)
267 DbgScope::~DbgScope() {
268 for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
270 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
274 } // end llvm namespace
276 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
277 : Dwarf(OS, A, T, "dbg"), ModuleCU(0),
278 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
279 DIEValues(), StringPool(),
280 SectionSourceLines(), didInitial(false), shouldEmit(false),
281 CurrentFnDbgScope(0), DebugTimer(0) {
282 if (TimePassesIsEnabled)
283 DebugTimer = new Timer("Dwarf Debug Writer");
285 DwarfDebug::~DwarfDebug() {
286 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
292 /// assignAbbrevNumber - Define a unique number for the abbreviation.
294 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
295 // Profile the node so that we can make it unique.
299 // Check the set for priors.
300 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
302 // If it's newly added.
303 if (InSet == &Abbrev) {
304 // Add to abbreviation list.
305 Abbreviations.push_back(&Abbrev);
307 // Assign the vector position + 1 as its number.
308 Abbrev.setNumber(Abbreviations.size());
310 // Assign existing abbreviation number.
311 Abbrev.setNumber(InSet->getNumber());
315 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
316 /// information entry.
317 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
318 DIEEntry *Value = new DIEEntry(Entry);
319 DIEValues.push_back(Value);
323 /// addUInt - Add an unsigned integer attribute data and value.
325 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
326 unsigned Form, uint64_t Integer) {
327 if (!Form) Form = DIEInteger::BestForm(false, Integer);
328 DIEValue *Value = new DIEInteger(Integer);
329 DIEValues.push_back(Value);
330 Die->addValue(Attribute, Form, Value);
333 /// addSInt - Add an signed integer attribute data and value.
335 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
336 unsigned Form, int64_t Integer) {
337 if (!Form) Form = DIEInteger::BestForm(true, Integer);
338 DIEValue *Value = new DIEInteger(Integer);
339 DIEValues.push_back(Value);
340 Die->addValue(Attribute, Form, Value);
343 /// addString - Add a string attribute data and value. DIEString only
344 /// keeps string reference.
345 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
346 const StringRef String) {
347 DIEValue *Value = new DIEString(String);
348 DIEValues.push_back(Value);
349 Die->addValue(Attribute, Form, Value);
352 /// addLabel - Add a Dwarf label attribute data and value.
354 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
355 const DWLabel &Label) {
356 DIEValue *Value = new DIEDwarfLabel(Label);
357 DIEValues.push_back(Value);
358 Die->addValue(Attribute, Form, Value);
361 /// addObjectLabel - Add an non-Dwarf label attribute data and value.
363 void DwarfDebug::addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
364 const std::string &Label) {
365 DIEValue *Value = new DIEObjectLabel(Label);
366 DIEValues.push_back(Value);
367 Die->addValue(Attribute, Form, Value);
370 /// addSectionOffset - Add a section offset label attribute data and value.
372 void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
373 const DWLabel &Label, const DWLabel &Section,
374 bool isEH, bool useSet) {
375 DIEValue *Value = new DIESectionOffset(Label, Section, isEH, useSet);
376 DIEValues.push_back(Value);
377 Die->addValue(Attribute, Form, Value);
380 /// addDelta - Add a label delta attribute data and value.
382 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
383 const DWLabel &Hi, const DWLabel &Lo) {
384 DIEValue *Value = new DIEDelta(Hi, Lo);
385 DIEValues.push_back(Value);
386 Die->addValue(Attribute, Form, Value);
389 /// addBlock - Add block data.
391 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
393 Block->ComputeSize(TD);
394 DIEValues.push_back(Block);
395 Die->addValue(Attribute, Block->BestForm(), Block);
398 /// addSourceLine - Add location information to specified debug information
400 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
401 // If there is no compile unit specified, don't add a line #.
402 if (V->getCompileUnit().isNull())
405 unsigned Line = V->getLineNumber();
406 unsigned FileID = findCompileUnit(V->getCompileUnit())->getID();
407 assert(FileID && "Invalid file id");
408 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
409 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
412 /// addSourceLine - Add location information to specified debug information
414 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
415 // If there is no compile unit specified, don't add a line #.
416 if (G->getCompileUnit().isNull())
419 unsigned Line = G->getLineNumber();
420 unsigned FileID = findCompileUnit(G->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 DISubprogram *SP) {
429 // If there is no compile unit specified, don't add a line #.
430 if (SP->getCompileUnit().isNull())
432 // If the line number is 0, don't add it.
433 if (SP->getLineNumber() == 0)
437 unsigned Line = SP->getLineNumber();
438 unsigned FileID = findCompileUnit(SP->getCompileUnit())->getID();
439 assert(FileID && "Invalid file id");
440 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
441 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
444 /// addSourceLine - Add location information to specified debug information
446 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
447 // If there is no compile unit specified, don't add a line #.
448 DICompileUnit CU = Ty->getCompileUnit();
452 unsigned Line = Ty->getLineNumber();
453 unsigned FileID = findCompileUnit(CU)->getID();
454 assert(FileID && "Invalid file id");
455 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
456 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
459 /// addSourceLine - Add location information to specified debug information
461 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
462 // If there is no compile unit specified, don't add a line #.
463 if (NS->getCompileUnit().isNull())
466 unsigned Line = NS->getLineNumber();
467 StringRef FN = NS->getFilename();
468 StringRef Dir = NS->getDirectory();
470 unsigned FileID = GetOrCreateSourceID(Dir, FN);
471 assert(FileID && "Invalid file id");
472 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
473 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
476 /* Byref variables, in Blocks, are declared by the programmer as
477 "SomeType VarName;", but the compiler creates a
478 __Block_byref_x_VarName struct, and gives the variable VarName
479 either the struct, or a pointer to the struct, as its type. This
480 is necessary for various behind-the-scenes things the compiler
481 needs to do with by-reference variables in blocks.
483 However, as far as the original *programmer* is concerned, the
484 variable should still have type 'SomeType', as originally declared.
486 The following function dives into the __Block_byref_x_VarName
487 struct to find the original type of the variable. This will be
488 passed back to the code generating the type for the Debug
489 Information Entry for the variable 'VarName'. 'VarName' will then
490 have the original type 'SomeType' in its debug information.
492 The original type 'SomeType' will be the type of the field named
493 'VarName' inside the __Block_byref_x_VarName struct.
495 NOTE: In order for this to not completely fail on the debugger
496 side, the Debug Information Entry for the variable VarName needs to
497 have a DW_AT_location that tells the debugger how to unwind through
498 the pointers and __Block_byref_x_VarName struct to find the actual
499 value of the variable. The function addBlockByrefType does this. */
501 /// Find the type the programmer originally declared the variable to be
502 /// and return that type.
504 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
507 unsigned tag = Ty.getTag();
509 if (tag == dwarf::DW_TAG_pointer_type) {
510 DIDerivedType DTy = DIDerivedType(Ty.getNode());
511 subType = DTy.getTypeDerivedFrom();
514 DICompositeType blockStruct = DICompositeType(subType.getNode());
516 DIArray Elements = blockStruct.getTypeArray();
518 if (Elements.isNull())
521 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
522 DIDescriptor Element = Elements.getElement(i);
523 DIDerivedType DT = DIDerivedType(Element.getNode());
524 if (Name == DT.getName())
525 return (DT.getTypeDerivedFrom());
531 /// addComplexAddress - Start with the address based on the location provided,
532 /// and generate the DWARF information necessary to find the actual variable
533 /// given the extra address information encoded in the DIVariable, starting from
534 /// the starting location. Add the DWARF information to the die.
536 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
538 const MachineLocation &Location) {
539 const DIVariable &VD = DV->getVariable();
540 DIType Ty = VD.getType();
542 // Decode the original location, and use that as the start of the byref
543 // variable's location.
544 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
545 DIEBlock *Block = new DIEBlock();
547 if (Location.isReg()) {
549 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
551 Reg = Reg - dwarf::DW_OP_reg0;
552 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
553 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
557 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
559 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
560 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
563 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
566 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
567 uint64_t Element = VD.getAddrElement(i);
569 if (Element == DIFactory::OpPlus) {
570 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
571 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
572 } else if (Element == DIFactory::OpDeref) {
573 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
574 } else llvm_unreachable("unknown DIFactory Opcode");
577 // Now attach the location information to the DIE.
578 addBlock(Die, Attribute, 0, Block);
581 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
582 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
583 gives the variable VarName either the struct, or a pointer to the struct, as
584 its type. This is necessary for various behind-the-scenes things the
585 compiler needs to do with by-reference variables in Blocks.
587 However, as far as the original *programmer* is concerned, the variable
588 should still have type 'SomeType', as originally declared.
590 The function getBlockByrefType dives into the __Block_byref_x_VarName
591 struct to find the original type of the variable, which is then assigned to
592 the variable's Debug Information Entry as its real type. So far, so good.
593 However now the debugger will expect the variable VarName to have the type
594 SomeType. So we need the location attribute for the variable to be an
595 expression that explains to the debugger how to navigate through the
596 pointers and struct to find the actual variable of type SomeType.
598 The following function does just that. We start by getting
599 the "normal" location for the variable. This will be the location
600 of either the struct __Block_byref_x_VarName or the pointer to the
601 struct __Block_byref_x_VarName.
603 The struct will look something like:
605 struct __Block_byref_x_VarName {
607 struct __Block_byref_x_VarName *forwarding;
608 ... <various other fields>
610 ... <maybe more fields>
613 If we are given the struct directly (as our starting point) we
614 need to tell the debugger to:
616 1). Add the offset of the forwarding field.
618 2). Follow that pointer to get the the real __Block_byref_x_VarName
619 struct to use (the real one may have been copied onto the heap).
621 3). Add the offset for the field VarName, to find the actual variable.
623 If we started with a pointer to the struct, then we need to
624 dereference that pointer first, before the other steps.
625 Translating this into DWARF ops, we will need to append the following
626 to the current location description for the variable:
628 DW_OP_deref -- optional, if we start with a pointer
629 DW_OP_plus_uconst <forward_fld_offset>
631 DW_OP_plus_uconst <varName_fld_offset>
633 That is what this function does. */
635 /// addBlockByrefAddress - Start with the address based on the location
636 /// provided, and generate the DWARF information necessary to find the
637 /// actual Block variable (navigating the Block struct) based on the
638 /// starting location. Add the DWARF information to the die. For
639 /// more information, read large comment just above here.
641 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
643 const MachineLocation &Location) {
644 const DIVariable &VD = DV->getVariable();
645 DIType Ty = VD.getType();
647 unsigned Tag = Ty.getTag();
648 bool isPointer = false;
650 StringRef varName = VD.getName();
652 if (Tag == dwarf::DW_TAG_pointer_type) {
653 DIDerivedType DTy = DIDerivedType(Ty.getNode());
654 TmpTy = DTy.getTypeDerivedFrom();
658 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
660 // Find the __forwarding field and the variable field in the __Block_byref
662 DIArray Fields = blockStruct.getTypeArray();
663 DIDescriptor varField = DIDescriptor();
664 DIDescriptor forwardingField = DIDescriptor();
667 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
668 DIDescriptor Element = Fields.getElement(i);
669 DIDerivedType DT = DIDerivedType(Element.getNode());
670 StringRef fieldName = DT.getName();
671 if (fieldName == "__forwarding")
672 forwardingField = Element;
673 else if (fieldName == varName)
677 assert(!varField.isNull() && "Can't find byref variable in Block struct");
678 assert(!forwardingField.isNull()
679 && "Can't find forwarding field in Block struct");
681 // Get the offsets for the forwarding field and the variable field.
682 unsigned int forwardingFieldOffset =
683 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
684 unsigned int varFieldOffset =
685 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
687 // Decode the original location, and use that as the start of the byref
688 // variable's location.
689 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
690 DIEBlock *Block = new DIEBlock();
692 if (Location.isReg()) {
694 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
696 Reg = Reg - dwarf::DW_OP_reg0;
697 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
698 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
702 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
704 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
705 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
708 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
711 // If we started with a pointer to the __Block_byref... struct, then
712 // the first thing we need to do is dereference the pointer (DW_OP_deref).
714 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
716 // Next add the offset for the '__forwarding' field:
717 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
718 // adding the offset if it's 0.
719 if (forwardingFieldOffset > 0) {
720 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
721 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
724 // Now dereference the __forwarding field to get to the real __Block_byref
725 // struct: DW_OP_deref.
726 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
728 // Now that we've got the real __Block_byref... struct, add the offset
729 // for the variable's field to get to the location of the actual variable:
730 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
731 if (varFieldOffset > 0) {
732 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
733 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
736 // Now attach the location information to the DIE.
737 addBlock(Die, Attribute, 0, Block);
740 /// addAddress - Add an address attribute to a die based on the location
742 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
743 const MachineLocation &Location) {
744 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
745 DIEBlock *Block = new DIEBlock();
747 if (Location.isReg()) {
749 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
751 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
752 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
756 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
758 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
759 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
762 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
765 addBlock(Die, Attribute, 0, Block);
768 /// addToContextOwner - Add Die into the list of its context owner's children.
769 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
770 if (Context.isNull())
771 ModuleCU->addDie(Die);
772 else if (Context.isType()) {
773 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
774 ContextDIE->addChild(Die);
775 } else if (Context.isNameSpace()) {
776 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
777 ContextDIE->addChild(Die);
778 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
779 ContextDIE->addChild(Die);
781 ModuleCU->addDie(Die);
784 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
786 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
787 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
792 TyDIE = new DIE(dwarf::DW_TAG_base_type);
793 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
794 if (Ty.isBasicType())
795 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
796 else if (Ty.isCompositeType())
797 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
799 assert(Ty.isDerivedType() && "Unknown kind of DIType");
800 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
803 addToContextOwner(TyDIE, Ty.getContext());
807 /// addType - Add a new type attribute to the specified entity.
808 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
812 // Check for pre-existence.
813 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
814 // If it exists then use the existing value.
816 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
821 Entry = createDIEEntry();
822 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
825 DIE *Buffer = getOrCreateTypeDIE(Ty);
827 Entry->setEntry(Buffer);
828 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
831 /// constructTypeDIE - Construct basic type die from DIBasicType.
832 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
833 // Get core information.
834 StringRef Name = BTy.getName();
835 Buffer.setTag(dwarf::DW_TAG_base_type);
836 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
839 // Add name if not anonymous or intermediate type.
841 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
842 uint64_t Size = BTy.getSizeInBits() >> 3;
843 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
846 /// constructTypeDIE - Construct derived type die from DIDerivedType.
847 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
848 // Get core information.
849 StringRef Name = DTy.getName();
850 uint64_t Size = DTy.getSizeInBits() >> 3;
851 unsigned Tag = DTy.getTag();
853 // FIXME - Workaround for templates.
854 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
858 // Map to main type, void will not have a type.
859 DIType FromTy = DTy.getTypeDerivedFrom();
860 addType(&Buffer, FromTy);
862 // Add name if not anonymous or intermediate type.
864 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
866 // Add size if non-zero (derived types might be zero-sized.)
868 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
870 // Add source line info if available and TyDesc is not a forward declaration.
871 if (!DTy.isForwardDecl())
872 addSourceLine(&Buffer, &DTy);
875 /// constructTypeDIE - Construct type DIE from DICompositeType.
876 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
877 // Get core information.
878 StringRef Name = CTy.getName();
880 uint64_t Size = CTy.getSizeInBits() >> 3;
881 unsigned Tag = CTy.getTag();
885 case dwarf::DW_TAG_vector_type:
886 case dwarf::DW_TAG_array_type:
887 constructArrayTypeDIE(Buffer, &CTy);
889 case dwarf::DW_TAG_enumeration_type: {
890 DIArray Elements = CTy.getTypeArray();
892 // Add enumerators to enumeration type.
893 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
895 DIEnumerator Enum(Elements.getElement(i).getNode());
896 if (!Enum.isNull()) {
897 ElemDie = constructEnumTypeDIE(&Enum);
898 Buffer.addChild(ElemDie);
903 case dwarf::DW_TAG_subroutine_type: {
905 DIArray Elements = CTy.getTypeArray();
906 DIDescriptor RTy = Elements.getElement(0);
907 addType(&Buffer, DIType(RTy.getNode()));
909 // Add prototype flag.
910 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
913 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
914 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
915 DIDescriptor Ty = Elements.getElement(i);
916 addType(Arg, DIType(Ty.getNode()));
917 Buffer.addChild(Arg);
921 case dwarf::DW_TAG_structure_type:
922 case dwarf::DW_TAG_union_type:
923 case dwarf::DW_TAG_class_type: {
924 // Add elements to structure type.
925 DIArray Elements = CTy.getTypeArray();
927 // A forward struct declared type may not have elements available.
928 if (Elements.isNull())
931 // Add elements to structure type.
932 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
933 DIDescriptor Element = Elements.getElement(i);
934 if (Element.isNull())
937 if (Element.getTag() == dwarf::DW_TAG_subprogram)
938 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
940 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
941 Buffer.addChild(ElemDie);
944 if (CTy.isAppleBlockExtension())
945 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
947 unsigned RLang = CTy.getRunTimeLang();
949 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
950 dwarf::DW_FORM_data1, RLang);
957 // Add name if not anonymous or intermediate type.
959 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
961 if (Tag == dwarf::DW_TAG_enumeration_type ||
962 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
963 // Add size if non-zero (derived types might be zero-sized.)
965 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
967 // Add zero size if it is not a forward declaration.
968 if (CTy.isForwardDecl())
969 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
971 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
974 // Add source line info if available.
975 if (!CTy.isForwardDecl())
976 addSourceLine(&Buffer, &CTy);
980 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
981 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
982 int64_t L = SR.getLo();
983 int64_t H = SR.getHi();
984 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
986 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
988 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
989 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
991 Buffer.addChild(DW_Subrange);
994 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
995 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
996 DICompositeType *CTy) {
997 Buffer.setTag(dwarf::DW_TAG_array_type);
998 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
999 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1001 // Emit derived type.
1002 addType(&Buffer, CTy->getTypeDerivedFrom());
1003 DIArray Elements = CTy->getTypeArray();
1005 // Get an anonymous type for index type.
1006 DIE *IdxTy = ModuleCU->getIndexTyDie();
1008 // Construct an anonymous type for index type.
1009 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1010 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1011 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1012 dwarf::DW_ATE_signed);
1013 ModuleCU->addDie(IdxTy);
1014 ModuleCU->setIndexTyDie(IdxTy);
1017 // Add subranges to array type.
1018 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1019 DIDescriptor Element = Elements.getElement(i);
1020 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1021 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1025 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1026 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator *ETy) {
1027 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1028 StringRef Name = ETy->getName();
1029 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1030 int64_t Value = ETy->getEnumValue();
1031 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1035 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1036 /// printer to not emit usual symbol prefix before the symbol name is used then
1037 /// return linkage name after skipping this special LLVM prefix.
1038 static StringRef getRealLinkageName(StringRef LinkageName) {
1040 if (LinkageName.startswith(StringRef(&One, 1)))
1041 return LinkageName.substr(1);
1045 /// createGlobalVariableDIE - Create new DIE using GV.
1046 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1047 // If the global variable was optmized out then no need to create debug info
1049 if (!GV.getGlobal()) return NULL;
1050 if (GV.getDisplayName().empty()) return NULL;
1052 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1053 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1054 GV.getDisplayName());
1056 StringRef LinkageName = GV.getLinkageName();
1057 if (!LinkageName.empty())
1058 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1059 getRealLinkageName(LinkageName));
1061 addType(GVDie, GV.getType());
1062 if (!GV.isLocalToUnit())
1063 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1064 addSourceLine(GVDie, &GV);
1069 /// createMemberDIE - Create new member DIE.
1070 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1071 DIE *MemberDie = new DIE(DT.getTag());
1072 StringRef Name = DT.getName();
1074 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1076 addType(MemberDie, DT.getTypeDerivedFrom());
1078 addSourceLine(MemberDie, &DT);
1080 DIEBlock *MemLocationDie = new DIEBlock();
1081 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1083 uint64_t Size = DT.getSizeInBits();
1084 uint64_t FieldSize = DT.getOriginalTypeSize();
1086 if (Size != FieldSize) {
1088 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1089 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1091 uint64_t Offset = DT.getOffsetInBits();
1092 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1093 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1094 uint64_t FieldOffset = (HiMark - FieldSize);
1095 Offset -= FieldOffset;
1097 // Maybe we need to work from the other end.
1098 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1099 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1101 // Here WD_AT_data_member_location points to the anonymous
1102 // field that includes this bit field.
1103 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1106 // This is not a bitfield.
1107 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1109 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1111 if (DT.isProtected())
1112 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1113 dwarf::DW_ACCESS_protected);
1114 else if (DT.isPrivate())
1115 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1116 dwarf::DW_ACCESS_private);
1117 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1118 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1119 dwarf::DW_ACCESS_public);
1121 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1122 dwarf::DW_VIRTUALITY_virtual);
1126 /// createSubprogramDIE - Create new DIE using SP.
1127 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1128 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1132 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1133 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1135 StringRef LinkageName = SP.getLinkageName();
1136 if (!LinkageName.empty())
1137 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1138 getRealLinkageName(LinkageName));
1140 addSourceLine(SPDie, &SP);
1142 // Add prototyped tag, if C or ObjC.
1143 unsigned Lang = SP.getCompileUnit().getLanguage();
1144 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1145 Lang == dwarf::DW_LANG_ObjC)
1146 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1149 DICompositeType SPTy = SP.getType();
1150 DIArray Args = SPTy.getTypeArray();
1151 unsigned SPTag = SPTy.getTag();
1153 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1154 addType(SPDie, SPTy);
1156 addType(SPDie, DIType(Args.getElement(0).getNode()));
1158 unsigned VK = SP.getVirtuality();
1160 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1161 DIEBlock *Block = new DIEBlock();
1162 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1163 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1164 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1165 ContainingTypeMap.insert(std::make_pair(SPDie, WeakVH(SP.getContainingType().getNode())));
1168 if (MakeDecl || !SP.isDefinition()) {
1169 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1171 // Add arguments. Do not add arguments for subprogram definition. They will
1172 // be handled while processing variables.
1173 DICompositeType SPTy = SP.getType();
1174 DIArray Args = SPTy.getTypeArray();
1175 unsigned SPTag = SPTy.getTag();
1177 if (SPTag == dwarf::DW_TAG_subroutine_type)
1178 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1179 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1180 addType(Arg, DIType(Args.getElement(i).getNode()));
1181 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1182 SPDie->addChild(Arg);
1186 // DW_TAG_inlined_subroutine may refer to this DIE.
1187 ModuleCU->insertDIE(SP.getNode(), SPDie);
1191 /// findCompileUnit - Get the compile unit for the given descriptor.
1193 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1194 DenseMap<Value *, CompileUnit *>::const_iterator I =
1195 CompileUnitMap.find(Unit.getNode());
1196 if (I == CompileUnitMap.end())
1197 return constructCompileUnit(Unit.getNode());
1201 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1202 /// Initialize scope and update scope hierarchy.
1203 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1204 MDNode *InlinedAt) {
1205 assert (N && "Invalid Scope encoding!");
1206 assert (MI && "Missing machine instruction!");
1207 bool GetConcreteScope = (MI && InlinedAt);
1209 DbgScope *NScope = NULL;
1212 NScope = DbgScopeMap.lookup(InlinedAt);
1214 NScope = DbgScopeMap.lookup(N);
1215 assert (NScope && "Unable to find working scope!");
1217 if (NScope->getFirstInsn())
1220 DbgScope *Parent = NULL;
1221 if (GetConcreteScope) {
1222 DILocation IL(InlinedAt);
1223 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1224 IL.getOrigLocation().getNode());
1225 assert (Parent && "Unable to find Parent scope!");
1226 NScope->setParent(Parent);
1227 Parent->addScope(NScope);
1228 } else if (DIDescriptor(N).isLexicalBlock()) {
1229 DILexicalBlock DB(N);
1230 if (!DB.getContext().isNull()) {
1231 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1232 NScope->setParent(Parent);
1233 Parent->addScope(NScope);
1237 NScope->setFirstInsn(MI);
1239 if (!Parent && !InlinedAt) {
1240 StringRef SPName = DISubprogram(N).getLinkageName();
1241 if (SPName == MF->getFunction()->getName())
1242 CurrentFnDbgScope = NScope;
1245 if (GetConcreteScope) {
1246 ConcreteScopes[InlinedAt] = NScope;
1247 getOrCreateAbstractScope(N);
1253 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1254 assert (N && "Invalid Scope encoding!");
1256 DbgScope *AScope = AbstractScopes.lookup(N);
1260 DbgScope *Parent = NULL;
1262 DIDescriptor Scope(N);
1263 if (Scope.isLexicalBlock()) {
1264 DILexicalBlock DB(N);
1265 DIDescriptor ParentDesc = DB.getContext();
1266 if (!ParentDesc.isNull())
1267 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1270 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1273 Parent->addScope(AScope);
1274 AScope->setAbstractScope();
1275 AbstractScopes[N] = AScope;
1276 if (DIDescriptor(N).isSubprogram())
1277 AbstractScopesList.push_back(AScope);
1281 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1282 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1283 /// If there are global variables in this scope then create and insert
1284 /// DIEs for these variables.
1285 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1287 DIE *SPDie = ModuleCU->getDIE(SPNode);
1288 assert (SPDie && "Unable to find subprogram DIE!");
1289 DISubprogram SP(SPNode);
1290 if (SP.isDefinition() && !SP.getContext().isCompileUnit()) {
1291 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1293 DICompositeType SPTy = SP.getType();
1294 DIArray Args = SPTy.getTypeArray();
1295 unsigned SPTag = SPTy.getTag();
1296 if (SPTag == dwarf::DW_TAG_subroutine_type)
1297 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1298 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1299 addType(Arg, DIType(Args.getElement(i).getNode()));
1300 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1301 SPDie->addChild(Arg);
1303 DIE *SPDeclDie = SPDie;
1304 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1305 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1307 ModuleCU->addDie(SPDie);
1310 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1311 DWLabel("func_begin", SubprogramCount));
1312 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1313 DWLabel("func_end", SubprogramCount));
1314 MachineLocation Location(RI->getFrameRegister(*MF));
1315 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1317 if (!DISubprogram(SPNode).isLocalToUnit())
1318 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1323 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1324 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1325 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1326 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1327 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1329 // Ignore empty scopes.
1330 if (StartID == EndID && StartID != 0)
1333 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1334 if (Scope->isAbstractScope())
1337 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1339 DWLabel("label", StartID)
1340 : DWLabel("func_begin", SubprogramCount));
1341 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1343 DWLabel("label", EndID)
1344 : DWLabel("func_end", SubprogramCount));
1351 /// constructInlinedScopeDIE - This scope represents inlined body of
1352 /// a function. Construct DIE to represent this concrete inlined copy
1353 /// of the function.
1354 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1355 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1356 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1357 assert (StartID && "Invalid starting label for an inlined scope!");
1358 assert (EndID && "Invalid end label for an inlined scope!");
1359 // Ignore empty scopes.
1360 if (StartID == EndID && StartID != 0)
1363 DIScope DS(Scope->getScopeNode());
1366 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1368 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1369 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1370 assert (OriginDIE && "Unable to find Origin DIE!");
1371 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1372 dwarf::DW_FORM_ref4, OriginDIE);
1374 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1375 DWLabel("label", StartID));
1376 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1377 DWLabel("label", EndID));
1379 InlinedSubprogramDIEs.insert(OriginDIE);
1381 // Track the start label for this inlined function.
1382 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1383 I = InlineInfo.find(InlinedSP.getNode());
1385 if (I == InlineInfo.end()) {
1386 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1388 InlinedSPNodes.push_back(InlinedSP.getNode());
1390 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1392 StringPool.insert(InlinedSP.getName());
1393 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1395 DILocation DL(Scope->getInlinedAt());
1396 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1397 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1403 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1404 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1405 // Get the descriptor.
1406 const DIVariable &VD = DV->getVariable();
1407 StringRef Name = VD.getName();
1411 // Translate tag to proper Dwarf tag. The result variable is dropped for
1414 switch (VD.getTag()) {
1415 case dwarf::DW_TAG_return_variable:
1417 case dwarf::DW_TAG_arg_variable:
1418 Tag = dwarf::DW_TAG_formal_parameter;
1420 case dwarf::DW_TAG_auto_variable: // fall thru
1422 Tag = dwarf::DW_TAG_variable;
1426 // Define variable debug information entry.
1427 DIE *VariableDie = new DIE(Tag);
1431 if (DbgVariable *AV = DV->getAbstractVariable())
1432 AbsDIE = AV->getDIE();
1435 DIScope DS(Scope->getScopeNode());
1436 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1437 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1439 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1440 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1441 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1442 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1443 dwarf::DW_FORM_ref4, AbsDIE);
1446 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1447 addSourceLine(VariableDie, &VD);
1449 // Add variable type.
1450 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1451 // addresses instead.
1452 if (VD.isBlockByrefVariable())
1453 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1455 addType(VariableDie, VD.getType());
1458 // Add variable address.
1459 if (!Scope->isAbstractScope()) {
1460 MachineLocation Location;
1462 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1463 Location.set(FrameReg, Offset);
1465 if (VD.hasComplexAddress())
1466 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1467 else if (VD.isBlockByrefVariable())
1468 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1470 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1472 DV->setDIE(VariableDie);
1477 void DwarfDebug::addPubTypes(DISubprogram SP) {
1478 DICompositeType SPTy = SP.getType();
1479 unsigned SPTag = SPTy.getTag();
1480 if (SPTag != dwarf::DW_TAG_subroutine_type)
1483 DIArray Args = SPTy.getTypeArray();
1487 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1488 DIType ATy(Args.getElement(i).getNode());
1491 DICompositeType CATy = getDICompositeType(ATy);
1492 if (!CATy.isNull() && !CATy.getName().empty()) {
1493 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1494 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1499 /// constructScopeDIE - Construct a DIE for this scope.
1500 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1503 DIScope DS(Scope->getScopeNode());
1507 DIE *ScopeDIE = NULL;
1508 if (Scope->getInlinedAt())
1509 ScopeDIE = constructInlinedScopeDIE(Scope);
1510 else if (DS.isSubprogram()) {
1511 if (Scope->isAbstractScope())
1512 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1514 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1517 ScopeDIE = constructLexicalScopeDIE(Scope);
1518 if (!ScopeDIE) return NULL;
1521 // Add variables to scope.
1522 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1523 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1524 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1526 ScopeDIE->addChild(VariableDIE);
1529 // Add nested scopes.
1530 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1531 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1532 // Define the Scope debug information entry.
1533 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1535 ScopeDIE->addChild(NestedDIE);
1538 if (DS.isSubprogram())
1539 addPubTypes(DISubprogram(DS.getNode()));
1544 /// GetOrCreateSourceID - Look up the source id with the given directory and
1545 /// source file names. If none currently exists, create a new id and insert it
1546 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1548 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1550 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1551 if (DI != DirectoryIdMap.end()) {
1552 DId = DI->getValue();
1554 DId = DirectoryNames.size() + 1;
1555 DirectoryIdMap[DirName] = DId;
1556 DirectoryNames.push_back(DirName);
1560 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1561 if (FI != SourceFileIdMap.end()) {
1562 FId = FI->getValue();
1564 FId = SourceFileNames.size() + 1;
1565 SourceFileIdMap[FileName] = FId;
1566 SourceFileNames.push_back(FileName);
1569 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1570 SourceIdMap.find(std::make_pair(DId, FId));
1571 if (SI != SourceIdMap.end())
1574 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1575 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1576 SourceIds.push_back(std::make_pair(DId, FId));
1581 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1582 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1583 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1586 NDie = new DIE(dwarf::DW_TAG_namespace);
1587 ModuleCU->insertDIE(NS.getNode(), NDie);
1588 if (!NS.getName().empty())
1589 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1590 addSourceLine(NDie, &NS);
1591 addToContextOwner(NDie, NS.getContext());
1595 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1596 DICompileUnit DIUnit(N);
1597 StringRef FN = DIUnit.getFilename();
1598 StringRef Dir = DIUnit.getDirectory();
1599 unsigned ID = GetOrCreateSourceID(Dir, FN);
1601 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1602 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1603 DWLabel("section_line", 0), DWLabel("section_line", 0),
1605 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1606 DIUnit.getProducer());
1607 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1608 DIUnit.getLanguage());
1609 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1612 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1613 if (DIUnit.isOptimized())
1614 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1616 StringRef Flags = DIUnit.getFlags();
1618 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1620 unsigned RVer = DIUnit.getRunTimeVersion();
1622 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1623 dwarf::DW_FORM_data1, RVer);
1625 CompileUnit *Unit = new CompileUnit(ID, Die);
1626 if (!ModuleCU && DIUnit.isMain()) {
1627 // Use first compile unit marked as isMain as the compile unit
1632 CompileUnitMap[DIUnit.getNode()] = Unit;
1633 CompileUnits.push_back(Unit);
1637 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1638 DIGlobalVariable DI_GV(N);
1640 // If debug information is malformed then ignore it.
1641 if (DI_GV.Verify() == false)
1644 // Check for pre-existence.
1645 if (ModuleCU->getDIE(DI_GV.getNode()))
1648 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1653 ModuleCU->insertDIE(N, VariableDie);
1655 // Add to context owner.
1656 DIDescriptor GVContext = DI_GV.getContext();
1657 // Do not create specification DIE if context is either compile unit
1659 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1660 && !GVContext.isSubprogram()) {
1661 // Create specification DIE.
1662 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1663 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1664 dwarf::DW_FORM_ref4, VariableDie);
1665 DIEBlock *Block = new DIEBlock();
1666 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1667 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1668 Asm->Mang->getMangledName(DI_GV.getGlobal()));
1669 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1670 ModuleCU->addDie(VariableSpecDIE);
1672 DIEBlock *Block = new DIEBlock();
1673 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1674 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1675 Asm->Mang->getMangledName(DI_GV.getGlobal()));
1676 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1678 addToContextOwner(VariableDie, GVContext);
1680 // Expose as global. FIXME - need to check external flag.
1681 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1683 DIType GTy = DI_GV.getType();
1684 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1685 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1686 assert (Entry && "Missing global type!");
1687 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1692 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1695 // Check for pre-existence.
1696 if (ModuleCU->getDIE(N))
1699 if (!SP.isDefinition())
1700 // This is a method declaration which will be handled while constructing
1704 DIE *SubprogramDie = createSubprogramDIE(SP);
1707 ModuleCU->insertDIE(N, SubprogramDie);
1709 // Add to context owner.
1710 addToContextOwner(SubprogramDie, SP.getContext());
1712 // Expose as global.
1713 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1718 /// beginModule - Emit all Dwarf sections that should come prior to the
1719 /// content. Create global DIEs and emit initial debug info sections.
1720 /// This is inovked by the target AsmPrinter.
1721 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1724 if (TimePassesIsEnabled)
1725 DebugTimer->startTimer();
1727 if (!MAI->doesSupportDebugInformation())
1730 DebugInfoFinder DbgFinder;
1731 DbgFinder.processModule(*M);
1733 // Create all the compile unit DIEs.
1734 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1735 E = DbgFinder.compile_unit_end(); I != E; ++I)
1736 constructCompileUnit(*I);
1738 if (CompileUnits.empty()) {
1739 if (TimePassesIsEnabled)
1740 DebugTimer->stopTimer();
1745 // If main compile unit for this module is not seen than randomly
1746 // select first compile unit.
1748 ModuleCU = CompileUnits[0];
1750 // Create DIEs for each subprogram.
1751 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1752 E = DbgFinder.subprogram_end(); I != E; ++I)
1753 constructSubprogramDIE(*I);
1755 // Create DIEs for each global variable.
1756 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1757 E = DbgFinder.global_variable_end(); I != E; ++I)
1758 constructGlobalVariableDIE(*I);
1762 MMI->setDebugInfoAvailability(true);
1764 // Prime section data.
1765 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1767 // Print out .file directives to specify files for .loc directives. These are
1768 // printed out early so that they precede any .loc directives.
1769 if (MAI->hasDotLocAndDotFile()) {
1770 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1771 // Remember source id starts at 1.
1772 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1773 sys::Path FullPath(getSourceDirectoryName(Id.first));
1775 FullPath.appendComponent(getSourceFileName(Id.second));
1776 assert(AppendOk && "Could not append filename to directory!");
1778 Asm->EmitFile(i, FullPath.str());
1783 // Emit initial sections
1786 if (TimePassesIsEnabled)
1787 DebugTimer->stopTimer();
1790 /// endModule - Emit all Dwarf sections that should come after the content.
1792 void DwarfDebug::endModule() {
1796 if (TimePassesIsEnabled)
1797 DebugTimer->startTimer();
1799 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1800 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1801 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1803 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1806 // Insert top level DIEs.
1807 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1808 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1809 ModuleCU->getCUDie()->addChild(*TI);
1811 for (DenseMap<DIE *, WeakVH>::iterator CI = ContainingTypeMap.begin(),
1812 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1813 DIE *SPDie = CI->first;
1814 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1816 DIE *NDie = ModuleCU->getDIE(N);
1817 if (!NDie) continue;
1818 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1819 // FIXME - This is not the correct approach.
1820 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1823 // Standard sections final addresses.
1824 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1825 EmitLabel("text_end", 0);
1826 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1827 EmitLabel("data_end", 0);
1829 // End text sections.
1830 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1831 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1832 EmitLabel("section_end", i);
1835 // Emit common frame information.
1836 emitCommonDebugFrame();
1838 // Emit function debug frame information
1839 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1840 E = DebugFrames.end(); I != E; ++I)
1841 emitFunctionDebugFrame(*I);
1843 // Compute DIE offsets and sizes.
1844 computeSizeAndOffsets();
1846 // Emit all the DIEs into a debug info section
1849 // Corresponding abbreviations into a abbrev section.
1850 emitAbbreviations();
1852 // Emit source line correspondence into a debug line section.
1855 // Emit info into a debug pubnames section.
1856 emitDebugPubNames();
1858 // Emit info into a debug pubtypes section.
1859 emitDebugPubTypes();
1861 // Emit info into a debug str section.
1864 // Emit info into a debug loc section.
1867 // Emit info into a debug aranges section.
1870 // Emit info into a debug ranges section.
1873 // Emit info into a debug macinfo section.
1876 // Emit inline info.
1877 emitDebugInlineInfo();
1879 if (TimePassesIsEnabled)
1880 DebugTimer->stopTimer();
1883 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1884 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1886 DILocation &ScopeLoc) {
1888 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1890 return AbsDbgVariable;
1892 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1896 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1897 Scope->addVariable(AbsDbgVariable);
1898 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1899 return AbsDbgVariable;
1902 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1903 void DwarfDebug::collectVariableInfo() {
1906 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1907 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1908 VE = VMap.end(); VI != VE; ++VI) {
1909 MetadataBase *MB = VI->first;
1910 MDNode *Var = dyn_cast_or_null<MDNode>(MB);
1912 DIVariable DV (Var);
1913 std::pair< unsigned, MDNode *> VP = VI->second;
1914 DILocation ScopeLoc(VP.second);
1917 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1919 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1920 // If variable scope is not found then skip this variable.
1924 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1925 Scope->addVariable(RegVar);
1926 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1928 RegVar->setAbstractVariable(AbsDbgVariable);
1932 /// beginScope - Process beginning of a scope starting at Label.
1933 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1934 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1935 if (I == DbgScopeBeginMap.end())
1937 ScopeVector &SD = I->second;
1938 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1940 (*SDI)->setStartLabelID(Label);
1943 /// endScope - Process end of a scope.
1944 void DwarfDebug::endScope(const MachineInstr *MI) {
1945 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1946 if (I == DbgScopeEndMap.end())
1949 unsigned Label = MMI->NextLabelID();
1950 Asm->printLabel(Label);
1953 SmallVector<DbgScope *, 2> &SD = I->second;
1954 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1956 (*SDI)->setEndLabelID(Label);
1960 /// createDbgScope - Create DbgScope for the scope.
1961 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1964 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1967 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1968 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1969 if (DIDescriptor(Scope).isLexicalBlock())
1970 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1974 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1978 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1979 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1980 DILocation DL(InlinedAt);
1981 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1984 /// extractScopeInformation - Scan machine instructions in this function
1985 /// and collect DbgScopes. Return true, if atleast one scope was found.
1986 bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
1987 // If scope information was extracted using .dbg intrinsics then there is not
1988 // any need to extract these information by scanning each instruction.
1989 if (!DbgScopeMap.empty())
1992 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
1993 unsigned MIIndex = 0;
1994 // Scan each instruction and create scopes. First build working set of scopes.
1995 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1997 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1999 const MachineInstr *MInsn = II;
2000 MIIndexMap[MInsn] = MIIndex++;
2001 DebugLoc DL = MInsn->getDebugLoc();
2002 if (DL.isUnknown()) continue;
2003 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
2004 if (!DLT.Scope) continue;
2005 // There is no need to create another DIE for compile unit. For all
2006 // other scopes, create one DbgScope now. This will be translated
2007 // into a scope DIE at the end.
2008 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
2009 createDbgScope(DLT.Scope, DLT.InlinedAtLoc);
2014 // Build scope hierarchy using working set of scopes.
2015 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2017 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2019 const MachineInstr *MInsn = II;
2020 DebugLoc DL = MInsn->getDebugLoc();
2021 if (DL.isUnknown()) continue;
2022 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
2023 if (!DLT.Scope) continue;
2024 // There is no need to create another DIE for compile unit. For all
2025 // other scopes, create one DbgScope now. This will be translated
2026 // into a scope DIE at the end.
2027 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
2028 DbgScope *Scope = getUpdatedDbgScope(DLT.Scope, MInsn, DLT.InlinedAtLoc);
2029 Scope->setLastInsn(MInsn);
2033 if (!CurrentFnDbgScope)
2036 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2038 // Each scope has first instruction and last instruction to mark beginning
2039 // and end of a scope respectively. Create an inverse map that list scopes
2040 // starts (and ends) with an instruction. One instruction may start (or end)
2042 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
2043 DE = DbgScopeMap.end(); DI != DE; ++DI) {
2044 DbgScope *S = DI->second;
2045 if (S->isAbstractScope())
2047 const MachineInstr *MI = S->getFirstInsn();
2048 assert (MI && "DbgScope does not have first instruction!");
2050 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2051 if (IDI != DbgScopeBeginMap.end())
2052 IDI->second.push_back(S);
2054 DbgScopeBeginMap[MI].push_back(S);
2056 MI = S->getLastInsn();
2057 assert (MI && "DbgScope does not have last instruction!");
2058 IDI = DbgScopeEndMap.find(MI);
2059 if (IDI != DbgScopeEndMap.end())
2060 IDI->second.push_back(S);
2062 DbgScopeEndMap[MI].push_back(S);
2065 return !DbgScopeMap.empty();
2068 /// beginFunction - Gather pre-function debug information. Assumes being
2069 /// emitted immediately after the function entry point.
2070 void DwarfDebug::beginFunction(MachineFunction *MF) {
2073 if (!ShouldEmitDwarfDebug()) return;
2075 if (TimePassesIsEnabled)
2076 DebugTimer->startTimer();
2078 if (!extractScopeInformation(MF))
2081 collectVariableInfo();
2083 // Begin accumulating function debug information.
2084 MMI->BeginFunction(MF);
2086 // Assumes in correct section after the entry point.
2087 EmitLabel("func_begin", ++SubprogramCount);
2089 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2091 DebugLoc FDL = MF->getDefaultDebugLoc();
2092 if (!FDL.isUnknown()) {
2093 DebugLocTuple DLT = MF->getDebugLocTuple(FDL);
2094 unsigned LabelID = 0;
2095 DISubprogram SP = getDISubprogram(DLT.Scope);
2097 LabelID = recordSourceLine(SP.getLineNumber(), 0, DLT.Scope);
2099 LabelID = recordSourceLine(DLT.Line, DLT.Col, DLT.Scope);
2100 Asm->printLabel(LabelID);
2103 if (TimePassesIsEnabled)
2104 DebugTimer->stopTimer();
2107 /// endFunction - Gather and emit post-function debug information.
2109 void DwarfDebug::endFunction(MachineFunction *MF) {
2110 if (!ShouldEmitDwarfDebug()) return;
2112 if (TimePassesIsEnabled)
2113 DebugTimer->startTimer();
2115 if (DbgScopeMap.empty())
2118 if (CurrentFnDbgScope) {
2119 // Define end label for subprogram.
2120 EmitLabel("func_end", SubprogramCount);
2122 // Get function line info.
2123 if (!Lines.empty()) {
2124 // Get section line info.
2125 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2126 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2127 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2128 // Append the function info to section info.
2129 SectionLineInfos.insert(SectionLineInfos.end(),
2130 Lines.begin(), Lines.end());
2133 // Construct abstract scopes.
2134 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2135 AE = AbstractScopesList.end(); AI != AE; ++AI)
2136 constructScopeDIE(*AI);
2138 constructScopeDIE(CurrentFnDbgScope);
2140 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2141 MMI->getFrameMoves()));
2145 if (CurrentFnDbgScope) {
2146 CurrentFnDbgScope = NULL;
2147 DbgScopeMap.clear();
2148 DbgScopeBeginMap.clear();
2149 DbgScopeEndMap.clear();
2150 ConcreteScopes.clear();
2151 AbstractScopesList.clear();
2155 if (TimePassesIsEnabled)
2156 DebugTimer->stopTimer();
2159 /// recordSourceLine - Records location information and associates it with a
2160 /// label. Returns a unique label ID used to generate a label and provide
2161 /// correspondence to the source line list.
2162 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2167 if (TimePassesIsEnabled)
2168 DebugTimer->startTimer();
2173 DIDescriptor Scope(S);
2174 if (Scope.isCompileUnit()) {
2175 DICompileUnit CU(S);
2176 Dir = CU.getDirectory();
2177 Fn = CU.getFilename();
2178 } else if (Scope.isSubprogram()) {
2180 Dir = SP.getDirectory();
2181 Fn = SP.getFilename();
2182 } else if (Scope.isLexicalBlock()) {
2183 DILexicalBlock DB(S);
2184 Dir = DB.getDirectory();
2185 Fn = DB.getFilename();
2187 assert (0 && "Unexpected scope info");
2189 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2190 unsigned ID = MMI->NextLabelID();
2191 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2193 if (TimePassesIsEnabled)
2194 DebugTimer->stopTimer();
2199 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2200 /// timed. Look up the source id with the given directory and source file
2201 /// names. If none currently exists, create a new id and insert it in the
2202 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2204 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2205 const std::string &FileName) {
2206 if (TimePassesIsEnabled)
2207 DebugTimer->startTimer();
2209 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2211 if (TimePassesIsEnabled)
2212 DebugTimer->stopTimer();
2217 //===----------------------------------------------------------------------===//
2219 //===----------------------------------------------------------------------===//
2221 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2224 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2225 // Get the children.
2226 const std::vector<DIE *> &Children = Die->getChildren();
2228 // If not last sibling and has children then add sibling offset attribute.
2229 if (!Last && !Children.empty()) Die->addSiblingOffset();
2231 // Record the abbreviation.
2232 assignAbbrevNumber(Die->getAbbrev());
2234 // Get the abbreviation for this DIE.
2235 unsigned AbbrevNumber = Die->getAbbrevNumber();
2236 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2239 Die->setOffset(Offset);
2241 // Start the size with the size of abbreviation code.
2242 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2244 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2245 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2247 // Size the DIE attribute values.
2248 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2249 // Size attribute value.
2250 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2252 // Size the DIE children if any.
2253 if (!Children.empty()) {
2254 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2255 "Children flag not set");
2257 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2258 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2260 // End of children marker.
2261 Offset += sizeof(int8_t);
2264 Die->setSize(Offset - Die->getOffset());
2268 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2270 void DwarfDebug::computeSizeAndOffsets() {
2271 // Compute size of compile unit header.
2272 static unsigned Offset =
2273 sizeof(int32_t) + // Length of Compilation Unit Info
2274 sizeof(int16_t) + // DWARF version number
2275 sizeof(int32_t) + // Offset Into Abbrev. Section
2276 sizeof(int8_t); // Pointer Size (in bytes)
2278 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2279 CompileUnitOffsets[ModuleCU] = 0;
2282 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2283 /// tools to recognize the object file contains Dwarf information.
2284 void DwarfDebug::emitInitial() {
2285 // Check to see if we already emitted intial headers.
2286 if (didInitial) return;
2289 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2291 // Dwarf sections base addresses.
2292 if (MAI->doesDwarfRequireFrameSection()) {
2293 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2294 EmitLabel("section_debug_frame", 0);
2297 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2298 EmitLabel("section_info", 0);
2299 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2300 EmitLabel("section_abbrev", 0);
2301 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2302 EmitLabel("section_aranges", 0);
2304 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2305 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2306 EmitLabel("section_macinfo", 0);
2309 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2310 EmitLabel("section_line", 0);
2311 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2312 EmitLabel("section_loc", 0);
2313 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2314 EmitLabel("section_pubnames", 0);
2315 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2316 EmitLabel("section_pubtypes", 0);
2317 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2318 EmitLabel("section_str", 0);
2319 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2320 EmitLabel("section_ranges", 0);
2322 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2323 EmitLabel("text_begin", 0);
2324 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2325 EmitLabel("data_begin", 0);
2328 /// emitDIE - Recusively Emits a debug information entry.
2330 void DwarfDebug::emitDIE(DIE *Die) {
2331 // Get the abbreviation for this DIE.
2332 unsigned AbbrevNumber = Die->getAbbrevNumber();
2333 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2337 // Emit the code (index) for the abbreviation.
2338 Asm->EmitULEB128Bytes(AbbrevNumber);
2340 if (Asm->isVerbose())
2341 Asm->EOL(std::string("Abbrev [" +
2342 utostr(AbbrevNumber) +
2343 "] 0x" + utohexstr(Die->getOffset()) +
2344 ":0x" + utohexstr(Die->getSize()) + " " +
2345 dwarf::TagString(Abbrev->getTag())));
2349 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2350 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2352 // Emit the DIE attribute values.
2353 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2354 unsigned Attr = AbbrevData[i].getAttribute();
2355 unsigned Form = AbbrevData[i].getForm();
2356 assert(Form && "Too many attributes for DIE (check abbreviation)");
2359 case dwarf::DW_AT_sibling:
2360 Asm->EmitInt32(Die->getSiblingOffset());
2362 case dwarf::DW_AT_abstract_origin: {
2363 DIEEntry *E = cast<DIEEntry>(Values[i]);
2364 DIE *Origin = E->getEntry();
2365 unsigned Addr = Origin->getOffset();
2366 Asm->EmitInt32(Addr);
2370 // Emit an attribute using the defined form.
2371 Values[i]->EmitValue(this, Form);
2375 Asm->EOL(dwarf::AttributeString(Attr));
2378 // Emit the DIE children if any.
2379 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2380 const std::vector<DIE *> &Children = Die->getChildren();
2382 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2383 emitDIE(Children[j]);
2385 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2389 /// emitDebugInfo - Emit the debug info section.
2391 void DwarfDebug::emitDebugInfo() {
2392 // Start debug info section.
2393 Asm->OutStreamer.SwitchSection(
2394 Asm->getObjFileLowering().getDwarfInfoSection());
2395 DIE *Die = ModuleCU->getCUDie();
2397 // Emit the compile units header.
2398 EmitLabel("info_begin", ModuleCU->getID());
2400 // Emit size of content not including length itself
2401 unsigned ContentSize = Die->getSize() +
2402 sizeof(int16_t) + // DWARF version number
2403 sizeof(int32_t) + // Offset Into Abbrev. Section
2404 sizeof(int8_t) + // Pointer Size (in bytes)
2405 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2407 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
2408 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2409 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2410 Asm->EOL("Offset Into Abbrev. Section");
2411 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2414 // FIXME - extra padding for gdb bug.
2415 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2416 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2417 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2418 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2419 EmitLabel("info_end", ModuleCU->getID());
2424 /// emitAbbreviations - Emit the abbreviation section.
2426 void DwarfDebug::emitAbbreviations() const {
2427 // Check to see if it is worth the effort.
2428 if (!Abbreviations.empty()) {
2429 // Start the debug abbrev section.
2430 Asm->OutStreamer.SwitchSection(
2431 Asm->getObjFileLowering().getDwarfAbbrevSection());
2433 EmitLabel("abbrev_begin", 0);
2435 // For each abbrevation.
2436 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2437 // Get abbreviation data
2438 const DIEAbbrev *Abbrev = Abbreviations[i];
2440 // Emit the abbrevations code (base 1 index.)
2441 Asm->EmitULEB128Bytes(Abbrev->getNumber());
2442 Asm->EOL("Abbreviation Code");
2444 // Emit the abbreviations data.
2450 // Mark end of abbreviations.
2451 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2453 EmitLabel("abbrev_end", 0);
2458 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2459 /// the line matrix.
2461 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2462 // Define last address of section.
2463 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2464 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2465 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2466 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2468 // Mark end of matrix.
2469 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2470 Asm->EmitULEB128Bytes(1); Asm->EOL();
2471 Asm->EmitInt8(1); Asm->EOL();
2474 /// emitDebugLines - Emit source line information.
2476 void DwarfDebug::emitDebugLines() {
2477 // If the target is using .loc/.file, the assembler will be emitting the
2478 // .debug_line table automatically.
2479 if (MAI->hasDotLocAndDotFile())
2482 // Minimum line delta, thus ranging from -10..(255-10).
2483 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2484 // Maximum line delta, thus ranging from -10..(255-10).
2485 const int MaxLineDelta = 255 + MinLineDelta;
2487 // Start the dwarf line section.
2488 Asm->OutStreamer.SwitchSection(
2489 Asm->getObjFileLowering().getDwarfLineSection());
2491 // Construct the section header.
2492 EmitDifference("line_end", 0, "line_begin", 0, true);
2493 Asm->EOL("Length of Source Line Info");
2494 EmitLabel("line_begin", 0);
2496 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2498 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2499 Asm->EOL("Prolog Length");
2500 EmitLabel("line_prolog_begin", 0);
2502 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2504 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2506 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2508 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2510 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2512 // Line number standard opcode encodings argument count
2513 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2514 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2515 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2516 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2517 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2518 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2519 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2520 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2521 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2523 // Emit directories.
2524 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2525 Asm->EmitString(getSourceDirectoryName(DI));
2526 Asm->EOL("Directory");
2529 Asm->EmitInt8(0); Asm->EOL("End of directories");
2532 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2533 // Remember source id starts at 1.
2534 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2535 Asm->EmitString(getSourceFileName(Id.second));
2537 Asm->EmitULEB128Bytes(Id.first);
2538 Asm->EOL("Directory #");
2539 Asm->EmitULEB128Bytes(0);
2540 Asm->EOL("Mod date");
2541 Asm->EmitULEB128Bytes(0);
2542 Asm->EOL("File size");
2545 Asm->EmitInt8(0); Asm->EOL("End of files");
2547 EmitLabel("line_prolog_end", 0);
2549 // A sequence for each text section.
2550 unsigned SecSrcLinesSize = SectionSourceLines.size();
2552 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2553 // Isolate current sections line info.
2554 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2556 /*if (Asm->isVerbose()) {
2557 const MCSection *S = SectionMap[j + 1];
2558 O << '\t' << MAI->getCommentString() << " Section"
2559 << S->getName() << '\n';
2563 // Dwarf assumes we start with first line of first source file.
2564 unsigned Source = 1;
2567 // Construct rows of the address, source, line, column matrix.
2568 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2569 const SrcLineInfo &LineInfo = LineInfos[i];
2570 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2571 if (!LabelID) continue;
2573 if (LineInfo.getLine() == 0) continue;
2575 if (!Asm->isVerbose())
2578 std::pair<unsigned, unsigned> SourceID =
2579 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2580 O << '\t' << MAI->getCommentString() << ' '
2581 << getSourceDirectoryName(SourceID.first) << '/'
2582 << getSourceFileName(SourceID.second)
2583 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2586 // Define the line address.
2587 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2588 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2589 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2590 EmitReference("label", LabelID); Asm->EOL("Location label");
2592 // If change of source, then switch to the new source.
2593 if (Source != LineInfo.getSourceID()) {
2594 Source = LineInfo.getSourceID();
2595 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2596 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2599 // If change of line.
2600 if (Line != LineInfo.getLine()) {
2601 // Determine offset.
2602 int Offset = LineInfo.getLine() - Line;
2603 int Delta = Offset - MinLineDelta;
2606 Line = LineInfo.getLine();
2608 // If delta is small enough and in range...
2609 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2610 // ... then use fast opcode.
2611 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2613 // ... otherwise use long hand.
2614 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2615 Asm->EOL("DW_LNS_advance_line");
2616 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2617 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2620 // Copy the previous row (different address or source)
2621 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2625 emitEndOfLineMatrix(j + 1);
2628 if (SecSrcLinesSize == 0)
2629 // Because we're emitting a debug_line section, we still need a line
2630 // table. The linker and friends expect it to exist. If there's nothing to
2631 // put into it, emit an empty table.
2632 emitEndOfLineMatrix(1);
2634 EmitLabel("line_end", 0);
2638 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2640 void DwarfDebug::emitCommonDebugFrame() {
2641 if (!MAI->doesDwarfRequireFrameSection())
2645 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2646 TargetFrameInfo::StackGrowsUp ?
2647 TD->getPointerSize() : -TD->getPointerSize();
2649 // Start the dwarf frame section.
2650 Asm->OutStreamer.SwitchSection(
2651 Asm->getObjFileLowering().getDwarfFrameSection());
2653 EmitLabel("debug_frame_common", 0);
2654 EmitDifference("debug_frame_common_end", 0,
2655 "debug_frame_common_begin", 0, true);
2656 Asm->EOL("Length of Common Information Entry");
2658 EmitLabel("debug_frame_common_begin", 0);
2659 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2660 Asm->EOL("CIE Identifier Tag");
2661 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2662 Asm->EOL("CIE Version");
2663 Asm->EmitString("");
2664 Asm->EOL("CIE Augmentation");
2665 Asm->EmitULEB128Bytes(1);
2666 Asm->EOL("CIE Code Alignment Factor");
2667 Asm->EmitSLEB128Bytes(stackGrowth);
2668 Asm->EOL("CIE Data Alignment Factor");
2669 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2670 Asm->EOL("CIE RA Column");
2672 std::vector<MachineMove> Moves;
2673 RI->getInitialFrameState(Moves);
2675 EmitFrameMoves(NULL, 0, Moves, false);
2677 Asm->EmitAlignment(2, 0, 0, false);
2678 EmitLabel("debug_frame_common_end", 0);
2683 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2686 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2687 if (!MAI->doesDwarfRequireFrameSection())
2690 // Start the dwarf frame section.
2691 Asm->OutStreamer.SwitchSection(
2692 Asm->getObjFileLowering().getDwarfFrameSection());
2694 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2695 "debug_frame_begin", DebugFrameInfo.Number, true);
2696 Asm->EOL("Length of Frame Information Entry");
2698 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2700 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2702 Asm->EOL("FDE CIE offset");
2704 EmitReference("func_begin", DebugFrameInfo.Number);
2705 Asm->EOL("FDE initial location");
2706 EmitDifference("func_end", DebugFrameInfo.Number,
2707 "func_begin", DebugFrameInfo.Number);
2708 Asm->EOL("FDE address range");
2710 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2713 Asm->EmitAlignment(2, 0, 0, false);
2714 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2719 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2721 void DwarfDebug::emitDebugPubNames() {
2722 // Start the dwarf pubnames section.
2723 Asm->OutStreamer.SwitchSection(
2724 Asm->getObjFileLowering().getDwarfPubNamesSection());
2726 EmitDifference("pubnames_end", ModuleCU->getID(),
2727 "pubnames_begin", ModuleCU->getID(), true);
2728 Asm->EOL("Length of Public Names Info");
2730 EmitLabel("pubnames_begin", ModuleCU->getID());
2732 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2734 EmitSectionOffset("info_begin", "section_info",
2735 ModuleCU->getID(), 0, true, false);
2736 Asm->EOL("Offset of Compilation Unit Info");
2738 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2740 Asm->EOL("Compilation Unit Length");
2742 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2743 for (StringMap<DIE*>::const_iterator
2744 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2745 const char *Name = GI->getKeyData();
2746 DIE * Entity = GI->second;
2748 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2749 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2752 Asm->EmitInt32(0); Asm->EOL("End Mark");
2753 EmitLabel("pubnames_end", ModuleCU->getID());
2758 void DwarfDebug::emitDebugPubTypes() {
2759 // Start the dwarf pubnames section.
2760 Asm->OutStreamer.SwitchSection(
2761 Asm->getObjFileLowering().getDwarfPubTypesSection());
2762 EmitDifference("pubtypes_end", ModuleCU->getID(),
2763 "pubtypes_begin", ModuleCU->getID(), true);
2764 Asm->EOL("Length of Public Types Info");
2766 EmitLabel("pubtypes_begin", ModuleCU->getID());
2768 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2770 EmitSectionOffset("info_begin", "section_info",
2771 ModuleCU->getID(), 0, true, false);
2772 Asm->EOL("Offset of Compilation ModuleCU Info");
2774 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2776 Asm->EOL("Compilation ModuleCU Length");
2778 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2779 for (StringMap<DIE*>::const_iterator
2780 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2781 const char *Name = GI->getKeyData();
2782 DIE * Entity = GI->second;
2784 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2785 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2788 Asm->EmitInt32(0); Asm->EOL("End Mark");
2789 EmitLabel("pubtypes_end", ModuleCU->getID());
2794 /// emitDebugStr - Emit visible names into a debug str section.
2796 void DwarfDebug::emitDebugStr() {
2797 // Check to see if it is worth the effort.
2798 if (!StringPool.empty()) {
2799 // Start the dwarf str section.
2800 Asm->OutStreamer.SwitchSection(
2801 Asm->getObjFileLowering().getDwarfStrSection());
2803 // For each of strings in the string pool.
2804 for (unsigned StringID = 1, N = StringPool.size();
2805 StringID <= N; ++StringID) {
2806 // Emit a label for reference from debug information entries.
2807 EmitLabel("string", StringID);
2809 // Emit the string itself.
2810 const std::string &String = StringPool[StringID];
2811 Asm->EmitString(String); Asm->EOL();
2818 /// emitDebugLoc - Emit visible names into a debug loc section.
2820 void DwarfDebug::emitDebugLoc() {
2821 // Start the dwarf loc section.
2822 Asm->OutStreamer.SwitchSection(
2823 Asm->getObjFileLowering().getDwarfLocSection());
2827 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2829 void DwarfDebug::EmitDebugARanges() {
2830 // Start the dwarf aranges section.
2831 Asm->OutStreamer.SwitchSection(
2832 Asm->getObjFileLowering().getDwarfARangesSection());
2836 CompileUnit *Unit = GetBaseCompileUnit();
2838 // Don't include size of length
2839 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
2841 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2843 EmitReference("info_begin", Unit->getID());
2844 Asm->EOL("Offset of Compilation Unit Info");
2846 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2848 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2850 Asm->EmitInt16(0); Asm->EOL("Pad (1)");
2851 Asm->EmitInt16(0); Asm->EOL("Pad (2)");
2854 EmitReference("text_begin", 0); Asm->EOL("Address");
2855 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2857 Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2858 Asm->EmitInt32(0); Asm->EOL("EOM (2)");
2864 /// emitDebugRanges - Emit visible names into a debug ranges section.
2866 void DwarfDebug::emitDebugRanges() {
2867 // Start the dwarf ranges section.
2868 Asm->OutStreamer.SwitchSection(
2869 Asm->getObjFileLowering().getDwarfRangesSection());
2873 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2875 void DwarfDebug::emitDebugMacInfo() {
2876 if (const MCSection *LineInfo =
2877 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2878 // Start the dwarf macinfo section.
2879 Asm->OutStreamer.SwitchSection(LineInfo);
2884 /// emitDebugInlineInfo - Emit inline info using following format.
2886 /// 1. length of section
2887 /// 2. Dwarf version number
2888 /// 3. address size.
2890 /// Entries (one "entry" for each function that was inlined):
2892 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2893 /// otherwise offset into __debug_str for regular function name.
2894 /// 2. offset into __debug_str section for regular function name.
2895 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2896 /// instances for the function.
2898 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2899 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2900 /// __debug_info section, and the low_pc is the starting address for the
2901 /// inlining instance.
2902 void DwarfDebug::emitDebugInlineInfo() {
2903 if (!MAI->doesDwarfUsesInlineInfoSection())
2909 Asm->OutStreamer.SwitchSection(
2910 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2912 EmitDifference("debug_inlined_end", 1,
2913 "debug_inlined_begin", 1, true);
2914 Asm->EOL("Length of Debug Inlined Information Entry");
2916 EmitLabel("debug_inlined_begin", 1);
2918 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2919 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2921 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2922 E = InlinedSPNodes.end(); I != E; ++I) {
2925 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2926 = InlineInfo.find(Node);
2927 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2928 DISubprogram SP(Node);
2929 StringRef LName = SP.getLinkageName();
2930 StringRef Name = SP.getName();
2933 Asm->EmitString(Name);
2935 EmitSectionOffset("string", "section_str",
2936 StringPool.idFor(getRealLinkageName(LName)), false, true);
2938 Asm->EOL("MIPS linkage name");
2939 EmitSectionOffset("string", "section_str",
2940 StringPool.idFor(Name), false, true);
2941 Asm->EOL("Function name");
2942 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2944 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2945 LE = Labels.end(); LI != LE; ++LI) {
2946 DIE *SP = LI->second;
2947 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2949 if (TD->getPointerSize() == sizeof(int32_t))
2950 O << MAI->getData32bitsDirective();
2952 O << MAI->getData64bitsDirective();
2954 PrintLabelName("label", LI->first); Asm->EOL("low_pc");
2958 EmitLabel("debug_inlined_end", 1);