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 FieldOffset = Offset;
1093 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1094 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1095 FieldOffset = (HiMark - FieldSize);
1096 Offset -= FieldOffset;
1098 // Maybe we need to work from the other end.
1099 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1100 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1102 // Here WD_AT_data_member_location points to the anonymous
1103 // field that includes this bit field.
1104 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1107 // This is not a bitfield.
1108 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1110 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1112 if (DT.isProtected())
1113 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1114 dwarf::DW_ACCESS_protected);
1115 else if (DT.isPrivate())
1116 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1117 dwarf::DW_ACCESS_private);
1118 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1119 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1120 dwarf::DW_ACCESS_public);
1122 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1123 dwarf::DW_VIRTUALITY_virtual);
1127 /// createSubprogramDIE - Create new DIE using SP.
1128 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1129 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1133 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1134 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1136 StringRef LinkageName = SP.getLinkageName();
1137 if (!LinkageName.empty())
1138 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1139 getRealLinkageName(LinkageName));
1141 addSourceLine(SPDie, &SP);
1143 // Add prototyped tag, if C or ObjC.
1144 unsigned Lang = SP.getCompileUnit().getLanguage();
1145 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1146 Lang == dwarf::DW_LANG_ObjC)
1147 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1150 DICompositeType SPTy = SP.getType();
1151 DIArray Args = SPTy.getTypeArray();
1152 unsigned SPTag = SPTy.getTag();
1154 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1155 addType(SPDie, SPTy);
1157 addType(SPDie, DIType(Args.getElement(0).getNode()));
1159 unsigned VK = SP.getVirtuality();
1161 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1162 DIEBlock *Block = new DIEBlock();
1163 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1164 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1165 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1166 ContainingTypeMap.insert(std::make_pair(SPDie, WeakVH(SP.getContainingType().getNode())));
1169 if (MakeDecl || !SP.isDefinition()) {
1170 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1172 // Add arguments. Do not add arguments for subprogram definition. They will
1173 // be handled while processing variables.
1174 DICompositeType SPTy = SP.getType();
1175 DIArray Args = SPTy.getTypeArray();
1176 unsigned SPTag = SPTy.getTag();
1178 if (SPTag == dwarf::DW_TAG_subroutine_type)
1179 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1180 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1181 addType(Arg, DIType(Args.getElement(i).getNode()));
1182 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1183 SPDie->addChild(Arg);
1187 // DW_TAG_inlined_subroutine may refer to this DIE.
1188 ModuleCU->insertDIE(SP.getNode(), SPDie);
1192 /// findCompileUnit - Get the compile unit for the given descriptor.
1194 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1195 DenseMap<Value *, CompileUnit *>::const_iterator I =
1196 CompileUnitMap.find(Unit.getNode());
1197 if (I == CompileUnitMap.end())
1198 return constructCompileUnit(Unit.getNode());
1202 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1203 /// Initialize scope and update scope hierarchy.
1204 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1205 MDNode *InlinedAt) {
1206 assert (N && "Invalid Scope encoding!");
1207 assert (MI && "Missing machine instruction!");
1208 bool GetConcreteScope = (MI && InlinedAt);
1210 DbgScope *NScope = NULL;
1213 NScope = DbgScopeMap.lookup(InlinedAt);
1215 NScope = DbgScopeMap.lookup(N);
1216 assert (NScope && "Unable to find working scope!");
1218 if (NScope->getFirstInsn())
1221 DbgScope *Parent = NULL;
1222 if (GetConcreteScope) {
1223 DILocation IL(InlinedAt);
1224 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1225 IL.getOrigLocation().getNode());
1226 assert (Parent && "Unable to find Parent scope!");
1227 NScope->setParent(Parent);
1228 Parent->addScope(NScope);
1229 } else if (DIDescriptor(N).isLexicalBlock()) {
1230 DILexicalBlock DB(N);
1231 if (!DB.getContext().isNull()) {
1232 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1233 NScope->setParent(Parent);
1234 Parent->addScope(NScope);
1238 NScope->setFirstInsn(MI);
1240 if (!Parent && !InlinedAt) {
1241 StringRef SPName = DISubprogram(N).getLinkageName();
1242 if (SPName == MF->getFunction()->getName())
1243 CurrentFnDbgScope = NScope;
1246 if (GetConcreteScope) {
1247 ConcreteScopes[InlinedAt] = NScope;
1248 getOrCreateAbstractScope(N);
1254 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1255 assert (N && "Invalid Scope encoding!");
1257 DbgScope *AScope = AbstractScopes.lookup(N);
1261 DbgScope *Parent = NULL;
1263 DIDescriptor Scope(N);
1264 if (Scope.isLexicalBlock()) {
1265 DILexicalBlock DB(N);
1266 DIDescriptor ParentDesc = DB.getContext();
1267 if (!ParentDesc.isNull())
1268 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1271 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1274 Parent->addScope(AScope);
1275 AScope->setAbstractScope();
1276 AbstractScopes[N] = AScope;
1277 if (DIDescriptor(N).isSubprogram())
1278 AbstractScopesList.push_back(AScope);
1282 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1283 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1284 /// If there are global variables in this scope then create and insert
1285 /// DIEs for these variables.
1286 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1288 DIE *SPDie = ModuleCU->getDIE(SPNode);
1289 assert (SPDie && "Unable to find subprogram DIE!");
1290 DISubprogram SP(SPNode);
1291 if (SP.isDefinition() && !SP.getContext().isCompileUnit()) {
1292 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1294 DICompositeType SPTy = SP.getType();
1295 DIArray Args = SPTy.getTypeArray();
1296 unsigned SPTag = SPTy.getTag();
1297 if (SPTag == dwarf::DW_TAG_subroutine_type)
1298 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1299 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1300 addType(Arg, DIType(Args.getElement(i).getNode()));
1301 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1302 SPDie->addChild(Arg);
1304 DIE *SPDeclDie = SPDie;
1305 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1306 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1308 ModuleCU->addDie(SPDie);
1311 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1312 DWLabel("func_begin", SubprogramCount));
1313 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1314 DWLabel("func_end", SubprogramCount));
1315 MachineLocation Location(RI->getFrameRegister(*MF));
1316 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1318 if (!DISubprogram(SPNode).isLocalToUnit())
1319 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1324 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1325 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1326 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1327 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1328 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1330 // Ignore empty scopes.
1331 if (StartID == EndID && StartID != 0)
1334 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1335 if (Scope->isAbstractScope())
1338 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1340 DWLabel("label", StartID)
1341 : DWLabel("func_begin", SubprogramCount));
1342 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1344 DWLabel("label", EndID)
1345 : DWLabel("func_end", SubprogramCount));
1352 /// constructInlinedScopeDIE - This scope represents inlined body of
1353 /// a function. Construct DIE to represent this concrete inlined copy
1354 /// of the function.
1355 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1356 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1357 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1358 assert (StartID && "Invalid starting label for an inlined scope!");
1359 assert (EndID && "Invalid end label for an inlined scope!");
1360 // Ignore empty scopes.
1361 if (StartID == EndID && StartID != 0)
1364 DIScope DS(Scope->getScopeNode());
1367 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1369 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1370 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1371 assert (OriginDIE && "Unable to find Origin DIE!");
1372 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1373 dwarf::DW_FORM_ref4, OriginDIE);
1375 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1376 DWLabel("label", StartID));
1377 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1378 DWLabel("label", EndID));
1380 InlinedSubprogramDIEs.insert(OriginDIE);
1382 // Track the start label for this inlined function.
1383 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1384 I = InlineInfo.find(InlinedSP.getNode());
1386 if (I == InlineInfo.end()) {
1387 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1389 InlinedSPNodes.push_back(InlinedSP.getNode());
1391 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1393 StringPool.insert(InlinedSP.getName());
1394 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1396 DILocation DL(Scope->getInlinedAt());
1397 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1398 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1404 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1405 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1406 // Get the descriptor.
1407 const DIVariable &VD = DV->getVariable();
1408 StringRef Name = VD.getName();
1412 // Translate tag to proper Dwarf tag. The result variable is dropped for
1415 switch (VD.getTag()) {
1416 case dwarf::DW_TAG_return_variable:
1418 case dwarf::DW_TAG_arg_variable:
1419 Tag = dwarf::DW_TAG_formal_parameter;
1421 case dwarf::DW_TAG_auto_variable: // fall thru
1423 Tag = dwarf::DW_TAG_variable;
1427 // Define variable debug information entry.
1428 DIE *VariableDie = new DIE(Tag);
1432 if (DbgVariable *AV = DV->getAbstractVariable())
1433 AbsDIE = AV->getDIE();
1436 DIScope DS(Scope->getScopeNode());
1437 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1438 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1440 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1441 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1442 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1443 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1444 dwarf::DW_FORM_ref4, AbsDIE);
1447 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1448 addSourceLine(VariableDie, &VD);
1450 // Add variable type.
1451 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1452 // addresses instead.
1453 if (VD.isBlockByrefVariable())
1454 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1456 addType(VariableDie, VD.getType());
1459 // Add variable address.
1460 if (!Scope->isAbstractScope()) {
1461 MachineLocation Location;
1463 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1464 Location.set(FrameReg, Offset);
1466 if (VD.hasComplexAddress())
1467 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1468 else if (VD.isBlockByrefVariable())
1469 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1471 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1473 DV->setDIE(VariableDie);
1478 void DwarfDebug::addPubTypes(DISubprogram SP) {
1479 DICompositeType SPTy = SP.getType();
1480 unsigned SPTag = SPTy.getTag();
1481 if (SPTag != dwarf::DW_TAG_subroutine_type)
1484 DIArray Args = SPTy.getTypeArray();
1488 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1489 DIType ATy(Args.getElement(i).getNode());
1492 DICompositeType CATy = getDICompositeType(ATy);
1493 if (!CATy.isNull() && !CATy.getName().empty()) {
1494 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1495 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1500 /// constructScopeDIE - Construct a DIE for this scope.
1501 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1504 DIScope DS(Scope->getScopeNode());
1508 DIE *ScopeDIE = NULL;
1509 if (Scope->getInlinedAt())
1510 ScopeDIE = constructInlinedScopeDIE(Scope);
1511 else if (DS.isSubprogram()) {
1512 if (Scope->isAbstractScope())
1513 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1515 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1518 ScopeDIE = constructLexicalScopeDIE(Scope);
1519 if (!ScopeDIE) return NULL;
1522 // Add variables to scope.
1523 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1524 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1525 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1527 ScopeDIE->addChild(VariableDIE);
1530 // Add nested scopes.
1531 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1532 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1533 // Define the Scope debug information entry.
1534 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1536 ScopeDIE->addChild(NestedDIE);
1539 if (DS.isSubprogram())
1540 addPubTypes(DISubprogram(DS.getNode()));
1545 /// GetOrCreateSourceID - Look up the source id with the given directory and
1546 /// source file names. If none currently exists, create a new id and insert it
1547 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1549 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1551 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1552 if (DI != DirectoryIdMap.end()) {
1553 DId = DI->getValue();
1555 DId = DirectoryNames.size() + 1;
1556 DirectoryIdMap[DirName] = DId;
1557 DirectoryNames.push_back(DirName);
1561 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1562 if (FI != SourceFileIdMap.end()) {
1563 FId = FI->getValue();
1565 FId = SourceFileNames.size() + 1;
1566 SourceFileIdMap[FileName] = FId;
1567 SourceFileNames.push_back(FileName);
1570 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1571 SourceIdMap.find(std::make_pair(DId, FId));
1572 if (SI != SourceIdMap.end())
1575 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1576 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1577 SourceIds.push_back(std::make_pair(DId, FId));
1582 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1583 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1584 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1587 NDie = new DIE(dwarf::DW_TAG_namespace);
1588 ModuleCU->insertDIE(NS.getNode(), NDie);
1589 if (!NS.getName().empty())
1590 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1591 addSourceLine(NDie, &NS);
1592 addToContextOwner(NDie, NS.getContext());
1596 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1597 DICompileUnit DIUnit(N);
1598 StringRef FN = DIUnit.getFilename();
1599 StringRef Dir = DIUnit.getDirectory();
1600 unsigned ID = GetOrCreateSourceID(Dir, FN);
1602 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1603 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1604 DWLabel("section_line", 0), DWLabel("section_line", 0),
1606 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1607 DIUnit.getProducer());
1608 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1609 DIUnit.getLanguage());
1610 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1613 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1614 if (DIUnit.isOptimized())
1615 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1617 StringRef Flags = DIUnit.getFlags();
1619 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1621 unsigned RVer = DIUnit.getRunTimeVersion();
1623 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1624 dwarf::DW_FORM_data1, RVer);
1626 CompileUnit *Unit = new CompileUnit(ID, Die);
1627 if (!ModuleCU && DIUnit.isMain()) {
1628 // Use first compile unit marked as isMain as the compile unit
1633 CompileUnitMap[DIUnit.getNode()] = Unit;
1634 CompileUnits.push_back(Unit);
1638 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1639 DIGlobalVariable DI_GV(N);
1641 // If debug information is malformed then ignore it.
1642 if (DI_GV.Verify() == false)
1645 // Check for pre-existence.
1646 if (ModuleCU->getDIE(DI_GV.getNode()))
1649 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1654 ModuleCU->insertDIE(N, VariableDie);
1656 // Add to context owner.
1657 if (DI_GV.isDefinition()
1658 && !DI_GV.getContext().isCompileUnit()) {
1659 // Create specification DIE.
1660 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1661 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1662 dwarf::DW_FORM_ref4, VariableDie);
1663 DIEBlock *Block = new DIEBlock();
1664 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1665 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1666 Asm->Mang->getMangledName(DI_GV.getGlobal()));
1667 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1668 ModuleCU->addDie(VariableSpecDIE);
1670 DIEBlock *Block = new DIEBlock();
1671 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1672 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1673 Asm->Mang->getMangledName(DI_GV.getGlobal()));
1674 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1676 addToContextOwner(VariableDie, DI_GV.getContext());
1678 // Expose as global. FIXME - need to check external flag.
1679 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1681 DIType GTy = DI_GV.getType();
1682 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1683 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1684 assert (Entry && "Missing global type!");
1685 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1690 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1693 // Check for pre-existence.
1694 if (ModuleCU->getDIE(N))
1697 if (!SP.isDefinition())
1698 // This is a method declaration which will be handled while constructing
1702 DIE *SubprogramDie = createSubprogramDIE(SP);
1705 ModuleCU->insertDIE(N, SubprogramDie);
1707 // Add to context owner.
1708 addToContextOwner(SubprogramDie, SP.getContext());
1710 // Expose as global.
1711 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1716 /// beginModule - Emit all Dwarf sections that should come prior to the
1717 /// content. Create global DIEs and emit initial debug info sections.
1718 /// This is inovked by the target AsmPrinter.
1719 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1722 if (TimePassesIsEnabled)
1723 DebugTimer->startTimer();
1725 if (!MAI->doesSupportDebugInformation())
1728 DebugInfoFinder DbgFinder;
1729 DbgFinder.processModule(*M);
1731 // Create all the compile unit DIEs.
1732 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1733 E = DbgFinder.compile_unit_end(); I != E; ++I)
1734 constructCompileUnit(*I);
1736 if (CompileUnits.empty()) {
1737 if (TimePassesIsEnabled)
1738 DebugTimer->stopTimer();
1743 // If main compile unit for this module is not seen than randomly
1744 // select first compile unit.
1746 ModuleCU = CompileUnits[0];
1748 // Create DIEs for each subprogram.
1749 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1750 E = DbgFinder.subprogram_end(); I != E; ++I)
1751 constructSubprogramDIE(*I);
1753 // Create DIEs for each global variable.
1754 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1755 E = DbgFinder.global_variable_end(); I != E; ++I)
1756 constructGlobalVariableDIE(*I);
1760 MMI->setDebugInfoAvailability(true);
1762 // Prime section data.
1763 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1765 // Print out .file directives to specify files for .loc directives. These are
1766 // printed out early so that they precede any .loc directives.
1767 if (MAI->hasDotLocAndDotFile()) {
1768 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1769 // Remember source id starts at 1.
1770 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1771 sys::Path FullPath(getSourceDirectoryName(Id.first));
1773 FullPath.appendComponent(getSourceFileName(Id.second));
1774 assert(AppendOk && "Could not append filename to directory!");
1776 Asm->EmitFile(i, FullPath.str());
1781 // Emit initial sections
1784 if (TimePassesIsEnabled)
1785 DebugTimer->stopTimer();
1788 /// endModule - Emit all Dwarf sections that should come after the content.
1790 void DwarfDebug::endModule() {
1794 if (TimePassesIsEnabled)
1795 DebugTimer->startTimer();
1797 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1798 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1799 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1801 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1804 // Insert top level DIEs.
1805 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1806 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1807 ModuleCU->getCUDie()->addChild(*TI);
1809 for (DenseMap<DIE *, WeakVH>::iterator CI = ContainingTypeMap.begin(),
1810 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1811 DIE *SPDie = CI->first;
1812 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1814 DIE *NDie = ModuleCU->getDIE(N);
1815 if (!NDie) continue;
1816 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1817 addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1820 // Standard sections final addresses.
1821 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1822 EmitLabel("text_end", 0);
1823 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1824 EmitLabel("data_end", 0);
1826 // End text sections.
1827 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1828 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1829 EmitLabel("section_end", i);
1832 // Emit common frame information.
1833 emitCommonDebugFrame();
1835 // Emit function debug frame information
1836 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1837 E = DebugFrames.end(); I != E; ++I)
1838 emitFunctionDebugFrame(*I);
1840 // Compute DIE offsets and sizes.
1841 computeSizeAndOffsets();
1843 // Emit all the DIEs into a debug info section
1846 // Corresponding abbreviations into a abbrev section.
1847 emitAbbreviations();
1849 // Emit source line correspondence into a debug line section.
1852 // Emit info into a debug pubnames section.
1853 emitDebugPubNames();
1855 // Emit info into a debug pubtypes section.
1856 emitDebugPubTypes();
1858 // Emit info into a debug str section.
1861 // Emit info into a debug loc section.
1864 // Emit info into a debug aranges section.
1867 // Emit info into a debug ranges section.
1870 // Emit info into a debug macinfo section.
1873 // Emit inline info.
1874 emitDebugInlineInfo();
1876 if (TimePassesIsEnabled)
1877 DebugTimer->stopTimer();
1880 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1881 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1883 DILocation &ScopeLoc) {
1885 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1887 return AbsDbgVariable;
1889 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1893 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1894 Scope->addVariable(AbsDbgVariable);
1895 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1896 return AbsDbgVariable;
1899 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1900 void DwarfDebug::collectVariableInfo() {
1903 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1904 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1905 VE = VMap.end(); VI != VE; ++VI) {
1906 MetadataBase *MB = VI->first;
1907 MDNode *Var = dyn_cast_or_null<MDNode>(MB);
1909 DIVariable DV (Var);
1910 std::pair< unsigned, MDNode *> VP = VI->second;
1911 DILocation ScopeLoc(VP.second);
1914 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1916 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1917 // If variable scope is not found then skip this variable.
1921 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1922 Scope->addVariable(RegVar);
1923 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1925 RegVar->setAbstractVariable(AbsDbgVariable);
1929 /// beginScope - Process beginning of a scope starting at Label.
1930 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1931 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1932 if (I == DbgScopeBeginMap.end())
1934 ScopeVector &SD = I->second;
1935 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1937 (*SDI)->setStartLabelID(Label);
1940 /// endScope - Process end of a scope.
1941 void DwarfDebug::endScope(const MachineInstr *MI) {
1942 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1943 if (I == DbgScopeEndMap.end())
1946 unsigned Label = MMI->NextLabelID();
1947 Asm->printLabel(Label);
1950 SmallVector<DbgScope *, 2> &SD = I->second;
1951 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1953 (*SDI)->setEndLabelID(Label);
1957 /// createDbgScope - Create DbgScope for the scope.
1958 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1961 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1964 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1965 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1966 if (DIDescriptor(Scope).isLexicalBlock())
1967 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1971 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1975 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1976 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1977 DILocation DL(InlinedAt);
1978 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1981 /// extractScopeInformation - Scan machine instructions in this function
1982 /// and collect DbgScopes. Return true, if atleast one scope was found.
1983 bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
1984 // If scope information was extracted using .dbg intrinsics then there is not
1985 // any need to extract these information by scanning each instruction.
1986 if (!DbgScopeMap.empty())
1989 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
1990 unsigned MIIndex = 0;
1991 // Scan each instruction and create scopes. First build working set of scopes.
1992 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1994 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1996 const MachineInstr *MInsn = II;
1997 MIIndexMap[MInsn] = MIIndex++;
1998 DebugLoc DL = MInsn->getDebugLoc();
1999 if (DL.isUnknown()) continue;
2000 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
2001 if (!DLT.Scope) continue;
2002 // There is no need to create another DIE for compile unit. For all
2003 // other scopes, create one DbgScope now. This will be translated
2004 // into a scope DIE at the end.
2005 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
2006 createDbgScope(DLT.Scope, DLT.InlinedAtLoc);
2011 // Build scope hierarchy using working set of scopes.
2012 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2014 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2016 const MachineInstr *MInsn = II;
2017 DebugLoc DL = MInsn->getDebugLoc();
2018 if (DL.isUnknown()) continue;
2019 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
2020 if (!DLT.Scope) continue;
2021 // There is no need to create another DIE for compile unit. For all
2022 // other scopes, create one DbgScope now. This will be translated
2023 // into a scope DIE at the end.
2024 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
2025 DbgScope *Scope = getUpdatedDbgScope(DLT.Scope, MInsn, DLT.InlinedAtLoc);
2026 Scope->setLastInsn(MInsn);
2030 if (!CurrentFnDbgScope)
2033 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2035 // Each scope has first instruction and last instruction to mark beginning
2036 // and end of a scope respectively. Create an inverse map that list scopes
2037 // starts (and ends) with an instruction. One instruction may start (or end)
2039 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
2040 DE = DbgScopeMap.end(); DI != DE; ++DI) {
2041 DbgScope *S = DI->second;
2042 if (S->isAbstractScope())
2044 const MachineInstr *MI = S->getFirstInsn();
2045 assert (MI && "DbgScope does not have first instruction!");
2047 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2048 if (IDI != DbgScopeBeginMap.end())
2049 IDI->second.push_back(S);
2051 DbgScopeBeginMap[MI].push_back(S);
2053 MI = S->getLastInsn();
2054 assert (MI && "DbgScope does not have last instruction!");
2055 IDI = DbgScopeEndMap.find(MI);
2056 if (IDI != DbgScopeEndMap.end())
2057 IDI->second.push_back(S);
2059 DbgScopeEndMap[MI].push_back(S);
2062 return !DbgScopeMap.empty();
2065 /// beginFunction - Gather pre-function debug information. Assumes being
2066 /// emitted immediately after the function entry point.
2067 void DwarfDebug::beginFunction(MachineFunction *MF) {
2070 if (!ShouldEmitDwarfDebug()) return;
2072 if (TimePassesIsEnabled)
2073 DebugTimer->startTimer();
2075 if (!extractScopeInformation(MF))
2078 collectVariableInfo();
2080 // Begin accumulating function debug information.
2081 MMI->BeginFunction(MF);
2083 // Assumes in correct section after the entry point.
2084 EmitLabel("func_begin", ++SubprogramCount);
2086 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2088 DebugLoc FDL = MF->getDefaultDebugLoc();
2089 if (!FDL.isUnknown()) {
2090 DebugLocTuple DLT = MF->getDebugLocTuple(FDL);
2091 unsigned LabelID = 0;
2092 DISubprogram SP = getDISubprogram(DLT.Scope);
2094 LabelID = recordSourceLine(SP.getLineNumber(), 0, DLT.Scope);
2096 LabelID = recordSourceLine(DLT.Line, DLT.Col, DLT.Scope);
2097 Asm->printLabel(LabelID);
2100 if (TimePassesIsEnabled)
2101 DebugTimer->stopTimer();
2104 /// endFunction - Gather and emit post-function debug information.
2106 void DwarfDebug::endFunction(MachineFunction *MF) {
2107 if (!ShouldEmitDwarfDebug()) return;
2109 if (TimePassesIsEnabled)
2110 DebugTimer->startTimer();
2112 if (DbgScopeMap.empty())
2115 if (CurrentFnDbgScope) {
2116 // Define end label for subprogram.
2117 EmitLabel("func_end", SubprogramCount);
2119 // Get function line info.
2120 if (!Lines.empty()) {
2121 // Get section line info.
2122 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2123 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2124 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2125 // Append the function info to section info.
2126 SectionLineInfos.insert(SectionLineInfos.end(),
2127 Lines.begin(), Lines.end());
2130 // Construct abstract scopes.
2131 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2132 AE = AbstractScopesList.end(); AI != AE; ++AI)
2133 constructScopeDIE(*AI);
2135 constructScopeDIE(CurrentFnDbgScope);
2137 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2138 MMI->getFrameMoves()));
2142 CurrentFnDbgScope = NULL;
2143 DbgScopeMap.clear();
2144 DbgScopeBeginMap.clear();
2145 DbgScopeEndMap.clear();
2146 ConcreteScopes.clear();
2147 AbstractScopesList.clear();
2151 if (TimePassesIsEnabled)
2152 DebugTimer->stopTimer();
2155 /// recordSourceLine - Records location information and associates it with a
2156 /// label. Returns a unique label ID used to generate a label and provide
2157 /// correspondence to the source line list.
2158 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2163 if (TimePassesIsEnabled)
2164 DebugTimer->startTimer();
2169 DIDescriptor Scope(S);
2170 if (Scope.isCompileUnit()) {
2171 DICompileUnit CU(S);
2172 Dir = CU.getDirectory();
2173 Fn = CU.getFilename();
2174 } else if (Scope.isSubprogram()) {
2176 Dir = SP.getDirectory();
2177 Fn = SP.getFilename();
2178 } else if (Scope.isLexicalBlock()) {
2179 DILexicalBlock DB(S);
2180 Dir = DB.getDirectory();
2181 Fn = DB.getFilename();
2183 assert (0 && "Unexpected scope info");
2185 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2186 unsigned ID = MMI->NextLabelID();
2187 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2189 if (TimePassesIsEnabled)
2190 DebugTimer->stopTimer();
2195 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2196 /// timed. Look up the source id with the given directory and source file
2197 /// names. If none currently exists, create a new id and insert it in the
2198 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2200 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2201 const std::string &FileName) {
2202 if (TimePassesIsEnabled)
2203 DebugTimer->startTimer();
2205 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2207 if (TimePassesIsEnabled)
2208 DebugTimer->stopTimer();
2213 //===----------------------------------------------------------------------===//
2215 //===----------------------------------------------------------------------===//
2217 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2220 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2221 // Get the children.
2222 const std::vector<DIE *> &Children = Die->getChildren();
2224 // If not last sibling and has children then add sibling offset attribute.
2225 if (!Last && !Children.empty()) Die->addSiblingOffset();
2227 // Record the abbreviation.
2228 assignAbbrevNumber(Die->getAbbrev());
2230 // Get the abbreviation for this DIE.
2231 unsigned AbbrevNumber = Die->getAbbrevNumber();
2232 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2235 Die->setOffset(Offset);
2237 // Start the size with the size of abbreviation code.
2238 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2240 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2241 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2243 // Size the DIE attribute values.
2244 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2245 // Size attribute value.
2246 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2248 // Size the DIE children if any.
2249 if (!Children.empty()) {
2250 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2251 "Children flag not set");
2253 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2254 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2256 // End of children marker.
2257 Offset += sizeof(int8_t);
2260 Die->setSize(Offset - Die->getOffset());
2264 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2266 void DwarfDebug::computeSizeAndOffsets() {
2267 // Compute size of compile unit header.
2268 static unsigned Offset =
2269 sizeof(int32_t) + // Length of Compilation Unit Info
2270 sizeof(int16_t) + // DWARF version number
2271 sizeof(int32_t) + // Offset Into Abbrev. Section
2272 sizeof(int8_t); // Pointer Size (in bytes)
2274 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2275 CompileUnitOffsets[ModuleCU] = 0;
2278 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2279 /// tools to recognize the object file contains Dwarf information.
2280 void DwarfDebug::emitInitial() {
2281 // Check to see if we already emitted intial headers.
2282 if (didInitial) return;
2285 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2287 // Dwarf sections base addresses.
2288 if (MAI->doesDwarfRequireFrameSection()) {
2289 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2290 EmitLabel("section_debug_frame", 0);
2293 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2294 EmitLabel("section_info", 0);
2295 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2296 EmitLabel("section_abbrev", 0);
2297 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2298 EmitLabel("section_aranges", 0);
2300 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2301 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2302 EmitLabel("section_macinfo", 0);
2305 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2306 EmitLabel("section_line", 0);
2307 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2308 EmitLabel("section_loc", 0);
2309 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2310 EmitLabel("section_pubnames", 0);
2311 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2312 EmitLabel("section_pubtypes", 0);
2313 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2314 EmitLabel("section_str", 0);
2315 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2316 EmitLabel("section_ranges", 0);
2318 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2319 EmitLabel("text_begin", 0);
2320 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2321 EmitLabel("data_begin", 0);
2324 /// emitDIE - Recusively Emits a debug information entry.
2326 void DwarfDebug::emitDIE(DIE *Die) {
2327 // Get the abbreviation for this DIE.
2328 unsigned AbbrevNumber = Die->getAbbrevNumber();
2329 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2333 // Emit the code (index) for the abbreviation.
2334 Asm->EmitULEB128Bytes(AbbrevNumber);
2336 if (Asm->isVerbose())
2337 Asm->EOL(std::string("Abbrev [" +
2338 utostr(AbbrevNumber) +
2339 "] 0x" + utohexstr(Die->getOffset()) +
2340 ":0x" + utohexstr(Die->getSize()) + " " +
2341 dwarf::TagString(Abbrev->getTag())));
2345 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2346 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2348 // Emit the DIE attribute values.
2349 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2350 unsigned Attr = AbbrevData[i].getAttribute();
2351 unsigned Form = AbbrevData[i].getForm();
2352 assert(Form && "Too many attributes for DIE (check abbreviation)");
2355 case dwarf::DW_AT_sibling:
2356 Asm->EmitInt32(Die->getSiblingOffset());
2358 case dwarf::DW_AT_abstract_origin: {
2359 DIEEntry *E = cast<DIEEntry>(Values[i]);
2360 DIE *Origin = E->getEntry();
2361 unsigned Addr = Origin->getOffset();
2362 Asm->EmitInt32(Addr);
2366 // Emit an attribute using the defined form.
2367 Values[i]->EmitValue(this, Form);
2371 Asm->EOL(dwarf::AttributeString(Attr));
2374 // Emit the DIE children if any.
2375 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2376 const std::vector<DIE *> &Children = Die->getChildren();
2378 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2379 emitDIE(Children[j]);
2381 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2385 /// emitDebugInfo - Emit the debug info section.
2387 void DwarfDebug::emitDebugInfo() {
2388 // Start debug info section.
2389 Asm->OutStreamer.SwitchSection(
2390 Asm->getObjFileLowering().getDwarfInfoSection());
2391 DIE *Die = ModuleCU->getCUDie();
2393 // Emit the compile units header.
2394 EmitLabel("info_begin", ModuleCU->getID());
2396 // Emit size of content not including length itself
2397 unsigned ContentSize = Die->getSize() +
2398 sizeof(int16_t) + // DWARF version number
2399 sizeof(int32_t) + // Offset Into Abbrev. Section
2400 sizeof(int8_t) + // Pointer Size (in bytes)
2401 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2403 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
2404 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2405 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2406 Asm->EOL("Offset Into Abbrev. Section");
2407 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2410 // FIXME - extra padding for gdb bug.
2411 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2412 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2413 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2414 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2415 EmitLabel("info_end", ModuleCU->getID());
2420 /// emitAbbreviations - Emit the abbreviation section.
2422 void DwarfDebug::emitAbbreviations() const {
2423 // Check to see if it is worth the effort.
2424 if (!Abbreviations.empty()) {
2425 // Start the debug abbrev section.
2426 Asm->OutStreamer.SwitchSection(
2427 Asm->getObjFileLowering().getDwarfAbbrevSection());
2429 EmitLabel("abbrev_begin", 0);
2431 // For each abbrevation.
2432 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2433 // Get abbreviation data
2434 const DIEAbbrev *Abbrev = Abbreviations[i];
2436 // Emit the abbrevations code (base 1 index.)
2437 Asm->EmitULEB128Bytes(Abbrev->getNumber());
2438 Asm->EOL("Abbreviation Code");
2440 // Emit the abbreviations data.
2446 // Mark end of abbreviations.
2447 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2449 EmitLabel("abbrev_end", 0);
2454 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2455 /// the line matrix.
2457 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2458 // Define last address of section.
2459 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2460 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2461 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2462 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2464 // Mark end of matrix.
2465 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2466 Asm->EmitULEB128Bytes(1); Asm->EOL();
2467 Asm->EmitInt8(1); Asm->EOL();
2470 /// emitDebugLines - Emit source line information.
2472 void DwarfDebug::emitDebugLines() {
2473 // If the target is using .loc/.file, the assembler will be emitting the
2474 // .debug_line table automatically.
2475 if (MAI->hasDotLocAndDotFile())
2478 // Minimum line delta, thus ranging from -10..(255-10).
2479 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2480 // Maximum line delta, thus ranging from -10..(255-10).
2481 const int MaxLineDelta = 255 + MinLineDelta;
2483 // Start the dwarf line section.
2484 Asm->OutStreamer.SwitchSection(
2485 Asm->getObjFileLowering().getDwarfLineSection());
2487 // Construct the section header.
2488 EmitDifference("line_end", 0, "line_begin", 0, true);
2489 Asm->EOL("Length of Source Line Info");
2490 EmitLabel("line_begin", 0);
2492 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2494 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2495 Asm->EOL("Prolog Length");
2496 EmitLabel("line_prolog_begin", 0);
2498 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2500 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2502 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2504 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2506 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2508 // Line number standard opcode encodings argument count
2509 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2510 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2511 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2512 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2513 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2514 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2515 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2516 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2517 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2519 // Emit directories.
2520 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2521 Asm->EmitString(getSourceDirectoryName(DI));
2522 Asm->EOL("Directory");
2525 Asm->EmitInt8(0); Asm->EOL("End of directories");
2528 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2529 // Remember source id starts at 1.
2530 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2531 Asm->EmitString(getSourceFileName(Id.second));
2533 Asm->EmitULEB128Bytes(Id.first);
2534 Asm->EOL("Directory #");
2535 Asm->EmitULEB128Bytes(0);
2536 Asm->EOL("Mod date");
2537 Asm->EmitULEB128Bytes(0);
2538 Asm->EOL("File size");
2541 Asm->EmitInt8(0); Asm->EOL("End of files");
2543 EmitLabel("line_prolog_end", 0);
2545 // A sequence for each text section.
2546 unsigned SecSrcLinesSize = SectionSourceLines.size();
2548 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2549 // Isolate current sections line info.
2550 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2552 /*if (Asm->isVerbose()) {
2553 const MCSection *S = SectionMap[j + 1];
2554 O << '\t' << MAI->getCommentString() << " Section"
2555 << S->getName() << '\n';
2559 // Dwarf assumes we start with first line of first source file.
2560 unsigned Source = 1;
2563 // Construct rows of the address, source, line, column matrix.
2564 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2565 const SrcLineInfo &LineInfo = LineInfos[i];
2566 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2567 if (!LabelID) continue;
2569 if (LineInfo.getLine() == 0) continue;
2571 if (!Asm->isVerbose())
2574 std::pair<unsigned, unsigned> SourceID =
2575 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2576 O << '\t' << MAI->getCommentString() << ' '
2577 << getSourceDirectoryName(SourceID.first) << '/'
2578 << getSourceFileName(SourceID.second)
2579 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2582 // Define the line address.
2583 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2584 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2585 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2586 EmitReference("label", LabelID); Asm->EOL("Location label");
2588 // If change of source, then switch to the new source.
2589 if (Source != LineInfo.getSourceID()) {
2590 Source = LineInfo.getSourceID();
2591 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2592 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2595 // If change of line.
2596 if (Line != LineInfo.getLine()) {
2597 // Determine offset.
2598 int Offset = LineInfo.getLine() - Line;
2599 int Delta = Offset - MinLineDelta;
2602 Line = LineInfo.getLine();
2604 // If delta is small enough and in range...
2605 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2606 // ... then use fast opcode.
2607 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2609 // ... otherwise use long hand.
2610 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2611 Asm->EOL("DW_LNS_advance_line");
2612 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2613 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2616 // Copy the previous row (different address or source)
2617 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2621 emitEndOfLineMatrix(j + 1);
2624 if (SecSrcLinesSize == 0)
2625 // Because we're emitting a debug_line section, we still need a line
2626 // table. The linker and friends expect it to exist. If there's nothing to
2627 // put into it, emit an empty table.
2628 emitEndOfLineMatrix(1);
2630 EmitLabel("line_end", 0);
2634 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2636 void DwarfDebug::emitCommonDebugFrame() {
2637 if (!MAI->doesDwarfRequireFrameSection())
2641 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2642 TargetFrameInfo::StackGrowsUp ?
2643 TD->getPointerSize() : -TD->getPointerSize();
2645 // Start the dwarf frame section.
2646 Asm->OutStreamer.SwitchSection(
2647 Asm->getObjFileLowering().getDwarfFrameSection());
2649 EmitLabel("debug_frame_common", 0);
2650 EmitDifference("debug_frame_common_end", 0,
2651 "debug_frame_common_begin", 0, true);
2652 Asm->EOL("Length of Common Information Entry");
2654 EmitLabel("debug_frame_common_begin", 0);
2655 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2656 Asm->EOL("CIE Identifier Tag");
2657 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2658 Asm->EOL("CIE Version");
2659 Asm->EmitString("");
2660 Asm->EOL("CIE Augmentation");
2661 Asm->EmitULEB128Bytes(1);
2662 Asm->EOL("CIE Code Alignment Factor");
2663 Asm->EmitSLEB128Bytes(stackGrowth);
2664 Asm->EOL("CIE Data Alignment Factor");
2665 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2666 Asm->EOL("CIE RA Column");
2668 std::vector<MachineMove> Moves;
2669 RI->getInitialFrameState(Moves);
2671 EmitFrameMoves(NULL, 0, Moves, false);
2673 Asm->EmitAlignment(2, 0, 0, false);
2674 EmitLabel("debug_frame_common_end", 0);
2679 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2682 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2683 if (!MAI->doesDwarfRequireFrameSection())
2686 // Start the dwarf frame section.
2687 Asm->OutStreamer.SwitchSection(
2688 Asm->getObjFileLowering().getDwarfFrameSection());
2690 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2691 "debug_frame_begin", DebugFrameInfo.Number, true);
2692 Asm->EOL("Length of Frame Information Entry");
2694 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2696 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2698 Asm->EOL("FDE CIE offset");
2700 EmitReference("func_begin", DebugFrameInfo.Number);
2701 Asm->EOL("FDE initial location");
2702 EmitDifference("func_end", DebugFrameInfo.Number,
2703 "func_begin", DebugFrameInfo.Number);
2704 Asm->EOL("FDE address range");
2706 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2709 Asm->EmitAlignment(2, 0, 0, false);
2710 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2715 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2717 void DwarfDebug::emitDebugPubNames() {
2718 // Start the dwarf pubnames section.
2719 Asm->OutStreamer.SwitchSection(
2720 Asm->getObjFileLowering().getDwarfPubNamesSection());
2722 EmitDifference("pubnames_end", ModuleCU->getID(),
2723 "pubnames_begin", ModuleCU->getID(), true);
2724 Asm->EOL("Length of Public Names Info");
2726 EmitLabel("pubnames_begin", ModuleCU->getID());
2728 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2730 EmitSectionOffset("info_begin", "section_info",
2731 ModuleCU->getID(), 0, true, false);
2732 Asm->EOL("Offset of Compilation Unit Info");
2734 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2736 Asm->EOL("Compilation Unit Length");
2738 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2739 for (StringMap<DIE*>::const_iterator
2740 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2741 const char *Name = GI->getKeyData();
2742 DIE * Entity = GI->second;
2744 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2745 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2748 Asm->EmitInt32(0); Asm->EOL("End Mark");
2749 EmitLabel("pubnames_end", ModuleCU->getID());
2754 void DwarfDebug::emitDebugPubTypes() {
2755 // Start the dwarf pubnames section.
2756 Asm->OutStreamer.SwitchSection(
2757 Asm->getObjFileLowering().getDwarfPubTypesSection());
2758 EmitDifference("pubtypes_end", ModuleCU->getID(),
2759 "pubtypes_begin", ModuleCU->getID(), true);
2760 Asm->EOL("Length of Public Types Info");
2762 EmitLabel("pubtypes_begin", ModuleCU->getID());
2764 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2766 EmitSectionOffset("info_begin", "section_info",
2767 ModuleCU->getID(), 0, true, false);
2768 Asm->EOL("Offset of Compilation ModuleCU Info");
2770 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2772 Asm->EOL("Compilation ModuleCU Length");
2774 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2775 for (StringMap<DIE*>::const_iterator
2776 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2777 const char *Name = GI->getKeyData();
2778 DIE * Entity = GI->second;
2780 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2781 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2784 Asm->EmitInt32(0); Asm->EOL("End Mark");
2785 EmitLabel("pubtypes_end", ModuleCU->getID());
2790 /// emitDebugStr - Emit visible names into a debug str section.
2792 void DwarfDebug::emitDebugStr() {
2793 // Check to see if it is worth the effort.
2794 if (!StringPool.empty()) {
2795 // Start the dwarf str section.
2796 Asm->OutStreamer.SwitchSection(
2797 Asm->getObjFileLowering().getDwarfStrSection());
2799 // For each of strings in the string pool.
2800 for (unsigned StringID = 1, N = StringPool.size();
2801 StringID <= N; ++StringID) {
2802 // Emit a label for reference from debug information entries.
2803 EmitLabel("string", StringID);
2805 // Emit the string itself.
2806 const std::string &String = StringPool[StringID];
2807 Asm->EmitString(String); Asm->EOL();
2814 /// emitDebugLoc - Emit visible names into a debug loc section.
2816 void DwarfDebug::emitDebugLoc() {
2817 // Start the dwarf loc section.
2818 Asm->OutStreamer.SwitchSection(
2819 Asm->getObjFileLowering().getDwarfLocSection());
2823 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2825 void DwarfDebug::EmitDebugARanges() {
2826 // Start the dwarf aranges section.
2827 Asm->OutStreamer.SwitchSection(
2828 Asm->getObjFileLowering().getDwarfARangesSection());
2832 CompileUnit *Unit = GetBaseCompileUnit();
2834 // Don't include size of length
2835 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
2837 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2839 EmitReference("info_begin", Unit->getID());
2840 Asm->EOL("Offset of Compilation Unit Info");
2842 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2844 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2846 Asm->EmitInt16(0); Asm->EOL("Pad (1)");
2847 Asm->EmitInt16(0); Asm->EOL("Pad (2)");
2850 EmitReference("text_begin", 0); Asm->EOL("Address");
2851 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2853 Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2854 Asm->EmitInt32(0); Asm->EOL("EOM (2)");
2860 /// emitDebugRanges - Emit visible names into a debug ranges section.
2862 void DwarfDebug::emitDebugRanges() {
2863 // Start the dwarf ranges section.
2864 Asm->OutStreamer.SwitchSection(
2865 Asm->getObjFileLowering().getDwarfRangesSection());
2869 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2871 void DwarfDebug::emitDebugMacInfo() {
2872 if (const MCSection *LineInfo =
2873 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2874 // Start the dwarf macinfo section.
2875 Asm->OutStreamer.SwitchSection(LineInfo);
2880 /// emitDebugInlineInfo - Emit inline info using following format.
2882 /// 1. length of section
2883 /// 2. Dwarf version number
2884 /// 3. address size.
2886 /// Entries (one "entry" for each function that was inlined):
2888 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2889 /// otherwise offset into __debug_str for regular function name.
2890 /// 2. offset into __debug_str section for regular function name.
2891 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2892 /// instances for the function.
2894 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2895 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2896 /// __debug_info section, and the low_pc is the starting address for the
2897 /// inlining instance.
2898 void DwarfDebug::emitDebugInlineInfo() {
2899 if (!MAI->doesDwarfUsesInlineInfoSection())
2905 Asm->OutStreamer.SwitchSection(
2906 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2908 EmitDifference("debug_inlined_end", 1,
2909 "debug_inlined_begin", 1, true);
2910 Asm->EOL("Length of Debug Inlined Information Entry");
2912 EmitLabel("debug_inlined_begin", 1);
2914 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2915 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2917 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2918 E = InlinedSPNodes.end(); I != E; ++I) {
2921 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2922 = InlineInfo.find(Node);
2923 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2924 DISubprogram SP(Node);
2925 StringRef LName = SP.getLinkageName();
2926 StringRef Name = SP.getName();
2929 Asm->EmitString(Name);
2931 EmitSectionOffset("string", "section_str",
2932 StringPool.idFor(getRealLinkageName(LName)), false, true);
2934 Asm->EOL("MIPS linkage name");
2935 EmitSectionOffset("string", "section_str",
2936 StringPool.idFor(Name), false, true);
2937 Asm->EOL("Function name");
2938 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2940 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2941 LE = Labels.end(); LI != LE; ++LI) {
2942 DIE *SP = LI->second;
2943 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2945 if (TD->getPointerSize() == sizeof(int32_t))
2946 O << MAI->getData32bitsDirective();
2948 O << MAI->getData64bitsDirective();
2950 PrintLabelName("label", LI->first); Asm->EOL("low_pc");
2954 EmitLabel("debug_inlined_end", 1);