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/TargetMachine.h"
28 #include "llvm/Target/TargetRegisterInfo.h"
29 #include "llvm/ADT/STLExtras.h"
30 #include "llvm/ADT/StringExtras.h"
31 #include "llvm/Support/Debug.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/ValueHandle.h"
34 #include "llvm/Support/FormattedStream.h"
35 #include "llvm/Support/Timer.h"
36 #include "llvm/System/Path.h"
39 //===----------------------------------------------------------------------===//
41 /// Configuration values for initial hash set sizes (log2).
43 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
47 //===----------------------------------------------------------------------===//
48 /// CompileUnit - This dwarf writer support class manages information associate
49 /// with a source file.
51 /// ID - File identifier for source.
55 /// Die - Compile unit debug information entry.
57 const OwningPtr<DIE> CUDie;
59 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
62 /// GVToDieMap - Tracks the mapping of unit level debug informaton
63 /// variables to debug information entries.
64 /// FIXME : Rename GVToDieMap -> NodeToDieMap
65 DenseMap<MDNode *, DIE *> GVToDieMap;
67 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
68 /// descriptors to debug information entries using a DIEEntry proxy.
70 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
72 /// Globals - A map of globally visible named entities for this unit.
74 StringMap<DIE*> Globals;
76 /// GlobalTypes - A map of globally visible types for this unit.
78 StringMap<DIE*> GlobalTypes;
81 CompileUnit(unsigned I, DIE *D)
82 : ID(I), CUDie(D), IndexTyDie(0) {}
85 unsigned getID() const { return ID; }
86 DIE* getCUDie() const { return CUDie.get(); }
87 const StringMap<DIE*> &getGlobals() const { return Globals; }
88 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
90 /// hasContent - Return true if this compile unit has something to write out.
92 bool hasContent() const { return !CUDie->getChildren().empty(); }
94 /// addGlobal - Add a new global entity to the compile unit.
96 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
98 /// addGlobalType - Add a new global type to the compile unit.
100 void addGlobalType(StringRef Name, DIE *Die) {
101 GlobalTypes[Name] = Die;
104 /// getDIE - Returns the debug information entry map slot for the
105 /// specified debug variable.
106 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
108 /// insertDIE - Insert DIE into the map.
109 void insertDIE(MDNode *N, DIE *D) {
110 GVToDieMap.insert(std::make_pair(N, D));
113 /// getDIEEntry - Returns the debug information entry for the speciefied
115 DIEEntry *getDIEEntry(MDNode *N) {
116 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
117 if (I == GVToDIEEntryMap.end())
122 /// insertDIEEntry - Insert debug information entry into the map.
123 void insertDIEEntry(MDNode *N, DIEEntry *E) {
124 GVToDIEEntryMap.insert(std::make_pair(N, E));
127 /// addDie - Adds or interns the DIE to the compile unit.
129 void addDie(DIE *Buffer) {
130 this->CUDie->addChild(Buffer);
133 // getIndexTyDie - Get an anonymous type for index type.
134 DIE *getIndexTyDie() {
138 // setIndexTyDie - Set D as anonymous type for index which can be reused
140 void setIndexTyDie(DIE *D) {
146 //===----------------------------------------------------------------------===//
147 /// DbgVariable - This class is used to track local variable information.
150 DIVariable Var; // Variable Descriptor.
151 unsigned FrameIndex; // Variable frame index.
152 const MachineInstr *DbgValueMInsn; // DBG_VALUE
153 // DbgValueLabel - DBG_VALUE is effective from this label.
154 MCSymbol *DbgValueLabel;
155 DbgVariable *const AbstractVar; // Abstract variable for this variable.
158 // AbsVar may be NULL.
159 DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar)
160 : Var(V), FrameIndex(I), DbgValueMInsn(0),
161 DbgValueLabel(0), AbstractVar(AbsVar), TheDIE(0) {}
162 DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar)
163 : Var(V), FrameIndex(0), DbgValueMInsn(MI), DbgValueLabel(0),
164 AbstractVar(AbsVar), TheDIE(0)
168 DIVariable getVariable() const { return Var; }
169 unsigned getFrameIndex() const { return FrameIndex; }
170 const MachineInstr *getDbgValue() const { return DbgValueMInsn; }
171 MCSymbol *getDbgValueLabel() const { return DbgValueLabel; }
172 void setDbgValueLabel(MCSymbol *L) { DbgValueLabel = L; }
173 DbgVariable *getAbstractVariable() const { return AbstractVar; }
174 void setDIE(DIE *D) { TheDIE = D; }
175 DIE *getDIE() const { return TheDIE; }
178 //===----------------------------------------------------------------------===//
179 /// DbgScope - This class is used to track scope information.
182 DbgScope *Parent; // Parent to this scope.
183 DIDescriptor Desc; // Debug info descriptor for scope.
184 // Location at which this scope is inlined.
185 AssertingVH<MDNode> InlinedAtLocation;
186 bool AbstractScope; // Abstract Scope
187 MCSymbol *StartLabel; // Label ID of the beginning of scope.
188 MCSymbol *EndLabel; // Label ID of the end of scope.
189 const MachineInstr *LastInsn; // Last instruction of this scope.
190 const MachineInstr *FirstInsn; // First instruction of this scope.
191 // Scopes defined in scope. Contents not owned.
192 SmallVector<DbgScope *, 4> Scopes;
193 // Variables declared in scope. Contents owned.
194 SmallVector<DbgVariable *, 8> Variables;
196 // Private state for dump()
197 mutable unsigned IndentLevel;
199 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
200 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
201 StartLabel(0), EndLabel(0),
202 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
206 DbgScope *getParent() const { return Parent; }
207 void setParent(DbgScope *P) { Parent = P; }
208 DIDescriptor getDesc() const { return Desc; }
209 MDNode *getInlinedAt() const { return InlinedAtLocation; }
210 MDNode *getScopeNode() const { return Desc.getNode(); }
211 MCSymbol *getStartLabel() const { return StartLabel; }
212 MCSymbol *getEndLabel() const { return EndLabel; }
213 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
214 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
215 void setStartLabel(MCSymbol *S) { StartLabel = S; }
216 void setEndLabel(MCSymbol *E) { EndLabel = E; }
217 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
218 const MachineInstr *getLastInsn() { return LastInsn; }
219 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
220 void setAbstractScope() { AbstractScope = true; }
221 bool isAbstractScope() const { return AbstractScope; }
222 const MachineInstr *getFirstInsn() { return FirstInsn; }
224 /// addScope - Add a scope to the scope.
226 void addScope(DbgScope *S) { Scopes.push_back(S); }
228 /// addVariable - Add a variable to the scope.
230 void addVariable(DbgVariable *V) { Variables.push_back(V); }
232 void fixInstructionMarkers(DenseMap<const MachineInstr *,
233 unsigned> &MIIndexMap) {
234 assert(getFirstInsn() && "First instruction is missing!");
236 // Use the end of last child scope as end of this scope.
237 const SmallVector<DbgScope *, 4> &Scopes = getScopes();
238 const MachineInstr *LastInsn = getFirstInsn();
240 if (Scopes.empty()) {
241 assert(getLastInsn() && "Inner most scope does not have last insn!");
244 for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(),
245 SE = Scopes.end(); SI != SE; ++SI) {
247 DS->fixInstructionMarkers(MIIndexMap);
248 const MachineInstr *DSLastInsn = DS->getLastInsn();
249 unsigned DSI = MIIndexMap[DSLastInsn];
251 LastInsn = DSLastInsn;
256 unsigned CurrentLastInsnIndex = 0;
257 if (const MachineInstr *CL = getLastInsn())
258 CurrentLastInsnIndex = MIIndexMap[CL];
259 unsigned FIndex = MIIndexMap[getFirstInsn()];
261 // Set LastInsn as the last instruction for this scope only if
263 // 1) this scope's first instruction and
264 // 2) current last instruction for this scope, if any.
265 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
266 setLastInsn(LastInsn);
275 void DbgScope::dump() const {
276 raw_ostream &err = dbgs();
277 err.indent(IndentLevel);
278 MDNode *N = Desc.getNode();
280 err << " [" << StartLabel << ", " << EndLabel << "]\n";
282 err << "Abstract Scope\n";
286 err << "Children ...\n";
287 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
288 if (Scopes[i] != this)
295 DbgScope::~DbgScope() {
296 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
300 } // end llvm namespace
302 DwarfDebug::DwarfDebug(AsmPrinter *A)
303 : Asm(A), MMI(Asm->MMI), ModuleCU(0),
304 AbbreviationsSet(InitAbbreviationsSetSize), shouldEmit(false),
305 CurrentFnDbgScope(0), DebugTimer(0) {
306 NextStringPoolNumber = 0;
308 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
309 DwarfStrSectionSym = TextSectionSym = 0;
311 if (TimePassesIsEnabled)
312 DebugTimer = new Timer("Dwarf Debug Writer");
314 DwarfDebug::~DwarfDebug() {
315 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
316 DIEBlocks[j]->~DIEBlock();
321 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
322 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
323 if (Entry.first) return Entry.first;
325 Entry.second = NextStringPoolNumber++;
326 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
330 /// assignAbbrevNumber - Define a unique number for the abbreviation.
332 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
333 // Profile the node so that we can make it unique.
337 // Check the set for priors.
338 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
340 // If it's newly added.
341 if (InSet == &Abbrev) {
342 // Add to abbreviation list.
343 Abbreviations.push_back(&Abbrev);
345 // Assign the vector position + 1 as its number.
346 Abbrev.setNumber(Abbreviations.size());
348 // Assign existing abbreviation number.
349 Abbrev.setNumber(InSet->getNumber());
353 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
354 /// information entry.
355 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
356 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
360 /// addUInt - Add an unsigned integer attribute data and value.
362 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
363 unsigned Form, uint64_t Integer) {
364 if (!Form) Form = DIEInteger::BestForm(false, Integer);
365 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
366 Die->addValue(Attribute, Form, Value);
369 /// addSInt - Add an signed integer attribute data and value.
371 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
372 unsigned Form, int64_t Integer) {
373 if (!Form) Form = DIEInteger::BestForm(true, Integer);
374 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
375 Die->addValue(Attribute, Form, Value);
378 /// addString - Add a string attribute data and value. DIEString only
379 /// keeps string reference.
380 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
382 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
383 Die->addValue(Attribute, Form, Value);
386 /// addLabel - Add a Dwarf label attribute data and value.
388 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
389 const MCSymbol *Label) {
390 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
391 Die->addValue(Attribute, Form, Value);
394 /// addDelta - Add a label delta attribute data and value.
396 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
397 const MCSymbol *Hi, const MCSymbol *Lo) {
398 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
399 Die->addValue(Attribute, Form, Value);
402 /// addBlock - Add block data.
404 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
406 Block->ComputeSize(&Asm->getTargetData());
407 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
408 Die->addValue(Attribute, Block->BestForm(), Block);
411 /// addSourceLine - Add location information to specified debug information
413 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
414 // If there is no compile unit specified, don't add a line #.
415 if (!V->getCompileUnit().Verify())
418 unsigned Line = V->getLineNumber();
419 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
420 V->getContext().getFilename());
421 assert(FileID && "Invalid file id");
422 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
423 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
426 /// addSourceLine - Add location information to specified debug information
428 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
429 // If there is no compile unit specified, don't add a line #.
430 if (!G->getCompileUnit().Verify())
433 unsigned Line = G->getLineNumber();
434 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
435 G->getContext().getFilename());
436 assert(FileID && "Invalid file id");
437 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
438 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
441 /// addSourceLine - Add location information to specified debug information
443 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
444 // If there is no compile unit specified, don't add a line #.
445 if (!SP->getCompileUnit().Verify())
447 // If the line number is 0, don't add it.
448 if (SP->getLineNumber() == 0)
451 unsigned Line = SP->getLineNumber();
452 if (!SP->getContext().Verify())
454 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
456 assert(FileID && "Invalid file id");
457 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
458 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
461 /// addSourceLine - Add location information to specified debug information
463 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
464 // If there is no compile unit specified, don't add a line #.
465 DICompileUnit CU = Ty->getCompileUnit();
469 unsigned Line = Ty->getLineNumber();
470 if (!Ty->getContext().Verify())
472 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
473 Ty->getContext().getFilename());
474 assert(FileID && "Invalid file id");
475 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
476 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
479 /// addSourceLine - Add location information to specified debug information
481 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
482 // If there is no compile unit specified, don't add a line #.
483 if (!NS->getCompileUnit().Verify())
486 unsigned Line = NS->getLineNumber();
487 StringRef FN = NS->getFilename();
488 StringRef Dir = NS->getDirectory();
490 unsigned FileID = GetOrCreateSourceID(Dir, FN);
491 assert(FileID && "Invalid file id");
492 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
493 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
496 /* Byref variables, in Blocks, are declared by the programmer as
497 "SomeType VarName;", but the compiler creates a
498 __Block_byref_x_VarName struct, and gives the variable VarName
499 either the struct, or a pointer to the struct, as its type. This
500 is necessary for various behind-the-scenes things the compiler
501 needs to do with by-reference variables in blocks.
503 However, as far as the original *programmer* is concerned, the
504 variable should still have type 'SomeType', as originally declared.
506 The following function dives into the __Block_byref_x_VarName
507 struct to find the original type of the variable. This will be
508 passed back to the code generating the type for the Debug
509 Information Entry for the variable 'VarName'. 'VarName' will then
510 have the original type 'SomeType' in its debug information.
512 The original type 'SomeType' will be the type of the field named
513 'VarName' inside the __Block_byref_x_VarName struct.
515 NOTE: In order for this to not completely fail on the debugger
516 side, the Debug Information Entry for the variable VarName needs to
517 have a DW_AT_location that tells the debugger how to unwind through
518 the pointers and __Block_byref_x_VarName struct to find the actual
519 value of the variable. The function addBlockByrefType does this. */
521 /// Find the type the programmer originally declared the variable to be
522 /// and return that type.
524 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
527 unsigned tag = Ty.getTag();
529 if (tag == dwarf::DW_TAG_pointer_type) {
530 DIDerivedType DTy = DIDerivedType(Ty.getNode());
531 subType = DTy.getTypeDerivedFrom();
534 DICompositeType blockStruct = DICompositeType(subType.getNode());
535 DIArray Elements = blockStruct.getTypeArray();
537 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
538 DIDescriptor Element = Elements.getElement(i);
539 DIDerivedType DT = DIDerivedType(Element.getNode());
540 if (Name == DT.getName())
541 return (DT.getTypeDerivedFrom());
547 /// addComplexAddress - Start with the address based on the location provided,
548 /// and generate the DWARF information necessary to find the actual variable
549 /// given the extra address information encoded in the DIVariable, starting from
550 /// the starting location. Add the DWARF information to the die.
552 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
554 const MachineLocation &Location) {
555 const DIVariable &VD = DV->getVariable();
556 DIType Ty = VD.getType();
558 // Decode the original location, and use that as the start of the byref
559 // variable's location.
560 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
561 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
562 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
564 if (Location.isReg()) {
566 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
568 Reg = Reg - dwarf::DW_OP_reg0;
569 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
570 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
574 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
576 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
577 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
580 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
583 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
584 uint64_t Element = VD.getAddrElement(i);
586 if (Element == DIFactory::OpPlus) {
587 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
588 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
589 } else if (Element == DIFactory::OpDeref) {
590 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
591 } else llvm_unreachable("unknown DIFactory Opcode");
594 // Now attach the location information to the DIE.
595 addBlock(Die, Attribute, 0, Block);
598 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
599 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
600 gives the variable VarName either the struct, or a pointer to the struct, as
601 its type. This is necessary for various behind-the-scenes things the
602 compiler needs to do with by-reference variables in Blocks.
604 However, as far as the original *programmer* is concerned, the variable
605 should still have type 'SomeType', as originally declared.
607 The function getBlockByrefType dives into the __Block_byref_x_VarName
608 struct to find the original type of the variable, which is then assigned to
609 the variable's Debug Information Entry as its real type. So far, so good.
610 However now the debugger will expect the variable VarName to have the type
611 SomeType. So we need the location attribute for the variable to be an
612 expression that explains to the debugger how to navigate through the
613 pointers and struct to find the actual variable of type SomeType.
615 The following function does just that. We start by getting
616 the "normal" location for the variable. This will be the location
617 of either the struct __Block_byref_x_VarName or the pointer to the
618 struct __Block_byref_x_VarName.
620 The struct will look something like:
622 struct __Block_byref_x_VarName {
624 struct __Block_byref_x_VarName *forwarding;
625 ... <various other fields>
627 ... <maybe more fields>
630 If we are given the struct directly (as our starting point) we
631 need to tell the debugger to:
633 1). Add the offset of the forwarding field.
635 2). Follow that pointer to get the real __Block_byref_x_VarName
636 struct to use (the real one may have been copied onto the heap).
638 3). Add the offset for the field VarName, to find the actual variable.
640 If we started with a pointer to the struct, then we need to
641 dereference that pointer first, before the other steps.
642 Translating this into DWARF ops, we will need to append the following
643 to the current location description for the variable:
645 DW_OP_deref -- optional, if we start with a pointer
646 DW_OP_plus_uconst <forward_fld_offset>
648 DW_OP_plus_uconst <varName_fld_offset>
650 That is what this function does. */
652 /// addBlockByrefAddress - Start with the address based on the location
653 /// provided, and generate the DWARF information necessary to find the
654 /// actual Block variable (navigating the Block struct) based on the
655 /// starting location. Add the DWARF information to the die. For
656 /// more information, read large comment just above here.
658 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
660 const MachineLocation &Location) {
661 const DIVariable &VD = DV->getVariable();
662 DIType Ty = VD.getType();
664 unsigned Tag = Ty.getTag();
665 bool isPointer = false;
667 StringRef varName = VD.getName();
669 if (Tag == dwarf::DW_TAG_pointer_type) {
670 DIDerivedType DTy = DIDerivedType(Ty.getNode());
671 TmpTy = DTy.getTypeDerivedFrom();
675 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
677 // Find the __forwarding field and the variable field in the __Block_byref
679 DIArray Fields = blockStruct.getTypeArray();
680 DIDescriptor varField = DIDescriptor();
681 DIDescriptor forwardingField = DIDescriptor();
683 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
684 DIDescriptor Element = Fields.getElement(i);
685 DIDerivedType DT = DIDerivedType(Element.getNode());
686 StringRef fieldName = DT.getName();
687 if (fieldName == "__forwarding")
688 forwardingField = Element;
689 else if (fieldName == varName)
693 // Get the offsets for the forwarding field and the variable field.
694 unsigned forwardingFieldOffset =
695 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
696 unsigned varFieldOffset =
697 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
699 // Decode the original location, and use that as the start of the byref
700 // variable's location.
701 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
702 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
703 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
705 if (Location.isReg()) {
707 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
709 Reg = Reg - dwarf::DW_OP_reg0;
710 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
711 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
715 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
717 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
718 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
721 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
724 // If we started with a pointer to the __Block_byref... struct, then
725 // the first thing we need to do is dereference the pointer (DW_OP_deref).
727 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
729 // Next add the offset for the '__forwarding' field:
730 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
731 // adding the offset if it's 0.
732 if (forwardingFieldOffset > 0) {
733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
734 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
737 // Now dereference the __forwarding field to get to the real __Block_byref
738 // struct: DW_OP_deref.
739 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
741 // Now that we've got the real __Block_byref... struct, add the offset
742 // for the variable's field to get to the location of the actual variable:
743 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
744 if (varFieldOffset > 0) {
745 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
746 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
749 // Now attach the location information to the DIE.
750 addBlock(Die, Attribute, 0, Block);
753 /// addAddress - Add an address attribute to a die based on the location
755 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
756 const MachineLocation &Location) {
757 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
758 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
759 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
761 if (Location.isReg()) {
763 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
765 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
766 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
770 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
772 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
773 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
776 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
779 addBlock(Die, Attribute, 0, Block);
782 /// addToContextOwner - Add Die into the list of its context owner's children.
783 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
784 if (Context.isType()) {
785 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
786 ContextDIE->addChild(Die);
787 } else if (Context.isNameSpace()) {
788 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
789 ContextDIE->addChild(Die);
790 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
791 ContextDIE->addChild(Die);
793 ModuleCU->addDie(Die);
796 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
798 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
799 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
804 TyDIE = new DIE(dwarf::DW_TAG_base_type);
805 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
806 if (Ty.isBasicType())
807 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
808 else if (Ty.isCompositeType())
809 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
811 assert(Ty.isDerivedType() && "Unknown kind of DIType");
812 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
815 addToContextOwner(TyDIE, Ty.getContext());
819 /// addType - Add a new type attribute to the specified entity.
820 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
824 // Check for pre-existence.
825 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
826 // If it exists then use the existing value.
828 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
833 DIE *Buffer = getOrCreateTypeDIE(Ty);
836 Entry = createDIEEntry(Buffer);
837 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
839 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
842 /// constructTypeDIE - Construct basic type die from DIBasicType.
843 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
844 // Get core information.
845 StringRef Name = BTy.getName();
846 Buffer.setTag(dwarf::DW_TAG_base_type);
847 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
850 // Add name if not anonymous or intermediate type.
852 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
853 uint64_t Size = BTy.getSizeInBits() >> 3;
854 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
857 /// constructTypeDIE - Construct derived type die from DIDerivedType.
858 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
859 // Get core information.
860 StringRef Name = DTy.getName();
861 uint64_t Size = DTy.getSizeInBits() >> 3;
862 unsigned Tag = DTy.getTag();
864 // FIXME - Workaround for templates.
865 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
869 // Map to main type, void will not have a type.
870 DIType FromTy = DTy.getTypeDerivedFrom();
871 addType(&Buffer, FromTy);
873 // Add name if not anonymous or intermediate type.
875 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
877 // Add size if non-zero (derived types might be zero-sized.)
879 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
881 // Add source line info if available and TyDesc is not a forward declaration.
882 if (!DTy.isForwardDecl())
883 addSourceLine(&Buffer, &DTy);
886 /// constructTypeDIE - Construct type DIE from DICompositeType.
887 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
888 // Get core information.
889 StringRef Name = CTy.getName();
891 uint64_t Size = CTy.getSizeInBits() >> 3;
892 unsigned Tag = CTy.getTag();
896 case dwarf::DW_TAG_vector_type:
897 case dwarf::DW_TAG_array_type:
898 constructArrayTypeDIE(Buffer, &CTy);
900 case dwarf::DW_TAG_enumeration_type: {
901 DIArray Elements = CTy.getTypeArray();
903 // Add enumerators to enumeration type.
904 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
906 DIDescriptor Enum(Elements.getElement(i).getNode());
907 if (Enum.isEnumerator()) {
908 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
909 Buffer.addChild(ElemDie);
914 case dwarf::DW_TAG_subroutine_type: {
916 DIArray Elements = CTy.getTypeArray();
917 DIDescriptor RTy = Elements.getElement(0);
918 addType(&Buffer, DIType(RTy.getNode()));
920 // Add prototype flag.
921 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
924 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
925 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
926 DIDescriptor Ty = Elements.getElement(i);
927 addType(Arg, DIType(Ty.getNode()));
928 Buffer.addChild(Arg);
932 case dwarf::DW_TAG_structure_type:
933 case dwarf::DW_TAG_union_type:
934 case dwarf::DW_TAG_class_type: {
935 // Add elements to structure type.
936 DIArray Elements = CTy.getTypeArray();
938 // A forward struct declared type may not have elements available.
939 unsigned N = Elements.getNumElements();
943 // Add elements to structure type.
944 for (unsigned i = 0; i < N; ++i) {
945 DIDescriptor Element = Elements.getElement(i);
947 if (Element.isSubprogram())
948 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
949 else if (Element.isVariable()) {
950 DIVariable DV(Element.getNode());
951 ElemDie = new DIE(dwarf::DW_TAG_variable);
952 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
954 addType(ElemDie, DV.getType());
955 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
956 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
957 addSourceLine(ElemDie, &DV);
958 } else if (Element.isDerivedType())
959 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
962 Buffer.addChild(ElemDie);
965 if (CTy.isAppleBlockExtension())
966 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
968 unsigned RLang = CTy.getRunTimeLang();
970 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
971 dwarf::DW_FORM_data1, RLang);
973 DICompositeType ContainingType = CTy.getContainingType();
974 if (DIDescriptor(ContainingType.getNode()).isCompositeType())
975 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
976 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
983 // Add name if not anonymous or intermediate type.
985 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
987 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
988 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
989 // Add size if non-zero (derived types might be zero-sized.)
991 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
993 // Add zero size if it is not a forward declaration.
994 if (CTy.isForwardDecl())
995 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
997 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1000 // Add source line info if available.
1001 if (!CTy.isForwardDecl())
1002 addSourceLine(&Buffer, &CTy);
1006 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1007 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1008 int64_t L = SR.getLo();
1009 int64_t H = SR.getHi();
1010 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1012 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1014 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1015 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1017 Buffer.addChild(DW_Subrange);
1020 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1021 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1022 DICompositeType *CTy) {
1023 Buffer.setTag(dwarf::DW_TAG_array_type);
1024 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1025 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1027 // Emit derived type.
1028 addType(&Buffer, CTy->getTypeDerivedFrom());
1029 DIArray Elements = CTy->getTypeArray();
1031 // Get an anonymous type for index type.
1032 DIE *IdxTy = ModuleCU->getIndexTyDie();
1034 // Construct an anonymous type for index type.
1035 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1036 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1037 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1038 dwarf::DW_ATE_signed);
1039 ModuleCU->addDie(IdxTy);
1040 ModuleCU->setIndexTyDie(IdxTy);
1043 // Add subranges to array type.
1044 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1045 DIDescriptor Element = Elements.getElement(i);
1046 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1047 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1051 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1052 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1053 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1054 StringRef Name = ETy.getName();
1055 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1056 int64_t Value = ETy.getEnumValue();
1057 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1061 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1062 /// printer to not emit usual symbol prefix before the symbol name is used then
1063 /// return linkage name after skipping this special LLVM prefix.
1064 static StringRef getRealLinkageName(StringRef LinkageName) {
1066 if (LinkageName.startswith(StringRef(&One, 1)))
1067 return LinkageName.substr(1);
1071 /// createGlobalVariableDIE - Create new DIE using GV.
1072 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1073 // If the global variable was optmized out then no need to create debug info
1075 if (!GV.getGlobal()) return NULL;
1076 if (GV.getDisplayName().empty()) return NULL;
1078 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1079 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1080 GV.getDisplayName());
1082 StringRef LinkageName = GV.getLinkageName();
1083 if (!LinkageName.empty())
1084 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1085 getRealLinkageName(LinkageName));
1087 addType(GVDie, GV.getType());
1088 if (!GV.isLocalToUnit())
1089 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1090 addSourceLine(GVDie, &GV);
1095 /// createMemberDIE - Create new member DIE.
1096 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1097 DIE *MemberDie = new DIE(DT.getTag());
1098 StringRef Name = DT.getName();
1100 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1102 addType(MemberDie, DT.getTypeDerivedFrom());
1104 addSourceLine(MemberDie, &DT);
1106 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1107 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1109 uint64_t Size = DT.getSizeInBits();
1110 uint64_t FieldSize = DT.getOriginalTypeSize();
1112 if (Size != FieldSize) {
1114 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1115 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1117 uint64_t Offset = DT.getOffsetInBits();
1118 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1119 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1120 uint64_t FieldOffset = (HiMark - FieldSize);
1121 Offset -= FieldOffset;
1123 // Maybe we need to work from the other end.
1124 if (Asm->getTargetData().isLittleEndian())
1125 Offset = FieldSize - (Offset + Size);
1126 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1128 // Here WD_AT_data_member_location points to the anonymous
1129 // field that includes this bit field.
1130 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1133 // This is not a bitfield.
1134 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1136 if (DT.getTag() == dwarf::DW_TAG_inheritance
1137 && DT.isVirtual()) {
1139 // For C++, virtual base classes are not at fixed offset. Use following
1140 // expression to extract appropriate offset from vtable.
1141 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1143 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1144 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1145 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1146 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1147 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1148 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1149 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1150 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1152 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1155 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1157 if (DT.isProtected())
1158 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1159 dwarf::DW_ACCESS_protected);
1160 else if (DT.isPrivate())
1161 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1162 dwarf::DW_ACCESS_private);
1163 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1164 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1165 dwarf::DW_ACCESS_public);
1167 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1168 dwarf::DW_VIRTUALITY_virtual);
1172 /// createSubprogramDIE - Create new DIE using SP.
1173 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1174 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1178 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1179 // Constructors and operators for anonymous aggregates do not have names.
1180 if (!SP.getName().empty())
1181 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1183 StringRef LinkageName = SP.getLinkageName();
1184 if (!LinkageName.empty())
1185 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1186 getRealLinkageName(LinkageName));
1188 addSourceLine(SPDie, &SP);
1190 // Add prototyped tag, if C or ObjC.
1191 unsigned Lang = SP.getCompileUnit().getLanguage();
1192 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1193 Lang == dwarf::DW_LANG_ObjC)
1194 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1197 DICompositeType SPTy = SP.getType();
1198 DIArray Args = SPTy.getTypeArray();
1199 unsigned SPTag = SPTy.getTag();
1201 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1202 addType(SPDie, SPTy);
1204 addType(SPDie, DIType(Args.getElement(0).getNode()));
1206 unsigned VK = SP.getVirtuality();
1208 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1209 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1210 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1211 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1212 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1213 ContainingTypeMap.insert(std::make_pair(SPDie,
1214 SP.getContainingType().getNode()));
1217 if (MakeDecl || !SP.isDefinition()) {
1218 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1220 // Add arguments. Do not add arguments for subprogram definition. They will
1221 // be handled while processing variables.
1222 DICompositeType SPTy = SP.getType();
1223 DIArray Args = SPTy.getTypeArray();
1224 unsigned SPTag = SPTy.getTag();
1226 if (SPTag == dwarf::DW_TAG_subroutine_type)
1227 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1228 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1229 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1231 if (ATy.isArtificial())
1232 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1233 SPDie->addChild(Arg);
1237 if (SP.isArtificial())
1238 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1240 // DW_TAG_inlined_subroutine may refer to this DIE.
1241 ModuleCU->insertDIE(SP.getNode(), SPDie);
1245 /// getUpdatedDbgScope - Find DbgScope assicated with the instruction.
1246 /// Update scope hierarchy. Create abstract scope if required.
1247 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1248 MDNode *InlinedAt) {
1249 assert(N && "Invalid Scope encoding!");
1250 assert(MI && "Missing machine instruction!");
1251 bool isAConcreteScope = InlinedAt != 0;
1253 DbgScope *NScope = NULL;
1256 NScope = DbgScopeMap.lookup(InlinedAt);
1258 NScope = DbgScopeMap.lookup(N);
1259 assert(NScope && "Unable to find working scope!");
1261 if (NScope->getFirstInsn())
1264 DbgScope *Parent = NULL;
1265 if (isAConcreteScope) {
1266 DILocation IL(InlinedAt);
1267 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1268 IL.getOrigLocation().getNode());
1269 assert(Parent && "Unable to find Parent scope!");
1270 NScope->setParent(Parent);
1271 Parent->addScope(NScope);
1272 } else if (DIDescriptor(N).isLexicalBlock()) {
1273 DILexicalBlock DB(N);
1274 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1275 NScope->setParent(Parent);
1276 Parent->addScope(NScope);
1279 NScope->setFirstInsn(MI);
1281 if (!Parent && !InlinedAt) {
1282 StringRef SPName = DISubprogram(N).getLinkageName();
1283 if (SPName == Asm->MF->getFunction()->getName())
1284 CurrentFnDbgScope = NScope;
1287 if (isAConcreteScope) {
1288 ConcreteScopes[InlinedAt] = NScope;
1289 getOrCreateAbstractScope(N);
1295 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1296 assert(N && "Invalid Scope encoding!");
1298 DbgScope *AScope = AbstractScopes.lookup(N);
1302 DbgScope *Parent = NULL;
1304 DIDescriptor Scope(N);
1305 if (Scope.isLexicalBlock()) {
1306 DILexicalBlock DB(N);
1307 DIDescriptor ParentDesc = DB.getContext();
1308 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1311 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1314 Parent->addScope(AScope);
1315 AScope->setAbstractScope();
1316 AbstractScopes[N] = AScope;
1317 if (DIDescriptor(N).isSubprogram())
1318 AbstractScopesList.push_back(AScope);
1322 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1323 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1324 /// If there are global variables in this scope then create and insert
1325 /// DIEs for these variables.
1326 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1327 DIE *SPDie = ModuleCU->getDIE(SPNode);
1328 assert(SPDie && "Unable to find subprogram DIE!");
1329 DISubprogram SP(SPNode);
1331 // There is not any need to generate specification DIE for a function
1332 // defined at compile unit level. If a function is defined inside another
1333 // function then gdb prefers the definition at top level and but does not
1334 // expect specification DIE in parent function. So avoid creating
1335 // specification DIE for a function defined inside a function.
1336 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1337 !SP.getContext().isFile() && !SP.getContext().isSubprogram()) {
1338 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1341 DICompositeType SPTy = SP.getType();
1342 DIArray Args = SPTy.getTypeArray();
1343 unsigned SPTag = SPTy.getTag();
1344 if (SPTag == dwarf::DW_TAG_subroutine_type)
1345 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1346 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1347 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1349 if (ATy.isArtificial())
1350 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1351 SPDie->addChild(Arg);
1353 DIE *SPDeclDie = SPDie;
1354 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1355 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1357 ModuleCU->addDie(SPDie);
1360 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1361 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1362 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1363 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1364 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1365 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1366 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1368 if (!DISubprogram(SPNode).isLocalToUnit())
1369 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1374 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1375 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1376 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1377 MCSymbol *Start = Scope->getStartLabel();
1378 MCSymbol *End = Scope->getEndLabel();
1379 if (Start == 0 || End == 0) return 0;
1381 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1382 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1384 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1385 if (Scope->isAbstractScope())
1388 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1389 Start ? Start : Asm->GetTempSymbol("func_begin",
1390 Asm->getFunctionNumber()));
1391 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1392 End ? End : Asm->GetTempSymbol("func_end",Asm->getFunctionNumber()));
1397 /// constructInlinedScopeDIE - This scope represents inlined body of
1398 /// a function. Construct DIE to represent this concrete inlined copy
1399 /// of the function.
1400 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1401 MCSymbol *StartLabel = Scope->getStartLabel();
1402 MCSymbol *EndLabel = Scope->getEndLabel();
1403 if (StartLabel == 0 || EndLabel == 0) return 0;
1405 assert(StartLabel->isDefined() &&
1406 "Invalid starting label for an inlined scope!");
1407 assert(EndLabel->isDefined() &&
1408 "Invalid end label for an inlined scope!");
1409 if (!Scope->getScopeNode())
1411 DIScope DS(Scope->getScopeNode());
1412 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1414 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1415 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1416 assert(OriginDIE && "Unable to find Origin DIE!");
1417 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1418 dwarf::DW_FORM_ref4, OriginDIE);
1420 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1421 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1423 InlinedSubprogramDIEs.insert(OriginDIE);
1425 // Track the start label for this inlined function.
1426 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1427 I = InlineInfo.find(InlinedSP.getNode());
1429 if (I == InlineInfo.end()) {
1430 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1432 InlinedSPNodes.push_back(InlinedSP.getNode());
1434 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1436 DILocation DL(Scope->getInlinedAt());
1437 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1438 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1444 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1445 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1446 // Get the descriptor.
1447 const DIVariable &VD = DV->getVariable();
1448 StringRef Name = VD.getName();
1452 // Translate tag to proper Dwarf tag. The result variable is dropped for
1455 switch (VD.getTag()) {
1456 case dwarf::DW_TAG_return_variable:
1458 case dwarf::DW_TAG_arg_variable:
1459 Tag = dwarf::DW_TAG_formal_parameter;
1461 case dwarf::DW_TAG_auto_variable: // fall thru
1463 Tag = dwarf::DW_TAG_variable;
1467 // Define variable debug information entry.
1468 DIE *VariableDie = new DIE(Tag);
1472 if (DbgVariable *AV = DV->getAbstractVariable())
1473 AbsDIE = AV->getDIE();
1476 DIScope DS(Scope->getScopeNode());
1477 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1478 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1480 assert(OriginSPDIE && "Unable to find Origin DIE for the SP!");
1481 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1482 assert(AbsDIE && "Unable to find Origin DIE for the Variable!");
1483 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1484 dwarf::DW_FORM_ref4, AbsDIE);
1487 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1488 addSourceLine(VariableDie, &VD);
1490 // Add variable type.
1491 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1492 // addresses instead.
1493 if (VD.isBlockByrefVariable())
1494 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1496 addType(VariableDie, VD.getType());
1499 // Add variable address.
1500 if (!Scope->isAbstractScope()) {
1501 // Check if variable is described by DBG_VALUE instruction.
1502 if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1503 if (DbgValueInsn->getNumOperands() == 3) {
1504 // FIXME : Handle getNumOperands != 3
1505 if (DbgValueInsn->getOperand(0).getType()
1506 == MachineOperand::MO_Register
1507 && DbgValueInsn->getOperand(0).getReg()) {
1508 MachineLocation Location;
1509 Location.set(DbgValueInsn->getOperand(0).getReg());
1510 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1511 if (MCSymbol *VS = DV->getDbgValueLabel())
1512 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1514 } else if (DbgValueInsn->getOperand(0).getType() ==
1515 MachineOperand::MO_Immediate) {
1516 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1517 unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1518 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1519 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1520 if (MCSymbol *VS = DV->getDbgValueLabel())
1521 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1524 //FIXME : Handle other operand types.
1530 MachineLocation Location;
1532 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1533 int Offset = RI->getFrameIndexReference(*Asm->MF, DV->getFrameIndex(),
1535 Location.set(FrameReg, Offset);
1537 if (VD.hasComplexAddress())
1538 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1539 else if (VD.isBlockByrefVariable())
1540 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1542 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1546 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1547 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1548 DV->setDIE(VariableDie);
1553 void DwarfDebug::addPubTypes(DISubprogram SP) {
1554 DICompositeType SPTy = SP.getType();
1555 unsigned SPTag = SPTy.getTag();
1556 if (SPTag != dwarf::DW_TAG_subroutine_type)
1559 DIArray Args = SPTy.getTypeArray();
1560 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1561 DIType ATy(Args.getElement(i).getNode());
1564 DICompositeType CATy = getDICompositeType(ATy);
1565 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1566 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1567 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1572 /// constructScopeDIE - Construct a DIE for this scope.
1573 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1574 if (!Scope || !Scope->getScopeNode())
1577 DIScope DS(Scope->getScopeNode());
1578 DIE *ScopeDIE = NULL;
1579 if (Scope->getInlinedAt())
1580 ScopeDIE = constructInlinedScopeDIE(Scope);
1581 else if (DS.isSubprogram()) {
1582 if (Scope->isAbstractScope())
1583 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1585 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1588 ScopeDIE = constructLexicalScopeDIE(Scope);
1589 if (!ScopeDIE) return NULL;
1591 // Add variables to scope.
1592 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1593 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1594 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1596 ScopeDIE->addChild(VariableDIE);
1599 // Add nested scopes.
1600 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1601 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1602 // Define the Scope debug information entry.
1603 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1605 ScopeDIE->addChild(NestedDIE);
1608 if (DS.isSubprogram())
1609 addPubTypes(DISubprogram(DS.getNode()));
1614 /// GetOrCreateSourceID - Look up the source id with the given directory and
1615 /// source file names. If none currently exists, create a new id and insert it
1616 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1618 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1620 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1621 if (DI != DirectoryIdMap.end()) {
1622 DId = DI->getValue();
1624 DId = DirectoryNames.size() + 1;
1625 DirectoryIdMap[DirName] = DId;
1626 DirectoryNames.push_back(DirName);
1630 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1631 if (FI != SourceFileIdMap.end()) {
1632 FId = FI->getValue();
1634 FId = SourceFileNames.size() + 1;
1635 SourceFileIdMap[FileName] = FId;
1636 SourceFileNames.push_back(FileName);
1639 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1640 SourceIdMap.find(std::make_pair(DId, FId));
1641 if (SI != SourceIdMap.end())
1644 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1645 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1646 SourceIds.push_back(std::make_pair(DId, FId));
1651 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1652 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1653 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1656 NDie = new DIE(dwarf::DW_TAG_namespace);
1657 ModuleCU->insertDIE(NS.getNode(), NDie);
1658 if (!NS.getName().empty())
1659 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1660 addSourceLine(NDie, &NS);
1661 addToContextOwner(NDie, NS.getContext());
1665 void DwarfDebug::constructCompileUnit(MDNode *N) {
1666 DICompileUnit DIUnit(N);
1667 // Use first compile unit marked as isMain as the compile unit for this
1669 if (ModuleCU || !DIUnit.isMain())
1671 StringRef FN = DIUnit.getFilename();
1672 StringRef Dir = DIUnit.getDirectory();
1673 unsigned ID = GetOrCreateSourceID(Dir, FN);
1675 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1676 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1677 DIUnit.getProducer());
1678 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1679 DIUnit.getLanguage());
1680 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1681 addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, TextSectionSym);
1682 addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1683 Asm->GetTempSymbol("text_end"));
1684 // DW_AT_stmt_list is a offset of line number information for this
1685 // compile unit in debug_line section. It is always zero when only one
1686 // compile unit is emitted in one object file.
1687 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1690 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1691 if (DIUnit.isOptimized())
1692 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1694 StringRef Flags = DIUnit.getFlags();
1696 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1698 unsigned RVer = DIUnit.getRunTimeVersion();
1700 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1701 dwarf::DW_FORM_data1, RVer);
1704 "ModuleCU assigned since the top of constructCompileUnit");
1705 ModuleCU = new CompileUnit(ID, Die);
1708 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1709 DIGlobalVariable DI_GV(N);
1711 // If debug information is malformed then ignore it.
1712 if (DI_GV.Verify() == false)
1715 // Check for pre-existence.
1716 if (ModuleCU->getDIE(DI_GV.getNode()))
1719 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1724 ModuleCU->insertDIE(N, VariableDie);
1726 // Add to context owner.
1727 DIDescriptor GVContext = DI_GV.getContext();
1728 // Do not create specification DIE if context is either compile unit
1730 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1731 !GVContext.isFile() && !GVContext.isSubprogram()) {
1732 // Create specification DIE.
1733 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1734 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1735 dwarf::DW_FORM_ref4, VariableDie);
1736 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1737 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1738 addLabel(Block, 0, dwarf::DW_FORM_udata,
1739 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1740 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1741 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1742 ModuleCU->addDie(VariableSpecDIE);
1744 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1745 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1746 addLabel(Block, 0, dwarf::DW_FORM_udata,
1747 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1748 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1750 addToContextOwner(VariableDie, GVContext);
1752 // Expose as global. FIXME - need to check external flag.
1753 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1755 DIType GTy = DI_GV.getType();
1756 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1757 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1758 assert(Entry && "Missing global type!");
1759 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1764 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1767 // Check for pre-existence.
1768 if (ModuleCU->getDIE(N))
1771 if (!SP.isDefinition())
1772 // This is a method declaration which will be handled while constructing
1776 DIE *SubprogramDie = createSubprogramDIE(SP);
1779 ModuleCU->insertDIE(N, SubprogramDie);
1781 // Add to context owner.
1782 addToContextOwner(SubprogramDie, SP.getContext());
1784 // Expose as global.
1785 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1790 /// beginModule - Emit all Dwarf sections that should come prior to the
1791 /// content. Create global DIEs and emit initial debug info sections.
1792 /// This is inovked by the target AsmPrinter.
1793 void DwarfDebug::beginModule(Module *M) {
1794 if (!Asm->MAI->doesSupportDebugInformation())
1797 TimeRegion Timer(DebugTimer);
1799 DebugInfoFinder DbgFinder;
1800 DbgFinder.processModule(*M);
1802 // Emit initial sections.
1803 if (DbgFinder.compile_unit_begin() != DbgFinder.compile_unit_end())
1804 EmitSectionLabels();
1806 // Create all the compile unit DIEs.
1807 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1808 E = DbgFinder.compile_unit_end(); I != E; ++I)
1809 constructCompileUnit(*I);
1814 // Create DIEs for each subprogram.
1815 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1816 E = DbgFinder.subprogram_end(); I != E; ++I)
1817 constructSubprogramDIE(*I);
1819 // Create DIEs for each global variable.
1820 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1821 E = DbgFinder.global_variable_end(); I != E; ++I)
1822 constructGlobalVariableDIE(*I);
1826 MMI->setDebugInfoAvailability(true);
1828 // Prime section data.
1829 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1831 // Print out .file directives to specify files for .loc directives. These are
1832 // printed out early so that they precede any .loc directives.
1833 if (Asm->MAI->hasDotLocAndDotFile()) {
1834 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1835 // Remember source id starts at 1.
1836 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1837 // FIXME: don't use sys::path for this! This should not depend on the
1839 sys::Path FullPath(getSourceDirectoryName(Id.first));
1841 FullPath.appendComponent(getSourceFileName(Id.second));
1842 assert(AppendOk && "Could not append filename to directory!");
1844 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1849 /// endModule - Emit all Dwarf sections that should come after the content.
1851 void DwarfDebug::endModule() {
1855 TimeRegion Timer(DebugTimer);
1857 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1858 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1859 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1861 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1864 // Insert top level DIEs.
1865 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1866 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1867 ModuleCU->getCUDie()->addChild(*TI);
1869 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1870 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1871 DIE *SPDie = CI->first;
1872 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1874 DIE *NDie = ModuleCU->getDIE(N);
1875 if (!NDie) continue;
1876 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1877 // FIXME - This is not the correct approach.
1878 //addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie
1881 // Standard sections final addresses.
1882 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1883 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1884 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1885 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1887 // End text sections.
1888 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1889 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1890 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1893 // Emit common frame information.
1894 emitCommonDebugFrame();
1896 // Emit function debug frame information
1897 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1898 E = DebugFrames.end(); I != E; ++I)
1899 emitFunctionDebugFrame(*I);
1901 // Compute DIE offsets and sizes.
1902 computeSizeAndOffsets();
1904 // Emit all the DIEs into a debug info section
1907 // Corresponding abbreviations into a abbrev section.
1908 emitAbbreviations();
1910 // Emit source line correspondence into a debug line section.
1913 // Emit info into a debug pubnames section.
1914 emitDebugPubNames();
1916 // Emit info into a debug pubtypes section.
1917 emitDebugPubTypes();
1919 // Emit info into a debug loc section.
1922 // Emit info into a debug aranges section.
1925 // Emit info into a debug ranges section.
1928 // Emit info into a debug macinfo section.
1931 // Emit inline info.
1932 emitDebugInlineInfo();
1934 // Emit info into a debug str section.
1938 ModuleCU = NULL; // Reset for the next Module, if any.
1941 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1942 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1944 DebugLoc ScopeLoc) {
1946 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1948 return AbsDbgVariable;
1950 LLVMContext &Ctx = Var.getNode()->getContext();
1951 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1955 AbsDbgVariable = new DbgVariable(Var, FrameIdx,
1956 NULL /* No more-abstract variable*/);
1957 Scope->addVariable(AbsDbgVariable);
1958 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1959 return AbsDbgVariable;
1962 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1963 /// FIXME : Refactor findAbstractVariable.
1964 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1965 const MachineInstr *MI,
1966 DebugLoc ScopeLoc) {
1968 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1970 return AbsDbgVariable;
1972 LLVMContext &Ctx = Var.getNode()->getContext();
1973 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1977 AbsDbgVariable = new DbgVariable(Var, MI,
1978 NULL /* No more-abstract variable*/);
1979 Scope->addVariable(AbsDbgVariable);
1980 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1981 DbgValueStartMap[MI] = AbsDbgVariable;
1982 return AbsDbgVariable;
1985 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1986 void DwarfDebug::collectVariableInfo() {
1989 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1991 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1992 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1993 VE = VMap.end(); VI != VE; ++VI) {
1994 MDNode *Var = VI->first;
1997 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1999 DbgScope *Scope = 0;
2000 if (MDNode *IA = VP.second.getInlinedAt(Ctx))
2001 Scope = ConcreteScopes.lookup(IA);
2003 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2005 // If variable scope is not found then skip this variable.
2009 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second);
2010 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
2011 Scope->addVariable(RegVar);
2014 // Collect variable information from DBG_VALUE machine instructions;
2015 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2017 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2019 const MachineInstr *MInsn = II;
2020 if (!MInsn->isDebugValue())
2023 // FIXME : Lift this restriction.
2024 if (MInsn->getNumOperands() != 3)
2026 DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands()
2027 - 1).getMetadata()));
2028 if (DV.getTag() == dwarf::DW_TAG_arg_variable) {
2029 // FIXME Handle inlined subroutine arguments.
2030 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2031 CurrentFnDbgScope->addVariable(ArgVar);
2032 DbgValueStartMap[MInsn] = ArgVar;
2036 DebugLoc DL = MInsn->getDebugLoc();
2037 if (DL.isUnknown()) continue;
2038 DbgScope *Scope = 0;
2039 if (MDNode *IA = DL.getInlinedAt(Ctx))
2040 Scope = ConcreteScopes.lookup(IA);
2042 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2044 // If variable scope is not found then skip this variable.
2048 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL);
2049 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2050 DbgValueStartMap[MInsn] = RegVar;
2051 Scope->addVariable(RegVar);
2056 /// beginScope - Process beginning of a scope.
2057 void DwarfDebug::beginScope(const MachineInstr *MI) {
2059 DebugLoc DL = MI->getDebugLoc();
2063 // Check and update last known location info.
2064 if (DL == PrevInstLoc)
2067 MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2069 // FIXME: Should only verify each scope once!
2070 if (!DIScope(Scope).Verify())
2073 // DBG_VALUE instruction establishes new value.
2074 if (MI->isDebugValue()) {
2075 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2076 = DbgValueStartMap.find(MI);
2077 if (DI != DbgValueStartMap.end()) {
2078 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2080 DI->second->setDbgValueLabel(Label);
2085 // Emit a label to indicate location change. This is used for line
2086 // table even if this instruction does start a new scope.
2087 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2090 // update DbgScope if this instruction starts a new scope.
2091 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2092 if (I == DbgScopeBeginMap.end())
2095 ScopeVector &SD = I->second;
2096 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
2098 (*SDI)->setStartLabel(Label);
2101 /// endScope - Process end of a scope.
2102 void DwarfDebug::endScope(const MachineInstr *MI) {
2103 // Ignore DBG_VALUE instruction.
2104 if (MI->isDebugValue())
2108 DebugLoc DL = MI->getDebugLoc();
2112 // Emit a label and update DbgScope if this instruction ends a scope.
2113 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2114 if (I == DbgScopeEndMap.end())
2117 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2118 Asm->OutStreamer.EmitLabel(Label);
2120 SmallVector<DbgScope*, 2> &SD = I->second;
2121 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2123 (*SDI)->setEndLabel(Label);
2127 /// createDbgScope - Create DbgScope for the scope.
2128 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2130 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2133 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2134 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2135 if (DIDescriptor(Scope).isLexicalBlock())
2136 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2140 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2144 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2145 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2146 DILocation DL(InlinedAt);
2147 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2150 /// extractScopeInformation - Scan machine instructions in this function
2151 /// and collect DbgScopes. Return true, if at least one scope was found.
2152 bool DwarfDebug::extractScopeInformation() {
2153 // If scope information was extracted using .dbg intrinsics then there is not
2154 // any need to extract these information by scanning each instruction.
2155 if (!DbgScopeMap.empty())
2158 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2159 unsigned MIIndex = 0;
2160 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2162 // Scan each instruction and create scopes. First build working set of scopes.
2163 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2165 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2167 const MachineInstr *MInsn = II;
2168 // FIXME : Remove DBG_VALUE check.
2169 if (MInsn->isDebugValue()) continue;
2170 MIIndexMap[MInsn] = MIIndex++;
2172 DebugLoc DL = MInsn->getDebugLoc();
2173 if (DL.isUnknown()) continue;
2175 MDNode *Scope = DL.getScope(Ctx);
2177 // There is no need to create another DIE for compile unit. For all
2178 // other scopes, create one DbgScope now. This will be translated
2179 // into a scope DIE at the end.
2180 if (DIScope(Scope).isCompileUnit()) continue;
2181 createDbgScope(Scope, DL.getInlinedAt(Ctx));
2186 // Build scope hierarchy using working set of scopes.
2187 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2189 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2191 const MachineInstr *MInsn = II;
2192 // FIXME : Remove DBG_VALUE check.
2193 if (MInsn->isDebugValue()) continue;
2194 DebugLoc DL = MInsn->getDebugLoc();
2195 if (DL.isUnknown()) continue;
2197 MDNode *Scope = DL.getScope(Ctx);
2198 if (Scope == 0) continue;
2200 // There is no need to create another DIE for compile unit. For all
2201 // other scopes, create one DbgScope now. This will be translated
2202 // into a scope DIE at the end.
2203 if (DIScope(Scope).isCompileUnit()) continue;
2204 DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx));
2205 DScope->setLastInsn(MInsn);
2209 if (!CurrentFnDbgScope)
2212 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2214 // Each scope has first instruction and last instruction to mark beginning
2215 // and end of a scope respectively. Create an inverse map that list scopes
2216 // starts (and ends) with an instruction. One instruction may start (or end)
2217 // multiple scopes. Ignore scopes that are not reachable.
2218 SmallVector<DbgScope *, 4> WorkList;
2219 WorkList.push_back(CurrentFnDbgScope);
2220 while (!WorkList.empty()) {
2221 DbgScope *S = WorkList.pop_back_val();
2223 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2224 if (!Children.empty())
2225 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2226 SE = Children.end(); SI != SE; ++SI)
2227 WorkList.push_back(*SI);
2229 if (S->isAbstractScope())
2231 const MachineInstr *MI = S->getFirstInsn();
2232 assert(MI && "DbgScope does not have first instruction!");
2234 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2235 if (IDI != DbgScopeBeginMap.end())
2236 IDI->second.push_back(S);
2238 DbgScopeBeginMap[MI].push_back(S);
2240 MI = S->getLastInsn();
2241 assert(MI && "DbgScope does not have last instruction!");
2242 IDI = DbgScopeEndMap.find(MI);
2243 if (IDI != DbgScopeEndMap.end())
2244 IDI->second.push_back(S);
2246 DbgScopeEndMap[MI].push_back(S);
2249 return !DbgScopeMap.empty();
2252 /// beginFunction - Gather pre-function debug information. Assumes being
2253 /// emitted immediately after the function entry point.
2254 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2255 if (!ShouldEmitDwarfDebug()) return;
2257 TimeRegion Timer(DebugTimer);
2258 if (!extractScopeInformation())
2261 collectVariableInfo();
2263 // Assumes in correct section after the entry point.
2264 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_begin",
2265 Asm->getFunctionNumber()));
2267 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2269 DebugLoc FDL = MF->getDefaultDebugLoc();
2270 if (FDL.isUnknown()) return;
2272 MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2274 DISubprogram SP = getDISubprogram(Scope);
2277 Line = SP.getLineNumber();
2280 Line = FDL.getLine();
2284 recordSourceLine(Line, Col, Scope);
2287 /// endFunction - Gather and emit post-function debug information.
2289 void DwarfDebug::endFunction(const MachineFunction *MF) {
2290 if (!ShouldEmitDwarfDebug()) return;
2291 if (DbgScopeMap.empty()) return;
2293 TimeRegion Timer(DebugTimer);
2295 if (CurrentFnDbgScope) {
2296 // Define end label for subprogram.
2297 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2298 Asm->getFunctionNumber()));
2300 // Get function line info.
2301 if (!Lines.empty()) {
2302 // Get section line info.
2303 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2304 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2305 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2306 // Append the function info to section info.
2307 SectionLineInfos.insert(SectionLineInfos.end(),
2308 Lines.begin(), Lines.end());
2311 // Construct abstract scopes.
2312 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2313 AE = AbstractScopesList.end(); AI != AE; ++AI)
2314 constructScopeDIE(*AI);
2316 constructScopeDIE(CurrentFnDbgScope);
2318 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2319 MMI->getFrameMoves()));
2323 CurrentFnDbgScope = NULL;
2324 DeleteContainerSeconds(DbgScopeMap);
2325 DbgScopeBeginMap.clear();
2326 DbgScopeEndMap.clear();
2327 DbgValueStartMap.clear();
2328 ConcreteScopes.clear();
2329 DeleteContainerSeconds(AbstractScopes);
2330 AbstractScopesList.clear();
2331 AbstractVariables.clear();
2335 /// recordSourceLine - Register a source line with debug info. Returns the
2336 /// unique label that was emitted and which provides correspondence to
2337 /// the source line list.
2338 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2342 TimeRegion Timer(DebugTimer);
2347 DIDescriptor Scope(S);
2348 if (Scope.isCompileUnit()) {
2349 DICompileUnit CU(S);
2350 Dir = CU.getDirectory();
2351 Fn = CU.getFilename();
2352 } else if (Scope.isSubprogram()) {
2354 Dir = SP.getDirectory();
2355 Fn = SP.getFilename();
2356 } else if (Scope.isLexicalBlock()) {
2357 DILexicalBlock DB(S);
2358 Dir = DB.getDirectory();
2359 Fn = DB.getFilename();
2361 assert(0 && "Unexpected scope info");
2363 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2364 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2365 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2367 Asm->OutStreamer.EmitLabel(Label);
2371 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2372 /// timed. Look up the source id with the given directory and source file
2373 /// names. If none currently exists, create a new id and insert it in the
2374 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2376 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2377 const std::string &FileName) {
2378 TimeRegion Timer(DebugTimer);
2379 return GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2382 //===----------------------------------------------------------------------===//
2384 //===----------------------------------------------------------------------===//
2386 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2389 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2390 // Get the children.
2391 const std::vector<DIE *> &Children = Die->getChildren();
2393 // If not last sibling and has children then add sibling offset attribute.
2394 if (!Last && !Children.empty())
2395 Die->addSiblingOffset(DIEValueAllocator);
2397 // Record the abbreviation.
2398 assignAbbrevNumber(Die->getAbbrev());
2400 // Get the abbreviation for this DIE.
2401 unsigned AbbrevNumber = Die->getAbbrevNumber();
2402 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2405 Die->setOffset(Offset);
2407 // Start the size with the size of abbreviation code.
2408 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2410 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2411 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2413 // Size the DIE attribute values.
2414 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2415 // Size attribute value.
2416 Offset += Values[i]->SizeOf(&Asm->getTargetData(), AbbrevData[i].getForm());
2418 // Size the DIE children if any.
2419 if (!Children.empty()) {
2420 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2421 "Children flag not set");
2423 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2424 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2426 // End of children marker.
2427 Offset += sizeof(int8_t);
2430 Die->setSize(Offset - Die->getOffset());
2434 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2436 void DwarfDebug::computeSizeAndOffsets() {
2437 // Compute size of compile unit header.
2438 static unsigned Offset =
2439 sizeof(int32_t) + // Length of Compilation Unit Info
2440 sizeof(int16_t) + // DWARF version number
2441 sizeof(int32_t) + // Offset Into Abbrev. Section
2442 sizeof(int8_t); // Pointer Size (in bytes)
2444 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2445 CompileUnitOffsets[ModuleCU] = 0;
2448 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2449 /// temporary label to it if SymbolStem is specified.
2450 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2451 const char *SymbolStem = 0) {
2452 Asm->OutStreamer.SwitchSection(Section);
2453 if (!SymbolStem) return 0;
2455 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2456 Asm->OutStreamer.EmitLabel(TmpSym);
2460 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2461 /// the start of each one.
2462 void DwarfDebug::EmitSectionLabels() {
2463 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2465 // Dwarf sections base addresses.
2466 if (Asm->MAI->doesDwarfRequireFrameSection()) {
2467 DwarfFrameSectionSym =
2468 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2471 DwarfInfoSectionSym =
2472 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2473 DwarfAbbrevSectionSym =
2474 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2475 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2477 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2478 EmitSectionSym(Asm, MacroInfo);
2480 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2481 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2482 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2483 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2484 DwarfStrSectionSym =
2485 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2486 EmitSectionSym(Asm, TLOF.getDwarfRangesSection());
2488 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2489 EmitSectionSym(Asm, TLOF.getDataSection());
2492 /// emitDIE - Recusively Emits a debug information entry.
2494 void DwarfDebug::emitDIE(DIE *Die) {
2495 // Get the abbreviation for this DIE.
2496 unsigned AbbrevNumber = Die->getAbbrevNumber();
2497 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2499 // Emit the code (index) for the abbreviation.
2500 if (Asm->isVerbose())
2501 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2502 Twine::utohexstr(Die->getOffset()) + ":0x" +
2503 Twine::utohexstr(Die->getSize()) + " " +
2504 dwarf::TagString(Abbrev->getTag()));
2505 Asm->EmitULEB128(AbbrevNumber);
2507 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2508 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2510 // Emit the DIE attribute values.
2511 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2512 unsigned Attr = AbbrevData[i].getAttribute();
2513 unsigned Form = AbbrevData[i].getForm();
2514 assert(Form && "Too many attributes for DIE (check abbreviation)");
2516 if (Asm->isVerbose())
2517 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2520 case dwarf::DW_AT_sibling:
2521 Asm->EmitInt32(Die->getSiblingOffset());
2523 case dwarf::DW_AT_abstract_origin: {
2524 DIEEntry *E = cast<DIEEntry>(Values[i]);
2525 DIE *Origin = E->getEntry();
2526 unsigned Addr = Origin->getOffset();
2527 Asm->EmitInt32(Addr);
2531 // Emit an attribute using the defined form.
2532 Values[i]->EmitValue(Asm, Form);
2537 // Emit the DIE children if any.
2538 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2539 const std::vector<DIE *> &Children = Die->getChildren();
2541 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2542 emitDIE(Children[j]);
2544 if (Asm->isVerbose())
2545 Asm->OutStreamer.AddComment("End Of Children Mark");
2550 /// emitDebugInfo - Emit the debug info section.
2552 void DwarfDebug::emitDebugInfo() {
2553 // Start debug info section.
2554 Asm->OutStreamer.SwitchSection(
2555 Asm->getObjFileLowering().getDwarfInfoSection());
2556 DIE *Die = ModuleCU->getCUDie();
2558 // Emit the compile units header.
2559 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2560 ModuleCU->getID()));
2562 // Emit size of content not including length itself
2563 unsigned ContentSize = Die->getSize() +
2564 sizeof(int16_t) + // DWARF version number
2565 sizeof(int32_t) + // Offset Into Abbrev. Section
2566 sizeof(int8_t) + // Pointer Size (in bytes)
2567 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2569 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2570 Asm->EmitInt32(ContentSize);
2571 Asm->OutStreamer.AddComment("DWARF version number");
2572 Asm->EmitInt16(dwarf::DWARF_VERSION);
2573 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2574 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2575 DwarfAbbrevSectionSym);
2576 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2577 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2580 // FIXME - extra padding for gdb bug.
2581 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2586 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", ModuleCU->getID()));
2589 /// emitAbbreviations - Emit the abbreviation section.
2591 void DwarfDebug::emitAbbreviations() const {
2592 // Check to see if it is worth the effort.
2593 if (!Abbreviations.empty()) {
2594 // Start the debug abbrev section.
2595 Asm->OutStreamer.SwitchSection(
2596 Asm->getObjFileLowering().getDwarfAbbrevSection());
2598 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2600 // For each abbrevation.
2601 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2602 // Get abbreviation data
2603 const DIEAbbrev *Abbrev = Abbreviations[i];
2605 // Emit the abbrevations code (base 1 index.)
2606 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2608 // Emit the abbreviations data.
2612 // Mark end of abbreviations.
2613 Asm->EmitULEB128(0, "EOM(3)");
2615 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2619 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2620 /// the line matrix.
2622 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2623 // Define last address of section.
2624 Asm->OutStreamer.AddComment("Extended Op");
2627 Asm->OutStreamer.AddComment("Op size");
2628 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2629 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2630 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2632 Asm->OutStreamer.AddComment("Section end label");
2634 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2635 Asm->getTargetData().getPointerSize(),
2638 // Mark end of matrix.
2639 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2645 /// emitDebugLines - Emit source line information.
2647 void DwarfDebug::emitDebugLines() {
2648 // If the target is using .loc/.file, the assembler will be emitting the
2649 // .debug_line table automatically.
2650 if (Asm->MAI->hasDotLocAndDotFile())
2653 // Minimum line delta, thus ranging from -10..(255-10).
2654 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2655 // Maximum line delta, thus ranging from -10..(255-10).
2656 const int MaxLineDelta = 255 + MinLineDelta;
2658 // Start the dwarf line section.
2659 Asm->OutStreamer.SwitchSection(
2660 Asm->getObjFileLowering().getDwarfLineSection());
2662 // Construct the section header.
2663 Asm->OutStreamer.AddComment("Length of Source Line Info");
2664 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2665 Asm->GetTempSymbol("line_begin"), 4);
2666 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
2668 Asm->OutStreamer.AddComment("DWARF version number");
2669 Asm->EmitInt16(dwarf::DWARF_VERSION);
2671 Asm->OutStreamer.AddComment("Prolog Length");
2672 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2673 Asm->GetTempSymbol("line_prolog_begin"), 4);
2674 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
2676 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2678 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2680 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2681 Asm->EmitInt8(MinLineDelta);
2682 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2683 Asm->EmitInt8(MaxLineDelta);
2684 Asm->OutStreamer.AddComment("Special Opcode Base");
2685 Asm->EmitInt8(-MinLineDelta);
2687 // Line number standard opcode encodings argument count
2688 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2690 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2692 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2694 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2696 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2698 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2700 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2702 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2704 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2707 // Emit directories.
2708 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2709 const std::string &Dir = getSourceDirectoryName(DI);
2710 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
2711 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2714 Asm->OutStreamer.AddComment("End of directories");
2718 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2719 // Remember source id starts at 1.
2720 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2721 const std::string &FN = getSourceFileName(Id.second);
2722 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
2723 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2725 Asm->EmitULEB128(Id.first, "Directory #");
2726 Asm->EmitULEB128(0, "Mod date");
2727 Asm->EmitULEB128(0, "File size");
2730 Asm->OutStreamer.AddComment("End of files");
2733 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
2735 // A sequence for each text section.
2736 unsigned SecSrcLinesSize = SectionSourceLines.size();
2738 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2739 // Isolate current sections line info.
2740 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2742 // Dwarf assumes we start with first line of first source file.
2743 unsigned Source = 1;
2746 // Construct rows of the address, source, line, column matrix.
2747 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2748 const SrcLineInfo &LineInfo = LineInfos[i];
2749 MCSymbol *Label = LineInfo.getLabel();
2750 if (!Label->isDefined()) continue; // Not emitted, in dead code.
2752 if (LineInfo.getLine() == 0) continue;
2754 if (Asm->isVerbose()) {
2755 std::pair<unsigned, unsigned> SrcID =
2756 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2757 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2759 Twine(getSourceFileName(SrcID.second)) +
2760 ":" + Twine(LineInfo.getLine()));
2763 // Define the line address.
2764 Asm->OutStreamer.AddComment("Extended Op");
2766 Asm->OutStreamer.AddComment("Op size");
2767 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2769 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2770 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2772 Asm->OutStreamer.AddComment("Location label");
2773 Asm->OutStreamer.EmitSymbolValue(Label,
2774 Asm->getTargetData().getPointerSize(),
2777 // If change of source, then switch to the new source.
2778 if (Source != LineInfo.getSourceID()) {
2779 Source = LineInfo.getSourceID();
2780 Asm->OutStreamer.AddComment("DW_LNS_set_file");
2781 Asm->EmitInt8(dwarf::DW_LNS_set_file);
2782 Asm->EmitULEB128(Source, "New Source");
2785 // If change of line.
2786 if (Line != LineInfo.getLine()) {
2787 // Determine offset.
2788 int Offset = LineInfo.getLine() - Line;
2789 int Delta = Offset - MinLineDelta;
2792 Line = LineInfo.getLine();
2794 // If delta is small enough and in range...
2795 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2796 // ... then use fast opcode.
2797 Asm->OutStreamer.AddComment("Line Delta");
2798 Asm->EmitInt8(Delta - MinLineDelta);
2800 // ... otherwise use long hand.
2801 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2802 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2803 Asm->EmitSLEB128(Offset, "Line Offset");
2804 Asm->OutStreamer.AddComment("DW_LNS_copy");
2805 Asm->EmitInt8(dwarf::DW_LNS_copy);
2808 // Copy the previous row (different address or source)
2809 Asm->OutStreamer.AddComment("DW_LNS_copy");
2810 Asm->EmitInt8(dwarf::DW_LNS_copy);
2814 emitEndOfLineMatrix(j + 1);
2817 if (SecSrcLinesSize == 0)
2818 // Because we're emitting a debug_line section, we still need a line
2819 // table. The linker and friends expect it to exist. If there's nothing to
2820 // put into it, emit an empty table.
2821 emitEndOfLineMatrix(1);
2823 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
2826 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2828 void DwarfDebug::emitCommonDebugFrame() {
2829 if (!Asm->MAI->doesDwarfRequireFrameSection())
2832 int stackGrowth = Asm->getTargetData().getPointerSize();
2833 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2834 TargetFrameInfo::StackGrowsDown)
2837 // Start the dwarf frame section.
2838 Asm->OutStreamer.SwitchSection(
2839 Asm->getObjFileLowering().getDwarfFrameSection());
2841 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
2842 Asm->OutStreamer.AddComment("Length of Common Information Entry");
2843 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
2844 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
2846 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
2847 Asm->OutStreamer.AddComment("CIE Identifier Tag");
2848 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2849 Asm->OutStreamer.AddComment("CIE Version");
2850 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2851 Asm->OutStreamer.AddComment("CIE Augmentation");
2852 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2853 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2854 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2855 Asm->OutStreamer.AddComment("CIE RA Column");
2856 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
2857 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2859 std::vector<MachineMove> Moves;
2860 RI->getInitialFrameState(Moves);
2862 Asm->EmitFrameMoves(Moves, 0, false);
2864 Asm->EmitAlignment(2, 0, 0, false);
2865 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
2868 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2871 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2872 if (!Asm->MAI->doesDwarfRequireFrameSection())
2875 // Start the dwarf frame section.
2876 Asm->OutStreamer.SwitchSection(
2877 Asm->getObjFileLowering().getDwarfFrameSection());
2879 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2880 MCSymbol *DebugFrameBegin =
2881 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
2882 MCSymbol *DebugFrameEnd =
2883 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
2884 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
2886 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2888 Asm->OutStreamer.AddComment("FDE CIE offset");
2889 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
2890 DwarfFrameSectionSym);
2892 Asm->OutStreamer.AddComment("FDE initial location");
2893 MCSymbol *FuncBeginSym =
2894 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
2895 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2896 Asm->getTargetData().getPointerSize(),
2900 Asm->OutStreamer.AddComment("FDE address range");
2901 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
2902 FuncBeginSym, Asm->getTargetData().getPointerSize());
2904 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
2906 Asm->EmitAlignment(2, 0, 0, false);
2907 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2910 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2912 void DwarfDebug::emitDebugPubNames() {
2913 // Start the dwarf pubnames section.
2914 Asm->OutStreamer.SwitchSection(
2915 Asm->getObjFileLowering().getDwarfPubNamesSection());
2917 Asm->OutStreamer.AddComment("Length of Public Names Info");
2918 Asm->EmitLabelDifference(
2919 Asm->GetTempSymbol("pubnames_end", ModuleCU->getID()),
2920 Asm->GetTempSymbol("pubnames_begin", ModuleCU->getID()), 4);
2922 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2923 ModuleCU->getID()));
2925 Asm->OutStreamer.AddComment("DWARF Version");
2926 Asm->EmitInt16(dwarf::DWARF_VERSION);
2928 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2929 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2930 DwarfInfoSectionSym);
2932 Asm->OutStreamer.AddComment("Compilation Unit Length");
2933 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2934 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2937 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2938 for (StringMap<DIE*>::const_iterator
2939 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2940 const char *Name = GI->getKeyData();
2941 DIE *Entity = GI->second;
2943 Asm->OutStreamer.AddComment("DIE offset");
2944 Asm->EmitInt32(Entity->getOffset());
2946 if (Asm->isVerbose())
2947 Asm->OutStreamer.AddComment("External Name");
2948 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2951 Asm->OutStreamer.AddComment("End Mark");
2953 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2954 ModuleCU->getID()));
2957 void DwarfDebug::emitDebugPubTypes() {
2958 // Start the dwarf pubnames section.
2959 Asm->OutStreamer.SwitchSection(
2960 Asm->getObjFileLowering().getDwarfPubTypesSection());
2961 Asm->OutStreamer.AddComment("Length of Public Types Info");
2962 Asm->EmitLabelDifference(
2963 Asm->GetTempSymbol("pubtypes_end", ModuleCU->getID()),
2964 Asm->GetTempSymbol("pubtypes_begin", ModuleCU->getID()), 4);
2966 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2967 ModuleCU->getID()));
2969 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2970 Asm->EmitInt16(dwarf::DWARF_VERSION);
2972 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
2973 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2974 DwarfInfoSectionSym);
2976 Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
2977 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2978 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2981 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2982 for (StringMap<DIE*>::const_iterator
2983 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2984 const char *Name = GI->getKeyData();
2985 DIE * Entity = GI->second;
2987 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2988 Asm->EmitInt32(Entity->getOffset());
2990 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2991 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2994 Asm->OutStreamer.AddComment("End Mark");
2996 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2997 ModuleCU->getID()));
3000 /// emitDebugStr - Emit visible names into a debug str section.
3002 void DwarfDebug::emitDebugStr() {
3003 // Check to see if it is worth the effort.
3004 if (StringPool.empty()) return;
3006 // Start the dwarf str section.
3007 Asm->OutStreamer.SwitchSection(
3008 Asm->getObjFileLowering().getDwarfStrSection());
3010 // Get all of the string pool entries and put them in an array by their ID so
3011 // we can sort them.
3012 SmallVector<std::pair<unsigned,
3013 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3015 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3016 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3017 Entries.push_back(std::make_pair(I->second.second, &*I));
3019 array_pod_sort(Entries.begin(), Entries.end());
3021 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3022 // Emit a label for reference from debug information entries.
3023 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3025 // Emit the string itself.
3026 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3030 /// emitDebugLoc - Emit visible names into a debug loc section.
3032 void DwarfDebug::emitDebugLoc() {
3033 // Start the dwarf loc section.
3034 Asm->OutStreamer.SwitchSection(
3035 Asm->getObjFileLowering().getDwarfLocSection());
3038 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3040 void DwarfDebug::EmitDebugARanges() {
3041 // Start the dwarf aranges section.
3042 Asm->OutStreamer.SwitchSection(
3043 Asm->getObjFileLowering().getDwarfARangesSection());
3046 /// emitDebugRanges - Emit visible names into a debug ranges section.
3048 void DwarfDebug::emitDebugRanges() {
3049 // Start the dwarf ranges section.
3050 Asm->OutStreamer.SwitchSection(
3051 Asm->getObjFileLowering().getDwarfRangesSection());
3054 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3056 void DwarfDebug::emitDebugMacInfo() {
3057 if (const MCSection *LineInfo =
3058 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3059 // Start the dwarf macinfo section.
3060 Asm->OutStreamer.SwitchSection(LineInfo);
3064 /// emitDebugInlineInfo - Emit inline info using following format.
3066 /// 1. length of section
3067 /// 2. Dwarf version number
3068 /// 3. address size.
3070 /// Entries (one "entry" for each function that was inlined):
3072 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3073 /// otherwise offset into __debug_str for regular function name.
3074 /// 2. offset into __debug_str section for regular function name.
3075 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3076 /// instances for the function.
3078 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3079 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3080 /// __debug_info section, and the low_pc is the starting address for the
3081 /// inlining instance.
3082 void DwarfDebug::emitDebugInlineInfo() {
3083 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3089 Asm->OutStreamer.SwitchSection(
3090 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3092 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3093 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3094 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3096 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3098 Asm->OutStreamer.AddComment("Dwarf Version");
3099 Asm->EmitInt16(dwarf::DWARF_VERSION);
3100 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3101 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3103 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3104 E = InlinedSPNodes.end(); I != E; ++I) {
3107 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3108 = InlineInfo.find(Node);
3109 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3110 DISubprogram SP(Node);
3111 StringRef LName = SP.getLinkageName();
3112 StringRef Name = SP.getName();
3114 Asm->OutStreamer.AddComment("MIPS linkage name");
3115 if (LName.empty()) {
3116 Asm->OutStreamer.EmitBytes(Name, 0);
3117 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3119 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3120 DwarfStrSectionSym);
3122 Asm->OutStreamer.AddComment("Function name");
3123 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3124 Asm->EmitULEB128(Labels.size(), "Inline count");
3126 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3127 LE = Labels.end(); LI != LE; ++LI) {
3128 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3129 Asm->EmitInt32(LI->second->getOffset());
3131 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3132 Asm->OutStreamer.EmitSymbolValue(LI->first,
3133 Asm->getTargetData().getPointerSize(),0);
3137 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));