1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
13 #define DEBUG_TYPE "dwarfdebug"
14 #include "DwarfDebug.h"
15 #include "llvm/Module.h"
16 #include "llvm/CodeGen/MachineFunction.h"
17 #include "llvm/CodeGen/MachineModuleInfo.h"
18 #include "llvm/MC/MCSection.h"
19 #include "llvm/MC/MCStreamer.h"
20 #include "llvm/MC/MCAsmInfo.h"
21 #include "llvm/Target/TargetData.h"
22 #include "llvm/Target/TargetFrameInfo.h"
23 #include "llvm/Target/TargetLoweringObjectFile.h"
24 #include "llvm/Target/TargetRegisterInfo.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/Support/Debug.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/Mangler.h"
29 #include "llvm/Support/Timer.h"
30 #include "llvm/System/Path.h"
33 static TimerGroup &getDwarfTimerGroup() {
34 static TimerGroup DwarfTimerGroup("Dwarf Debugging");
35 return DwarfTimerGroup;
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.
58 /// IndexTyDie - An anonymous type for index type.
61 /// GVToDieMap - Tracks the mapping of unit level debug informaton
62 /// variables to debug information entries.
63 /// FIXME : Rename GVToDieMap -> NodeToDieMap
64 ValueMap<MDNode *, DIE *> GVToDieMap;
66 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
67 /// descriptors to debug information entries using a DIEEntry proxy.
69 ValueMap<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) {}
82 ~CompileUnit() { delete CUDie; delete IndexTyDie; }
85 unsigned getID() const { return ID; }
86 DIE* getCUDie() const { return CUDie; }
87 const StringMap<DIE*> &getGlobals() const { return Globals; }
88 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
90 /// hasContent - Return true if this compile unit has something to write out.
92 bool hasContent() const { return !CUDie->getChildren().empty(); }
94 /// addGlobal - Add a new global entity to the compile unit.
96 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
98 /// addGlobalType - Add a new global type to the compile unit.
100 void addGlobalType(const std::string &Name, DIE *Die) {
101 GlobalTypes[Name] = Die;
104 /// getDIE - Returns the debug information entry map slot for the
105 /// specified debug variable.
106 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
108 /// insertDIE - Insert DIE into the map.
109 void insertDIE(MDNode *N, DIE *D) {
110 GVToDieMap.insert(std::make_pair(N, D));
113 /// getDIEEntry - Returns the debug information entry for the speciefied
115 DIEEntry *getDIEEntry(MDNode *N) { return GVToDIEEntryMap.lookup(N); }
117 /// insertDIEEntry - Insert debug information entry into the map.
118 void insertDIEEntry(MDNode *N, DIEEntry *E) {
119 GVToDIEEntryMap.insert(std::make_pair(N, E));
122 /// addDie - Adds or interns the DIE to the compile unit.
124 void addDie(DIE *Buffer) {
125 this->CUDie->addChild(Buffer);
128 // getIndexTyDie - Get an anonymous type for index type.
129 DIE *getIndexTyDie() {
133 // setIndexTyDie - Set D as anonymous type for index which can be reused
135 void setIndexTyDie(DIE *D) {
141 //===----------------------------------------------------------------------===//
142 /// DbgVariable - This class is used to track local variable information.
145 DIVariable Var; // Variable Descriptor.
146 unsigned FrameIndex; // Variable frame index.
147 DbgVariable *AbstractVar; // Abstract variable for this variable.
150 DbgVariable(DIVariable V, unsigned I)
151 : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0) {}
154 DIVariable getVariable() const { return Var; }
155 unsigned getFrameIndex() const { return FrameIndex; }
156 void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
157 DbgVariable *getAbstractVariable() const { return AbstractVar; }
158 void setDIE(DIE *D) { TheDIE = D; }
159 DIE *getDIE() const { return TheDIE; }
162 //===----------------------------------------------------------------------===//
163 /// DbgScope - This class is used to track scope information.
166 DbgScope *Parent; // Parent to this scope.
167 DIDescriptor Desc; // Debug info descriptor for scope.
168 WeakVH InlinedAtLocation; // Location at which scope is inlined.
169 bool AbstractScope; // Abstract Scope
170 unsigned StartLabelID; // Label ID of the beginning of scope.
171 unsigned EndLabelID; // Label ID of the end of scope.
172 const MachineInstr *LastInsn; // Last instruction of this scope.
173 const MachineInstr *FirstInsn; // First instruction of this scope.
174 SmallVector<DbgScope *, 4> Scopes; // Scopes defined in scope.
175 SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
177 // Private state for dump()
178 mutable unsigned IndentLevel;
180 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
181 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
182 StartLabelID(0), EndLabelID(0),
183 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
187 DbgScope *getParent() const { return Parent; }
188 void setParent(DbgScope *P) { Parent = P; }
189 DIDescriptor getDesc() const { return Desc; }
190 MDNode *getInlinedAt() const {
191 return dyn_cast_or_null<MDNode>(InlinedAtLocation);
193 MDNode *getScopeNode() const { return Desc.getNode(); }
194 unsigned getStartLabelID() const { return StartLabelID; }
195 unsigned getEndLabelID() const { return EndLabelID; }
196 SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
197 SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
198 void setStartLabelID(unsigned S) { StartLabelID = S; }
199 void setEndLabelID(unsigned E) { EndLabelID = E; }
200 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
201 const MachineInstr *getLastInsn() { return LastInsn; }
202 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
203 void setAbstractScope() { AbstractScope = true; }
204 bool isAbstractScope() const { return AbstractScope; }
205 const MachineInstr *getFirstInsn() { return FirstInsn; }
207 /// addScope - Add a scope to the scope.
209 void addScope(DbgScope *S) { Scopes.push_back(S); }
211 /// addVariable - Add a variable to the scope.
213 void addVariable(DbgVariable *V) { Variables.push_back(V); }
215 void fixInstructionMarkers() {
216 assert (getFirstInsn() && "First instruction is missing!");
220 // If a scope does not have an instruction to mark an end then use
221 // the end of last child scope.
222 SmallVector<DbgScope *, 4> &Scopes = getScopes();
223 assert (!Scopes.empty() && "Inner most scope does not have last insn!");
224 DbgScope *L = Scopes.back();
225 if (!L->getLastInsn())
226 L->fixInstructionMarkers();
227 setLastInsn(L->getLastInsn());
236 void DbgScope::dump() const {
237 raw_ostream &err = errs();
238 err.indent(IndentLevel);
239 MDNode *N = Desc.getNode();
241 err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
243 err << "Abstract Scope\n";
247 err << "Children ...\n";
248 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
249 if (Scopes[i] != this)
256 DbgScope::~DbgScope() {
257 for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
259 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
263 } // end llvm namespace
265 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
266 : Dwarf(OS, A, T, "dbg"), ModuleCU(0),
267 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
268 DIEValues(), StringPool(),
269 SectionSourceLines(), didInitial(false), shouldEmit(false),
270 CurrentFnDbgScope(0), DebugTimer(0) {
271 if (TimePassesIsEnabled)
272 DebugTimer = new Timer("Dwarf Debug Writer",
273 getDwarfTimerGroup());
275 DwarfDebug::~DwarfDebug() {
276 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
282 /// assignAbbrevNumber - Define a unique number for the abbreviation.
284 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
285 // Profile the node so that we can make it unique.
289 // Check the set for priors.
290 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
292 // If it's newly added.
293 if (InSet == &Abbrev) {
294 // Add to abbreviation list.
295 Abbreviations.push_back(&Abbrev);
297 // Assign the vector position + 1 as its number.
298 Abbrev.setNumber(Abbreviations.size());
300 // Assign existing abbreviation number.
301 Abbrev.setNumber(InSet->getNumber());
305 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
306 /// information entry.
307 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
308 DIEEntry *Value = new DIEEntry(Entry);
309 DIEValues.push_back(Value);
313 /// addUInt - Add an unsigned integer attribute data and value.
315 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
316 unsigned Form, uint64_t Integer) {
317 if (!Form) Form = DIEInteger::BestForm(false, Integer);
318 DIEValue *Value = new DIEInteger(Integer);
319 DIEValues.push_back(Value);
320 Die->addValue(Attribute, Form, Value);
323 /// addSInt - Add an signed integer attribute data and value.
325 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
326 unsigned Form, int64_t Integer) {
327 if (!Form) Form = DIEInteger::BestForm(true, Integer);
328 DIEValue *Value = new DIEInteger(Integer);
329 DIEValues.push_back(Value);
330 Die->addValue(Attribute, Form, Value);
333 /// addString - Add a string attribute data and value. DIEString only
334 /// keeps string reference.
335 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
336 const StringRef String) {
337 DIEValue *Value = new DIEString(String);
338 DIEValues.push_back(Value);
339 Die->addValue(Attribute, Form, Value);
342 /// addLabel - Add a Dwarf label attribute data and value.
344 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
345 const DWLabel &Label) {
346 DIEValue *Value = new DIEDwarfLabel(Label);
347 DIEValues.push_back(Value);
348 Die->addValue(Attribute, Form, Value);
351 /// addObjectLabel - Add an non-Dwarf label attribute data and value.
353 void DwarfDebug::addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
354 const std::string &Label) {
355 DIEValue *Value = new DIEObjectLabel(Label);
356 DIEValues.push_back(Value);
357 Die->addValue(Attribute, Form, Value);
360 /// addSectionOffset - Add a section offset label attribute data and value.
362 void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
363 const DWLabel &Label, const DWLabel &Section,
364 bool isEH, bool useSet) {
365 DIEValue *Value = new DIESectionOffset(Label, Section, isEH, useSet);
366 DIEValues.push_back(Value);
367 Die->addValue(Attribute, Form, Value);
370 /// addDelta - Add a label delta attribute data and value.
372 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
373 const DWLabel &Hi, const DWLabel &Lo) {
374 DIEValue *Value = new DIEDelta(Hi, Lo);
375 DIEValues.push_back(Value);
376 Die->addValue(Attribute, Form, Value);
379 /// addBlock - Add block data.
381 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
383 Block->ComputeSize(TD);
384 DIEValues.push_back(Block);
385 Die->addValue(Attribute, Block->BestForm(), Block);
388 /// addSourceLine - Add location information to specified debug information
390 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
391 // If there is no compile unit specified, don't add a line #.
392 if (V->getCompileUnit().isNull())
395 unsigned Line = V->getLineNumber();
396 unsigned FileID = findCompileUnit(V->getCompileUnit()).getID();
397 assert(FileID && "Invalid file id");
398 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
399 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
402 /// addSourceLine - Add location information to specified debug information
404 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
405 // If there is no compile unit specified, don't add a line #.
406 if (G->getCompileUnit().isNull())
409 unsigned Line = G->getLineNumber();
410 unsigned FileID = findCompileUnit(G->getCompileUnit()).getID();
411 assert(FileID && "Invalid file id");
412 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
413 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
416 /// addSourceLine - Add location information to specified debug information
418 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
419 // If there is no compile unit specified, don't add a line #.
420 if (SP->getCompileUnit().isNull())
422 // If the line number is 0, don't add it.
423 if (SP->getLineNumber() == 0)
427 unsigned Line = SP->getLineNumber();
428 unsigned FileID = findCompileUnit(SP->getCompileUnit()).getID();
429 assert(FileID && "Invalid file id");
430 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
431 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
434 /// addSourceLine - Add location information to specified debug information
436 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
437 // If there is no compile unit specified, don't add a line #.
438 DICompileUnit CU = Ty->getCompileUnit();
442 unsigned Line = Ty->getLineNumber();
443 unsigned FileID = findCompileUnit(CU).getID();
444 assert(FileID && "Invalid file id");
445 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
446 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
449 /* Byref variables, in Blocks, are declared by the programmer as
450 "SomeType VarName;", but the compiler creates a
451 __Block_byref_x_VarName struct, and gives the variable VarName
452 either the struct, or a pointer to the struct, as its type. This
453 is necessary for various behind-the-scenes things the compiler
454 needs to do with by-reference variables in blocks.
456 However, as far as the original *programmer* is concerned, the
457 variable should still have type 'SomeType', as originally declared.
459 The following function dives into the __Block_byref_x_VarName
460 struct to find the original type of the variable. This will be
461 passed back to the code generating the type for the Debug
462 Information Entry for the variable 'VarName'. 'VarName' will then
463 have the original type 'SomeType' in its debug information.
465 The original type 'SomeType' will be the type of the field named
466 'VarName' inside the __Block_byref_x_VarName struct.
468 NOTE: In order for this to not completely fail on the debugger
469 side, the Debug Information Entry for the variable VarName needs to
470 have a DW_AT_location that tells the debugger how to unwind through
471 the pointers and __Block_byref_x_VarName struct to find the actual
472 value of the variable. The function addBlockByrefType does this. */
474 /// Find the type the programmer originally declared the variable to be
475 /// and return that type.
477 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
480 unsigned tag = Ty.getTag();
482 if (tag == dwarf::DW_TAG_pointer_type) {
483 DIDerivedType DTy = DIDerivedType(Ty.getNode());
484 subType = DTy.getTypeDerivedFrom();
487 DICompositeType blockStruct = DICompositeType(subType.getNode());
489 DIArray Elements = blockStruct.getTypeArray();
491 if (Elements.isNull())
494 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
495 DIDescriptor Element = Elements.getElement(i);
496 DIDerivedType DT = DIDerivedType(Element.getNode());
497 if (Name == DT.getName())
498 return (DT.getTypeDerivedFrom());
504 /// addComplexAddress - Start with the address based on the location provided,
505 /// and generate the DWARF information necessary to find the actual variable
506 /// given the extra address information encoded in the DIVariable, starting from
507 /// the starting location. Add the DWARF information to the die.
509 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
511 const MachineLocation &Location) {
512 const DIVariable &VD = DV->getVariable();
513 DIType Ty = VD.getType();
515 // Decode the original location, and use that as the start of the byref
516 // variable's location.
517 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
518 DIEBlock *Block = new DIEBlock();
520 if (Location.isReg()) {
522 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
524 Reg = Reg - dwarf::DW_OP_reg0;
525 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
526 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
530 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
532 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
533 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
536 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
539 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
540 uint64_t Element = VD.getAddrElement(i);
542 if (Element == DIFactory::OpPlus) {
543 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
544 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
545 } else if (Element == DIFactory::OpDeref) {
546 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
547 } else llvm_unreachable("unknown DIFactory Opcode");
550 // Now attach the location information to the DIE.
551 addBlock(Die, Attribute, 0, Block);
554 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
555 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
556 gives the variable VarName either the struct, or a pointer to the struct, as
557 its type. This is necessary for various behind-the-scenes things the
558 compiler needs to do with by-reference variables in Blocks.
560 However, as far as the original *programmer* is concerned, the variable
561 should still have type 'SomeType', as originally declared.
563 The function getBlockByrefType dives into the __Block_byref_x_VarName
564 struct to find the original type of the variable, which is then assigned to
565 the variable's Debug Information Entry as its real type. So far, so good.
566 However now the debugger will expect the variable VarName to have the type
567 SomeType. So we need the location attribute for the variable to be an
568 expression that explains to the debugger how to navigate through the
569 pointers and struct to find the actual variable of type SomeType.
571 The following function does just that. We start by getting
572 the "normal" location for the variable. This will be the location
573 of either the struct __Block_byref_x_VarName or the pointer to the
574 struct __Block_byref_x_VarName.
576 The struct will look something like:
578 struct __Block_byref_x_VarName {
580 struct __Block_byref_x_VarName *forwarding;
581 ... <various other fields>
583 ... <maybe more fields>
586 If we are given the struct directly (as our starting point) we
587 need to tell the debugger to:
589 1). Add the offset of the forwarding field.
591 2). Follow that pointer to get the the real __Block_byref_x_VarName
592 struct to use (the real one may have been copied onto the heap).
594 3). Add the offset for the field VarName, to find the actual variable.
596 If we started with a pointer to the struct, then we need to
597 dereference that pointer first, before the other steps.
598 Translating this into DWARF ops, we will need to append the following
599 to the current location description for the variable:
601 DW_OP_deref -- optional, if we start with a pointer
602 DW_OP_plus_uconst <forward_fld_offset>
604 DW_OP_plus_uconst <varName_fld_offset>
606 That is what this function does. */
608 /// addBlockByrefAddress - Start with the address based on the location
609 /// provided, and generate the DWARF information necessary to find the
610 /// actual Block variable (navigating the Block struct) based on the
611 /// starting location. Add the DWARF information to the die. For
612 /// more information, read large comment just above here.
614 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
616 const MachineLocation &Location) {
617 const DIVariable &VD = DV->getVariable();
618 DIType Ty = VD.getType();
620 unsigned Tag = Ty.getTag();
621 bool isPointer = false;
623 StringRef varName = VD.getName();
625 if (Tag == dwarf::DW_TAG_pointer_type) {
626 DIDerivedType DTy = DIDerivedType(Ty.getNode());
627 TmpTy = DTy.getTypeDerivedFrom();
631 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
633 // Find the __forwarding field and the variable field in the __Block_byref
635 DIArray Fields = blockStruct.getTypeArray();
636 DIDescriptor varField = DIDescriptor();
637 DIDescriptor forwardingField = DIDescriptor();
640 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
641 DIDescriptor Element = Fields.getElement(i);
642 DIDerivedType DT = DIDerivedType(Element.getNode());
643 StringRef fieldName = DT.getName();
644 if (fieldName == "__forwarding")
645 forwardingField = Element;
646 else if (fieldName == varName)
650 assert(!varField.isNull() && "Can't find byref variable in Block struct");
651 assert(!forwardingField.isNull()
652 && "Can't find forwarding field in Block struct");
654 // Get the offsets for the forwarding field and the variable field.
655 unsigned int forwardingFieldOffset =
656 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
657 unsigned int varFieldOffset =
658 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
660 // Decode the original location, and use that as the start of the byref
661 // variable's location.
662 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
663 DIEBlock *Block = new DIEBlock();
665 if (Location.isReg()) {
667 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
669 Reg = Reg - dwarf::DW_OP_reg0;
670 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
671 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
675 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
677 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
678 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
681 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
684 // If we started with a pointer to the __Block_byref... struct, then
685 // the first thing we need to do is dereference the pointer (DW_OP_deref).
687 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
689 // Next add the offset for the '__forwarding' field:
690 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
691 // adding the offset if it's 0.
692 if (forwardingFieldOffset > 0) {
693 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
694 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
697 // Now dereference the __forwarding field to get to the real __Block_byref
698 // struct: DW_OP_deref.
699 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
701 // Now that we've got the real __Block_byref... struct, add the offset
702 // for the variable's field to get to the location of the actual variable:
703 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
704 if (varFieldOffset > 0) {
705 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
706 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
709 // Now attach the location information to the DIE.
710 addBlock(Die, Attribute, 0, Block);
713 /// addAddress - Add an address attribute to a die based on the location
715 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
716 const MachineLocation &Location) {
717 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
718 DIEBlock *Block = new DIEBlock();
720 if (Location.isReg()) {
722 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
724 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
725 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
729 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
731 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
732 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
735 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
738 addBlock(Die, Attribute, 0, Block);
741 /// addToContextOwner - Add Die into the list of its context owner's children.
742 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
743 if (Context.isNull())
744 ModuleCU->addDie(Die);
745 else if (Context.isType()) {
746 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
747 ContextDIE->addChild(Die);
748 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
749 ContextDIE->addChild(Die);
751 ModuleCU->addDie(Die);
754 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
756 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
757 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
762 TyDIE = new DIE(dwarf::DW_TAG_base_type);
763 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
764 if (Ty.isBasicType())
765 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
766 else if (Ty.isCompositeType())
767 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
769 assert(Ty.isDerivedType() && "Unknown kind of DIType");
770 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
773 addToContextOwner(TyDIE, Ty.getContext());
777 /// addType - Add a new type attribute to the specified entity.
778 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
782 // Check for pre-existence.
783 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
785 // If it exists then use the existing value.
787 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
792 Entry = createDIEEntry();
793 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
796 DIE *Buffer = getOrCreateTypeDIE(Ty);
798 Entry->setEntry(Buffer);
799 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
802 /// constructTypeDIE - Construct basic type die from DIBasicType.
803 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
804 // Get core information.
805 StringRef Name = BTy.getName();
806 Buffer.setTag(dwarf::DW_TAG_base_type);
807 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
810 // Add name if not anonymous or intermediate type.
812 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
813 uint64_t Size = BTy.getSizeInBits() >> 3;
814 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
817 /// constructTypeDIE - Construct derived type die from DIDerivedType.
818 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
819 // Get core information.
820 StringRef Name = DTy.getName();
821 uint64_t Size = DTy.getSizeInBits() >> 3;
822 unsigned Tag = DTy.getTag();
824 // FIXME - Workaround for templates.
825 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
829 // Map to main type, void will not have a type.
830 DIType FromTy = DTy.getTypeDerivedFrom();
831 addType(&Buffer, FromTy);
833 // Add name if not anonymous or intermediate type.
835 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
837 // Add size if non-zero (derived types might be zero-sized.)
839 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
841 // Add source line info if available and TyDesc is not a forward declaration.
842 if (!DTy.isForwardDecl())
843 addSourceLine(&Buffer, &DTy);
846 /// constructTypeDIE - Construct type DIE from DICompositeType.
847 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
848 // Get core information.
849 StringRef Name = CTy.getName();
851 uint64_t Size = CTy.getSizeInBits() >> 3;
852 unsigned Tag = CTy.getTag();
856 case dwarf::DW_TAG_vector_type:
857 case dwarf::DW_TAG_array_type:
858 constructArrayTypeDIE(Buffer, &CTy);
860 case dwarf::DW_TAG_enumeration_type: {
861 DIArray Elements = CTy.getTypeArray();
863 // Add enumerators to enumeration type.
864 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
866 DIEnumerator Enum(Elements.getElement(i).getNode());
867 if (!Enum.isNull()) {
868 ElemDie = constructEnumTypeDIE(&Enum);
869 Buffer.addChild(ElemDie);
874 case dwarf::DW_TAG_subroutine_type: {
876 DIArray Elements = CTy.getTypeArray();
877 DIDescriptor RTy = Elements.getElement(0);
878 addType(&Buffer, DIType(RTy.getNode()));
880 // Add prototype flag.
881 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
884 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
885 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
886 DIDescriptor Ty = Elements.getElement(i);
887 addType(Arg, DIType(Ty.getNode()));
888 Buffer.addChild(Arg);
892 case dwarf::DW_TAG_structure_type:
893 case dwarf::DW_TAG_union_type:
894 case dwarf::DW_TAG_class_type: {
895 // Add elements to structure type.
896 DIArray Elements = CTy.getTypeArray();
898 // A forward struct declared type may not have elements available.
899 if (Elements.isNull())
902 // Add elements to structure type.
903 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
904 DIDescriptor Element = Elements.getElement(i);
905 if (Element.isNull())
908 if (Element.getTag() == dwarf::DW_TAG_subprogram)
909 ElemDie = createMemberSubprogramDIE(DISubprogram(Element.getNode()));
911 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
912 Buffer.addChild(ElemDie);
915 if (CTy.isAppleBlockExtension())
916 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
918 unsigned RLang = CTy.getRunTimeLang();
920 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
921 dwarf::DW_FORM_data1, RLang);
928 // Add name if not anonymous or intermediate type.
930 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
932 if (Tag == dwarf::DW_TAG_enumeration_type ||
933 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
934 // Add size if non-zero (derived types might be zero-sized.)
936 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
938 // Add zero size if it is not a forward declaration.
939 if (CTy.isForwardDecl())
940 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
942 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
945 // Add source line info if available.
946 if (!CTy.isForwardDecl())
947 addSourceLine(&Buffer, &CTy);
951 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
952 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
953 int64_t L = SR.getLo();
954 int64_t H = SR.getHi();
955 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
957 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
959 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
960 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
962 Buffer.addChild(DW_Subrange);
965 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
966 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
967 DICompositeType *CTy) {
968 Buffer.setTag(dwarf::DW_TAG_array_type);
969 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
970 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
972 // Emit derived type.
973 addType(&Buffer, CTy->getTypeDerivedFrom());
974 DIArray Elements = CTy->getTypeArray();
976 // Get an anonymous type for index type.
977 DIE *IdxTy = ModuleCU->getIndexTyDie();
979 // Construct an anonymous type for index type.
980 IdxTy = new DIE(dwarf::DW_TAG_base_type);
981 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
982 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
983 dwarf::DW_ATE_signed);
984 ModuleCU->addDie(IdxTy);
985 ModuleCU->setIndexTyDie(IdxTy);
988 // Add subranges to array type.
989 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
990 DIDescriptor Element = Elements.getElement(i);
991 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
992 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
996 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
997 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator *ETy) {
998 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
999 StringRef Name = ETy->getName();
1000 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1001 int64_t Value = ETy->getEnumValue();
1002 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1006 /// createGlobalVariableDIE - Create new DIE using GV.
1007 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1008 // If the global variable was optmized out then no need to create debug info
1010 if (!GV.getGlobal()) return NULL;
1011 if (GV.getDisplayName().empty()) return NULL;
1013 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1014 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1015 GV.getDisplayName());
1017 StringRef LinkageName = GV.getLinkageName();
1018 if (!LinkageName.empty()) {
1019 // Skip special LLVM prefix that is used to inform the asm printer to not
1020 // emit usual symbol prefix before the symbol name. This happens for
1021 // Objective-C symbol names and symbol whose name is replaced using GCC's
1022 // __asm__ attribute.
1023 if (LinkageName[0] == 1)
1024 LinkageName = LinkageName.substr(1);
1025 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1028 addType(GVDie, GV.getType());
1029 if (!GV.isLocalToUnit())
1030 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1031 addSourceLine(GVDie, &GV);
1034 DIEBlock *Block = new DIEBlock();
1035 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1036 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1037 Asm->Mang->getMangledName(GV.getGlobal()));
1038 addBlock(GVDie, dwarf::DW_AT_location, 0, Block);
1043 /// createMemberDIE - Create new member DIE.
1044 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1045 DIE *MemberDie = new DIE(DT.getTag());
1046 StringRef Name = DT.getName();
1048 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1050 addType(MemberDie, DT.getTypeDerivedFrom());
1052 addSourceLine(MemberDie, &DT);
1054 DIEBlock *MemLocationDie = new DIEBlock();
1055 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1057 uint64_t Size = DT.getSizeInBits();
1058 uint64_t FieldSize = DT.getOriginalTypeSize();
1060 if (Size != FieldSize) {
1062 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1063 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1065 uint64_t Offset = DT.getOffsetInBits();
1066 uint64_t FieldOffset = Offset;
1067 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1068 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1069 FieldOffset = (HiMark - FieldSize);
1070 Offset -= FieldOffset;
1072 // Maybe we need to work from the other end.
1073 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1074 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1076 // Here WD_AT_data_member_location points to the anonymous
1077 // field that includes this bit field.
1078 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1081 // This is not a bitfield.
1082 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1084 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1086 if (DT.isProtected())
1087 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1088 dwarf::DW_ACCESS_protected);
1089 else if (DT.isPrivate())
1090 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1091 dwarf::DW_ACCESS_private);
1092 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1093 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1094 dwarf::DW_ACCESS_public);
1096 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1097 dwarf::DW_VIRTUALITY_virtual);
1101 /// createRawSubprogramDIE - Create new partially incomplete DIE. This is
1102 /// a helper routine used by createMemberSubprogramDIE and
1103 /// createSubprogramDIE.
1104 DIE *DwarfDebug::createRawSubprogramDIE(const DISubprogram &SP) {
1105 DIE *SPDie = new DIE(dwarf::DW_TAG_subprogram);
1106 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1108 StringRef LinkageName = SP.getLinkageName();
1109 if (!LinkageName.empty()) {
1110 // Skip special LLVM prefix that is used to inform the asm printer to not
1111 // emit usual symbol prefix before the symbol name. This happens for
1112 // Objective-C symbol names and symbol whose name is replaced using GCC's
1113 // __asm__ attribute.
1114 if (LinkageName[0] == 1)
1115 LinkageName = LinkageName.substr(1);
1116 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1119 addSourceLine(SPDie, &SP);
1121 // Add prototyped tag, if C or ObjC.
1122 unsigned Lang = SP.getCompileUnit().getLanguage();
1123 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1124 Lang == dwarf::DW_LANG_ObjC)
1125 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1128 DICompositeType SPTy = SP.getType();
1129 DIArray Args = SPTy.getTypeArray();
1130 unsigned SPTag = SPTy.getTag();
1132 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1133 addType(SPDie, SPTy);
1135 addType(SPDie, DIType(Args.getElement(0).getNode()));
1137 unsigned VK = SP.getVirtuality();
1139 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1140 DIEBlock *Block = new DIEBlock();
1141 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1142 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1143 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1144 ContainingTypeMap.insert(std::make_pair(SPDie, WeakVH(SP.getContainingType().getNode())));
1150 /// createMemberSubprogramDIE - Create new member DIE using SP. This routine
1151 /// always returns a die with DW_AT_declaration attribute.
1152 DIE *DwarfDebug::createMemberSubprogramDIE(const DISubprogram &SP) {
1153 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1155 SPDie = createSubprogramDIE(SP);
1157 // If SPDie has DW_AT_declaration then reuse it.
1158 if (!SP.isDefinition())
1161 // Otherwise create new DIE for the declaration. First push definition
1162 // DIE at the top level.
1163 if (TopLevelDIEs.insert(SPDie))
1164 TopLevelDIEsVector.push_back(SPDie);
1166 SPDie = createRawSubprogramDIE(SP);
1169 DICompositeType SPTy = SP.getType();
1170 DIArray Args = SPTy.getTypeArray();
1171 unsigned SPTag = SPTy.getTag();
1172 if (SPTag == dwarf::DW_TAG_subroutine_type)
1173 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1174 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1175 addType(Arg, DIType(Args.getElement(i).getNode()));
1176 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1177 SPDie->addChild(Arg);
1180 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1184 /// createSubprogramDIE - Create new DIE using SP.
1185 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP) {
1186 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1190 SPDie = createRawSubprogramDIE(SP);
1192 if (!SP.isDefinition()) {
1193 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1195 // Add arguments. Do not add arguments for subprogram definition. They will
1196 // be handled while processing variables.
1197 DICompositeType SPTy = SP.getType();
1198 DIArray Args = SPTy.getTypeArray();
1199 unsigned SPTag = SPTy.getTag();
1201 if (SPTag == dwarf::DW_TAG_subroutine_type)
1202 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1203 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1204 addType(Arg, DIType(Args.getElement(i).getNode()));
1205 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1206 SPDie->addChild(Arg);
1210 // DW_TAG_inlined_subroutine may refer to this DIE.
1211 ModuleCU->insertDIE(SP.getNode(), SPDie);
1215 /// findCompileUnit - Get the compile unit for the given descriptor.
1217 CompileUnit &DwarfDebug::findCompileUnit(DICompileUnit Unit) const {
1218 DenseMap<Value *, CompileUnit *>::const_iterator I =
1219 CompileUnitMap.find(Unit.getNode());
1220 assert(I != CompileUnitMap.end() && "Missing compile unit.");
1224 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1225 /// Initialize scope and update scope hierarchy.
1226 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1227 MDNode *InlinedAt) {
1228 assert (N && "Invalid Scope encoding!");
1229 assert (MI && "Missing machine instruction!");
1230 bool GetConcreteScope = (MI && InlinedAt);
1232 DbgScope *NScope = NULL;
1235 NScope = DbgScopeMap.lookup(InlinedAt);
1237 NScope = DbgScopeMap.lookup(N);
1238 assert (NScope && "Unable to find working scope!");
1240 if (NScope->getFirstInsn())
1243 DbgScope *Parent = NULL;
1244 if (GetConcreteScope) {
1245 DILocation IL(InlinedAt);
1246 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1247 IL.getOrigLocation().getNode());
1248 assert (Parent && "Unable to find Parent scope!");
1249 NScope->setParent(Parent);
1250 Parent->addScope(NScope);
1251 } else if (DIDescriptor(N).isLexicalBlock()) {
1252 DILexicalBlock DB(N);
1253 if (!DB.getContext().isNull()) {
1254 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1255 NScope->setParent(Parent);
1256 Parent->addScope(NScope);
1260 NScope->setFirstInsn(MI);
1262 if (!Parent && !InlinedAt) {
1263 StringRef SPName = DISubprogram(N).getLinkageName();
1264 if (SPName == MF->getFunction()->getName())
1265 CurrentFnDbgScope = NScope;
1268 if (GetConcreteScope) {
1269 ConcreteScopes[InlinedAt] = NScope;
1270 getOrCreateAbstractScope(N);
1276 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1277 assert (N && "Invalid Scope encoding!");
1279 DbgScope *AScope = AbstractScopes.lookup(N);
1283 DbgScope *Parent = NULL;
1285 DIDescriptor Scope(N);
1286 if (Scope.isLexicalBlock()) {
1287 DILexicalBlock DB(N);
1288 DIDescriptor ParentDesc = DB.getContext();
1289 if (!ParentDesc.isNull())
1290 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1293 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1296 Parent->addScope(AScope);
1297 AScope->setAbstractScope();
1298 AbstractScopes[N] = AScope;
1299 if (DIDescriptor(N).isSubprogram())
1300 AbstractScopesList.push_back(AScope);
1304 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1305 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1306 /// If there are global variables in this scope then create and insert
1307 /// DIEs for these variables.
1308 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1310 DIE *SPDie = ModuleCU->getDIE(SPNode);
1311 assert (SPDie && "Unable to find subprogram DIE!");
1312 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1313 DWLabel("func_begin", SubprogramCount));
1314 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1315 DWLabel("func_end", SubprogramCount));
1316 MachineLocation Location(RI->getFrameRegister(*MF));
1317 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1319 if (!DISubprogram(SPNode).isLocalToUnit())
1320 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1325 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1326 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1327 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1328 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1329 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1331 // Ignore empty scopes.
1332 if (StartID == EndID && StartID != 0)
1335 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1336 if (Scope->isAbstractScope())
1339 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1341 DWLabel("label", StartID)
1342 : DWLabel("func_begin", SubprogramCount));
1343 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1345 DWLabel("label", EndID)
1346 : DWLabel("func_end", SubprogramCount));
1353 /// constructInlinedScopeDIE - This scope represents inlined body of
1354 /// a function. Construct DIE to represent this concrete inlined copy
1355 /// of the function.
1356 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1357 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1358 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1359 assert (StartID && "Invalid starting label for an inlined scope!");
1360 assert (EndID && "Invalid end label for an inlined scope!");
1361 // Ignore empty scopes.
1362 if (StartID == EndID && StartID != 0)
1365 DIScope DS(Scope->getScopeNode());
1368 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1370 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1371 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1372 assert (OriginDIE && "Unable to find Origin DIE!");
1373 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1374 dwarf::DW_FORM_ref4, OriginDIE);
1376 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1377 DWLabel("label", StartID));
1378 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1379 DWLabel("label", EndID));
1381 InlinedSubprogramDIEs.insert(OriginDIE);
1383 // Track the start label for this inlined function.
1384 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1385 I = InlineInfo.find(InlinedSP.getNode());
1387 if (I == InlineInfo.end()) {
1388 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1390 InlinedSPNodes.push_back(InlinedSP.getNode());
1392 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1394 StringPool.insert(InlinedSP.getName());
1395 StringPool.insert(InlinedSP.getLinkageName());
1396 DILocation DL(Scope->getInlinedAt());
1397 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1398 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1404 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1405 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1406 // Get the descriptor.
1407 const DIVariable &VD = DV->getVariable();
1408 StringRef Name = VD.getName();
1412 // Translate tag to proper Dwarf tag. The result variable is dropped for
1415 switch (VD.getTag()) {
1416 case dwarf::DW_TAG_return_variable:
1418 case dwarf::DW_TAG_arg_variable:
1419 Tag = dwarf::DW_TAG_formal_parameter;
1421 case dwarf::DW_TAG_auto_variable: // fall thru
1423 Tag = dwarf::DW_TAG_variable;
1427 // Define variable debug information entry.
1428 DIE *VariableDie = new DIE(Tag);
1432 if (DbgVariable *AV = DV->getAbstractVariable())
1433 AbsDIE = AV->getDIE();
1436 DIScope DS(Scope->getScopeNode());
1437 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1438 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1440 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1441 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1442 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1443 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1444 dwarf::DW_FORM_ref4, AbsDIE);
1447 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1448 addSourceLine(VariableDie, &VD);
1450 // Add variable type.
1451 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1452 // addresses instead.
1453 if (VD.isBlockByrefVariable())
1454 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1456 addType(VariableDie, VD.getType());
1459 // Add variable address.
1460 if (!Scope->isAbstractScope()) {
1461 MachineLocation Location;
1463 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1464 Location.set(FrameReg, Offset);
1466 if (VD.hasComplexAddress())
1467 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1468 else if (VD.isBlockByrefVariable())
1469 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1471 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1473 DV->setDIE(VariableDie);
1478 void DwarfDebug::addPubTypes(DISubprogram SP) {
1479 DICompositeType SPTy = SP.getType();
1480 unsigned SPTag = SPTy.getTag();
1481 if (SPTag != dwarf::DW_TAG_subroutine_type)
1484 DIArray Args = SPTy.getTypeArray();
1488 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1489 DIType ATy(Args.getElement(i).getNode());
1492 DICompositeType CATy = getDICompositeType(ATy);
1493 if (!CATy.isNull() && !CATy.getName().empty()) {
1494 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1495 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1500 /// constructScopeDIE - Construct a DIE for this scope.
1501 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1504 DIScope DS(Scope->getScopeNode());
1508 DIE *ScopeDIE = NULL;
1509 if (Scope->getInlinedAt())
1510 ScopeDIE = constructInlinedScopeDIE(Scope);
1511 else if (DS.isSubprogram()) {
1512 if (Scope->isAbstractScope())
1513 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1515 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1518 ScopeDIE = constructLexicalScopeDIE(Scope);
1519 if (!ScopeDIE) return NULL;
1522 // Add variables to scope.
1523 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1524 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1525 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1527 ScopeDIE->addChild(VariableDIE);
1530 // Add nested scopes.
1531 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1532 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1533 // Define the Scope debug information entry.
1534 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1536 ScopeDIE->addChild(NestedDIE);
1539 if (DS.isSubprogram())
1540 addPubTypes(DISubprogram(DS.getNode()));
1545 /// GetOrCreateSourceID - Look up the source id with the given directory and
1546 /// source file names. If none currently exists, create a new id and insert it
1547 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1549 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1551 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1552 if (DI != DirectoryIdMap.end()) {
1553 DId = DI->getValue();
1555 DId = DirectoryNames.size() + 1;
1556 DirectoryIdMap[DirName] = DId;
1557 DirectoryNames.push_back(DirName);
1561 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1562 if (FI != SourceFileIdMap.end()) {
1563 FId = FI->getValue();
1565 FId = SourceFileNames.size() + 1;
1566 SourceFileIdMap[FileName] = FId;
1567 SourceFileNames.push_back(FileName);
1570 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1571 SourceIdMap.find(std::make_pair(DId, FId));
1572 if (SI != SourceIdMap.end())
1575 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1576 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1577 SourceIds.push_back(std::make_pair(DId, FId));
1582 void DwarfDebug::constructCompileUnit(MDNode *N) {
1583 DICompileUnit DIUnit(N);
1584 StringRef FN = DIUnit.getFilename();
1585 StringRef Dir = DIUnit.getDirectory();
1586 unsigned ID = GetOrCreateSourceID(Dir, FN);
1588 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1589 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1590 DWLabel("section_line", 0), DWLabel("section_line", 0),
1592 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1593 DIUnit.getProducer());
1594 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1595 DIUnit.getLanguage());
1596 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1599 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1600 if (DIUnit.isOptimized())
1601 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1603 StringRef Flags = DIUnit.getFlags();
1605 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1607 unsigned RVer = DIUnit.getRunTimeVersion();
1609 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1610 dwarf::DW_FORM_data1, RVer);
1612 CompileUnit *Unit = new CompileUnit(ID, Die);
1613 if (!ModuleCU && DIUnit.isMain()) {
1614 // Use first compile unit marked as isMain as the compile unit
1619 CompileUnitMap[DIUnit.getNode()] = Unit;
1620 CompileUnits.push_back(Unit);
1623 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1624 DIGlobalVariable DI_GV(N);
1626 // If debug information is malformed then ignore it.
1627 if (DI_GV.Verify() == false)
1630 // Check for pre-existence.
1631 if (ModuleCU->getDIE(DI_GV.getNode()))
1634 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1639 ModuleCU->insertDIE(N, VariableDie);
1641 // Add to context owner.
1642 addToContextOwner(VariableDie, DI_GV.getContext());
1644 // Expose as global. FIXME - need to check external flag.
1645 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1647 DIType GTy = DI_GV.getType();
1648 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1649 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1650 assert (Entry && "Missing global type!");
1651 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1656 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1659 // Check for pre-existence.
1660 if (ModuleCU->getDIE(N))
1663 if (!SP.isDefinition())
1664 // This is a method declaration which will be handled while constructing
1668 DIE *SubprogramDie = createSubprogramDIE(SP);
1671 ModuleCU->insertDIE(N, SubprogramDie);
1673 // Add to context owner.
1674 if (SP.getContext().getNode() == SP.getCompileUnit().getNode())
1675 if (TopLevelDIEs.insert(SubprogramDie))
1676 TopLevelDIEsVector.push_back(SubprogramDie);
1678 // Expose as global.
1679 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1684 /// beginModule - Emit all Dwarf sections that should come prior to the
1685 /// content. Create global DIEs and emit initial debug info sections.
1686 /// This is inovked by the target AsmPrinter.
1687 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1690 if (TimePassesIsEnabled)
1691 DebugTimer->startTimer();
1693 if (!MAI->doesSupportDebugInformation())
1696 DebugInfoFinder DbgFinder;
1697 DbgFinder.processModule(*M);
1699 // Create all the compile unit DIEs.
1700 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1701 E = DbgFinder.compile_unit_end(); I != E; ++I)
1702 constructCompileUnit(*I);
1704 if (CompileUnits.empty()) {
1705 if (TimePassesIsEnabled)
1706 DebugTimer->stopTimer();
1711 // If main compile unit for this module is not seen than randomly
1712 // select first compile unit.
1714 ModuleCU = CompileUnits[0];
1716 // Create DIEs for each subprogram.
1717 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1718 E = DbgFinder.subprogram_end(); I != E; ++I)
1719 constructSubprogramDIE(*I);
1721 // Create DIEs for each global variable.
1722 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1723 E = DbgFinder.global_variable_end(); I != E; ++I)
1724 constructGlobalVariableDIE(*I);
1728 MMI->setDebugInfoAvailability(true);
1730 // Prime section data.
1731 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1733 // Print out .file directives to specify files for .loc directives. These are
1734 // printed out early so that they precede any .loc directives.
1735 if (MAI->hasDotLocAndDotFile()) {
1736 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1737 // Remember source id starts at 1.
1738 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1739 sys::Path FullPath(getSourceDirectoryName(Id.first));
1741 FullPath.appendComponent(getSourceFileName(Id.second));
1742 assert(AppendOk && "Could not append filename to directory!");
1744 Asm->EmitFile(i, FullPath.str());
1749 // Emit initial sections
1752 if (TimePassesIsEnabled)
1753 DebugTimer->stopTimer();
1756 /// endModule - Emit all Dwarf sections that should come after the content.
1758 void DwarfDebug::endModule() {
1762 if (TimePassesIsEnabled)
1763 DebugTimer->startTimer();
1765 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1766 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1767 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1769 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1772 // Insert top level DIEs.
1773 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1774 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1775 ModuleCU->getCUDie()->addChild(*TI);
1777 for (DenseMap<DIE *, WeakVH>::iterator CI = ContainingTypeMap.begin(),
1778 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1779 DIE *SPDie = CI->first;
1780 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1782 DIE *NDie = ModuleCU->getDIE(N);
1783 if (!NDie) continue;
1784 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1785 addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1788 // Standard sections final addresses.
1789 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1790 EmitLabel("text_end", 0);
1791 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1792 EmitLabel("data_end", 0);
1794 // End text sections.
1795 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1796 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1797 EmitLabel("section_end", i);
1800 // Emit common frame information.
1801 emitCommonDebugFrame();
1803 // Emit function debug frame information
1804 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1805 E = DebugFrames.end(); I != E; ++I)
1806 emitFunctionDebugFrame(*I);
1808 // Compute DIE offsets and sizes.
1809 computeSizeAndOffsets();
1811 // Emit all the DIEs into a debug info section
1814 // Corresponding abbreviations into a abbrev section.
1815 emitAbbreviations();
1817 // Emit source line correspondence into a debug line section.
1820 // Emit info into a debug pubnames section.
1821 emitDebugPubNames();
1823 // Emit info into a debug pubtypes section.
1824 emitDebugPubTypes();
1826 // Emit info into a debug str section.
1829 // Emit info into a debug loc section.
1832 // Emit info into a debug aranges section.
1835 // Emit info into a debug ranges section.
1838 // Emit info into a debug macinfo section.
1841 // Emit inline info.
1842 emitDebugInlineInfo();
1844 if (TimePassesIsEnabled)
1845 DebugTimer->stopTimer();
1848 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1849 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1851 DILocation &ScopeLoc) {
1853 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1855 return AbsDbgVariable;
1857 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1861 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1862 Scope->addVariable(AbsDbgVariable);
1863 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1864 return AbsDbgVariable;
1867 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1868 void DwarfDebug::collectVariableInfo() {
1871 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1872 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1873 VE = VMap.end(); VI != VE; ++VI) {
1874 MetadataBase *MB = VI->first;
1875 MDNode *Var = dyn_cast_or_null<MDNode>(MB);
1877 DIVariable DV (Var);
1878 std::pair< unsigned, MDNode *> VP = VI->second;
1879 DILocation ScopeLoc(VP.second);
1882 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1884 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1885 // If variable scope is not found then skip this variable.
1889 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1890 Scope->addVariable(RegVar);
1891 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1893 RegVar->setAbstractVariable(AbsDbgVariable);
1897 /// beginScope - Process beginning of a scope starting at Label.
1898 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1899 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1900 if (I == DbgScopeBeginMap.end())
1902 ScopeVector &SD = I->second;
1903 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1905 (*SDI)->setStartLabelID(Label);
1908 /// endScope - Process end of a scope.
1909 void DwarfDebug::endScope(const MachineInstr *MI) {
1910 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1911 if (I == DbgScopeEndMap.end())
1914 unsigned Label = MMI->NextLabelID();
1915 Asm->printLabel(Label);
1918 SmallVector<DbgScope *, 2> &SD = I->second;
1919 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1921 (*SDI)->setEndLabelID(Label);
1925 /// createDbgScope - Create DbgScope for the scope.
1926 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1929 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1932 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1933 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1934 if (DIDescriptor(Scope).isLexicalBlock())
1935 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1939 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1943 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1944 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1945 DILocation DL(InlinedAt);
1946 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1949 /// extractScopeInformation - Scan machine instructions in this function
1950 /// and collect DbgScopes. Return true, if atleast one scope was found.
1951 bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
1952 // If scope information was extracted using .dbg intrinsics then there is not
1953 // any need to extract these information by scanning each instruction.
1954 if (!DbgScopeMap.empty())
1957 // Scan each instruction and create scopes. First build working set of scopes.
1958 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1960 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1962 const MachineInstr *MInsn = II;
1963 DebugLoc DL = MInsn->getDebugLoc();
1964 if (DL.isUnknown()) continue;
1965 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
1966 if (!DLT.Scope) continue;
1967 // There is no need to create another DIE for compile unit. For all
1968 // other scopes, create one DbgScope now. This will be translated
1969 // into a scope DIE at the end.
1970 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
1971 createDbgScope(DLT.Scope, DLT.InlinedAtLoc);
1976 // Build scope hierarchy using working set of scopes.
1977 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1979 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1981 const MachineInstr *MInsn = II;
1982 DebugLoc DL = MInsn->getDebugLoc();
1983 if (DL.isUnknown()) continue;
1984 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
1985 if (!DLT.Scope) continue;
1986 // There is no need to create another DIE for compile unit. For all
1987 // other scopes, create one DbgScope now. This will be translated
1988 // into a scope DIE at the end.
1989 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
1990 DbgScope *Scope = getUpdatedDbgScope(DLT.Scope, MInsn, DLT.InlinedAtLoc);
1991 Scope->setLastInsn(MInsn);
1995 // If a scope's last instruction is not set then use its child scope's
1996 // last instruction as this scope's last instrunction.
1997 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
1998 DE = DbgScopeMap.end(); DI != DE; ++DI) {
1999 if (DI->second->isAbstractScope())
2001 assert (DI->second->getFirstInsn() && "Invalid first instruction!");
2002 DI->second->fixInstructionMarkers();
2003 assert (DI->second->getLastInsn() && "Invalid last instruction!");
2006 // Each scope has first instruction and last instruction to mark beginning
2007 // and end of a scope respectively. Create an inverse map that list scopes
2008 // starts (and ends) with an instruction. One instruction may start (or end)
2010 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
2011 DE = DbgScopeMap.end(); DI != DE; ++DI) {
2012 DbgScope *S = DI->second;
2013 if (S->isAbstractScope())
2015 const MachineInstr *MI = S->getFirstInsn();
2016 assert (MI && "DbgScope does not have first instruction!");
2018 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2019 if (IDI != DbgScopeBeginMap.end())
2020 IDI->second.push_back(S);
2022 DbgScopeBeginMap[MI].push_back(S);
2024 MI = S->getLastInsn();
2025 assert (MI && "DbgScope does not have last instruction!");
2026 IDI = DbgScopeEndMap.find(MI);
2027 if (IDI != DbgScopeEndMap.end())
2028 IDI->second.push_back(S);
2030 DbgScopeEndMap[MI].push_back(S);
2033 return !DbgScopeMap.empty();
2036 /// beginFunction - Gather pre-function debug information. Assumes being
2037 /// emitted immediately after the function entry point.
2038 void DwarfDebug::beginFunction(MachineFunction *MF) {
2041 if (!ShouldEmitDwarfDebug()) return;
2043 if (TimePassesIsEnabled)
2044 DebugTimer->startTimer();
2046 if (!extractScopeInformation(MF))
2049 collectVariableInfo();
2051 // Begin accumulating function debug information.
2052 MMI->BeginFunction(MF);
2054 // Assumes in correct section after the entry point.
2055 EmitLabel("func_begin", ++SubprogramCount);
2057 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2059 DebugLoc FDL = MF->getDefaultDebugLoc();
2060 if (!FDL.isUnknown()) {
2061 DebugLocTuple DLT = MF->getDebugLocTuple(FDL);
2062 unsigned LabelID = 0;
2063 DISubprogram SP = getDISubprogram(DLT.Scope);
2065 LabelID = recordSourceLine(SP.getLineNumber(), 0, DLT.Scope);
2067 LabelID = recordSourceLine(DLT.Line, DLT.Col, DLT.Scope);
2068 Asm->printLabel(LabelID);
2071 if (TimePassesIsEnabled)
2072 DebugTimer->stopTimer();
2075 /// endFunction - Gather and emit post-function debug information.
2077 void DwarfDebug::endFunction(MachineFunction *MF) {
2078 if (!ShouldEmitDwarfDebug()) return;
2080 if (TimePassesIsEnabled)
2081 DebugTimer->startTimer();
2083 if (DbgScopeMap.empty())
2086 // Define end label for subprogram.
2087 EmitLabel("func_end", SubprogramCount);
2089 // Get function line info.
2090 if (!Lines.empty()) {
2091 // Get section line info.
2092 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2093 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2094 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2095 // Append the function info to section info.
2096 SectionLineInfos.insert(SectionLineInfos.end(),
2097 Lines.begin(), Lines.end());
2100 // Construct abstract scopes.
2101 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2102 AE = AbstractScopesList.end(); AI != AE; ++AI)
2103 constructScopeDIE(*AI);
2105 constructScopeDIE(CurrentFnDbgScope);
2107 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2108 MMI->getFrameMoves()));
2111 CurrentFnDbgScope = NULL;
2112 DbgScopeMap.clear();
2113 DbgScopeBeginMap.clear();
2114 DbgScopeEndMap.clear();
2115 ConcreteScopes.clear();
2116 AbstractScopesList.clear();
2120 if (TimePassesIsEnabled)
2121 DebugTimer->stopTimer();
2124 /// recordSourceLine - Records location information and associates it with a
2125 /// label. Returns a unique label ID used to generate a label and provide
2126 /// correspondence to the source line list.
2127 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2132 if (TimePassesIsEnabled)
2133 DebugTimer->startTimer();
2138 DIDescriptor Scope(S);
2139 if (Scope.isCompileUnit()) {
2140 DICompileUnit CU(S);
2141 Dir = CU.getDirectory();
2142 Fn = CU.getFilename();
2143 } else if (Scope.isSubprogram()) {
2145 Dir = SP.getDirectory();
2146 Fn = SP.getFilename();
2147 } else if (Scope.isLexicalBlock()) {
2148 DILexicalBlock DB(S);
2149 Dir = DB.getDirectory();
2150 Fn = DB.getFilename();
2152 assert (0 && "Unexpected scope info");
2154 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2155 unsigned ID = MMI->NextLabelID();
2156 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2158 if (TimePassesIsEnabled)
2159 DebugTimer->stopTimer();
2164 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2165 /// timed. Look up the source id with the given directory and source file
2166 /// names. If none currently exists, create a new id and insert it in the
2167 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2169 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2170 const std::string &FileName) {
2171 if (TimePassesIsEnabled)
2172 DebugTimer->startTimer();
2174 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2176 if (TimePassesIsEnabled)
2177 DebugTimer->stopTimer();
2182 //===----------------------------------------------------------------------===//
2184 //===----------------------------------------------------------------------===//
2186 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2189 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2190 // Get the children.
2191 const std::vector<DIE *> &Children = Die->getChildren();
2193 // If not last sibling and has children then add sibling offset attribute.
2194 if (!Last && !Children.empty()) Die->addSiblingOffset();
2196 // Record the abbreviation.
2197 assignAbbrevNumber(Die->getAbbrev());
2199 // Get the abbreviation for this DIE.
2200 unsigned AbbrevNumber = Die->getAbbrevNumber();
2201 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2204 Die->setOffset(Offset);
2206 // Start the size with the size of abbreviation code.
2207 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2209 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2210 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2212 // Size the DIE attribute values.
2213 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2214 // Size attribute value.
2215 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2217 // Size the DIE children if any.
2218 if (!Children.empty()) {
2219 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2220 "Children flag not set");
2222 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2223 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2225 // End of children marker.
2226 Offset += sizeof(int8_t);
2229 Die->setSize(Offset - Die->getOffset());
2233 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2235 void DwarfDebug::computeSizeAndOffsets() {
2236 // Compute size of compile unit header.
2237 static unsigned Offset =
2238 sizeof(int32_t) + // Length of Compilation Unit Info
2239 sizeof(int16_t) + // DWARF version number
2240 sizeof(int32_t) + // Offset Into Abbrev. Section
2241 sizeof(int8_t); // Pointer Size (in bytes)
2243 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2244 CompileUnitOffsets[ModuleCU] = 0;
2247 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2248 /// tools to recognize the object file contains Dwarf information.
2249 void DwarfDebug::emitInitial() {
2250 // Check to see if we already emitted intial headers.
2251 if (didInitial) return;
2254 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2256 // Dwarf sections base addresses.
2257 if (MAI->doesDwarfRequireFrameSection()) {
2258 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2259 EmitLabel("section_debug_frame", 0);
2262 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2263 EmitLabel("section_info", 0);
2264 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2265 EmitLabel("section_abbrev", 0);
2266 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2267 EmitLabel("section_aranges", 0);
2269 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2270 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2271 EmitLabel("section_macinfo", 0);
2274 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2275 EmitLabel("section_line", 0);
2276 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2277 EmitLabel("section_loc", 0);
2278 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2279 EmitLabel("section_pubnames", 0);
2280 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2281 EmitLabel("section_pubtypes", 0);
2282 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2283 EmitLabel("section_str", 0);
2284 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2285 EmitLabel("section_ranges", 0);
2287 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2288 EmitLabel("text_begin", 0);
2289 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2290 EmitLabel("data_begin", 0);
2293 /// emitDIE - Recusively Emits a debug information entry.
2295 void DwarfDebug::emitDIE(DIE *Die) {
2296 // Get the abbreviation for this DIE.
2297 unsigned AbbrevNumber = Die->getAbbrevNumber();
2298 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2302 // Emit the code (index) for the abbreviation.
2303 Asm->EmitULEB128Bytes(AbbrevNumber);
2305 if (Asm->isVerbose())
2306 Asm->EOL(std::string("Abbrev [" +
2307 utostr(AbbrevNumber) +
2308 "] 0x" + utohexstr(Die->getOffset()) +
2309 ":0x" + utohexstr(Die->getSize()) + " " +
2310 dwarf::TagString(Abbrev->getTag())));
2314 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2315 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2317 // Emit the DIE attribute values.
2318 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2319 unsigned Attr = AbbrevData[i].getAttribute();
2320 unsigned Form = AbbrevData[i].getForm();
2321 assert(Form && "Too many attributes for DIE (check abbreviation)");
2324 case dwarf::DW_AT_sibling:
2325 Asm->EmitInt32(Die->getSiblingOffset());
2327 case dwarf::DW_AT_abstract_origin: {
2328 DIEEntry *E = cast<DIEEntry>(Values[i]);
2329 DIE *Origin = E->getEntry();
2330 unsigned Addr = Origin->getOffset();
2331 Asm->EmitInt32(Addr);
2335 // Emit an attribute using the defined form.
2336 Values[i]->EmitValue(this, Form);
2340 Asm->EOL(dwarf::AttributeString(Attr));
2343 // Emit the DIE children if any.
2344 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2345 const std::vector<DIE *> &Children = Die->getChildren();
2347 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2348 emitDIE(Children[j]);
2350 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2354 /// emitDebugInfo - Emit the debug info section.
2356 void DwarfDebug::emitDebugInfo() {
2357 // Start debug info section.
2358 Asm->OutStreamer.SwitchSection(
2359 Asm->getObjFileLowering().getDwarfInfoSection());
2360 DIE *Die = ModuleCU->getCUDie();
2362 // Emit the compile units header.
2363 EmitLabel("info_begin", ModuleCU->getID());
2365 // Emit size of content not including length itself
2366 unsigned ContentSize = Die->getSize() +
2367 sizeof(int16_t) + // DWARF version number
2368 sizeof(int32_t) + // Offset Into Abbrev. Section
2369 sizeof(int8_t) + // Pointer Size (in bytes)
2370 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2372 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
2373 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2374 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2375 Asm->EOL("Offset Into Abbrev. Section");
2376 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2379 // FIXME - extra padding for gdb bug.
2380 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2381 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2382 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2383 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2384 EmitLabel("info_end", ModuleCU->getID());
2390 /// emitAbbreviations - Emit the abbreviation section.
2392 void DwarfDebug::emitAbbreviations() const {
2393 // Check to see if it is worth the effort.
2394 if (!Abbreviations.empty()) {
2395 // Start the debug abbrev section.
2396 Asm->OutStreamer.SwitchSection(
2397 Asm->getObjFileLowering().getDwarfAbbrevSection());
2399 EmitLabel("abbrev_begin", 0);
2401 // For each abbrevation.
2402 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2403 // Get abbreviation data
2404 const DIEAbbrev *Abbrev = Abbreviations[i];
2406 // Emit the abbrevations code (base 1 index.)
2407 Asm->EmitULEB128Bytes(Abbrev->getNumber());
2408 Asm->EOL("Abbreviation Code");
2410 // Emit the abbreviations data.
2416 // Mark end of abbreviations.
2417 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2419 EmitLabel("abbrev_end", 0);
2424 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2425 /// the line matrix.
2427 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2428 // Define last address of section.
2429 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2430 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2431 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2432 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2434 // Mark end of matrix.
2435 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2436 Asm->EmitULEB128Bytes(1); Asm->EOL();
2437 Asm->EmitInt8(1); Asm->EOL();
2440 /// emitDebugLines - Emit source line information.
2442 void DwarfDebug::emitDebugLines() {
2443 // If the target is using .loc/.file, the assembler will be emitting the
2444 // .debug_line table automatically.
2445 if (MAI->hasDotLocAndDotFile())
2448 // Minimum line delta, thus ranging from -10..(255-10).
2449 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2450 // Maximum line delta, thus ranging from -10..(255-10).
2451 const int MaxLineDelta = 255 + MinLineDelta;
2453 // Start the dwarf line section.
2454 Asm->OutStreamer.SwitchSection(
2455 Asm->getObjFileLowering().getDwarfLineSection());
2457 // Construct the section header.
2458 EmitDifference("line_end", 0, "line_begin", 0, true);
2459 Asm->EOL("Length of Source Line Info");
2460 EmitLabel("line_begin", 0);
2462 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2464 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2465 Asm->EOL("Prolog Length");
2466 EmitLabel("line_prolog_begin", 0);
2468 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2470 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2472 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2474 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2476 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2478 // Line number standard opcode encodings argument count
2479 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2480 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2481 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2482 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2483 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2484 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2485 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2486 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2487 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2489 // Emit directories.
2490 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2491 Asm->EmitString(getSourceDirectoryName(DI));
2492 Asm->EOL("Directory");
2495 Asm->EmitInt8(0); Asm->EOL("End of directories");
2498 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2499 // Remember source id starts at 1.
2500 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2501 Asm->EmitString(getSourceFileName(Id.second));
2503 Asm->EmitULEB128Bytes(Id.first);
2504 Asm->EOL("Directory #");
2505 Asm->EmitULEB128Bytes(0);
2506 Asm->EOL("Mod date");
2507 Asm->EmitULEB128Bytes(0);
2508 Asm->EOL("File size");
2511 Asm->EmitInt8(0); Asm->EOL("End of files");
2513 EmitLabel("line_prolog_end", 0);
2515 // A sequence for each text section.
2516 unsigned SecSrcLinesSize = SectionSourceLines.size();
2518 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2519 // Isolate current sections line info.
2520 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2522 /*if (Asm->isVerbose()) {
2523 const MCSection *S = SectionMap[j + 1];
2524 O << '\t' << MAI->getCommentString() << " Section"
2525 << S->getName() << '\n';
2529 // Dwarf assumes we start with first line of first source file.
2530 unsigned Source = 1;
2533 // Construct rows of the address, source, line, column matrix.
2534 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2535 const SrcLineInfo &LineInfo = LineInfos[i];
2536 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2537 if (!LabelID) continue;
2539 if (LineInfo.getLine() == 0) continue;
2541 if (!Asm->isVerbose())
2544 std::pair<unsigned, unsigned> SourceID =
2545 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2546 O << '\t' << MAI->getCommentString() << ' '
2547 << getSourceDirectoryName(SourceID.first) << '/'
2548 << getSourceFileName(SourceID.second)
2549 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2552 // Define the line address.
2553 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2554 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2555 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2556 EmitReference("label", LabelID); Asm->EOL("Location label");
2558 // If change of source, then switch to the new source.
2559 if (Source != LineInfo.getSourceID()) {
2560 Source = LineInfo.getSourceID();
2561 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2562 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2565 // If change of line.
2566 if (Line != LineInfo.getLine()) {
2567 // Determine offset.
2568 int Offset = LineInfo.getLine() - Line;
2569 int Delta = Offset - MinLineDelta;
2572 Line = LineInfo.getLine();
2574 // If delta is small enough and in range...
2575 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2576 // ... then use fast opcode.
2577 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2579 // ... otherwise use long hand.
2580 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2581 Asm->EOL("DW_LNS_advance_line");
2582 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2583 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2586 // Copy the previous row (different address or source)
2587 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2591 emitEndOfLineMatrix(j + 1);
2594 if (SecSrcLinesSize == 0)
2595 // Because we're emitting a debug_line section, we still need a line
2596 // table. The linker and friends expect it to exist. If there's nothing to
2597 // put into it, emit an empty table.
2598 emitEndOfLineMatrix(1);
2600 EmitLabel("line_end", 0);
2604 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2606 void DwarfDebug::emitCommonDebugFrame() {
2607 if (!MAI->doesDwarfRequireFrameSection())
2611 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2612 TargetFrameInfo::StackGrowsUp ?
2613 TD->getPointerSize() : -TD->getPointerSize();
2615 // Start the dwarf frame section.
2616 Asm->OutStreamer.SwitchSection(
2617 Asm->getObjFileLowering().getDwarfFrameSection());
2619 EmitLabel("debug_frame_common", 0);
2620 EmitDifference("debug_frame_common_end", 0,
2621 "debug_frame_common_begin", 0, true);
2622 Asm->EOL("Length of Common Information Entry");
2624 EmitLabel("debug_frame_common_begin", 0);
2625 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2626 Asm->EOL("CIE Identifier Tag");
2627 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2628 Asm->EOL("CIE Version");
2629 Asm->EmitString("");
2630 Asm->EOL("CIE Augmentation");
2631 Asm->EmitULEB128Bytes(1);
2632 Asm->EOL("CIE Code Alignment Factor");
2633 Asm->EmitSLEB128Bytes(stackGrowth);
2634 Asm->EOL("CIE Data Alignment Factor");
2635 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2636 Asm->EOL("CIE RA Column");
2638 std::vector<MachineMove> Moves;
2639 RI->getInitialFrameState(Moves);
2641 EmitFrameMoves(NULL, 0, Moves, false);
2643 Asm->EmitAlignment(2, 0, 0, false);
2644 EmitLabel("debug_frame_common_end", 0);
2649 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2652 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2653 if (!MAI->doesDwarfRequireFrameSection())
2656 // Start the dwarf frame section.
2657 Asm->OutStreamer.SwitchSection(
2658 Asm->getObjFileLowering().getDwarfFrameSection());
2660 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2661 "debug_frame_begin", DebugFrameInfo.Number, true);
2662 Asm->EOL("Length of Frame Information Entry");
2664 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2666 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2668 Asm->EOL("FDE CIE offset");
2670 EmitReference("func_begin", DebugFrameInfo.Number);
2671 Asm->EOL("FDE initial location");
2672 EmitDifference("func_end", DebugFrameInfo.Number,
2673 "func_begin", DebugFrameInfo.Number);
2674 Asm->EOL("FDE address range");
2676 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2679 Asm->EmitAlignment(2, 0, 0, false);
2680 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2685 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2687 void DwarfDebug::emitDebugPubNames() {
2688 // Start the dwarf pubnames section.
2689 Asm->OutStreamer.SwitchSection(
2690 Asm->getObjFileLowering().getDwarfPubNamesSection());
2692 EmitDifference("pubnames_end", ModuleCU->getID(),
2693 "pubnames_begin", ModuleCU->getID(), true);
2694 Asm->EOL("Length of Public Names Info");
2696 EmitLabel("pubnames_begin", ModuleCU->getID());
2698 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2700 EmitSectionOffset("info_begin", "section_info",
2701 ModuleCU->getID(), 0, true, false);
2702 Asm->EOL("Offset of Compilation Unit Info");
2704 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2706 Asm->EOL("Compilation Unit Length");
2708 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2709 for (StringMap<DIE*>::const_iterator
2710 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2711 const char *Name = GI->getKeyData();
2712 DIE * Entity = GI->second;
2714 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2715 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2718 Asm->EmitInt32(0); Asm->EOL("End Mark");
2719 EmitLabel("pubnames_end", ModuleCU->getID());
2724 void DwarfDebug::emitDebugPubTypes() {
2725 // Start the dwarf pubnames section.
2726 Asm->OutStreamer.SwitchSection(
2727 Asm->getObjFileLowering().getDwarfPubTypesSection());
2728 EmitDifference("pubtypes_end", ModuleCU->getID(),
2729 "pubtypes_begin", ModuleCU->getID(), true);
2730 Asm->EOL("Length of Public Types Info");
2732 EmitLabel("pubtypes_begin", ModuleCU->getID());
2734 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2736 EmitSectionOffset("info_begin", "section_info",
2737 ModuleCU->getID(), 0, true, false);
2738 Asm->EOL("Offset of Compilation ModuleCU Info");
2740 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2742 Asm->EOL("Compilation ModuleCU Length");
2744 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2745 for (StringMap<DIE*>::const_iterator
2746 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2747 const char *Name = GI->getKeyData();
2748 DIE * Entity = GI->second;
2750 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2751 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2754 Asm->EmitInt32(0); Asm->EOL("End Mark");
2755 EmitLabel("pubtypes_end", ModuleCU->getID());
2760 /// emitDebugStr - Emit visible names into a debug str section.
2762 void DwarfDebug::emitDebugStr() {
2763 // Check to see if it is worth the effort.
2764 if (!StringPool.empty()) {
2765 // Start the dwarf str section.
2766 Asm->OutStreamer.SwitchSection(
2767 Asm->getObjFileLowering().getDwarfStrSection());
2769 // For each of strings in the string pool.
2770 for (unsigned StringID = 1, N = StringPool.size();
2771 StringID <= N; ++StringID) {
2772 // Emit a label for reference from debug information entries.
2773 EmitLabel("string", StringID);
2775 // Emit the string itself.
2776 const std::string &String = StringPool[StringID];
2777 Asm->EmitString(String); Asm->EOL();
2784 /// emitDebugLoc - Emit visible names into a debug loc section.
2786 void DwarfDebug::emitDebugLoc() {
2787 // Start the dwarf loc section.
2788 Asm->OutStreamer.SwitchSection(
2789 Asm->getObjFileLowering().getDwarfLocSection());
2793 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2795 void DwarfDebug::EmitDebugARanges() {
2796 // Start the dwarf aranges section.
2797 Asm->OutStreamer.SwitchSection(
2798 Asm->getObjFileLowering().getDwarfARangesSection());
2802 CompileUnit *Unit = GetBaseCompileUnit();
2804 // Don't include size of length
2805 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
2807 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2809 EmitReference("info_begin", Unit->getID());
2810 Asm->EOL("Offset of Compilation Unit Info");
2812 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2814 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2816 Asm->EmitInt16(0); Asm->EOL("Pad (1)");
2817 Asm->EmitInt16(0); Asm->EOL("Pad (2)");
2820 EmitReference("text_begin", 0); Asm->EOL("Address");
2821 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2823 Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2824 Asm->EmitInt32(0); Asm->EOL("EOM (2)");
2830 /// emitDebugRanges - Emit visible names into a debug ranges section.
2832 void DwarfDebug::emitDebugRanges() {
2833 // Start the dwarf ranges section.
2834 Asm->OutStreamer.SwitchSection(
2835 Asm->getObjFileLowering().getDwarfRangesSection());
2839 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2841 void DwarfDebug::emitDebugMacInfo() {
2842 if (const MCSection *LineInfo =
2843 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2844 // Start the dwarf macinfo section.
2845 Asm->OutStreamer.SwitchSection(LineInfo);
2850 /// emitDebugInlineInfo - Emit inline info using following format.
2852 /// 1. length of section
2853 /// 2. Dwarf version number
2854 /// 3. address size.
2856 /// Entries (one "entry" for each function that was inlined):
2858 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2859 /// otherwise offset into __debug_str for regular function name.
2860 /// 2. offset into __debug_str section for regular function name.
2861 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2862 /// instances for the function.
2864 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2865 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2866 /// __debug_info section, and the low_pc is the starting address for the
2867 /// inlining instance.
2868 void DwarfDebug::emitDebugInlineInfo() {
2869 if (!MAI->doesDwarfUsesInlineInfoSection())
2875 Asm->OutStreamer.SwitchSection(
2876 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2878 EmitDifference("debug_inlined_end", 1,
2879 "debug_inlined_begin", 1, true);
2880 Asm->EOL("Length of Debug Inlined Information Entry");
2882 EmitLabel("debug_inlined_begin", 1);
2884 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2885 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2887 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2888 E = InlinedSPNodes.end(); I != E; ++I) {
2890 // for (ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
2891 // I = InlineInfo.begin(), E = InlineInfo.end(); I != E; ++I) {
2893 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2894 = InlineInfo.find(Node);
2895 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2896 DISubprogram SP(Node);
2897 StringRef LName = SP.getLinkageName();
2898 StringRef Name = SP.getName();
2901 Asm->EmitString(Name);
2903 // Skip special LLVM prefix that is used to inform the asm printer to not
2904 // emit usual symbol prefix before the symbol name. This happens for
2905 // Objective-C symbol names and symbol whose name is replaced using GCC's
2906 // __asm__ attribute.
2908 LName = LName.substr(1);
2909 // Asm->EmitString(LName);
2910 EmitSectionOffset("string", "section_str",
2911 StringPool.idFor(LName), false, true);
2914 Asm->EOL("MIPS linkage name");
2915 // Asm->EmitString(Name);
2916 EmitSectionOffset("string", "section_str",
2917 StringPool.idFor(Name), false, true);
2918 Asm->EOL("Function name");
2919 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2921 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2922 LE = Labels.end(); LI != LE; ++LI) {
2923 DIE *SP = LI->second;
2924 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2926 if (TD->getPointerSize() == sizeof(int32_t))
2927 O << MAI->getData32bitsDirective();
2929 O << MAI->getData64bitsDirective();
2931 PrintLabelName("label", LI->first); Asm->EOL("low_pc");
2935 EmitLabel("debug_inlined_end", 1);