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.
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 /// addType - Add a new type attribute to the specified entity.
742 void DwarfDebug::addType(CompileUnit *DW_Unit, DIE *Entity, DIType Ty) {
746 // Check for pre-existence.
747 DIEEntry *Entry = DW_Unit->getDIEEntry(Ty.getNode());
749 // If it exists then use the existing value.
751 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
756 Entry = createDIEEntry();
757 DW_Unit->insertDIEEntry(Ty.getNode(), Entry);
760 DIE *Buffer = new DIE(dwarf::DW_TAG_base_type);
761 if (Ty.isBasicType())
762 constructTypeDIE(DW_Unit, *Buffer, DIBasicType(Ty.getNode()));
763 else if (Ty.isCompositeType())
764 constructTypeDIE(DW_Unit, *Buffer, DICompositeType(Ty.getNode()));
766 assert(Ty.isDerivedType() && "Unknown kind of DIType");
767 constructTypeDIE(DW_Unit, *Buffer, DIDerivedType(Ty.getNode()));
770 // Add debug information entry to entity and appropriate context.
772 DIDescriptor Context = Ty.getContext();
773 if (!Context.isNull())
774 Die = DW_Unit->getDIE(Context.getNode());
777 Die->addChild(Buffer);
779 DW_Unit->addDie(Buffer);
780 Entry->setEntry(Buffer);
781 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
784 /// constructTypeDIE - Construct basic type die from DIBasicType.
785 void DwarfDebug::constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
787 // Get core information.
788 StringRef Name = BTy.getName();
789 Buffer.setTag(dwarf::DW_TAG_base_type);
790 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
793 // Add name if not anonymous or intermediate type.
795 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
796 uint64_t Size = BTy.getSizeInBits() >> 3;
797 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
800 /// constructTypeDIE - Construct derived type die from DIDerivedType.
801 void DwarfDebug::constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
803 // Get core information.
804 StringRef Name = DTy.getName();
805 uint64_t Size = DTy.getSizeInBits() >> 3;
806 unsigned Tag = DTy.getTag();
808 // FIXME - Workaround for templates.
809 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
813 // Map to main type, void will not have a type.
814 DIType FromTy = DTy.getTypeDerivedFrom();
815 addType(DW_Unit, &Buffer, FromTy);
817 // Add name if not anonymous or intermediate type.
819 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
821 // Add size if non-zero (derived types might be zero-sized.)
823 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
825 // Add source line info if available and TyDesc is not a forward declaration.
826 if (!DTy.isForwardDecl())
827 addSourceLine(&Buffer, &DTy);
830 /// constructTypeDIE - Construct type DIE from DICompositeType.
831 void DwarfDebug::constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
832 DICompositeType CTy) {
833 // Get core information.
834 StringRef Name = CTy.getName();
836 uint64_t Size = CTy.getSizeInBits() >> 3;
837 unsigned Tag = CTy.getTag();
841 case dwarf::DW_TAG_vector_type:
842 case dwarf::DW_TAG_array_type:
843 constructArrayTypeDIE(DW_Unit, Buffer, &CTy);
845 case dwarf::DW_TAG_enumeration_type: {
846 DIArray Elements = CTy.getTypeArray();
848 // Add enumerators to enumeration type.
849 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
851 DIEnumerator Enum(Elements.getElement(i).getNode());
852 if (!Enum.isNull()) {
853 ElemDie = constructEnumTypeDIE(DW_Unit, &Enum);
854 Buffer.addChild(ElemDie);
859 case dwarf::DW_TAG_subroutine_type: {
861 DIArray Elements = CTy.getTypeArray();
862 DIDescriptor RTy = Elements.getElement(0);
863 addType(DW_Unit, &Buffer, DIType(RTy.getNode()));
865 // Add prototype flag.
866 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
869 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
870 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
871 DIDescriptor Ty = Elements.getElement(i);
872 addType(DW_Unit, Arg, DIType(Ty.getNode()));
873 Buffer.addChild(Arg);
877 case dwarf::DW_TAG_structure_type:
878 case dwarf::DW_TAG_union_type:
879 case dwarf::DW_TAG_class_type: {
880 // Add elements to structure type.
881 DIArray Elements = CTy.getTypeArray();
883 // A forward struct declared type may not have elements available.
884 if (Elements.isNull())
887 // Add elements to structure type.
888 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
889 DIDescriptor Element = Elements.getElement(i);
890 if (Element.isNull())
893 if (Element.getTag() == dwarf::DW_TAG_subprogram)
894 ElemDie = createSubprogramDIE(DW_Unit,
895 DISubprogram(Element.getNode()));
897 ElemDie = createMemberDIE(DW_Unit,
898 DIDerivedType(Element.getNode()));
899 Buffer.addChild(ElemDie);
902 if (CTy.isAppleBlockExtension())
903 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
905 unsigned RLang = CTy.getRunTimeLang();
907 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
908 dwarf::DW_FORM_data1, RLang);
915 // Add name if not anonymous or intermediate type.
917 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
919 if (Tag == dwarf::DW_TAG_enumeration_type ||
920 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
921 // Add size if non-zero (derived types might be zero-sized.)
923 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
925 // Add zero size if it is not a forward declaration.
926 if (CTy.isForwardDecl())
927 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
929 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
932 // Add source line info if available.
933 if (!CTy.isForwardDecl())
934 addSourceLine(&Buffer, &CTy);
938 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
939 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
940 int64_t L = SR.getLo();
941 int64_t H = SR.getHi();
942 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
944 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
946 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
948 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
950 Buffer.addChild(DW_Subrange);
953 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
954 void DwarfDebug::constructArrayTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
955 DICompositeType *CTy) {
956 Buffer.setTag(dwarf::DW_TAG_array_type);
957 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
958 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
960 // Emit derived type.
961 addType(DW_Unit, &Buffer, CTy->getTypeDerivedFrom());
962 DIArray Elements = CTy->getTypeArray();
964 // Get an anonymous type for index type.
965 DIE *IdxTy = DW_Unit->getIndexTyDie();
967 // Construct an anonymous type for index type.
968 IdxTy = new DIE(dwarf::DW_TAG_base_type);
969 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
970 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
971 dwarf::DW_ATE_signed);
972 DW_Unit->addDie(IdxTy);
973 DW_Unit->setIndexTyDie(IdxTy);
976 // Add subranges to array type.
977 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
978 DIDescriptor Element = Elements.getElement(i);
979 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
980 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
984 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
985 DIE *DwarfDebug::constructEnumTypeDIE(CompileUnit *DW_Unit, DIEnumerator *ETy) {
986 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
987 StringRef Name = ETy->getName();
988 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
989 int64_t Value = ETy->getEnumValue();
990 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
994 /// createGlobalVariableDIE - Create new DIE using GV.
995 DIE *DwarfDebug::createGlobalVariableDIE(CompileUnit *DW_Unit,
996 const DIGlobalVariable &GV) {
997 // If the global variable was optmized out then no need to create debug info
999 if (!GV.getGlobal()) return NULL;
1000 if (GV.getDisplayName().empty()) return NULL;
1002 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1003 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1004 GV.getDisplayName());
1006 StringRef LinkageName = GV.getLinkageName();
1007 if (!LinkageName.empty()) {
1008 // Skip special LLVM prefix that is used to inform the asm printer to not
1009 // emit usual symbol prefix before the symbol name. This happens for
1010 // Objective-C symbol names and symbol whose name is replaced using GCC's
1011 // __asm__ attribute.
1012 if (LinkageName[0] == 1)
1013 LinkageName = LinkageName.substr(1);
1014 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1017 addType(DW_Unit, GVDie, GV.getType());
1018 if (!GV.isLocalToUnit())
1019 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1020 addSourceLine(GVDie, &GV);
1023 DIEBlock *Block = new DIEBlock();
1024 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1025 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1026 Asm->Mang->getMangledName(GV.getGlobal()));
1027 addBlock(GVDie, dwarf::DW_AT_location, 0, Block);
1032 /// createMemberDIE - Create new member DIE.
1033 DIE *DwarfDebug::createMemberDIE(CompileUnit *DW_Unit, const DIDerivedType &DT){
1034 DIE *MemberDie = new DIE(DT.getTag());
1035 StringRef Name = DT.getName();
1037 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1039 addType(DW_Unit, MemberDie, DT.getTypeDerivedFrom());
1041 addSourceLine(MemberDie, &DT);
1043 DIEBlock *MemLocationDie = new DIEBlock();
1044 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1046 uint64_t Size = DT.getSizeInBits();
1047 uint64_t FieldSize = DT.getOriginalTypeSize();
1049 if (Size != FieldSize) {
1051 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1052 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1054 uint64_t Offset = DT.getOffsetInBits();
1055 uint64_t FieldOffset = Offset;
1056 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1057 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1058 FieldOffset = (HiMark - FieldSize);
1059 Offset -= FieldOffset;
1061 // Maybe we need to work from the other end.
1062 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1063 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1065 // Here WD_AT_data_member_location points to the anonymous
1066 // field that includes this bit field.
1067 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1070 // This is not a bitfield.
1071 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1073 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1075 if (DT.isProtected())
1076 addUInt(MemberDie, dwarf::DW_AT_accessibility, 0,
1077 dwarf::DW_ACCESS_protected);
1078 else if (DT.isPrivate())
1079 addUInt(MemberDie, dwarf::DW_AT_accessibility, 0,
1080 dwarf::DW_ACCESS_private);
1085 /// createSubprogramDIE - Create new DIE using SP.
1086 DIE *DwarfDebug::createSubprogramDIE(CompileUnit *DW_Unit,
1087 const DISubprogram &SP,
1090 DIE *SPDie = new DIE(dwarf::DW_TAG_subprogram);
1091 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1093 StringRef LinkageName = SP.getLinkageName();
1094 if (!LinkageName.empty()) {
1095 // Skip special LLVM prefix that is used to inform the asm printer to not
1096 // emit usual symbol prefix before the symbol name. This happens for
1097 // Objective-C symbol names and symbol whose name is replaced using GCC's
1098 // __asm__ attribute.
1099 if (LinkageName[0] == 1)
1100 LinkageName = LinkageName.substr(1);
1101 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1104 addSourceLine(SPDie, &SP);
1106 DICompositeType SPTy = SP.getType();
1107 DIArray Args = SPTy.getTypeArray();
1109 // Add prototyped tag, if C or ObjC.
1110 unsigned Lang = SP.getCompileUnit().getLanguage();
1111 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1112 Lang == dwarf::DW_LANG_ObjC)
1113 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1116 unsigned SPTag = SPTy.getTag();
1117 if (!IsConstructor) {
1118 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1119 addType(DW_Unit, SPDie, SPTy);
1121 addType(DW_Unit, SPDie, DIType(Args.getElement(0).getNode()));
1124 if (!SP.isDefinition()) {
1125 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1127 // Add arguments. Do not add arguments for subprogram definition. They will
1128 // be handled through RecordVariable.
1129 if (SPTag == dwarf::DW_TAG_subroutine_type)
1130 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1131 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1132 addType(DW_Unit, Arg, DIType(Args.getElement(i).getNode()));
1133 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1134 SPDie->addChild(Arg);
1138 // DW_TAG_inlined_subroutine may refer to this DIE.
1139 DW_Unit->insertDIE(SP.getNode(), SPDie);
1143 /// findCompileUnit - Get the compile unit for the given descriptor.
1145 CompileUnit &DwarfDebug::findCompileUnit(DICompileUnit Unit) const {
1146 DenseMap<Value *, CompileUnit *>::const_iterator I =
1147 CompileUnitMap.find(Unit.getNode());
1148 assert(I != CompileUnitMap.end() && "Missing compile unit.");
1152 /// createDbgScopeVariable - Create a new scope variable.
1154 DIE *DwarfDebug::createDbgScopeVariable(DbgVariable *DV, CompileUnit *Unit) {
1155 // Get the descriptor.
1156 const DIVariable &VD = DV->getVariable();
1157 StringRef Name = VD.getName();
1161 // Translate tag to proper Dwarf tag. The result variable is dropped for
1164 switch (VD.getTag()) {
1165 case dwarf::DW_TAG_return_variable:
1167 case dwarf::DW_TAG_arg_variable:
1168 Tag = dwarf::DW_TAG_formal_parameter;
1170 case dwarf::DW_TAG_auto_variable: // fall thru
1172 Tag = dwarf::DW_TAG_variable;
1176 // Define variable debug information entry.
1177 DIE *VariableDie = new DIE(Tag);
1178 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1180 // Add source line info if available.
1181 addSourceLine(VariableDie, &VD);
1183 // Add variable type.
1184 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1185 // addresses instead.
1186 if (VD.isBlockByrefVariable())
1187 addType(Unit, VariableDie, getBlockByrefType(VD.getType(), Name));
1189 addType(Unit, VariableDie, VD.getType());
1191 // Add variable address.
1192 // Variables for abstract instances of inlined functions don't get a
1194 MachineLocation Location;
1196 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1197 Location.set(FrameReg, Offset);
1200 if (VD.hasComplexAddress())
1201 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1202 else if (VD.isBlockByrefVariable())
1203 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1205 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1210 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1211 /// Initialize scope and update scope hierarchy.
1212 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1213 MDNode *InlinedAt) {
1214 assert (N && "Invalid Scope encoding!");
1215 assert (MI && "Missing machine instruction!");
1216 bool GetConcreteScope = (MI && InlinedAt);
1218 DbgScope *NScope = NULL;
1221 NScope = DbgScopeMap.lookup(InlinedAt);
1223 NScope = DbgScopeMap.lookup(N);
1224 assert (NScope && "Unable to find working scope!");
1226 if (NScope->getFirstInsn())
1229 DbgScope *Parent = NULL;
1230 if (GetConcreteScope) {
1231 DILocation IL(InlinedAt);
1232 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1233 IL.getOrigLocation().getNode());
1234 assert (Parent && "Unable to find Parent scope!");
1235 NScope->setParent(Parent);
1236 Parent->addScope(NScope);
1237 } else if (DIDescriptor(N).isLexicalBlock()) {
1238 DILexicalBlock DB(N);
1239 if (!DB.getContext().isNull()) {
1240 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1241 NScope->setParent(Parent);
1242 Parent->addScope(NScope);
1246 NScope->setFirstInsn(MI);
1248 if (!Parent && !InlinedAt) {
1249 StringRef SPName = DISubprogram(N).getLinkageName();
1250 if (SPName == MF->getFunction()->getName())
1251 CurrentFnDbgScope = NScope;
1254 if (GetConcreteScope) {
1255 ConcreteScopes[InlinedAt] = NScope;
1256 getOrCreateAbstractScope(N);
1262 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1263 assert (N && "Invalid Scope encoding!");
1265 DbgScope *AScope = AbstractScopes.lookup(N);
1269 DbgScope *Parent = NULL;
1271 DIDescriptor Scope(N);
1272 if (Scope.isLexicalBlock()) {
1273 DILexicalBlock DB(N);
1274 DIDescriptor ParentDesc = DB.getContext();
1275 if (!ParentDesc.isNull())
1276 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1279 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1282 Parent->addScope(AScope);
1283 AScope->setAbstractScope();
1284 AbstractScopes[N] = AScope;
1285 if (DIDescriptor(N).isSubprogram())
1286 AbstractScopesList.push_back(AScope);
1290 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1291 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1292 /// If there are global variables in this scope then create and insert
1293 /// DIEs for these variables.
1294 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1296 DIE *SPDie = ModuleCU->getDIE(SPNode);
1297 assert (SPDie && "Unable to find subprogram DIE!");
1298 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1299 DWLabel("func_begin", SubprogramCount));
1300 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1301 DWLabel("func_end", SubprogramCount));
1302 MachineLocation Location(RI->getFrameRegister(*MF));
1303 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1305 if (!DISubprogram(SPNode).isLocalToUnit())
1306 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1308 // If there are global variables at this scope then add their dies.
1309 for (SmallVector<WeakVH, 4>::iterator SGI = ScopedGVs.begin(),
1310 SGE = ScopedGVs.end(); SGI != SGE; ++SGI) {
1311 MDNode *N = dyn_cast_or_null<MDNode>(*SGI);
1313 DIGlobalVariable GV(N);
1314 if (GV.getContext().getNode() == SPNode) {
1315 DIE *ScopedGVDie = createGlobalVariableDIE(ModuleCU, GV);
1317 SPDie->addChild(ScopedGVDie);
1324 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1325 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1326 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1327 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1328 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1330 // Ignore empty scopes.
1331 if (StartID == EndID && StartID != 0)
1334 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1335 if (Scope->isAbstractScope())
1338 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1340 DWLabel("label", StartID)
1341 : DWLabel("func_begin", SubprogramCount));
1342 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1344 DWLabel("label", EndID)
1345 : DWLabel("func_end", SubprogramCount));
1352 /// constructInlinedScopeDIE - This scope represents inlined body of
1353 /// a function. Construct DIE to represent this concrete inlined copy
1354 /// of the function.
1355 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1356 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1357 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1358 assert (StartID && "Invalid starting label for an inlined scope!");
1359 assert (EndID && "Invalid end label for an inlined scope!");
1360 // Ignore empty scopes.
1361 if (StartID == EndID && StartID != 0)
1364 DIScope DS(Scope->getScopeNode());
1367 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1369 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1370 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1371 assert (OriginDIE && "Unable to find Origin DIE!");
1372 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1373 dwarf::DW_FORM_ref4, OriginDIE);
1375 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1376 DWLabel("label", StartID));
1377 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1378 DWLabel("label", EndID));
1380 InlinedSubprogramDIEs.insert(OriginDIE);
1382 // Track the start label for this inlined function.
1383 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1384 I = InlineInfo.find(InlinedSP.getNode());
1386 if (I == InlineInfo.end()) {
1387 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1389 InlinedSPNodes.push_back(InlinedSP.getNode());
1391 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1393 StringPool.insert(InlinedSP.getName());
1394 StringPool.insert(InlinedSP.getLinkageName());
1395 DILocation DL(Scope->getInlinedAt());
1396 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1397 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1403 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1404 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV,
1405 DbgScope *Scope, CompileUnit *Unit) {
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(Unit, VariableDie, getBlockByrefType(VD.getType(), Name));
1456 addType(Unit, 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, ModuleCU);
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(ModuleCU, DI_GV);
1637 ModuleCU->insertDIE(N, VariableDie);
1639 // Add to context owner.
1640 ModuleCU->getCUDie()->addChild(VariableDie);
1642 // Expose as global. FIXME - need to check external flag.
1643 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1645 DIType GTy = DI_GV.getType();
1646 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1647 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1648 assert (Entry && "Missing global type!");
1649 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1654 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1657 // Check for pre-existence.
1658 if (ModuleCU->getDIE(N))
1661 if (!SP.isDefinition())
1662 // This is a method declaration which will be handled while constructing
1666 DIE *SubprogramDie = createSubprogramDIE(ModuleCU, SP);
1669 ModuleCU->insertDIE(N, SubprogramDie);
1671 // Add to context owner.
1672 ModuleCU->getCUDie()->addChild(SubprogramDie);
1674 // Expose as global.
1675 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1680 /// beginModule - Emit all Dwarf sections that should come prior to the
1681 /// content. Create global DIEs and emit initial debug info sections.
1682 /// This is inovked by the target AsmPrinter.
1683 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1686 if (TimePassesIsEnabled)
1687 DebugTimer->startTimer();
1689 if (!MAI->doesSupportDebugInformation())
1692 DebugInfoFinder DbgFinder;
1693 DbgFinder.processModule(*M);
1695 // Create all the compile unit DIEs.
1696 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1697 E = DbgFinder.compile_unit_end(); I != E; ++I)
1698 constructCompileUnit(*I);
1700 if (CompileUnits.empty()) {
1701 if (TimePassesIsEnabled)
1702 DebugTimer->stopTimer();
1707 // If main compile unit for this module is not seen than randomly
1708 // select first compile unit.
1710 ModuleCU = CompileUnits[0];
1712 // Create DIEs for each of the externally visible global variables.
1713 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1714 E = DbgFinder.global_variable_end(); I != E; ++I) {
1715 DIGlobalVariable GV(*I);
1716 if (GV.getContext().getNode() != GV.getCompileUnit().getNode())
1717 ScopedGVs.push_back(*I);
1719 constructGlobalVariableDIE(*I);
1722 // Create DIEs for each subprogram.
1723 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1724 E = DbgFinder.subprogram_end(); I != E; ++I)
1725 constructSubprogramDIE(*I);
1729 MMI->setDebugInfoAvailability(true);
1731 // Prime section data.
1732 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1734 // Print out .file directives to specify files for .loc directives. These are
1735 // printed out early so that they precede any .loc directives.
1736 if (MAI->hasDotLocAndDotFile()) {
1737 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1738 // Remember source id starts at 1.
1739 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1740 sys::Path FullPath(getSourceDirectoryName(Id.first));
1742 FullPath.appendComponent(getSourceFileName(Id.second));
1743 assert(AppendOk && "Could not append filename to directory!");
1745 Asm->EmitFile(i, FullPath.str());
1750 // Emit initial sections
1753 if (TimePassesIsEnabled)
1754 DebugTimer->stopTimer();
1757 /// endModule - Emit all Dwarf sections that should come after the content.
1759 void DwarfDebug::endModule() {
1763 if (TimePassesIsEnabled)
1764 DebugTimer->startTimer();
1766 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1767 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1768 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1770 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1773 // Standard sections final addresses.
1774 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1775 EmitLabel("text_end", 0);
1776 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1777 EmitLabel("data_end", 0);
1779 // End text sections.
1780 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1781 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1782 EmitLabel("section_end", i);
1785 // Emit common frame information.
1786 emitCommonDebugFrame();
1788 // Emit function debug frame information
1789 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1790 E = DebugFrames.end(); I != E; ++I)
1791 emitFunctionDebugFrame(*I);
1793 // Compute DIE offsets and sizes.
1794 computeSizeAndOffsets();
1796 // Emit all the DIEs into a debug info section
1799 // Corresponding abbreviations into a abbrev section.
1800 emitAbbreviations();
1802 // Emit source line correspondence into a debug line section.
1805 // Emit info into a debug pubnames section.
1806 emitDebugPubNames();
1808 // Emit info into a debug pubtypes section.
1809 emitDebugPubTypes();
1811 // Emit info into a debug str section.
1814 // Emit info into a debug loc section.
1817 // Emit info into a debug aranges section.
1820 // Emit info into a debug ranges section.
1823 // Emit info into a debug macinfo section.
1826 // Emit inline info.
1827 emitDebugInlineInfo();
1829 if (TimePassesIsEnabled)
1830 DebugTimer->stopTimer();
1833 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1834 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1836 DILocation &ScopeLoc) {
1838 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1840 return AbsDbgVariable;
1842 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1846 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1847 Scope->addVariable(AbsDbgVariable);
1848 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1849 return AbsDbgVariable;
1852 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1853 void DwarfDebug::collectVariableInfo() {
1856 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1857 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1858 VE = VMap.end(); VI != VE; ++VI) {
1859 MetadataBase *MB = VI->first;
1860 MDNode *Var = dyn_cast_or_null<MDNode>(MB);
1862 DIVariable DV (Var);
1863 std::pair< unsigned, MDNode *> VP = VI->second;
1864 DILocation ScopeLoc(VP.second);
1867 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1869 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1870 // If variable scope is not found then skip this variable.
1874 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1875 Scope->addVariable(RegVar);
1876 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1878 RegVar->setAbstractVariable(AbsDbgVariable);
1882 /// beginScope - Process beginning of a scope starting at Label.
1883 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1884 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1885 if (I == DbgScopeBeginMap.end())
1887 ScopeVector &SD = I->second;
1888 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1890 (*SDI)->setStartLabelID(Label);
1893 /// endScope - Process end of a scope.
1894 void DwarfDebug::endScope(const MachineInstr *MI) {
1895 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1896 if (I == DbgScopeEndMap.end())
1899 unsigned Label = MMI->NextLabelID();
1900 Asm->printLabel(Label);
1902 SmallVector<DbgScope *, 2> &SD = I->second;
1903 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1905 (*SDI)->setEndLabelID(Label);
1909 /// createDbgScope - Create DbgScope for the scope.
1910 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1913 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1916 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1917 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1918 if (DIDescriptor(Scope).isLexicalBlock())
1919 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1923 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1927 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1928 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1929 DILocation DL(InlinedAt);
1930 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1933 /// extractScopeInformation - Scan machine instructions in this function
1934 /// and collect DbgScopes. Return true, if atleast one scope was found.
1935 bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
1936 // If scope information was extracted using .dbg intrinsics then there is not
1937 // any need to extract these information by scanning each instruction.
1938 if (!DbgScopeMap.empty())
1941 // Scan each instruction and create scopes. First build working set of scopes.
1942 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1944 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1946 const MachineInstr *MInsn = II;
1947 DebugLoc DL = MInsn->getDebugLoc();
1948 if (DL.isUnknown()) continue;
1949 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
1950 if (!DLT.Scope) continue;
1951 // There is no need to create another DIE for compile unit. For all
1952 // other scopes, create one DbgScope now. This will be translated
1953 // into a scope DIE at the end.
1954 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
1955 createDbgScope(DLT.Scope, DLT.InlinedAtLoc);
1960 // Build scope hierarchy using working set of scopes.
1961 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1963 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1965 const MachineInstr *MInsn = II;
1966 DebugLoc DL = MInsn->getDebugLoc();
1967 if (DL.isUnknown()) continue;
1968 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
1969 if (!DLT.Scope) continue;
1970 // There is no need to create another DIE for compile unit. For all
1971 // other scopes, create one DbgScope now. This will be translated
1972 // into a scope DIE at the end.
1973 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
1974 DbgScope *Scope = getUpdatedDbgScope(DLT.Scope, MInsn, DLT.InlinedAtLoc);
1975 Scope->setLastInsn(MInsn);
1979 // If a scope's last instruction is not set then use its child scope's
1980 // last instruction as this scope's last instrunction.
1981 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
1982 DE = DbgScopeMap.end(); DI != DE; ++DI) {
1983 if (DI->second->isAbstractScope())
1985 assert (DI->second->getFirstInsn() && "Invalid first instruction!");
1986 DI->second->fixInstructionMarkers();
1987 assert (DI->second->getLastInsn() && "Invalid last instruction!");
1990 // Each scope has first instruction and last instruction to mark beginning
1991 // and end of a scope respectively. Create an inverse map that list scopes
1992 // starts (and ends) with an instruction. One instruction may start (or end)
1994 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
1995 DE = DbgScopeMap.end(); DI != DE; ++DI) {
1996 DbgScope *S = DI->second;
1997 if (S->isAbstractScope())
1999 const MachineInstr *MI = S->getFirstInsn();
2000 assert (MI && "DbgScope does not have first instruction!");
2002 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2003 if (IDI != DbgScopeBeginMap.end())
2004 IDI->second.push_back(S);
2006 DbgScopeBeginMap[MI].push_back(S);
2008 MI = S->getLastInsn();
2009 assert (MI && "DbgScope does not have last instruction!");
2010 IDI = DbgScopeEndMap.find(MI);
2011 if (IDI != DbgScopeEndMap.end())
2012 IDI->second.push_back(S);
2014 DbgScopeEndMap[MI].push_back(S);
2017 return !DbgScopeMap.empty();
2020 /// beginFunction - Gather pre-function debug information. Assumes being
2021 /// emitted immediately after the function entry point.
2022 void DwarfDebug::beginFunction(MachineFunction *MF) {
2025 if (!ShouldEmitDwarfDebug()) return;
2027 if (TimePassesIsEnabled)
2028 DebugTimer->startTimer();
2030 if (!extractScopeInformation(MF))
2033 collectVariableInfo();
2035 // Begin accumulating function debug information.
2036 MMI->BeginFunction(MF);
2038 // Assumes in correct section after the entry point.
2039 EmitLabel("func_begin", ++SubprogramCount);
2041 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2043 DebugLoc FDL = MF->getDefaultDebugLoc();
2044 if (!FDL.isUnknown()) {
2045 DebugLocTuple DLT = MF->getDebugLocTuple(FDL);
2046 unsigned LabelID = 0;
2047 DISubprogram SP = getDISubprogram(DLT.Scope);
2049 LabelID = recordSourceLine(SP.getLineNumber(), 0, DLT.Scope);
2051 LabelID = recordSourceLine(DLT.Line, DLT.Col, DLT.Scope);
2052 Asm->printLabel(LabelID);
2055 if (TimePassesIsEnabled)
2056 DebugTimer->stopTimer();
2059 /// endFunction - Gather and emit post-function debug information.
2061 void DwarfDebug::endFunction(MachineFunction *MF) {
2062 if (!ShouldEmitDwarfDebug()) return;
2064 if (TimePassesIsEnabled)
2065 DebugTimer->startTimer();
2067 if (DbgScopeMap.empty())
2070 // Define end label for subprogram.
2071 EmitLabel("func_end", SubprogramCount);
2073 // Get function line info.
2074 if (!Lines.empty()) {
2075 // Get section line info.
2076 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2077 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2078 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2079 // Append the function info to section info.
2080 SectionLineInfos.insert(SectionLineInfos.end(),
2081 Lines.begin(), Lines.end());
2084 // Construct abstract scopes.
2085 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2086 AE = AbstractScopesList.end(); AI != AE; ++AI)
2087 constructScopeDIE(*AI);
2089 constructScopeDIE(CurrentFnDbgScope);
2091 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2092 MMI->getFrameMoves()));
2095 if (CurrentFnDbgScope) {
2096 CurrentFnDbgScope = NULL;
2097 DbgScopeMap.clear();
2098 DbgScopeBeginMap.clear();
2099 DbgScopeEndMap.clear();
2100 ConcreteScopes.clear();
2101 AbstractScopesList.clear();
2106 if (TimePassesIsEnabled)
2107 DebugTimer->stopTimer();
2110 /// recordSourceLine - Records location information and associates it with a
2111 /// label. Returns a unique label ID used to generate a label and provide
2112 /// correspondence to the source line list.
2113 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2118 if (TimePassesIsEnabled)
2119 DebugTimer->startTimer();
2124 DIDescriptor Scope(S);
2125 if (Scope.isCompileUnit()) {
2126 DICompileUnit CU(S);
2127 Dir = CU.getDirectory();
2128 Fn = CU.getFilename();
2129 } else if (Scope.isSubprogram()) {
2131 Dir = SP.getDirectory();
2132 Fn = SP.getFilename();
2133 } else if (Scope.isLexicalBlock()) {
2134 DILexicalBlock DB(S);
2135 Dir = DB.getDirectory();
2136 Fn = DB.getFilename();
2138 assert (0 && "Unexpected scope info");
2140 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2141 unsigned ID = MMI->NextLabelID();
2142 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2144 if (TimePassesIsEnabled)
2145 DebugTimer->stopTimer();
2150 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2151 /// timed. Look up the source id with the given directory and source file
2152 /// names. If none currently exists, create a new id and insert it in the
2153 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2155 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2156 const std::string &FileName) {
2157 if (TimePassesIsEnabled)
2158 DebugTimer->startTimer();
2160 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2162 if (TimePassesIsEnabled)
2163 DebugTimer->stopTimer();
2168 //===----------------------------------------------------------------------===//
2170 //===----------------------------------------------------------------------===//
2172 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2175 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2176 // Get the children.
2177 const std::vector<DIE *> &Children = Die->getChildren();
2179 // If not last sibling and has children then add sibling offset attribute.
2180 if (!Last && !Children.empty()) Die->addSiblingOffset();
2182 // Record the abbreviation.
2183 assignAbbrevNumber(Die->getAbbrev());
2185 // Get the abbreviation for this DIE.
2186 unsigned AbbrevNumber = Die->getAbbrevNumber();
2187 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2190 Die->setOffset(Offset);
2192 // Start the size with the size of abbreviation code.
2193 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2195 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2196 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2198 // Size the DIE attribute values.
2199 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2200 // Size attribute value.
2201 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2203 // Size the DIE children if any.
2204 if (!Children.empty()) {
2205 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2206 "Children flag not set");
2208 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2209 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2211 // End of children marker.
2212 Offset += sizeof(int8_t);
2215 Die->setSize(Offset - Die->getOffset());
2219 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2221 void DwarfDebug::computeSizeAndOffsets() {
2222 // Compute size of compile unit header.
2223 static unsigned Offset =
2224 sizeof(int32_t) + // Length of Compilation Unit Info
2225 sizeof(int16_t) + // DWARF version number
2226 sizeof(int32_t) + // Offset Into Abbrev. Section
2227 sizeof(int8_t); // Pointer Size (in bytes)
2229 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2230 CompileUnitOffsets[ModuleCU] = 0;
2233 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2234 /// tools to recognize the object file contains Dwarf information.
2235 void DwarfDebug::emitInitial() {
2236 // Check to see if we already emitted intial headers.
2237 if (didInitial) return;
2240 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2242 // Dwarf sections base addresses.
2243 if (MAI->doesDwarfRequireFrameSection()) {
2244 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2245 EmitLabel("section_debug_frame", 0);
2248 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2249 EmitLabel("section_info", 0);
2250 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2251 EmitLabel("section_abbrev", 0);
2252 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2253 EmitLabel("section_aranges", 0);
2255 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2256 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2257 EmitLabel("section_macinfo", 0);
2260 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2261 EmitLabel("section_line", 0);
2262 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2263 EmitLabel("section_loc", 0);
2264 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2265 EmitLabel("section_pubnames", 0);
2266 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2267 EmitLabel("section_pubtypes", 0);
2268 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2269 EmitLabel("section_str", 0);
2270 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2271 EmitLabel("section_ranges", 0);
2273 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2274 EmitLabel("text_begin", 0);
2275 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2276 EmitLabel("data_begin", 0);
2279 /// emitDIE - Recusively Emits a debug information entry.
2281 void DwarfDebug::emitDIE(DIE *Die) {
2282 // Get the abbreviation for this DIE.
2283 unsigned AbbrevNumber = Die->getAbbrevNumber();
2284 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2288 // Emit the code (index) for the abbreviation.
2289 Asm->EmitULEB128Bytes(AbbrevNumber);
2291 if (Asm->isVerbose())
2292 Asm->EOL(std::string("Abbrev [" +
2293 utostr(AbbrevNumber) +
2294 "] 0x" + utohexstr(Die->getOffset()) +
2295 ":0x" + utohexstr(Die->getSize()) + " " +
2296 dwarf::TagString(Abbrev->getTag())));
2300 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2301 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2303 // Emit the DIE attribute values.
2304 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2305 unsigned Attr = AbbrevData[i].getAttribute();
2306 unsigned Form = AbbrevData[i].getForm();
2307 assert(Form && "Too many attributes for DIE (check abbreviation)");
2310 case dwarf::DW_AT_sibling:
2311 Asm->EmitInt32(Die->getSiblingOffset());
2313 case dwarf::DW_AT_abstract_origin: {
2314 DIEEntry *E = cast<DIEEntry>(Values[i]);
2315 DIE *Origin = E->getEntry();
2316 unsigned Addr = Origin->getOffset();
2317 Asm->EmitInt32(Addr);
2321 // Emit an attribute using the defined form.
2322 Values[i]->EmitValue(this, Form);
2326 Asm->EOL(dwarf::AttributeString(Attr));
2329 // Emit the DIE children if any.
2330 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2331 const std::vector<DIE *> &Children = Die->getChildren();
2333 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2334 emitDIE(Children[j]);
2336 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2340 /// emitDebugInfo / emitDebugInfoPerCU - Emit the debug info section.
2342 void DwarfDebug::emitDebugInfoPerCU(CompileUnit *Unit) {
2343 DIE *Die = Unit->getCUDie();
2345 // Emit the compile units header.
2346 EmitLabel("info_begin", Unit->getID());
2348 // Emit size of content not including length itself
2349 unsigned ContentSize = Die->getSize() +
2350 sizeof(int16_t) + // DWARF version number
2351 sizeof(int32_t) + // Offset Into Abbrev. Section
2352 sizeof(int8_t) + // Pointer Size (in bytes)
2353 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2355 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
2356 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2357 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2358 Asm->EOL("Offset Into Abbrev. Section");
2359 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2362 // FIXME - extra padding for gdb bug.
2363 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2364 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2365 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2366 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2367 EmitLabel("info_end", Unit->getID());
2372 void DwarfDebug::emitDebugInfo() {
2373 // Start debug info section.
2374 Asm->OutStreamer.SwitchSection(
2375 Asm->getObjFileLowering().getDwarfInfoSection());
2377 emitDebugInfoPerCU(ModuleCU);
2380 /// emitAbbreviations - Emit the abbreviation section.
2382 void DwarfDebug::emitAbbreviations() const {
2383 // Check to see if it is worth the effort.
2384 if (!Abbreviations.empty()) {
2385 // Start the debug abbrev section.
2386 Asm->OutStreamer.SwitchSection(
2387 Asm->getObjFileLowering().getDwarfAbbrevSection());
2389 EmitLabel("abbrev_begin", 0);
2391 // For each abbrevation.
2392 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2393 // Get abbreviation data
2394 const DIEAbbrev *Abbrev = Abbreviations[i];
2396 // Emit the abbrevations code (base 1 index.)
2397 Asm->EmitULEB128Bytes(Abbrev->getNumber());
2398 Asm->EOL("Abbreviation Code");
2400 // Emit the abbreviations data.
2406 // Mark end of abbreviations.
2407 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2409 EmitLabel("abbrev_end", 0);
2414 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2415 /// the line matrix.
2417 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2418 // Define last address of section.
2419 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2420 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2421 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2422 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2424 // Mark end of matrix.
2425 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2426 Asm->EmitULEB128Bytes(1); Asm->EOL();
2427 Asm->EmitInt8(1); Asm->EOL();
2430 /// emitDebugLines - Emit source line information.
2432 void DwarfDebug::emitDebugLines() {
2433 // If the target is using .loc/.file, the assembler will be emitting the
2434 // .debug_line table automatically.
2435 if (MAI->hasDotLocAndDotFile())
2438 // Minimum line delta, thus ranging from -10..(255-10).
2439 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2440 // Maximum line delta, thus ranging from -10..(255-10).
2441 const int MaxLineDelta = 255 + MinLineDelta;
2443 // Start the dwarf line section.
2444 Asm->OutStreamer.SwitchSection(
2445 Asm->getObjFileLowering().getDwarfLineSection());
2447 // Construct the section header.
2448 EmitDifference("line_end", 0, "line_begin", 0, true);
2449 Asm->EOL("Length of Source Line Info");
2450 EmitLabel("line_begin", 0);
2452 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2454 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2455 Asm->EOL("Prolog Length");
2456 EmitLabel("line_prolog_begin", 0);
2458 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2460 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2462 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2464 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2466 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2468 // Line number standard opcode encodings argument count
2469 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2470 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2471 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2472 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2473 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2474 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2475 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2476 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2477 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2479 // Emit directories.
2480 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2481 Asm->EmitString(getSourceDirectoryName(DI));
2482 Asm->EOL("Directory");
2485 Asm->EmitInt8(0); Asm->EOL("End of directories");
2488 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2489 // Remember source id starts at 1.
2490 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2491 Asm->EmitString(getSourceFileName(Id.second));
2493 Asm->EmitULEB128Bytes(Id.first);
2494 Asm->EOL("Directory #");
2495 Asm->EmitULEB128Bytes(0);
2496 Asm->EOL("Mod date");
2497 Asm->EmitULEB128Bytes(0);
2498 Asm->EOL("File size");
2501 Asm->EmitInt8(0); Asm->EOL("End of files");
2503 EmitLabel("line_prolog_end", 0);
2505 // A sequence for each text section.
2506 unsigned SecSrcLinesSize = SectionSourceLines.size();
2508 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2509 // Isolate current sections line info.
2510 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2512 /*if (Asm->isVerbose()) {
2513 const MCSection *S = SectionMap[j + 1];
2514 O << '\t' << MAI->getCommentString() << " Section"
2515 << S->getName() << '\n';
2519 // Dwarf assumes we start with first line of first source file.
2520 unsigned Source = 1;
2523 // Construct rows of the address, source, line, column matrix.
2524 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2525 const SrcLineInfo &LineInfo = LineInfos[i];
2526 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2527 if (!LabelID) continue;
2529 if (LineInfo.getLine() == 0) continue;
2531 if (!Asm->isVerbose())
2534 std::pair<unsigned, unsigned> SourceID =
2535 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2536 O << '\t' << MAI->getCommentString() << ' '
2537 << getSourceDirectoryName(SourceID.first) << ' '
2538 << getSourceFileName(SourceID.second)
2539 <<" :" << utostr_32(LineInfo.getLine()) << '\n';
2542 // Define the line address.
2543 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2544 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2545 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2546 EmitReference("label", LabelID); Asm->EOL("Location label");
2548 // If change of source, then switch to the new source.
2549 if (Source != LineInfo.getSourceID()) {
2550 Source = LineInfo.getSourceID();
2551 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2552 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2555 // If change of line.
2556 if (Line != LineInfo.getLine()) {
2557 // Determine offset.
2558 int Offset = LineInfo.getLine() - Line;
2559 int Delta = Offset - MinLineDelta;
2562 Line = LineInfo.getLine();
2564 // If delta is small enough and in range...
2565 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2566 // ... then use fast opcode.
2567 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2569 // ... otherwise use long hand.
2570 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2571 Asm->EOL("DW_LNS_advance_line");
2572 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2573 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2576 // Copy the previous row (different address or source)
2577 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2581 emitEndOfLineMatrix(j + 1);
2584 if (SecSrcLinesSize == 0)
2585 // Because we're emitting a debug_line section, we still need a line
2586 // table. The linker and friends expect it to exist. If there's nothing to
2587 // put into it, emit an empty table.
2588 emitEndOfLineMatrix(1);
2590 EmitLabel("line_end", 0);
2594 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2596 void DwarfDebug::emitCommonDebugFrame() {
2597 if (!MAI->doesDwarfRequireFrameSection())
2601 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2602 TargetFrameInfo::StackGrowsUp ?
2603 TD->getPointerSize() : -TD->getPointerSize();
2605 // Start the dwarf frame section.
2606 Asm->OutStreamer.SwitchSection(
2607 Asm->getObjFileLowering().getDwarfFrameSection());
2609 EmitLabel("debug_frame_common", 0);
2610 EmitDifference("debug_frame_common_end", 0,
2611 "debug_frame_common_begin", 0, true);
2612 Asm->EOL("Length of Common Information Entry");
2614 EmitLabel("debug_frame_common_begin", 0);
2615 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2616 Asm->EOL("CIE Identifier Tag");
2617 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2618 Asm->EOL("CIE Version");
2619 Asm->EmitString("");
2620 Asm->EOL("CIE Augmentation");
2621 Asm->EmitULEB128Bytes(1);
2622 Asm->EOL("CIE Code Alignment Factor");
2623 Asm->EmitSLEB128Bytes(stackGrowth);
2624 Asm->EOL("CIE Data Alignment Factor");
2625 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2626 Asm->EOL("CIE RA Column");
2628 std::vector<MachineMove> Moves;
2629 RI->getInitialFrameState(Moves);
2631 EmitFrameMoves(NULL, 0, Moves, false);
2633 Asm->EmitAlignment(2, 0, 0, false);
2634 EmitLabel("debug_frame_common_end", 0);
2639 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2642 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2643 if (!MAI->doesDwarfRequireFrameSection())
2646 // Start the dwarf frame section.
2647 Asm->OutStreamer.SwitchSection(
2648 Asm->getObjFileLowering().getDwarfFrameSection());
2650 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2651 "debug_frame_begin", DebugFrameInfo.Number, true);
2652 Asm->EOL("Length of Frame Information Entry");
2654 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2656 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2658 Asm->EOL("FDE CIE offset");
2660 EmitReference("func_begin", DebugFrameInfo.Number);
2661 Asm->EOL("FDE initial location");
2662 EmitDifference("func_end", DebugFrameInfo.Number,
2663 "func_begin", DebugFrameInfo.Number);
2664 Asm->EOL("FDE address range");
2666 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2669 Asm->EmitAlignment(2, 0, 0, false);
2670 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2675 void DwarfDebug::emitDebugPubNamesPerCU(CompileUnit *Unit) {
2676 EmitDifference("pubnames_end", Unit->getID(),
2677 "pubnames_begin", Unit->getID(), true);
2678 Asm->EOL("Length of Public Names Info");
2680 EmitLabel("pubnames_begin", Unit->getID());
2682 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2684 EmitSectionOffset("info_begin", "section_info",
2685 Unit->getID(), 0, true, false);
2686 Asm->EOL("Offset of Compilation Unit Info");
2688 EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(),
2690 Asm->EOL("Compilation Unit Length");
2692 const StringMap<DIE*> &Globals = Unit->getGlobals();
2693 for (StringMap<DIE*>::const_iterator
2694 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2695 const char *Name = GI->getKeyData();
2696 DIE * Entity = GI->second;
2698 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2699 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2702 Asm->EmitInt32(0); Asm->EOL("End Mark");
2703 EmitLabel("pubnames_end", Unit->getID());
2708 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2710 void DwarfDebug::emitDebugPubNames() {
2711 // Start the dwarf pubnames section.
2712 Asm->OutStreamer.SwitchSection(
2713 Asm->getObjFileLowering().getDwarfPubNamesSection());
2715 emitDebugPubNamesPerCU(ModuleCU);
2718 void DwarfDebug::emitDebugPubTypes() {
2719 // Start the dwarf pubnames section.
2720 Asm->OutStreamer.SwitchSection(
2721 Asm->getObjFileLowering().getDwarfPubTypesSection());
2722 EmitDifference("pubtypes_end", ModuleCU->getID(),
2723 "pubtypes_begin", ModuleCU->getID(), true);
2724 Asm->EOL("Length of Public Types Info");
2726 EmitLabel("pubtypes_begin", ModuleCU->getID());
2728 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2730 EmitSectionOffset("info_begin", "section_info",
2731 ModuleCU->getID(), 0, true, false);
2732 Asm->EOL("Offset of Compilation ModuleCU Info");
2734 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2736 Asm->EOL("Compilation ModuleCU Length");
2738 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2739 for (StringMap<DIE*>::const_iterator
2740 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2741 const char *Name = GI->getKeyData();
2742 DIE * Entity = GI->second;
2744 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2745 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2748 Asm->EmitInt32(0); Asm->EOL("End Mark");
2749 EmitLabel("pubtypes_end", ModuleCU->getID());
2754 /// emitDebugStr - Emit visible names into a debug str section.
2756 void DwarfDebug::emitDebugStr() {
2757 // Check to see if it is worth the effort.
2758 if (!StringPool.empty()) {
2759 // Start the dwarf str section.
2760 Asm->OutStreamer.SwitchSection(
2761 Asm->getObjFileLowering().getDwarfStrSection());
2763 // For each of strings in the string pool.
2764 for (unsigned StringID = 1, N = StringPool.size();
2765 StringID <= N; ++StringID) {
2766 // Emit a label for reference from debug information entries.
2767 EmitLabel("string", StringID);
2769 // Emit the string itself.
2770 const std::string &String = StringPool[StringID];
2771 Asm->EmitString(String); Asm->EOL();
2778 /// emitDebugLoc - Emit visible names into a debug loc section.
2780 void DwarfDebug::emitDebugLoc() {
2781 // Start the dwarf loc section.
2782 Asm->OutStreamer.SwitchSection(
2783 Asm->getObjFileLowering().getDwarfLocSection());
2787 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2789 void DwarfDebug::EmitDebugARanges() {
2790 // Start the dwarf aranges section.
2791 Asm->OutStreamer.SwitchSection(
2792 Asm->getObjFileLowering().getDwarfARangesSection());
2796 CompileUnit *Unit = GetBaseCompileUnit();
2798 // Don't include size of length
2799 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
2801 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2803 EmitReference("info_begin", Unit->getID());
2804 Asm->EOL("Offset of Compilation Unit Info");
2806 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2808 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2810 Asm->EmitInt16(0); Asm->EOL("Pad (1)");
2811 Asm->EmitInt16(0); Asm->EOL("Pad (2)");
2814 EmitReference("text_begin", 0); Asm->EOL("Address");
2815 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2817 Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2818 Asm->EmitInt32(0); Asm->EOL("EOM (2)");
2824 /// emitDebugRanges - Emit visible names into a debug ranges section.
2826 void DwarfDebug::emitDebugRanges() {
2827 // Start the dwarf ranges section.
2828 Asm->OutStreamer.SwitchSection(
2829 Asm->getObjFileLowering().getDwarfRangesSection());
2833 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2835 void DwarfDebug::emitDebugMacInfo() {
2836 if (const MCSection *LineInfo =
2837 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2838 // Start the dwarf macinfo section.
2839 Asm->OutStreamer.SwitchSection(LineInfo);
2844 /// emitDebugInlineInfo - Emit inline info using following format.
2846 /// 1. length of section
2847 /// 2. Dwarf version number
2848 /// 3. address size.
2850 /// Entries (one "entry" for each function that was inlined):
2852 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2853 /// otherwise offset into __debug_str for regular function name.
2854 /// 2. offset into __debug_str section for regular function name.
2855 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2856 /// instances for the function.
2858 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2859 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2860 /// __debug_info section, and the low_pc is the starting address for the
2861 /// inlining instance.
2862 void DwarfDebug::emitDebugInlineInfo() {
2863 if (!MAI->doesDwarfUsesInlineInfoSection())
2869 Asm->OutStreamer.SwitchSection(
2870 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2872 EmitDifference("debug_inlined_end", 1,
2873 "debug_inlined_begin", 1, true);
2874 Asm->EOL("Length of Debug Inlined Information Entry");
2876 EmitLabel("debug_inlined_begin", 1);
2878 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2879 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2881 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2882 E = InlinedSPNodes.end(); I != E; ++I) {
2884 // for (ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
2885 // I = InlineInfo.begin(), E = InlineInfo.end(); I != E; ++I) {
2887 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2888 = InlineInfo.find(Node);
2889 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2890 DISubprogram SP(Node);
2891 StringRef LName = SP.getLinkageName();
2892 StringRef Name = SP.getName();
2895 Asm->EmitString(Name);
2897 // Skip special LLVM prefix that is used to inform the asm printer to not
2898 // emit usual symbol prefix before the symbol name. This happens for
2899 // Objective-C symbol names and symbol whose name is replaced using GCC's
2900 // __asm__ attribute.
2902 LName = LName.substr(1);
2903 // Asm->EmitString(LName);
2904 EmitSectionOffset("string", "section_str",
2905 StringPool.idFor(LName), false, true);
2908 Asm->EOL("MIPS linkage name");
2909 // Asm->EmitString(Name);
2910 EmitSectionOffset("string", "section_str",
2911 StringPool.idFor(Name), false, true);
2912 Asm->EOL("Function name");
2913 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2915 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2916 LE = Labels.end(); LI != LE; ++LI) {
2917 DIE *SP = LI->second;
2918 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2920 if (TD->getPointerSize() == sizeof(int32_t))
2921 O << MAI->getData32bitsDirective();
2923 O << MAI->getData64bitsDirective();
2925 PrintLabelName("label", LI->first); Asm->EOL("low_pc");
2929 EmitLabel("debug_inlined_end", 1);