1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
16 #include "llvm/Module.h"
17 #include "llvm/CodeGen/MachineFunction.h"
18 #include "llvm/CodeGen/MachineModuleInfo.h"
19 #include "llvm/MC/MCAsmInfo.h"
20 #include "llvm/MC/MCSection.h"
21 #include "llvm/MC/MCStreamer.h"
22 #include "llvm/MC/MCSymbol.h"
23 #include "llvm/Target/Mangler.h"
24 #include "llvm/Target/TargetData.h"
25 #include "llvm/Target/TargetFrameInfo.h"
26 #include "llvm/Target/TargetLoweringObjectFile.h"
27 #include "llvm/Target/TargetRegisterInfo.h"
28 #include "llvm/ADT/STLExtras.h"
29 #include "llvm/ADT/StringExtras.h"
30 #include "llvm/Support/Debug.h"
31 #include "llvm/Support/ErrorHandling.h"
32 #include "llvm/Support/ValueHandle.h"
33 #include "llvm/Support/FormattedStream.h"
34 #include "llvm/Support/Timer.h"
35 #include "llvm/System/Path.h"
38 //===----------------------------------------------------------------------===//
40 /// Configuration values for initial hash set sizes (log2).
42 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
46 //===----------------------------------------------------------------------===//
47 /// CompileUnit - This dwarf writer support class manages information associate
48 /// with a source file.
50 /// ID - File identifier for source.
54 /// Die - Compile unit debug information entry.
56 const OwningPtr<DIE> CUDie;
58 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
61 /// GVToDieMap - Tracks the mapping of unit level debug informaton
62 /// variables to debug information entries.
63 /// FIXME : Rename GVToDieMap -> NodeToDieMap
64 DenseMap<MDNode *, DIE *> GVToDieMap;
66 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
67 /// descriptors to debug information entries using a DIEEntry proxy.
69 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
71 /// Globals - A map of globally visible named entities for this unit.
73 StringMap<DIE*> Globals;
75 /// GlobalTypes - A map of globally visible types for this unit.
77 StringMap<DIE*> GlobalTypes;
80 CompileUnit(unsigned I, DIE *D)
81 : ID(I), CUDie(D), IndexTyDie(0) {}
84 unsigned getID() const { return ID; }
85 DIE* getCUDie() const { return CUDie.get(); }
86 const StringMap<DIE*> &getGlobals() const { return Globals; }
87 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
89 /// hasContent - Return true if this compile unit has something to write out.
91 bool hasContent() const { return !CUDie->getChildren().empty(); }
93 /// addGlobal - Add a new global entity to the compile unit.
95 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
97 /// addGlobalType - Add a new global type to the compile unit.
99 void addGlobalType(const std::string &Name, DIE *Die) {
100 GlobalTypes[Name] = Die;
103 /// getDIE - Returns the debug information entry map slot for the
104 /// specified debug variable.
105 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
107 /// insertDIE - Insert DIE into the map.
108 void insertDIE(MDNode *N, DIE *D) {
109 GVToDieMap.insert(std::make_pair(N, D));
112 /// getDIEEntry - Returns the debug information entry for the speciefied
114 DIEEntry *getDIEEntry(MDNode *N) {
115 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
116 if (I == GVToDIEEntryMap.end())
121 /// insertDIEEntry - Insert debug information entry into the map.
122 void insertDIEEntry(MDNode *N, DIEEntry *E) {
123 GVToDIEEntryMap.insert(std::make_pair(N, E));
126 /// addDie - Adds or interns the DIE to the compile unit.
128 void addDie(DIE *Buffer) {
129 this->CUDie->addChild(Buffer);
132 // getIndexTyDie - Get an anonymous type for index type.
133 DIE *getIndexTyDie() {
137 // setIndexTyDie - Set D as anonymous type for index which can be reused
139 void setIndexTyDie(DIE *D) {
145 //===----------------------------------------------------------------------===//
146 /// DbgVariable - This class is used to track local variable information.
149 DIVariable Var; // Variable Descriptor.
150 unsigned FrameIndex; // Variable frame index.
151 const MachineInstr *DbgValueMInsn; // DBG_VALUE
152 // DbgValueLabel - DBG_VALUE is effective from this label.
153 MCSymbol *DbgValueLabel;
154 DbgVariable *const AbstractVar; // Abstract variable for this variable.
157 // AbsVar may be NULL.
158 DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar)
159 : Var(V), FrameIndex(I), DbgValueMInsn(0),
160 DbgValueLabel(0), AbstractVar(AbsVar), TheDIE(0) {}
161 DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar)
162 : Var(V), FrameIndex(0), DbgValueMInsn(MI), DbgValueLabel(0),
163 AbstractVar(AbsVar), TheDIE(0)
167 DIVariable getVariable() const { return Var; }
168 unsigned getFrameIndex() const { return FrameIndex; }
169 const MachineInstr *getDbgValue() const { return DbgValueMInsn; }
170 MCSymbol *getDbgValueLabel() const { return DbgValueLabel; }
171 void setDbgValueLabel(MCSymbol *L) { DbgValueLabel = L; }
172 DbgVariable *getAbstractVariable() const { return AbstractVar; }
173 void setDIE(DIE *D) { TheDIE = D; }
174 DIE *getDIE() const { return TheDIE; }
177 //===----------------------------------------------------------------------===//
178 /// DbgScope - This class is used to track scope information.
181 DbgScope *Parent; // Parent to this scope.
182 DIDescriptor Desc; // Debug info descriptor for scope.
183 // Location at which this scope is inlined.
184 AssertingVH<MDNode> InlinedAtLocation;
185 bool AbstractScope; // Abstract Scope
186 MCSymbol *StartLabel; // Label ID of the beginning of scope.
187 MCSymbol *EndLabel; // Label ID of the end of scope.
188 const MachineInstr *LastInsn; // Last instruction of this scope.
189 const MachineInstr *FirstInsn; // First instruction of this scope.
190 // Scopes defined in scope. Contents not owned.
191 SmallVector<DbgScope *, 4> Scopes;
192 // Variables declared in scope. Contents owned.
193 SmallVector<DbgVariable *, 8> Variables;
195 // Private state for dump()
196 mutable unsigned IndentLevel;
198 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
199 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
200 StartLabel(0), EndLabel(0),
201 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
205 DbgScope *getParent() const { return Parent; }
206 void setParent(DbgScope *P) { Parent = P; }
207 DIDescriptor getDesc() const { return Desc; }
208 MDNode *getInlinedAt() const { return InlinedAtLocation; }
209 MDNode *getScopeNode() const { return Desc.getNode(); }
210 MCSymbol *getStartLabel() const { return StartLabel; }
211 MCSymbol *getEndLabel() const { return EndLabel; }
212 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
213 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
214 void setStartLabel(MCSymbol *S) { StartLabel = S; }
215 void setEndLabel(MCSymbol *E) { EndLabel = E; }
216 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
217 const MachineInstr *getLastInsn() { return LastInsn; }
218 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
219 void setAbstractScope() { AbstractScope = true; }
220 bool isAbstractScope() const { return AbstractScope; }
221 const MachineInstr *getFirstInsn() { return FirstInsn; }
223 /// addScope - Add a scope to the scope.
225 void addScope(DbgScope *S) { Scopes.push_back(S); }
227 /// addVariable - Add a variable to the scope.
229 void addVariable(DbgVariable *V) { Variables.push_back(V); }
231 void fixInstructionMarkers(DenseMap<const MachineInstr *,
232 unsigned> &MIIndexMap) {
233 assert (getFirstInsn() && "First instruction is missing!");
235 // Use the end of last child scope as end of this scope.
236 const SmallVector<DbgScope *, 4> &Scopes = getScopes();
237 const MachineInstr *LastInsn = getFirstInsn();
239 if (Scopes.empty()) {
240 assert (getLastInsn() && "Inner most scope does not have last insn!");
243 for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(),
244 SE = Scopes.end(); SI != SE; ++SI) {
246 DS->fixInstructionMarkers(MIIndexMap);
247 const MachineInstr *DSLastInsn = DS->getLastInsn();
248 unsigned DSI = MIIndexMap[DSLastInsn];
250 LastInsn = DSLastInsn;
255 unsigned CurrentLastInsnIndex = 0;
256 if (const MachineInstr *CL = getLastInsn())
257 CurrentLastInsnIndex = MIIndexMap[CL];
258 unsigned FIndex = MIIndexMap[getFirstInsn()];
260 // Set LastInsn as the last instruction for this scope only if
262 // 1) this scope's first instruction and
263 // 2) current last instruction for this scope, if any.
264 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
265 setLastInsn(LastInsn);
274 void DbgScope::dump() const {
275 raw_ostream &err = dbgs();
276 err.indent(IndentLevel);
277 MDNode *N = Desc.getNode();
279 err << " [" << StartLabel << ", " << EndLabel << "]\n";
281 err << "Abstract Scope\n";
285 err << "Children ...\n";
286 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
287 if (Scopes[i] != this)
294 DbgScope::~DbgScope() {
295 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
299 } // end llvm namespace
301 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
302 : DwarfPrinter(OS, A, T), ModuleCU(0),
303 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
304 DIEValues(), SectionSourceLines(), didInitial(false), shouldEmit(false),
305 CurrentFnDbgScope(0), PrevDILoc(0), DebugTimer(0) {
306 NextStringPoolNumber = 0;
307 if (TimePassesIsEnabled)
308 DebugTimer = new Timer("Dwarf Debug Writer");
310 DwarfDebug::~DwarfDebug() {
311 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
317 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
318 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
319 if (Entry.first) return Entry.first;
321 Entry.second = NextStringPoolNumber++;
322 return Entry.first = getDWLabel("string", Entry.second);
326 /// assignAbbrevNumber - Define a unique number for the abbreviation.
328 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
329 // Profile the node so that we can make it unique.
333 // Check the set for priors.
334 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
336 // If it's newly added.
337 if (InSet == &Abbrev) {
338 // Add to abbreviation list.
339 Abbreviations.push_back(&Abbrev);
341 // Assign the vector position + 1 as its number.
342 Abbrev.setNumber(Abbreviations.size());
344 // Assign existing abbreviation number.
345 Abbrev.setNumber(InSet->getNumber());
349 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
350 /// information entry.
351 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
352 DIEEntry *Value = new DIEEntry(Entry);
353 DIEValues.push_back(Value);
357 /// addUInt - Add an unsigned integer attribute data and value.
359 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
360 unsigned Form, uint64_t Integer) {
361 if (!Form) Form = DIEInteger::BestForm(false, Integer);
362 DIEValue *Value = new DIEInteger(Integer);
363 DIEValues.push_back(Value);
364 Die->addValue(Attribute, Form, Value);
367 /// addSInt - Add an signed integer attribute data and value.
369 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
370 unsigned Form, int64_t Integer) {
371 if (!Form) Form = DIEInteger::BestForm(true, Integer);
372 DIEValue *Value = new DIEInteger(Integer);
373 DIEValues.push_back(Value);
374 Die->addValue(Attribute, Form, Value);
377 /// addString - Add a string attribute data and value. DIEString only
378 /// keeps string reference.
379 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
381 DIEValue *Value = new DIEString(String);
382 DIEValues.push_back(Value);
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 DIELabel(Label);
391 DIEValues.push_back(Value);
392 Die->addValue(Attribute, Form, Value);
395 /// addDelta - Add a label delta attribute data and value.
397 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
398 const MCSymbol *Hi, const MCSymbol *Lo) {
399 DIEValue *Value = new DIEDelta(Hi, Lo);
400 DIEValues.push_back(Value);
401 Die->addValue(Attribute, Form, Value);
404 /// addBlock - Add block data.
406 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
408 Block->ComputeSize(TD);
409 DIEValues.push_back(Block);
410 Die->addValue(Attribute, Block->BestForm(), Block);
413 /// addSourceLine - Add location information to specified debug information
415 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
416 // If there is no compile unit specified, don't add a line #.
417 if (!V->getCompileUnit().Verify())
420 unsigned Line = V->getLineNumber();
421 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
422 V->getContext().getFilename());
423 assert(FileID && "Invalid file id");
424 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
425 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
428 /// addSourceLine - Add location information to specified debug information
430 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
431 // If there is no compile unit specified, don't add a line #.
432 if (!G->getCompileUnit().Verify())
435 unsigned Line = G->getLineNumber();
436 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
437 G->getContext().getFilename());
438 assert(FileID && "Invalid file id");
439 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
440 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
443 /// addSourceLine - Add location information to specified debug information
445 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
446 // If there is no compile unit specified, don't add a line #.
447 if (!SP->getCompileUnit().Verify())
449 // If the line number is 0, don't add it.
450 if (SP->getLineNumber() == 0)
453 unsigned Line = SP->getLineNumber();
454 if (!SP->getContext().Verify())
456 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
458 assert(FileID && "Invalid file id");
459 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
460 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
463 /// addSourceLine - Add location information to specified debug information
465 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
466 // If there is no compile unit specified, don't add a line #.
467 DICompileUnit CU = Ty->getCompileUnit();
471 unsigned Line = Ty->getLineNumber();
472 if (!Ty->getContext().Verify())
474 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
475 Ty->getContext().getFilename());
476 assert(FileID && "Invalid file id");
477 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
478 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
481 /// addSourceLine - Add location information to specified debug information
483 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
484 // If there is no compile unit specified, don't add a line #.
485 if (!NS->getCompileUnit().Verify())
488 unsigned Line = NS->getLineNumber();
489 StringRef FN = NS->getFilename();
490 StringRef Dir = NS->getDirectory();
492 unsigned FileID = GetOrCreateSourceID(Dir, FN);
493 assert(FileID && "Invalid file id");
494 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
495 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
498 /* Byref variables, in Blocks, are declared by the programmer as
499 "SomeType VarName;", but the compiler creates a
500 __Block_byref_x_VarName struct, and gives the variable VarName
501 either the struct, or a pointer to the struct, as its type. This
502 is necessary for various behind-the-scenes things the compiler
503 needs to do with by-reference variables in blocks.
505 However, as far as the original *programmer* is concerned, the
506 variable should still have type 'SomeType', as originally declared.
508 The following function dives into the __Block_byref_x_VarName
509 struct to find the original type of the variable. This will be
510 passed back to the code generating the type for the Debug
511 Information Entry for the variable 'VarName'. 'VarName' will then
512 have the original type 'SomeType' in its debug information.
514 The original type 'SomeType' will be the type of the field named
515 'VarName' inside the __Block_byref_x_VarName struct.
517 NOTE: In order for this to not completely fail on the debugger
518 side, the Debug Information Entry for the variable VarName needs to
519 have a DW_AT_location that tells the debugger how to unwind through
520 the pointers and __Block_byref_x_VarName struct to find the actual
521 value of the variable. The function addBlockByrefType does this. */
523 /// Find the type the programmer originally declared the variable to be
524 /// and return that type.
526 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
529 unsigned tag = Ty.getTag();
531 if (tag == dwarf::DW_TAG_pointer_type) {
532 DIDerivedType DTy = DIDerivedType(Ty.getNode());
533 subType = DTy.getTypeDerivedFrom();
536 DICompositeType blockStruct = DICompositeType(subType.getNode());
537 DIArray Elements = blockStruct.getTypeArray();
539 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
540 DIDescriptor Element = Elements.getElement(i);
541 DIDerivedType DT = DIDerivedType(Element.getNode());
542 if (Name == DT.getName())
543 return (DT.getTypeDerivedFrom());
549 /// addComplexAddress - Start with the address based on the location provided,
550 /// and generate the DWARF information necessary to find the actual variable
551 /// given the extra address information encoded in the DIVariable, starting from
552 /// the starting location. Add the DWARF information to the die.
554 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
556 const MachineLocation &Location) {
557 const DIVariable &VD = DV->getVariable();
558 DIType Ty = VD.getType();
560 // Decode the original location, and use that as the start of the byref
561 // variable's location.
562 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
563 DIEBlock *Block = new DIEBlock();
565 if (Location.isReg()) {
567 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
569 Reg = Reg - dwarf::DW_OP_reg0;
570 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
571 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
575 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
577 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
578 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
581 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
584 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
585 uint64_t Element = VD.getAddrElement(i);
587 if (Element == DIFactory::OpPlus) {
588 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
589 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
590 } else if (Element == DIFactory::OpDeref) {
591 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
592 } else llvm_unreachable("unknown DIFactory Opcode");
595 // Now attach the location information to the DIE.
596 addBlock(Die, Attribute, 0, Block);
599 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
600 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
601 gives the variable VarName either the struct, or a pointer to the struct, as
602 its type. This is necessary for various behind-the-scenes things the
603 compiler needs to do with by-reference variables in Blocks.
605 However, as far as the original *programmer* is concerned, the variable
606 should still have type 'SomeType', as originally declared.
608 The function getBlockByrefType dives into the __Block_byref_x_VarName
609 struct to find the original type of the variable, which is then assigned to
610 the variable's Debug Information Entry as its real type. So far, so good.
611 However now the debugger will expect the variable VarName to have the type
612 SomeType. So we need the location attribute for the variable to be an
613 expression that explains to the debugger how to navigate through the
614 pointers and struct to find the actual variable of type SomeType.
616 The following function does just that. We start by getting
617 the "normal" location for the variable. This will be the location
618 of either the struct __Block_byref_x_VarName or the pointer to the
619 struct __Block_byref_x_VarName.
621 The struct will look something like:
623 struct __Block_byref_x_VarName {
625 struct __Block_byref_x_VarName *forwarding;
626 ... <various other fields>
628 ... <maybe more fields>
631 If we are given the struct directly (as our starting point) we
632 need to tell the debugger to:
634 1). Add the offset of the forwarding field.
636 2). Follow that pointer to get the real __Block_byref_x_VarName
637 struct to use (the real one may have been copied onto the heap).
639 3). Add the offset for the field VarName, to find the actual variable.
641 If we started with a pointer to the struct, then we need to
642 dereference that pointer first, before the other steps.
643 Translating this into DWARF ops, we will need to append the following
644 to the current location description for the variable:
646 DW_OP_deref -- optional, if we start with a pointer
647 DW_OP_plus_uconst <forward_fld_offset>
649 DW_OP_plus_uconst <varName_fld_offset>
651 That is what this function does. */
653 /// addBlockByrefAddress - Start with the address based on the location
654 /// provided, and generate the DWARF information necessary to find the
655 /// actual Block variable (navigating the Block struct) based on the
656 /// starting location. Add the DWARF information to the die. For
657 /// more information, read large comment just above here.
659 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
661 const MachineLocation &Location) {
662 const DIVariable &VD = DV->getVariable();
663 DIType Ty = VD.getType();
665 unsigned Tag = Ty.getTag();
666 bool isPointer = false;
668 StringRef varName = VD.getName();
670 if (Tag == dwarf::DW_TAG_pointer_type) {
671 DIDerivedType DTy = DIDerivedType(Ty.getNode());
672 TmpTy = DTy.getTypeDerivedFrom();
676 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
678 // Find the __forwarding field and the variable field in the __Block_byref
680 DIArray Fields = blockStruct.getTypeArray();
681 DIDescriptor varField = DIDescriptor();
682 DIDescriptor forwardingField = DIDescriptor();
684 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
685 DIDescriptor Element = Fields.getElement(i);
686 DIDerivedType DT = DIDerivedType(Element.getNode());
687 StringRef fieldName = DT.getName();
688 if (fieldName == "__forwarding")
689 forwardingField = Element;
690 else if (fieldName == varName)
694 // Get the offsets for the forwarding field and the variable field.
695 unsigned int forwardingFieldOffset =
696 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
697 unsigned int varFieldOffset =
698 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
700 // Decode the original location, and use that as the start of the byref
701 // variable's location.
702 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
703 DIEBlock *Block = new 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 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
758 DIEBlock *Block = new DIEBlock();
760 if (Location.isReg()) {
762 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
764 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
765 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
769 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
771 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
772 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
775 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
778 addBlock(Die, Attribute, 0, Block);
781 /// addToContextOwner - Add Die into the list of its context owner's children.
782 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
783 if (Context.isType()) {
784 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
785 ContextDIE->addChild(Die);
786 } else if (Context.isNameSpace()) {
787 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
788 ContextDIE->addChild(Die);
789 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
790 ContextDIE->addChild(Die);
792 ModuleCU->addDie(Die);
795 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
797 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
798 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
803 TyDIE = new DIE(dwarf::DW_TAG_base_type);
804 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
805 if (Ty.isBasicType())
806 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
807 else if (Ty.isCompositeType())
808 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
810 assert(Ty.isDerivedType() && "Unknown kind of DIType");
811 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
814 addToContextOwner(TyDIE, Ty.getContext());
818 /// addType - Add a new type attribute to the specified entity.
819 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
823 // Check for pre-existence.
824 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
825 // If it exists then use the existing value.
827 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
832 DIE *Buffer = getOrCreateTypeDIE(Ty);
835 Entry = createDIEEntry(Buffer);
836 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
838 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
841 /// constructTypeDIE - Construct basic type die from DIBasicType.
842 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
843 // Get core information.
844 StringRef Name = BTy.getName();
845 Buffer.setTag(dwarf::DW_TAG_base_type);
846 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
849 // Add name if not anonymous or intermediate type.
851 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
852 uint64_t Size = BTy.getSizeInBits() >> 3;
853 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
856 /// constructTypeDIE - Construct derived type die from DIDerivedType.
857 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
858 // Get core information.
859 StringRef Name = DTy.getName();
860 uint64_t Size = DTy.getSizeInBits() >> 3;
861 unsigned Tag = DTy.getTag();
863 // FIXME - Workaround for templates.
864 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
868 // Map to main type, void will not have a type.
869 DIType FromTy = DTy.getTypeDerivedFrom();
870 addType(&Buffer, FromTy);
872 // Add name if not anonymous or intermediate type.
874 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
876 // Add size if non-zero (derived types might be zero-sized.)
878 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
880 // Add source line info if available and TyDesc is not a forward declaration.
881 if (!DTy.isForwardDecl())
882 addSourceLine(&Buffer, &DTy);
885 /// constructTypeDIE - Construct type DIE from DICompositeType.
886 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
887 // Get core information.
888 StringRef Name = CTy.getName();
890 uint64_t Size = CTy.getSizeInBits() >> 3;
891 unsigned Tag = CTy.getTag();
895 case dwarf::DW_TAG_vector_type:
896 case dwarf::DW_TAG_array_type:
897 constructArrayTypeDIE(Buffer, &CTy);
899 case dwarf::DW_TAG_enumeration_type: {
900 DIArray Elements = CTy.getTypeArray();
902 // Add enumerators to enumeration type.
903 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
905 DIDescriptor Enum(Elements.getElement(i).getNode());
906 if (Enum.isEnumerator()) {
907 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
908 Buffer.addChild(ElemDie);
913 case dwarf::DW_TAG_subroutine_type: {
915 DIArray Elements = CTy.getTypeArray();
916 DIDescriptor RTy = Elements.getElement(0);
917 addType(&Buffer, DIType(RTy.getNode()));
919 // Add prototype flag.
920 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
923 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
924 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
925 DIDescriptor Ty = Elements.getElement(i);
926 addType(Arg, DIType(Ty.getNode()));
927 Buffer.addChild(Arg);
931 case dwarf::DW_TAG_structure_type:
932 case dwarf::DW_TAG_union_type:
933 case dwarf::DW_TAG_class_type: {
934 // Add elements to structure type.
935 DIArray Elements = CTy.getTypeArray();
937 // A forward struct declared type may not have elements available.
938 unsigned N = Elements.getNumElements();
942 // Add elements to structure type.
943 for (unsigned i = 0; i < N; ++i) {
944 DIDescriptor Element = Elements.getElement(i);
946 if (Element.isSubprogram())
947 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
948 else if (Element.isVariable()) {
949 DIVariable DV(Element.getNode());
950 ElemDie = new DIE(dwarf::DW_TAG_variable);
951 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
953 addType(ElemDie, DV.getType());
954 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
955 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
956 addSourceLine(ElemDie, &DV);
957 } else if (Element.isDerivedType())
958 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
961 Buffer.addChild(ElemDie);
964 if (CTy.isAppleBlockExtension())
965 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
967 unsigned RLang = CTy.getRunTimeLang();
969 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
970 dwarf::DW_FORM_data1, RLang);
972 DICompositeType ContainingType = CTy.getContainingType();
973 if (DIDescriptor(ContainingType.getNode()).isCompositeType())
974 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
975 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
982 // Add name if not anonymous or intermediate type.
984 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
986 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
987 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
988 // Add size if non-zero (derived types might be zero-sized.)
990 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
992 // Add zero size if it is not a forward declaration.
993 if (CTy.isForwardDecl())
994 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
996 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
999 // Add source line info if available.
1000 if (!CTy.isForwardDecl())
1001 addSourceLine(&Buffer, &CTy);
1005 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1006 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1007 int64_t L = SR.getLo();
1008 int64_t H = SR.getHi();
1009 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1011 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1013 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1014 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1016 Buffer.addChild(DW_Subrange);
1019 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1020 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1021 DICompositeType *CTy) {
1022 Buffer.setTag(dwarf::DW_TAG_array_type);
1023 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1024 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1026 // Emit derived type.
1027 addType(&Buffer, CTy->getTypeDerivedFrom());
1028 DIArray Elements = CTy->getTypeArray();
1030 // Get an anonymous type for index type.
1031 DIE *IdxTy = ModuleCU->getIndexTyDie();
1033 // Construct an anonymous type for index type.
1034 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1035 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1036 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1037 dwarf::DW_ATE_signed);
1038 ModuleCU->addDie(IdxTy);
1039 ModuleCU->setIndexTyDie(IdxTy);
1042 // Add subranges to array type.
1043 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1044 DIDescriptor Element = Elements.getElement(i);
1045 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1046 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1050 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1051 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1052 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1053 StringRef Name = ETy.getName();
1054 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1055 int64_t Value = ETy.getEnumValue();
1056 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1060 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1061 /// printer to not emit usual symbol prefix before the symbol name is used then
1062 /// return linkage name after skipping this special LLVM prefix.
1063 static StringRef getRealLinkageName(StringRef LinkageName) {
1065 if (LinkageName.startswith(StringRef(&One, 1)))
1066 return LinkageName.substr(1);
1070 /// createGlobalVariableDIE - Create new DIE using GV.
1071 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1072 // If the global variable was optmized out then no need to create debug info
1074 if (!GV.getGlobal()) return NULL;
1075 if (GV.getDisplayName().empty()) return NULL;
1077 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1078 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1079 GV.getDisplayName());
1081 StringRef LinkageName = GV.getLinkageName();
1082 if (!LinkageName.empty())
1083 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1084 getRealLinkageName(LinkageName));
1086 addType(GVDie, GV.getType());
1087 if (!GV.isLocalToUnit())
1088 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1089 addSourceLine(GVDie, &GV);
1094 /// createMemberDIE - Create new member DIE.
1095 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1096 DIE *MemberDie = new DIE(DT.getTag());
1097 StringRef Name = DT.getName();
1099 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1101 addType(MemberDie, DT.getTypeDerivedFrom());
1103 addSourceLine(MemberDie, &DT);
1105 DIEBlock *MemLocationDie = new DIEBlock();
1106 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1108 uint64_t Size = DT.getSizeInBits();
1109 uint64_t FieldSize = DT.getOriginalTypeSize();
1111 if (Size != FieldSize) {
1113 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1114 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1116 uint64_t Offset = DT.getOffsetInBits();
1117 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1118 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1119 uint64_t FieldOffset = (HiMark - FieldSize);
1120 Offset -= FieldOffset;
1122 // Maybe we need to work from the other end.
1123 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1124 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1126 // Here WD_AT_data_member_location points to the anonymous
1127 // field that includes this bit field.
1128 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1131 // This is not a bitfield.
1132 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1134 if (DT.getTag() == dwarf::DW_TAG_inheritance
1135 && DT.isVirtual()) {
1137 // For C++, virtual base classes are not at fixed offset. Use following
1138 // expression to extract appropriate offset from vtable.
1139 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1141 DIEBlock *VBaseLocationDie = new DIEBlock();
1142 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1143 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1144 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1145 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1146 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1147 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1148 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1150 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1153 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1155 if (DT.isProtected())
1156 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1157 dwarf::DW_ACCESS_protected);
1158 else if (DT.isPrivate())
1159 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1160 dwarf::DW_ACCESS_private);
1161 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1162 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1163 dwarf::DW_ACCESS_public);
1165 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1166 dwarf::DW_VIRTUALITY_virtual);
1170 /// createSubprogramDIE - Create new DIE using SP.
1171 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1172 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1176 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1177 // Constructors and operators for anonymous aggregates do not have names.
1178 if (!SP.getName().empty())
1179 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1181 StringRef LinkageName = SP.getLinkageName();
1182 if (!LinkageName.empty())
1183 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1184 getRealLinkageName(LinkageName));
1186 addSourceLine(SPDie, &SP);
1188 // Add prototyped tag, if C or ObjC.
1189 unsigned Lang = SP.getCompileUnit().getLanguage();
1190 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1191 Lang == dwarf::DW_LANG_ObjC)
1192 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1195 DICompositeType SPTy = SP.getType();
1196 DIArray Args = SPTy.getTypeArray();
1197 unsigned SPTag = SPTy.getTag();
1199 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1200 addType(SPDie, SPTy);
1202 addType(SPDie, DIType(Args.getElement(0).getNode()));
1204 unsigned VK = SP.getVirtuality();
1206 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1207 DIEBlock *Block = new DIEBlock();
1208 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1209 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1210 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1211 ContainingTypeMap.insert(std::make_pair(SPDie,
1212 SP.getContainingType().getNode()));
1215 if (MakeDecl || !SP.isDefinition()) {
1216 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1218 // Add arguments. Do not add arguments for subprogram definition. They will
1219 // be handled while processing variables.
1220 DICompositeType SPTy = SP.getType();
1221 DIArray Args = SPTy.getTypeArray();
1222 unsigned SPTag = SPTy.getTag();
1224 if (SPTag == dwarf::DW_TAG_subroutine_type)
1225 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1226 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1227 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1229 if (ATy.isArtificial())
1230 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1231 SPDie->addChild(Arg);
1235 if (SP.isArtificial())
1236 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1238 // DW_TAG_inlined_subroutine may refer to this DIE.
1239 ModuleCU->insertDIE(SP.getNode(), SPDie);
1243 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1244 /// Initialize scope and update scope hierarchy.
1245 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1246 MDNode *InlinedAt) {
1247 assert (N && "Invalid Scope encoding!");
1248 assert (MI && "Missing machine instruction!");
1249 bool GetConcreteScope = (MI && InlinedAt);
1251 DbgScope *NScope = NULL;
1254 NScope = DbgScopeMap.lookup(InlinedAt);
1256 NScope = DbgScopeMap.lookup(N);
1257 assert (NScope && "Unable to find working scope!");
1259 if (NScope->getFirstInsn())
1262 DbgScope *Parent = NULL;
1263 if (GetConcreteScope) {
1264 DILocation IL(InlinedAt);
1265 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1266 IL.getOrigLocation().getNode());
1267 assert (Parent && "Unable to find Parent scope!");
1268 NScope->setParent(Parent);
1269 Parent->addScope(NScope);
1270 } else if (DIDescriptor(N).isLexicalBlock()) {
1271 DILexicalBlock DB(N);
1272 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1273 NScope->setParent(Parent);
1274 Parent->addScope(NScope);
1277 NScope->setFirstInsn(MI);
1279 if (!Parent && !InlinedAt) {
1280 StringRef SPName = DISubprogram(N).getLinkageName();
1281 if (SPName == MF->getFunction()->getName())
1282 CurrentFnDbgScope = NScope;
1285 if (GetConcreteScope) {
1286 ConcreteScopes[InlinedAt] = NScope;
1287 getOrCreateAbstractScope(N);
1293 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1294 assert (N && "Invalid Scope encoding!");
1296 DbgScope *AScope = AbstractScopes.lookup(N);
1300 DbgScope *Parent = NULL;
1302 DIDescriptor Scope(N);
1303 if (Scope.isLexicalBlock()) {
1304 DILexicalBlock DB(N);
1305 DIDescriptor ParentDesc = DB.getContext();
1306 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1309 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1312 Parent->addScope(AScope);
1313 AScope->setAbstractScope();
1314 AbstractScopes[N] = AScope;
1315 if (DIDescriptor(N).isSubprogram())
1316 AbstractScopesList.push_back(AScope);
1320 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1321 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1322 /// If there are global variables in this scope then create and insert
1323 /// DIEs for these variables.
1324 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1325 DIE *SPDie = ModuleCU->getDIE(SPNode);
1326 assert(SPDie && "Unable to find subprogram DIE!");
1327 DISubprogram SP(SPNode);
1329 // There is not any need to generate specification DIE for a function
1330 // defined at compile unit level. If a function is defined inside another
1331 // function then gdb prefers the definition at top level and but does not
1332 // expect specification DIE in parent function. So avoid creating
1333 // specification DIE for a function defined inside a function.
1334 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1335 !SP.getContext().isFile() && !SP.getContext().isSubprogram()) {
1336 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1339 DICompositeType SPTy = SP.getType();
1340 DIArray Args = SPTy.getTypeArray();
1341 unsigned SPTag = SPTy.getTag();
1342 if (SPTag == dwarf::DW_TAG_subroutine_type)
1343 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1344 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1345 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1347 if (ATy.isArtificial())
1348 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1349 SPDie->addChild(Arg);
1351 DIE *SPDeclDie = SPDie;
1352 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1353 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1355 ModuleCU->addDie(SPDie);
1358 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1359 getDWLabel("func_begin", SubprogramCount));
1360 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1361 getDWLabel("func_end", SubprogramCount));
1362 MachineLocation Location(RI->getFrameRegister(*MF));
1363 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1365 if (!DISubprogram(SPNode).isLocalToUnit())
1366 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1371 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1372 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1373 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1374 MCSymbol *Start = Scope->getStartLabel();
1375 MCSymbol *End = Scope->getEndLabel();
1376 if (Start == 0 || End == 0) return 0;
1378 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1379 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1381 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1382 if (Scope->isAbstractScope())
1385 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1386 Start ? Start : getDWLabel("func_begin", SubprogramCount));
1387 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1388 End ? End : getDWLabel("func_end", SubprogramCount));
1393 /// constructInlinedScopeDIE - This scope represents inlined body of
1394 /// a function. Construct DIE to represent this concrete inlined copy
1395 /// of the function.
1396 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1397 MCSymbol *StartLabel = Scope->getStartLabel();
1398 MCSymbol *EndLabel = Scope->getEndLabel();
1399 if (StartLabel == 0 || EndLabel == 0) return 0;
1401 assert(StartLabel->isDefined() &&
1402 "Invalid starting label for an inlined scope!");
1403 assert(EndLabel->isDefined() &&
1404 "Invalid end label for an inlined scope!");
1405 if (!Scope->getScopeNode())
1407 DIScope DS(Scope->getScopeNode());
1408 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1410 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1411 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1412 assert (OriginDIE && "Unable to find Origin DIE!");
1413 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1414 dwarf::DW_FORM_ref4, OriginDIE);
1416 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1417 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1419 InlinedSubprogramDIEs.insert(OriginDIE);
1421 // Track the start label for this inlined function.
1422 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1423 I = InlineInfo.find(InlinedSP.getNode());
1425 if (I == InlineInfo.end()) {
1426 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
1428 InlinedSPNodes.push_back(InlinedSP.getNode());
1430 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1432 DILocation DL(Scope->getInlinedAt());
1433 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1434 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1440 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1441 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1442 // Get the descriptor.
1443 const DIVariable &VD = DV->getVariable();
1444 StringRef Name = VD.getName();
1448 // Translate tag to proper Dwarf tag. The result variable is dropped for
1451 switch (VD.getTag()) {
1452 case dwarf::DW_TAG_return_variable:
1454 case dwarf::DW_TAG_arg_variable:
1455 Tag = dwarf::DW_TAG_formal_parameter;
1457 case dwarf::DW_TAG_auto_variable: // fall thru
1459 Tag = dwarf::DW_TAG_variable;
1463 // Define variable debug information entry.
1464 DIE *VariableDie = new DIE(Tag);
1468 if (DbgVariable *AV = DV->getAbstractVariable())
1469 AbsDIE = AV->getDIE();
1472 DIScope DS(Scope->getScopeNode());
1473 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1474 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1476 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1477 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1478 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1479 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1480 dwarf::DW_FORM_ref4, AbsDIE);
1483 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1484 addSourceLine(VariableDie, &VD);
1486 // Add variable type.
1487 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1488 // addresses instead.
1489 if (VD.isBlockByrefVariable())
1490 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1492 addType(VariableDie, VD.getType());
1495 // Add variable address.
1496 if (!Scope->isAbstractScope()) {
1497 // Check if variable is described by DBG_VALUE instruction.
1498 if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1499 if (DbgValueInsn->getNumOperands() == 3) {
1500 // FIXME : Handle getNumOperands != 3
1501 if (DbgValueInsn->getOperand(0).getType()
1502 == MachineOperand::MO_Register
1503 && DbgValueInsn->getOperand(0).getReg()) {
1504 MachineLocation Location;
1505 Location.set(DbgValueInsn->getOperand(0).getReg());
1506 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1507 if (MCSymbol *VS = DV->getDbgValueLabel())
1508 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1510 } else if (DbgValueInsn->getOperand(0).getType() ==
1511 MachineOperand::MO_Immediate) {
1512 DIEBlock *Block = new DIEBlock();
1513 unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1514 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1515 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
1516 if (MCSymbol *VS = DV->getDbgValueLabel())
1517 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1520 //FIXME : Handle other operand types.
1526 MachineLocation Location;
1528 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1529 Location.set(FrameReg, Offset);
1531 if (VD.hasComplexAddress())
1532 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1533 else if (VD.isBlockByrefVariable())
1534 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1536 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1540 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1541 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1542 DV->setDIE(VariableDie);
1547 void DwarfDebug::addPubTypes(DISubprogram SP) {
1548 DICompositeType SPTy = SP.getType();
1549 unsigned SPTag = SPTy.getTag();
1550 if (SPTag != dwarf::DW_TAG_subroutine_type)
1553 DIArray Args = SPTy.getTypeArray();
1554 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1555 DIType ATy(Args.getElement(i).getNode());
1558 DICompositeType CATy = getDICompositeType(ATy);
1559 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
1560 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1561 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1566 /// constructScopeDIE - Construct a DIE for this scope.
1567 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1568 if (!Scope || !Scope->getScopeNode())
1571 DIScope DS(Scope->getScopeNode());
1572 DIE *ScopeDIE = NULL;
1573 if (Scope->getInlinedAt())
1574 ScopeDIE = constructInlinedScopeDIE(Scope);
1575 else if (DS.isSubprogram()) {
1576 if (Scope->isAbstractScope())
1577 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1579 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1582 ScopeDIE = constructLexicalScopeDIE(Scope);
1583 if (!ScopeDIE) return NULL;
1585 // Add variables to scope.
1586 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1587 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1588 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1590 ScopeDIE->addChild(VariableDIE);
1593 // Add nested scopes.
1594 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1595 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1596 // Define the Scope debug information entry.
1597 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1599 ScopeDIE->addChild(NestedDIE);
1602 if (DS.isSubprogram())
1603 addPubTypes(DISubprogram(DS.getNode()));
1608 /// GetOrCreateSourceID - Look up the source id with the given directory and
1609 /// source file names. If none currently exists, create a new id and insert it
1610 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1612 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1614 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1615 if (DI != DirectoryIdMap.end()) {
1616 DId = DI->getValue();
1618 DId = DirectoryNames.size() + 1;
1619 DirectoryIdMap[DirName] = DId;
1620 DirectoryNames.push_back(DirName);
1624 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1625 if (FI != SourceFileIdMap.end()) {
1626 FId = FI->getValue();
1628 FId = SourceFileNames.size() + 1;
1629 SourceFileIdMap[FileName] = FId;
1630 SourceFileNames.push_back(FileName);
1633 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1634 SourceIdMap.find(std::make_pair(DId, FId));
1635 if (SI != SourceIdMap.end())
1638 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1639 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1640 SourceIds.push_back(std::make_pair(DId, FId));
1645 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1646 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1647 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1650 NDie = new DIE(dwarf::DW_TAG_namespace);
1651 ModuleCU->insertDIE(NS.getNode(), NDie);
1652 if (!NS.getName().empty())
1653 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1654 addSourceLine(NDie, &NS);
1655 addToContextOwner(NDie, NS.getContext());
1659 void DwarfDebug::constructCompileUnit(MDNode *N) {
1660 DICompileUnit DIUnit(N);
1661 // Use first compile unit marked as isMain as the compile unit for this
1663 if (ModuleCU || !DIUnit.isMain())
1665 StringRef FN = DIUnit.getFilename();
1666 StringRef Dir = DIUnit.getDirectory();
1667 unsigned ID = GetOrCreateSourceID(Dir, FN);
1669 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1670 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1671 DIUnit.getProducer());
1672 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1673 DIUnit.getLanguage());
1674 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1675 addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1676 getTempLabel("text_begin"));
1677 addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1678 getTempLabel("text_end"));
1679 // DW_AT_stmt_list is a offset of line number information for this
1680 // compile unit in debug_line section. It is always zero when only one
1681 // compile unit is emitted in one object file.
1682 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1685 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1686 if (DIUnit.isOptimized())
1687 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1689 StringRef Flags = DIUnit.getFlags();
1691 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1693 unsigned RVer = DIUnit.getRunTimeVersion();
1695 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1696 dwarf::DW_FORM_data1, RVer);
1699 "ModuleCU assigned since the top of constructCompileUnit");
1700 ModuleCU = new CompileUnit(ID, Die);
1703 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1704 DIGlobalVariable DI_GV(N);
1706 // If debug information is malformed then ignore it.
1707 if (DI_GV.Verify() == false)
1710 // Check for pre-existence.
1711 if (ModuleCU->getDIE(DI_GV.getNode()))
1714 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1719 ModuleCU->insertDIE(N, VariableDie);
1721 // Add to context owner.
1722 DIDescriptor GVContext = DI_GV.getContext();
1723 // Do not create specification DIE if context is either compile unit
1725 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1726 && !GVContext.isFile() && !GVContext.isSubprogram()) {
1727 // Create specification DIE.
1728 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1729 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1730 dwarf::DW_FORM_ref4, VariableDie);
1731 DIEBlock *Block = new DIEBlock();
1732 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1733 addLabel(Block, 0, dwarf::DW_FORM_udata,
1734 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1735 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1736 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1737 ModuleCU->addDie(VariableSpecDIE);
1739 DIEBlock *Block = new DIEBlock();
1740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1741 addLabel(Block, 0, dwarf::DW_FORM_udata,
1742 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1743 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1745 addToContextOwner(VariableDie, GVContext);
1747 // Expose as global. FIXME - need to check external flag.
1748 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1750 DIType GTy = DI_GV.getType();
1751 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1752 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1753 assert (Entry && "Missing global type!");
1754 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1759 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1762 // Check for pre-existence.
1763 if (ModuleCU->getDIE(N))
1766 if (!SP.isDefinition())
1767 // This is a method declaration which will be handled while constructing
1771 DIE *SubprogramDie = createSubprogramDIE(SP);
1774 ModuleCU->insertDIE(N, SubprogramDie);
1776 // Add to context owner.
1777 addToContextOwner(SubprogramDie, SP.getContext());
1779 // Expose as global.
1780 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1785 /// beginModule - Emit all Dwarf sections that should come prior to the
1786 /// content. Create global DIEs and emit initial debug info sections.
1787 /// This is inovked by the target AsmPrinter.
1788 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1791 if (!MAI->doesSupportDebugInformation())
1794 TimeRegion Timer(DebugTimer);
1796 DebugInfoFinder DbgFinder;
1797 DbgFinder.processModule(*M);
1799 // Create all the compile unit DIEs.
1800 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1801 E = DbgFinder.compile_unit_end(); I != E; ++I)
1802 constructCompileUnit(*I);
1807 // Create DIEs for each subprogram.
1808 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1809 E = DbgFinder.subprogram_end(); I != E; ++I)
1810 constructSubprogramDIE(*I);
1812 // Create DIEs for each global variable.
1813 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1814 E = DbgFinder.global_variable_end(); I != E; ++I)
1815 constructGlobalVariableDIE(*I);
1819 MMI->setDebugInfoAvailability(true);
1821 // Prime section data.
1822 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1824 // Print out .file directives to specify files for .loc directives. These are
1825 // printed out early so that they precede any .loc directives.
1826 if (MAI->hasDotLocAndDotFile()) {
1827 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1828 // Remember source id starts at 1.
1829 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1830 // FIXME: don't use sys::path for this! This should not depend on the
1832 sys::Path FullPath(getSourceDirectoryName(Id.first));
1834 FullPath.appendComponent(getSourceFileName(Id.second));
1835 assert(AppendOk && "Could not append filename to directory!");
1837 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1841 // Emit initial sections
1845 /// endModule - Emit all Dwarf sections that should come after the content.
1847 void DwarfDebug::endModule() {
1851 TimeRegion Timer(DebugTimer);
1853 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1854 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1855 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1857 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1860 // Insert top level DIEs.
1861 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1862 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1863 ModuleCU->getCUDie()->addChild(*TI);
1865 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1866 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1867 DIE *SPDie = CI->first;
1868 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1870 DIE *NDie = ModuleCU->getDIE(N);
1871 if (!NDie) continue;
1872 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1873 // FIXME - This is not the correct approach.
1874 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1877 // Standard sections final addresses.
1878 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1879 Asm->OutStreamer.EmitLabel(getTempLabel("text_end"));
1880 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1881 Asm->OutStreamer.EmitLabel(getTempLabel("data_end"));
1883 // End text sections.
1884 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1885 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1886 Asm->OutStreamer.EmitLabel(getDWLabel("section_end", i));
1889 // Emit common frame information.
1890 emitCommonDebugFrame();
1892 // Emit function debug frame information
1893 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1894 E = DebugFrames.end(); I != E; ++I)
1895 emitFunctionDebugFrame(*I);
1897 // Compute DIE offsets and sizes.
1898 computeSizeAndOffsets();
1900 // Emit all the DIEs into a debug info section
1903 // Corresponding abbreviations into a abbrev section.
1904 emitAbbreviations();
1906 // Emit source line correspondence into a debug line section.
1909 // Emit info into a debug pubnames section.
1910 emitDebugPubNames();
1912 // Emit info into a debug pubtypes section.
1913 emitDebugPubTypes();
1915 // Emit info into a debug loc section.
1918 // Emit info into a debug aranges section.
1921 // Emit info into a debug ranges section.
1924 // Emit info into a debug macinfo section.
1927 // Emit inline info.
1928 emitDebugInlineInfo();
1930 // Emit info into a debug str section.
1934 ModuleCU = NULL; // Reset for the next Module, if any.
1937 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1938 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1940 DILocation &ScopeLoc) {
1942 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1944 return AbsDbgVariable;
1946 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1950 AbsDbgVariable = new DbgVariable(Var, FrameIdx,
1951 NULL /* No more-abstract variable*/);
1952 Scope->addVariable(AbsDbgVariable);
1953 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1954 return AbsDbgVariable;
1957 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1958 /// FIXME : Refactor findAbstractVariable.
1959 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1960 const MachineInstr *MI,
1961 DILocation &ScopeLoc) {
1963 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1965 return AbsDbgVariable;
1967 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1971 AbsDbgVariable = new DbgVariable(Var, MI,
1972 NULL /* No more-abstract variable*/);
1973 Scope->addVariable(AbsDbgVariable);
1974 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1975 DbgValueStartMap[MI] = AbsDbgVariable;
1976 return AbsDbgVariable;
1979 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1980 void DwarfDebug::collectVariableInfo() {
1983 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1984 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1985 VE = VMap.end(); VI != VE; ++VI) {
1986 MDNode *Var = VI->first;
1988 DIVariable DV (Var);
1989 std::pair< unsigned, MDNode *> VP = VI->second;
1990 DILocation ScopeLoc(VP.second);
1993 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1995 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1996 // If variable scope is not found then skip this variable.
2000 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, ScopeLoc);
2001 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
2002 Scope->addVariable(RegVar);
2005 // Collect variable information from DBG_VALUE machine instructions;
2006 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2008 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2010 const MachineInstr *MInsn = II;
2011 if (MInsn->getOpcode() != TargetOpcode::DBG_VALUE)
2014 // FIXME : Lift this restriction.
2015 if (MInsn->getNumOperands() != 3)
2017 DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands()
2018 - 1).getMetadata()));
2019 if (DV.getTag() == dwarf::DW_TAG_arg_variable) {
2020 // FIXME Handle inlined subroutine arguments.
2021 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2022 CurrentFnDbgScope->addVariable(ArgVar);
2023 DbgValueStartMap[MInsn] = ArgVar;
2027 DebugLoc DL = MInsn->getDebugLoc();
2028 if (DL.isUnknown()) continue;
2029 DILocation ScopeLoc = MF->getDILocation(DL);
2031 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
2033 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
2034 // If variable scope is not found then skip this variable.
2038 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, ScopeLoc);
2039 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
2040 DbgValueStartMap[MInsn] = RegVar;
2041 Scope->addVariable(RegVar);
2046 /// beginScope - Process beginning of a scope.
2047 void DwarfDebug::beginScope(const MachineInstr *MI) {
2049 DebugLoc DL = MI->getDebugLoc();
2052 DILocation DILoc = MF->getDILocation(DL);
2053 if (!DILoc.getScope().Verify())
2056 // Check and update last known location info.
2057 if(DILoc.getNode() == PrevDILoc)
2059 PrevDILoc = DILoc.getNode();
2061 // DBG_VALUE instruction establishes new value.
2062 if (MI->getOpcode() == TargetOpcode::DBG_VALUE) {
2063 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2064 = DbgValueStartMap.find(MI);
2065 if (DI != DbgValueStartMap.end()) {
2066 MCSymbol *Label = recordSourceLine(DILoc.getLineNumber(),
2067 DILoc.getColumnNumber(),
2068 DILoc.getScope().getNode());
2069 DI->second->setDbgValueLabel(Label);
2074 // Emit a label to indicate location change. This is used for line
2075 // table even if this instruction does start a new scope.
2076 MCSymbol *Label = recordSourceLine(DILoc.getLineNumber(),
2077 DILoc.getColumnNumber(),
2078 DILoc.getScope().getNode());
2080 // update DbgScope if this instruction starts a new scope.
2081 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2082 if (I == DbgScopeBeginMap.end())
2085 ScopeVector &SD = I->second;
2086 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
2088 (*SDI)->setStartLabel(Label);
2091 /// endScope - Process end of a scope.
2092 void DwarfDebug::endScope(const MachineInstr *MI) {
2093 // Ignore DBG_VALUE instruction.
2094 if (MI->getOpcode() == TargetOpcode::DBG_VALUE)
2098 DebugLoc DL = MI->getDebugLoc();
2101 DILocation DILoc = MF->getDILocation(DL);
2102 if (!DILoc.getScope().Verify())
2105 // Emit a label and update DbgScope if this instruction ends a scope.
2106 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
2107 if (I == DbgScopeEndMap.end())
2110 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2111 Asm->OutStreamer.EmitLabel(Label);
2113 SmallVector<DbgScope*, 2> &SD = I->second;
2114 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
2116 (*SDI)->setEndLabel(Label);
2120 /// createDbgScope - Create DbgScope for the scope.
2121 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
2124 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2127 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2128 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2129 if (DIDescriptor(Scope).isLexicalBlock())
2130 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
2134 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2138 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2139 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2140 DILocation DL(InlinedAt);
2141 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
2144 /// extractScopeInformation - Scan machine instructions in this function
2145 /// and collect DbgScopes. Return true, if atleast one scope was found.
2146 bool DwarfDebug::extractScopeInformation() {
2147 // If scope information was extracted using .dbg intrinsics then there is not
2148 // any need to extract these information by scanning each instruction.
2149 if (!DbgScopeMap.empty())
2152 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2153 unsigned MIIndex = 0;
2154 // Scan each instruction and create scopes. First build working set of scopes.
2155 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2157 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2159 const MachineInstr *MInsn = II;
2160 // FIXME : Remove DBG_VALUE check.
2161 if (MInsn->getOpcode() == TargetOpcode::DBG_VALUE) continue;
2162 MIIndexMap[MInsn] = MIIndex++;
2163 DebugLoc DL = MInsn->getDebugLoc();
2164 if (DL.isUnknown()) continue;
2165 DILocation DLT = MF->getDILocation(DL);
2166 DIScope DLTScope = DLT.getScope();
2167 if (!DLTScope.getNode()) continue;
2168 // There is no need to create another DIE for compile unit. For all
2169 // other scopes, create one DbgScope now. This will be translated
2170 // into a scope DIE at the end.
2171 if (DLTScope.isCompileUnit()) continue;
2172 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2177 // Build scope hierarchy using working set of scopes.
2178 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2180 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2182 const MachineInstr *MInsn = II;
2183 // FIXME : Remove DBG_VALUE check.
2184 if (MInsn->getOpcode() == TargetOpcode::DBG_VALUE) continue;
2185 DebugLoc DL = MInsn->getDebugLoc();
2186 if (DL.isUnknown()) continue;
2187 DILocation DLT = MF->getDILocation(DL);
2188 DIScope DLTScope = DLT.getScope();
2189 if (!DLTScope.getNode()) continue;
2190 // There is no need to create another DIE for compile unit. For all
2191 // other scopes, create one DbgScope now. This will be translated
2192 // into a scope DIE at the end.
2193 if (DLTScope.isCompileUnit()) continue;
2194 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2195 DLT.getOrigLocation().getNode());
2196 Scope->setLastInsn(MInsn);
2200 if (!CurrentFnDbgScope)
2203 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2205 // Each scope has first instruction and last instruction to mark beginning
2206 // and end of a scope respectively. Create an inverse map that list scopes
2207 // starts (and ends) with an instruction. One instruction may start (or end)
2208 // multiple scopes. Ignore scopes that are not reachable.
2209 SmallVector<DbgScope *, 4> WorkList;
2210 WorkList.push_back(CurrentFnDbgScope);
2211 while (!WorkList.empty()) {
2212 DbgScope *S = WorkList.back(); WorkList.pop_back();
2214 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2215 if (!Children.empty())
2216 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2217 SE = Children.end(); SI != SE; ++SI)
2218 WorkList.push_back(*SI);
2220 if (S->isAbstractScope())
2222 const MachineInstr *MI = S->getFirstInsn();
2223 assert (MI && "DbgScope does not have first instruction!");
2225 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2226 if (IDI != DbgScopeBeginMap.end())
2227 IDI->second.push_back(S);
2229 DbgScopeBeginMap[MI].push_back(S);
2231 MI = S->getLastInsn();
2232 assert (MI && "DbgScope does not have last instruction!");
2233 IDI = DbgScopeEndMap.find(MI);
2234 if (IDI != DbgScopeEndMap.end())
2235 IDI->second.push_back(S);
2237 DbgScopeEndMap[MI].push_back(S);
2240 return !DbgScopeMap.empty();
2243 /// beginFunction - Gather pre-function debug information. Assumes being
2244 /// emitted immediately after the function entry point.
2245 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2248 if (!ShouldEmitDwarfDebug()) return;
2249 if (!extractScopeInformation())
2252 TimeRegion Timer(DebugTimer);
2254 collectVariableInfo();
2256 // Assumes in correct section after the entry point.
2257 Asm->OutStreamer.EmitLabel(getDWLabel("func_begin", ++SubprogramCount));
2259 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2261 DebugLoc FDL = MF->getDefaultDebugLoc();
2262 if (!FDL.isUnknown()) {
2263 DILocation DLT = MF->getDILocation(FDL);
2264 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2267 Line = SP.getLineNumber();
2270 Line = DLT.getLineNumber();
2271 Col = DLT.getColumnNumber();
2274 recordSourceLine(Line, Col, DLT.getScope().getNode());
2278 /// endFunction - Gather and emit post-function debug information.
2280 void DwarfDebug::endFunction(const MachineFunction *MF) {
2281 if (!ShouldEmitDwarfDebug()) return;
2282 if (DbgScopeMap.empty()) return;
2284 TimeRegion Timer(DebugTimer);
2286 if (CurrentFnDbgScope) {
2287 // Define end label for subprogram.
2288 Asm->OutStreamer.EmitLabel(getDWLabel("func_end", SubprogramCount));
2290 // Get function line info.
2291 if (!Lines.empty()) {
2292 // Get section line info.
2293 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2294 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2295 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2296 // Append the function info to section info.
2297 SectionLineInfos.insert(SectionLineInfos.end(),
2298 Lines.begin(), Lines.end());
2301 // Construct abstract scopes.
2302 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2303 AE = AbstractScopesList.end(); AI != AE; ++AI)
2304 constructScopeDIE(*AI);
2306 constructScopeDIE(CurrentFnDbgScope);
2308 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2309 MMI->getFrameMoves()));
2313 CurrentFnDbgScope = NULL;
2314 DeleteContainerSeconds(DbgScopeMap);
2315 DbgScopeBeginMap.clear();
2316 DbgScopeEndMap.clear();
2317 DbgValueStartMap.clear();
2318 ConcreteScopes.clear();
2319 DeleteContainerSeconds(AbstractScopes);
2320 AbstractScopesList.clear();
2321 AbstractVariables.clear();
2325 /// recordSourceLine - Register a source line with debug info. Returns the
2326 /// unique label that was emitted and which provides correspondence to
2327 /// the source line list.
2328 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
2332 TimeRegion Timer(DebugTimer);
2337 DIDescriptor Scope(S);
2338 if (Scope.isCompileUnit()) {
2339 DICompileUnit CU(S);
2340 Dir = CU.getDirectory();
2341 Fn = CU.getFilename();
2342 } else if (Scope.isSubprogram()) {
2344 Dir = SP.getDirectory();
2345 Fn = SP.getFilename();
2346 } else if (Scope.isLexicalBlock()) {
2347 DILexicalBlock DB(S);
2348 Dir = DB.getDirectory();
2349 Fn = DB.getFilename();
2351 assert(0 && "Unexpected scope info");
2353 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2354 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2355 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2357 Asm->OutStreamer.EmitLabel(Label);
2361 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2362 /// timed. Look up the source id with the given directory and source file
2363 /// names. If none currently exists, create a new id and insert it in the
2364 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2366 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2367 const std::string &FileName) {
2368 TimeRegion Timer(DebugTimer);
2369 return GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2372 //===----------------------------------------------------------------------===//
2374 //===----------------------------------------------------------------------===//
2376 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2379 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2380 // Get the children.
2381 const std::vector<DIE *> &Children = Die->getChildren();
2383 // If not last sibling and has children then add sibling offset attribute.
2384 if (!Last && !Children.empty())
2385 DIEValues.push_back(Die->addSiblingOffset());
2387 // Record the abbreviation.
2388 assignAbbrevNumber(Die->getAbbrev());
2390 // Get the abbreviation for this DIE.
2391 unsigned AbbrevNumber = Die->getAbbrevNumber();
2392 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2395 Die->setOffset(Offset);
2397 // Start the size with the size of abbreviation code.
2398 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2400 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2401 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2403 // Size the DIE attribute values.
2404 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2405 // Size attribute value.
2406 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2408 // Size the DIE children if any.
2409 if (!Children.empty()) {
2410 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2411 "Children flag not set");
2413 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2414 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2416 // End of children marker.
2417 Offset += sizeof(int8_t);
2420 Die->setSize(Offset - Die->getOffset());
2424 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2426 void DwarfDebug::computeSizeAndOffsets() {
2427 // Compute size of compile unit header.
2428 static unsigned Offset =
2429 sizeof(int32_t) + // Length of Compilation Unit Info
2430 sizeof(int16_t) + // DWARF version number
2431 sizeof(int32_t) + // Offset Into Abbrev. Section
2432 sizeof(int8_t); // Pointer Size (in bytes)
2434 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2435 CompileUnitOffsets[ModuleCU] = 0;
2438 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2439 /// tools to recognize the object file contains Dwarf information.
2440 void DwarfDebug::emitInitial() {
2441 // Check to see if we already emitted intial headers.
2442 if (didInitial) return;
2445 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2447 // Dwarf sections base addresses.
2448 if (MAI->doesDwarfRequireFrameSection()) {
2449 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2450 Asm->OutStreamer.EmitLabel(getTempLabel("section_debug_frame"));
2453 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2454 Asm->OutStreamer.EmitLabel(getTempLabel("section_info"));
2455 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2456 Asm->OutStreamer.EmitLabel(getTempLabel("section_abbrev"));
2457 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2458 Asm->OutStreamer.EmitLabel(getTempLabel("section_aranges"));
2460 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2461 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2462 Asm->OutStreamer.EmitLabel(getTempLabel("section_macinfo"));
2465 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2466 Asm->OutStreamer.EmitLabel(getTempLabel("section_line"));
2467 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2468 Asm->OutStreamer.EmitLabel(getTempLabel("section_loc"));
2469 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2470 Asm->OutStreamer.EmitLabel(getTempLabel("section_pubnames"));
2471 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2472 Asm->OutStreamer.EmitLabel(getTempLabel("section_pubtypes"));
2473 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2474 Asm->OutStreamer.EmitLabel(getTempLabel("section_str"));
2475 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2476 Asm->OutStreamer.EmitLabel(getTempLabel("section_ranges"));
2478 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2479 Asm->OutStreamer.EmitLabel(getTempLabel("text_begin"));
2480 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2481 Asm->OutStreamer.EmitLabel(getTempLabel("data_begin"));
2484 /// emitDIE - Recusively Emits a debug information entry.
2486 void DwarfDebug::emitDIE(DIE *Die) {
2487 // Get the abbreviation for this DIE.
2488 unsigned AbbrevNumber = Die->getAbbrevNumber();
2489 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2491 // Emit the code (index) for the abbreviation.
2492 if (Asm->VerboseAsm)
2493 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2494 Twine::utohexstr(Die->getOffset()) + ":0x" +
2495 Twine::utohexstr(Die->getSize()) + " " +
2496 dwarf::TagString(Abbrev->getTag()));
2497 EmitULEB128(AbbrevNumber);
2499 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2500 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2502 // Emit the DIE attribute values.
2503 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2504 unsigned Attr = AbbrevData[i].getAttribute();
2505 unsigned Form = AbbrevData[i].getForm();
2506 assert(Form && "Too many attributes for DIE (check abbreviation)");
2508 if (Asm->VerboseAsm)
2509 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2512 case dwarf::DW_AT_sibling:
2513 Asm->EmitInt32(Die->getSiblingOffset());
2515 case dwarf::DW_AT_abstract_origin: {
2516 DIEEntry *E = cast<DIEEntry>(Values[i]);
2517 DIE *Origin = E->getEntry();
2518 unsigned Addr = Origin->getOffset();
2519 Asm->EmitInt32(Addr);
2523 // Emit an attribute using the defined form.
2524 Values[i]->EmitValue(this, Form);
2529 // Emit the DIE children if any.
2530 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2531 const std::vector<DIE *> &Children = Die->getChildren();
2533 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2534 emitDIE(Children[j]);
2536 if (Asm->VerboseAsm)
2537 Asm->OutStreamer.AddComment("End Of Children Mark");
2542 /// emitDebugInfo - Emit the debug info section.
2544 void DwarfDebug::emitDebugInfo() {
2545 // Start debug info section.
2546 Asm->OutStreamer.SwitchSection(
2547 Asm->getObjFileLowering().getDwarfInfoSection());
2548 DIE *Die = ModuleCU->getCUDie();
2550 // Emit the compile units header.
2551 Asm->OutStreamer.EmitLabel(getDWLabel("info_begin", ModuleCU->getID()));
2553 // Emit size of content not including length itself
2554 unsigned ContentSize = Die->getSize() +
2555 sizeof(int16_t) + // DWARF version number
2556 sizeof(int32_t) + // Offset Into Abbrev. Section
2557 sizeof(int8_t) + // Pointer Size (in bytes)
2558 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2560 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2561 Asm->EmitInt32(ContentSize);
2562 Asm->OutStreamer.AddComment("DWARF version number");
2563 Asm->EmitInt16(dwarf::DWARF_VERSION);
2564 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2565 EmitSectionOffset(getTempLabel("abbrev_begin"),getTempLabel("section_abbrev"),
2567 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2568 Asm->EmitInt8(TD->getPointerSize());
2571 // FIXME - extra padding for gdb bug.
2572 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2577 Asm->OutStreamer.EmitLabel(getDWLabel("info_end", ModuleCU->getID()));
2580 /// emitAbbreviations - Emit the abbreviation section.
2582 void DwarfDebug::emitAbbreviations() const {
2583 // Check to see if it is worth the effort.
2584 if (!Abbreviations.empty()) {
2585 // Start the debug abbrev section.
2586 Asm->OutStreamer.SwitchSection(
2587 Asm->getObjFileLowering().getDwarfAbbrevSection());
2589 Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_begin"));
2591 // For each abbrevation.
2592 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2593 // Get abbreviation data
2594 const DIEAbbrev *Abbrev = Abbreviations[i];
2596 // Emit the abbrevations code (base 1 index.)
2597 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2599 // Emit the abbreviations data.
2603 // Mark end of abbreviations.
2604 EmitULEB128(0, "EOM(3)");
2606 Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_end"));
2610 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2611 /// the line matrix.
2613 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2614 // Define last address of section.
2615 Asm->OutStreamer.AddComment("Extended Op");
2618 Asm->OutStreamer.AddComment("Op size");
2619 Asm->EmitInt8(TD->getPointerSize() + 1);
2620 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2621 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2623 Asm->OutStreamer.AddComment("Section end label");
2625 Asm->OutStreamer.EmitSymbolValue(getDWLabel("section_end", SectionEnd),
2626 TD->getPointerSize(), 0/*AddrSpace*/);
2628 // Mark end of matrix.
2629 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2635 /// emitDebugLines - Emit source line information.
2637 void DwarfDebug::emitDebugLines() {
2638 // If the target is using .loc/.file, the assembler will be emitting the
2639 // .debug_line table automatically.
2640 if (MAI->hasDotLocAndDotFile())
2643 // Minimum line delta, thus ranging from -10..(255-10).
2644 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2645 // Maximum line delta, thus ranging from -10..(255-10).
2646 const int MaxLineDelta = 255 + MinLineDelta;
2648 // Start the dwarf line section.
2649 Asm->OutStreamer.SwitchSection(
2650 Asm->getObjFileLowering().getDwarfLineSection());
2652 // Construct the section header.
2653 Asm->OutStreamer.AddComment("Length of Source Line Info");
2654 EmitDifference(getTempLabel("line_end"), getTempLabel("line_begin"), true);
2655 Asm->OutStreamer.EmitLabel(getTempLabel("line_begin"));
2657 Asm->OutStreamer.AddComment("DWARF version number");
2658 Asm->EmitInt16(dwarf::DWARF_VERSION);
2660 Asm->OutStreamer.AddComment("Prolog Length");
2661 EmitDifference(getTempLabel("line_prolog_end"),
2662 getTempLabel("line_prolog_begin"), true);
2663 Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_begin"));
2665 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2667 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2669 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2670 Asm->EmitInt8(MinLineDelta);
2671 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2672 Asm->EmitInt8(MaxLineDelta);
2673 Asm->OutStreamer.AddComment("Special Opcode Base");
2674 Asm->EmitInt8(-MinLineDelta);
2676 // Line number standard opcode encodings argument count
2677 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2679 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2681 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2683 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2685 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2687 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2689 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2691 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2693 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2696 // Emit directories.
2697 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2698 const std::string &Dir = getSourceDirectoryName(DI);
2699 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2700 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2703 Asm->OutStreamer.AddComment("End of directories");
2707 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2708 // Remember source id starts at 1.
2709 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2710 const std::string &FN = getSourceFileName(Id.second);
2711 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2712 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2714 EmitULEB128(Id.first, "Directory #");
2715 EmitULEB128(0, "Mod date");
2716 EmitULEB128(0, "File size");
2719 Asm->OutStreamer.AddComment("End of files");
2722 Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_end"));
2724 // A sequence for each text section.
2725 unsigned SecSrcLinesSize = SectionSourceLines.size();
2727 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2728 // Isolate current sections line info.
2729 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2731 // Dwarf assumes we start with first line of first source file.
2732 unsigned Source = 1;
2735 // Construct rows of the address, source, line, column matrix.
2736 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2737 const SrcLineInfo &LineInfo = LineInfos[i];
2738 MCSymbol *Label = LineInfo.getLabel();
2739 if (!Label->isDefined()) continue; // Not emitted, in dead code.
2741 if (LineInfo.getLine() == 0) continue;
2743 if (Asm->isVerbose()) {
2744 std::pair<unsigned, unsigned> SrcID =
2745 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2746 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
2748 Twine(getSourceFileName(SrcID.second)) +
2749 ":" + Twine(LineInfo.getLine()));
2752 // Define the line address.
2753 Asm->OutStreamer.AddComment("Extended Op");
2755 Asm->OutStreamer.AddComment("Op size");
2756 Asm->EmitInt8(TD->getPointerSize() + 1);
2758 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2759 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2761 Asm->OutStreamer.AddComment("Location label");
2762 Asm->OutStreamer.EmitSymbolValue(Label, TD->getPointerSize(),
2765 // If change of source, then switch to the new source.
2766 if (Source != LineInfo.getSourceID()) {
2767 Source = LineInfo.getSourceID();
2768 Asm->OutStreamer.AddComment("DW_LNS_set_file");
2769 Asm->EmitInt8(dwarf::DW_LNS_set_file);
2770 EmitULEB128(Source, "New Source");
2773 // If change of line.
2774 if (Line != LineInfo.getLine()) {
2775 // Determine offset.
2776 int Offset = LineInfo.getLine() - Line;
2777 int Delta = Offset - MinLineDelta;
2780 Line = LineInfo.getLine();
2782 // If delta is small enough and in range...
2783 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2784 // ... then use fast opcode.
2785 Asm->OutStreamer.AddComment("Line Delta");
2786 Asm->EmitInt8(Delta - MinLineDelta);
2788 // ... otherwise use long hand.
2789 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
2790 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2791 EmitSLEB128(Offset, "Line Offset");
2792 Asm->OutStreamer.AddComment("DW_LNS_copy");
2793 Asm->EmitInt8(dwarf::DW_LNS_copy);
2796 // Copy the previous row (different address or source)
2797 Asm->OutStreamer.AddComment("DW_LNS_copy");
2798 Asm->EmitInt8(dwarf::DW_LNS_copy);
2802 emitEndOfLineMatrix(j + 1);
2805 if (SecSrcLinesSize == 0)
2806 // Because we're emitting a debug_line section, we still need a line
2807 // table. The linker and friends expect it to exist. If there's nothing to
2808 // put into it, emit an empty table.
2809 emitEndOfLineMatrix(1);
2811 Asm->OutStreamer.EmitLabel(getTempLabel("line_end"));
2814 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2816 void DwarfDebug::emitCommonDebugFrame() {
2817 if (!MAI->doesDwarfRequireFrameSection())
2821 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2822 TargetFrameInfo::StackGrowsUp ?
2823 TD->getPointerSize() : -TD->getPointerSize();
2825 // Start the dwarf frame section.
2826 Asm->OutStreamer.SwitchSection(
2827 Asm->getObjFileLowering().getDwarfFrameSection());
2829 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common"));
2830 Asm->OutStreamer.AddComment("Length of Common Information Entry");
2831 EmitDifference(getTempLabel("debug_frame_common_end"),
2832 getTempLabel("debug_frame_common_begin"), true);
2834 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_begin"));
2835 Asm->OutStreamer.AddComment("CIE Identifier Tag");
2836 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2837 Asm->OutStreamer.AddComment("CIE Version");
2838 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2839 Asm->OutStreamer.AddComment("CIE Augmentation");
2840 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2841 EmitULEB128(1, "CIE Code Alignment Factor");
2842 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2843 Asm->OutStreamer.AddComment("CIE RA Column");
2844 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2846 std::vector<MachineMove> Moves;
2847 RI->getInitialFrameState(Moves);
2849 EmitFrameMoves(0, Moves, false);
2851 Asm->EmitAlignment(2, 0, 0, false);
2852 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_end"));
2855 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2858 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
2859 if (!MAI->doesDwarfRequireFrameSection())
2862 // Start the dwarf frame section.
2863 Asm->OutStreamer.SwitchSection(
2864 Asm->getObjFileLowering().getDwarfFrameSection());
2866 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
2867 MCSymbol *DebugFrameBegin =
2868 getDWLabel("debug_frame_begin", DebugFrameInfo.Number);
2869 MCSymbol *DebugFrameEnd =
2870 getDWLabel("debug_frame_end", DebugFrameInfo.Number);
2871 EmitDifference(DebugFrameEnd, DebugFrameBegin, true);
2873 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
2875 Asm->OutStreamer.AddComment("FDE CIE offset");
2876 EmitSectionOffset(getTempLabel("debug_frame_common"),
2877 getTempLabel("section_debug_frame"), true);
2879 Asm->OutStreamer.AddComment("FDE initial location");
2880 MCSymbol *FuncBeginSym = getDWLabel("func_begin", DebugFrameInfo.Number);
2881 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
2882 TD->getPointerSize(), 0/*AddrSpace*/);
2885 Asm->OutStreamer.AddComment("FDE address range");
2886 EmitDifference(getDWLabel("func_end", DebugFrameInfo.Number), FuncBeginSym);
2888 EmitFrameMoves(FuncBeginSym, DebugFrameInfo.Moves, false);
2890 Asm->EmitAlignment(2, 0, 0, false);
2891 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
2894 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2896 void DwarfDebug::emitDebugPubNames() {
2897 // Start the dwarf pubnames section.
2898 Asm->OutStreamer.SwitchSection(
2899 Asm->getObjFileLowering().getDwarfPubNamesSection());
2901 Asm->OutStreamer.AddComment("Length of Public Names Info");
2902 EmitDifference(getDWLabel("pubnames_end", ModuleCU->getID()),
2903 getDWLabel("pubnames_begin", ModuleCU->getID()), true);
2905 Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_begin", ModuleCU->getID()));
2907 Asm->OutStreamer.AddComment("DWARF Version");
2908 Asm->EmitInt16(dwarf::DWARF_VERSION);
2910 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2911 EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2912 getTempLabel("section_info"), true);
2914 Asm->OutStreamer.AddComment("Compilation Unit Length");
2915 EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2916 getDWLabel("info_begin", ModuleCU->getID()),
2919 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2920 for (StringMap<DIE*>::const_iterator
2921 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2922 const char *Name = GI->getKeyData();
2923 DIE *Entity = GI->second;
2925 Asm->OutStreamer.AddComment("DIE offset");
2926 Asm->EmitInt32(Entity->getOffset());
2928 if (Asm->VerboseAsm)
2929 Asm->OutStreamer.AddComment("External Name");
2930 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2933 Asm->OutStreamer.AddComment("End Mark");
2935 Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_end", ModuleCU->getID()));
2938 void DwarfDebug::emitDebugPubTypes() {
2939 // Start the dwarf pubnames section.
2940 Asm->OutStreamer.SwitchSection(
2941 Asm->getObjFileLowering().getDwarfPubTypesSection());
2942 Asm->OutStreamer.AddComment("Length of Public Types Info");
2943 EmitDifference(getDWLabel("pubtypes_end", ModuleCU->getID()),
2944 getDWLabel("pubtypes_begin", ModuleCU->getID()), true);
2946 Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_begin", ModuleCU->getID()));
2948 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version");
2949 Asm->EmitInt16(dwarf::DWARF_VERSION);
2951 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
2952 EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()),
2953 getTempLabel("section_info"), true);
2955 Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
2956 EmitDifference(getDWLabel("info_end", ModuleCU->getID()),
2957 getDWLabel("info_begin", ModuleCU->getID()),
2960 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2961 for (StringMap<DIE*>::const_iterator
2962 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2963 const char *Name = GI->getKeyData();
2964 DIE * Entity = GI->second;
2966 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
2967 Asm->EmitInt32(Entity->getOffset());
2969 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2970 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2973 Asm->OutStreamer.AddComment("End Mark");
2975 Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_end", ModuleCU->getID()));
2978 /// emitDebugStr - Emit visible names into a debug str section.
2980 void DwarfDebug::emitDebugStr() {
2981 // Check to see if it is worth the effort.
2982 if (StringPool.empty()) return;
2984 // Start the dwarf str section.
2985 Asm->OutStreamer.SwitchSection(
2986 Asm->getObjFileLowering().getDwarfStrSection());
2988 // Get all of the string pool entries and put them in an array by their ID so
2989 // we can sort them.
2990 SmallVector<std::pair<unsigned,
2991 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2993 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2994 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2995 Entries.push_back(std::make_pair(I->second.second, &*I));
2997 array_pod_sort(Entries.begin(), Entries.end());
2999 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3000 // Emit a label for reference from debug information entries.
3001 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3003 // Emit the string itself.
3004 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3008 /// emitDebugLoc - Emit visible names into a debug loc section.
3010 void DwarfDebug::emitDebugLoc() {
3011 // Start the dwarf loc section.
3012 Asm->OutStreamer.SwitchSection(
3013 Asm->getObjFileLowering().getDwarfLocSection());
3016 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3018 void DwarfDebug::EmitDebugARanges() {
3019 // Start the dwarf aranges section.
3020 Asm->OutStreamer.SwitchSection(
3021 Asm->getObjFileLowering().getDwarfARangesSection());
3024 /// emitDebugRanges - Emit visible names into a debug ranges section.
3026 void DwarfDebug::emitDebugRanges() {
3027 // Start the dwarf ranges section.
3028 Asm->OutStreamer.SwitchSection(
3029 Asm->getObjFileLowering().getDwarfRangesSection());
3032 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3034 void DwarfDebug::emitDebugMacInfo() {
3035 if (const MCSection *LineInfo =
3036 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3037 // Start the dwarf macinfo section.
3038 Asm->OutStreamer.SwitchSection(LineInfo);
3042 /// emitDebugInlineInfo - Emit inline info using following format.
3044 /// 1. length of section
3045 /// 2. Dwarf version number
3046 /// 3. address size.
3048 /// Entries (one "entry" for each function that was inlined):
3050 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3051 /// otherwise offset into __debug_str for regular function name.
3052 /// 2. offset into __debug_str section for regular function name.
3053 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3054 /// instances for the function.
3056 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3057 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3058 /// __debug_info section, and the low_pc is the starting address for the
3059 /// inlining instance.
3060 void DwarfDebug::emitDebugInlineInfo() {
3061 if (!MAI->doesDwarfUsesInlineInfoSection())
3067 Asm->OutStreamer.SwitchSection(
3068 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3070 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3071 EmitDifference(getDWLabel("debug_inlined_end", 1),
3072 getDWLabel("debug_inlined_begin", 1), true);
3074 Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_begin", 1));
3076 Asm->OutStreamer.AddComment("Dwarf Version");
3077 Asm->EmitInt16(dwarf::DWARF_VERSION);
3078 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3079 Asm->EmitInt8(TD->getPointerSize());
3081 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3082 E = InlinedSPNodes.end(); I != E; ++I) {
3085 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3086 = InlineInfo.find(Node);
3087 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3088 DISubprogram SP(Node);
3089 StringRef LName = SP.getLinkageName();
3090 StringRef Name = SP.getName();
3092 Asm->OutStreamer.AddComment("MIPS linkage name");
3093 if (LName.empty()) {
3094 Asm->OutStreamer.EmitBytes(Name, 0);
3095 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3097 EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3098 getTempLabel("section_str"), true);
3100 Asm->OutStreamer.AddComment("Function name");
3101 EmitSectionOffset(getStringPoolEntry(Name), getTempLabel("section_str"),
3103 EmitULEB128(Labels.size(), "Inline count");
3105 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3106 LE = Labels.end(); LI != LE; ++LI) {
3107 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset");
3108 Asm->EmitInt32(LI->second->getOffset());
3110 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("low_pc");
3111 Asm->OutStreamer.EmitSymbolValue(LI->first, TD->getPointerSize(), 0);
3115 Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_end", 1));