1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
13 #define DEBUG_TYPE "dwarfdebug"
14 #include "DwarfDebug.h"
15 #include "llvm/Module.h"
16 #include "llvm/CodeGen/MachineFunction.h"
17 #include "llvm/CodeGen/MachineModuleInfo.h"
18 #include "llvm/MC/MCSection.h"
19 #include "llvm/MC/MCStreamer.h"
20 #include "llvm/MC/MCAsmInfo.h"
21 #include "llvm/Target/TargetData.h"
22 #include "llvm/Target/TargetFrameInfo.h"
23 #include "llvm/Target/TargetLoweringObjectFile.h"
24 #include "llvm/Target/TargetRegisterInfo.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/Support/Debug.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/Mangler.h"
29 #include "llvm/Support/Timer.h"
30 #include "llvm/System/Path.h"
33 static TimerGroup &getDwarfTimerGroup() {
34 static TimerGroup DwarfTimerGroup("Dwarf Debugging");
35 return DwarfTimerGroup;
38 //===----------------------------------------------------------------------===//
40 /// Configuration values for initial hash set sizes (log2).
42 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
46 //===----------------------------------------------------------------------===//
47 /// CompileUnit - This dwarf writer support class manages information associate
48 /// with a source file.
50 /// ID - File identifier for source.
54 /// Die - Compile unit debug information entry.
58 /// IndexTyDie - An anonymous type for index type.
61 /// GVToDieMap - Tracks the mapping of unit level debug informaton
62 /// variables to debug information entries.
63 /// FIXME : Rename GVToDieMap -> NodeToDieMap
64 ValueMap<MDNode *, DIE *> GVToDieMap;
66 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
67 /// descriptors to debug information entries using a DIEEntry proxy.
69 ValueMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
71 /// Globals - A map of globally visible named entities for this unit.
73 StringMap<DIE*> Globals;
75 /// GlobalTypes - A map of globally visible types for this unit.
77 StringMap<DIE*> GlobalTypes;
80 CompileUnit(unsigned I, DIE *D)
81 : ID(I), CUDie(D), IndexTyDie(0) {}
82 ~CompileUnit() { delete CUDie; delete IndexTyDie; }
85 unsigned getID() const { return ID; }
86 DIE* getCUDie() const { return CUDie; }
87 const StringMap<DIE*> &getGlobals() const { return Globals; }
88 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
90 /// hasContent - Return true if this compile unit has something to write out.
92 bool hasContent() const { return !CUDie->getChildren().empty(); }
94 /// addGlobal - Add a new global entity to the compile unit.
96 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
98 /// addGlobalType - Add a new global type to the compile unit.
100 void addGlobalType(const std::string &Name, DIE *Die) {
101 GlobalTypes[Name] = Die;
104 /// getDIE - Returns the debug information entry map slot for the
105 /// specified debug variable.
106 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
108 /// insertDIE - Insert DIE into the map.
109 void insertDIE(MDNode *N, DIE *D) {
110 GVToDieMap.insert(std::make_pair(N, D));
113 /// getDIEEntry - Returns the debug information entry for the speciefied
115 DIEEntry *getDIEEntry(MDNode *N) { return GVToDIEEntryMap.lookup(N); }
117 /// insertDIEEntry - Insert debug information entry into the map.
118 void insertDIEEntry(MDNode *N, DIEEntry *E) {
119 GVToDIEEntryMap.insert(std::make_pair(N, E));
122 /// addDie - Adds or interns the DIE to the compile unit.
124 void addDie(DIE *Buffer) {
125 this->CUDie->addChild(Buffer);
128 // getIndexTyDie - Get an anonymous type for index type.
129 DIE *getIndexTyDie() {
133 // setIndexTyDie - Set D as anonymous type for index which can be reused
135 void setIndexTyDie(DIE *D) {
141 //===----------------------------------------------------------------------===//
142 /// DbgVariable - This class is used to track local variable information.
145 DIVariable Var; // Variable Descriptor.
146 unsigned FrameIndex; // Variable frame index.
147 DbgVariable *AbstractVar; // Abstract variable for this variable.
150 DbgVariable(DIVariable V, unsigned I)
151 : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0) {}
154 DIVariable getVariable() const { return Var; }
155 unsigned getFrameIndex() const { return FrameIndex; }
156 void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
157 DbgVariable *getAbstractVariable() const { return AbstractVar; }
158 void setDIE(DIE *D) { TheDIE = D; }
159 DIE *getDIE() const { return TheDIE; }
162 //===----------------------------------------------------------------------===//
163 /// DbgScope - This class is used to track scope information.
166 DbgScope *Parent; // Parent to this scope.
167 DIDescriptor Desc; // Debug info descriptor for scope.
168 WeakVH InlinedAtLocation; // Location at which scope is inlined.
169 bool AbstractScope; // Abstract Scope
170 unsigned StartLabelID; // Label ID of the beginning of scope.
171 unsigned EndLabelID; // Label ID of the end of scope.
172 const MachineInstr *LastInsn; // Last instruction of this scope.
173 const MachineInstr *FirstInsn; // First instruction of this scope.
174 SmallVector<DbgScope *, 4> Scopes; // Scopes defined in scope.
175 SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
177 // Private state for dump()
178 mutable unsigned IndentLevel;
180 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
181 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
182 StartLabelID(0), EndLabelID(0),
183 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
187 DbgScope *getParent() const { return Parent; }
188 void setParent(DbgScope *P) { Parent = P; }
189 DIDescriptor getDesc() const { return Desc; }
190 MDNode *getInlinedAt() const {
191 return dyn_cast_or_null<MDNode>(InlinedAtLocation);
193 MDNode *getScopeNode() const { return Desc.getNode(); }
194 unsigned getStartLabelID() const { return StartLabelID; }
195 unsigned getEndLabelID() const { return EndLabelID; }
196 SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
197 SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
198 void setStartLabelID(unsigned S) { StartLabelID = S; }
199 void setEndLabelID(unsigned E) { EndLabelID = E; }
200 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
201 const MachineInstr *getLastInsn() { return LastInsn; }
202 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
203 void setAbstractScope() { AbstractScope = true; }
204 bool isAbstractScope() const { return AbstractScope; }
205 const MachineInstr *getFirstInsn() { return FirstInsn; }
207 /// addScope - Add a scope to the scope.
209 void addScope(DbgScope *S) { Scopes.push_back(S); }
211 /// addVariable - Add a variable to the scope.
213 void addVariable(DbgVariable *V) { Variables.push_back(V); }
215 void fixInstructionMarkers() {
216 assert (getFirstInsn() && "First instruction is missing!");
220 // If a scope does not have an instruction to mark an end then use
221 // the end of last child scope.
222 SmallVector<DbgScope *, 4> &Scopes = getScopes();
223 assert (!Scopes.empty() && "Inner most scope does not have last insn!");
224 DbgScope *L = Scopes.back();
225 if (!L->getLastInsn())
226 L->fixInstructionMarkers();
227 setLastInsn(L->getLastInsn());
236 void DbgScope::dump() const {
237 raw_ostream &err = errs();
238 err.indent(IndentLevel);
239 MDNode *N = Desc.getNode();
241 err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
243 err << "Abstract Scope\n";
247 err << "Children ...\n";
248 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
249 if (Scopes[i] != this)
256 DbgScope::~DbgScope() {
257 for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
259 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
263 } // end llvm namespace
265 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
266 : Dwarf(OS, A, T, "dbg"), ModuleCU(0),
267 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
268 DIEValues(), StringPool(),
269 SectionSourceLines(), didInitial(false), shouldEmit(false),
270 CurrentFnDbgScope(0), DebugTimer(0) {
271 if (TimePassesIsEnabled)
272 DebugTimer = new Timer("Dwarf Debug Writer",
273 getDwarfTimerGroup());
275 DwarfDebug::~DwarfDebug() {
276 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
282 /// assignAbbrevNumber - Define a unique number for the abbreviation.
284 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
285 // Profile the node so that we can make it unique.
289 // Check the set for priors.
290 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
292 // If it's newly added.
293 if (InSet == &Abbrev) {
294 // Add to abbreviation list.
295 Abbreviations.push_back(&Abbrev);
297 // Assign the vector position + 1 as its number.
298 Abbrev.setNumber(Abbreviations.size());
300 // Assign existing abbreviation number.
301 Abbrev.setNumber(InSet->getNumber());
305 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
306 /// information entry.
307 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
308 DIEEntry *Value = new DIEEntry(Entry);
309 DIEValues.push_back(Value);
313 /// addUInt - Add an unsigned integer attribute data and value.
315 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
316 unsigned Form, uint64_t Integer) {
317 if (!Form) Form = DIEInteger::BestForm(false, Integer);
318 DIEValue *Value = new DIEInteger(Integer);
319 DIEValues.push_back(Value);
320 Die->addValue(Attribute, Form, Value);
323 /// addSInt - Add an signed integer attribute data and value.
325 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
326 unsigned Form, int64_t Integer) {
327 if (!Form) Form = DIEInteger::BestForm(true, Integer);
328 DIEValue *Value = new DIEInteger(Integer);
329 DIEValues.push_back(Value);
330 Die->addValue(Attribute, Form, Value);
333 /// addString - Add a string attribute data and value. DIEString only
334 /// keeps string reference.
335 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
336 const StringRef String) {
337 DIEValue *Value = new DIEString(String);
338 DIEValues.push_back(Value);
339 Die->addValue(Attribute, Form, Value);
342 /// addLabel - Add a Dwarf label attribute data and value.
344 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
345 const DWLabel &Label) {
346 DIEValue *Value = new DIEDwarfLabel(Label);
347 DIEValues.push_back(Value);
348 Die->addValue(Attribute, Form, Value);
351 /// addObjectLabel - Add an non-Dwarf label attribute data and value.
353 void DwarfDebug::addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
354 const std::string &Label) {
355 DIEValue *Value = new DIEObjectLabel(Label);
356 DIEValues.push_back(Value);
357 Die->addValue(Attribute, Form, Value);
360 /// addSectionOffset - Add a section offset label attribute data and value.
362 void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
363 const DWLabel &Label, const DWLabel &Section,
364 bool isEH, bool useSet) {
365 DIEValue *Value = new DIESectionOffset(Label, Section, isEH, useSet);
366 DIEValues.push_back(Value);
367 Die->addValue(Attribute, Form, Value);
370 /// addDelta - Add a label delta attribute data and value.
372 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
373 const DWLabel &Hi, const DWLabel &Lo) {
374 DIEValue *Value = new DIEDelta(Hi, Lo);
375 DIEValues.push_back(Value);
376 Die->addValue(Attribute, Form, Value);
379 /// addBlock - Add block data.
381 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
383 Block->ComputeSize(TD);
384 DIEValues.push_back(Block);
385 Die->addValue(Attribute, Block->BestForm(), Block);
388 /// addSourceLine - Add location information to specified debug information
390 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
391 // If there is no compile unit specified, don't add a line #.
392 if (V->getCompileUnit().isNull())
395 unsigned Line = V->getLineNumber();
396 unsigned FileID = findCompileUnit(V->getCompileUnit()).getID();
397 assert(FileID && "Invalid file id");
398 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
399 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
402 /// addSourceLine - Add location information to specified debug information
404 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
405 // If there is no compile unit specified, don't add a line #.
406 if (G->getCompileUnit().isNull())
409 unsigned Line = G->getLineNumber();
410 unsigned FileID = findCompileUnit(G->getCompileUnit()).getID();
411 assert(FileID && "Invalid file id");
412 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
413 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
416 /// addSourceLine - Add location information to specified debug information
418 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
419 // If there is no compile unit specified, don't add a line #.
420 if (SP->getCompileUnit().isNull())
422 // If the line number is 0, don't add it.
423 if (SP->getLineNumber() == 0)
427 unsigned Line = SP->getLineNumber();
428 unsigned FileID = findCompileUnit(SP->getCompileUnit()).getID();
429 assert(FileID && "Invalid file id");
430 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
431 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
434 /// addSourceLine - Add location information to specified debug information
436 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
437 // If there is no compile unit specified, don't add a line #.
438 DICompileUnit CU = Ty->getCompileUnit();
442 unsigned Line = Ty->getLineNumber();
443 unsigned FileID = findCompileUnit(CU).getID();
444 assert(FileID && "Invalid file id");
445 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
446 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
449 /* Byref variables, in Blocks, are declared by the programmer as
450 "SomeType VarName;", but the compiler creates a
451 __Block_byref_x_VarName struct, and gives the variable VarName
452 either the struct, or a pointer to the struct, as its type. This
453 is necessary for various behind-the-scenes things the compiler
454 needs to do with by-reference variables in blocks.
456 However, as far as the original *programmer* is concerned, the
457 variable should still have type 'SomeType', as originally declared.
459 The following function dives into the __Block_byref_x_VarName
460 struct to find the original type of the variable. This will be
461 passed back to the code generating the type for the Debug
462 Information Entry for the variable 'VarName'. 'VarName' will then
463 have the original type 'SomeType' in its debug information.
465 The original type 'SomeType' will be the type of the field named
466 'VarName' inside the __Block_byref_x_VarName struct.
468 NOTE: In order for this to not completely fail on the debugger
469 side, the Debug Information Entry for the variable VarName needs to
470 have a DW_AT_location that tells the debugger how to unwind through
471 the pointers and __Block_byref_x_VarName struct to find the actual
472 value of the variable. The function addBlockByrefType does this. */
474 /// Find the type the programmer originally declared the variable to be
475 /// and return that type.
477 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
480 unsigned tag = Ty.getTag();
482 if (tag == dwarf::DW_TAG_pointer_type) {
483 DIDerivedType DTy = DIDerivedType(Ty.getNode());
484 subType = DTy.getTypeDerivedFrom();
487 DICompositeType blockStruct = DICompositeType(subType.getNode());
489 DIArray Elements = blockStruct.getTypeArray();
491 if (Elements.isNull())
494 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
495 DIDescriptor Element = Elements.getElement(i);
496 DIDerivedType DT = DIDerivedType(Element.getNode());
497 if (Name == DT.getName())
498 return (DT.getTypeDerivedFrom());
504 /// addComplexAddress - Start with the address based on the location provided,
505 /// and generate the DWARF information necessary to find the actual variable
506 /// given the extra address information encoded in the DIVariable, starting from
507 /// the starting location. Add the DWARF information to the die.
509 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
511 const MachineLocation &Location) {
512 const DIVariable &VD = DV->getVariable();
513 DIType Ty = VD.getType();
515 // Decode the original location, and use that as the start of the byref
516 // variable's location.
517 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
518 DIEBlock *Block = new DIEBlock();
520 if (Location.isReg()) {
522 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
524 Reg = Reg - dwarf::DW_OP_reg0;
525 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
526 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
530 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
532 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
533 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
536 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
539 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
540 uint64_t Element = VD.getAddrElement(i);
542 if (Element == DIFactory::OpPlus) {
543 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
544 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
545 } else if (Element == DIFactory::OpDeref) {
546 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
547 } else llvm_unreachable("unknown DIFactory Opcode");
550 // Now attach the location information to the DIE.
551 addBlock(Die, Attribute, 0, Block);
554 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
555 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
556 gives the variable VarName either the struct, or a pointer to the struct, as
557 its type. This is necessary for various behind-the-scenes things the
558 compiler needs to do with by-reference variables in Blocks.
560 However, as far as the original *programmer* is concerned, the variable
561 should still have type 'SomeType', as originally declared.
563 The function getBlockByrefType dives into the __Block_byref_x_VarName
564 struct to find the original type of the variable, which is then assigned to
565 the variable's Debug Information Entry as its real type. So far, so good.
566 However now the debugger will expect the variable VarName to have the type
567 SomeType. So we need the location attribute for the variable to be an
568 expression that explains to the debugger how to navigate through the
569 pointers and struct to find the actual variable of type SomeType.
571 The following function does just that. We start by getting
572 the "normal" location for the variable. This will be the location
573 of either the struct __Block_byref_x_VarName or the pointer to the
574 struct __Block_byref_x_VarName.
576 The struct will look something like:
578 struct __Block_byref_x_VarName {
580 struct __Block_byref_x_VarName *forwarding;
581 ... <various other fields>
583 ... <maybe more fields>
586 If we are given the struct directly (as our starting point) we
587 need to tell the debugger to:
589 1). Add the offset of the forwarding field.
591 2). Follow that pointer to get the the real __Block_byref_x_VarName
592 struct to use (the real one may have been copied onto the heap).
594 3). Add the offset for the field VarName, to find the actual variable.
596 If we started with a pointer to the struct, then we need to
597 dereference that pointer first, before the other steps.
598 Translating this into DWARF ops, we will need to append the following
599 to the current location description for the variable:
601 DW_OP_deref -- optional, if we start with a pointer
602 DW_OP_plus_uconst <forward_fld_offset>
604 DW_OP_plus_uconst <varName_fld_offset>
606 That is what this function does. */
608 /// addBlockByrefAddress - Start with the address based on the location
609 /// provided, and generate the DWARF information necessary to find the
610 /// actual Block variable (navigating the Block struct) based on the
611 /// starting location. Add the DWARF information to the die. For
612 /// more information, read large comment just above here.
614 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
616 const MachineLocation &Location) {
617 const DIVariable &VD = DV->getVariable();
618 DIType Ty = VD.getType();
620 unsigned Tag = Ty.getTag();
621 bool isPointer = false;
623 StringRef varName = VD.getName();
625 if (Tag == dwarf::DW_TAG_pointer_type) {
626 DIDerivedType DTy = DIDerivedType(Ty.getNode());
627 TmpTy = DTy.getTypeDerivedFrom();
631 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
633 // Find the __forwarding field and the variable field in the __Block_byref
635 DIArray Fields = blockStruct.getTypeArray();
636 DIDescriptor varField = DIDescriptor();
637 DIDescriptor forwardingField = DIDescriptor();
640 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
641 DIDescriptor Element = Fields.getElement(i);
642 DIDerivedType DT = DIDerivedType(Element.getNode());
643 StringRef fieldName = DT.getName();
644 if (fieldName == "__forwarding")
645 forwardingField = Element;
646 else if (fieldName == varName)
650 assert(!varField.isNull() && "Can't find byref variable in Block struct");
651 assert(!forwardingField.isNull()
652 && "Can't find forwarding field in Block struct");
654 // Get the offsets for the forwarding field and the variable field.
655 unsigned int forwardingFieldOffset =
656 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
657 unsigned int varFieldOffset =
658 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
660 // Decode the original location, and use that as the start of the byref
661 // variable's location.
662 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
663 DIEBlock *Block = new DIEBlock();
665 if (Location.isReg()) {
667 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
669 Reg = Reg - dwarf::DW_OP_reg0;
670 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
671 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
675 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
677 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
678 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
681 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
684 // If we started with a pointer to the __Block_byref... struct, then
685 // the first thing we need to do is dereference the pointer (DW_OP_deref).
687 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
689 // Next add the offset for the '__forwarding' field:
690 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
691 // adding the offset if it's 0.
692 if (forwardingFieldOffset > 0) {
693 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
694 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
697 // Now dereference the __forwarding field to get to the real __Block_byref
698 // struct: DW_OP_deref.
699 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
701 // Now that we've got the real __Block_byref... struct, add the offset
702 // for the variable's field to get to the location of the actual variable:
703 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
704 if (varFieldOffset > 0) {
705 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
706 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
709 // Now attach the location information to the DIE.
710 addBlock(Die, Attribute, 0, Block);
713 /// addAddress - Add an address attribute to a die based on the location
715 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
716 const MachineLocation &Location) {
717 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
718 DIEBlock *Block = new DIEBlock();
720 if (Location.isReg()) {
722 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
724 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
725 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
729 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
731 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
732 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
735 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
738 addBlock(Die, Attribute, 0, Block);
741 /// 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 = ModuleCU->getDIE(SP.getNode());
1094 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1095 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1097 StringRef LinkageName = SP.getLinkageName();
1098 if (!LinkageName.empty()) {
1099 // Skip special LLVM prefix that is used to inform the asm printer to not
1100 // emit usual symbol prefix before the symbol name. This happens for
1101 // Objective-C symbol names and symbol whose name is replaced using GCC's
1102 // __asm__ attribute.
1103 if (LinkageName[0] == 1)
1104 LinkageName = LinkageName.substr(1);
1105 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1108 addSourceLine(SPDie, &SP);
1110 DICompositeType SPTy = SP.getType();
1111 DIArray Args = SPTy.getTypeArray();
1113 // Add prototyped tag, if C or ObjC.
1114 unsigned Lang = SP.getCompileUnit().getLanguage();
1115 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1116 Lang == dwarf::DW_LANG_ObjC)
1117 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1120 unsigned SPTag = SPTy.getTag();
1121 if (!IsConstructor) {
1122 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1123 addType(DW_Unit, SPDie, SPTy);
1125 addType(DW_Unit, SPDie, DIType(Args.getElement(0).getNode()));
1128 if (!SP.isDefinition()) {
1129 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1131 // Add arguments. Do not add arguments for subprogram definition. They will
1132 // be handled through RecordVariable.
1133 if (SPTag == dwarf::DW_TAG_subroutine_type)
1134 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1135 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1136 addType(DW_Unit, Arg, DIType(Args.getElement(i).getNode()));
1137 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1138 SPDie->addChild(Arg);
1142 // DW_TAG_inlined_subroutine may refer to this DIE.
1143 DW_Unit->insertDIE(SP.getNode(), SPDie);
1147 /// findCompileUnit - Get the compile unit for the given descriptor.
1149 CompileUnit &DwarfDebug::findCompileUnit(DICompileUnit Unit) const {
1150 DenseMap<Value *, CompileUnit *>::const_iterator I =
1151 CompileUnitMap.find(Unit.getNode());
1152 assert(I != CompileUnitMap.end() && "Missing compile unit.");
1156 /// createDbgScopeVariable - Create a new scope variable.
1158 DIE *DwarfDebug::createDbgScopeVariable(DbgVariable *DV, CompileUnit *Unit) {
1159 // Get the descriptor.
1160 const DIVariable &VD = DV->getVariable();
1161 StringRef Name = VD.getName();
1165 // Translate tag to proper Dwarf tag. The result variable is dropped for
1168 switch (VD.getTag()) {
1169 case dwarf::DW_TAG_return_variable:
1171 case dwarf::DW_TAG_arg_variable:
1172 Tag = dwarf::DW_TAG_formal_parameter;
1174 case dwarf::DW_TAG_auto_variable: // fall thru
1176 Tag = dwarf::DW_TAG_variable;
1180 // Define variable debug information entry.
1181 DIE *VariableDie = new DIE(Tag);
1182 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1184 // Add source line info if available.
1185 addSourceLine(VariableDie, &VD);
1187 // Add variable type.
1188 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1189 // addresses instead.
1190 if (VD.isBlockByrefVariable())
1191 addType(Unit, VariableDie, getBlockByrefType(VD.getType(), Name));
1193 addType(Unit, VariableDie, VD.getType());
1195 // Add variable address.
1196 // Variables for abstract instances of inlined functions don't get a
1198 MachineLocation Location;
1200 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1201 Location.set(FrameReg, Offset);
1204 if (VD.hasComplexAddress())
1205 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1206 else if (VD.isBlockByrefVariable())
1207 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1209 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1214 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1215 /// Initialize scope and update scope hierarchy.
1216 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1217 MDNode *InlinedAt) {
1218 assert (N && "Invalid Scope encoding!");
1219 assert (MI && "Missing machine instruction!");
1220 bool GetConcreteScope = (MI && InlinedAt);
1222 DbgScope *NScope = NULL;
1225 NScope = DbgScopeMap.lookup(InlinedAt);
1227 NScope = DbgScopeMap.lookup(N);
1228 assert (NScope && "Unable to find working scope!");
1230 if (NScope->getFirstInsn())
1233 DbgScope *Parent = NULL;
1234 if (GetConcreteScope) {
1235 DILocation IL(InlinedAt);
1236 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1237 IL.getOrigLocation().getNode());
1238 assert (Parent && "Unable to find Parent scope!");
1239 NScope->setParent(Parent);
1240 Parent->addScope(NScope);
1241 } else if (DIDescriptor(N).isLexicalBlock()) {
1242 DILexicalBlock DB(N);
1243 if (!DB.getContext().isNull()) {
1244 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1245 NScope->setParent(Parent);
1246 Parent->addScope(NScope);
1250 NScope->setFirstInsn(MI);
1252 if (!Parent && !InlinedAt) {
1253 StringRef SPName = DISubprogram(N).getLinkageName();
1254 if (SPName == MF->getFunction()->getName())
1255 CurrentFnDbgScope = NScope;
1258 if (GetConcreteScope) {
1259 ConcreteScopes[InlinedAt] = NScope;
1260 getOrCreateAbstractScope(N);
1266 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1267 assert (N && "Invalid Scope encoding!");
1269 DbgScope *AScope = AbstractScopes.lookup(N);
1273 DbgScope *Parent = NULL;
1275 DIDescriptor Scope(N);
1276 if (Scope.isLexicalBlock()) {
1277 DILexicalBlock DB(N);
1278 DIDescriptor ParentDesc = DB.getContext();
1279 if (!ParentDesc.isNull())
1280 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1283 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1286 Parent->addScope(AScope);
1287 AScope->setAbstractScope();
1288 AbstractScopes[N] = AScope;
1289 if (DIDescriptor(N).isSubprogram())
1290 AbstractScopesList.push_back(AScope);
1294 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1295 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1296 /// If there are global variables in this scope then create and insert
1297 /// DIEs for these variables.
1298 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1300 DIE *SPDie = ModuleCU->getDIE(SPNode);
1301 assert (SPDie && "Unable to find subprogram DIE!");
1302 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1303 DWLabel("func_begin", SubprogramCount));
1304 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1305 DWLabel("func_end", SubprogramCount));
1306 MachineLocation Location(RI->getFrameRegister(*MF));
1307 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1309 if (!DISubprogram(SPNode).isLocalToUnit())
1310 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1312 // If there are global variables at this scope then add their dies.
1313 for (SmallVector<WeakVH, 4>::iterator SGI = ScopedGVs.begin(),
1314 SGE = ScopedGVs.end(); SGI != SGE; ++SGI) {
1315 MDNode *N = dyn_cast_or_null<MDNode>(*SGI);
1317 DIGlobalVariable GV(N);
1318 if (GV.getContext().getNode() == SPNode) {
1319 DIE *ScopedGVDie = createGlobalVariableDIE(ModuleCU, GV);
1321 SPDie->addChild(ScopedGVDie);
1328 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1329 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1330 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1331 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1332 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1334 // Ignore empty scopes.
1335 if (StartID == EndID && StartID != 0)
1338 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1339 if (Scope->isAbstractScope())
1342 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1344 DWLabel("label", StartID)
1345 : DWLabel("func_begin", SubprogramCount));
1346 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1348 DWLabel("label", EndID)
1349 : DWLabel("func_end", SubprogramCount));
1356 /// constructInlinedScopeDIE - This scope represents inlined body of
1357 /// a function. Construct DIE to represent this concrete inlined copy
1358 /// of the function.
1359 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1360 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1361 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1362 assert (StartID && "Invalid starting label for an inlined scope!");
1363 assert (EndID && "Invalid end label for an inlined scope!");
1364 // Ignore empty scopes.
1365 if (StartID == EndID && StartID != 0)
1368 DIScope DS(Scope->getScopeNode());
1371 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1373 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1374 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1375 assert (OriginDIE && "Unable to find Origin DIE!");
1376 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1377 dwarf::DW_FORM_ref4, OriginDIE);
1379 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1380 DWLabel("label", StartID));
1381 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1382 DWLabel("label", EndID));
1384 InlinedSubprogramDIEs.insert(OriginDIE);
1386 // Track the start label for this inlined function.
1387 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1388 I = InlineInfo.find(InlinedSP.getNode());
1390 if (I == InlineInfo.end()) {
1391 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1393 InlinedSPNodes.push_back(InlinedSP.getNode());
1395 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1397 StringPool.insert(InlinedSP.getName());
1398 StringPool.insert(InlinedSP.getLinkageName());
1399 DILocation DL(Scope->getInlinedAt());
1400 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1401 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1407 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1408 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV,
1409 DbgScope *Scope, CompileUnit *Unit) {
1410 // Get the descriptor.
1411 const DIVariable &VD = DV->getVariable();
1412 StringRef Name = VD.getName();
1416 // Translate tag to proper Dwarf tag. The result variable is dropped for
1419 switch (VD.getTag()) {
1420 case dwarf::DW_TAG_return_variable:
1422 case dwarf::DW_TAG_arg_variable:
1423 Tag = dwarf::DW_TAG_formal_parameter;
1425 case dwarf::DW_TAG_auto_variable: // fall thru
1427 Tag = dwarf::DW_TAG_variable;
1431 // Define variable debug information entry.
1432 DIE *VariableDie = new DIE(Tag);
1436 if (DbgVariable *AV = DV->getAbstractVariable())
1437 AbsDIE = AV->getDIE();
1440 DIScope DS(Scope->getScopeNode());
1441 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1442 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1444 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1445 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1446 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1447 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1448 dwarf::DW_FORM_ref4, AbsDIE);
1451 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1452 addSourceLine(VariableDie, &VD);
1454 // Add variable type.
1455 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1456 // addresses instead.
1457 if (VD.isBlockByrefVariable())
1458 addType(Unit, VariableDie, getBlockByrefType(VD.getType(), Name));
1460 addType(Unit, VariableDie, VD.getType());
1463 // Add variable address.
1464 if (!Scope->isAbstractScope()) {
1465 MachineLocation Location;
1467 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1468 Location.set(FrameReg, Offset);
1470 if (VD.hasComplexAddress())
1471 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1472 else if (VD.isBlockByrefVariable())
1473 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1475 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1477 DV->setDIE(VariableDie);
1482 void DwarfDebug::addPubTypes(DISubprogram SP) {
1483 DICompositeType SPTy = SP.getType();
1484 unsigned SPTag = SPTy.getTag();
1485 if (SPTag != dwarf::DW_TAG_subroutine_type)
1488 DIArray Args = SPTy.getTypeArray();
1492 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1493 DIType ATy(Args.getElement(i).getNode());
1496 DICompositeType CATy = getDICompositeType(ATy);
1497 if (!CATy.isNull() && !CATy.getName().empty()) {
1498 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1499 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1504 /// constructScopeDIE - Construct a DIE for this scope.
1505 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1508 DIScope DS(Scope->getScopeNode());
1512 DIE *ScopeDIE = NULL;
1513 if (Scope->getInlinedAt())
1514 ScopeDIE = constructInlinedScopeDIE(Scope);
1515 else if (DS.isSubprogram()) {
1516 if (Scope->isAbstractScope())
1517 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1519 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1522 ScopeDIE = constructLexicalScopeDIE(Scope);
1523 if (!ScopeDIE) return NULL;
1526 // Add variables to scope.
1527 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1528 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1529 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope, ModuleCU);
1531 ScopeDIE->addChild(VariableDIE);
1534 // Add nested scopes.
1535 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1536 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1537 // Define the Scope debug information entry.
1538 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1540 ScopeDIE->addChild(NestedDIE);
1543 if (DS.isSubprogram())
1544 addPubTypes(DISubprogram(DS.getNode()));
1549 /// GetOrCreateSourceID - Look up the source id with the given directory and
1550 /// source file names. If none currently exists, create a new id and insert it
1551 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1553 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1555 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1556 if (DI != DirectoryIdMap.end()) {
1557 DId = DI->getValue();
1559 DId = DirectoryNames.size() + 1;
1560 DirectoryIdMap[DirName] = DId;
1561 DirectoryNames.push_back(DirName);
1565 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1566 if (FI != SourceFileIdMap.end()) {
1567 FId = FI->getValue();
1569 FId = SourceFileNames.size() + 1;
1570 SourceFileIdMap[FileName] = FId;
1571 SourceFileNames.push_back(FileName);
1574 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1575 SourceIdMap.find(std::make_pair(DId, FId));
1576 if (SI != SourceIdMap.end())
1579 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1580 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1581 SourceIds.push_back(std::make_pair(DId, FId));
1586 void DwarfDebug::constructCompileUnit(MDNode *N) {
1587 DICompileUnit DIUnit(N);
1588 StringRef FN = DIUnit.getFilename();
1589 StringRef Dir = DIUnit.getDirectory();
1590 unsigned ID = GetOrCreateSourceID(Dir, FN);
1592 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1593 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1594 DWLabel("section_line", 0), DWLabel("section_line", 0),
1596 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1597 DIUnit.getProducer());
1598 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1599 DIUnit.getLanguage());
1600 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1603 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1604 if (DIUnit.isOptimized())
1605 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1607 StringRef Flags = DIUnit.getFlags();
1609 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1611 unsigned RVer = DIUnit.getRunTimeVersion();
1613 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1614 dwarf::DW_FORM_data1, RVer);
1616 CompileUnit *Unit = new CompileUnit(ID, Die);
1617 if (!ModuleCU && DIUnit.isMain()) {
1618 // Use first compile unit marked as isMain as the compile unit
1623 CompileUnitMap[DIUnit.getNode()] = Unit;
1624 CompileUnits.push_back(Unit);
1627 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1628 DIGlobalVariable DI_GV(N);
1630 // If debug information is malformed then ignore it.
1631 if (DI_GV.Verify() == false)
1634 // Check for pre-existence.
1635 if (ModuleCU->getDIE(DI_GV.getNode()))
1638 DIE *VariableDie = createGlobalVariableDIE(ModuleCU, DI_GV);
1641 ModuleCU->insertDIE(N, VariableDie);
1643 // Add to context owner.
1644 ModuleCU->getCUDie()->addChild(VariableDie);
1646 // Expose as global. FIXME - need to check external flag.
1647 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1649 DIType GTy = DI_GV.getType();
1650 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1651 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1652 assert (Entry && "Missing global type!");
1653 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1658 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1661 // Check for pre-existence.
1662 if (ModuleCU->getDIE(N))
1665 if (!SP.isDefinition())
1666 // This is a method declaration which will be handled while constructing
1670 DIE *SubprogramDie = createSubprogramDIE(ModuleCU, SP);
1673 ModuleCU->insertDIE(N, SubprogramDie);
1675 // Add to context owner.
1676 if (SP.getContext().getNode() == SP.getCompileUnit().getNode())
1677 ModuleCU->getCUDie()->addChild(SubprogramDie);
1679 // Expose as global.
1680 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1685 /// beginModule - Emit all Dwarf sections that should come prior to the
1686 /// content. Create global DIEs and emit initial debug info sections.
1687 /// This is inovked by the target AsmPrinter.
1688 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1691 if (TimePassesIsEnabled)
1692 DebugTimer->startTimer();
1694 if (!MAI->doesSupportDebugInformation())
1697 DebugInfoFinder DbgFinder;
1698 DbgFinder.processModule(*M);
1700 // Create all the compile unit DIEs.
1701 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1702 E = DbgFinder.compile_unit_end(); I != E; ++I)
1703 constructCompileUnit(*I);
1705 if (CompileUnits.empty()) {
1706 if (TimePassesIsEnabled)
1707 DebugTimer->stopTimer();
1712 // If main compile unit for this module is not seen than randomly
1713 // select first compile unit.
1715 ModuleCU = CompileUnits[0];
1717 // Create DIEs for each of the externally visible global variables.
1718 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1719 E = DbgFinder.global_variable_end(); I != E; ++I) {
1720 DIGlobalVariable GV(*I);
1721 if (GV.getContext().getNode() != GV.getCompileUnit().getNode())
1722 ScopedGVs.push_back(*I);
1724 constructGlobalVariableDIE(*I);
1727 // Create DIEs for each subprogram.
1728 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1729 E = DbgFinder.subprogram_end(); I != E; ++I)
1730 constructSubprogramDIE(*I);
1734 MMI->setDebugInfoAvailability(true);
1736 // Prime section data.
1737 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1739 // Print out .file directives to specify files for .loc directives. These are
1740 // printed out early so that they precede any .loc directives.
1741 if (MAI->hasDotLocAndDotFile()) {
1742 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1743 // Remember source id starts at 1.
1744 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1745 sys::Path FullPath(getSourceDirectoryName(Id.first));
1747 FullPath.appendComponent(getSourceFileName(Id.second));
1748 assert(AppendOk && "Could not append filename to directory!");
1750 Asm->EmitFile(i, FullPath.str());
1755 // Emit initial sections
1758 if (TimePassesIsEnabled)
1759 DebugTimer->stopTimer();
1762 /// endModule - Emit all Dwarf sections that should come after the content.
1764 void DwarfDebug::endModule() {
1768 if (TimePassesIsEnabled)
1769 DebugTimer->startTimer();
1771 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1772 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1773 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1775 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1778 // Standard sections final addresses.
1779 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1780 EmitLabel("text_end", 0);
1781 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1782 EmitLabel("data_end", 0);
1784 // End text sections.
1785 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1786 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1787 EmitLabel("section_end", i);
1790 // Emit common frame information.
1791 emitCommonDebugFrame();
1793 // Emit function debug frame information
1794 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1795 E = DebugFrames.end(); I != E; ++I)
1796 emitFunctionDebugFrame(*I);
1798 // Compute DIE offsets and sizes.
1799 computeSizeAndOffsets();
1801 // Emit all the DIEs into a debug info section
1804 // Corresponding abbreviations into a abbrev section.
1805 emitAbbreviations();
1807 // Emit source line correspondence into a debug line section.
1810 // Emit info into a debug pubnames section.
1811 emitDebugPubNames();
1813 // Emit info into a debug pubtypes section.
1814 emitDebugPubTypes();
1816 // Emit info into a debug str section.
1819 // Emit info into a debug loc section.
1822 // Emit info into a debug aranges section.
1825 // Emit info into a debug ranges section.
1828 // Emit info into a debug macinfo section.
1831 // Emit inline info.
1832 emitDebugInlineInfo();
1834 if (TimePassesIsEnabled)
1835 DebugTimer->stopTimer();
1838 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1839 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1841 DILocation &ScopeLoc) {
1843 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1845 return AbsDbgVariable;
1847 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1851 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1852 Scope->addVariable(AbsDbgVariable);
1853 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1854 return AbsDbgVariable;
1857 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1858 void DwarfDebug::collectVariableInfo() {
1861 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1862 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1863 VE = VMap.end(); VI != VE; ++VI) {
1864 MetadataBase *MB = VI->first;
1865 MDNode *Var = dyn_cast_or_null<MDNode>(MB);
1867 DIVariable DV (Var);
1868 std::pair< unsigned, MDNode *> VP = VI->second;
1869 DILocation ScopeLoc(VP.second);
1872 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1874 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1875 // If variable scope is not found then skip this variable.
1879 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1880 Scope->addVariable(RegVar);
1881 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1883 RegVar->setAbstractVariable(AbsDbgVariable);
1887 /// beginScope - Process beginning of a scope starting at Label.
1888 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1889 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1890 if (I == DbgScopeBeginMap.end())
1892 ScopeVector &SD = I->second;
1893 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1895 (*SDI)->setStartLabelID(Label);
1898 /// endScope - Process end of a scope.
1899 void DwarfDebug::endScope(const MachineInstr *MI) {
1900 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1901 if (I == DbgScopeEndMap.end())
1904 unsigned Label = MMI->NextLabelID();
1905 Asm->printLabel(Label);
1907 SmallVector<DbgScope *, 2> &SD = I->second;
1908 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1910 (*SDI)->setEndLabelID(Label);
1914 /// createDbgScope - Create DbgScope for the scope.
1915 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1918 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1921 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1922 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1923 if (DIDescriptor(Scope).isLexicalBlock())
1924 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1928 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1932 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1933 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1934 DILocation DL(InlinedAt);
1935 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1938 /// extractScopeInformation - Scan machine instructions in this function
1939 /// and collect DbgScopes. Return true, if atleast one scope was found.
1940 bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
1941 // If scope information was extracted using .dbg intrinsics then there is not
1942 // any need to extract these information by scanning each instruction.
1943 if (!DbgScopeMap.empty())
1946 // Scan each instruction and create scopes. First build working set of scopes.
1947 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1949 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1951 const MachineInstr *MInsn = II;
1952 DebugLoc DL = MInsn->getDebugLoc();
1953 if (DL.isUnknown()) continue;
1954 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
1955 if (!DLT.Scope) continue;
1956 // There is no need to create another DIE for compile unit. For all
1957 // other scopes, create one DbgScope now. This will be translated
1958 // into a scope DIE at the end.
1959 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
1960 createDbgScope(DLT.Scope, DLT.InlinedAtLoc);
1965 // Build scope hierarchy using working set of scopes.
1966 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1968 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1970 const MachineInstr *MInsn = II;
1971 DebugLoc DL = MInsn->getDebugLoc();
1972 if (DL.isUnknown()) continue;
1973 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
1974 if (!DLT.Scope) continue;
1975 // There is no need to create another DIE for compile unit. For all
1976 // other scopes, create one DbgScope now. This will be translated
1977 // into a scope DIE at the end.
1978 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
1979 DbgScope *Scope = getUpdatedDbgScope(DLT.Scope, MInsn, DLT.InlinedAtLoc);
1980 Scope->setLastInsn(MInsn);
1984 // If a scope's last instruction is not set then use its child scope's
1985 // last instruction as this scope's last instrunction.
1986 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
1987 DE = DbgScopeMap.end(); DI != DE; ++DI) {
1988 if (DI->second->isAbstractScope())
1990 assert (DI->second->getFirstInsn() && "Invalid first instruction!");
1991 DI->second->fixInstructionMarkers();
1992 assert (DI->second->getLastInsn() && "Invalid last instruction!");
1995 // Each scope has first instruction and last instruction to mark beginning
1996 // and end of a scope respectively. Create an inverse map that list scopes
1997 // starts (and ends) with an instruction. One instruction may start (or end)
1999 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
2000 DE = DbgScopeMap.end(); DI != DE; ++DI) {
2001 DbgScope *S = DI->second;
2002 if (S->isAbstractScope())
2004 const MachineInstr *MI = S->getFirstInsn();
2005 assert (MI && "DbgScope does not have first instruction!");
2007 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2008 if (IDI != DbgScopeBeginMap.end())
2009 IDI->second.push_back(S);
2011 DbgScopeBeginMap[MI].push_back(S);
2013 MI = S->getLastInsn();
2014 assert (MI && "DbgScope does not have last instruction!");
2015 IDI = DbgScopeEndMap.find(MI);
2016 if (IDI != DbgScopeEndMap.end())
2017 IDI->second.push_back(S);
2019 DbgScopeEndMap[MI].push_back(S);
2022 return !DbgScopeMap.empty();
2025 /// beginFunction - Gather pre-function debug information. Assumes being
2026 /// emitted immediately after the function entry point.
2027 void DwarfDebug::beginFunction(MachineFunction *MF) {
2030 if (!ShouldEmitDwarfDebug()) return;
2032 if (TimePassesIsEnabled)
2033 DebugTimer->startTimer();
2035 if (!extractScopeInformation(MF))
2038 collectVariableInfo();
2040 // Begin accumulating function debug information.
2041 MMI->BeginFunction(MF);
2043 // Assumes in correct section after the entry point.
2044 EmitLabel("func_begin", ++SubprogramCount);
2046 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2048 DebugLoc FDL = MF->getDefaultDebugLoc();
2049 if (!FDL.isUnknown()) {
2050 DebugLocTuple DLT = MF->getDebugLocTuple(FDL);
2051 unsigned LabelID = 0;
2052 DISubprogram SP = getDISubprogram(DLT.Scope);
2054 LabelID = recordSourceLine(SP.getLineNumber(), 0, DLT.Scope);
2056 LabelID = recordSourceLine(DLT.Line, DLT.Col, DLT.Scope);
2057 Asm->printLabel(LabelID);
2060 if (TimePassesIsEnabled)
2061 DebugTimer->stopTimer();
2064 /// endFunction - Gather and emit post-function debug information.
2066 void DwarfDebug::endFunction(MachineFunction *MF) {
2067 if (!ShouldEmitDwarfDebug()) return;
2069 if (TimePassesIsEnabled)
2070 DebugTimer->startTimer();
2072 if (DbgScopeMap.empty())
2075 // Define end label for subprogram.
2076 EmitLabel("func_end", SubprogramCount);
2078 // Get function line info.
2079 if (!Lines.empty()) {
2080 // Get section line info.
2081 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2082 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2083 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2084 // Append the function info to section info.
2085 SectionLineInfos.insert(SectionLineInfos.end(),
2086 Lines.begin(), Lines.end());
2089 // Construct abstract scopes.
2090 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2091 AE = AbstractScopesList.end(); AI != AE; ++AI)
2092 constructScopeDIE(*AI);
2094 constructScopeDIE(CurrentFnDbgScope);
2096 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2097 MMI->getFrameMoves()));
2100 CurrentFnDbgScope = NULL;
2101 DbgScopeMap.clear();
2102 DbgScopeBeginMap.clear();
2103 DbgScopeEndMap.clear();
2104 ConcreteScopes.clear();
2105 AbstractScopesList.clear();
2109 if (TimePassesIsEnabled)
2110 DebugTimer->stopTimer();
2113 /// recordSourceLine - Records location information and associates it with a
2114 /// label. Returns a unique label ID used to generate a label and provide
2115 /// correspondence to the source line list.
2116 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2121 if (TimePassesIsEnabled)
2122 DebugTimer->startTimer();
2127 DIDescriptor Scope(S);
2128 if (Scope.isCompileUnit()) {
2129 DICompileUnit CU(S);
2130 Dir = CU.getDirectory();
2131 Fn = CU.getFilename();
2132 } else if (Scope.isSubprogram()) {
2134 Dir = SP.getDirectory();
2135 Fn = SP.getFilename();
2136 } else if (Scope.isLexicalBlock()) {
2137 DILexicalBlock DB(S);
2138 Dir = DB.getDirectory();
2139 Fn = DB.getFilename();
2141 assert (0 && "Unexpected scope info");
2143 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2144 unsigned ID = MMI->NextLabelID();
2145 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2147 if (TimePassesIsEnabled)
2148 DebugTimer->stopTimer();
2153 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2154 /// timed. Look up the source id with the given directory and source file
2155 /// names. If none currently exists, create a new id and insert it in the
2156 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2158 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2159 const std::string &FileName) {
2160 if (TimePassesIsEnabled)
2161 DebugTimer->startTimer();
2163 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2165 if (TimePassesIsEnabled)
2166 DebugTimer->stopTimer();
2171 //===----------------------------------------------------------------------===//
2173 //===----------------------------------------------------------------------===//
2175 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2178 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2179 // Get the children.
2180 const std::vector<DIE *> &Children = Die->getChildren();
2182 // If not last sibling and has children then add sibling offset attribute.
2183 if (!Last && !Children.empty()) Die->addSiblingOffset();
2185 // Record the abbreviation.
2186 assignAbbrevNumber(Die->getAbbrev());
2188 // Get the abbreviation for this DIE.
2189 unsigned AbbrevNumber = Die->getAbbrevNumber();
2190 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2193 Die->setOffset(Offset);
2195 // Start the size with the size of abbreviation code.
2196 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2198 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2199 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2201 // Size the DIE attribute values.
2202 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2203 // Size attribute value.
2204 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2206 // Size the DIE children if any.
2207 if (!Children.empty()) {
2208 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2209 "Children flag not set");
2211 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2212 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2214 // End of children marker.
2215 Offset += sizeof(int8_t);
2218 Die->setSize(Offset - Die->getOffset());
2222 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2224 void DwarfDebug::computeSizeAndOffsets() {
2225 // Compute size of compile unit header.
2226 static unsigned Offset =
2227 sizeof(int32_t) + // Length of Compilation Unit Info
2228 sizeof(int16_t) + // DWARF version number
2229 sizeof(int32_t) + // Offset Into Abbrev. Section
2230 sizeof(int8_t); // Pointer Size (in bytes)
2232 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2233 CompileUnitOffsets[ModuleCU] = 0;
2236 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2237 /// tools to recognize the object file contains Dwarf information.
2238 void DwarfDebug::emitInitial() {
2239 // Check to see if we already emitted intial headers.
2240 if (didInitial) return;
2243 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2245 // Dwarf sections base addresses.
2246 if (MAI->doesDwarfRequireFrameSection()) {
2247 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2248 EmitLabel("section_debug_frame", 0);
2251 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2252 EmitLabel("section_info", 0);
2253 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2254 EmitLabel("section_abbrev", 0);
2255 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2256 EmitLabel("section_aranges", 0);
2258 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2259 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2260 EmitLabel("section_macinfo", 0);
2263 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2264 EmitLabel("section_line", 0);
2265 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2266 EmitLabel("section_loc", 0);
2267 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2268 EmitLabel("section_pubnames", 0);
2269 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2270 EmitLabel("section_pubtypes", 0);
2271 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2272 EmitLabel("section_str", 0);
2273 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2274 EmitLabel("section_ranges", 0);
2276 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2277 EmitLabel("text_begin", 0);
2278 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2279 EmitLabel("data_begin", 0);
2282 /// emitDIE - Recusively Emits a debug information entry.
2284 void DwarfDebug::emitDIE(DIE *Die) {
2285 // Get the abbreviation for this DIE.
2286 unsigned AbbrevNumber = Die->getAbbrevNumber();
2287 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2291 // Emit the code (index) for the abbreviation.
2292 Asm->EmitULEB128Bytes(AbbrevNumber);
2294 if (Asm->isVerbose())
2295 Asm->EOL(std::string("Abbrev [" +
2296 utostr(AbbrevNumber) +
2297 "] 0x" + utohexstr(Die->getOffset()) +
2298 ":0x" + utohexstr(Die->getSize()) + " " +
2299 dwarf::TagString(Abbrev->getTag())));
2303 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2304 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2306 // Emit the DIE attribute values.
2307 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2308 unsigned Attr = AbbrevData[i].getAttribute();
2309 unsigned Form = AbbrevData[i].getForm();
2310 assert(Form && "Too many attributes for DIE (check abbreviation)");
2313 case dwarf::DW_AT_sibling:
2314 Asm->EmitInt32(Die->getSiblingOffset());
2316 case dwarf::DW_AT_abstract_origin: {
2317 DIEEntry *E = cast<DIEEntry>(Values[i]);
2318 DIE *Origin = E->getEntry();
2319 unsigned Addr = Origin->getOffset();
2320 Asm->EmitInt32(Addr);
2324 // Emit an attribute using the defined form.
2325 Values[i]->EmitValue(this, Form);
2329 Asm->EOL(dwarf::AttributeString(Attr));
2332 // Emit the DIE children if any.
2333 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2334 const std::vector<DIE *> &Children = Die->getChildren();
2336 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2337 emitDIE(Children[j]);
2339 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2343 /// emitDebugInfo / emitDebugInfoPerCU - Emit the debug info section.
2345 void DwarfDebug::emitDebugInfoPerCU(CompileUnit *Unit) {
2346 DIE *Die = Unit->getCUDie();
2348 // Emit the compile units header.
2349 EmitLabel("info_begin", Unit->getID());
2351 // Emit size of content not including length itself
2352 unsigned ContentSize = Die->getSize() +
2353 sizeof(int16_t) + // DWARF version number
2354 sizeof(int32_t) + // Offset Into Abbrev. Section
2355 sizeof(int8_t) + // Pointer Size (in bytes)
2356 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2358 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
2359 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2360 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2361 Asm->EOL("Offset Into Abbrev. Section");
2362 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2365 // FIXME - extra padding for gdb bug.
2366 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2367 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2368 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2369 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2370 EmitLabel("info_end", Unit->getID());
2375 void DwarfDebug::emitDebugInfo() {
2376 // Start debug info section.
2377 Asm->OutStreamer.SwitchSection(
2378 Asm->getObjFileLowering().getDwarfInfoSection());
2380 emitDebugInfoPerCU(ModuleCU);
2383 /// emitAbbreviations - Emit the abbreviation section.
2385 void DwarfDebug::emitAbbreviations() const {
2386 // Check to see if it is worth the effort.
2387 if (!Abbreviations.empty()) {
2388 // Start the debug abbrev section.
2389 Asm->OutStreamer.SwitchSection(
2390 Asm->getObjFileLowering().getDwarfAbbrevSection());
2392 EmitLabel("abbrev_begin", 0);
2394 // For each abbrevation.
2395 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2396 // Get abbreviation data
2397 const DIEAbbrev *Abbrev = Abbreviations[i];
2399 // Emit the abbrevations code (base 1 index.)
2400 Asm->EmitULEB128Bytes(Abbrev->getNumber());
2401 Asm->EOL("Abbreviation Code");
2403 // Emit the abbreviations data.
2409 // Mark end of abbreviations.
2410 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2412 EmitLabel("abbrev_end", 0);
2417 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2418 /// the line matrix.
2420 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2421 // Define last address of section.
2422 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2423 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2424 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2425 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2427 // Mark end of matrix.
2428 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2429 Asm->EmitULEB128Bytes(1); Asm->EOL();
2430 Asm->EmitInt8(1); Asm->EOL();
2433 /// emitDebugLines - Emit source line information.
2435 void DwarfDebug::emitDebugLines() {
2436 // If the target is using .loc/.file, the assembler will be emitting the
2437 // .debug_line table automatically.
2438 if (MAI->hasDotLocAndDotFile())
2441 // Minimum line delta, thus ranging from -10..(255-10).
2442 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2443 // Maximum line delta, thus ranging from -10..(255-10).
2444 const int MaxLineDelta = 255 + MinLineDelta;
2446 // Start the dwarf line section.
2447 Asm->OutStreamer.SwitchSection(
2448 Asm->getObjFileLowering().getDwarfLineSection());
2450 // Construct the section header.
2451 EmitDifference("line_end", 0, "line_begin", 0, true);
2452 Asm->EOL("Length of Source Line Info");
2453 EmitLabel("line_begin", 0);
2455 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2457 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2458 Asm->EOL("Prolog Length");
2459 EmitLabel("line_prolog_begin", 0);
2461 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2463 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2465 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2467 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2469 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2471 // Line number standard opcode encodings argument count
2472 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2473 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2474 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2475 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2476 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2477 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2478 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2479 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2480 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2482 // Emit directories.
2483 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2484 Asm->EmitString(getSourceDirectoryName(DI));
2485 Asm->EOL("Directory");
2488 Asm->EmitInt8(0); Asm->EOL("End of directories");
2491 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2492 // Remember source id starts at 1.
2493 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2494 Asm->EmitString(getSourceFileName(Id.second));
2496 Asm->EmitULEB128Bytes(Id.first);
2497 Asm->EOL("Directory #");
2498 Asm->EmitULEB128Bytes(0);
2499 Asm->EOL("Mod date");
2500 Asm->EmitULEB128Bytes(0);
2501 Asm->EOL("File size");
2504 Asm->EmitInt8(0); Asm->EOL("End of files");
2506 EmitLabel("line_prolog_end", 0);
2508 // A sequence for each text section.
2509 unsigned SecSrcLinesSize = SectionSourceLines.size();
2511 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2512 // Isolate current sections line info.
2513 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2515 /*if (Asm->isVerbose()) {
2516 const MCSection *S = SectionMap[j + 1];
2517 O << '\t' << MAI->getCommentString() << " Section"
2518 << S->getName() << '\n';
2522 // Dwarf assumes we start with first line of first source file.
2523 unsigned Source = 1;
2526 // Construct rows of the address, source, line, column matrix.
2527 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2528 const SrcLineInfo &LineInfo = LineInfos[i];
2529 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2530 if (!LabelID) continue;
2532 if (LineInfo.getLine() == 0) continue;
2534 if (!Asm->isVerbose())
2537 std::pair<unsigned, unsigned> SourceID =
2538 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2539 O << '\t' << MAI->getCommentString() << ' '
2540 << getSourceDirectoryName(SourceID.first) << ' '
2541 << getSourceFileName(SourceID.second)
2542 <<" :" << utostr_32(LineInfo.getLine()) << '\n';
2545 // Define the line address.
2546 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2547 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2548 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2549 EmitReference("label", LabelID); Asm->EOL("Location label");
2551 // If change of source, then switch to the new source.
2552 if (Source != LineInfo.getSourceID()) {
2553 Source = LineInfo.getSourceID();
2554 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2555 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2558 // If change of line.
2559 if (Line != LineInfo.getLine()) {
2560 // Determine offset.
2561 int Offset = LineInfo.getLine() - Line;
2562 int Delta = Offset - MinLineDelta;
2565 Line = LineInfo.getLine();
2567 // If delta is small enough and in range...
2568 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2569 // ... then use fast opcode.
2570 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2572 // ... otherwise use long hand.
2573 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2574 Asm->EOL("DW_LNS_advance_line");
2575 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2576 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2579 // Copy the previous row (different address or source)
2580 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2584 emitEndOfLineMatrix(j + 1);
2587 if (SecSrcLinesSize == 0)
2588 // Because we're emitting a debug_line section, we still need a line
2589 // table. The linker and friends expect it to exist. If there's nothing to
2590 // put into it, emit an empty table.
2591 emitEndOfLineMatrix(1);
2593 EmitLabel("line_end", 0);
2597 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2599 void DwarfDebug::emitCommonDebugFrame() {
2600 if (!MAI->doesDwarfRequireFrameSection())
2604 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2605 TargetFrameInfo::StackGrowsUp ?
2606 TD->getPointerSize() : -TD->getPointerSize();
2608 // Start the dwarf frame section.
2609 Asm->OutStreamer.SwitchSection(
2610 Asm->getObjFileLowering().getDwarfFrameSection());
2612 EmitLabel("debug_frame_common", 0);
2613 EmitDifference("debug_frame_common_end", 0,
2614 "debug_frame_common_begin", 0, true);
2615 Asm->EOL("Length of Common Information Entry");
2617 EmitLabel("debug_frame_common_begin", 0);
2618 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2619 Asm->EOL("CIE Identifier Tag");
2620 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2621 Asm->EOL("CIE Version");
2622 Asm->EmitString("");
2623 Asm->EOL("CIE Augmentation");
2624 Asm->EmitULEB128Bytes(1);
2625 Asm->EOL("CIE Code Alignment Factor");
2626 Asm->EmitSLEB128Bytes(stackGrowth);
2627 Asm->EOL("CIE Data Alignment Factor");
2628 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2629 Asm->EOL("CIE RA Column");
2631 std::vector<MachineMove> Moves;
2632 RI->getInitialFrameState(Moves);
2634 EmitFrameMoves(NULL, 0, Moves, false);
2636 Asm->EmitAlignment(2, 0, 0, false);
2637 EmitLabel("debug_frame_common_end", 0);
2642 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2645 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2646 if (!MAI->doesDwarfRequireFrameSection())
2649 // Start the dwarf frame section.
2650 Asm->OutStreamer.SwitchSection(
2651 Asm->getObjFileLowering().getDwarfFrameSection());
2653 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2654 "debug_frame_begin", DebugFrameInfo.Number, true);
2655 Asm->EOL("Length of Frame Information Entry");
2657 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2659 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2661 Asm->EOL("FDE CIE offset");
2663 EmitReference("func_begin", DebugFrameInfo.Number);
2664 Asm->EOL("FDE initial location");
2665 EmitDifference("func_end", DebugFrameInfo.Number,
2666 "func_begin", DebugFrameInfo.Number);
2667 Asm->EOL("FDE address range");
2669 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2672 Asm->EmitAlignment(2, 0, 0, false);
2673 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2678 void DwarfDebug::emitDebugPubNamesPerCU(CompileUnit *Unit) {
2679 EmitDifference("pubnames_end", Unit->getID(),
2680 "pubnames_begin", Unit->getID(), true);
2681 Asm->EOL("Length of Public Names Info");
2683 EmitLabel("pubnames_begin", Unit->getID());
2685 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2687 EmitSectionOffset("info_begin", "section_info",
2688 Unit->getID(), 0, true, false);
2689 Asm->EOL("Offset of Compilation Unit Info");
2691 EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(),
2693 Asm->EOL("Compilation Unit Length");
2695 const StringMap<DIE*> &Globals = Unit->getGlobals();
2696 for (StringMap<DIE*>::const_iterator
2697 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2698 const char *Name = GI->getKeyData();
2699 DIE * Entity = GI->second;
2701 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2702 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2705 Asm->EmitInt32(0); Asm->EOL("End Mark");
2706 EmitLabel("pubnames_end", Unit->getID());
2711 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2713 void DwarfDebug::emitDebugPubNames() {
2714 // Start the dwarf pubnames section.
2715 Asm->OutStreamer.SwitchSection(
2716 Asm->getObjFileLowering().getDwarfPubNamesSection());
2718 emitDebugPubNamesPerCU(ModuleCU);
2721 void DwarfDebug::emitDebugPubTypes() {
2722 // Start the dwarf pubnames section.
2723 Asm->OutStreamer.SwitchSection(
2724 Asm->getObjFileLowering().getDwarfPubTypesSection());
2725 EmitDifference("pubtypes_end", ModuleCU->getID(),
2726 "pubtypes_begin", ModuleCU->getID(), true);
2727 Asm->EOL("Length of Public Types Info");
2729 EmitLabel("pubtypes_begin", ModuleCU->getID());
2731 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2733 EmitSectionOffset("info_begin", "section_info",
2734 ModuleCU->getID(), 0, true, false);
2735 Asm->EOL("Offset of Compilation ModuleCU Info");
2737 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2739 Asm->EOL("Compilation ModuleCU Length");
2741 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2742 for (StringMap<DIE*>::const_iterator
2743 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2744 const char *Name = GI->getKeyData();
2745 DIE * Entity = GI->second;
2747 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2748 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2751 Asm->EmitInt32(0); Asm->EOL("End Mark");
2752 EmitLabel("pubtypes_end", ModuleCU->getID());
2757 /// emitDebugStr - Emit visible names into a debug str section.
2759 void DwarfDebug::emitDebugStr() {
2760 // Check to see if it is worth the effort.
2761 if (!StringPool.empty()) {
2762 // Start the dwarf str section.
2763 Asm->OutStreamer.SwitchSection(
2764 Asm->getObjFileLowering().getDwarfStrSection());
2766 // For each of strings in the string pool.
2767 for (unsigned StringID = 1, N = StringPool.size();
2768 StringID <= N; ++StringID) {
2769 // Emit a label for reference from debug information entries.
2770 EmitLabel("string", StringID);
2772 // Emit the string itself.
2773 const std::string &String = StringPool[StringID];
2774 Asm->EmitString(String); Asm->EOL();
2781 /// emitDebugLoc - Emit visible names into a debug loc section.
2783 void DwarfDebug::emitDebugLoc() {
2784 // Start the dwarf loc section.
2785 Asm->OutStreamer.SwitchSection(
2786 Asm->getObjFileLowering().getDwarfLocSection());
2790 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2792 void DwarfDebug::EmitDebugARanges() {
2793 // Start the dwarf aranges section.
2794 Asm->OutStreamer.SwitchSection(
2795 Asm->getObjFileLowering().getDwarfARangesSection());
2799 CompileUnit *Unit = GetBaseCompileUnit();
2801 // Don't include size of length
2802 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
2804 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2806 EmitReference("info_begin", Unit->getID());
2807 Asm->EOL("Offset of Compilation Unit Info");
2809 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2811 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2813 Asm->EmitInt16(0); Asm->EOL("Pad (1)");
2814 Asm->EmitInt16(0); Asm->EOL("Pad (2)");
2817 EmitReference("text_begin", 0); Asm->EOL("Address");
2818 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2820 Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2821 Asm->EmitInt32(0); Asm->EOL("EOM (2)");
2827 /// emitDebugRanges - Emit visible names into a debug ranges section.
2829 void DwarfDebug::emitDebugRanges() {
2830 // Start the dwarf ranges section.
2831 Asm->OutStreamer.SwitchSection(
2832 Asm->getObjFileLowering().getDwarfRangesSection());
2836 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2838 void DwarfDebug::emitDebugMacInfo() {
2839 if (const MCSection *LineInfo =
2840 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2841 // Start the dwarf macinfo section.
2842 Asm->OutStreamer.SwitchSection(LineInfo);
2847 /// emitDebugInlineInfo - Emit inline info using following format.
2849 /// 1. length of section
2850 /// 2. Dwarf version number
2851 /// 3. address size.
2853 /// Entries (one "entry" for each function that was inlined):
2855 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2856 /// otherwise offset into __debug_str for regular function name.
2857 /// 2. offset into __debug_str section for regular function name.
2858 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2859 /// instances for the function.
2861 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2862 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2863 /// __debug_info section, and the low_pc is the starting address for the
2864 /// inlining instance.
2865 void DwarfDebug::emitDebugInlineInfo() {
2866 if (!MAI->doesDwarfUsesInlineInfoSection())
2872 Asm->OutStreamer.SwitchSection(
2873 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2875 EmitDifference("debug_inlined_end", 1,
2876 "debug_inlined_begin", 1, true);
2877 Asm->EOL("Length of Debug Inlined Information Entry");
2879 EmitLabel("debug_inlined_begin", 1);
2881 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2882 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2884 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2885 E = InlinedSPNodes.end(); I != E; ++I) {
2887 // for (ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
2888 // I = InlineInfo.begin(), E = InlineInfo.end(); I != E; ++I) {
2890 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2891 = InlineInfo.find(Node);
2892 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2893 DISubprogram SP(Node);
2894 StringRef LName = SP.getLinkageName();
2895 StringRef Name = SP.getName();
2898 Asm->EmitString(Name);
2900 // Skip special LLVM prefix that is used to inform the asm printer to not
2901 // emit usual symbol prefix before the symbol name. This happens for
2902 // Objective-C symbol names and symbol whose name is replaced using GCC's
2903 // __asm__ attribute.
2905 LName = LName.substr(1);
2906 // Asm->EmitString(LName);
2907 EmitSectionOffset("string", "section_str",
2908 StringPool.idFor(LName), false, true);
2911 Asm->EOL("MIPS linkage name");
2912 // Asm->EmitString(Name);
2913 EmitSectionOffset("string", "section_str",
2914 StringPool.idFor(Name), false, true);
2915 Asm->EOL("Function name");
2916 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2918 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2919 LE = Labels.end(); LI != LE; ++LI) {
2920 DIE *SP = LI->second;
2921 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2923 if (TD->getPointerSize() == sizeof(int32_t))
2924 O << MAI->getData32bitsDirective();
2926 O << MAI->getData64bitsDirective();
2928 PrintLabelName("label", LI->first); Asm->EOL("low_pc");
2932 EmitLabel("debug_inlined_end", 1);