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 = NULL;
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 /// createGlobalVariableDIE - Create new DIE using GV.
1036 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1037 // If the global variable was optmized out then no need to create debug info
1039 if (!GV.getGlobal()) return NULL;
1040 if (GV.getDisplayName().empty()) return NULL;
1042 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1043 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1044 GV.getDisplayName());
1046 StringRef LinkageName = GV.getLinkageName();
1047 if (!LinkageName.empty()) {
1048 // Skip special LLVM prefix that is used to inform the asm printer to not
1049 // emit usual symbol prefix before the symbol name. This happens for
1050 // Objective-C symbol names and symbol whose name is replaced using GCC's
1051 // __asm__ attribute.
1052 if (LinkageName[0] == 1)
1053 LinkageName = LinkageName.substr(1);
1054 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1057 addType(GVDie, GV.getType());
1058 if (!GV.isLocalToUnit())
1059 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1060 addSourceLine(GVDie, &GV);
1065 /// createMemberDIE - Create new member DIE.
1066 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1067 DIE *MemberDie = new DIE(DT.getTag());
1068 StringRef Name = DT.getName();
1070 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1072 addType(MemberDie, DT.getTypeDerivedFrom());
1074 addSourceLine(MemberDie, &DT);
1076 DIEBlock *MemLocationDie = new DIEBlock();
1077 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1079 uint64_t Size = DT.getSizeInBits();
1080 uint64_t FieldSize = DT.getOriginalTypeSize();
1082 if (Size != FieldSize) {
1084 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1085 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1087 uint64_t Offset = DT.getOffsetInBits();
1088 uint64_t FieldOffset = Offset;
1089 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1090 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1091 FieldOffset = (HiMark - FieldSize);
1092 Offset -= FieldOffset;
1094 // Maybe we need to work from the other end.
1095 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1096 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1098 // Here WD_AT_data_member_location points to the anonymous
1099 // field that includes this bit field.
1100 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1103 // This is not a bitfield.
1104 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1106 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1108 if (DT.isProtected())
1109 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1110 dwarf::DW_ACCESS_protected);
1111 else if (DT.isPrivate())
1112 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1113 dwarf::DW_ACCESS_private);
1114 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1115 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1116 dwarf::DW_ACCESS_public);
1118 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1119 dwarf::DW_VIRTUALITY_virtual);
1123 /// createSubprogramDIE - Create new DIE using SP.
1124 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1125 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1129 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1130 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1132 StringRef LinkageName = SP.getLinkageName();
1133 if (!LinkageName.empty()) {
1134 // Skip special LLVM prefix that is used to inform the asm printer to not
1135 // emit usual symbol prefix before the symbol name. This happens for
1136 // Objective-C symbol names and symbol whose name is replaced using GCC's
1137 // __asm__ attribute.
1138 if (LinkageName[0] == 1)
1139 LinkageName = LinkageName.substr(1);
1140 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1143 addSourceLine(SPDie, &SP);
1145 // Add prototyped tag, if C or ObjC.
1146 unsigned Lang = SP.getCompileUnit().getLanguage();
1147 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1148 Lang == dwarf::DW_LANG_ObjC)
1149 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1152 DICompositeType SPTy = SP.getType();
1153 DIArray Args = SPTy.getTypeArray();
1154 unsigned SPTag = SPTy.getTag();
1156 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1157 addType(SPDie, SPTy);
1159 addType(SPDie, DIType(Args.getElement(0).getNode()));
1161 unsigned VK = SP.getVirtuality();
1163 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1164 DIEBlock *Block = new DIEBlock();
1165 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1166 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1167 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1168 ContainingTypeMap.insert(std::make_pair(SPDie, WeakVH(SP.getContainingType().getNode())));
1171 if (MakeDecl || !SP.isDefinition()) {
1172 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1174 // Add arguments. Do not add arguments for subprogram definition. They will
1175 // be handled while processing variables.
1176 DICompositeType SPTy = SP.getType();
1177 DIArray Args = SPTy.getTypeArray();
1178 unsigned SPTag = SPTy.getTag();
1180 if (SPTag == dwarf::DW_TAG_subroutine_type)
1181 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1182 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1183 addType(Arg, DIType(Args.getElement(i).getNode()));
1184 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1185 SPDie->addChild(Arg);
1189 // DW_TAG_inlined_subroutine may refer to this DIE.
1190 ModuleCU->insertDIE(SP.getNode(), SPDie);
1194 /// findCompileUnit - Get the compile unit for the given descriptor.
1196 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1197 DenseMap<Value *, CompileUnit *>::const_iterator I =
1198 CompileUnitMap.find(Unit.getNode());
1199 if (I == CompileUnitMap.end())
1200 return constructCompileUnit(Unit.getNode());
1204 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1205 /// Initialize scope and update scope hierarchy.
1206 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1207 MDNode *InlinedAt) {
1208 assert (N && "Invalid Scope encoding!");
1209 assert (MI && "Missing machine instruction!");
1210 bool GetConcreteScope = (MI && InlinedAt);
1212 DbgScope *NScope = NULL;
1215 NScope = DbgScopeMap.lookup(InlinedAt);
1217 NScope = DbgScopeMap.lookup(N);
1218 assert (NScope && "Unable to find working scope!");
1220 if (NScope->getFirstInsn())
1223 DbgScope *Parent = NULL;
1224 if (GetConcreteScope) {
1225 DILocation IL(InlinedAt);
1226 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1227 IL.getOrigLocation().getNode());
1228 assert (Parent && "Unable to find Parent scope!");
1229 NScope->setParent(Parent);
1230 Parent->addScope(NScope);
1231 } else if (DIDescriptor(N).isLexicalBlock()) {
1232 DILexicalBlock DB(N);
1233 if (!DB.getContext().isNull()) {
1234 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1235 NScope->setParent(Parent);
1236 Parent->addScope(NScope);
1240 NScope->setFirstInsn(MI);
1242 if (!Parent && !InlinedAt) {
1243 StringRef SPName = DISubprogram(N).getLinkageName();
1244 if (SPName == MF->getFunction()->getName())
1245 CurrentFnDbgScope = NScope;
1248 if (GetConcreteScope) {
1249 ConcreteScopes[InlinedAt] = NScope;
1250 getOrCreateAbstractScope(N);
1256 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1257 assert (N && "Invalid Scope encoding!");
1259 DbgScope *AScope = AbstractScopes.lookup(N);
1263 DbgScope *Parent = NULL;
1265 DIDescriptor Scope(N);
1266 if (Scope.isLexicalBlock()) {
1267 DILexicalBlock DB(N);
1268 DIDescriptor ParentDesc = DB.getContext();
1269 if (!ParentDesc.isNull())
1270 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1273 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1276 Parent->addScope(AScope);
1277 AScope->setAbstractScope();
1278 AbstractScopes[N] = AScope;
1279 if (DIDescriptor(N).isSubprogram())
1280 AbstractScopesList.push_back(AScope);
1284 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1285 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1286 /// If there are global variables in this scope then create and insert
1287 /// DIEs for these variables.
1288 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1290 DIE *SPDie = ModuleCU->getDIE(SPNode);
1291 assert (SPDie && "Unable to find subprogram DIE!");
1292 DISubprogram SP(SPNode);
1293 if (SP.isDefinition() && !SP.getContext().isCompileUnit()) {
1294 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1296 DICompositeType SPTy = SP.getType();
1297 DIArray Args = SPTy.getTypeArray();
1298 unsigned SPTag = SPTy.getTag();
1299 if (SPTag == dwarf::DW_TAG_subroutine_type)
1300 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1301 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1302 addType(Arg, DIType(Args.getElement(i).getNode()));
1303 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1304 SPDie->addChild(Arg);
1306 DIE *SPDeclDie = SPDie;
1307 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1308 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1310 ModuleCU->addDie(SPDie);
1313 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1314 DWLabel("func_begin", SubprogramCount));
1315 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1316 DWLabel("func_end", SubprogramCount));
1317 MachineLocation Location(RI->getFrameRegister(*MF));
1318 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1320 if (!DISubprogram(SPNode).isLocalToUnit())
1321 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1326 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1327 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1328 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1329 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1330 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1332 // Ignore empty scopes.
1333 if (StartID == EndID && StartID != 0)
1336 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1337 if (Scope->isAbstractScope())
1340 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1342 DWLabel("label", StartID)
1343 : DWLabel("func_begin", SubprogramCount));
1344 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1346 DWLabel("label", EndID)
1347 : DWLabel("func_end", SubprogramCount));
1354 /// constructInlinedScopeDIE - This scope represents inlined body of
1355 /// a function. Construct DIE to represent this concrete inlined copy
1356 /// of the function.
1357 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1358 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1359 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1360 assert (StartID && "Invalid starting label for an inlined scope!");
1361 assert (EndID && "Invalid end label for an inlined scope!");
1362 // Ignore empty scopes.
1363 if (StartID == EndID && StartID != 0)
1366 DIScope DS(Scope->getScopeNode());
1369 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1371 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1372 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1373 assert (OriginDIE && "Unable to find Origin DIE!");
1374 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1375 dwarf::DW_FORM_ref4, OriginDIE);
1377 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1378 DWLabel("label", StartID));
1379 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1380 DWLabel("label", EndID));
1382 InlinedSubprogramDIEs.insert(OriginDIE);
1384 // Track the start label for this inlined function.
1385 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1386 I = InlineInfo.find(InlinedSP.getNode());
1388 if (I == InlineInfo.end()) {
1389 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1391 InlinedSPNodes.push_back(InlinedSP.getNode());
1393 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1395 StringPool.insert(InlinedSP.getName());
1396 StringPool.insert(InlinedSP.getLinkageName());
1397 DILocation DL(Scope->getInlinedAt());
1398 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1399 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1405 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1406 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1407 // Get the descriptor.
1408 const DIVariable &VD = DV->getVariable();
1409 StringRef Name = VD.getName();
1413 // Translate tag to proper Dwarf tag. The result variable is dropped for
1416 switch (VD.getTag()) {
1417 case dwarf::DW_TAG_return_variable:
1419 case dwarf::DW_TAG_arg_variable:
1420 Tag = dwarf::DW_TAG_formal_parameter;
1422 case dwarf::DW_TAG_auto_variable: // fall thru
1424 Tag = dwarf::DW_TAG_variable;
1428 // Define variable debug information entry.
1429 DIE *VariableDie = new DIE(Tag);
1433 if (DbgVariable *AV = DV->getAbstractVariable())
1434 AbsDIE = AV->getDIE();
1437 DIScope DS(Scope->getScopeNode());
1438 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1439 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1441 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1442 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1443 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1444 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1445 dwarf::DW_FORM_ref4, AbsDIE);
1448 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1449 addSourceLine(VariableDie, &VD);
1451 // Add variable type.
1452 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1453 // addresses instead.
1454 if (VD.isBlockByrefVariable())
1455 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1457 addType(VariableDie, VD.getType());
1460 // Add variable address.
1461 if (!Scope->isAbstractScope()) {
1462 MachineLocation Location;
1464 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1465 Location.set(FrameReg, Offset);
1467 if (VD.hasComplexAddress())
1468 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1469 else if (VD.isBlockByrefVariable())
1470 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1472 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1474 DV->setDIE(VariableDie);
1479 void DwarfDebug::addPubTypes(DISubprogram SP) {
1480 DICompositeType SPTy = SP.getType();
1481 unsigned SPTag = SPTy.getTag();
1482 if (SPTag != dwarf::DW_TAG_subroutine_type)
1485 DIArray Args = SPTy.getTypeArray();
1489 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1490 DIType ATy(Args.getElement(i).getNode());
1493 DICompositeType CATy = getDICompositeType(ATy);
1494 if (!CATy.isNull() && !CATy.getName().empty()) {
1495 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1496 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1501 /// constructScopeDIE - Construct a DIE for this scope.
1502 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1505 DIScope DS(Scope->getScopeNode());
1509 DIE *ScopeDIE = NULL;
1510 if (Scope->getInlinedAt())
1511 ScopeDIE = constructInlinedScopeDIE(Scope);
1512 else if (DS.isSubprogram()) {
1513 if (Scope->isAbstractScope())
1514 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1516 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1519 ScopeDIE = constructLexicalScopeDIE(Scope);
1520 if (!ScopeDIE) return NULL;
1523 // Add variables to scope.
1524 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1525 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1526 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1528 ScopeDIE->addChild(VariableDIE);
1531 // Add nested scopes.
1532 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1533 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1534 // Define the Scope debug information entry.
1535 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1537 ScopeDIE->addChild(NestedDIE);
1540 if (DS.isSubprogram())
1541 addPubTypes(DISubprogram(DS.getNode()));
1546 /// GetOrCreateSourceID - Look up the source id with the given directory and
1547 /// source file names. If none currently exists, create a new id and insert it
1548 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1550 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1552 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1553 if (DI != DirectoryIdMap.end()) {
1554 DId = DI->getValue();
1556 DId = DirectoryNames.size() + 1;
1557 DirectoryIdMap[DirName] = DId;
1558 DirectoryNames.push_back(DirName);
1562 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1563 if (FI != SourceFileIdMap.end()) {
1564 FId = FI->getValue();
1566 FId = SourceFileNames.size() + 1;
1567 SourceFileIdMap[FileName] = FId;
1568 SourceFileNames.push_back(FileName);
1571 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1572 SourceIdMap.find(std::make_pair(DId, FId));
1573 if (SI != SourceIdMap.end())
1576 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1577 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1578 SourceIds.push_back(std::make_pair(DId, FId));
1583 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1584 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1585 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1588 NDie = new DIE(dwarf::DW_TAG_namespace);
1589 ModuleCU->insertDIE(NS.getNode(), NDie);
1590 if (!NS.getName().empty())
1591 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1592 addSourceLine(NDie, &NS);
1593 addToContextOwner(NDie, NS.getContext());
1597 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1598 DICompileUnit DIUnit(N);
1599 StringRef FN = DIUnit.getFilename();
1600 StringRef Dir = DIUnit.getDirectory();
1601 unsigned ID = GetOrCreateSourceID(Dir, FN);
1603 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1604 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1605 DWLabel("section_line", 0), DWLabel("section_line", 0),
1607 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1608 DIUnit.getProducer());
1609 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1610 DIUnit.getLanguage());
1611 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1614 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1615 if (DIUnit.isOptimized())
1616 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1618 StringRef Flags = DIUnit.getFlags();
1620 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1622 unsigned RVer = DIUnit.getRunTimeVersion();
1624 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1625 dwarf::DW_FORM_data1, RVer);
1627 CompileUnit *Unit = new CompileUnit(ID, Die);
1628 if (!ModuleCU && DIUnit.isMain()) {
1629 // Use first compile unit marked as isMain as the compile unit
1634 CompileUnitMap[DIUnit.getNode()] = Unit;
1635 CompileUnits.push_back(Unit);
1639 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1640 DIGlobalVariable DI_GV(N);
1642 // If debug information is malformed then ignore it.
1643 if (DI_GV.Verify() == false)
1646 // Check for pre-existence.
1647 if (ModuleCU->getDIE(DI_GV.getNode()))
1650 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1655 ModuleCU->insertDIE(N, VariableDie);
1657 // Add to context owner.
1658 if (DI_GV.isDefinition()
1659 && !DI_GV.getContext().isCompileUnit()) {
1660 // Create specification DIE.
1661 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1662 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1663 dwarf::DW_FORM_ref4, VariableDie);
1664 DIEBlock *Block = new DIEBlock();
1665 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1666 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1667 Asm->Mang->getMangledName(DI_GV.getGlobal()));
1668 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1669 ModuleCU->addDie(VariableSpecDIE);
1671 DIEBlock *Block = new DIEBlock();
1672 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1673 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1674 Asm->Mang->getMangledName(DI_GV.getGlobal()));
1675 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1677 addToContextOwner(VariableDie, DI_GV.getContext());
1679 // Expose as global. FIXME - need to check external flag.
1680 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1682 DIType GTy = DI_GV.getType();
1683 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1684 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1685 assert (Entry && "Missing global type!");
1686 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1691 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1694 // Check for pre-existence.
1695 if (ModuleCU->getDIE(N))
1698 if (!SP.isDefinition())
1699 // This is a method declaration which will be handled while constructing
1703 DIE *SubprogramDie = createSubprogramDIE(SP);
1706 ModuleCU->insertDIE(N, SubprogramDie);
1708 // Add to context owner.
1709 addToContextOwner(SubprogramDie, SP.getContext());
1711 // Expose as global.
1712 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1717 /// beginModule - Emit all Dwarf sections that should come prior to the
1718 /// content. Create global DIEs and emit initial debug info sections.
1719 /// This is inovked by the target AsmPrinter.
1720 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1723 if (TimePassesIsEnabled)
1724 DebugTimer->startTimer();
1726 if (!MAI->doesSupportDebugInformation())
1729 DebugInfoFinder DbgFinder;
1730 DbgFinder.processModule(*M);
1732 // Create all the compile unit DIEs.
1733 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1734 E = DbgFinder.compile_unit_end(); I != E; ++I)
1735 constructCompileUnit(*I);
1737 if (CompileUnits.empty()) {
1738 if (TimePassesIsEnabled)
1739 DebugTimer->stopTimer();
1744 // If main compile unit for this module is not seen than randomly
1745 // select first compile unit.
1747 ModuleCU = CompileUnits[0];
1749 // Create DIEs for each subprogram.
1750 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1751 E = DbgFinder.subprogram_end(); I != E; ++I)
1752 constructSubprogramDIE(*I);
1754 // Create DIEs for each global variable.
1755 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1756 E = DbgFinder.global_variable_end(); I != E; ++I)
1757 constructGlobalVariableDIE(*I);
1761 MMI->setDebugInfoAvailability(true);
1763 // Prime section data.
1764 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1766 // Print out .file directives to specify files for .loc directives. These are
1767 // printed out early so that they precede any .loc directives.
1768 if (MAI->hasDotLocAndDotFile()) {
1769 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1770 // Remember source id starts at 1.
1771 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1772 sys::Path FullPath(getSourceDirectoryName(Id.first));
1774 FullPath.appendComponent(getSourceFileName(Id.second));
1775 assert(AppendOk && "Could not append filename to directory!");
1777 Asm->EmitFile(i, FullPath.str());
1782 // Emit initial sections
1785 if (TimePassesIsEnabled)
1786 DebugTimer->stopTimer();
1789 /// endModule - Emit all Dwarf sections that should come after the content.
1791 void DwarfDebug::endModule() {
1795 if (TimePassesIsEnabled)
1796 DebugTimer->startTimer();
1798 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1799 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1800 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1802 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1805 // Insert top level DIEs.
1806 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1807 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1808 ModuleCU->getCUDie()->addChild(*TI);
1810 for (DenseMap<DIE *, WeakVH>::iterator CI = ContainingTypeMap.begin(),
1811 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1812 DIE *SPDie = CI->first;
1813 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1815 DIE *NDie = ModuleCU->getDIE(N);
1816 if (!NDie) continue;
1817 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1818 addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1821 // Standard sections final addresses.
1822 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1823 EmitLabel("text_end", 0);
1824 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1825 EmitLabel("data_end", 0);
1827 // End text sections.
1828 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1829 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1830 EmitLabel("section_end", i);
1833 // Emit common frame information.
1834 emitCommonDebugFrame();
1836 // Emit function debug frame information
1837 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1838 E = DebugFrames.end(); I != E; ++I)
1839 emitFunctionDebugFrame(*I);
1841 // Compute DIE offsets and sizes.
1842 computeSizeAndOffsets();
1844 // Emit all the DIEs into a debug info section
1847 // Corresponding abbreviations into a abbrev section.
1848 emitAbbreviations();
1850 // Emit source line correspondence into a debug line section.
1853 // Emit info into a debug pubnames section.
1854 emitDebugPubNames();
1856 // Emit info into a debug pubtypes section.
1857 emitDebugPubTypes();
1859 // Emit info into a debug str section.
1862 // Emit info into a debug loc section.
1865 // Emit info into a debug aranges section.
1868 // Emit info into a debug ranges section.
1871 // Emit info into a debug macinfo section.
1874 // Emit inline info.
1875 emitDebugInlineInfo();
1877 if (TimePassesIsEnabled)
1878 DebugTimer->stopTimer();
1881 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1882 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1884 DILocation &ScopeLoc) {
1886 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1888 return AbsDbgVariable;
1890 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1894 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1895 Scope->addVariable(AbsDbgVariable);
1896 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1897 return AbsDbgVariable;
1900 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1901 void DwarfDebug::collectVariableInfo() {
1904 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1905 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1906 VE = VMap.end(); VI != VE; ++VI) {
1907 MetadataBase *MB = VI->first;
1908 MDNode *Var = dyn_cast_or_null<MDNode>(MB);
1910 DIVariable DV (Var);
1911 std::pair< unsigned, MDNode *> VP = VI->second;
1912 DILocation ScopeLoc(VP.second);
1915 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1917 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1918 // If variable scope is not found then skip this variable.
1922 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1923 Scope->addVariable(RegVar);
1924 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1926 RegVar->setAbstractVariable(AbsDbgVariable);
1930 /// beginScope - Process beginning of a scope starting at Label.
1931 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1932 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1933 if (I == DbgScopeBeginMap.end())
1935 ScopeVector &SD = I->second;
1936 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1938 (*SDI)->setStartLabelID(Label);
1941 /// endScope - Process end of a scope.
1942 void DwarfDebug::endScope(const MachineInstr *MI) {
1943 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1944 if (I == DbgScopeEndMap.end())
1947 unsigned Label = MMI->NextLabelID();
1948 Asm->printLabel(Label);
1951 SmallVector<DbgScope *, 2> &SD = I->second;
1952 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1954 (*SDI)->setEndLabelID(Label);
1958 /// createDbgScope - Create DbgScope for the scope.
1959 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1962 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1965 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1966 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1967 if (DIDescriptor(Scope).isLexicalBlock())
1968 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1972 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1976 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1977 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1978 DILocation DL(InlinedAt);
1979 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1982 /// extractScopeInformation - Scan machine instructions in this function
1983 /// and collect DbgScopes. Return true, if atleast one scope was found.
1984 bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
1985 // If scope information was extracted using .dbg intrinsics then there is not
1986 // any need to extract these information by scanning each instruction.
1987 if (!DbgScopeMap.empty())
1990 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
1991 unsigned MIIndex = 0;
1992 // Scan each instruction and create scopes. First build working set of scopes.
1993 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1995 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1997 const MachineInstr *MInsn = II;
1998 MIIndexMap[MInsn] = MIIndex++;
1999 DebugLoc DL = MInsn->getDebugLoc();
2000 if (DL.isUnknown()) continue;
2001 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
2002 if (!DLT.Scope) continue;
2003 // There is no need to create another DIE for compile unit. For all
2004 // other scopes, create one DbgScope now. This will be translated
2005 // into a scope DIE at the end.
2006 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
2007 createDbgScope(DLT.Scope, DLT.InlinedAtLoc);
2012 // Build scope hierarchy using working set of scopes.
2013 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2015 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2017 const MachineInstr *MInsn = II;
2018 DebugLoc DL = MInsn->getDebugLoc();
2019 if (DL.isUnknown()) continue;
2020 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
2021 if (!DLT.Scope) continue;
2022 // There is no need to create another DIE for compile unit. For all
2023 // other scopes, create one DbgScope now. This will be translated
2024 // into a scope DIE at the end.
2025 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
2026 DbgScope *Scope = getUpdatedDbgScope(DLT.Scope, MInsn, DLT.InlinedAtLoc);
2027 Scope->setLastInsn(MInsn);
2031 if (!CurrentFnDbgScope)
2034 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2036 // Each scope has first instruction and last instruction to mark beginning
2037 // and end of a scope respectively. Create an inverse map that list scopes
2038 // starts (and ends) with an instruction. One instruction may start (or end)
2040 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
2041 DE = DbgScopeMap.end(); DI != DE; ++DI) {
2042 DbgScope *S = DI->second;
2043 if (S->isAbstractScope())
2045 const MachineInstr *MI = S->getFirstInsn();
2046 assert (MI && "DbgScope does not have first instruction!");
2048 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2049 if (IDI != DbgScopeBeginMap.end())
2050 IDI->second.push_back(S);
2052 DbgScopeBeginMap[MI].push_back(S);
2054 MI = S->getLastInsn();
2055 assert (MI && "DbgScope does not have last instruction!");
2056 IDI = DbgScopeEndMap.find(MI);
2057 if (IDI != DbgScopeEndMap.end())
2058 IDI->second.push_back(S);
2060 DbgScopeEndMap[MI].push_back(S);
2063 return !DbgScopeMap.empty();
2066 /// beginFunction - Gather pre-function debug information. Assumes being
2067 /// emitted immediately after the function entry point.
2068 void DwarfDebug::beginFunction(MachineFunction *MF) {
2071 if (!ShouldEmitDwarfDebug()) return;
2073 if (TimePassesIsEnabled)
2074 DebugTimer->startTimer();
2076 if (!extractScopeInformation(MF))
2079 collectVariableInfo();
2081 // Begin accumulating function debug information.
2082 MMI->BeginFunction(MF);
2084 // Assumes in correct section after the entry point.
2085 EmitLabel("func_begin", ++SubprogramCount);
2087 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2089 DebugLoc FDL = MF->getDefaultDebugLoc();
2090 if (!FDL.isUnknown()) {
2091 DebugLocTuple DLT = MF->getDebugLocTuple(FDL);
2092 unsigned LabelID = 0;
2093 DISubprogram SP = getDISubprogram(DLT.Scope);
2095 LabelID = recordSourceLine(SP.getLineNumber(), 0, DLT.Scope);
2097 LabelID = recordSourceLine(DLT.Line, DLT.Col, DLT.Scope);
2098 Asm->printLabel(LabelID);
2101 if (TimePassesIsEnabled)
2102 DebugTimer->stopTimer();
2105 /// endFunction - Gather and emit post-function debug information.
2107 void DwarfDebug::endFunction(MachineFunction *MF) {
2108 if (!ShouldEmitDwarfDebug()) return;
2110 if (TimePassesIsEnabled)
2111 DebugTimer->startTimer();
2113 if (DbgScopeMap.empty())
2116 if (CurrentFnDbgScope) {
2117 // Define end label for subprogram.
2118 EmitLabel("func_end", SubprogramCount);
2120 // Get function line info.
2121 if (!Lines.empty()) {
2122 // Get section line info.
2123 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2124 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2125 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2126 // Append the function info to section info.
2127 SectionLineInfos.insert(SectionLineInfos.end(),
2128 Lines.begin(), Lines.end());
2131 // Construct abstract scopes.
2132 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2133 AE = AbstractScopesList.end(); AI != AE; ++AI)
2134 constructScopeDIE(*AI);
2136 constructScopeDIE(CurrentFnDbgScope);
2138 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2139 MMI->getFrameMoves()));
2143 CurrentFnDbgScope = NULL;
2144 DbgScopeMap.clear();
2145 DbgScopeBeginMap.clear();
2146 DbgScopeEndMap.clear();
2147 ConcreteScopes.clear();
2148 AbstractScopesList.clear();
2152 if (TimePassesIsEnabled)
2153 DebugTimer->stopTimer();
2156 /// recordSourceLine - Records location information and associates it with a
2157 /// label. Returns a unique label ID used to generate a label and provide
2158 /// correspondence to the source line list.
2159 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2164 if (TimePassesIsEnabled)
2165 DebugTimer->startTimer();
2170 DIDescriptor Scope(S);
2171 if (Scope.isCompileUnit()) {
2172 DICompileUnit CU(S);
2173 Dir = CU.getDirectory();
2174 Fn = CU.getFilename();
2175 } else if (Scope.isSubprogram()) {
2177 Dir = SP.getDirectory();
2178 Fn = SP.getFilename();
2179 } else if (Scope.isLexicalBlock()) {
2180 DILexicalBlock DB(S);
2181 Dir = DB.getDirectory();
2182 Fn = DB.getFilename();
2184 assert (0 && "Unexpected scope info");
2186 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2187 unsigned ID = MMI->NextLabelID();
2188 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2190 if (TimePassesIsEnabled)
2191 DebugTimer->stopTimer();
2196 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2197 /// timed. Look up the source id with the given directory and source file
2198 /// names. If none currently exists, create a new id and insert it in the
2199 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2201 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2202 const std::string &FileName) {
2203 if (TimePassesIsEnabled)
2204 DebugTimer->startTimer();
2206 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2208 if (TimePassesIsEnabled)
2209 DebugTimer->stopTimer();
2214 //===----------------------------------------------------------------------===//
2216 //===----------------------------------------------------------------------===//
2218 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2221 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2222 // Get the children.
2223 const std::vector<DIE *> &Children = Die->getChildren();
2225 // If not last sibling and has children then add sibling offset attribute.
2226 if (!Last && !Children.empty()) Die->addSiblingOffset();
2228 // Record the abbreviation.
2229 assignAbbrevNumber(Die->getAbbrev());
2231 // Get the abbreviation for this DIE.
2232 unsigned AbbrevNumber = Die->getAbbrevNumber();
2233 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2236 Die->setOffset(Offset);
2238 // Start the size with the size of abbreviation code.
2239 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2241 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2242 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2244 // Size the DIE attribute values.
2245 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2246 // Size attribute value.
2247 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2249 // Size the DIE children if any.
2250 if (!Children.empty()) {
2251 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2252 "Children flag not set");
2254 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2255 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2257 // End of children marker.
2258 Offset += sizeof(int8_t);
2261 Die->setSize(Offset - Die->getOffset());
2265 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2267 void DwarfDebug::computeSizeAndOffsets() {
2268 // Compute size of compile unit header.
2269 static unsigned Offset =
2270 sizeof(int32_t) + // Length of Compilation Unit Info
2271 sizeof(int16_t) + // DWARF version number
2272 sizeof(int32_t) + // Offset Into Abbrev. Section
2273 sizeof(int8_t); // Pointer Size (in bytes)
2275 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2276 CompileUnitOffsets[ModuleCU] = 0;
2279 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2280 /// tools to recognize the object file contains Dwarf information.
2281 void DwarfDebug::emitInitial() {
2282 // Check to see if we already emitted intial headers.
2283 if (didInitial) return;
2286 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2288 // Dwarf sections base addresses.
2289 if (MAI->doesDwarfRequireFrameSection()) {
2290 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2291 EmitLabel("section_debug_frame", 0);
2294 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2295 EmitLabel("section_info", 0);
2296 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2297 EmitLabel("section_abbrev", 0);
2298 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2299 EmitLabel("section_aranges", 0);
2301 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2302 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2303 EmitLabel("section_macinfo", 0);
2306 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2307 EmitLabel("section_line", 0);
2308 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2309 EmitLabel("section_loc", 0);
2310 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2311 EmitLabel("section_pubnames", 0);
2312 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2313 EmitLabel("section_pubtypes", 0);
2314 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2315 EmitLabel("section_str", 0);
2316 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2317 EmitLabel("section_ranges", 0);
2319 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2320 EmitLabel("text_begin", 0);
2321 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2322 EmitLabel("data_begin", 0);
2325 /// emitDIE - Recusively Emits a debug information entry.
2327 void DwarfDebug::emitDIE(DIE *Die) {
2328 // Get the abbreviation for this DIE.
2329 unsigned AbbrevNumber = Die->getAbbrevNumber();
2330 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2334 // Emit the code (index) for the abbreviation.
2335 Asm->EmitULEB128Bytes(AbbrevNumber);
2337 if (Asm->isVerbose())
2338 Asm->EOL(std::string("Abbrev [" +
2339 utostr(AbbrevNumber) +
2340 "] 0x" + utohexstr(Die->getOffset()) +
2341 ":0x" + utohexstr(Die->getSize()) + " " +
2342 dwarf::TagString(Abbrev->getTag())));
2346 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2347 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2349 // Emit the DIE attribute values.
2350 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2351 unsigned Attr = AbbrevData[i].getAttribute();
2352 unsigned Form = AbbrevData[i].getForm();
2353 assert(Form && "Too many attributes for DIE (check abbreviation)");
2356 case dwarf::DW_AT_sibling:
2357 Asm->EmitInt32(Die->getSiblingOffset());
2359 case dwarf::DW_AT_abstract_origin: {
2360 DIEEntry *E = cast<DIEEntry>(Values[i]);
2361 DIE *Origin = E->getEntry();
2362 unsigned Addr = Origin->getOffset();
2363 Asm->EmitInt32(Addr);
2367 // Emit an attribute using the defined form.
2368 Values[i]->EmitValue(this, Form);
2372 Asm->EOL(dwarf::AttributeString(Attr));
2375 // Emit the DIE children if any.
2376 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2377 const std::vector<DIE *> &Children = Die->getChildren();
2379 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2380 emitDIE(Children[j]);
2382 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2386 /// emitDebugInfo - Emit the debug info section.
2388 void DwarfDebug::emitDebugInfo() {
2389 // Start debug info section.
2390 Asm->OutStreamer.SwitchSection(
2391 Asm->getObjFileLowering().getDwarfInfoSection());
2392 DIE *Die = ModuleCU->getCUDie();
2394 // Emit the compile units header.
2395 EmitLabel("info_begin", ModuleCU->getID());
2397 // Emit size of content not including length itself
2398 unsigned ContentSize = Die->getSize() +
2399 sizeof(int16_t) + // DWARF version number
2400 sizeof(int32_t) + // Offset Into Abbrev. Section
2401 sizeof(int8_t) + // Pointer Size (in bytes)
2402 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2404 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
2405 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2406 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2407 Asm->EOL("Offset Into Abbrev. Section");
2408 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2411 // FIXME - extra padding for gdb bug.
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 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2416 EmitLabel("info_end", ModuleCU->getID());
2421 /// emitAbbreviations - Emit the abbreviation section.
2423 void DwarfDebug::emitAbbreviations() const {
2424 // Check to see if it is worth the effort.
2425 if (!Abbreviations.empty()) {
2426 // Start the debug abbrev section.
2427 Asm->OutStreamer.SwitchSection(
2428 Asm->getObjFileLowering().getDwarfAbbrevSection());
2430 EmitLabel("abbrev_begin", 0);
2432 // For each abbrevation.
2433 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2434 // Get abbreviation data
2435 const DIEAbbrev *Abbrev = Abbreviations[i];
2437 // Emit the abbrevations code (base 1 index.)
2438 Asm->EmitULEB128Bytes(Abbrev->getNumber());
2439 Asm->EOL("Abbreviation Code");
2441 // Emit the abbreviations data.
2447 // Mark end of abbreviations.
2448 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2450 EmitLabel("abbrev_end", 0);
2455 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2456 /// the line matrix.
2458 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2459 // Define last address of section.
2460 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2461 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2462 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2463 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2465 // Mark end of matrix.
2466 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2467 Asm->EmitULEB128Bytes(1); Asm->EOL();
2468 Asm->EmitInt8(1); Asm->EOL();
2471 /// emitDebugLines - Emit source line information.
2473 void DwarfDebug::emitDebugLines() {
2474 // If the target is using .loc/.file, the assembler will be emitting the
2475 // .debug_line table automatically.
2476 if (MAI->hasDotLocAndDotFile())
2479 // Minimum line delta, thus ranging from -10..(255-10).
2480 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2481 // Maximum line delta, thus ranging from -10..(255-10).
2482 const int MaxLineDelta = 255 + MinLineDelta;
2484 // Start the dwarf line section.
2485 Asm->OutStreamer.SwitchSection(
2486 Asm->getObjFileLowering().getDwarfLineSection());
2488 // Construct the section header.
2489 EmitDifference("line_end", 0, "line_begin", 0, true);
2490 Asm->EOL("Length of Source Line Info");
2491 EmitLabel("line_begin", 0);
2493 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2495 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2496 Asm->EOL("Prolog Length");
2497 EmitLabel("line_prolog_begin", 0);
2499 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2501 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2503 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2505 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2507 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2509 // Line number standard opcode encodings argument count
2510 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2511 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2512 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2513 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2514 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2515 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2516 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2517 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2518 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2520 // Emit directories.
2521 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2522 Asm->EmitString(getSourceDirectoryName(DI));
2523 Asm->EOL("Directory");
2526 Asm->EmitInt8(0); Asm->EOL("End of directories");
2529 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2530 // Remember source id starts at 1.
2531 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2532 Asm->EmitString(getSourceFileName(Id.second));
2534 Asm->EmitULEB128Bytes(Id.first);
2535 Asm->EOL("Directory #");
2536 Asm->EmitULEB128Bytes(0);
2537 Asm->EOL("Mod date");
2538 Asm->EmitULEB128Bytes(0);
2539 Asm->EOL("File size");
2542 Asm->EmitInt8(0); Asm->EOL("End of files");
2544 EmitLabel("line_prolog_end", 0);
2546 // A sequence for each text section.
2547 unsigned SecSrcLinesSize = SectionSourceLines.size();
2549 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2550 // Isolate current sections line info.
2551 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2553 /*if (Asm->isVerbose()) {
2554 const MCSection *S = SectionMap[j + 1];
2555 O << '\t' << MAI->getCommentString() << " Section"
2556 << S->getName() << '\n';
2560 // Dwarf assumes we start with first line of first source file.
2561 unsigned Source = 1;
2564 // Construct rows of the address, source, line, column matrix.
2565 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2566 const SrcLineInfo &LineInfo = LineInfos[i];
2567 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2568 if (!LabelID) continue;
2570 if (LineInfo.getLine() == 0) continue;
2572 if (!Asm->isVerbose())
2575 std::pair<unsigned, unsigned> SourceID =
2576 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2577 O << '\t' << MAI->getCommentString() << ' '
2578 << getSourceDirectoryName(SourceID.first) << '/'
2579 << getSourceFileName(SourceID.second)
2580 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2583 // Define the line address.
2584 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2585 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2586 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2587 EmitReference("label", LabelID); Asm->EOL("Location label");
2589 // If change of source, then switch to the new source.
2590 if (Source != LineInfo.getSourceID()) {
2591 Source = LineInfo.getSourceID();
2592 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2593 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2596 // If change of line.
2597 if (Line != LineInfo.getLine()) {
2598 // Determine offset.
2599 int Offset = LineInfo.getLine() - Line;
2600 int Delta = Offset - MinLineDelta;
2603 Line = LineInfo.getLine();
2605 // If delta is small enough and in range...
2606 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2607 // ... then use fast opcode.
2608 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2610 // ... otherwise use long hand.
2611 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2612 Asm->EOL("DW_LNS_advance_line");
2613 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2614 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2617 // Copy the previous row (different address or source)
2618 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2622 emitEndOfLineMatrix(j + 1);
2625 if (SecSrcLinesSize == 0)
2626 // Because we're emitting a debug_line section, we still need a line
2627 // table. The linker and friends expect it to exist. If there's nothing to
2628 // put into it, emit an empty table.
2629 emitEndOfLineMatrix(1);
2631 EmitLabel("line_end", 0);
2635 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2637 void DwarfDebug::emitCommonDebugFrame() {
2638 if (!MAI->doesDwarfRequireFrameSection())
2642 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2643 TargetFrameInfo::StackGrowsUp ?
2644 TD->getPointerSize() : -TD->getPointerSize();
2646 // Start the dwarf frame section.
2647 Asm->OutStreamer.SwitchSection(
2648 Asm->getObjFileLowering().getDwarfFrameSection());
2650 EmitLabel("debug_frame_common", 0);
2651 EmitDifference("debug_frame_common_end", 0,
2652 "debug_frame_common_begin", 0, true);
2653 Asm->EOL("Length of Common Information Entry");
2655 EmitLabel("debug_frame_common_begin", 0);
2656 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2657 Asm->EOL("CIE Identifier Tag");
2658 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2659 Asm->EOL("CIE Version");
2660 Asm->EmitString("");
2661 Asm->EOL("CIE Augmentation");
2662 Asm->EmitULEB128Bytes(1);
2663 Asm->EOL("CIE Code Alignment Factor");
2664 Asm->EmitSLEB128Bytes(stackGrowth);
2665 Asm->EOL("CIE Data Alignment Factor");
2666 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2667 Asm->EOL("CIE RA Column");
2669 std::vector<MachineMove> Moves;
2670 RI->getInitialFrameState(Moves);
2672 EmitFrameMoves(NULL, 0, Moves, false);
2674 Asm->EmitAlignment(2, 0, 0, false);
2675 EmitLabel("debug_frame_common_end", 0);
2680 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2683 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2684 if (!MAI->doesDwarfRequireFrameSection())
2687 // Start the dwarf frame section.
2688 Asm->OutStreamer.SwitchSection(
2689 Asm->getObjFileLowering().getDwarfFrameSection());
2691 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2692 "debug_frame_begin", DebugFrameInfo.Number, true);
2693 Asm->EOL("Length of Frame Information Entry");
2695 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2697 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2699 Asm->EOL("FDE CIE offset");
2701 EmitReference("func_begin", DebugFrameInfo.Number);
2702 Asm->EOL("FDE initial location");
2703 EmitDifference("func_end", DebugFrameInfo.Number,
2704 "func_begin", DebugFrameInfo.Number);
2705 Asm->EOL("FDE address range");
2707 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2710 Asm->EmitAlignment(2, 0, 0, false);
2711 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2716 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2718 void DwarfDebug::emitDebugPubNames() {
2719 // Start the dwarf pubnames section.
2720 Asm->OutStreamer.SwitchSection(
2721 Asm->getObjFileLowering().getDwarfPubNamesSection());
2723 EmitDifference("pubnames_end", ModuleCU->getID(),
2724 "pubnames_begin", ModuleCU->getID(), true);
2725 Asm->EOL("Length of Public Names Info");
2727 EmitLabel("pubnames_begin", ModuleCU->getID());
2729 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2731 EmitSectionOffset("info_begin", "section_info",
2732 ModuleCU->getID(), 0, true, false);
2733 Asm->EOL("Offset of Compilation Unit Info");
2735 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2737 Asm->EOL("Compilation Unit Length");
2739 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2740 for (StringMap<DIE*>::const_iterator
2741 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2742 const char *Name = GI->getKeyData();
2743 DIE * Entity = GI->second;
2745 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2746 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2749 Asm->EmitInt32(0); Asm->EOL("End Mark");
2750 EmitLabel("pubnames_end", ModuleCU->getID());
2755 void DwarfDebug::emitDebugPubTypes() {
2756 // Start the dwarf pubnames section.
2757 Asm->OutStreamer.SwitchSection(
2758 Asm->getObjFileLowering().getDwarfPubTypesSection());
2759 EmitDifference("pubtypes_end", ModuleCU->getID(),
2760 "pubtypes_begin", ModuleCU->getID(), true);
2761 Asm->EOL("Length of Public Types Info");
2763 EmitLabel("pubtypes_begin", ModuleCU->getID());
2765 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2767 EmitSectionOffset("info_begin", "section_info",
2768 ModuleCU->getID(), 0, true, false);
2769 Asm->EOL("Offset of Compilation ModuleCU Info");
2771 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2773 Asm->EOL("Compilation ModuleCU Length");
2775 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2776 for (StringMap<DIE*>::const_iterator
2777 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2778 const char *Name = GI->getKeyData();
2779 DIE * Entity = GI->second;
2781 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2782 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2785 Asm->EmitInt32(0); Asm->EOL("End Mark");
2786 EmitLabel("pubtypes_end", ModuleCU->getID());
2791 /// emitDebugStr - Emit visible names into a debug str section.
2793 void DwarfDebug::emitDebugStr() {
2794 // Check to see if it is worth the effort.
2795 if (!StringPool.empty()) {
2796 // Start the dwarf str section.
2797 Asm->OutStreamer.SwitchSection(
2798 Asm->getObjFileLowering().getDwarfStrSection());
2800 // For each of strings in the string pool.
2801 for (unsigned StringID = 1, N = StringPool.size();
2802 StringID <= N; ++StringID) {
2803 // Emit a label for reference from debug information entries.
2804 EmitLabel("string", StringID);
2806 // Emit the string itself.
2807 const std::string &String = StringPool[StringID];
2808 Asm->EmitString(String); Asm->EOL();
2815 /// emitDebugLoc - Emit visible names into a debug loc section.
2817 void DwarfDebug::emitDebugLoc() {
2818 // Start the dwarf loc section.
2819 Asm->OutStreamer.SwitchSection(
2820 Asm->getObjFileLowering().getDwarfLocSection());
2824 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2826 void DwarfDebug::EmitDebugARanges() {
2827 // Start the dwarf aranges section.
2828 Asm->OutStreamer.SwitchSection(
2829 Asm->getObjFileLowering().getDwarfARangesSection());
2833 CompileUnit *Unit = GetBaseCompileUnit();
2835 // Don't include size of length
2836 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
2838 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2840 EmitReference("info_begin", Unit->getID());
2841 Asm->EOL("Offset of Compilation Unit Info");
2843 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2845 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2847 Asm->EmitInt16(0); Asm->EOL("Pad (1)");
2848 Asm->EmitInt16(0); Asm->EOL("Pad (2)");
2851 EmitReference("text_begin", 0); Asm->EOL("Address");
2852 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2854 Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2855 Asm->EmitInt32(0); Asm->EOL("EOM (2)");
2861 /// emitDebugRanges - Emit visible names into a debug ranges section.
2863 void DwarfDebug::emitDebugRanges() {
2864 // Start the dwarf ranges section.
2865 Asm->OutStreamer.SwitchSection(
2866 Asm->getObjFileLowering().getDwarfRangesSection());
2870 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2872 void DwarfDebug::emitDebugMacInfo() {
2873 if (const MCSection *LineInfo =
2874 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2875 // Start the dwarf macinfo section.
2876 Asm->OutStreamer.SwitchSection(LineInfo);
2881 /// emitDebugInlineInfo - Emit inline info using following format.
2883 /// 1. length of section
2884 /// 2. Dwarf version number
2885 /// 3. address size.
2887 /// Entries (one "entry" for each function that was inlined):
2889 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2890 /// otherwise offset into __debug_str for regular function name.
2891 /// 2. offset into __debug_str section for regular function name.
2892 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2893 /// instances for the function.
2895 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2896 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2897 /// __debug_info section, and the low_pc is the starting address for the
2898 /// inlining instance.
2899 void DwarfDebug::emitDebugInlineInfo() {
2900 if (!MAI->doesDwarfUsesInlineInfoSection())
2906 Asm->OutStreamer.SwitchSection(
2907 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2909 EmitDifference("debug_inlined_end", 1,
2910 "debug_inlined_begin", 1, true);
2911 Asm->EOL("Length of Debug Inlined Information Entry");
2913 EmitLabel("debug_inlined_begin", 1);
2915 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2916 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2918 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2919 E = InlinedSPNodes.end(); I != E; ++I) {
2921 // for (ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
2922 // I = InlineInfo.begin(), E = InlineInfo.end(); I != E; ++I) {
2924 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2925 = InlineInfo.find(Node);
2926 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2927 DISubprogram SP(Node);
2928 StringRef LName = SP.getLinkageName();
2929 StringRef Name = SP.getName();
2932 Asm->EmitString(Name);
2934 // Skip special LLVM prefix that is used to inform the asm printer to not
2935 // emit usual symbol prefix before the symbol name. This happens for
2936 // Objective-C symbol names and symbol whose name is replaced using GCC's
2937 // __asm__ attribute.
2939 LName = LName.substr(1);
2940 // Asm->EmitString(LName);
2941 EmitSectionOffset("string", "section_str",
2942 StringPool.idFor(LName), false, true);
2945 Asm->EOL("MIPS linkage name");
2946 // Asm->EmitString(Name);
2947 EmitSectionOffset("string", "section_str",
2948 StringPool.idFor(Name), false, true);
2949 Asm->EOL("Function name");
2950 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2952 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2953 LE = Labels.end(); LI != LE; ++LI) {
2954 DIE *SP = LI->second;
2955 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2957 if (TD->getPointerSize() == sizeof(int32_t))
2958 O << MAI->getData32bitsDirective();
2960 O << MAI->getData64bitsDirective();
2962 PrintLabelName("label", LI->first); Asm->EOL("low_pc");
2966 EmitLabel("debug_inlined_end", 1);