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 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
16 #include "llvm/Module.h"
17 #include "llvm/CodeGen/MachineFunction.h"
18 #include "llvm/CodeGen/MachineModuleInfo.h"
19 #include "llvm/MC/MCAsmInfo.h"
20 #include "llvm/MC/MCSection.h"
21 #include "llvm/MC/MCStreamer.h"
22 #include "llvm/MC/MCSymbol.h"
23 #include "llvm/Target/Mangler.h"
24 #include "llvm/Target/TargetData.h"
25 #include "llvm/Target/TargetFrameInfo.h"
26 #include "llvm/Target/TargetLoweringObjectFile.h"
27 #include "llvm/Target/TargetRegisterInfo.h"
28 #include "llvm/ADT/STLExtras.h"
29 #include "llvm/ADT/StringExtras.h"
30 #include "llvm/Support/Debug.h"
31 #include "llvm/Support/ErrorHandling.h"
32 #include "llvm/Support/ValueHandle.h"
33 #include "llvm/Support/FormattedStream.h"
34 #include "llvm/Support/Timer.h"
35 #include "llvm/System/Path.h"
38 //===----------------------------------------------------------------------===//
40 /// Configuration values for initial hash set sizes (log2).
42 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
46 //===----------------------------------------------------------------------===//
47 /// CompileUnit - This dwarf writer support class manages information associate
48 /// with a source file.
50 /// ID - File identifier for source.
54 /// Die - Compile unit debug information entry.
56 const OwningPtr<DIE> CUDie;
58 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
61 /// GVToDieMap - Tracks the mapping of unit level debug informaton
62 /// variables to debug information entries.
63 /// FIXME : Rename GVToDieMap -> NodeToDieMap
64 DenseMap<MDNode *, DIE *> GVToDieMap;
66 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
67 /// descriptors to debug information entries using a DIEEntry proxy.
69 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
71 /// Globals - A map of globally visible named entities for this unit.
73 StringMap<DIE*> Globals;
75 /// GlobalTypes - A map of globally visible types for this unit.
77 StringMap<DIE*> GlobalTypes;
80 CompileUnit(unsigned I, DIE *D)
81 : ID(I), CUDie(D), IndexTyDie(0) {}
84 unsigned getID() const { return ID; }
85 DIE* getCUDie() const { return CUDie.get(); }
86 const StringMap<DIE*> &getGlobals() const { return Globals; }
87 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
89 /// hasContent - Return true if this compile unit has something to write out.
91 bool hasContent() const { return !CUDie->getChildren().empty(); }
93 /// addGlobal - Add a new global entity to the compile unit.
95 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
97 /// addGlobalType - Add a new global type to the compile unit.
99 void addGlobalType(StringRef Name, DIE *Die) {
100 GlobalTypes[Name] = Die;
103 /// getDIE - Returns the debug information entry map slot for the
104 /// specified debug variable.
105 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
107 /// insertDIE - Insert DIE into the map.
108 void insertDIE(MDNode *N, DIE *D) {
109 GVToDieMap.insert(std::make_pair(N, D));
112 /// getDIEEntry - Returns the debug information entry for the speciefied
114 DIEEntry *getDIEEntry(MDNode *N) {
115 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
116 if (I == GVToDIEEntryMap.end())
121 /// insertDIEEntry - Insert debug information entry into the map.
122 void insertDIEEntry(MDNode *N, DIEEntry *E) {
123 GVToDIEEntryMap.insert(std::make_pair(N, E));
126 /// addDie - Adds or interns the DIE to the compile unit.
128 void addDie(DIE *Buffer) {
129 this->CUDie->addChild(Buffer);
132 // getIndexTyDie - Get an anonymous type for index type.
133 DIE *getIndexTyDie() {
137 // setIndexTyDie - Set D as anonymous type for index which can be reused
139 void setIndexTyDie(DIE *D) {
145 //===----------------------------------------------------------------------===//
146 /// DbgVariable - This class is used to track local variable information.
149 DIVariable Var; // Variable Descriptor.
150 unsigned FrameIndex; // Variable frame index.
151 const MachineInstr *DbgValueMInsn; // DBG_VALUE
152 // DbgValueLabel - DBG_VALUE is effective from this label.
153 MCSymbol *DbgValueLabel;
154 DbgVariable *const AbstractVar; // Abstract variable for this variable.
157 // AbsVar may be NULL.
158 DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar)
159 : Var(V), FrameIndex(I), DbgValueMInsn(0),
160 DbgValueLabel(0), AbstractVar(AbsVar), TheDIE(0) {}
161 DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar)
162 : Var(V), FrameIndex(0), DbgValueMInsn(MI), DbgValueLabel(0),
163 AbstractVar(AbsVar), TheDIE(0)
167 DIVariable getVariable() const { return Var; }
168 unsigned getFrameIndex() const { return FrameIndex; }
169 const MachineInstr *getDbgValue() const { return DbgValueMInsn; }
170 MCSymbol *getDbgValueLabel() const { return DbgValueLabel; }
171 void setDbgValueLabel(MCSymbol *L) { DbgValueLabel = L; }
172 DbgVariable *getAbstractVariable() const { return AbstractVar; }
173 void setDIE(DIE *D) { TheDIE = D; }
174 DIE *getDIE() const { return TheDIE; }
177 //===----------------------------------------------------------------------===//
178 /// DbgScope - This class is used to track scope information.
181 DbgScope *Parent; // Parent to this scope.
182 DIDescriptor Desc; // Debug info descriptor for scope.
183 // Location at which this scope is inlined.
184 AssertingVH<MDNode> InlinedAtLocation;
185 bool AbstractScope; // Abstract Scope
186 MCSymbol *StartLabel; // Label ID of the beginning of scope.
187 MCSymbol *EndLabel; // Label ID of the end of scope.
188 const MachineInstr *LastInsn; // Last instruction of this scope.
189 const MachineInstr *FirstInsn; // First instruction of this scope.
190 // Scopes defined in scope. Contents not owned.
191 SmallVector<DbgScope *, 4> Scopes;
192 // Variables declared in scope. Contents owned.
193 SmallVector<DbgVariable *, 8> Variables;
195 // Private state for dump()
196 mutable unsigned IndentLevel;
198 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
199 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
200 StartLabel(0), EndLabel(0),
201 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
205 DbgScope *getParent() const { return Parent; }
206 void setParent(DbgScope *P) { Parent = P; }
207 DIDescriptor getDesc() const { return Desc; }
208 MDNode *getInlinedAt() const { return InlinedAtLocation; }
209 MDNode *getScopeNode() const { return Desc.getNode(); }
210 MCSymbol *getStartLabel() const { return StartLabel; }
211 MCSymbol *getEndLabel() const { return EndLabel; }
212 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
213 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
214 void setStartLabel(MCSymbol *S) { StartLabel = S; }
215 void setEndLabel(MCSymbol *E) { EndLabel = E; }
216 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
217 const MachineInstr *getLastInsn() { return LastInsn; }
218 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
219 void setAbstractScope() { AbstractScope = true; }
220 bool isAbstractScope() const { return AbstractScope; }
221 const MachineInstr *getFirstInsn() { return FirstInsn; }
223 /// addScope - Add a scope to the scope.
225 void addScope(DbgScope *S) { Scopes.push_back(S); }
227 /// addVariable - Add a variable to the scope.
229 void addVariable(DbgVariable *V) { Variables.push_back(V); }
231 void fixInstructionMarkers(DenseMap<const MachineInstr *,
232 unsigned> &MIIndexMap) {
233 assert(getFirstInsn() && "First instruction is missing!");
235 // Use the end of last child scope as end of this scope.
236 const SmallVector<DbgScope *, 4> &Scopes = getScopes();
237 const MachineInstr *LastInsn = getFirstInsn();
239 if (Scopes.empty()) {
240 assert(getLastInsn() && "Inner most scope does not have last insn!");
243 for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(),
244 SE = Scopes.end(); SI != SE; ++SI) {
246 DS->fixInstructionMarkers(MIIndexMap);
247 const MachineInstr *DSLastInsn = DS->getLastInsn();
248 unsigned DSI = MIIndexMap[DSLastInsn];
250 LastInsn = DSLastInsn;
255 unsigned CurrentLastInsnIndex = 0;
256 if (const MachineInstr *CL = getLastInsn())
257 CurrentLastInsnIndex = MIIndexMap[CL];
258 unsigned FIndex = MIIndexMap[getFirstInsn()];
260 // Set LastInsn as the last instruction for this scope only if
262 // 1) this scope's first instruction and
263 // 2) current last instruction for this scope, if any.
264 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
265 setLastInsn(LastInsn);
274 void DbgScope::dump() const {
275 raw_ostream &err = dbgs();
276 err.indent(IndentLevel);
277 MDNode *N = Desc.getNode();
279 err << " [" << StartLabel << ", " << EndLabel << "]\n";
281 err << "Abstract Scope\n";
285 err << "Children ...\n";
286 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
287 if (Scopes[i] != this)
294 DbgScope::~DbgScope() {
295 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
299 } // end llvm namespace
301 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
302 : DwarfPrinter(OS, A, T), ModuleCU(0),
303 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
304 DIEBlocks(), SectionSourceLines(), didInitial(false), shouldEmit(false),
305 CurrentFnDbgScope(0), PrevDILoc(0), DebugTimer(0) {
306 NextStringPoolNumber = 0;
307 if (TimePassesIsEnabled)
308 DebugTimer = new Timer("Dwarf Debug Writer");
310 DwarfDebug::~DwarfDebug() {
311 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
312 DIEBlocks[j]->~DIEBlock();
317 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
318 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
319 if (Entry.first) return Entry.first;
321 Entry.second = NextStringPoolNumber++;
322 return Entry.first = getDWLabel("string", Entry.second);
326 /// assignAbbrevNumber - Define a unique number for the abbreviation.
328 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
329 // Profile the node so that we can make it unique.
333 // Check the set for priors.
334 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
336 // If it's newly added.
337 if (InSet == &Abbrev) {
338 // Add to abbreviation list.
339 Abbreviations.push_back(&Abbrev);
341 // Assign the vector position + 1 as its number.
342 Abbrev.setNumber(Abbreviations.size());
344 // Assign existing abbreviation number.
345 Abbrev.setNumber(InSet->getNumber());
349 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
350 /// information entry.
351 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
352 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
356 /// addUInt - Add an unsigned integer attribute data and value.
358 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
359 unsigned Form, uint64_t Integer) {
360 if (!Form) Form = DIEInteger::BestForm(false, Integer);
361 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
362 Die->addValue(Attribute, Form, Value);
365 /// addSInt - Add an signed integer attribute data and value.
367 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
368 unsigned Form, int64_t Integer) {
369 if (!Form) Form = DIEInteger::BestForm(true, Integer);
370 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
371 Die->addValue(Attribute, Form, Value);
374 /// addString - Add a string attribute data and value. DIEString only
375 /// keeps string reference.
376 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
378 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
379 Die->addValue(Attribute, Form, Value);
382 /// addLabel - Add a Dwarf label attribute data and value.
384 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
385 const MCSymbol *Label) {
386 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
387 Die->addValue(Attribute, Form, Value);
390 /// addDelta - Add a label delta attribute data and value.
392 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
393 const MCSymbol *Hi, const MCSymbol *Lo) {
394 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
395 Die->addValue(Attribute, Form, Value);
398 /// addBlock - Add block data.
400 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
402 Block->ComputeSize(TD);
403 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
404 Die->addValue(Attribute, Block->BestForm(), Block);
407 /// addSourceLine - Add location information to specified debug information
409 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
410 // If there is no compile unit specified, don't add a line #.
411 if (!V->getCompileUnit().Verify())
414 unsigned Line = V->getLineNumber();
415 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
416 V->getContext().getFilename());
417 assert(FileID && "Invalid file id");
418 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
419 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
422 /// addSourceLine - Add location information to specified debug information
424 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
425 // If there is no compile unit specified, don't add a line #.
426 if (!G->getCompileUnit().Verify())
429 unsigned Line = G->getLineNumber();
430 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
431 G->getContext().getFilename());
432 assert(FileID && "Invalid file id");
433 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
434 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
437 /// addSourceLine - Add location information to specified debug information
439 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
440 // If there is no compile unit specified, don't add a line #.
441 if (!SP->getCompileUnit().Verify())
443 // If the line number is 0, don't add it.
444 if (SP->getLineNumber() == 0)
447 unsigned Line = SP->getLineNumber();
448 if (!SP->getContext().Verify())
450 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
452 assert(FileID && "Invalid file id");
453 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
454 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
457 /// addSourceLine - Add location information to specified debug information
459 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
460 // If there is no compile unit specified, don't add a line #.
461 DICompileUnit CU = Ty->getCompileUnit();
465 unsigned Line = Ty->getLineNumber();
466 if (!Ty->getContext().Verify())
468 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
469 Ty->getContext().getFilename());
470 assert(FileID && "Invalid file id");
471 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
472 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
475 /// addSourceLine - Add location information to specified debug information
477 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
478 // If there is no compile unit specified, don't add a line #.
479 if (!NS->getCompileUnit().Verify())
482 unsigned Line = NS->getLineNumber();
483 StringRef FN = NS->getFilename();
484 StringRef Dir = NS->getDirectory();
486 unsigned FileID = GetOrCreateSourceID(Dir, FN);
487 assert(FileID && "Invalid file id");
488 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
489 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
492 /* Byref variables, in Blocks, are declared by the programmer as
493 "SomeType VarName;", but the compiler creates a
494 __Block_byref_x_VarName struct, and gives the variable VarName
495 either the struct, or a pointer to the struct, as its type. This
496 is necessary for various behind-the-scenes things the compiler
497 needs to do with by-reference variables in blocks.
499 However, as far as the original *programmer* is concerned, the
500 variable should still have type 'SomeType', as originally declared.
502 The following function dives into the __Block_byref_x_VarName
503 struct to find the original type of the variable. This will be
504 passed back to the code generating the type for the Debug
505 Information Entry for the variable 'VarName'. 'VarName' will then
506 have the original type 'SomeType' in its debug information.
508 The original type 'SomeType' will be the type of the field named
509 'VarName' inside the __Block_byref_x_VarName struct.
511 NOTE: In order for this to not completely fail on the debugger
512 side, the Debug Information Entry for the variable VarName needs to
513 have a DW_AT_location that tells the debugger how to unwind through
514 the pointers and __Block_byref_x_VarName struct to find the actual
515 value of the variable. The function addBlockByrefType does this. */
517 /// Find the type the programmer originally declared the variable to be
518 /// and return that type.
520 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
523 unsigned tag = Ty.getTag();
525 if (tag == dwarf::DW_TAG_pointer_type) {
526 DIDerivedType DTy = DIDerivedType(Ty.getNode());
527 subType = DTy.getTypeDerivedFrom();
530 DICompositeType blockStruct = DICompositeType(subType.getNode());
531 DIArray Elements = blockStruct.getTypeArray();
533 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
534 DIDescriptor Element = Elements.getElement(i);
535 DIDerivedType DT = DIDerivedType(Element.getNode());
536 if (Name == DT.getName())
537 return (DT.getTypeDerivedFrom());
543 /// addComplexAddress - Start with the address based on the location provided,
544 /// and generate the DWARF information necessary to find the actual variable
545 /// given the extra address information encoded in the DIVariable, starting from
546 /// the starting location. Add the DWARF information to the die.
548 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
550 const MachineLocation &Location) {
551 const DIVariable &VD = DV->getVariable();
552 DIType Ty = VD.getType();
554 // Decode the original location, and use that as the start of the byref
555 // variable's location.
556 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
557 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
559 if (Location.isReg()) {
561 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
563 Reg = Reg - dwarf::DW_OP_reg0;
564 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
565 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
569 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
571 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
572 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
575 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
578 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
579 uint64_t Element = VD.getAddrElement(i);
581 if (Element == DIFactory::OpPlus) {
582 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
583 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
584 } else if (Element == DIFactory::OpDeref) {
585 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
586 } else llvm_unreachable("unknown DIFactory Opcode");
589 // Now attach the location information to the DIE.
590 addBlock(Die, Attribute, 0, Block);
593 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
594 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
595 gives the variable VarName either the struct, or a pointer to the struct, as
596 its type. This is necessary for various behind-the-scenes things the
597 compiler needs to do with by-reference variables in Blocks.
599 However, as far as the original *programmer* is concerned, the variable
600 should still have type 'SomeType', as originally declared.
602 The function getBlockByrefType dives into the __Block_byref_x_VarName
603 struct to find the original type of the variable, which is then assigned to
604 the variable's Debug Information Entry as its real type. So far, so good.
605 However now the debugger will expect the variable VarName to have the type
606 SomeType. So we need the location attribute for the variable to be an
607 expression that explains to the debugger how to navigate through the
608 pointers and struct to find the actual variable of type SomeType.
610 The following function does just that. We start by getting
611 the "normal" location for the variable. This will be the location
612 of either the struct __Block_byref_x_VarName or the pointer to the
613 struct __Block_byref_x_VarName.
615 The struct will look something like:
617 struct __Block_byref_x_VarName {
619 struct __Block_byref_x_VarName *forwarding;
620 ... <various other fields>
622 ... <maybe more fields>
625 If we are given the struct directly (as our starting point) we
626 need to tell the debugger to:
628 1). Add the offset of the forwarding field.
630 2). Follow that pointer to get the real __Block_byref_x_VarName
631 struct to use (the real one may have been copied onto the heap).
633 3). Add the offset for the field VarName, to find the actual variable.
635 If we started with a pointer to the struct, then we need to
636 dereference that pointer first, before the other steps.
637 Translating this into DWARF ops, we will need to append the following
638 to the current location description for the variable:
640 DW_OP_deref -- optional, if we start with a pointer
641 DW_OP_plus_uconst <forward_fld_offset>
643 DW_OP_plus_uconst <varName_fld_offset>
645 That is what this function does. */
647 /// addBlockByrefAddress - Start with the address based on the location
648 /// provided, and generate the DWARF information necessary to find the
649 /// actual Block variable (navigating the Block struct) based on the
650 /// starting location. Add the DWARF information to the die. For
651 /// more information, read large comment just above here.
653 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
655 const MachineLocation &Location) {
656 const DIVariable &VD = DV->getVariable();
657 DIType Ty = VD.getType();
659 unsigned Tag = Ty.getTag();
660 bool isPointer = false;
662 StringRef varName = VD.getName();
664 if (Tag == dwarf::DW_TAG_pointer_type) {
665 DIDerivedType DTy = DIDerivedType(Ty.getNode());
666 TmpTy = DTy.getTypeDerivedFrom();
670 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
672 // Find the __forwarding field and the variable field in the __Block_byref
674 DIArray Fields = blockStruct.getTypeArray();
675 DIDescriptor varField = DIDescriptor();
676 DIDescriptor forwardingField = DIDescriptor();
678 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
679 DIDescriptor Element = Fields.getElement(i);
680 DIDerivedType DT = DIDerivedType(Element.getNode());
681 StringRef fieldName = DT.getName();
682 if (fieldName == "__forwarding")
683 forwardingField = Element;
684 else if (fieldName == varName)
688 // Get the offsets for the forwarding field and the variable field.
689 unsigned forwardingFieldOffset =
690 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
691 unsigned varFieldOffset =
692 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
694 // Decode the original location, and use that as the start of the byref
695 // variable's location.
696 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
697 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
699 if (Location.isReg()) {
701 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
703 Reg = Reg - dwarf::DW_OP_reg0;
704 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
705 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
709 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
711 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
712 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
715 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
718 // If we started with a pointer to the __Block_byref... struct, then
719 // the first thing we need to do is dereference the pointer (DW_OP_deref).
721 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
723 // Next add the offset for the '__forwarding' field:
724 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
725 // adding the offset if it's 0.
726 if (forwardingFieldOffset > 0) {
727 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
728 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
731 // Now dereference the __forwarding field to get to the real __Block_byref
732 // struct: DW_OP_deref.
733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
735 // Now that we've got the real __Block_byref... struct, add the offset
736 // for the variable's field to get to the location of the actual variable:
737 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
738 if (varFieldOffset > 0) {
739 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
740 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
743 // Now attach the location information to the DIE.
744 addBlock(Die, Attribute, 0, Block);
747 /// addAddress - Add an address attribute to a die based on the location
749 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
750 const MachineLocation &Location) {
751 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
752 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
754 if (Location.isReg()) {
756 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
758 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
759 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
763 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
765 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
766 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
769 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
772 addBlock(Die, Attribute, 0, Block);
775 /// addToContextOwner - Add Die into the list of its context owner's children.
776 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
777 if (Context.isType()) {
778 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
779 ContextDIE->addChild(Die);
780 } else if (Context.isNameSpace()) {
781 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
782 ContextDIE->addChild(Die);
783 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
784 ContextDIE->addChild(Die);
786 ModuleCU->addDie(Die);
789 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
791 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
792 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
797 TyDIE = new DIE(dwarf::DW_TAG_base_type);
798 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
799 if (Ty.isBasicType())
800 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
801 else if (Ty.isCompositeType())
802 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
804 assert(Ty.isDerivedType() && "Unknown kind of DIType");
805 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
808 addToContextOwner(TyDIE, Ty.getContext());
812 /// addType - Add a new type attribute to the specified entity.
813 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
817 // Check for pre-existence.
818 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
819 // If it exists then use the existing value.
821 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
826 DIE *Buffer = getOrCreateTypeDIE(Ty);
829 Entry = createDIEEntry(Buffer);
830 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
832 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
835 /// constructTypeDIE - Construct basic type die from DIBasicType.
836 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
837 // Get core information.
838 StringRef Name = BTy.getName();
839 Buffer.setTag(dwarf::DW_TAG_base_type);
840 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
843 // Add name if not anonymous or intermediate type.
845 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
846 uint64_t Size = BTy.getSizeInBits() >> 3;
847 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
850 /// constructTypeDIE - Construct derived type die from DIDerivedType.
851 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
852 // Get core information.
853 StringRef Name = DTy.getName();
854 uint64_t Size = DTy.getSizeInBits() >> 3;
855 unsigned Tag = DTy.getTag();
857 // FIXME - Workaround for templates.
858 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
862 // Map to main type, void will not have a type.
863 DIType FromTy = DTy.getTypeDerivedFrom();
864 addType(&Buffer, FromTy);
866 // Add name if not anonymous or intermediate type.
868 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
870 // Add size if non-zero (derived types might be zero-sized.)
872 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
874 // Add source line info if available and TyDesc is not a forward declaration.
875 if (!DTy.isForwardDecl())
876 addSourceLine(&Buffer, &DTy);
879 /// constructTypeDIE - Construct type DIE from DICompositeType.
880 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
881 // Get core information.
882 StringRef Name = CTy.getName();
884 uint64_t Size = CTy.getSizeInBits() >> 3;
885 unsigned Tag = CTy.getTag();
889 case dwarf::DW_TAG_vector_type:
890 case dwarf::DW_TAG_array_type:
891 constructArrayTypeDIE(Buffer, &CTy);
893 case dwarf::DW_TAG_enumeration_type: {
894 DIArray Elements = CTy.getTypeArray();
896 // Add enumerators to enumeration type.
897 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
899 DIDescriptor Enum(Elements.getElement(i).getNode());
900 if (Enum.isEnumerator()) {
901 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
902 Buffer.addChild(ElemDie);
907 case dwarf::DW_TAG_subroutine_type: {
909 DIArray Elements = CTy.getTypeArray();
910 DIDescriptor RTy = Elements.getElement(0);
911 addType(&Buffer, DIType(RTy.getNode()));
913 // Add prototype flag.
914 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
917 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
918 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
919 DIDescriptor Ty = Elements.getElement(i);
920 addType(Arg, DIType(Ty.getNode()));
921 Buffer.addChild(Arg);
925 case dwarf::DW_TAG_structure_type:
926 case dwarf::DW_TAG_union_type:
927 case dwarf::DW_TAG_class_type: {
928 // Add elements to structure type.
929 DIArray Elements = CTy.getTypeArray();
931 // A forward struct declared type may not have elements available.
932 unsigned N = Elements.getNumElements();
936 // Add elements to structure type.
937 for (unsigned i = 0; i < N; ++i) {
938 DIDescriptor Element = Elements.getElement(i);
940 if (Element.isSubprogram())
941 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
942 else if (Element.isVariable()) {
943 DIVariable DV(Element.getNode());
944 ElemDie = new DIE(dwarf::DW_TAG_variable);
945 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
947 addType(ElemDie, DV.getType());
948 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
949 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
950 addSourceLine(ElemDie, &DV);
951 } else if (Element.isDerivedType())
952 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
955 Buffer.addChild(ElemDie);
958 if (CTy.isAppleBlockExtension())
959 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
961 unsigned RLang = CTy.getRunTimeLang();
963 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
964 dwarf::DW_FORM_data1, RLang);
966 DICompositeType ContainingType = CTy.getContainingType();
967 if (DIDescriptor(ContainingType.getNode()).isCompositeType())
968 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
969 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
976 // Add name if not anonymous or intermediate type.
978 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
980 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
981 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
982 // Add size if non-zero (derived types might be zero-sized.)
984 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
986 // Add zero size if it is not a forward declaration.
987 if (CTy.isForwardDecl())
988 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
990 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
993 // Add source line info if available.
994 if (!CTy.isForwardDecl())
995 addSourceLine(&Buffer, &CTy);
999 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1000 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1001 int64_t L = SR.getLo();
1002 int64_t H = SR.getHi();
1003 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1005 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1007 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1008 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1010 Buffer.addChild(DW_Subrange);
1013 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1014 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1015 DICompositeType *CTy) {
1016 Buffer.setTag(dwarf::DW_TAG_array_type);
1017 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1018 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1020 // Emit derived type.
1021 addType(&Buffer, CTy->getTypeDerivedFrom());
1022 DIArray Elements = CTy->getTypeArray();
1024 // Get an anonymous type for index type.
1025 DIE *IdxTy = ModuleCU->getIndexTyDie();
1027 // Construct an anonymous type for index type.
1028 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1029 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1030 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1031 dwarf::DW_ATE_signed);
1032 ModuleCU->addDie(IdxTy);
1033 ModuleCU->setIndexTyDie(IdxTy);
1036 // Add subranges to array type.
1037 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1038 DIDescriptor Element = Elements.getElement(i);
1039 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1040 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1044 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1045 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1046 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1047 StringRef Name = ETy.getName();
1048 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1049 int64_t Value = ETy.getEnumValue();
1050 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1054 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1055 /// printer to not emit usual symbol prefix before the symbol name is used then
1056 /// return linkage name after skipping this special LLVM prefix.
1057 static StringRef getRealLinkageName(StringRef LinkageName) {
1059 if (LinkageName.startswith(StringRef(&One, 1)))
1060 return LinkageName.substr(1);
1064 /// createGlobalVariableDIE - Create new DIE using GV.
1065 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1066 // If the global variable was optmized out then no need to create debug info
1068 if (!GV.getGlobal()) return NULL;
1069 if (GV.getDisplayName().empty()) return NULL;
1071 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1072 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1073 GV.getDisplayName());
1075 StringRef LinkageName = GV.getLinkageName();
1076 if (!LinkageName.empty())
1077 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1078 getRealLinkageName(LinkageName));
1080 addType(GVDie, GV.getType());
1081 if (!GV.isLocalToUnit())
1082 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1083 addSourceLine(GVDie, &GV);
1088 /// createMemberDIE - Create new member DIE.
1089 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1090 DIE *MemberDie = new DIE(DT.getTag());
1091 StringRef Name = DT.getName();
1093 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1095 addType(MemberDie, DT.getTypeDerivedFrom());
1097 addSourceLine(MemberDie, &DT);
1099 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1100 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1102 uint64_t Size = DT.getSizeInBits();
1103 uint64_t FieldSize = DT.getOriginalTypeSize();
1105 if (Size != FieldSize) {
1107 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1108 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1110 uint64_t Offset = DT.getOffsetInBits();
1111 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1112 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1113 uint64_t FieldOffset = (HiMark - FieldSize);
1114 Offset -= FieldOffset;
1116 // Maybe we need to work from the other end.
1117 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1118 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1120 // Here WD_AT_data_member_location points to the anonymous
1121 // field that includes this bit field.
1122 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1125 // This is not a bitfield.
1126 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1128 if (DT.getTag() == dwarf::DW_TAG_inheritance
1129 && DT.isVirtual()) {
1131 // For C++, virtual base classes are not at fixed offset. Use following
1132 // expression to extract appropriate offset from vtable.
1133 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1135 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1136 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1137 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1138 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1139 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1140 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1141 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1142 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1144 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1147 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1149 if (DT.isProtected())
1150 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1151 dwarf::DW_ACCESS_protected);
1152 else if (DT.isPrivate())
1153 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1154 dwarf::DW_ACCESS_private);
1155 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1156 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1157 dwarf::DW_ACCESS_public);
1159 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1160 dwarf::DW_VIRTUALITY_virtual);
1164 /// createSubprogramDIE - Create new DIE using SP.
1165 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1166 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1170 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1171 // Constructors and operators for anonymous aggregates do not have names.
1172 if (!SP.getName().empty())
1173 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1175 StringRef LinkageName = SP.getLinkageName();
1176 if (!LinkageName.empty())
1177 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1178 getRealLinkageName(LinkageName));
1180 addSourceLine(SPDie, &SP);
1182 // Add prototyped tag, if C or ObjC.
1183 unsigned Lang = SP.getCompileUnit().getLanguage();
1184 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1185 Lang == dwarf::DW_LANG_ObjC)
1186 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1189 DICompositeType SPTy = SP.getType();
1190 DIArray Args = SPTy.getTypeArray();
1191 unsigned SPTag = SPTy.getTag();
1193 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1194 addType(SPDie, SPTy);
1196 addType(SPDie, DIType(Args.getElement(0).getNode()));
1198 unsigned VK = SP.getVirtuality();
1200 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1201 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1202 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1203 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1204 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1205 ContainingTypeMap.insert(std::make_pair(SPDie,
1206 SP.getContainingType().getNode()));
1209 if (MakeDecl || !SP.isDefinition()) {
1210 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1212 // Add arguments. Do not add arguments for subprogram definition. They will
1213 // be handled while processing variables.
1214 DICompositeType SPTy = SP.getType();
1215 DIArray Args = SPTy.getTypeArray();
1216 unsigned SPTag = SPTy.getTag();
1218 if (SPTag == dwarf::DW_TAG_subroutine_type)
1219 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1220 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1221 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1223 if (ATy.isArtificial())
1224 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1225 SPDie->addChild(Arg);
1229 if (SP.isArtificial())
1230 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1232 // DW_TAG_inlined_subroutine may refer to this DIE.
1233 ModuleCU->insertDIE(SP.getNode(), SPDie);
1237 /// getUpdatedDbgScope - Find DbgScope assicated with the instruction.
1238 /// Update scope hierarchy. Create abstract scope if required.
1239 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1240 MDNode *InlinedAt) {
1241 assert(N && "Invalid Scope encoding!");
1242 assert(MI && "Missing machine instruction!");
1243 bool isAConcreteScope = InlinedAt != 0;
1245 DbgScope *NScope = NULL;
1248 NScope = DbgScopeMap.lookup(InlinedAt);
1250 NScope = DbgScopeMap.lookup(N);
1251 assert(NScope && "Unable to find working scope!");
1253 if (NScope->getFirstInsn())
1256 DbgScope *Parent = NULL;
1257 if (isAConcreteScope) {
1258 DILocation IL(InlinedAt);
1259 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1260 IL.getOrigLocation().getNode());
1261 assert(Parent && "Unable to find Parent scope!");
1262 NScope->setParent(Parent);
1263 Parent->addScope(NScope);
1264 } else if (DIDescriptor(N).isLexicalBlock()) {
1265 DILexicalBlock DB(N);
1266 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1267 NScope->setParent(Parent);
1268 Parent->addScope(NScope);
1271 NScope->setFirstInsn(MI);
1273 if (!Parent && !InlinedAt) {
1274 StringRef SPName = DISubprogram(N).getLinkageName();
1275 if (SPName == MF->getFunction()->getName())
1276 CurrentFnDbgScope = NScope;
1279 if (isAConcreteScope) {
1280 ConcreteScopes[InlinedAt] = NScope;
1281 getOrCreateAbstractScope(N);
1287 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1288 assert(N && "Invalid Scope encoding!");
1290 DbgScope *AScope = AbstractScopes.lookup(N);
1294 DbgScope *Parent = NULL;
1296 DIDescriptor Scope(N);
1297 if (Scope.isLexicalBlock()) {
1298 DILexicalBlock DB(N);
1299 DIDescriptor ParentDesc = DB.getContext();
1300 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1303 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1306 Parent->addScope(AScope);
1307 AScope->setAbstractScope();
1308 AbstractScopes[N] = AScope;
1309 if (DIDescriptor(N).isSubprogram())
1310 AbstractScopesList.push_back(AScope);
1314 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1315 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1316 /// If there are global variables in this scope then create and insert
1317 /// DIEs for these variables.
1318 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1319 DIE *SPDie = ModuleCU->getDIE(SPNode);
1320 assert(SPDie && "Unable to find subprogram DIE!");
1321 DISubprogram SP(SPNode);
1323 // There is not any need to generate specification DIE for a function
1324 // defined at compile unit level. If a function is defined inside another
1325 // function then gdb prefers the definition at top level and but does not
1326 // expect specification DIE in parent function. So avoid creating
1327 // specification DIE for a function defined inside a function.
1328 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1329 !SP.getContext().isFile() && !SP.getContext().isSubprogram()) {
1330 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1333 DICompositeType SPTy = SP.getType();
1334 DIArray Args = SPTy.getTypeArray();
1335 unsigned SPTag = SPTy.getTag();
1336 if (SPTag == dwarf::DW_TAG_subroutine_type)
1337 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1338 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1339 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1341 if (ATy.isArtificial())
1342 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1343 SPDie->addChild(Arg);
1345 DIE *SPDeclDie = SPDie;
1346 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1347 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1349 ModuleCU->addDie(SPDie);
1352 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1353 getDWLabel("func_begin", SubprogramCount));
1354 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1355 getDWLabel("func_end", SubprogramCount));
1356 MachineLocation Location(RI->getFrameRegister(*MF));
1357 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1359 if (!DISubprogram(SPNode).isLocalToUnit())
1360 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1365 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1366 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1367 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1368 MCSymbol *Start = Scope->getStartLabel();
1369 MCSymbol *End = Scope->getEndLabel();
1370 if (Start == 0 || End == 0) return 0;
1372 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1373 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1375 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1376 if (Scope->isAbstractScope())
1379 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1380 Start ? Start : getDWLabel("func_begin", SubprogramCount));
1381 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1382 End ? End : getDWLabel("func_end", SubprogramCount));
1387 /// constructInlinedScopeDIE - This scope represents inlined body of
1388 /// a function. Construct DIE to represent this concrete inlined copy
1389 /// of the function.
1390 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1391 MCSymbol *StartLabel = Scope->getStartLabel();
1392 MCSymbol *EndLabel = Scope->getEndLabel();
1393 if (StartLabel == 0 || EndLabel == 0) return 0;
1395 assert(StartLabel->isDefined() &&
1396 "Invalid starting label for an inlined scope!");
1397 assert(EndLabel->isDefined() &&
1398 "Invalid end label for an inlined scope!");
1399 if (!Scope->getScopeNode())
1401 DIScope DS(Scope->getScopeNode());
1402 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1404 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1405 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1406 assert(OriginDIE && "Unable to find Origin DIE!");
1407 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1408 dwarf::DW_FORM_ref4, OriginDIE);
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, EndLabel);
1413 InlinedSubprogramDIEs.insert(OriginDIE);
1415 // Track the start label for this inlined function.
1416 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1417 I = InlineInfo.find(InlinedSP.getNode());
1419 if (I == InlineInfo.end()) {
1420 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1422 InlinedSPNodes.push_back(InlinedSP.getNode());
1424 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1426 DILocation DL(Scope->getInlinedAt());
1427 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1428 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1434 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1435 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1436 // Get the descriptor.
1437 const DIVariable &VD = DV->getVariable();
1438 StringRef Name = VD.getName();
1442 // Translate tag to proper Dwarf tag. The result variable is dropped for
1445 switch (VD.getTag()) {
1446 case dwarf::DW_TAG_return_variable:
1448 case dwarf::DW_TAG_arg_variable:
1449 Tag = dwarf::DW_TAG_formal_parameter;
1451 case dwarf::DW_TAG_auto_variable: // fall thru
1453 Tag = dwarf::DW_TAG_variable;
1457 // Define variable debug information entry.
1458 DIE *VariableDie = new DIE(Tag);
1462 if (DbgVariable *AV = DV->getAbstractVariable())
1463 AbsDIE = AV->getDIE();
1466 DIScope DS(Scope->getScopeNode());
1467 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1468 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1470 assert(OriginSPDIE && "Unable to find Origin DIE for the SP!");
1471 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1472 assert(AbsDIE && "Unable to find Origin DIE for the Variable!");
1473 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1474 dwarf::DW_FORM_ref4, AbsDIE);
1477 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1478 addSourceLine(VariableDie, &VD);
1480 // Add variable type.
1481 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1482 // addresses instead.
1483 if (VD.isBlockByrefVariable())
1484 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1486 addType(VariableDie, VD.getType());
1489 // Add variable address.
1490 if (!Scope->isAbstractScope()) {
1491 // Check if variable is described by DBG_VALUE instruction.
1492 if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1493 if (DbgValueInsn->getNumOperands() == 3) {
1494 // FIXME : Handle getNumOperands != 3
1495 if (DbgValueInsn->getOperand(0).getType()
1496 == MachineOperand::MO_Register
1497 && DbgValueInsn->getOperand(0).getReg()) {
1498 MachineLocation Location;
1499 Location.set(DbgValueInsn->getOperand(0).getReg());
1500 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1501 if (MCSymbol *VS = DV->getDbgValueLabel())
1502 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1504 } else if (DbgValueInsn->getOperand(0).getType() ==
1505 MachineOperand::MO_Immediate) {
1506 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1507 unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1508 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1509 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1510 if (MCSymbol *VS = DV->getDbgValueLabel())
1511 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1514 //FIXME : Handle other operand types.
1520 MachineLocation Location;
1522 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(),
1524 Location.set(FrameReg, Offset);
1526 if (VD.hasComplexAddress())
1527 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1528 else if (VD.isBlockByrefVariable())
1529 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1531 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1535 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1536 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1537 DV->setDIE(VariableDie);
1542 void DwarfDebug::addPubTypes(DISubprogram SP) {
1543 DICompositeType SPTy = SP.getType();
1544 unsigned SPTag = SPTy.getTag();
1545 if (SPTag != dwarf::DW_TAG_subroutine_type)
1548 DIArray Args = SPTy.getTypeArray();
1549 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1550 DIType ATy(Args.getElement(i).getNode());
1553 DICompositeType CATy = getDICompositeType(ATy);
1554 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1555 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1556 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1561 /// constructScopeDIE - Construct a DIE for this scope.
1562 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1563 if (!Scope || !Scope->getScopeNode())
1566 DIScope DS(Scope->getScopeNode());
1567 DIE *ScopeDIE = NULL;
1568 if (Scope->getInlinedAt())
1569 ScopeDIE = constructInlinedScopeDIE(Scope);
1570 else if (DS.isSubprogram()) {
1571 if (Scope->isAbstractScope())
1572 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1574 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1577 ScopeDIE = constructLexicalScopeDIE(Scope);
1578 if (!ScopeDIE) return NULL;
1580 // Add variables to scope.
1581 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1582 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1583 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1585 ScopeDIE->addChild(VariableDIE);
1588 // Add nested scopes.
1589 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1590 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1591 // Define the Scope debug information entry.
1592 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1594 ScopeDIE->addChild(NestedDIE);
1597 if (DS.isSubprogram())
1598 addPubTypes(DISubprogram(DS.getNode()));
1603 /// GetOrCreateSourceID - Look up the source id with the given directory and
1604 /// source file names. If none currently exists, create a new id and insert it
1605 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1607 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1609 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1610 if (DI != DirectoryIdMap.end()) {
1611 DId = DI->getValue();
1613 DId = DirectoryNames.size() + 1;
1614 DirectoryIdMap[DirName] = DId;
1615 DirectoryNames.push_back(DirName);
1619 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1620 if (FI != SourceFileIdMap.end()) {
1621 FId = FI->getValue();
1623 FId = SourceFileNames.size() + 1;
1624 SourceFileIdMap[FileName] = FId;
1625 SourceFileNames.push_back(FileName);
1628 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1629 SourceIdMap.find(std::make_pair(DId, FId));
1630 if (SI != SourceIdMap.end())
1633 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1634 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1635 SourceIds.push_back(std::make_pair(DId, FId));
1640 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1641 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1642 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1645 NDie = new DIE(dwarf::DW_TAG_namespace);
1646 ModuleCU->insertDIE(NS.getNode(), NDie);
1647 if (!NS.getName().empty())
1648 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1649 addSourceLine(NDie, &NS);
1650 addToContextOwner(NDie, NS.getContext());
1654 void DwarfDebug::constructCompileUnit(MDNode *N) {
1655 DICompileUnit DIUnit(N);
1656 // Use first compile unit marked as isMain as the compile unit for this
1658 if (ModuleCU || !DIUnit.isMain())
1660 StringRef FN = DIUnit.getFilename();
1661 StringRef Dir = DIUnit.getDirectory();
1662 unsigned ID = GetOrCreateSourceID(Dir, FN);
1664 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1665 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1666 DIUnit.getProducer());
1667 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1668 DIUnit.getLanguage());
1669 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1670 addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1671 getTempLabel("text_begin"));
1672 addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1673 getTempLabel("text_end"));
1674 // DW_AT_stmt_list is a offset of line number information for this
1675 // compile unit in debug_line section. It is always zero when only one
1676 // compile unit is emitted in one object file.
1677 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1680 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1681 if (DIUnit.isOptimized())
1682 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1684 StringRef Flags = DIUnit.getFlags();
1686 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1688 unsigned RVer = DIUnit.getRunTimeVersion();
1690 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1691 dwarf::DW_FORM_data1, RVer);
1694 "ModuleCU assigned since the top of constructCompileUnit");
1695 ModuleCU = new CompileUnit(ID, Die);
1698 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1699 DIGlobalVariable DI_GV(N);
1701 // If debug information is malformed then ignore it.
1702 if (DI_GV.Verify() == false)
1705 // Check for pre-existence.
1706 if (ModuleCU->getDIE(DI_GV.getNode()))
1709 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1714 ModuleCU->insertDIE(N, VariableDie);
1716 // Add to context owner.
1717 DIDescriptor GVContext = DI_GV.getContext();
1718 // Do not create specification DIE if context is either compile unit
1720 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1721 !GVContext.isFile() && !GVContext.isSubprogram()) {
1722 // Create specification DIE.
1723 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1724 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1725 dwarf::DW_FORM_ref4, VariableDie);
1726 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1727 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1728 addLabel(Block, 0, dwarf::DW_FORM_udata,
1729 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1730 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1731 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1732 ModuleCU->addDie(VariableSpecDIE);
1734 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1735 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1736 addLabel(Block, 0, dwarf::DW_FORM_udata,
1737 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1738 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1740 addToContextOwner(VariableDie, GVContext);
1742 // Expose as global. FIXME - need to check external flag.
1743 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1745 DIType GTy = DI_GV.getType();
1746 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1747 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1748 assert(Entry && "Missing global type!");
1749 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1754 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1757 // Check for pre-existence.
1758 if (ModuleCU->getDIE(N))
1761 if (!SP.isDefinition())
1762 // This is a method declaration which will be handled while constructing
1766 DIE *SubprogramDie = createSubprogramDIE(SP);
1769 ModuleCU->insertDIE(N, SubprogramDie);
1771 // Add to context owner.
1772 addToContextOwner(SubprogramDie, SP.getContext());
1774 // Expose as global.
1775 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1780 /// beginModule - Emit all Dwarf sections that should come prior to the
1781 /// content. Create global DIEs and emit initial debug info sections.
1782 /// This is inovked by the target AsmPrinter.
1783 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1786 if (!MAI->doesSupportDebugInformation())
1789 TimeRegion Timer(DebugTimer);
1791 DebugInfoFinder DbgFinder;
1792 DbgFinder.processModule(*M);
1794 // Create all the compile unit DIEs.
1795 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1796 E = DbgFinder.compile_unit_end(); I != E; ++I)
1797 constructCompileUnit(*I);
1802 // Create DIEs for each subprogram.
1803 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1804 E = DbgFinder.subprogram_end(); I != E; ++I)
1805 constructSubprogramDIE(*I);
1807 // Create DIEs for each global variable.
1808 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1809 E = DbgFinder.global_variable_end(); I != E; ++I)
1810 constructGlobalVariableDIE(*I);
1814 MMI->setDebugInfoAvailability(true);
1816 // Prime section data.
1817 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1819 // Print out .file directives to specify files for .loc directives. These are
1820 // printed out early so that they precede any .loc directives.
1821 if (MAI->hasDotLocAndDotFile()) {
1822 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1823 // Remember source id starts at 1.
1824 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1825 // FIXME: don't use sys::path for this! This should not depend on the
1827 sys::Path FullPath(getSourceDirectoryName(Id.first));
1829 FullPath.appendComponent(getSourceFileName(Id.second));
1830 assert(AppendOk && "Could not append filename to directory!");
1832 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1836 // Emit initial sections
1840 /// endModule - Emit all Dwarf sections that should come after the content.
1842 void DwarfDebug::endModule() {
1846 TimeRegion Timer(DebugTimer);
1848 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1849 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1850 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1852 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1855 // Insert top level DIEs.
1856 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1857 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1858 ModuleCU->getCUDie()->addChild(*TI);
1860 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1861 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1862 DIE *SPDie = CI->first;
1863 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1865 DIE *NDie = ModuleCU->getDIE(N);
1866 if (!NDie) continue;
1867 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1868 // FIXME - This is not the correct approach.
1869 //addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie
1872 // Standard sections final addresses.
1873 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1874 Asm->OutStreamer.EmitLabel(getTempLabel("text_end"));
1875 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1876 Asm->OutStreamer.EmitLabel(getTempLabel("data_end"));
1878 // End text sections.
1879 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1880 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1881 Asm->OutStreamer.EmitLabel(getDWLabel("section_end", i));
1884 // Emit common frame information.
1885 emitCommonDebugFrame();
1887 // Emit function debug frame information
1888 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1889 E = DebugFrames.end(); I != E; ++I)
1890 emitFunctionDebugFrame(*I);
1892 // Compute DIE offsets and sizes.
1893 computeSizeAndOffsets();
1895 // Emit all the DIEs into a debug info section
1898 // Corresponding abbreviations into a abbrev section.
1899 emitAbbreviations();
1901 // Emit source line correspondence into a debug line section.
1904 // Emit info into a debug pubnames section.
1905 emitDebugPubNames();
1907 // Emit info into a debug pubtypes section.
1908 emitDebugPubTypes();
1910 // Emit info into a debug loc section.
1913 // Emit info into a debug aranges section.
1916 // Emit info into a debug ranges section.
1919 // Emit info into a debug macinfo section.
1922 // Emit inline info.
1923 emitDebugInlineInfo();
1925 // Emit info into a debug str section.
1929 ModuleCU = NULL; // Reset for the next Module, if any.
1932 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1933 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1935 DILocation &ScopeLoc) {
1937 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1939 return AbsDbgVariable;
1941 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1945 AbsDbgVariable = new DbgVariable(Var, FrameIdx,
1946 NULL /* No more-abstract variable*/);
1947 Scope->addVariable(AbsDbgVariable);
1948 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1949 return AbsDbgVariable;
1952 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1953 /// FIXME : Refactor findAbstractVariable.
1954 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1955 const MachineInstr *MI,
1956 DILocation &ScopeLoc) {
1958 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1960 return AbsDbgVariable;
1962 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1966 AbsDbgVariable = new DbgVariable(Var, MI,
1967 NULL /* No more-abstract variable*/);
1968 Scope->addVariable(AbsDbgVariable);
1969 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1970 DbgValueStartMap[MI] = AbsDbgVariable;
1971 return AbsDbgVariable;
1974 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1975 void DwarfDebug::collectVariableInfo() {
1978 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1979 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1980 VE = VMap.end(); VI != VE; ++VI) {
1981 MDNode *Var = VI->first;
1983 DIVariable DV (Var);
1984 std::pair< unsigned, MDNode *> VP = VI->second;
1985 DILocation ScopeLoc(VP.second);
1988 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1990 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1991 // If variable scope is not found then skip this variable.
1995 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, ScopeLoc);
1996 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
1997 Scope->addVariable(RegVar);
2000 // Collect variable information from DBG_VALUE machine instructions;
2001 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2003 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2005 const MachineInstr *MInsn = II;
2006 if (!MInsn->isDebugValue())
2009 // FIXME : Lift this restriction.
2010 if (MInsn->getNumOperands() != 3)
2012 DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands()
2013 - 1).getMetadata()));
2014 if (DV.getTag() == dwarf::DW_TAG_arg_variable) {
2015 // FIXME Handle inlined subroutine arguments.
2016 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2017 CurrentFnDbgScope->addVariable(ArgVar);
2018 DbgValueStartMap[MInsn] = ArgVar;
2022 DebugLoc DL = MInsn->getDebugLoc();
2023 if (DL.isUnknown()) continue;
2024 DILocation ScopeLoc = MF->getDILocation(DL);
2026 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
2028 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
2029 // If variable scope is not found then skip this variable.
2033 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, ScopeLoc);
2034 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2035 DbgValueStartMap[MInsn] = RegVar;
2036 Scope->addVariable(RegVar);
2041 /// beginScope - Process beginning of a scope.
2042 void DwarfDebug::beginScope(const MachineInstr *MI) {
2044 DebugLoc DL = MI->getDebugLoc();
2047 DILocation DILoc = MF->getDILocation(DL);
2048 if (!DILoc.getScope().Verify())
2051 // Check and update last known location info.
2052 if(DILoc.getNode() == PrevDILoc)
2054 PrevDILoc = DILoc.getNode();
2056 // DBG_VALUE instruction establishes new value.
2057 if (MI->isDebugValue()) {
2058 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2059 = DbgValueStartMap.find(MI);
2060 if (DI != DbgValueStartMap.end()) {
2061 MCSymbol *Label = recordSourceLine(DILoc.getLineNumber(),
2062 DILoc.getColumnNumber(),
2063 DILoc.getScope().getNode());
2064 DI->second->setDbgValueLabel(Label);
2069 // Emit a label to indicate location change. This is used for line
2070 // table even if this instruction does start a new scope.
2071 MCSymbol *Label = recordSourceLine(DILoc.getLineNumber(),
2072 DILoc.getColumnNumber(),
2073 DILoc.getScope().getNode());
2075 // update DbgScope if this instruction starts a new scope.
2076 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2077 if (I == DbgScopeBeginMap.end())
2080 ScopeVector &SD = I->second;
2081 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
2083 (*SDI)->setStartLabel(Label);
2086 /// endScope - Process end of a scope.
2087 void DwarfDebug::endScope(const MachineInstr *MI) {
2088 // Ignore DBG_VALUE instruction.
2089 if (MI->isDebugValue())
2093 DebugLoc DL = MI->getDebugLoc();
2096 DILocation DILoc = MF->getDILocation(DL);
2097 if (!DILoc.getScope().Verify())
2100 // Emit a label and update DbgScope if this instruction ends a scope.
2101 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2102 if (I == DbgScopeEndMap.end())
2105 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2106 Asm->OutStreamer.EmitLabel(Label);
2108 SmallVector<DbgScope*, 2> &SD = I->second;
2109 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2111 (*SDI)->setEndLabel(Label);
2115 /// createDbgScope - Create DbgScope for the scope.
2116 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2119 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2122 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2123 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2124 if (DIDescriptor(Scope).isLexicalBlock())
2125 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2129 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2133 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2134 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2135 DILocation DL(InlinedAt);
2136 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2139 /// extractScopeInformation - Scan machine instructions in this function
2140 /// and collect DbgScopes. Return true, if at least one scope was found.
2141 bool DwarfDebug::extractScopeInformation() {
2142 // If scope information was extracted using .dbg intrinsics then there is not
2143 // any need to extract these information by scanning each instruction.
2144 if (!DbgScopeMap.empty())
2147 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2148 unsigned MIIndex = 0;
2149 MDNode *PrevScope = NULL;
2150 MDNode *PrevInlinedAt = NULL;
2151 // Scan each instruction and create scopes. First build working set of scopes.
2152 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2154 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2156 const MachineInstr *MInsn = II;
2157 // FIXME : Remove DBG_VALUE check.
2158 if (MInsn->isDebugValue()) continue;
2159 MIIndexMap[MInsn] = MIIndex++;
2160 DebugLoc DL = MInsn->getDebugLoc();
2161 if (DL.isUnknown()) continue;
2162 DILocation DLT = MF->getDILocation(DL);
2163 DIScope DLTScope = DLT.getScope();
2164 MDNode *NewScope = DLTScope.getNode();
2165 if (!NewScope) continue;
2166 // There is no need to create another DIE for compile unit. For all
2167 // other scopes, create one DbgScope now. This will be translated
2168 // into a scope DIE at the end.
2169 if (DLTScope.isCompileUnit()) continue;
2170 MDNode *NewInlinedAt = DLT.getOrigLocation().getNode();
2171 if (NewScope == PrevScope && NewInlinedAt == PrevInlinedAt) continue;
2172 createDbgScope(NewScope, NewInlinedAt);
2173 PrevScope = NewScope;
2174 PrevInlinedAt = NewInlinedAt;
2178 // Build scope hierarchy using working set of scopes.
2180 PrevInlinedAt = NULL;
2181 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2183 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2185 const MachineInstr *MInsn = II;
2186 // FIXME : Remove DBG_VALUE check.
2187 if (MInsn->isDebugValue()) continue;
2188 DebugLoc DL = MInsn->getDebugLoc();
2189 if (DL.isUnknown()) continue;
2190 DILocation DLT = MF->getDILocation(DL);
2191 DIScope DLTScope = DLT.getScope();
2192 MDNode *NewScope = DLTScope.getNode();
2193 if (!NewScope) continue;
2194 // There is no need to create another DIE for compile unit. For all
2195 // other scopes, create one DbgScope now. This will be translated
2196 // into a scope DIE at the end.
2197 if (DLTScope.isCompileUnit()) continue;
2198 MDNode *NewInlinedAt = DLT.getOrigLocation().getNode();
2199 if (NewScope == PrevScope && NewInlinedAt == PrevInlinedAt) continue;
2200 DbgScope *Scope = getUpdatedDbgScope(NewScope, MInsn, NewInlinedAt);
2201 Scope->setLastInsn(MInsn);
2202 PrevScope = NewScope;
2203 PrevInlinedAt = NewInlinedAt;
2207 if (!CurrentFnDbgScope)
2210 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2212 // Each scope has first instruction and last instruction to mark beginning
2213 // and end of a scope respectively. Create an inverse map that list scopes
2214 // starts (and ends) with an instruction. One instruction may start (or end)
2215 // multiple scopes. Ignore scopes that are not reachable.
2216 SmallVector<DbgScope *, 4> WorkList;
2217 WorkList.push_back(CurrentFnDbgScope);
2218 while (!WorkList.empty()) {
2219 DbgScope *S = WorkList.pop_back_val();
2221 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2222 if (!Children.empty())
2223 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2224 SE = Children.end(); SI != SE; ++SI)
2225 WorkList.push_back(*SI);
2227 if (S->isAbstractScope())
2229 const MachineInstr *MI = S->getFirstInsn();
2230 assert(MI && "DbgScope does not have first instruction!");
2232 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2233 if (IDI != DbgScopeBeginMap.end())
2234 IDI->second.push_back(S);
2236 DbgScopeBeginMap[MI].push_back(S);
2238 MI = S->getLastInsn();
2239 assert(MI && "DbgScope does not have last instruction!");
2240 IDI = DbgScopeEndMap.find(MI);
2241 if (IDI != DbgScopeEndMap.end())
2242 IDI->second.push_back(S);
2244 DbgScopeEndMap[MI].push_back(S);
2247 return !DbgScopeMap.empty();
2250 /// beginFunction - Gather pre-function debug information. Assumes being
2251 /// emitted immediately after the function entry point.
2252 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2255 if (!ShouldEmitDwarfDebug()) return;
2256 if (!extractScopeInformation())
2259 TimeRegion Timer(DebugTimer);
2261 collectVariableInfo();
2263 // Assumes in correct section after the entry point.
2264 Asm->OutStreamer.EmitLabel(getDWLabel("func_begin", ++SubprogramCount));
2266 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2268 DebugLoc FDL = MF->getDefaultDebugLoc();
2269 if (!FDL.isUnknown()) {
2270 DILocation DLT = MF->getDILocation(FDL);
2271 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2274 Line = SP.getLineNumber();
2277 Line = DLT.getLineNumber();
2278 Col = DLT.getColumnNumber();
2281 recordSourceLine(Line, Col, DLT.getScope().getNode());
2285 /// endFunction - Gather and emit post-function debug information.
2287 void DwarfDebug::endFunction(const MachineFunction *MF) {
2288 if (!ShouldEmitDwarfDebug()) return;
2289 if (DbgScopeMap.empty()) return;
2291 TimeRegion Timer(DebugTimer);
2293 if (CurrentFnDbgScope) {
2294 // Define end label for subprogram.
2295 Asm->OutStreamer.EmitLabel(getDWLabel("func_end", SubprogramCount));
2297 // Get function line info.
2298 if (!Lines.empty()) {
2299 // Get section line info.
2300 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2301 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2302 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2303 // Append the function info to section info.
2304 SectionLineInfos.insert(SectionLineInfos.end(),
2305 Lines.begin(), Lines.end());
2308 // Construct abstract scopes.
2309 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2310 AE = AbstractScopesList.end(); AI != AE; ++AI)
2311 constructScopeDIE(*AI);
2313 constructScopeDIE(CurrentFnDbgScope);
2315 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2316 MMI->getFrameMoves()));
2320 CurrentFnDbgScope = NULL;
2321 DeleteContainerSeconds(DbgScopeMap);
2322 DbgScopeBeginMap.clear();
2323 DbgScopeEndMap.clear();
2324 DbgValueStartMap.clear();
2325 ConcreteScopes.clear();
2326 DeleteContainerSeconds(AbstractScopes);
2327 AbstractScopesList.clear();
2328 AbstractVariables.clear();
2332 /// recordSourceLine - Register a source line with debug info. Returns the
2333 /// unique label that was emitted and which provides correspondence to
2334 /// the source line list.
2335 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2339 TimeRegion Timer(DebugTimer);
2344 DIDescriptor Scope(S);
2345 if (Scope.isCompileUnit()) {
2346 DICompileUnit CU(S);
2347 Dir = CU.getDirectory();
2348 Fn = CU.getFilename();
2349 } else if (Scope.isSubprogram()) {
2351 Dir = SP.getDirectory();
2352 Fn = SP.getFilename();
2353 } else if (Scope.isLexicalBlock()) {
2354 DILexicalBlock DB(S);
2355 Dir = DB.getDirectory();
2356 Fn = DB.getFilename();
2358 assert(0 && "Unexpected scope info");
2360 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2361 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2362 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2364 Asm->OutStreamer.EmitLabel(Label);
2368 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2369 /// timed. Look up the source id with the given directory and source file
2370 /// names. If none currently exists, create a new id and insert it in the
2371 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2373 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2374 const std::string &FileName) {
2375 TimeRegion Timer(DebugTimer);
2376 return GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2379 //===----------------------------------------------------------------------===//
2381 //===----------------------------------------------------------------------===//
2383 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2386 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2387 // Get the children.
2388 const std::vector<DIE *> &Children = Die->getChildren();
2390 // If not last sibling and has children then add sibling offset attribute.
2391 if (!Last && !Children.empty())
2392 Die->addSiblingOffset(DIEValueAllocator);
2394 // Record the abbreviation.
2395 assignAbbrevNumber(Die->getAbbrev());
2397 // Get the abbreviation for this DIE.
2398 unsigned AbbrevNumber = Die->getAbbrevNumber();
2399 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2402 Die->setOffset(Offset);
2404 // Start the size with the size of abbreviation code.
2405 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2407 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2408 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2410 // Size the DIE attribute values.
2411 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2412 // Size attribute value.
2413 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2415 // Size the DIE children if any.
2416 if (!Children.empty()) {
2417 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2418 "Children flag not set");
2420 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2421 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2423 // End of children marker.
2424 Offset += sizeof(int8_t);
2427 Die->setSize(Offset - Die->getOffset());
2431 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2433 void DwarfDebug::computeSizeAndOffsets() {
2434 // Compute size of compile unit header.
2435 static unsigned Offset =
2436 sizeof(int32_t) + // Length of Compilation Unit Info
2437 sizeof(int16_t) + // DWARF version number
2438 sizeof(int32_t) + // Offset Into Abbrev. Section
2439 sizeof(int8_t); // Pointer Size (in bytes)
2441 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2442 CompileUnitOffsets[ModuleCU] = 0;
2445 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2446 /// tools to recognize the object file contains Dwarf information.
2447 void DwarfDebug::emitInitial() {
2448 // Check to see if we already emitted intial headers.
2449 if (didInitial) return;
2452 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2454 // Dwarf sections base addresses.
2455 if (MAI->doesDwarfRequireFrameSection()) {
2456 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2457 Asm->OutStreamer.EmitLabel(getTempLabel("section_debug_frame"));
2460 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2461 Asm->OutStreamer.EmitLabel(getTempLabel("section_info"));
2462 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2463 Asm->OutStreamer.EmitLabel(getTempLabel("section_abbrev"));
2464 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2465 Asm->OutStreamer.EmitLabel(getTempLabel("section_aranges"));
2467 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2468 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2469 Asm->OutStreamer.EmitLabel(getTempLabel("section_macinfo"));
2472 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2473 Asm->OutStreamer.EmitLabel(getTempLabel("section_line"));
2474 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2475 Asm->OutStreamer.EmitLabel(getTempLabel("section_loc"));
2476 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2477 Asm->OutStreamer.EmitLabel(getTempLabel("section_pubnames"));
2478 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2479 Asm->OutStreamer.EmitLabel(getTempLabel("section_pubtypes"));
2480 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2481 Asm->OutStreamer.EmitLabel(getTempLabel("section_str"));
2482 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2483 Asm->OutStreamer.EmitLabel(getTempLabel("section_ranges"));
2485 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2486 Asm->OutStreamer.EmitLabel(getTempLabel("text_begin"));
2487 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2488 Asm->OutStreamer.EmitLabel(getTempLabel("data_begin"));
2491 /// emitDIE - Recusively Emits a debug information entry.
2493 void DwarfDebug::emitDIE(DIE *Die) {
2494 // Get the abbreviation for this DIE.
2495 unsigned AbbrevNumber = Die->getAbbrevNumber();
2496 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2498 // Emit the code (index) for the abbreviation.
2499 if (Asm->VerboseAsm)
2500 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2501 Twine::utohexstr(Die->getOffset()) + ":0x" +
2502 Twine::utohexstr(Die->getSize()) + " " +
2503 dwarf::TagString(Abbrev->getTag()));
2504 EmitULEB128(AbbrevNumber);
2506 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2507 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2509 // Emit the DIE attribute values.
2510 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2511 unsigned Attr = AbbrevData[i].getAttribute();
2512 unsigned Form = AbbrevData[i].getForm();
2513 assert(Form && "Too many attributes for DIE (check abbreviation)");
2515 if (Asm->VerboseAsm)
2516 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2519 case dwarf::DW_AT_sibling:
2520 Asm->EmitInt32(Die->getSiblingOffset());
2522 case dwarf::DW_AT_abstract_origin: {
2523 DIEEntry *E = cast<DIEEntry>(Values[i]);
2524 DIE *Origin = E->getEntry();
2525 unsigned Addr = Origin->getOffset();
2526 Asm->EmitInt32(Addr);
2530 // Emit an attribute using the defined form.
2531 Values[i]->EmitValue(this, Form);
2536 // Emit the DIE children if any.
2537 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2538 const std::vector<DIE *> &Children = Die->getChildren();
2540 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2541 emitDIE(Children[j]);
2543 if (Asm->VerboseAsm)
2544 Asm->OutStreamer.AddComment("End Of Children Mark");
2549 /// emitDebugInfo - Emit the debug info section.
2551 void DwarfDebug::emitDebugInfo() {
2552 // Start debug info section.
2553 Asm->OutStreamer.SwitchSection(
2554 Asm->getObjFileLowering().getDwarfInfoSection());
2555 DIE *Die = ModuleCU->getCUDie();
2557 // Emit the compile units header.
2558 Asm->OutStreamer.EmitLabel(getDWLabel("info_begin", ModuleCU->getID()));
2560 // Emit size of content not including length itself
2561 unsigned ContentSize = Die->getSize() +
2562 sizeof(int16_t) + // DWARF version number
2563 sizeof(int32_t) + // Offset Into Abbrev. Section
2564 sizeof(int8_t) + // Pointer Size (in bytes)
2565 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2567 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2568 Asm->EmitInt32(ContentSize);
2569 Asm->OutStreamer.AddComment("DWARF version number");
2570 Asm->EmitInt16(dwarf::DWARF_VERSION);
2571 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2572 EmitSectionOffset(getTempLabel("abbrev_begin"),getTempLabel("section_abbrev"),
2574 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2575 Asm->EmitInt8(TD->getPointerSize());
2578 // FIXME - extra padding for gdb bug.
2579 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2584 Asm->OutStreamer.EmitLabel(getDWLabel("info_end", ModuleCU->getID()));
2587 /// emitAbbreviations - Emit the abbreviation section.
2589 void DwarfDebug::emitAbbreviations() const {
2590 // Check to see if it is worth the effort.
2591 if (!Abbreviations.empty()) {
2592 // Start the debug abbrev section.
2593 Asm->OutStreamer.SwitchSection(
2594 Asm->getObjFileLowering().getDwarfAbbrevSection());
2596 Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_begin"));
2598 // For each abbrevation.
2599 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2600 // Get abbreviation data
2601 const DIEAbbrev *Abbrev = Abbreviations[i];
2603 // Emit the abbrevations code (base 1 index.)
2604 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2606 // Emit the abbreviations data.
2610 // Mark end of abbreviations.
2611 EmitULEB128(0, "EOM(3)");
2613 Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_end"));
2617 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2618 /// the line matrix.
2620 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2621 // Define last address of section.
2622 Asm->OutStreamer.AddComment("Extended Op");
2625 Asm->OutStreamer.AddComment("Op size");
2626 Asm->EmitInt8(TD->getPointerSize() + 1);
2627 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2628 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2630 Asm->OutStreamer.AddComment("Section end label");
2632 Asm->OutStreamer.EmitSymbolValue(getDWLabel("section_end", SectionEnd),
2633 TD->getPointerSize(), 0/*AddrSpace*/);
2635 // Mark end of matrix.
2636 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2642 /// emitDebugLines - Emit source line information.
2644 void DwarfDebug::emitDebugLines() {
2645 // If the target is using .loc/.file, the assembler will be emitting the
2646 // .debug_line table automatically.
2647 if (MAI->hasDotLocAndDotFile())
2650 // Minimum line delta, thus ranging from -10..(255-10).
2651 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2652 // Maximum line delta, thus ranging from -10..(255-10).
2653 const int MaxLineDelta = 255 + MinLineDelta;
2655 // Start the dwarf line section.
2656 Asm->OutStreamer.SwitchSection(
2657 Asm->getObjFileLowering().getDwarfLineSection());
2659 // Construct the section header.
2660 Asm->OutStreamer.AddComment("Length of Source Line Info");
2661 EmitDifference(getTempLabel("line_end"), getTempLabel("line_begin"), true);
2662 Asm->OutStreamer.EmitLabel(getTempLabel("line_begin"));
2664 Asm->OutStreamer.AddComment("DWARF version number");
2665 Asm->EmitInt16(dwarf::DWARF_VERSION);
2667 Asm->OutStreamer.AddComment("Prolog Length");
2668 EmitDifference(getTempLabel("line_prolog_end"),
2669 getTempLabel("line_prolog_begin"), true);
2670 Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_begin"));
2672 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2674 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2676 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2677 Asm->EmitInt8(MinLineDelta);
2678 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2679 Asm->EmitInt8(MaxLineDelta);
2680 Asm->OutStreamer.AddComment("Special Opcode Base");
2681 Asm->EmitInt8(-MinLineDelta);
2683 // Line number standard opcode encodings argument count
2684 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2686 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2688 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2690 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2692 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2694 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2696 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2698 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2700 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2703 // Emit directories.
2704 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2705 const std::string &Dir = getSourceDirectoryName(DI);
2706 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2707 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2710 Asm->OutStreamer.AddComment("End of directories");
2714 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2715 // Remember source id starts at 1.
2716 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2717 const std::string &FN = getSourceFileName(Id.second);
2718 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2719 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2721 EmitULEB128(Id.first, "Directory #");
2722 EmitULEB128(0, "Mod date");
2723 EmitULEB128(0, "File size");
2726 Asm->OutStreamer.AddComment("End of files");
2729 Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_end"));
2731 // A sequence for each text section.
2732 unsigned SecSrcLinesSize = SectionSourceLines.size();
2734 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2735 // Isolate current sections line info.
2736 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2738 // Dwarf assumes we start with first line of first source file.
2739 unsigned Source = 1;
2742 // Construct rows of the address, source, line, column matrix.
2743 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2744 const SrcLineInfo &LineInfo = LineInfos[i];
2745 MCSymbol *Label = LineInfo.getLabel();
2746 if (!Label->isDefined()) continue; // Not emitted, in dead code.
2748 if (LineInfo.getLine() == 0) continue;
2750 if (Asm->isVerbose()) {
2751 std::pair<unsigned, unsigned> SrcID =
2752 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2753 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2755 Twine(getSourceFileName(SrcID.second)) +
2756 ":" + Twine(LineInfo.getLine()));
2759 // Define the line address.
2760 Asm->OutStreamer.AddComment("Extended Op");
2762 Asm->OutStreamer.AddComment("Op size");
2763 Asm->EmitInt8(TD->getPointerSize() + 1);
2765 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2766 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2768 Asm->OutStreamer.AddComment("Location label");
2769 Asm->OutStreamer.EmitSymbolValue(Label, TD->getPointerSize(),
2772 // If change of source, then switch to the new source.
2773 if (Source != LineInfo.getSourceID()) {
2774 Source = LineInfo.getSourceID();
2775 Asm->OutStreamer.AddComment("DW_LNS_set_file");
2776 Asm->EmitInt8(dwarf::DW_LNS_set_file);
2777 EmitULEB128(Source, "New Source");
2780 // If change of line.
2781 if (Line != LineInfo.getLine()) {
2782 // Determine offset.
2783 int Offset = LineInfo.getLine() - Line;
2784 int Delta = Offset - MinLineDelta;
2787 Line = LineInfo.getLine();
2789 // If delta is small enough and in range...
2790 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2791 // ... then use fast opcode.
2792 Asm->OutStreamer.AddComment("Line Delta");
2793 Asm->EmitInt8(Delta - MinLineDelta);
2795 // ... otherwise use long hand.
2796 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2797 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2798 EmitSLEB128(Offset, "Line Offset");
2799 Asm->OutStreamer.AddComment("DW_LNS_copy");
2800 Asm->EmitInt8(dwarf::DW_LNS_copy);
2803 // Copy the previous row (different address or source)
2804 Asm->OutStreamer.AddComment("DW_LNS_copy");
2805 Asm->EmitInt8(dwarf::DW_LNS_copy);
2809 emitEndOfLineMatrix(j + 1);
2812 if (SecSrcLinesSize == 0)
2813 // Because we're emitting a debug_line section, we still need a line
2814 // table. The linker and friends expect it to exist. If there's nothing to
2815 // put into it, emit an empty table.
2816 emitEndOfLineMatrix(1);
2818 Asm->OutStreamer.EmitLabel(getTempLabel("line_end"));
2821 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2823 void DwarfDebug::emitCommonDebugFrame() {
2824 if (!MAI->doesDwarfRequireFrameSection())
2828 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2829 TargetFrameInfo::StackGrowsUp ?
2830 TD->getPointerSize() : -TD->getPointerSize();
2832 // Start the dwarf frame section.
2833 Asm->OutStreamer.SwitchSection(
2834 Asm->getObjFileLowering().getDwarfFrameSection());
2836 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common"));
2837 Asm->OutStreamer.AddComment("Length of Common Information Entry");
2838 EmitDifference(getTempLabel("debug_frame_common_end"),
2839 getTempLabel("debug_frame_common_begin"), true);
2841 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_begin"));
2842 Asm->OutStreamer.AddComment("CIE Identifier Tag");
2843 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2844 Asm->OutStreamer.AddComment("CIE Version");
2845 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2846 Asm->OutStreamer.AddComment("CIE Augmentation");
2847 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2848 EmitULEB128(1, "CIE Code Alignment Factor");
2849 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2850 Asm->OutStreamer.AddComment("CIE RA Column");
2851 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2853 std::vector<MachineMove> Moves;
2854 RI->getInitialFrameState(Moves);
2856 EmitFrameMoves(0, Moves, false);
2858 Asm->EmitAlignment(2, 0, 0, false);
2859 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_end"));
2862 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2865 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2866 if (!MAI->doesDwarfRequireFrameSection())
2869 // Start the dwarf frame section.
2870 Asm->OutStreamer.SwitchSection(
2871 Asm->getObjFileLowering().getDwarfFrameSection());
2873 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2874 MCSymbol *DebugFrameBegin =
2875 getDWLabel("debug_frame_begin", DebugFrameInfo.Number);
2876 MCSymbol *DebugFrameEnd =
2877 getDWLabel("debug_frame_end", DebugFrameInfo.Number);
2878 EmitDifference(DebugFrameEnd, DebugFrameBegin, true);
2880 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2882 Asm->OutStreamer.AddComment("FDE CIE offset");
2883 EmitSectionOffset(getTempLabel("debug_frame_common"),
2884 getTempLabel("section_debug_frame"), true);
2886 Asm->OutStreamer.AddComment("FDE initial location");
2887 MCSymbol *FuncBeginSym = getDWLabel("func_begin", DebugFrameInfo.Number);
2888 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2889 TD->getPointerSize(), 0/*AddrSpace*/);
2892 Asm->OutStreamer.AddComment("FDE address range");
2893 EmitDifference(getDWLabel("func_end", DebugFrameInfo.Number), FuncBeginSym);
2895 EmitFrameMoves(FuncBeginSym, DebugFrameInfo.Moves, false);
2897 Asm->EmitAlignment(2, 0, 0, false);
2898 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2901 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2903 void DwarfDebug::emitDebugPubNames() {
2904 // Start the dwarf pubnames section.
2905 Asm->OutStreamer.SwitchSection(
2906 Asm->getObjFileLowering().getDwarfPubNamesSection());
2908 Asm->OutStreamer.AddComment("Length of Public Names Info");
2909 EmitDifference(getDWLabel("pubnames_end", ModuleCU->getID()),
2910 getDWLabel("pubnames_begin", ModuleCU->getID()), true);
2912 Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_begin", ModuleCU->getID()));
2914 Asm->OutStreamer.AddComment("DWARF Version");
2915 Asm->EmitInt16(dwarf::DWARF_VERSION);
2917 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2918 EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2919 getTempLabel("section_info"), true);
2921 Asm->OutStreamer.AddComment("Compilation Unit Length");
2922 EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2923 getDWLabel("info_begin", ModuleCU->getID()),
2926 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2927 for (StringMap<DIE*>::const_iterator
2928 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2929 const char *Name = GI->getKeyData();
2930 DIE *Entity = GI->second;
2932 Asm->OutStreamer.AddComment("DIE offset");
2933 Asm->EmitInt32(Entity->getOffset());
2935 if (Asm->VerboseAsm)
2936 Asm->OutStreamer.AddComment("External Name");
2937 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2940 Asm->OutStreamer.AddComment("End Mark");
2942 Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_end", ModuleCU->getID()));
2945 void DwarfDebug::emitDebugPubTypes() {
2946 // Start the dwarf pubnames section.
2947 Asm->OutStreamer.SwitchSection(
2948 Asm->getObjFileLowering().getDwarfPubTypesSection());
2949 Asm->OutStreamer.AddComment("Length of Public Types Info");
2950 EmitDifference(getDWLabel("pubtypes_end", ModuleCU->getID()),
2951 getDWLabel("pubtypes_begin", ModuleCU->getID()), true);
2953 Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_begin", ModuleCU->getID()));
2955 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2956 Asm->EmitInt16(dwarf::DWARF_VERSION);
2958 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
2959 EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2960 getTempLabel("section_info"), true);
2962 Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
2963 EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2964 getDWLabel("info_begin", ModuleCU->getID()),
2967 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2968 for (StringMap<DIE*>::const_iterator
2969 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2970 const char *Name = GI->getKeyData();
2971 DIE * Entity = GI->second;
2973 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2974 Asm->EmitInt32(Entity->getOffset());
2976 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2977 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2980 Asm->OutStreamer.AddComment("End Mark");
2982 Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_end", ModuleCU->getID()));
2985 /// emitDebugStr - Emit visible names into a debug str section.
2987 void DwarfDebug::emitDebugStr() {
2988 // Check to see if it is worth the effort.
2989 if (StringPool.empty()) return;
2991 // Start the dwarf str section.
2992 Asm->OutStreamer.SwitchSection(
2993 Asm->getObjFileLowering().getDwarfStrSection());
2995 // Get all of the string pool entries and put them in an array by their ID so
2996 // we can sort them.
2997 SmallVector<std::pair<unsigned,
2998 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3000 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3001 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3002 Entries.push_back(std::make_pair(I->second.second, &*I));
3004 array_pod_sort(Entries.begin(), Entries.end());
3006 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3007 // Emit a label for reference from debug information entries.
3008 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3010 // Emit the string itself.
3011 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3015 /// emitDebugLoc - Emit visible names into a debug loc section.
3017 void DwarfDebug::emitDebugLoc() {
3018 // Start the dwarf loc section.
3019 Asm->OutStreamer.SwitchSection(
3020 Asm->getObjFileLowering().getDwarfLocSection());
3023 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3025 void DwarfDebug::EmitDebugARanges() {
3026 // Start the dwarf aranges section.
3027 Asm->OutStreamer.SwitchSection(
3028 Asm->getObjFileLowering().getDwarfARangesSection());
3031 /// emitDebugRanges - Emit visible names into a debug ranges section.
3033 void DwarfDebug::emitDebugRanges() {
3034 // Start the dwarf ranges section.
3035 Asm->OutStreamer.SwitchSection(
3036 Asm->getObjFileLowering().getDwarfRangesSection());
3039 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3041 void DwarfDebug::emitDebugMacInfo() {
3042 if (const MCSection *LineInfo =
3043 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3044 // Start the dwarf macinfo section.
3045 Asm->OutStreamer.SwitchSection(LineInfo);
3049 /// emitDebugInlineInfo - Emit inline info using following format.
3051 /// 1. length of section
3052 /// 2. Dwarf version number
3053 /// 3. address size.
3055 /// Entries (one "entry" for each function that was inlined):
3057 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3058 /// otherwise offset into __debug_str for regular function name.
3059 /// 2. offset into __debug_str section for regular function name.
3060 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3061 /// instances for the function.
3063 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3064 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3065 /// __debug_info section, and the low_pc is the starting address for the
3066 /// inlining instance.
3067 void DwarfDebug::emitDebugInlineInfo() {
3068 if (!MAI->doesDwarfUsesInlineInfoSection())
3074 Asm->OutStreamer.SwitchSection(
3075 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3077 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3078 EmitDifference(getDWLabel("debug_inlined_end", 1),
3079 getDWLabel("debug_inlined_begin", 1), true);
3081 Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_begin", 1));
3083 Asm->OutStreamer.AddComment("Dwarf Version");
3084 Asm->EmitInt16(dwarf::DWARF_VERSION);
3085 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3086 Asm->EmitInt8(TD->getPointerSize());
3088 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3089 E = InlinedSPNodes.end(); I != E; ++I) {
3092 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3093 = InlineInfo.find(Node);
3094 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3095 DISubprogram SP(Node);
3096 StringRef LName = SP.getLinkageName();
3097 StringRef Name = SP.getName();
3099 Asm->OutStreamer.AddComment("MIPS linkage name");
3100 if (LName.empty()) {
3101 Asm->OutStreamer.EmitBytes(Name, 0);
3102 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3104 EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3105 getTempLabel("section_str"), true);
3107 Asm->OutStreamer.AddComment("Function name");
3108 EmitSectionOffset(getStringPoolEntry(Name), getTempLabel("section_str"),
3110 EmitULEB128(Labels.size(), "Inline count");
3112 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3113 LE = Labels.end(); LI != LE; ++LI) {
3114 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
3115 Asm->EmitInt32(LI->second->getOffset());
3117 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("low_pc");
3118 Asm->OutStreamer.EmitSymbolValue(LI->first, TD->getPointerSize(), 0);
3122 Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_end", 1));