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/MCExpr.h"
19 #include "llvm/MC/MCSection.h"
20 #include "llvm/MC/MCStreamer.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/Target/Mangler.h"
23 #include "llvm/Target/TargetData.h"
24 #include "llvm/Target/TargetFrameInfo.h"
25 #include "llvm/Target/TargetLoweringObjectFile.h"
26 #include "llvm/Target/TargetRegisterInfo.h"
27 #include "llvm/ADT/StringExtras.h"
28 #include "llvm/Support/Debug.h"
29 #include "llvm/Support/ErrorHandling.h"
30 #include "llvm/Support/ValueHandle.h"
31 #include "llvm/Support/FormattedStream.h"
32 #include "llvm/Support/Timer.h"
33 #include "llvm/System/Path.h"
36 //===----------------------------------------------------------------------===//
38 /// Configuration values for initial hash set sizes (log2).
40 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
44 //===----------------------------------------------------------------------===//
45 /// CompileUnit - This dwarf writer support class manages information associate
46 /// with a source file.
48 /// ID - File identifier for source.
52 /// Die - Compile unit debug information entry.
56 /// IndexTyDie - An anonymous type for index type.
59 /// GVToDieMap - Tracks the mapping of unit level debug informaton
60 /// variables to debug information entries.
61 /// FIXME : Rename GVToDieMap -> NodeToDieMap
62 DenseMap<MDNode *, DIE *> GVToDieMap;
64 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
65 /// descriptors to debug information entries using a DIEEntry proxy.
67 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
69 /// Globals - A map of globally visible named entities for this unit.
71 StringMap<DIE*> Globals;
73 /// GlobalTypes - A map of globally visible types for this unit.
75 StringMap<DIE*> GlobalTypes;
78 CompileUnit(unsigned I, DIE *D)
79 : ID(I), CUDie(D), IndexTyDie(0) {}
80 ~CompileUnit() { delete CUDie; delete IndexTyDie; }
83 unsigned getID() const { return ID; }
84 DIE* getCUDie() const { return CUDie; }
85 const StringMap<DIE*> &getGlobals() const { return Globals; }
86 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
88 /// hasContent - Return true if this compile unit has something to write out.
90 bool hasContent() const { return !CUDie->getChildren().empty(); }
92 /// addGlobal - Add a new global entity to the compile unit.
94 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
96 /// addGlobalType - Add a new global type to the compile unit.
98 void addGlobalType(const std::string &Name, DIE *Die) {
99 GlobalTypes[Name] = Die;
102 /// getDIE - Returns the debug information entry map slot for the
103 /// specified debug variable.
104 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
106 /// insertDIE - Insert DIE into the map.
107 void insertDIE(MDNode *N, DIE *D) {
108 GVToDieMap.insert(std::make_pair(N, D));
111 /// getDIEEntry - Returns the debug information entry for the speciefied
113 DIEEntry *getDIEEntry(MDNode *N) {
114 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
115 if (I == GVToDIEEntryMap.end())
120 /// insertDIEEntry - Insert debug information entry into the map.
121 void insertDIEEntry(MDNode *N, DIEEntry *E) {
122 GVToDIEEntryMap.insert(std::make_pair(N, E));
125 /// addDie - Adds or interns the DIE to the compile unit.
127 void addDie(DIE *Buffer) {
128 this->CUDie->addChild(Buffer);
131 // getIndexTyDie - Get an anonymous type for index type.
132 DIE *getIndexTyDie() {
136 // setIndexTyDie - Set D as anonymous type for index which can be reused
138 void setIndexTyDie(DIE *D) {
144 //===----------------------------------------------------------------------===//
145 /// DbgVariable - This class is used to track local variable information.
148 DIVariable Var; // Variable Descriptor.
149 unsigned FrameIndex; // Variable frame index.
150 DbgVariable *AbstractVar; // Abstract variable for this variable.
153 DbgVariable(DIVariable V, unsigned I)
154 : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0) {}
157 DIVariable getVariable() const { return Var; }
158 unsigned getFrameIndex() const { return FrameIndex; }
159 void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
160 DbgVariable *getAbstractVariable() const { return AbstractVar; }
161 void setDIE(DIE *D) { TheDIE = D; }
162 DIE *getDIE() const { return TheDIE; }
165 //===----------------------------------------------------------------------===//
166 /// DbgScope - This class is used to track scope information.
169 DbgScope *Parent; // Parent to this scope.
170 DIDescriptor Desc; // Debug info descriptor for scope.
171 // Location at which this scope is inlined.
172 AssertingVH<MDNode> InlinedAtLocation;
173 bool AbstractScope; // Abstract Scope
174 unsigned StartLabelID; // Label ID of the beginning of scope.
175 unsigned EndLabelID; // Label ID of the end of scope.
176 const MachineInstr *LastInsn; // Last instruction of this scope.
177 const MachineInstr *FirstInsn; // First instruction of this scope.
178 SmallVector<DbgScope *, 4> Scopes; // Scopes defined in scope.
179 SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
181 // Private state for dump()
182 mutable unsigned IndentLevel;
184 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
185 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
186 StartLabelID(0), EndLabelID(0),
187 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
191 DbgScope *getParent() const { return Parent; }
192 void setParent(DbgScope *P) { Parent = P; }
193 DIDescriptor getDesc() const { return Desc; }
194 MDNode *getInlinedAt() const {
195 return InlinedAtLocation;
197 MDNode *getScopeNode() const { return Desc.getNode(); }
198 unsigned getStartLabelID() const { return StartLabelID; }
199 unsigned getEndLabelID() const { return EndLabelID; }
200 SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
201 SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
202 void setStartLabelID(unsigned S) { StartLabelID = S; }
203 void setEndLabelID(unsigned E) { EndLabelID = E; }
204 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
205 const MachineInstr *getLastInsn() { return LastInsn; }
206 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
207 void setAbstractScope() { AbstractScope = true; }
208 bool isAbstractScope() const { return AbstractScope; }
209 const MachineInstr *getFirstInsn() { return FirstInsn; }
211 /// addScope - Add a scope to the scope.
213 void addScope(DbgScope *S) { Scopes.push_back(S); }
215 /// addVariable - Add a variable to the scope.
217 void addVariable(DbgVariable *V) { Variables.push_back(V); }
219 void fixInstructionMarkers(DenseMap<const MachineInstr *,
220 unsigned> &MIIndexMap) {
221 assert (getFirstInsn() && "First instruction is missing!");
223 // Use the end of last child scope as end of this scope.
224 SmallVector<DbgScope *, 4> &Scopes = getScopes();
225 const MachineInstr *LastInsn = getFirstInsn();
227 if (Scopes.empty()) {
228 assert (getLastInsn() && "Inner most scope does not have last insn!");
231 for (SmallVector<DbgScope *, 4>::iterator SI = Scopes.begin(),
232 SE = Scopes.end(); SI != SE; ++SI) {
234 DS->fixInstructionMarkers(MIIndexMap);
235 const MachineInstr *DSLastInsn = DS->getLastInsn();
236 unsigned DSI = MIIndexMap[DSLastInsn];
238 LastInsn = DSLastInsn;
243 unsigned CurrentLastInsnIndex = 0;
244 if (const MachineInstr *CL = getLastInsn())
245 CurrentLastInsnIndex = MIIndexMap[CL];
246 unsigned FIndex = MIIndexMap[getFirstInsn()];
248 // Set LastInsn as the last instruction for this scope only if
250 // 1) this scope's first instruction and
251 // 2) current last instruction for this scope, if any.
252 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
253 setLastInsn(LastInsn);
262 void DbgScope::dump() const {
263 raw_ostream &err = dbgs();
264 err.indent(IndentLevel);
265 MDNode *N = Desc.getNode();
267 err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
269 err << "Abstract Scope\n";
273 err << "Children ...\n";
274 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
275 if (Scopes[i] != this)
282 DbgScope::~DbgScope() {
283 for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
285 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
289 } // end llvm namespace
291 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
292 : DwarfPrinter(OS, A, T), ModuleCU(0),
293 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
294 DIEValues(), StringPool(),
295 SectionSourceLines(), didInitial(false), shouldEmit(false),
296 CurrentFnDbgScope(0), DebugTimer(0) {
297 if (TimePassesIsEnabled)
298 DebugTimer = new Timer("Dwarf Debug Writer");
300 DwarfDebug::~DwarfDebug() {
301 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
307 /// assignAbbrevNumber - Define a unique number for the abbreviation.
309 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
310 // Profile the node so that we can make it unique.
314 // Check the set for priors.
315 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
317 // If it's newly added.
318 if (InSet == &Abbrev) {
319 // Add to abbreviation list.
320 Abbreviations.push_back(&Abbrev);
322 // Assign the vector position + 1 as its number.
323 Abbrev.setNumber(Abbreviations.size());
325 // Assign existing abbreviation number.
326 Abbrev.setNumber(InSet->getNumber());
330 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
331 /// information entry.
332 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
333 DIEEntry *Value = new DIEEntry(Entry);
334 DIEValues.push_back(Value);
338 /// addUInt - Add an unsigned integer attribute data and value.
340 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
341 unsigned Form, uint64_t Integer) {
342 if (!Form) Form = DIEInteger::BestForm(false, Integer);
343 DIEValue *Value = new DIEInteger(Integer);
344 DIEValues.push_back(Value);
345 Die->addValue(Attribute, Form, Value);
348 /// addSInt - Add an signed integer attribute data and value.
350 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
351 unsigned Form, int64_t Integer) {
352 if (!Form) Form = DIEInteger::BestForm(true, Integer);
353 DIEValue *Value = new DIEInteger(Integer);
354 DIEValues.push_back(Value);
355 Die->addValue(Attribute, Form, Value);
358 /// addString - Add a string attribute data and value. DIEString only
359 /// keeps string reference.
360 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
362 DIEValue *Value = new DIEString(String);
363 DIEValues.push_back(Value);
364 Die->addValue(Attribute, Form, Value);
367 /// addLabel - Add a Dwarf label attribute data and value.
369 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
370 const MCSymbol *Label) {
371 DIEValue *Value = new DIELabel(Label);
372 DIEValues.push_back(Value);
373 Die->addValue(Attribute, Form, Value);
376 /// addSectionOffset - Add a section offset label attribute data and value.
378 void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
379 const MCSymbol *Label,const MCSymbol *Section,
381 DIEValue *Value = new DIESectionOffset(Label, Section, isEH);
382 DIEValues.push_back(Value);
383 Die->addValue(Attribute, Form, Value);
386 /// addDelta - Add a label delta attribute data and value.
388 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
389 const MCSymbol *Hi, const MCSymbol *Lo) {
390 DIEValue *Value = new DIEDelta(Hi, Lo);
391 DIEValues.push_back(Value);
392 Die->addValue(Attribute, Form, Value);
395 /// addBlock - Add block data.
397 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
399 Block->ComputeSize(TD);
400 DIEValues.push_back(Block);
401 Die->addValue(Attribute, Block->BestForm(), Block);
404 /// addSourceLine - Add location information to specified debug information
406 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
407 // If there is no compile unit specified, don't add a line #.
408 if (!V->getCompileUnit().Verify())
411 unsigned Line = V->getLineNumber();
412 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
413 V->getContext().getFilename());
414 assert(FileID && "Invalid file id");
415 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
416 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
419 /// addSourceLine - Add location information to specified debug information
421 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
422 // If there is no compile unit specified, don't add a line #.
423 if (!G->getCompileUnit().Verify())
426 unsigned Line = G->getLineNumber();
427 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
428 G->getContext().getFilename());
429 assert(FileID && "Invalid file id");
430 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
431 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
434 /// addSourceLine - Add location information to specified debug information
436 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
437 // If there is no compile unit specified, don't add a line #.
438 if (!SP->getCompileUnit().Verify())
440 // If the line number is 0, don't add it.
441 if (SP->getLineNumber() == 0)
444 unsigned Line = SP->getLineNumber();
445 if (!SP->getContext().Verify())
447 unsigned FileID = GetOrCreateSourceID(SP->getContext().getDirectory(),
448 SP->getContext().getFilename());
449 assert(FileID && "Invalid file id");
450 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
451 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
454 /// addSourceLine - Add location information to specified debug information
456 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
457 // If there is no compile unit specified, don't add a line #.
458 DICompileUnit CU = Ty->getCompileUnit();
462 unsigned Line = Ty->getLineNumber();
463 if (!Ty->getContext().Verify())
465 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
466 Ty->getContext().getFilename());
467 assert(FileID && "Invalid file id");
468 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
469 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
472 /// addSourceLine - Add location information to specified debug information
474 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
475 // If there is no compile unit specified, don't add a line #.
476 if (!NS->getCompileUnit().Verify())
479 unsigned Line = NS->getLineNumber();
480 StringRef FN = NS->getFilename();
481 StringRef Dir = NS->getDirectory();
483 unsigned FileID = GetOrCreateSourceID(Dir, FN);
484 assert(FileID && "Invalid file id");
485 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
486 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
489 /* Byref variables, in Blocks, are declared by the programmer as
490 "SomeType VarName;", but the compiler creates a
491 __Block_byref_x_VarName struct, and gives the variable VarName
492 either the struct, or a pointer to the struct, as its type. This
493 is necessary for various behind-the-scenes things the compiler
494 needs to do with by-reference variables in blocks.
496 However, as far as the original *programmer* is concerned, the
497 variable should still have type 'SomeType', as originally declared.
499 The following function dives into the __Block_byref_x_VarName
500 struct to find the original type of the variable. This will be
501 passed back to the code generating the type for the Debug
502 Information Entry for the variable 'VarName'. 'VarName' will then
503 have the original type 'SomeType' in its debug information.
505 The original type 'SomeType' will be the type of the field named
506 'VarName' inside the __Block_byref_x_VarName struct.
508 NOTE: In order for this to not completely fail on the debugger
509 side, the Debug Information Entry for the variable VarName needs to
510 have a DW_AT_location that tells the debugger how to unwind through
511 the pointers and __Block_byref_x_VarName struct to find the actual
512 value of the variable. The function addBlockByrefType does this. */
514 /// Find the type the programmer originally declared the variable to be
515 /// and return that type.
517 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
520 unsigned tag = Ty.getTag();
522 if (tag == dwarf::DW_TAG_pointer_type) {
523 DIDerivedType DTy = DIDerivedType(Ty.getNode());
524 subType = DTy.getTypeDerivedFrom();
527 DICompositeType blockStruct = DICompositeType(subType.getNode());
528 DIArray Elements = blockStruct.getTypeArray();
530 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
531 DIDescriptor Element = Elements.getElement(i);
532 DIDerivedType DT = DIDerivedType(Element.getNode());
533 if (Name == DT.getName())
534 return (DT.getTypeDerivedFrom());
540 /// addComplexAddress - Start with the address based on the location provided,
541 /// and generate the DWARF information necessary to find the actual variable
542 /// given the extra address information encoded in the DIVariable, starting from
543 /// the starting location. Add the DWARF information to the die.
545 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
547 const MachineLocation &Location) {
548 const DIVariable &VD = DV->getVariable();
549 DIType Ty = VD.getType();
551 // Decode the original location, and use that as the start of the byref
552 // variable's location.
553 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
554 DIEBlock *Block = new DIEBlock();
556 if (Location.isReg()) {
558 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
560 Reg = Reg - dwarf::DW_OP_reg0;
561 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
562 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
566 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
568 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
569 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
572 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
575 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
576 uint64_t Element = VD.getAddrElement(i);
578 if (Element == DIFactory::OpPlus) {
579 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
580 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
581 } else if (Element == DIFactory::OpDeref) {
582 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
583 } else llvm_unreachable("unknown DIFactory Opcode");
586 // Now attach the location information to the DIE.
587 addBlock(Die, Attribute, 0, Block);
590 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
591 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
592 gives the variable VarName either the struct, or a pointer to the struct, as
593 its type. This is necessary for various behind-the-scenes things the
594 compiler needs to do with by-reference variables in Blocks.
596 However, as far as the original *programmer* is concerned, the variable
597 should still have type 'SomeType', as originally declared.
599 The function getBlockByrefType dives into the __Block_byref_x_VarName
600 struct to find the original type of the variable, which is then assigned to
601 the variable's Debug Information Entry as its real type. So far, so good.
602 However now the debugger will expect the variable VarName to have the type
603 SomeType. So we need the location attribute for the variable to be an
604 expression that explains to the debugger how to navigate through the
605 pointers and struct to find the actual variable of type SomeType.
607 The following function does just that. We start by getting
608 the "normal" location for the variable. This will be the location
609 of either the struct __Block_byref_x_VarName or the pointer to the
610 struct __Block_byref_x_VarName.
612 The struct will look something like:
614 struct __Block_byref_x_VarName {
616 struct __Block_byref_x_VarName *forwarding;
617 ... <various other fields>
619 ... <maybe more fields>
622 If we are given the struct directly (as our starting point) we
623 need to tell the debugger to:
625 1). Add the offset of the forwarding field.
627 2). Follow that pointer to get the real __Block_byref_x_VarName
628 struct to use (the real one may have been copied onto the heap).
630 3). Add the offset for the field VarName, to find the actual variable.
632 If we started with a pointer to the struct, then we need to
633 dereference that pointer first, before the other steps.
634 Translating this into DWARF ops, we will need to append the following
635 to the current location description for the variable:
637 DW_OP_deref -- optional, if we start with a pointer
638 DW_OP_plus_uconst <forward_fld_offset>
640 DW_OP_plus_uconst <varName_fld_offset>
642 That is what this function does. */
644 /// addBlockByrefAddress - Start with the address based on the location
645 /// provided, and generate the DWARF information necessary to find the
646 /// actual Block variable (navigating the Block struct) based on the
647 /// starting location. Add the DWARF information to the die. For
648 /// more information, read large comment just above here.
650 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
652 const MachineLocation &Location) {
653 const DIVariable &VD = DV->getVariable();
654 DIType Ty = VD.getType();
656 unsigned Tag = Ty.getTag();
657 bool isPointer = false;
659 StringRef varName = VD.getName();
661 if (Tag == dwarf::DW_TAG_pointer_type) {
662 DIDerivedType DTy = DIDerivedType(Ty.getNode());
663 TmpTy = DTy.getTypeDerivedFrom();
667 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
669 // Find the __forwarding field and the variable field in the __Block_byref
671 DIArray Fields = blockStruct.getTypeArray();
672 DIDescriptor varField = DIDescriptor();
673 DIDescriptor forwardingField = DIDescriptor();
675 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
676 DIDescriptor Element = Fields.getElement(i);
677 DIDerivedType DT = DIDerivedType(Element.getNode());
678 StringRef fieldName = DT.getName();
679 if (fieldName == "__forwarding")
680 forwardingField = Element;
681 else if (fieldName == varName)
685 // Get the offsets for the forwarding field and the variable field.
686 unsigned int forwardingFieldOffset =
687 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
688 unsigned int varFieldOffset =
689 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
691 // Decode the original location, and use that as the start of the byref
692 // variable's location.
693 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
694 DIEBlock *Block = new DIEBlock();
696 if (Location.isReg()) {
698 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
700 Reg = Reg - dwarf::DW_OP_reg0;
701 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
702 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
706 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
708 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
709 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
712 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
715 // If we started with a pointer to the __Block_byref... struct, then
716 // the first thing we need to do is dereference the pointer (DW_OP_deref).
718 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
720 // Next add the offset for the '__forwarding' field:
721 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
722 // adding the offset if it's 0.
723 if (forwardingFieldOffset > 0) {
724 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
725 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
728 // Now dereference the __forwarding field to get to the real __Block_byref
729 // struct: DW_OP_deref.
730 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
732 // Now that we've got the real __Block_byref... struct, add the offset
733 // for the variable's field to get to the location of the actual variable:
734 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
735 if (varFieldOffset > 0) {
736 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
737 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
740 // Now attach the location information to the DIE.
741 addBlock(Die, Attribute, 0, Block);
744 /// addAddress - Add an address attribute to a die based on the location
746 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
747 const MachineLocation &Location) {
748 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
749 DIEBlock *Block = new DIEBlock();
751 if (Location.isReg()) {
753 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
755 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
756 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
760 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
762 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
763 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
766 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
769 addBlock(Die, Attribute, 0, Block);
772 /// addToContextOwner - Add Die into the list of its context owner's children.
773 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
774 if (Context.isType()) {
775 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
776 ContextDIE->addChild(Die);
777 } else if (Context.isNameSpace()) {
778 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
779 ContextDIE->addChild(Die);
780 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
781 ContextDIE->addChild(Die);
783 ModuleCU->addDie(Die);
786 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
788 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
789 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
794 TyDIE = new DIE(dwarf::DW_TAG_base_type);
795 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
796 if (Ty.isBasicType())
797 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
798 else if (Ty.isCompositeType())
799 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
801 assert(Ty.isDerivedType() && "Unknown kind of DIType");
802 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
805 addToContextOwner(TyDIE, Ty.getContext());
809 /// addType - Add a new type attribute to the specified entity.
810 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
814 // Check for pre-existence.
815 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
816 // If it exists then use the existing value.
818 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
823 Entry = createDIEEntry();
824 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
827 DIE *Buffer = getOrCreateTypeDIE(Ty);
829 Entry->setEntry(Buffer);
830 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
833 /// constructTypeDIE - Construct basic type die from DIBasicType.
834 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
835 // Get core information.
836 StringRef Name = BTy.getName();
837 Buffer.setTag(dwarf::DW_TAG_base_type);
838 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
841 // Add name if not anonymous or intermediate type.
843 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
844 uint64_t Size = BTy.getSizeInBits() >> 3;
845 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
848 /// constructTypeDIE - Construct derived type die from DIDerivedType.
849 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
850 // Get core information.
851 StringRef Name = DTy.getName();
852 uint64_t Size = DTy.getSizeInBits() >> 3;
853 unsigned Tag = DTy.getTag();
855 // FIXME - Workaround for templates.
856 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
860 // Map to main type, void will not have a type.
861 DIType FromTy = DTy.getTypeDerivedFrom();
862 addType(&Buffer, FromTy);
864 // Add name if not anonymous or intermediate type.
866 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
868 // Add size if non-zero (derived types might be zero-sized.)
870 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
872 // Add source line info if available and TyDesc is not a forward declaration.
873 if (!DTy.isForwardDecl())
874 addSourceLine(&Buffer, &DTy);
877 /// constructTypeDIE - Construct type DIE from DICompositeType.
878 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
879 // Get core information.
880 StringRef Name = CTy.getName();
882 uint64_t Size = CTy.getSizeInBits() >> 3;
883 unsigned Tag = CTy.getTag();
887 case dwarf::DW_TAG_vector_type:
888 case dwarf::DW_TAG_array_type:
889 constructArrayTypeDIE(Buffer, &CTy);
891 case dwarf::DW_TAG_enumeration_type: {
892 DIArray Elements = CTy.getTypeArray();
894 // Add enumerators to enumeration type.
895 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
897 DIDescriptor Enum(Elements.getElement(i).getNode());
898 if (Enum.isEnumerator()) {
899 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
900 Buffer.addChild(ElemDie);
905 case dwarf::DW_TAG_subroutine_type: {
907 DIArray Elements = CTy.getTypeArray();
908 DIDescriptor RTy = Elements.getElement(0);
909 addType(&Buffer, DIType(RTy.getNode()));
911 // Add prototype flag.
912 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
915 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
916 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
917 DIDescriptor Ty = Elements.getElement(i);
918 addType(Arg, DIType(Ty.getNode()));
919 Buffer.addChild(Arg);
923 case dwarf::DW_TAG_structure_type:
924 case dwarf::DW_TAG_union_type:
925 case dwarf::DW_TAG_class_type: {
926 // Add elements to structure type.
927 DIArray Elements = CTy.getTypeArray();
929 // A forward struct declared type may not have elements available.
930 unsigned N = Elements.getNumElements();
934 // Add elements to structure type.
935 for (unsigned i = 0; i < N; ++i) {
936 DIDescriptor Element = Elements.getElement(i);
938 if (Element.isSubprogram())
939 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
940 else if (Element.isVariable()) {
941 DIVariable DV(Element.getNode());
942 ElemDie = new DIE(dwarf::DW_TAG_variable);
943 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
945 addType(ElemDie, DV.getType());
946 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
947 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
948 addSourceLine(ElemDie, &DV);
949 } else if (Element.isDerivedType())
950 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
953 Buffer.addChild(ElemDie);
956 if (CTy.isAppleBlockExtension())
957 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
959 unsigned RLang = CTy.getRunTimeLang();
961 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
962 dwarf::DW_FORM_data1, RLang);
964 DICompositeType ContainingType = CTy.getContainingType();
965 if (DIDescriptor(ContainingType.getNode()).isCompositeType())
966 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
967 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
974 // Add name if not anonymous or intermediate type.
976 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
978 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
979 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
980 // Add size if non-zero (derived types might be zero-sized.)
982 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
984 // Add zero size if it is not a forward declaration.
985 if (CTy.isForwardDecl())
986 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
988 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
991 // Add source line info if available.
992 if (!CTy.isForwardDecl())
993 addSourceLine(&Buffer, &CTy);
997 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
998 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
999 int64_t L = SR.getLo();
1000 int64_t H = SR.getHi();
1001 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1003 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1005 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1006 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1008 Buffer.addChild(DW_Subrange);
1011 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1012 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1013 DICompositeType *CTy) {
1014 Buffer.setTag(dwarf::DW_TAG_array_type);
1015 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1016 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1018 // Emit derived type.
1019 addType(&Buffer, CTy->getTypeDerivedFrom());
1020 DIArray Elements = CTy->getTypeArray();
1022 // Get an anonymous type for index type.
1023 DIE *IdxTy = ModuleCU->getIndexTyDie();
1025 // Construct an anonymous type for index type.
1026 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1027 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1028 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1029 dwarf::DW_ATE_signed);
1030 ModuleCU->addDie(IdxTy);
1031 ModuleCU->setIndexTyDie(IdxTy);
1034 // Add subranges to array type.
1035 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1036 DIDescriptor Element = Elements.getElement(i);
1037 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1038 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1042 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1043 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1044 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1045 StringRef Name = ETy.getName();
1046 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1047 int64_t Value = ETy.getEnumValue();
1048 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1052 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1053 /// printer to not emit usual symbol prefix before the symbol name is used then
1054 /// return linkage name after skipping this special LLVM prefix.
1055 static StringRef getRealLinkageName(StringRef LinkageName) {
1057 if (LinkageName.startswith(StringRef(&One, 1)))
1058 return LinkageName.substr(1);
1062 /// createGlobalVariableDIE - Create new DIE using GV.
1063 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1064 // If the global variable was optmized out then no need to create debug info
1066 if (!GV.getGlobal()) return NULL;
1067 if (GV.getDisplayName().empty()) return NULL;
1069 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1070 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1071 GV.getDisplayName());
1073 StringRef LinkageName = GV.getLinkageName();
1074 if (!LinkageName.empty())
1075 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1076 getRealLinkageName(LinkageName));
1078 addType(GVDie, GV.getType());
1079 if (!GV.isLocalToUnit())
1080 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1081 addSourceLine(GVDie, &GV);
1086 /// createMemberDIE - Create new member DIE.
1087 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1088 DIE *MemberDie = new DIE(DT.getTag());
1089 StringRef Name = DT.getName();
1091 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1093 addType(MemberDie, DT.getTypeDerivedFrom());
1095 addSourceLine(MemberDie, &DT);
1097 DIEBlock *MemLocationDie = new DIEBlock();
1098 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1100 uint64_t Size = DT.getSizeInBits();
1101 uint64_t FieldSize = DT.getOriginalTypeSize();
1103 if (Size != FieldSize) {
1105 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1106 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1108 uint64_t Offset = DT.getOffsetInBits();
1109 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1110 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1111 uint64_t FieldOffset = (HiMark - FieldSize);
1112 Offset -= FieldOffset;
1114 // Maybe we need to work from the other end.
1115 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1116 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1118 // Here WD_AT_data_member_location points to the anonymous
1119 // field that includes this bit field.
1120 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1123 // This is not a bitfield.
1124 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1126 if (DT.getTag() == dwarf::DW_TAG_inheritance
1127 && DT.isVirtual()) {
1129 // For C++, virtual base classes are not at fixed offset. Use following
1130 // expression to extract appropriate offset from vtable.
1131 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1133 DIEBlock *VBaseLocationDie = new DIEBlock();
1134 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1135 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1136 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1137 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1138 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1139 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1140 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1142 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1145 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1147 if (DT.isProtected())
1148 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1149 dwarf::DW_ACCESS_protected);
1150 else if (DT.isPrivate())
1151 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1152 dwarf::DW_ACCESS_private);
1153 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1154 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1155 dwarf::DW_ACCESS_public);
1157 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1158 dwarf::DW_VIRTUALITY_virtual);
1162 /// createSubprogramDIE - Create new DIE using SP.
1163 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1164 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1168 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1169 // Constructors and operators for anonymous aggregates do not have names.
1170 if (!SP.getName().empty())
1171 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1173 StringRef LinkageName = SP.getLinkageName();
1174 if (!LinkageName.empty())
1175 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1176 getRealLinkageName(LinkageName));
1178 addSourceLine(SPDie, &SP);
1180 // Add prototyped tag, if C or ObjC.
1181 unsigned Lang = SP.getCompileUnit().getLanguage();
1182 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1183 Lang == dwarf::DW_LANG_ObjC)
1184 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1187 DICompositeType SPTy = SP.getType();
1188 DIArray Args = SPTy.getTypeArray();
1189 unsigned SPTag = SPTy.getTag();
1191 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1192 addType(SPDie, SPTy);
1194 addType(SPDie, DIType(Args.getElement(0).getNode()));
1196 unsigned VK = SP.getVirtuality();
1198 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1199 DIEBlock *Block = new DIEBlock();
1200 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1201 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1202 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1203 ContainingTypeMap.insert(std::make_pair(SPDie,
1204 SP.getContainingType().getNode()));
1207 if (MakeDecl || !SP.isDefinition()) {
1208 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1210 // Add arguments. Do not add arguments for subprogram definition. They will
1211 // be handled while processing variables.
1212 DICompositeType SPTy = SP.getType();
1213 DIArray Args = SPTy.getTypeArray();
1214 unsigned SPTag = SPTy.getTag();
1216 if (SPTag == dwarf::DW_TAG_subroutine_type)
1217 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1218 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1219 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1221 if (ATy.isArtificial())
1222 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1223 SPDie->addChild(Arg);
1227 if (SP.isArtificial())
1228 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1230 // DW_TAG_inlined_subroutine may refer to this DIE.
1231 ModuleCU->insertDIE(SP.getNode(), SPDie);
1235 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1236 /// Initialize scope and update scope hierarchy.
1237 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1238 MDNode *InlinedAt) {
1239 assert (N && "Invalid Scope encoding!");
1240 assert (MI && "Missing machine instruction!");
1241 bool GetConcreteScope = (MI && InlinedAt);
1243 DbgScope *NScope = NULL;
1246 NScope = DbgScopeMap.lookup(InlinedAt);
1248 NScope = DbgScopeMap.lookup(N);
1249 assert (NScope && "Unable to find working scope!");
1251 if (NScope->getFirstInsn())
1254 DbgScope *Parent = NULL;
1255 if (GetConcreteScope) {
1256 DILocation IL(InlinedAt);
1257 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1258 IL.getOrigLocation().getNode());
1259 assert (Parent && "Unable to find Parent scope!");
1260 NScope->setParent(Parent);
1261 Parent->addScope(NScope);
1262 } else if (DIDescriptor(N).isLexicalBlock()) {
1263 DILexicalBlock DB(N);
1264 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1265 NScope->setParent(Parent);
1266 Parent->addScope(NScope);
1269 NScope->setFirstInsn(MI);
1271 if (!Parent && !InlinedAt) {
1272 StringRef SPName = DISubprogram(N).getLinkageName();
1273 if (SPName == MF->getFunction()->getName())
1274 CurrentFnDbgScope = NScope;
1277 if (GetConcreteScope) {
1278 ConcreteScopes[InlinedAt] = NScope;
1279 getOrCreateAbstractScope(N);
1285 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1286 assert (N && "Invalid Scope encoding!");
1288 DbgScope *AScope = AbstractScopes.lookup(N);
1292 DbgScope *Parent = NULL;
1294 DIDescriptor Scope(N);
1295 if (Scope.isLexicalBlock()) {
1296 DILexicalBlock DB(N);
1297 DIDescriptor ParentDesc = DB.getContext();
1298 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1301 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1304 Parent->addScope(AScope);
1305 AScope->setAbstractScope();
1306 AbstractScopes[N] = AScope;
1307 if (DIDescriptor(N).isSubprogram())
1308 AbstractScopesList.push_back(AScope);
1312 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1313 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1314 /// If there are global variables in this scope then create and insert
1315 /// DIEs for these variables.
1316 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1318 DIE *SPDie = ModuleCU->getDIE(SPNode);
1319 assert (SPDie && "Unable to find subprogram DIE!");
1320 DISubprogram SP(SPNode);
1321 // There is not any need to generate specification DIE for a function
1322 // defined at compile unit level. If a function is defined inside another
1323 // function then gdb prefers the definition at top level and but does not
1324 // expect specification DIE in parent function. So avoid creating
1325 // specification DIE for a function defined inside a function.
1326 if (SP.isDefinition() && !SP.getContext().isCompileUnit()
1327 && !SP.getContext().isSubprogram()) {
1328 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1330 DICompositeType SPTy = SP.getType();
1331 DIArray Args = SPTy.getTypeArray();
1332 unsigned SPTag = SPTy.getTag();
1333 if (SPTag == dwarf::DW_TAG_subroutine_type)
1334 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1335 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1336 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1338 if (ATy.isArtificial())
1339 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1340 SPDie->addChild(Arg);
1342 DIE *SPDeclDie = SPDie;
1343 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1344 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1346 ModuleCU->addDie(SPDie);
1349 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1350 getDWLabel("func_begin", SubprogramCount));
1351 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1352 getDWLabel("func_end", SubprogramCount));
1353 MachineLocation Location(RI->getFrameRegister(*MF));
1354 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1356 if (!DISubprogram(SPNode).isLocalToUnit())
1357 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1362 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1363 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1364 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1365 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1366 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1368 // Ignore empty scopes.
1369 if (StartID == EndID && StartID != 0)
1372 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1373 if (Scope->isAbstractScope())
1376 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1377 StartID ? getDWLabel("label", StartID)
1378 : getDWLabel("func_begin", SubprogramCount));
1379 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1380 EndID ? getDWLabel("label", EndID)
1381 : getDWLabel("func_end", SubprogramCount));
1386 /// constructInlinedScopeDIE - This scope represents inlined body of
1387 /// a function. Construct DIE to represent this concrete inlined copy
1388 /// of the function.
1389 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1390 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1391 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1392 assert (StartID && "Invalid starting label for an inlined scope!");
1393 assert (EndID && "Invalid end label for an inlined scope!");
1394 // Ignore empty scopes.
1395 if (StartID == EndID && StartID != 0)
1397 if (!Scope->getScopeNode())
1399 DIScope DS(Scope->getScopeNode());
1400 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1402 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1403 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1404 assert (OriginDIE && "Unable to find Origin DIE!");
1405 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1406 dwarf::DW_FORM_ref4, OriginDIE);
1408 MCSymbol *StartLabel = getDWLabel("label", StartID);
1410 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1411 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1412 getDWLabel("label", EndID));
1414 InlinedSubprogramDIEs.insert(OriginDIE);
1416 // Track the start label for this inlined function.
1417 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1418 I = InlineInfo.find(InlinedSP.getNode());
1420 if (I == InlineInfo.end()) {
1421 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1423 InlinedSPNodes.push_back(InlinedSP.getNode());
1425 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1427 StringPool.insert(InlinedSP.getName());
1428 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1430 DILocation DL(Scope->getInlinedAt());
1431 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1432 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1438 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1439 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1440 // Get the descriptor.
1441 const DIVariable &VD = DV->getVariable();
1442 StringRef Name = VD.getName();
1446 // Translate tag to proper Dwarf tag. The result variable is dropped for
1449 switch (VD.getTag()) {
1450 case dwarf::DW_TAG_return_variable:
1452 case dwarf::DW_TAG_arg_variable:
1453 Tag = dwarf::DW_TAG_formal_parameter;
1455 case dwarf::DW_TAG_auto_variable: // fall thru
1457 Tag = dwarf::DW_TAG_variable;
1461 // Define variable debug information entry.
1462 DIE *VariableDie = new DIE(Tag);
1466 if (DbgVariable *AV = DV->getAbstractVariable())
1467 AbsDIE = AV->getDIE();
1470 DIScope DS(Scope->getScopeNode());
1471 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1472 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1474 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1475 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1476 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1477 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1478 dwarf::DW_FORM_ref4, AbsDIE);
1481 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1482 addSourceLine(VariableDie, &VD);
1484 // Add variable type.
1485 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1486 // addresses instead.
1487 if (VD.isBlockByrefVariable())
1488 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1490 addType(VariableDie, VD.getType());
1493 // Add variable address.
1494 if (!Scope->isAbstractScope()) {
1495 MachineLocation Location;
1497 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1498 Location.set(FrameReg, Offset);
1500 if (VD.hasComplexAddress())
1501 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1502 else if (VD.isBlockByrefVariable())
1503 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1505 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1508 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1509 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1510 DV->setDIE(VariableDie);
1515 void DwarfDebug::addPubTypes(DISubprogram SP) {
1516 DICompositeType SPTy = SP.getType();
1517 unsigned SPTag = SPTy.getTag();
1518 if (SPTag != dwarf::DW_TAG_subroutine_type)
1521 DIArray Args = SPTy.getTypeArray();
1522 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1523 DIType ATy(Args.getElement(i).getNode());
1526 DICompositeType CATy = getDICompositeType(ATy);
1527 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1528 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1529 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1534 /// constructScopeDIE - Construct a DIE for this scope.
1535 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1536 if (!Scope || !Scope->getScopeNode())
1539 DIScope DS(Scope->getScopeNode());
1540 DIE *ScopeDIE = NULL;
1541 if (Scope->getInlinedAt())
1542 ScopeDIE = constructInlinedScopeDIE(Scope);
1543 else if (DS.isSubprogram()) {
1544 if (Scope->isAbstractScope())
1545 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1547 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1550 ScopeDIE = constructLexicalScopeDIE(Scope);
1551 if (!ScopeDIE) return NULL;
1554 // Add variables to scope.
1555 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1556 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1557 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1559 ScopeDIE->addChild(VariableDIE);
1562 // Add nested scopes.
1563 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1564 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1565 // Define the Scope debug information entry.
1566 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1568 ScopeDIE->addChild(NestedDIE);
1571 if (DS.isSubprogram())
1572 addPubTypes(DISubprogram(DS.getNode()));
1577 /// GetOrCreateSourceID - Look up the source id with the given directory and
1578 /// source file names. If none currently exists, create a new id and insert it
1579 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1581 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1583 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1584 if (DI != DirectoryIdMap.end()) {
1585 DId = DI->getValue();
1587 DId = DirectoryNames.size() + 1;
1588 DirectoryIdMap[DirName] = DId;
1589 DirectoryNames.push_back(DirName);
1593 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1594 if (FI != SourceFileIdMap.end()) {
1595 FId = FI->getValue();
1597 FId = SourceFileNames.size() + 1;
1598 SourceFileIdMap[FileName] = FId;
1599 SourceFileNames.push_back(FileName);
1602 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1603 SourceIdMap.find(std::make_pair(DId, FId));
1604 if (SI != SourceIdMap.end())
1607 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1608 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1609 SourceIds.push_back(std::make_pair(DId, FId));
1614 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1615 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1616 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1619 NDie = new DIE(dwarf::DW_TAG_namespace);
1620 ModuleCU->insertDIE(NS.getNode(), NDie);
1621 if (!NS.getName().empty())
1622 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1623 addSourceLine(NDie, &NS);
1624 addToContextOwner(NDie, NS.getContext());
1628 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1629 DICompileUnit DIUnit(N);
1630 StringRef FN = DIUnit.getFilename();
1631 StringRef Dir = DIUnit.getDirectory();
1632 unsigned ID = GetOrCreateSourceID(Dir, FN);
1634 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1635 // FIXME: Why getting the delta between two identical labels??
1636 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1637 getTempLabel("section_line"), getTempLabel("section_line"),
1639 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1640 DIUnit.getProducer());
1641 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1642 DIUnit.getLanguage());
1643 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1646 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1647 if (DIUnit.isOptimized())
1648 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1650 StringRef Flags = DIUnit.getFlags();
1652 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1654 unsigned RVer = DIUnit.getRunTimeVersion();
1656 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1657 dwarf::DW_FORM_data1, RVer);
1659 CompileUnit *Unit = new CompileUnit(ID, Die);
1660 if (!ModuleCU && DIUnit.isMain()) {
1661 // Use first compile unit marked as isMain as the compile unit
1669 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1670 DIGlobalVariable DI_GV(N);
1672 // If debug information is malformed then ignore it.
1673 if (DI_GV.Verify() == false)
1676 // Check for pre-existence.
1677 if (ModuleCU->getDIE(DI_GV.getNode()))
1680 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1685 ModuleCU->insertDIE(N, VariableDie);
1687 // Add to context owner.
1688 DIDescriptor GVContext = DI_GV.getContext();
1689 // Do not create specification DIE if context is either compile unit
1691 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1692 && !GVContext.isSubprogram()) {
1693 // Create specification DIE.
1694 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1695 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1696 dwarf::DW_FORM_ref4, VariableDie);
1697 DIEBlock *Block = new DIEBlock();
1698 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1699 addLabel(Block, 0, dwarf::DW_FORM_udata,
1700 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1701 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1702 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1703 ModuleCU->addDie(VariableSpecDIE);
1705 DIEBlock *Block = new DIEBlock();
1706 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1707 addLabel(Block, 0, dwarf::DW_FORM_udata,
1708 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1709 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1711 addToContextOwner(VariableDie, GVContext);
1713 // Expose as global. FIXME - need to check external flag.
1714 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1716 DIType GTy = DI_GV.getType();
1717 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1718 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1719 assert (Entry && "Missing global type!");
1720 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1725 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1728 // Check for pre-existence.
1729 if (ModuleCU->getDIE(N))
1732 if (!SP.isDefinition())
1733 // This is a method declaration which will be handled while constructing
1737 DIE *SubprogramDie = createSubprogramDIE(SP);
1740 ModuleCU->insertDIE(N, SubprogramDie);
1742 // Add to context owner.
1743 addToContextOwner(SubprogramDie, SP.getContext());
1745 // Expose as global.
1746 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1751 /// beginModule - Emit all Dwarf sections that should come prior to the
1752 /// content. Create global DIEs and emit initial debug info sections.
1753 /// This is inovked by the target AsmPrinter.
1754 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1757 if (TimePassesIsEnabled)
1758 DebugTimer->startTimer();
1760 if (!MAI->doesSupportDebugInformation())
1763 DebugInfoFinder DbgFinder;
1764 DbgFinder.processModule(*M);
1766 // Create all the compile unit DIEs.
1767 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1768 E = DbgFinder.compile_unit_end(); I != E; ++I)
1769 constructCompileUnit(*I);
1774 // Create DIEs for each subprogram.
1775 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1776 E = DbgFinder.subprogram_end(); I != E; ++I)
1777 constructSubprogramDIE(*I);
1779 // Create DIEs for each global variable.
1780 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1781 E = DbgFinder.global_variable_end(); I != E; ++I)
1782 constructGlobalVariableDIE(*I);
1786 MMI->setDebugInfoAvailability(true);
1788 // Prime section data.
1789 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1791 // Print out .file directives to specify files for .loc directives. These are
1792 // printed out early so that they precede any .loc directives.
1793 if (MAI->hasDotLocAndDotFile()) {
1794 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1795 // Remember source id starts at 1.
1796 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1797 // FIXME: don't use sys::path for this! This should not depend on the
1799 sys::Path FullPath(getSourceDirectoryName(Id.first));
1801 FullPath.appendComponent(getSourceFileName(Id.second));
1802 assert(AppendOk && "Could not append filename to directory!");
1804 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1808 // Emit initial sections
1811 if (TimePassesIsEnabled)
1812 DebugTimer->stopTimer();
1815 /// endModule - Emit all Dwarf sections that should come after the content.
1817 void DwarfDebug::endModule() {
1821 if (TimePassesIsEnabled)
1822 DebugTimer->startTimer();
1824 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1825 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1826 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1828 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1831 // Insert top level DIEs.
1832 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1833 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1834 ModuleCU->getCUDie()->addChild(*TI);
1836 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1837 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1838 DIE *SPDie = CI->first;
1839 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1841 DIE *NDie = ModuleCU->getDIE(N);
1842 if (!NDie) continue;
1843 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1844 // FIXME - This is not the correct approach.
1845 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1848 // Standard sections final addresses.
1849 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1850 Asm->OutStreamer.EmitLabel(getTempLabel("text_end"));
1851 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1852 Asm->OutStreamer.EmitLabel(getTempLabel("data_end"));
1854 // End text sections.
1855 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1856 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1857 Asm->OutStreamer.EmitLabel(getDWLabel("section_end", i));
1860 // Emit common frame information.
1861 emitCommonDebugFrame();
1863 // Emit function debug frame information
1864 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1865 E = DebugFrames.end(); I != E; ++I)
1866 emitFunctionDebugFrame(*I);
1868 // Compute DIE offsets and sizes.
1869 computeSizeAndOffsets();
1871 // Emit all the DIEs into a debug info section
1874 // Corresponding abbreviations into a abbrev section.
1875 emitAbbreviations();
1877 // Emit source line correspondence into a debug line section.
1880 // Emit info into a debug pubnames section.
1881 emitDebugPubNames();
1883 // Emit info into a debug pubtypes section.
1884 emitDebugPubTypes();
1886 // Emit info into a debug str section.
1889 // Emit info into a debug loc section.
1892 // Emit info into a debug aranges section.
1895 // Emit info into a debug ranges section.
1898 // Emit info into a debug macinfo section.
1901 // Emit inline info.
1902 emitDebugInlineInfo();
1904 if (TimePassesIsEnabled)
1905 DebugTimer->stopTimer();
1908 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1909 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1911 DILocation &ScopeLoc) {
1913 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1915 return AbsDbgVariable;
1917 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1921 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1922 Scope->addVariable(AbsDbgVariable);
1923 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1924 return AbsDbgVariable;
1927 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1928 void DwarfDebug::collectVariableInfo() {
1931 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1932 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1933 VE = VMap.end(); VI != VE; ++VI) {
1934 MDNode *Var = VI->first;
1936 DIVariable DV (Var);
1937 std::pair< unsigned, MDNode *> VP = VI->second;
1938 DILocation ScopeLoc(VP.second);
1941 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1943 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1944 // If variable scope is not found then skip this variable.
1948 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1949 Scope->addVariable(RegVar);
1950 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1952 RegVar->setAbstractVariable(AbsDbgVariable);
1956 /// beginScope - Process beginning of a scope starting at Label.
1957 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1958 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1959 if (I == DbgScopeBeginMap.end())
1961 ScopeVector &SD = I->second;
1962 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1964 (*SDI)->setStartLabelID(Label);
1967 /// endScope - Process end of a scope.
1968 void DwarfDebug::endScope(const MachineInstr *MI) {
1969 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1970 if (I == DbgScopeEndMap.end())
1973 unsigned Label = MMI->NextLabelID();
1974 Asm->printLabel(Label);
1977 SmallVector<DbgScope *, 2> &SD = I->second;
1978 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1980 (*SDI)->setEndLabelID(Label);
1984 /// createDbgScope - Create DbgScope for the scope.
1985 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1988 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1991 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1992 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1993 if (DIDescriptor(Scope).isLexicalBlock())
1994 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1998 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2002 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2003 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2004 DILocation DL(InlinedAt);
2005 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2008 /// extractScopeInformation - Scan machine instructions in this function
2009 /// and collect DbgScopes. Return true, if atleast one scope was found.
2010 bool DwarfDebug::extractScopeInformation() {
2011 // If scope information was extracted using .dbg intrinsics then there is not
2012 // any need to extract these information by scanning each instruction.
2013 if (!DbgScopeMap.empty())
2016 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2017 unsigned MIIndex = 0;
2018 // Scan each instruction and create scopes. First build working set of scopes.
2019 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2021 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2023 const MachineInstr *MInsn = II;
2024 MIIndexMap[MInsn] = MIIndex++;
2025 DebugLoc DL = MInsn->getDebugLoc();
2026 if (DL.isUnknown()) continue;
2027 DILocation DLT = MF->getDILocation(DL);
2028 DIScope DLTScope = DLT.getScope();
2029 // There is no need to create another DIE for compile unit. For all
2030 // other scopes, create one DbgScope now. This will be translated
2031 // into a scope DIE at the end.
2032 if (DLTScope.isCompileUnit()) continue;
2033 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2038 // Build scope hierarchy using working set of scopes.
2039 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2041 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2043 const MachineInstr *MInsn = II;
2044 DebugLoc DL = MInsn->getDebugLoc();
2045 if (DL.isUnknown()) continue;
2046 DILocation DLT = MF->getDILocation(DL);
2047 DIScope DLTScope = DLT.getScope();
2048 // There is no need to create another DIE for compile unit. For all
2049 // other scopes, create one DbgScope now. This will be translated
2050 // into a scope DIE at the end.
2051 if (DLTScope.isCompileUnit()) continue;
2052 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2053 DLT.getOrigLocation().getNode());
2054 Scope->setLastInsn(MInsn);
2058 if (!CurrentFnDbgScope)
2061 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2063 // Each scope has first instruction and last instruction to mark beginning
2064 // and end of a scope respectively. Create an inverse map that list scopes
2065 // starts (and ends) with an instruction. One instruction may start (or end)
2066 // multiple scopes. Ignore scopes that are not reachable.
2067 SmallVector<DbgScope *, 4> WorkList;
2068 WorkList.push_back(CurrentFnDbgScope);
2069 while (!WorkList.empty()) {
2070 DbgScope *S = WorkList.back(); WorkList.pop_back();
2072 SmallVector<DbgScope *, 4> &Children = S->getScopes();
2073 if (!Children.empty())
2074 for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2075 SE = Children.end(); SI != SE; ++SI)
2076 WorkList.push_back(*SI);
2078 if (S->isAbstractScope())
2080 const MachineInstr *MI = S->getFirstInsn();
2081 assert (MI && "DbgScope does not have first instruction!");
2083 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2084 if (IDI != DbgScopeBeginMap.end())
2085 IDI->second.push_back(S);
2087 DbgScopeBeginMap[MI].push_back(S);
2089 MI = S->getLastInsn();
2090 assert (MI && "DbgScope does not have last instruction!");
2091 IDI = DbgScopeEndMap.find(MI);
2092 if (IDI != DbgScopeEndMap.end())
2093 IDI->second.push_back(S);
2095 DbgScopeEndMap[MI].push_back(S);
2098 return !DbgScopeMap.empty();
2101 /// beginFunction - Gather pre-function debug information. Assumes being
2102 /// emitted immediately after the function entry point.
2103 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2106 if (!ShouldEmitDwarfDebug()) return;
2108 if (TimePassesIsEnabled)
2109 DebugTimer->startTimer();
2111 if (!extractScopeInformation())
2114 collectVariableInfo();
2116 // Assumes in correct section after the entry point.
2117 Asm->OutStreamer.EmitLabel(getDWLabel("func_begin", ++SubprogramCount));
2119 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2121 DebugLoc FDL = MF->getDefaultDebugLoc();
2122 if (!FDL.isUnknown()) {
2123 DILocation DLT = MF->getDILocation(FDL);
2124 unsigned LabelID = 0;
2125 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2127 LabelID = recordSourceLine(SP.getLineNumber(), 0,
2128 DLT.getScope().getNode());
2130 LabelID = recordSourceLine(DLT.getLineNumber(),
2131 DLT.getColumnNumber(),
2132 DLT.getScope().getNode());
2133 Asm->printLabel(LabelID);
2136 if (TimePassesIsEnabled)
2137 DebugTimer->stopTimer();
2140 /// endFunction - Gather and emit post-function debug information.
2142 void DwarfDebug::endFunction(const MachineFunction *MF) {
2143 if (!ShouldEmitDwarfDebug()) return;
2145 if (TimePassesIsEnabled)
2146 DebugTimer->startTimer();
2148 if (DbgScopeMap.empty())
2151 if (CurrentFnDbgScope) {
2152 // Define end label for subprogram.
2153 Asm->OutStreamer.EmitLabel(getDWLabel("func_end", SubprogramCount));
2155 // Get function line info.
2156 if (!Lines.empty()) {
2157 // Get section line info.
2158 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2159 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2160 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2161 // Append the function info to section info.
2162 SectionLineInfos.insert(SectionLineInfos.end(),
2163 Lines.begin(), Lines.end());
2166 // Construct abstract scopes.
2167 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2168 AE = AbstractScopesList.end(); AI != AE; ++AI)
2169 constructScopeDIE(*AI);
2171 constructScopeDIE(CurrentFnDbgScope);
2173 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2174 MMI->getFrameMoves()));
2178 CurrentFnDbgScope = NULL;
2179 DbgScopeMap.clear();
2180 DbgScopeBeginMap.clear();
2181 DbgScopeEndMap.clear();
2182 ConcreteScopes.clear();
2183 AbstractScopesList.clear();
2186 if (TimePassesIsEnabled)
2187 DebugTimer->stopTimer();
2190 /// recordSourceLine - Records location information and associates it with a
2191 /// label. Returns a unique label ID used to generate a label and provide
2192 /// correspondence to the source line list.
2193 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2198 if (TimePassesIsEnabled)
2199 DebugTimer->startTimer();
2204 DIDescriptor Scope(S);
2205 if (Scope.isCompileUnit()) {
2206 DICompileUnit CU(S);
2207 Dir = CU.getDirectory();
2208 Fn = CU.getFilename();
2209 } else if (Scope.isSubprogram()) {
2211 Dir = SP.getDirectory();
2212 Fn = SP.getFilename();
2213 } else if (Scope.isLexicalBlock()) {
2214 DILexicalBlock DB(S);
2215 Dir = DB.getDirectory();
2216 Fn = DB.getFilename();
2218 assert (0 && "Unexpected scope info");
2220 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2221 unsigned ID = MMI->NextLabelID();
2222 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2224 if (TimePassesIsEnabled)
2225 DebugTimer->stopTimer();
2230 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2231 /// timed. Look up the source id with the given directory and source file
2232 /// names. If none currently exists, create a new id and insert it in the
2233 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2235 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2236 const std::string &FileName) {
2237 if (TimePassesIsEnabled)
2238 DebugTimer->startTimer();
2240 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2242 if (TimePassesIsEnabled)
2243 DebugTimer->stopTimer();
2248 //===----------------------------------------------------------------------===//
2250 //===----------------------------------------------------------------------===//
2252 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2255 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2256 // Get the children.
2257 const std::vector<DIE *> &Children = Die->getChildren();
2259 // If not last sibling and has children then add sibling offset attribute.
2260 if (!Last && !Children.empty()) Die->addSiblingOffset();
2262 // Record the abbreviation.
2263 assignAbbrevNumber(Die->getAbbrev());
2265 // Get the abbreviation for this DIE.
2266 unsigned AbbrevNumber = Die->getAbbrevNumber();
2267 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2270 Die->setOffset(Offset);
2272 // Start the size with the size of abbreviation code.
2273 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2275 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2276 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2278 // Size the DIE attribute values.
2279 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2280 // Size attribute value.
2281 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2283 // Size the DIE children if any.
2284 if (!Children.empty()) {
2285 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2286 "Children flag not set");
2288 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2289 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2291 // End of children marker.
2292 Offset += sizeof(int8_t);
2295 Die->setSize(Offset - Die->getOffset());
2299 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2301 void DwarfDebug::computeSizeAndOffsets() {
2302 // Compute size of compile unit header.
2303 static unsigned Offset =
2304 sizeof(int32_t) + // Length of Compilation Unit Info
2305 sizeof(int16_t) + // DWARF version number
2306 sizeof(int32_t) + // Offset Into Abbrev. Section
2307 sizeof(int8_t); // Pointer Size (in bytes)
2309 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2310 CompileUnitOffsets[ModuleCU] = 0;
2313 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2314 /// tools to recognize the object file contains Dwarf information.
2315 void DwarfDebug::emitInitial() {
2316 // Check to see if we already emitted intial headers.
2317 if (didInitial) return;
2320 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2322 // Dwarf sections base addresses.
2323 if (MAI->doesDwarfRequireFrameSection()) {
2324 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2325 Asm->OutStreamer.EmitLabel(getTempLabel("section_debug_frame"));
2328 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2329 Asm->OutStreamer.EmitLabel(getTempLabel("section_info"));
2330 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2331 Asm->OutStreamer.EmitLabel(getTempLabel("section_abbrev"));
2332 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2333 Asm->OutStreamer.EmitLabel(getTempLabel("section_aranges"));
2335 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2336 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2337 Asm->OutStreamer.EmitLabel(getTempLabel("section_macinfo"));
2340 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2341 Asm->OutStreamer.EmitLabel(getTempLabel("section_line"));
2342 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2343 Asm->OutStreamer.EmitLabel(getTempLabel("section_loc"));
2344 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2345 Asm->OutStreamer.EmitLabel(getTempLabel("section_pubnames"));
2346 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2347 Asm->OutStreamer.EmitLabel(getTempLabel("section_pubtypes"));
2348 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2349 Asm->OutStreamer.EmitLabel(getTempLabel("section_str"));
2350 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2351 Asm->OutStreamer.EmitLabel(getTempLabel("section_ranges"));
2353 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2354 Asm->OutStreamer.EmitLabel(getTempLabel("text_begin"));
2355 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2356 Asm->OutStreamer.EmitLabel(getTempLabel("data_begin"));
2359 /// emitDIE - Recusively Emits a debug information entry.
2361 void DwarfDebug::emitDIE(DIE *Die) {
2362 // Get the abbreviation for this DIE.
2363 unsigned AbbrevNumber = Die->getAbbrevNumber();
2364 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2368 // Emit the code (index) for the abbreviation.
2369 if (Asm->VerboseAsm)
2370 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2371 Twine::utohexstr(Die->getOffset()) + ":0x" +
2372 Twine::utohexstr(Die->getSize()) + " " +
2373 dwarf::TagString(Abbrev->getTag()));
2374 EmitULEB128(AbbrevNumber);
2376 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2377 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2379 // Emit the DIE attribute values.
2380 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2381 unsigned Attr = AbbrevData[i].getAttribute();
2382 unsigned Form = AbbrevData[i].getForm();
2383 assert(Form && "Too many attributes for DIE (check abbreviation)");
2385 if (Asm->VerboseAsm)
2386 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2389 case dwarf::DW_AT_sibling:
2390 Asm->EmitInt32(Die->getSiblingOffset());
2392 case dwarf::DW_AT_abstract_origin: {
2393 DIEEntry *E = cast<DIEEntry>(Values[i]);
2394 DIE *Origin = E->getEntry();
2395 unsigned Addr = Origin->getOffset();
2396 Asm->EmitInt32(Addr);
2400 // Emit an attribute using the defined form.
2401 Values[i]->EmitValue(this, Form);
2402 O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2407 // Emit the DIE children if any.
2408 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2409 const std::vector<DIE *> &Children = Die->getChildren();
2411 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2412 emitDIE(Children[j]);
2414 Asm->EmitInt8(0); EOL("End Of Children Mark");
2418 /// emitDebugInfo - Emit the debug info section.
2420 void DwarfDebug::emitDebugInfo() {
2421 // Start debug info section.
2422 Asm->OutStreamer.SwitchSection(
2423 Asm->getObjFileLowering().getDwarfInfoSection());
2424 DIE *Die = ModuleCU->getCUDie();
2426 // Emit the compile units header.
2427 Asm->OutStreamer.EmitLabel(getDWLabel("info_begin", ModuleCU->getID()));
2429 // Emit size of content not including length itself
2430 unsigned ContentSize = Die->getSize() +
2431 sizeof(int16_t) + // DWARF version number
2432 sizeof(int32_t) + // Offset Into Abbrev. Section
2433 sizeof(int8_t) + // Pointer Size (in bytes)
2434 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2436 Asm->EmitInt32(ContentSize); EOL("Length of Compilation Unit Info");
2437 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2438 EmitSectionOffset(getTempLabel("abbrev_begin"),getTempLabel("section_abbrev"),
2440 EOL("Offset Into Abbrev. Section");
2441 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2444 // FIXME - extra padding for gdb bug.
2445 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2446 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2447 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2448 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2449 Asm->OutStreamer.EmitLabel(getDWLabel("info_end", ModuleCU->getID()));
2453 /// emitAbbreviations - Emit the abbreviation section.
2455 void DwarfDebug::emitAbbreviations() const {
2456 // Check to see if it is worth the effort.
2457 if (!Abbreviations.empty()) {
2458 // Start the debug abbrev section.
2459 Asm->OutStreamer.SwitchSection(
2460 Asm->getObjFileLowering().getDwarfAbbrevSection());
2462 Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_begin"));
2464 // For each abbrevation.
2465 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2466 // Get abbreviation data
2467 const DIEAbbrev *Abbrev = Abbreviations[i];
2469 // Emit the abbrevations code (base 1 index.)
2470 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2472 // Emit the abbreviations data.
2477 // Mark end of abbreviations.
2478 EmitULEB128(0, "EOM(3)");
2480 Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_end"));
2484 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2485 /// the line matrix.
2487 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2488 // Define last address of section.
2489 Asm->EmitInt8(0); EOL("Extended Op");
2490 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2491 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2492 EmitReference(getDWLabel("section_end", SectionEnd));
2493 EOL("Section end label");
2495 // Mark end of matrix.
2496 Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2501 /// emitDebugLines - Emit source line information.
2503 void DwarfDebug::emitDebugLines() {
2504 // If the target is using .loc/.file, the assembler will be emitting the
2505 // .debug_line table automatically.
2506 if (MAI->hasDotLocAndDotFile())
2509 // Minimum line delta, thus ranging from -10..(255-10).
2510 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2511 // Maximum line delta, thus ranging from -10..(255-10).
2512 const int MaxLineDelta = 255 + MinLineDelta;
2514 // Start the dwarf line section.
2515 Asm->OutStreamer.SwitchSection(
2516 Asm->getObjFileLowering().getDwarfLineSection());
2518 // Construct the section header.
2519 EmitDifference(getTempLabel("line_end"), getTempLabel("line_begin"), true);
2520 EOL("Length of Source Line Info");
2521 Asm->OutStreamer.EmitLabel(getTempLabel("line_begin"));
2523 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2525 EmitDifference(getTempLabel("line_prolog_end"),
2526 getTempLabel("line_prolog_begin"), true);
2527 EOL("Prolog Length");
2528 Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_begin"));
2530 Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2531 Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2532 Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2533 Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2534 Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2536 // Line number standard opcode encodings argument count
2537 Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2538 Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2539 Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2540 Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2541 Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2542 Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2543 Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2544 Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2545 Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2547 // Emit directories.
2548 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2549 const std::string &Dir = getSourceDirectoryName(DI);
2550 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2551 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2554 Asm->EmitInt8(0); EOL("End of directories");
2557 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2558 // Remember source id starts at 1.
2559 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2560 const std::string &FN = getSourceFileName(Id.second);
2561 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2562 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2564 EmitULEB128(Id.first, "Directory #");
2565 EmitULEB128(0, "Mod date");
2566 EmitULEB128(0, "File size");
2569 Asm->EmitInt8(0); EOL("End of files");
2571 Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_end"));
2573 // A sequence for each text section.
2574 unsigned SecSrcLinesSize = SectionSourceLines.size();
2576 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2577 // Isolate current sections line info.
2578 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2580 /*if (Asm->isVerbose()) {
2581 const MCSection *S = SectionMap[j + 1];
2582 O << '\t' << MAI->getCommentString() << " Section"
2583 << S->getName() << '\n';
2587 // Dwarf assumes we start with first line of first source file.
2588 unsigned Source = 1;
2591 // Construct rows of the address, source, line, column matrix.
2592 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2593 const SrcLineInfo &LineInfo = LineInfos[i];
2594 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2595 if (!LabelID) continue;
2597 if (LineInfo.getLine() == 0) continue;
2599 if (!Asm->isVerbose())
2602 std::pair<unsigned, unsigned> SourceID =
2603 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2604 O << '\t' << MAI->getCommentString() << ' '
2605 << getSourceDirectoryName(SourceID.first) << '/'
2606 << getSourceFileName(SourceID.second)
2607 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2610 // Define the line address.
2611 Asm->EmitInt8(0); EOL("Extended Op");
2612 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2613 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2614 EmitReference(getDWLabel("label", LabelID)); EOL("Location label");
2616 // If change of source, then switch to the new source.
2617 if (Source != LineInfo.getSourceID()) {
2618 Source = LineInfo.getSourceID();
2619 Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2620 EmitULEB128(Source, "New Source");
2623 // If change of line.
2624 if (Line != LineInfo.getLine()) {
2625 // Determine offset.
2626 int Offset = LineInfo.getLine() - Line;
2627 int Delta = Offset - MinLineDelta;
2630 Line = LineInfo.getLine();
2632 // If delta is small enough and in range...
2633 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2634 // ... then use fast opcode.
2635 Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2637 // ... otherwise use long hand.
2638 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2639 EOL("DW_LNS_advance_line");
2640 EmitSLEB128(Offset, "Line Offset");
2641 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2644 // Copy the previous row (different address or source)
2645 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2649 emitEndOfLineMatrix(j + 1);
2652 if (SecSrcLinesSize == 0)
2653 // Because we're emitting a debug_line section, we still need a line
2654 // table. The linker and friends expect it to exist. If there's nothing to
2655 // put into it, emit an empty table.
2656 emitEndOfLineMatrix(1);
2658 Asm->OutStreamer.EmitLabel(getTempLabel("line_end"));
2661 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2663 void DwarfDebug::emitCommonDebugFrame() {
2664 if (!MAI->doesDwarfRequireFrameSection())
2668 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2669 TargetFrameInfo::StackGrowsUp ?
2670 TD->getPointerSize() : -TD->getPointerSize();
2672 // Start the dwarf frame section.
2673 Asm->OutStreamer.SwitchSection(
2674 Asm->getObjFileLowering().getDwarfFrameSection());
2676 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common"));
2677 EmitDifference(getTempLabel("debug_frame_common_end"),
2678 getTempLabel("debug_frame_common_begin"), true);
2679 EOL("Length of Common Information Entry");
2681 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_begin"));
2682 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2683 EOL("CIE Identifier Tag");
2684 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2686 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2687 EOL("CIE Augmentation");
2688 EmitULEB128(1, "CIE Code Alignment Factor");
2689 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2690 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2691 EOL("CIE RA Column");
2693 std::vector<MachineMove> Moves;
2694 RI->getInitialFrameState(Moves);
2696 EmitFrameMoves(NULL, 0, Moves, false);
2698 Asm->EmitAlignment(2, 0, 0, false);
2699 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_end"));
2702 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2705 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2706 if (!MAI->doesDwarfRequireFrameSection())
2709 // Start the dwarf frame section.
2710 Asm->OutStreamer.SwitchSection(
2711 Asm->getObjFileLowering().getDwarfFrameSection());
2713 EmitDifference(getDWLabel("debug_frame_end", DebugFrameInfo.Number),
2714 getDWLabel("debug_frame_begin", DebugFrameInfo.Number), true);
2715 EOL("Length of Frame Information Entry");
2717 Asm->OutStreamer.EmitLabel(getDWLabel("debug_frame_begin",
2718 DebugFrameInfo.Number));
2720 EmitSectionOffset(getTempLabel("debug_frame_common"),
2721 getTempLabel("section_debug_frame"), true, false);
2722 EOL("FDE CIE offset");
2724 EmitReference(getDWLabel("func_begin", DebugFrameInfo.Number));
2725 EOL("FDE initial location");
2726 EmitDifference(getDWLabel("func_end", DebugFrameInfo.Number),
2727 getDWLabel("func_begin", DebugFrameInfo.Number));
2728 EOL("FDE address range");
2730 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2733 Asm->EmitAlignment(2, 0, 0, false);
2734 Asm->OutStreamer.EmitLabel(getDWLabel("debug_frame_end",
2735 DebugFrameInfo.Number));
2738 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2740 void DwarfDebug::emitDebugPubNames() {
2741 // Start the dwarf pubnames section.
2742 Asm->OutStreamer.SwitchSection(
2743 Asm->getObjFileLowering().getDwarfPubNamesSection());
2745 EmitDifference(getDWLabel("pubnames_end", ModuleCU->getID()),
2746 getDWLabel("pubnames_begin", ModuleCU->getID()), true);
2747 EOL("Length of Public Names Info");
2749 Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_begin", ModuleCU->getID()));
2751 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2753 EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2754 getTempLabel("section_info"),
2756 EOL("Offset of Compilation Unit Info");
2758 EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2759 getDWLabel("info_begin", ModuleCU->getID()),
2761 EOL("Compilation Unit Length");
2763 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2764 for (StringMap<DIE*>::const_iterator
2765 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2766 const char *Name = GI->getKeyData();
2767 DIE * Entity = GI->second;
2769 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2771 if (Asm->VerboseAsm)
2772 Asm->OutStreamer.AddComment("External Name");
2773 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2776 Asm->EmitInt32(0); EOL("End Mark");
2777 Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_end", ModuleCU->getID()));
2780 void DwarfDebug::emitDebugPubTypes() {
2781 // Start the dwarf pubnames section.
2782 Asm->OutStreamer.SwitchSection(
2783 Asm->getObjFileLowering().getDwarfPubTypesSection());
2784 EmitDifference(getDWLabel("pubtypes_end", ModuleCU->getID()),
2785 getDWLabel("pubtypes_begin", ModuleCU->getID()), true);
2786 EOL("Length of Public Types Info");
2788 Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_begin", ModuleCU->getID()));
2790 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2791 Asm->EmitInt16(dwarf::DWARF_VERSION);
2793 EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2794 getTempLabel("section_info"), true, false);
2795 EOL("Offset of Compilation ModuleCU Info");
2797 EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2798 getDWLabel("info_begin", ModuleCU->getID()),
2800 EOL("Compilation ModuleCU Length");
2802 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2803 for (StringMap<DIE*>::const_iterator
2804 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2805 const char *Name = GI->getKeyData();
2806 DIE * Entity = GI->second;
2808 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2809 Asm->EmitInt32(Entity->getOffset());
2811 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2812 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2815 Asm->EmitInt32(0); EOL("End Mark");
2816 Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_end", ModuleCU->getID()));
2819 /// emitDebugStr - Emit visible names into a debug str section.
2821 void DwarfDebug::emitDebugStr() {
2822 // Check to see if it is worth the effort.
2823 if (!StringPool.empty()) {
2824 // Start the dwarf str section.
2825 Asm->OutStreamer.SwitchSection(
2826 Asm->getObjFileLowering().getDwarfStrSection());
2828 // For each of strings in the string pool.
2829 for (unsigned StringID = 1, N = StringPool.size();
2830 StringID <= N; ++StringID) {
2831 // Emit a label for reference from debug information entries.
2832 Asm->OutStreamer.EmitLabel(getDWLabel("string", StringID));
2834 // Emit the string itself.
2835 const std::string &String = StringPool[StringID];
2836 Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2843 /// emitDebugLoc - Emit visible names into a debug loc section.
2845 void DwarfDebug::emitDebugLoc() {
2846 // Start the dwarf loc section.
2847 Asm->OutStreamer.SwitchSection(
2848 Asm->getObjFileLowering().getDwarfLocSection());
2851 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2853 void DwarfDebug::EmitDebugARanges() {
2854 // Start the dwarf aranges section.
2855 Asm->OutStreamer.SwitchSection(
2856 Asm->getObjFileLowering().getDwarfARangesSection());
2860 CompileUnit *Unit = GetBaseCompileUnit();
2862 // Don't include size of length
2863 Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2865 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2867 EmitReference("info_begin", Unit->getID());
2868 EOL("Offset of Compilation Unit Info");
2870 Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2872 Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2874 Asm->EmitInt16(0); EOL("Pad (1)");
2875 Asm->EmitInt16(0); EOL("Pad (2)");
2878 EmitReference("text_begin", 0); EOL("Address");
2879 EmitDifference(getTempLabel("text_end"), getTempLabel("text_begin"),
2880 true); EOL("Length");
2882 Asm->EmitInt32(0); EOL("EOM (1)");
2883 Asm->EmitInt32(0); EOL("EOM (2)");
2887 /// emitDebugRanges - Emit visible names into a debug ranges section.
2889 void DwarfDebug::emitDebugRanges() {
2890 // Start the dwarf ranges section.
2891 Asm->OutStreamer.SwitchSection(
2892 Asm->getObjFileLowering().getDwarfRangesSection());
2895 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2897 void DwarfDebug::emitDebugMacInfo() {
2898 if (const MCSection *LineInfo =
2899 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2900 // Start the dwarf macinfo section.
2901 Asm->OutStreamer.SwitchSection(LineInfo);
2905 /// emitDebugInlineInfo - Emit inline info using following format.
2907 /// 1. length of section
2908 /// 2. Dwarf version number
2909 /// 3. address size.
2911 /// Entries (one "entry" for each function that was inlined):
2913 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2914 /// otherwise offset into __debug_str for regular function name.
2915 /// 2. offset into __debug_str section for regular function name.
2916 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2917 /// instances for the function.
2919 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2920 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2921 /// __debug_info section, and the low_pc is the starting address for the
2922 /// inlining instance.
2923 void DwarfDebug::emitDebugInlineInfo() {
2924 if (!MAI->doesDwarfUsesInlineInfoSection())
2930 Asm->OutStreamer.SwitchSection(
2931 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2933 EmitDifference(getDWLabel("debug_inlined_end", 1),
2934 getDWLabel("debug_inlined_begin", 1), true);
2935 EOL("Length of Debug Inlined Information Entry");
2937 Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_begin", 1));
2939 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2940 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2942 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2943 E = InlinedSPNodes.end(); I != E; ++I) {
2946 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2947 = InlineInfo.find(Node);
2948 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2949 DISubprogram SP(Node);
2950 StringRef LName = SP.getLinkageName();
2951 StringRef Name = SP.getName();
2953 if (LName.empty()) {
2954 Asm->OutStreamer.EmitBytes(Name, 0);
2955 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2957 EmitSectionOffset(getDWLabel("string",
2958 StringPool.idFor(getRealLinkageName(LName))),
2959 getTempLabel("section_str"), true);
2961 EOL("MIPS linkage name");
2962 EmitSectionOffset(getDWLabel("string", StringPool.idFor(Name)),
2963 getTempLabel("section_str"), false, true);
2964 EOL("Function name");
2965 EmitULEB128(Labels.size(), "Inline count");
2967 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2968 LE = Labels.end(); LI != LE; ++LI) {
2969 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2970 Asm->EmitInt32(LI->second->getOffset());
2972 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("low_pc");
2973 Asm->OutStreamer.EmitValue(MCSymbolRefExpr::Create(LI->first,
2975 TD->getPointerSize(), 0/*AddrSpace*/);
2979 Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_end", 1));