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;
76 CompileUnit(unsigned I, DIE *D)
77 : ID(I), CUDie(D), IndexTyDie(0) {}
78 ~CompileUnit() { delete CUDie; delete IndexTyDie; }
81 unsigned getID() const { return ID; }
82 DIE* getCUDie() const { return CUDie; }
83 StringMap<DIE*> &getGlobals() { return Globals; }
85 /// hasContent - Return true if this compile unit has something to write out.
87 bool hasContent() const { return !CUDie->getChildren().empty(); }
89 /// addGlobal - Add a new global entity to the compile unit.
91 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
93 /// getDIE - Returns the debug information entry map slot for the
94 /// specified debug variable.
95 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
97 /// insertDIE - Insert DIE into the map.
98 void insertDIE(MDNode *N, DIE *D) {
99 GVToDieMap.insert(std::make_pair(N, D));
102 /// getDIEEntry - Returns the debug information entry for the speciefied
104 DIEEntry *getDIEEntry(MDNode *N) { return GVToDIEEntryMap.lookup(N); }
106 /// insertDIEEntry - Insert debug information entry into the map.
107 void insertDIEEntry(MDNode *N, DIEEntry *E) {
108 GVToDIEEntryMap.insert(std::make_pair(N, E));
111 /// addDie - Adds or interns the DIE to the compile unit.
113 void addDie(DIE *Buffer) {
114 this->CUDie->addChild(Buffer);
117 // getIndexTyDie - Get an anonymous type for index type.
118 DIE *getIndexTyDie() {
122 // setIndexTyDie - Set D as anonymous type for index which can be reused
124 void setIndexTyDie(DIE *D) {
130 //===----------------------------------------------------------------------===//
131 /// DbgVariable - This class is used to track local variable information.
134 DIVariable Var; // Variable Descriptor.
135 unsigned FrameIndex; // Variable frame index.
136 DbgVariable *AbstractVar; // Abstract variable for this variable.
139 DbgVariable(DIVariable V, unsigned I)
140 : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0) {}
143 DIVariable getVariable() const { return Var; }
144 unsigned getFrameIndex() const { return FrameIndex; }
145 void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
146 DbgVariable *getAbstractVariable() const { return AbstractVar; }
147 void setDIE(DIE *D) { TheDIE = D; }
148 DIE *getDIE() const { return TheDIE; }
151 //===----------------------------------------------------------------------===//
152 /// DbgScope - This class is used to track scope information.
155 DbgScope *Parent; // Parent to this scope.
156 DIDescriptor Desc; // Debug info descriptor for scope.
157 WeakVH InlinedAtLocation; // Location at which scope is inlined.
158 bool AbstractScope; // Abstract Scope
159 unsigned StartLabelID; // Label ID of the beginning of scope.
160 unsigned EndLabelID; // Label ID of the end of scope.
161 const MachineInstr *LastInsn; // Last instruction of this scope.
162 const MachineInstr *FirstInsn; // First instruction of this scope.
163 SmallVector<DbgScope *, 4> Scopes; // Scopes defined in scope.
164 SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
166 // Private state for dump()
167 mutable unsigned IndentLevel;
169 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
170 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
171 StartLabelID(0), EndLabelID(0),
172 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
176 DbgScope *getParent() const { return Parent; }
177 void setParent(DbgScope *P) { Parent = P; }
178 DIDescriptor getDesc() const { return Desc; }
179 MDNode *getInlinedAt() const {
180 return dyn_cast_or_null<MDNode>(InlinedAtLocation);
182 MDNode *getScopeNode() const { return Desc.getNode(); }
183 unsigned getStartLabelID() const { return StartLabelID; }
184 unsigned getEndLabelID() const { return EndLabelID; }
185 SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
186 SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
187 void setStartLabelID(unsigned S) { StartLabelID = S; }
188 void setEndLabelID(unsigned E) { EndLabelID = E; }
189 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
190 const MachineInstr *getLastInsn() { return LastInsn; }
191 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
192 void setAbstractScope() { AbstractScope = true; }
193 bool isAbstractScope() const { return AbstractScope; }
194 const MachineInstr *getFirstInsn() { return FirstInsn; }
196 /// addScope - Add a scope to the scope.
198 void addScope(DbgScope *S) { Scopes.push_back(S); }
200 /// addVariable - Add a variable to the scope.
202 void addVariable(DbgVariable *V) { Variables.push_back(V); }
204 void fixInstructionMarkers() {
205 assert (getFirstInsn() && "First instruction is missing!");
209 // If a scope does not have an instruction to mark an end then use
210 // the end of last child scope.
211 SmallVector<DbgScope *, 4> &Scopes = getScopes();
212 assert (!Scopes.empty() && "Inner most scope does not have last insn!");
213 DbgScope *L = Scopes.back();
214 if (!L->getLastInsn())
215 L->fixInstructionMarkers();
216 setLastInsn(L->getLastInsn());
225 void DbgScope::dump() const {
226 raw_ostream &err = errs();
227 err.indent(IndentLevel);
228 MDNode *N = Desc.getNode();
230 err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
232 err << "Abstract Scope\n";
236 err << "Children ...\n";
237 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
238 if (Scopes[i] != this)
245 DbgScope::~DbgScope() {
246 for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
248 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
252 } // end llvm namespace
254 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
255 : Dwarf(OS, A, T, "dbg"), ModuleCU(0),
256 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
257 DIEValues(), StringPool(),
258 SectionSourceLines(), didInitial(false), shouldEmit(false),
259 CurrentFnDbgScope(0), DebugTimer(0) {
260 if (TimePassesIsEnabled)
261 DebugTimer = new Timer("Dwarf Debug Writer",
262 getDwarfTimerGroup());
264 DwarfDebug::~DwarfDebug() {
265 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
271 /// assignAbbrevNumber - Define a unique number for the abbreviation.
273 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
274 // Profile the node so that we can make it unique.
278 // Check the set for priors.
279 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
281 // If it's newly added.
282 if (InSet == &Abbrev) {
283 // Add to abbreviation list.
284 Abbreviations.push_back(&Abbrev);
286 // Assign the vector position + 1 as its number.
287 Abbrev.setNumber(Abbreviations.size());
289 // Assign existing abbreviation number.
290 Abbrev.setNumber(InSet->getNumber());
294 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
295 /// information entry.
296 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
297 DIEEntry *Value = new DIEEntry(Entry);
298 DIEValues.push_back(Value);
302 /// addUInt - Add an unsigned integer attribute data and value.
304 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
305 unsigned Form, uint64_t Integer) {
306 if (!Form) Form = DIEInteger::BestForm(false, Integer);
307 DIEValue *Value = new DIEInteger(Integer);
308 DIEValues.push_back(Value);
309 Die->addValue(Attribute, Form, Value);
312 /// addSInt - Add an signed integer attribute data and value.
314 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
315 unsigned Form, int64_t Integer) {
316 if (!Form) Form = DIEInteger::BestForm(true, Integer);
317 DIEValue *Value = new DIEInteger(Integer);
318 DIEValues.push_back(Value);
319 Die->addValue(Attribute, Form, Value);
322 /// addString - Add a string attribute data and value.
324 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
325 const std::string &String) {
326 DIEValue *Value = new DIEString(String);
327 DIEValues.push_back(Value);
328 Die->addValue(Attribute, Form, Value);
331 /// addLabel - Add a Dwarf label attribute data and value.
333 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
334 const DWLabel &Label) {
335 DIEValue *Value = new DIEDwarfLabel(Label);
336 DIEValues.push_back(Value);
337 Die->addValue(Attribute, Form, Value);
340 /// addObjectLabel - Add an non-Dwarf label attribute data and value.
342 void DwarfDebug::addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
343 const std::string &Label) {
344 DIEValue *Value = new DIEObjectLabel(Label);
345 DIEValues.push_back(Value);
346 Die->addValue(Attribute, Form, Value);
349 /// addSectionOffset - Add a section offset label attribute data and value.
351 void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
352 const DWLabel &Label, const DWLabel &Section,
353 bool isEH, bool useSet) {
354 DIEValue *Value = new DIESectionOffset(Label, Section, isEH, useSet);
355 DIEValues.push_back(Value);
356 Die->addValue(Attribute, Form, Value);
359 /// addDelta - Add a label delta attribute data and value.
361 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
362 const DWLabel &Hi, const DWLabel &Lo) {
363 DIEValue *Value = new DIEDelta(Hi, Lo);
364 DIEValues.push_back(Value);
365 Die->addValue(Attribute, Form, Value);
368 /// addBlock - Add block data.
370 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
372 Block->ComputeSize(TD);
373 DIEValues.push_back(Block);
374 Die->addValue(Attribute, Block->BestForm(), Block);
377 /// addSourceLine - Add location information to specified debug information
379 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
380 // If there is no compile unit specified, don't add a line #.
381 if (V->getCompileUnit().isNull())
384 unsigned Line = V->getLineNumber();
385 unsigned FileID = findCompileUnit(V->getCompileUnit()).getID();
386 assert(FileID && "Invalid file id");
387 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
388 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
391 /// addSourceLine - Add location information to specified debug information
393 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
394 // If there is no compile unit specified, don't add a line #.
395 if (G->getCompileUnit().isNull())
398 unsigned Line = G->getLineNumber();
399 unsigned FileID = findCompileUnit(G->getCompileUnit()).getID();
400 assert(FileID && "Invalid file id");
401 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
402 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
405 /// addSourceLine - Add location information to specified debug information
407 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
408 // If there is no compile unit specified, don't add a line #.
409 if (SP->getCompileUnit().isNull())
411 // If the line number is 0, don't add it.
412 if (SP->getLineNumber() == 0)
416 unsigned Line = SP->getLineNumber();
417 unsigned FileID = findCompileUnit(SP->getCompileUnit()).getID();
418 assert(FileID && "Invalid file id");
419 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
420 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
423 /// addSourceLine - Add location information to specified debug information
425 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
426 // If there is no compile unit specified, don't add a line #.
427 DICompileUnit CU = Ty->getCompileUnit();
431 unsigned Line = Ty->getLineNumber();
432 unsigned FileID = findCompileUnit(CU).getID();
433 assert(FileID && "Invalid file id");
434 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
435 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
438 /* Byref variables, in Blocks, are declared by the programmer as
439 "SomeType VarName;", but the compiler creates a
440 __Block_byref_x_VarName struct, and gives the variable VarName
441 either the struct, or a pointer to the struct, as its type. This
442 is necessary for various behind-the-scenes things the compiler
443 needs to do with by-reference variables in blocks.
445 However, as far as the original *programmer* is concerned, the
446 variable should still have type 'SomeType', as originally declared.
448 The following function dives into the __Block_byref_x_VarName
449 struct to find the original type of the variable. This will be
450 passed back to the code generating the type for the Debug
451 Information Entry for the variable 'VarName'. 'VarName' will then
452 have the original type 'SomeType' in its debug information.
454 The original type 'SomeType' will be the type of the field named
455 'VarName' inside the __Block_byref_x_VarName struct.
457 NOTE: In order for this to not completely fail on the debugger
458 side, the Debug Information Entry for the variable VarName needs to
459 have a DW_AT_location that tells the debugger how to unwind through
460 the pointers and __Block_byref_x_VarName struct to find the actual
461 value of the variable. The function addBlockByrefType does this. */
463 /// Find the type the programmer originally declared the variable to be
464 /// and return that type.
466 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
469 unsigned tag = Ty.getTag();
471 if (tag == dwarf::DW_TAG_pointer_type) {
472 DIDerivedType DTy = DIDerivedType(Ty.getNode());
473 subType = DTy.getTypeDerivedFrom();
476 DICompositeType blockStruct = DICompositeType(subType.getNode());
478 DIArray Elements = blockStruct.getTypeArray();
480 if (Elements.isNull())
483 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
484 DIDescriptor Element = Elements.getElement(i);
485 DIDerivedType DT = DIDerivedType(Element.getNode());
486 if (strcmp(Name.c_str(), DT.getName()) == 0)
487 return (DT.getTypeDerivedFrom());
493 /// addComplexAddress - Start with the address based on the location provided,
494 /// and generate the DWARF information necessary to find the actual variable
495 /// given the extra address information encoded in the DIVariable, starting from
496 /// the starting location. Add the DWARF information to the die.
498 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
500 const MachineLocation &Location) {
501 const DIVariable &VD = DV->getVariable();
502 DIType Ty = VD.getType();
504 // Decode the original location, and use that as the start of the byref
505 // variable's location.
506 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
507 DIEBlock *Block = new DIEBlock();
509 if (Location.isReg()) {
511 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
513 Reg = Reg - dwarf::DW_OP_reg0;
514 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
515 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
519 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
521 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
522 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
525 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
528 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
529 uint64_t Element = VD.getAddrElement(i);
531 if (Element == DIFactory::OpPlus) {
532 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
533 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
534 } else if (Element == DIFactory::OpDeref) {
535 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
536 } else llvm_unreachable("unknown DIFactory Opcode");
539 // Now attach the location information to the DIE.
540 addBlock(Die, Attribute, 0, Block);
543 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
544 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
545 gives the variable VarName either the struct, or a pointer to the struct, as
546 its type. This is necessary for various behind-the-scenes things the
547 compiler needs to do with by-reference variables in Blocks.
549 However, as far as the original *programmer* is concerned, the variable
550 should still have type 'SomeType', as originally declared.
552 The function getBlockByrefType dives into the __Block_byref_x_VarName
553 struct to find the original type of the variable, which is then assigned to
554 the variable's Debug Information Entry as its real type. So far, so good.
555 However now the debugger will expect the variable VarName to have the type
556 SomeType. So we need the location attribute for the variable to be an
557 expression that explains to the debugger how to navigate through the
558 pointers and struct to find the actual variable of type SomeType.
560 The following function does just that. We start by getting
561 the "normal" location for the variable. This will be the location
562 of either the struct __Block_byref_x_VarName or the pointer to the
563 struct __Block_byref_x_VarName.
565 The struct will look something like:
567 struct __Block_byref_x_VarName {
569 struct __Block_byref_x_VarName *forwarding;
570 ... <various other fields>
572 ... <maybe more fields>
575 If we are given the struct directly (as our starting point) we
576 need to tell the debugger to:
578 1). Add the offset of the forwarding field.
580 2). Follow that pointer to get the the real __Block_byref_x_VarName
581 struct to use (the real one may have been copied onto the heap).
583 3). Add the offset for the field VarName, to find the actual variable.
585 If we started with a pointer to the struct, then we need to
586 dereference that pointer first, before the other steps.
587 Translating this into DWARF ops, we will need to append the following
588 to the current location description for the variable:
590 DW_OP_deref -- optional, if we start with a pointer
591 DW_OP_plus_uconst <forward_fld_offset>
593 DW_OP_plus_uconst <varName_fld_offset>
595 That is what this function does. */
597 /// addBlockByrefAddress - Start with the address based on the location
598 /// provided, and generate the DWARF information necessary to find the
599 /// actual Block variable (navigating the Block struct) based on the
600 /// starting location. Add the DWARF information to the die. For
601 /// more information, read large comment just above here.
603 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
605 const MachineLocation &Location) {
606 const DIVariable &VD = DV->getVariable();
607 DIType Ty = VD.getType();
609 unsigned Tag = Ty.getTag();
610 bool isPointer = false;
612 const char *varName = VD.getName();
614 if (Tag == dwarf::DW_TAG_pointer_type) {
615 DIDerivedType DTy = DIDerivedType(Ty.getNode());
616 TmpTy = DTy.getTypeDerivedFrom();
620 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
622 // Find the __forwarding field and the variable field in the __Block_byref
624 DIArray Fields = blockStruct.getTypeArray();
625 DIDescriptor varField = DIDescriptor();
626 DIDescriptor forwardingField = DIDescriptor();
629 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
630 DIDescriptor Element = Fields.getElement(i);
631 DIDerivedType DT = DIDerivedType(Element.getNode());
632 const char *fieldName = DT.getName();
633 if (strcmp(fieldName, "__forwarding") == 0)
634 forwardingField = Element;
635 else if (strcmp(fieldName, varName) == 0)
639 assert(!varField.isNull() && "Can't find byref variable in Block struct");
640 assert(!forwardingField.isNull()
641 && "Can't find forwarding field in Block struct");
643 // Get the offsets for the forwarding field and the variable field.
644 unsigned int forwardingFieldOffset =
645 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
646 unsigned int varFieldOffset =
647 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
649 // Decode the original location, and use that as the start of the byref
650 // variable's location.
651 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
652 DIEBlock *Block = new DIEBlock();
654 if (Location.isReg()) {
656 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
658 Reg = Reg - dwarf::DW_OP_reg0;
659 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
660 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
664 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
666 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
667 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
670 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
673 // If we started with a pointer to the __Block_byref... struct, then
674 // the first thing we need to do is dereference the pointer (DW_OP_deref).
676 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
678 // Next add the offset for the '__forwarding' field:
679 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
680 // adding the offset if it's 0.
681 if (forwardingFieldOffset > 0) {
682 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
683 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
686 // Now dereference the __forwarding field to get to the real __Block_byref
687 // struct: DW_OP_deref.
688 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
690 // Now that we've got the real __Block_byref... struct, add the offset
691 // for the variable's field to get to the location of the actual variable:
692 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
693 if (varFieldOffset > 0) {
694 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
695 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
698 // Now attach the location information to the DIE.
699 addBlock(Die, Attribute, 0, Block);
702 /// addAddress - Add an address attribute to a die based on the location
704 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
705 const MachineLocation &Location) {
706 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
707 DIEBlock *Block = new DIEBlock();
709 if (Location.isReg()) {
711 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
713 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
714 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
718 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
720 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
721 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
724 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
727 addBlock(Die, Attribute, 0, Block);
730 /// addType - Add a new type attribute to the specified entity.
731 void DwarfDebug::addType(CompileUnit *DW_Unit, DIE *Entity, DIType Ty) {
735 // Check for pre-existence.
736 DIEEntry *Entry = DW_Unit->getDIEEntry(Ty.getNode());
738 // If it exists then use the existing value.
740 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
745 Entry = createDIEEntry();
746 DW_Unit->insertDIEEntry(Ty.getNode(), Entry);
749 DIE *Buffer = new DIE(dwarf::DW_TAG_base_type);
750 if (Ty.isBasicType())
751 constructTypeDIE(DW_Unit, *Buffer, DIBasicType(Ty.getNode()));
752 else if (Ty.isCompositeType())
753 constructTypeDIE(DW_Unit, *Buffer, DICompositeType(Ty.getNode()));
755 assert(Ty.isDerivedType() && "Unknown kind of DIType");
756 constructTypeDIE(DW_Unit, *Buffer, DIDerivedType(Ty.getNode()));
759 // Add debug information entry to entity and appropriate context.
761 DIDescriptor Context = Ty.getContext();
762 if (!Context.isNull())
763 Die = DW_Unit->getDIE(Context.getNode());
766 Die->addChild(Buffer);
768 DW_Unit->addDie(Buffer);
769 Entry->setEntry(Buffer);
770 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
773 /// constructTypeDIE - Construct basic type die from DIBasicType.
774 void DwarfDebug::constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
776 // Get core information.
777 const char *Name = BTy.getName();
778 Buffer.setTag(dwarf::DW_TAG_base_type);
779 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
782 // Add name if not anonymous or intermediate type.
784 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
785 uint64_t Size = BTy.getSizeInBits() >> 3;
786 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
789 /// constructTypeDIE - Construct derived type die from DIDerivedType.
790 void DwarfDebug::constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
792 // Get core information.
793 const char *Name = DTy.getName();
794 uint64_t Size = DTy.getSizeInBits() >> 3;
795 unsigned Tag = DTy.getTag();
797 // FIXME - Workaround for templates.
798 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
802 // Map to main type, void will not have a type.
803 DIType FromTy = DTy.getTypeDerivedFrom();
804 addType(DW_Unit, &Buffer, FromTy);
806 // Add name if not anonymous or intermediate type.
807 if (Name && Tag != dwarf::DW_TAG_pointer_type)
808 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
810 // Add size if non-zero (derived types might be zero-sized.)
812 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
814 // Add source line info if available and TyDesc is not a forward declaration.
815 if (!DTy.isForwardDecl() && Tag != dwarf::DW_TAG_pointer_type)
816 addSourceLine(&Buffer, &DTy);
819 /// constructTypeDIE - Construct type DIE from DICompositeType.
820 void DwarfDebug::constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
821 DICompositeType CTy) {
822 // Get core information.
823 const char *Name = CTy.getName();
825 uint64_t Size = CTy.getSizeInBits() >> 3;
826 unsigned Tag = CTy.getTag();
830 case dwarf::DW_TAG_vector_type:
831 case dwarf::DW_TAG_array_type:
832 constructArrayTypeDIE(DW_Unit, Buffer, &CTy);
834 case dwarf::DW_TAG_enumeration_type: {
835 DIArray Elements = CTy.getTypeArray();
837 // Add enumerators to enumeration type.
838 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
840 DIEnumerator Enum(Elements.getElement(i).getNode());
841 if (!Enum.isNull()) {
842 ElemDie = constructEnumTypeDIE(DW_Unit, &Enum);
843 Buffer.addChild(ElemDie);
848 case dwarf::DW_TAG_subroutine_type: {
850 DIArray Elements = CTy.getTypeArray();
851 DIDescriptor RTy = Elements.getElement(0);
852 addType(DW_Unit, &Buffer, DIType(RTy.getNode()));
854 // Add prototype flag.
855 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
858 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
859 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
860 DIDescriptor Ty = Elements.getElement(i);
861 addType(DW_Unit, Arg, DIType(Ty.getNode()));
862 Buffer.addChild(Arg);
866 case dwarf::DW_TAG_structure_type:
867 case dwarf::DW_TAG_union_type:
868 case dwarf::DW_TAG_class_type: {
869 // Add elements to structure type.
870 DIArray Elements = CTy.getTypeArray();
872 // A forward struct declared type may not have elements available.
873 if (Elements.isNull())
876 // Add elements to structure type.
877 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
878 DIDescriptor Element = Elements.getElement(i);
879 if (Element.isNull())
882 if (Element.getTag() == dwarf::DW_TAG_subprogram)
883 ElemDie = createSubprogramDIE(DW_Unit,
884 DISubprogram(Element.getNode()));
886 ElemDie = createMemberDIE(DW_Unit,
887 DIDerivedType(Element.getNode()));
888 Buffer.addChild(ElemDie);
891 if (CTy.isAppleBlockExtension())
892 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
894 unsigned RLang = CTy.getRunTimeLang();
896 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
897 dwarf::DW_FORM_data1, RLang);
904 // Add name if not anonymous or intermediate type.
906 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
908 if (Tag == dwarf::DW_TAG_enumeration_type ||
909 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
910 // Add size if non-zero (derived types might be zero-sized.)
912 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
914 // Add zero size if it is not a forward declaration.
915 if (CTy.isForwardDecl())
916 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
918 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
921 // Add source line info if available.
922 if (!CTy.isForwardDecl())
923 addSourceLine(&Buffer, &CTy);
927 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
928 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
929 int64_t L = SR.getLo();
930 int64_t H = SR.getHi();
931 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
933 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
935 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
937 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
939 Buffer.addChild(DW_Subrange);
942 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
943 void DwarfDebug::constructArrayTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
944 DICompositeType *CTy) {
945 Buffer.setTag(dwarf::DW_TAG_array_type);
946 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
947 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
949 // Emit derived type.
950 addType(DW_Unit, &Buffer, CTy->getTypeDerivedFrom());
951 DIArray Elements = CTy->getTypeArray();
953 // Get an anonymous type for index type.
954 DIE *IdxTy = DW_Unit->getIndexTyDie();
956 // Construct an anonymous type for index type.
957 IdxTy = new DIE(dwarf::DW_TAG_base_type);
958 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
959 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
960 dwarf::DW_ATE_signed);
961 DW_Unit->addDie(IdxTy);
962 DW_Unit->setIndexTyDie(IdxTy);
965 // Add subranges to array type.
966 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
967 DIDescriptor Element = Elements.getElement(i);
968 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
969 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
973 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
974 DIE *DwarfDebug::constructEnumTypeDIE(CompileUnit *DW_Unit, DIEnumerator *ETy) {
975 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
976 const char *Name = ETy->getName();
977 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
978 int64_t Value = ETy->getEnumValue();
979 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
983 /// createGlobalVariableDIE - Create new DIE using GV.
984 DIE *DwarfDebug::createGlobalVariableDIE(CompileUnit *DW_Unit,
985 const DIGlobalVariable &GV) {
986 // If the global variable was optmized out then no need to create debug info
988 if (!GV.getGlobal()) return NULL;
989 if (!GV.getDisplayName()) return NULL;
991 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
992 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
993 GV.getDisplayName());
995 const char *LinkageName = GV.getLinkageName();
997 // Skip special LLVM prefix that is used to inform the asm printer to not
998 // emit usual symbol prefix before the symbol name. This happens for
999 // Objective-C symbol names and symbol whose name is replaced using GCC's
1000 // __asm__ attribute.
1001 if (LinkageName[0] == 1)
1002 LinkageName = &LinkageName[1];
1003 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1006 addType(DW_Unit, GVDie, GV.getType());
1007 if (!GV.isLocalToUnit())
1008 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1009 addSourceLine(GVDie, &GV);
1012 DIEBlock *Block = new DIEBlock();
1013 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1014 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1015 Asm->Mang->getMangledName(GV.getGlobal()));
1016 addBlock(GVDie, dwarf::DW_AT_location, 0, Block);
1021 /// createMemberDIE - Create new member DIE.
1022 DIE *DwarfDebug::createMemberDIE(CompileUnit *DW_Unit, const DIDerivedType &DT){
1023 DIE *MemberDie = new DIE(DT.getTag());
1024 if (const char *Name = DT.getName())
1025 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1027 addType(DW_Unit, MemberDie, DT.getTypeDerivedFrom());
1029 addSourceLine(MemberDie, &DT);
1031 DIEBlock *MemLocationDie = new DIEBlock();
1032 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1034 uint64_t Size = DT.getSizeInBits();
1035 uint64_t FieldSize = DT.getOriginalTypeSize();
1037 if (Size != FieldSize) {
1039 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1040 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1042 uint64_t Offset = DT.getOffsetInBits();
1043 uint64_t FieldOffset = Offset;
1044 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1045 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1046 FieldOffset = (HiMark - FieldSize);
1047 Offset -= FieldOffset;
1049 // Maybe we need to work from the other end.
1050 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1051 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1053 // Here WD_AT_data_member_location points to the anonymous
1054 // field that includes this bit field.
1055 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1058 // This is not a bitfield.
1059 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1061 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1063 if (DT.isProtected())
1064 addUInt(MemberDie, dwarf::DW_AT_accessibility, 0,
1065 dwarf::DW_ACCESS_protected);
1066 else if (DT.isPrivate())
1067 addUInt(MemberDie, dwarf::DW_AT_accessibility, 0,
1068 dwarf::DW_ACCESS_private);
1073 /// createSubprogramDIE - Create new DIE using SP.
1074 DIE *DwarfDebug::createSubprogramDIE(CompileUnit *DW_Unit,
1075 const DISubprogram &SP,
1078 DIE *SPDie = new DIE(dwarf::DW_TAG_subprogram);
1080 const char * Name = SP.getName();
1081 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1083 const char *LinkageName = SP.getLinkageName();
1085 // Skip special LLVM prefix that is used to inform the asm printer to not
1086 // emit usual symbol prefix before the symbol name. This happens for
1087 // Objective-C symbol names and symbol whose name is replaced using GCC's
1088 // __asm__ attribute.
1089 if (LinkageName[0] == 1)
1090 LinkageName = &LinkageName[1];
1091 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1094 addSourceLine(SPDie, &SP);
1096 DICompositeType SPTy = SP.getType();
1097 DIArray Args = SPTy.getTypeArray();
1099 // Add prototyped tag, if C or ObjC.
1100 unsigned Lang = SP.getCompileUnit().getLanguage();
1101 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1102 Lang == dwarf::DW_LANG_ObjC)
1103 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1106 unsigned SPTag = SPTy.getTag();
1107 if (!IsConstructor) {
1108 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1109 addType(DW_Unit, SPDie, SPTy);
1111 addType(DW_Unit, SPDie, DIType(Args.getElement(0).getNode()));
1114 if (!SP.isDefinition()) {
1115 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1117 // Add arguments. Do not add arguments for subprogram definition. They will
1118 // be handled through RecordVariable.
1119 if (SPTag == dwarf::DW_TAG_subroutine_type)
1120 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1121 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1122 addType(DW_Unit, Arg, DIType(Args.getElement(i).getNode()));
1123 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1124 SPDie->addChild(Arg);
1128 // DW_TAG_inlined_subroutine may refer to this DIE.
1129 DW_Unit->insertDIE(SP.getNode(), SPDie);
1133 /// findCompileUnit - Get the compile unit for the given descriptor.
1135 CompileUnit &DwarfDebug::findCompileUnit(DICompileUnit Unit) const {
1136 DenseMap<Value *, CompileUnit *>::const_iterator I =
1137 CompileUnitMap.find(Unit.getNode());
1138 assert(I != CompileUnitMap.end() && "Missing compile unit.");
1142 /// createDbgScopeVariable - Create a new scope variable.
1144 DIE *DwarfDebug::createDbgScopeVariable(DbgVariable *DV, CompileUnit *Unit) {
1145 // Get the descriptor.
1146 const DIVariable &VD = DV->getVariable();
1147 const char *Name = VD.getName();
1151 // Translate tag to proper Dwarf tag. The result variable is dropped for
1154 switch (VD.getTag()) {
1155 case dwarf::DW_TAG_return_variable:
1157 case dwarf::DW_TAG_arg_variable:
1158 Tag = dwarf::DW_TAG_formal_parameter;
1160 case dwarf::DW_TAG_auto_variable: // fall thru
1162 Tag = dwarf::DW_TAG_variable;
1166 // Define variable debug information entry.
1167 DIE *VariableDie = new DIE(Tag);
1168 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1170 // Add source line info if available.
1171 addSourceLine(VariableDie, &VD);
1173 // Add variable type.
1174 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1175 // addresses instead.
1176 if (VD.isBlockByrefVariable())
1177 addType(Unit, VariableDie, getBlockByrefType(VD.getType(), Name));
1179 addType(Unit, VariableDie, VD.getType());
1181 // Add variable address.
1182 // Variables for abstract instances of inlined functions don't get a
1184 MachineLocation Location;
1185 Location.set(RI->getFrameRegister(*MF),
1186 RI->getFrameIndexOffset(*MF, DV->getFrameIndex()));
1189 if (VD.hasComplexAddress())
1190 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1191 else if (VD.isBlockByrefVariable())
1192 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1194 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1199 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1200 /// Initialize scope and update scope hierarchy.
1201 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1202 MDNode *InlinedAt) {
1203 assert (N && "Invalid Scope encoding!");
1204 assert (MI && "Missing machine instruction!");
1205 bool GetConcreteScope = (MI && InlinedAt);
1207 DbgScope *NScope = NULL;
1210 NScope = DbgScopeMap.lookup(InlinedAt);
1212 NScope = DbgScopeMap.lookup(N);
1213 assert (NScope && "Unable to find working scope!");
1215 if (NScope->getFirstInsn())
1218 DbgScope *Parent = NULL;
1219 if (GetConcreteScope) {
1220 DILocation IL(InlinedAt);
1221 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1222 IL.getOrigLocation().getNode());
1223 assert (Parent && "Unable to find Parent scope!");
1224 NScope->setParent(Parent);
1225 Parent->addScope(NScope);
1226 } else if (DIDescriptor(N).isLexicalBlock()) {
1227 DILexicalBlock DB(N);
1228 if (!DB.getContext().isNull()) {
1229 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1230 NScope->setParent(Parent);
1231 Parent->addScope(NScope);
1235 NScope->setFirstInsn(MI);
1237 if (!Parent && !InlinedAt) {
1238 StringRef SPName = DISubprogram(N).getLinkageName();
1239 if (SPName == MF->getFunction()->getName())
1240 CurrentFnDbgScope = NScope;
1243 if (GetConcreteScope) {
1244 ConcreteScopes[InlinedAt] = NScope;
1245 getOrCreateAbstractScope(N);
1251 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1252 assert (N && "Invalid Scope encoding!");
1254 DbgScope *AScope = AbstractScopes.lookup(N);
1258 DbgScope *Parent = NULL;
1260 DIDescriptor Scope(N);
1261 if (Scope.isLexicalBlock()) {
1262 DILexicalBlock DB(N);
1263 DIDescriptor ParentDesc = DB.getContext();
1264 if (!ParentDesc.isNull())
1265 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1268 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1271 Parent->addScope(AScope);
1272 AScope->setAbstractScope();
1273 AbstractScopes[N] = AScope;
1274 if (DIDescriptor(N).isSubprogram())
1275 AbstractScopesList.push_back(AScope);
1279 static DISubprogram getDISubprogram(MDNode *N) {
1283 return DISubprogram();
1285 if (D.isCompileUnit())
1286 return DISubprogram();
1288 if (D.isSubprogram())
1289 return DISubprogram(N);
1291 if (D.isLexicalBlock())
1292 return getDISubprogram(DILexicalBlock(N).getContext().getNode());
1294 llvm_unreachable("Unexpected Descriptor!");
1297 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1298 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1299 /// If there are global variables in this scope then create and insert
1300 /// DIEs for these variables.
1301 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1303 DIE *SPDie = ModuleCU->getDIE(SPNode);
1304 assert (SPDie && "Unable to find subprogram DIE!");
1305 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1306 DWLabel("func_begin", SubprogramCount));
1307 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1308 DWLabel("func_end", SubprogramCount));
1309 MachineLocation Location(RI->getFrameRegister(*MF));
1310 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1312 if (!DISubprogram(SPNode).isLocalToUnit())
1313 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1315 // If there are global variables at this scope then add their dies.
1316 for (SmallVector<WeakVH, 4>::iterator SGI = ScopedGVs.begin(),
1317 SGE = ScopedGVs.end(); SGI != SGE; ++SGI) {
1318 MDNode *N = dyn_cast_or_null<MDNode>(*SGI);
1320 DIGlobalVariable GV(N);
1321 if (GV.getContext().getNode() == SPNode) {
1322 DIE *ScopedGVDie = createGlobalVariableDIE(ModuleCU, GV);
1324 SPDie->addChild(ScopedGVDie);
1330 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1331 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1332 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1333 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1334 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1336 // Ignore empty scopes.
1337 if (StartID == EndID && StartID != 0)
1340 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1341 if (Scope->isAbstractScope())
1344 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1346 DWLabel("label", StartID)
1347 : DWLabel("func_begin", SubprogramCount));
1348 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1350 DWLabel("label", EndID)
1351 : DWLabel("func_end", SubprogramCount));
1358 /// constructInlinedScopeDIE - This scope represents inlined body of
1359 /// a function. Construct DIE to represent this concrete inlined copy
1360 /// of the function.
1361 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1362 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1363 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1364 assert (StartID && "Invalid starting label for an inlined scope!");
1365 assert (EndID && "Invalid end label for an inlined scope!");
1366 // Ignore empty scopes.
1367 if (StartID == EndID && StartID != 0)
1370 DIScope DS(Scope->getScopeNode());
1373 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1375 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1376 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1377 assert (OriginDIE && "Unable to find Origin DIE!");
1378 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1379 dwarf::DW_FORM_ref4, OriginDIE);
1381 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1382 DWLabel("label", StartID));
1383 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1384 DWLabel("label", EndID));
1386 InlinedSubprogramDIEs.insert(OriginDIE);
1388 // Track the start label for this inlined function.
1389 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1390 I = InlineInfo.find(InlinedSP.getNode());
1392 if (I == InlineInfo.end()) {
1393 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1395 InlinedSPNodes.push_back(InlinedSP.getNode());
1397 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1399 StringPool.insert(InlinedSP.getName());
1400 StringPool.insert(InlinedSP.getLinkageName());
1401 DILocation DL(Scope->getInlinedAt());
1402 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1403 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1409 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1410 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV,
1411 DbgScope *Scope, CompileUnit *Unit) {
1412 // Get the descriptor.
1413 const DIVariable &VD = DV->getVariable();
1414 const char *Name = VD.getName();
1418 // Translate tag to proper Dwarf tag. The result variable is dropped for
1421 switch (VD.getTag()) {
1422 case dwarf::DW_TAG_return_variable:
1424 case dwarf::DW_TAG_arg_variable:
1425 Tag = dwarf::DW_TAG_formal_parameter;
1427 case dwarf::DW_TAG_auto_variable: // fall thru
1429 Tag = dwarf::DW_TAG_variable;
1433 // Define variable debug information entry.
1434 DIE *VariableDie = new DIE(Tag);
1438 if (DbgVariable *AV = DV->getAbstractVariable())
1439 AbsDIE = AV->getDIE();
1442 DIScope DS(Scope->getScopeNode());
1443 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1444 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1446 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1447 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1448 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1449 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1450 dwarf::DW_FORM_ref4, AbsDIE);
1453 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1454 addSourceLine(VariableDie, &VD);
1456 // Add variable type.
1457 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1458 // addresses instead.
1459 if (VD.isBlockByrefVariable())
1460 addType(Unit, VariableDie, getBlockByrefType(VD.getType(), Name));
1462 addType(Unit, VariableDie, VD.getType());
1465 // Add variable address.
1466 if (!Scope->isAbstractScope()) {
1467 MachineLocation Location;
1468 Location.set(RI->getFrameRegister(*MF),
1469 RI->getFrameIndexOffset(*MF, DV->getFrameIndex()));
1472 if (VD.hasComplexAddress())
1473 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1474 else if (VD.isBlockByrefVariable())
1475 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1477 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1479 DV->setDIE(VariableDie);
1484 /// constructScopeDIE - Construct a DIE for this scope.
1485 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1488 DIScope DS(Scope->getScopeNode());
1492 DIE *ScopeDIE = NULL;
1493 if (Scope->getInlinedAt())
1494 ScopeDIE = constructInlinedScopeDIE(Scope);
1495 else if (DS.isSubprogram()) {
1496 if (Scope->isAbstractScope())
1497 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1499 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1502 ScopeDIE = constructLexicalScopeDIE(Scope);
1503 if (!ScopeDIE) return NULL;
1506 // Add variables to scope.
1507 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1508 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1509 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope, ModuleCU);
1511 ScopeDIE->addChild(VariableDIE);
1514 // Add nested scopes.
1515 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1516 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1517 // Define the Scope debug information entry.
1518 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1520 ScopeDIE->addChild(NestedDIE);
1525 /// GetOrCreateSourceID - Look up the source id with the given directory and
1526 /// source file names. If none currently exists, create a new id and insert it
1527 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1529 unsigned DwarfDebug::GetOrCreateSourceID(const char *DirName,
1530 const char *FileName) {
1532 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1533 if (DI != DirectoryIdMap.end()) {
1534 DId = DI->getValue();
1536 DId = DirectoryNames.size() + 1;
1537 DirectoryIdMap[DirName] = DId;
1538 DirectoryNames.push_back(DirName);
1542 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1543 if (FI != SourceFileIdMap.end()) {
1544 FId = FI->getValue();
1546 FId = SourceFileNames.size() + 1;
1547 SourceFileIdMap[FileName] = FId;
1548 SourceFileNames.push_back(FileName);
1551 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1552 SourceIdMap.find(std::make_pair(DId, FId));
1553 if (SI != SourceIdMap.end())
1556 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1557 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1558 SourceIds.push_back(std::make_pair(DId, FId));
1563 void DwarfDebug::constructCompileUnit(MDNode *N) {
1564 DICompileUnit DIUnit(N);
1565 const char *FN = DIUnit.getFilename();
1566 const char *Dir = DIUnit.getDirectory();
1567 unsigned ID = GetOrCreateSourceID(Dir, FN);
1569 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1570 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1571 DWLabel("section_line", 0), DWLabel("section_line", 0),
1573 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1574 DIUnit.getProducer());
1575 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1576 DIUnit.getLanguage());
1577 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1580 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1581 if (DIUnit.isOptimized())
1582 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1584 if (const char *Flags = DIUnit.getFlags())
1585 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1587 unsigned RVer = DIUnit.getRunTimeVersion();
1589 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1590 dwarf::DW_FORM_data1, RVer);
1592 CompileUnit *Unit = new CompileUnit(ID, Die);
1593 if (!ModuleCU && DIUnit.isMain()) {
1594 // Use first compile unit marked as isMain as the compile unit
1599 CompileUnitMap[DIUnit.getNode()] = Unit;
1600 CompileUnits.push_back(Unit);
1603 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1604 DIGlobalVariable DI_GV(N);
1606 // If debug information is malformed then ignore it.
1607 if (DI_GV.Verify() == false)
1610 // Check for pre-existence.
1611 if (ModuleCU->getDIE(DI_GV.getNode()))
1614 DIE *VariableDie = createGlobalVariableDIE(ModuleCU, DI_GV);
1617 ModuleCU->insertDIE(N, VariableDie);
1619 // Add to context owner.
1620 ModuleCU->getCUDie()->addChild(VariableDie);
1622 // Expose as global. FIXME - need to check external flag.
1623 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1627 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1630 // Check for pre-existence.
1631 if (ModuleCU->getDIE(N))
1634 if (!SP.isDefinition())
1635 // This is a method declaration which will be handled while constructing
1639 DIE *SubprogramDie = createSubprogramDIE(ModuleCU, SP);
1642 ModuleCU->insertDIE(N, SubprogramDie);
1644 // Add to context owner.
1645 ModuleCU->getCUDie()->addChild(SubprogramDie);
1647 // Expose as global.
1648 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1652 /// beginModule - Emit all Dwarf sections that should come prior to the
1653 /// content. Create global DIEs and emit initial debug info sections.
1654 /// This is inovked by the target AsmPrinter.
1655 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1658 if (TimePassesIsEnabled)
1659 DebugTimer->startTimer();
1661 if (!MAI->doesSupportDebugInformation())
1664 DebugInfoFinder DbgFinder;
1665 DbgFinder.processModule(*M);
1667 // Create all the compile unit DIEs.
1668 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1669 E = DbgFinder.compile_unit_end(); I != E; ++I)
1670 constructCompileUnit(*I);
1672 if (CompileUnits.empty()) {
1673 if (TimePassesIsEnabled)
1674 DebugTimer->stopTimer();
1679 // If main compile unit for this module is not seen than randomly
1680 // select first compile unit.
1682 ModuleCU = CompileUnits[0];
1684 // Create DIEs for each of the externally visible global variables.
1685 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1686 E = DbgFinder.global_variable_end(); I != E; ++I) {
1687 DIGlobalVariable GV(*I);
1688 if (GV.getContext().getNode() != GV.getCompileUnit().getNode())
1689 ScopedGVs.push_back(*I);
1691 constructGlobalVariableDIE(*I);
1694 // Create DIEs for each subprogram.
1695 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1696 E = DbgFinder.subprogram_end(); I != E; ++I)
1697 constructSubprogramDIE(*I);
1701 MMI->setDebugInfoAvailability(true);
1703 // Prime section data.
1704 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1706 // Print out .file directives to specify files for .loc directives. These are
1707 // printed out early so that they precede any .loc directives.
1708 if (MAI->hasDotLocAndDotFile()) {
1709 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1710 // Remember source id starts at 1.
1711 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1712 sys::Path FullPath(getSourceDirectoryName(Id.first));
1714 FullPath.appendComponent(getSourceFileName(Id.second));
1715 assert(AppendOk && "Could not append filename to directory!");
1717 Asm->EmitFile(i, FullPath.str());
1722 // Emit initial sections
1725 if (TimePassesIsEnabled)
1726 DebugTimer->stopTimer();
1729 /// endModule - Emit all Dwarf sections that should come after the content.
1731 void DwarfDebug::endModule() {
1735 if (TimePassesIsEnabled)
1736 DebugTimer->startTimer();
1738 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1739 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1740 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1742 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1745 // Standard sections final addresses.
1746 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1747 EmitLabel("text_end", 0);
1748 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1749 EmitLabel("data_end", 0);
1751 // End text sections.
1752 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1753 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1754 EmitLabel("section_end", i);
1757 // Emit common frame information.
1758 emitCommonDebugFrame();
1760 // Emit function debug frame information
1761 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1762 E = DebugFrames.end(); I != E; ++I)
1763 emitFunctionDebugFrame(*I);
1765 // Compute DIE offsets and sizes.
1766 computeSizeAndOffsets();
1768 // Emit all the DIEs into a debug info section
1771 // Corresponding abbreviations into a abbrev section.
1772 emitAbbreviations();
1774 // Emit source line correspondence into a debug line section.
1777 // Emit info into a debug pubnames section.
1778 emitDebugPubNames();
1780 // Emit info into a debug str section.
1783 // Emit info into a debug loc section.
1786 // Emit info into a debug aranges section.
1789 // Emit info into a debug ranges section.
1792 // Emit info into a debug macinfo section.
1795 // Emit inline info.
1796 emitDebugInlineInfo();
1798 if (TimePassesIsEnabled)
1799 DebugTimer->stopTimer();
1802 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1803 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1805 DILocation &ScopeLoc) {
1807 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1809 return AbsDbgVariable;
1811 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1815 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1816 Scope->addVariable(AbsDbgVariable);
1817 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1818 return AbsDbgVariable;
1821 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1822 void DwarfDebug::collectVariableInfo() {
1825 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1826 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1827 VE = VMap.end(); VI != VE; ++VI) {
1828 MetadataBase *MB = VI->first;
1829 MDNode *Var = dyn_cast_or_null<MDNode>(MB);
1831 DIVariable DV (Var);
1832 std::pair< unsigned, MDNode *> VP = VI->second;
1833 DILocation ScopeLoc(VP.second);
1836 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1838 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1839 // If variable scope is not found then skip this variable.
1843 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1844 Scope->addVariable(RegVar);
1845 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1847 RegVar->setAbstractVariable(AbsDbgVariable);
1851 /// beginScope - Process beginning of a scope starting at Label.
1852 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1853 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1854 if (I == DbgScopeBeginMap.end())
1856 ScopeVector &SD = DbgScopeBeginMap[MI];
1857 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1859 (*SDI)->setStartLabelID(Label);
1862 /// endScope - Process end of a scope.
1863 void DwarfDebug::endScope(const MachineInstr *MI) {
1864 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1865 if (I == DbgScopeEndMap.end())
1868 unsigned Label = MMI->NextLabelID();
1869 Asm->printLabel(Label);
1871 SmallVector<DbgScope *, 2> &SD = I->second;
1872 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1874 (*SDI)->setEndLabelID(Label);
1878 /// createDbgScope - Create DbgScope for the scope.
1879 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1882 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1885 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1886 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1887 if (DIDescriptor(Scope).isLexicalBlock())
1888 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1892 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1896 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1897 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1898 DILocation DL(InlinedAt);
1899 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1902 /// extractScopeInformation - Scan machine instructions in this function
1903 /// and collect DbgScopes. Return true, if atleast one scope was found.
1904 bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
1905 // If scope information was extracted using .dbg intrinsics then there is not
1906 // any need to extract these information by scanning each instruction.
1907 if (!DbgScopeMap.empty())
1910 // Scan each instruction and create scopes. First build working set of scopes.
1911 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1913 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1915 const MachineInstr *MInsn = II;
1916 DebugLoc DL = MInsn->getDebugLoc();
1917 if (DL.isUnknown()) continue;
1918 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
1919 if (!DLT.Scope) continue;
1920 // There is no need to create another DIE for compile unit. For all
1921 // other scopes, create one DbgScope now. This will be translated
1922 // into a scope DIE at the end.
1923 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
1924 createDbgScope(DLT.Scope, DLT.InlinedAtLoc);
1929 // Build scope hierarchy using working set of scopes.
1930 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1932 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1934 const MachineInstr *MInsn = II;
1935 DebugLoc DL = MInsn->getDebugLoc();
1936 if (DL.isUnknown()) continue;
1937 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
1938 if (!DLT.Scope) continue;
1939 // There is no need to create another DIE for compile unit. For all
1940 // other scopes, create one DbgScope now. This will be translated
1941 // into a scope DIE at the end.
1942 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
1943 DbgScope *Scope = getUpdatedDbgScope(DLT.Scope, MInsn, DLT.InlinedAtLoc);
1944 Scope->setLastInsn(MInsn);
1948 // If a scope's last instruction is not set then use its child scope's
1949 // last instruction as this scope's last instrunction.
1950 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
1951 DE = DbgScopeMap.end(); DI != DE; ++DI) {
1952 if (DI->second->isAbstractScope())
1954 assert (DI->second->getFirstInsn() && "Invalid first instruction!");
1955 DI->second->fixInstructionMarkers();
1956 assert (DI->second->getLastInsn() && "Invalid last instruction!");
1959 // Each scope has first instruction and last instruction to mark beginning
1960 // and end of a scope respectively. Create an inverse map that list scopes
1961 // starts (and ends) with an instruction. One instruction may start (or end)
1963 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
1964 DE = DbgScopeMap.end(); DI != DE; ++DI) {
1965 DbgScope *S = DI->second;
1966 if (S->isAbstractScope())
1968 const MachineInstr *MI = S->getFirstInsn();
1969 assert (MI && "DbgScope does not have first instruction!");
1971 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
1972 if (IDI != DbgScopeBeginMap.end())
1973 IDI->second.push_back(S);
1975 DbgScopeBeginMap[MI].push_back(S);
1977 MI = S->getLastInsn();
1978 assert (MI && "DbgScope does not have last instruction!");
1979 IDI = DbgScopeEndMap.find(MI);
1980 if (IDI != DbgScopeEndMap.end())
1981 IDI->second.push_back(S);
1983 DbgScopeEndMap[MI].push_back(S);
1986 return !DbgScopeMap.empty();
1989 /// beginFunction - Gather pre-function debug information. Assumes being
1990 /// emitted immediately after the function entry point.
1991 void DwarfDebug::beginFunction(MachineFunction *MF) {
1994 if (!ShouldEmitDwarfDebug()) return;
1996 if (TimePassesIsEnabled)
1997 DebugTimer->startTimer();
1999 if (!extractScopeInformation(MF))
2002 collectVariableInfo();
2004 // Begin accumulating function debug information.
2005 MMI->BeginFunction(MF);
2007 // Assumes in correct section after the entry point.
2008 EmitLabel("func_begin", ++SubprogramCount);
2010 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2012 DebugLoc FDL = MF->getDefaultDebugLoc();
2013 if (!FDL.isUnknown()) {
2014 DebugLocTuple DLT = MF->getDebugLocTuple(FDL);
2015 unsigned LabelID = 0;
2016 DISubprogram SP = getDISubprogram(DLT.Scope);
2018 LabelID = recordSourceLine(SP.getLineNumber(), 0, DLT.Scope);
2020 LabelID = recordSourceLine(DLT.Line, DLT.Col, DLT.Scope);
2021 Asm->printLabel(LabelID);
2024 if (TimePassesIsEnabled)
2025 DebugTimer->stopTimer();
2028 /// endFunction - Gather and emit post-function debug information.
2030 void DwarfDebug::endFunction(MachineFunction *MF) {
2031 if (!ShouldEmitDwarfDebug()) return;
2033 if (TimePassesIsEnabled)
2034 DebugTimer->startTimer();
2036 if (DbgScopeMap.empty())
2039 // Define end label for subprogram.
2040 EmitLabel("func_end", SubprogramCount);
2042 // Get function line info.
2043 if (!Lines.empty()) {
2044 // Get section line info.
2045 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2046 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2047 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2048 // Append the function info to section info.
2049 SectionLineInfos.insert(SectionLineInfos.end(),
2050 Lines.begin(), Lines.end());
2053 // Construct abstract scopes.
2054 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2055 AE = AbstractScopesList.end(); AI != AE; ++AI)
2056 constructScopeDIE(*AI);
2058 constructScopeDIE(CurrentFnDbgScope);
2060 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2061 MMI->getFrameMoves()));
2064 if (CurrentFnDbgScope) {
2065 CurrentFnDbgScope = NULL;
2066 DbgScopeMap.clear();
2067 DbgScopeBeginMap.clear();
2068 DbgScopeEndMap.clear();
2069 ConcreteScopes.clear();
2070 AbstractScopesList.clear();
2075 if (TimePassesIsEnabled)
2076 DebugTimer->stopTimer();
2079 /// recordSourceLine - Records location information and associates it with a
2080 /// label. Returns a unique label ID used to generate a label and provide
2081 /// correspondence to the source line list.
2082 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2087 if (TimePassesIsEnabled)
2088 DebugTimer->startTimer();
2090 const char *Dir = NULL;
2091 const char *Fn = NULL;
2093 DIDescriptor Scope(S);
2094 if (Scope.isCompileUnit()) {
2095 DICompileUnit CU(S);
2096 Dir = CU.getDirectory();
2097 Fn = CU.getFilename();
2098 } else if (Scope.isSubprogram()) {
2100 Dir = SP.getDirectory();
2101 Fn = SP.getFilename();
2102 } else if (Scope.isLexicalBlock()) {
2103 DILexicalBlock DB(S);
2104 Dir = DB.getDirectory();
2105 Fn = DB.getFilename();
2107 assert (0 && "Unexpected scope info");
2109 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2110 unsigned ID = MMI->NextLabelID();
2111 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2113 if (TimePassesIsEnabled)
2114 DebugTimer->stopTimer();
2119 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2120 /// timed. Look up the source id with the given directory and source file
2121 /// names. If none currently exists, create a new id and insert it in the
2122 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2124 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2125 const std::string &FileName) {
2126 if (TimePassesIsEnabled)
2127 DebugTimer->startTimer();
2129 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2131 if (TimePassesIsEnabled)
2132 DebugTimer->stopTimer();
2137 //===----------------------------------------------------------------------===//
2139 //===----------------------------------------------------------------------===//
2141 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2144 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2145 // Get the children.
2146 const std::vector<DIE *> &Children = Die->getChildren();
2148 // If not last sibling and has children then add sibling offset attribute.
2149 if (!Last && !Children.empty()) Die->addSiblingOffset();
2151 // Record the abbreviation.
2152 assignAbbrevNumber(Die->getAbbrev());
2154 // Get the abbreviation for this DIE.
2155 unsigned AbbrevNumber = Die->getAbbrevNumber();
2156 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2159 Die->setOffset(Offset);
2161 // Start the size with the size of abbreviation code.
2162 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2164 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2165 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2167 // Size the DIE attribute values.
2168 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2169 // Size attribute value.
2170 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2172 // Size the DIE children if any.
2173 if (!Children.empty()) {
2174 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2175 "Children flag not set");
2177 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2178 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2180 // End of children marker.
2181 Offset += sizeof(int8_t);
2184 Die->setSize(Offset - Die->getOffset());
2188 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2190 void DwarfDebug::computeSizeAndOffsets() {
2191 // Compute size of compile unit header.
2192 static unsigned Offset =
2193 sizeof(int32_t) + // Length of Compilation Unit Info
2194 sizeof(int16_t) + // DWARF version number
2195 sizeof(int32_t) + // Offset Into Abbrev. Section
2196 sizeof(int8_t); // Pointer Size (in bytes)
2198 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2199 CompileUnitOffsets[ModuleCU] = 0;
2202 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2203 /// tools to recognize the object file contains Dwarf information.
2204 void DwarfDebug::emitInitial() {
2205 // Check to see if we already emitted intial headers.
2206 if (didInitial) return;
2209 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2211 // Dwarf sections base addresses.
2212 if (MAI->doesDwarfRequireFrameSection()) {
2213 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2214 EmitLabel("section_debug_frame", 0);
2217 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2218 EmitLabel("section_info", 0);
2219 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2220 EmitLabel("section_abbrev", 0);
2221 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2222 EmitLabel("section_aranges", 0);
2224 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2225 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2226 EmitLabel("section_macinfo", 0);
2229 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2230 EmitLabel("section_line", 0);
2231 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2232 EmitLabel("section_loc", 0);
2233 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2234 EmitLabel("section_pubnames", 0);
2235 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2236 EmitLabel("section_str", 0);
2237 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2238 EmitLabel("section_ranges", 0);
2240 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2241 EmitLabel("text_begin", 0);
2242 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2243 EmitLabel("data_begin", 0);
2246 /// emitDIE - Recusively Emits a debug information entry.
2248 void DwarfDebug::emitDIE(DIE *Die) {
2249 // Get the abbreviation for this DIE.
2250 unsigned AbbrevNumber = Die->getAbbrevNumber();
2251 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2255 // Emit the code (index) for the abbreviation.
2256 Asm->EmitULEB128Bytes(AbbrevNumber);
2258 if (Asm->isVerbose())
2259 Asm->EOL(std::string("Abbrev [" +
2260 utostr(AbbrevNumber) +
2261 "] 0x" + utohexstr(Die->getOffset()) +
2262 ":0x" + utohexstr(Die->getSize()) + " " +
2263 dwarf::TagString(Abbrev->getTag())));
2267 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2268 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2270 // Emit the DIE attribute values.
2271 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2272 unsigned Attr = AbbrevData[i].getAttribute();
2273 unsigned Form = AbbrevData[i].getForm();
2274 assert(Form && "Too many attributes for DIE (check abbreviation)");
2277 case dwarf::DW_AT_sibling:
2278 Asm->EmitInt32(Die->getSiblingOffset());
2280 case dwarf::DW_AT_abstract_origin: {
2281 DIEEntry *E = cast<DIEEntry>(Values[i]);
2282 DIE *Origin = E->getEntry();
2283 unsigned Addr = Origin->getOffset();
2284 Asm->EmitInt32(Addr);
2288 // Emit an attribute using the defined form.
2289 Values[i]->EmitValue(this, Form);
2293 Asm->EOL(dwarf::AttributeString(Attr));
2296 // Emit the DIE children if any.
2297 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2298 const std::vector<DIE *> &Children = Die->getChildren();
2300 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2301 emitDIE(Children[j]);
2303 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2307 /// emitDebugInfo / emitDebugInfoPerCU - Emit the debug info section.
2309 void DwarfDebug::emitDebugInfoPerCU(CompileUnit *Unit) {
2310 DIE *Die = Unit->getCUDie();
2312 // Emit the compile units header.
2313 EmitLabel("info_begin", Unit->getID());
2315 // Emit size of content not including length itself
2316 unsigned ContentSize = Die->getSize() +
2317 sizeof(int16_t) + // DWARF version number
2318 sizeof(int32_t) + // Offset Into Abbrev. Section
2319 sizeof(int8_t) + // Pointer Size (in bytes)
2320 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2322 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
2323 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2324 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2325 Asm->EOL("Offset Into Abbrev. Section");
2326 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2329 // FIXME - extra padding for gdb bug.
2330 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2331 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2332 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2333 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2334 EmitLabel("info_end", Unit->getID());
2339 void DwarfDebug::emitDebugInfo() {
2340 // Start debug info section.
2341 Asm->OutStreamer.SwitchSection(
2342 Asm->getObjFileLowering().getDwarfInfoSection());
2344 emitDebugInfoPerCU(ModuleCU);
2347 /// emitAbbreviations - Emit the abbreviation section.
2349 void DwarfDebug::emitAbbreviations() const {
2350 // Check to see if it is worth the effort.
2351 if (!Abbreviations.empty()) {
2352 // Start the debug abbrev section.
2353 Asm->OutStreamer.SwitchSection(
2354 Asm->getObjFileLowering().getDwarfAbbrevSection());
2356 EmitLabel("abbrev_begin", 0);
2358 // For each abbrevation.
2359 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2360 // Get abbreviation data
2361 const DIEAbbrev *Abbrev = Abbreviations[i];
2363 // Emit the abbrevations code (base 1 index.)
2364 Asm->EmitULEB128Bytes(Abbrev->getNumber());
2365 Asm->EOL("Abbreviation Code");
2367 // Emit the abbreviations data.
2373 // Mark end of abbreviations.
2374 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2376 EmitLabel("abbrev_end", 0);
2381 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2382 /// the line matrix.
2384 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2385 // Define last address of section.
2386 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2387 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2388 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2389 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2391 // Mark end of matrix.
2392 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2393 Asm->EmitULEB128Bytes(1); Asm->EOL();
2394 Asm->EmitInt8(1); Asm->EOL();
2397 /// emitDebugLines - Emit source line information.
2399 void DwarfDebug::emitDebugLines() {
2400 // If the target is using .loc/.file, the assembler will be emitting the
2401 // .debug_line table automatically.
2402 if (MAI->hasDotLocAndDotFile())
2405 // Minimum line delta, thus ranging from -10..(255-10).
2406 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2407 // Maximum line delta, thus ranging from -10..(255-10).
2408 const int MaxLineDelta = 255 + MinLineDelta;
2410 // Start the dwarf line section.
2411 Asm->OutStreamer.SwitchSection(
2412 Asm->getObjFileLowering().getDwarfLineSection());
2414 // Construct the section header.
2415 EmitDifference("line_end", 0, "line_begin", 0, true);
2416 Asm->EOL("Length of Source Line Info");
2417 EmitLabel("line_begin", 0);
2419 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2421 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2422 Asm->EOL("Prolog Length");
2423 EmitLabel("line_prolog_begin", 0);
2425 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2427 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2429 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2431 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2433 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2435 // Line number standard opcode encodings argument count
2436 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2437 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2438 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2439 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2440 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2441 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2442 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2443 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2444 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2446 // Emit directories.
2447 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2448 Asm->EmitString(getSourceDirectoryName(DI));
2449 Asm->EOL("Directory");
2452 Asm->EmitInt8(0); Asm->EOL("End of directories");
2455 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2456 // Remember source id starts at 1.
2457 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2458 Asm->EmitString(getSourceFileName(Id.second));
2460 Asm->EmitULEB128Bytes(Id.first);
2461 Asm->EOL("Directory #");
2462 Asm->EmitULEB128Bytes(0);
2463 Asm->EOL("Mod date");
2464 Asm->EmitULEB128Bytes(0);
2465 Asm->EOL("File size");
2468 Asm->EmitInt8(0); Asm->EOL("End of files");
2470 EmitLabel("line_prolog_end", 0);
2472 // A sequence for each text section.
2473 unsigned SecSrcLinesSize = SectionSourceLines.size();
2475 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2476 // Isolate current sections line info.
2477 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2479 /*if (Asm->isVerbose()) {
2480 const MCSection *S = SectionMap[j + 1];
2481 O << '\t' << MAI->getCommentString() << " Section"
2482 << S->getName() << '\n';
2486 // Dwarf assumes we start with first line of first source file.
2487 unsigned Source = 1;
2490 // Construct rows of the address, source, line, column matrix.
2491 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2492 const SrcLineInfo &LineInfo = LineInfos[i];
2493 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2494 if (!LabelID) continue;
2496 if (LineInfo.getLine() == 0) continue;
2498 if (!Asm->isVerbose())
2501 std::pair<unsigned, unsigned> SourceID =
2502 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2503 O << '\t' << MAI->getCommentString() << ' '
2504 << getSourceDirectoryName(SourceID.first) << ' '
2505 << getSourceFileName(SourceID.second)
2506 <<" :" << utostr_32(LineInfo.getLine()) << '\n';
2509 // Define the line address.
2510 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2511 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2512 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2513 EmitReference("label", LabelID); Asm->EOL("Location label");
2515 // If change of source, then switch to the new source.
2516 if (Source != LineInfo.getSourceID()) {
2517 Source = LineInfo.getSourceID();
2518 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2519 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2522 // If change of line.
2523 if (Line != LineInfo.getLine()) {
2524 // Determine offset.
2525 int Offset = LineInfo.getLine() - Line;
2526 int Delta = Offset - MinLineDelta;
2529 Line = LineInfo.getLine();
2531 // If delta is small enough and in range...
2532 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2533 // ... then use fast opcode.
2534 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2536 // ... otherwise use long hand.
2537 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2538 Asm->EOL("DW_LNS_advance_line");
2539 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2540 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2543 // Copy the previous row (different address or source)
2544 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2548 emitEndOfLineMatrix(j + 1);
2551 if (SecSrcLinesSize == 0)
2552 // Because we're emitting a debug_line section, we still need a line
2553 // table. The linker and friends expect it to exist. If there's nothing to
2554 // put into it, emit an empty table.
2555 emitEndOfLineMatrix(1);
2557 EmitLabel("line_end", 0);
2561 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2563 void DwarfDebug::emitCommonDebugFrame() {
2564 if (!MAI->doesDwarfRequireFrameSection())
2568 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2569 TargetFrameInfo::StackGrowsUp ?
2570 TD->getPointerSize() : -TD->getPointerSize();
2572 // Start the dwarf frame section.
2573 Asm->OutStreamer.SwitchSection(
2574 Asm->getObjFileLowering().getDwarfFrameSection());
2576 EmitLabel("debug_frame_common", 0);
2577 EmitDifference("debug_frame_common_end", 0,
2578 "debug_frame_common_begin", 0, true);
2579 Asm->EOL("Length of Common Information Entry");
2581 EmitLabel("debug_frame_common_begin", 0);
2582 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2583 Asm->EOL("CIE Identifier Tag");
2584 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2585 Asm->EOL("CIE Version");
2586 Asm->EmitString("");
2587 Asm->EOL("CIE Augmentation");
2588 Asm->EmitULEB128Bytes(1);
2589 Asm->EOL("CIE Code Alignment Factor");
2590 Asm->EmitSLEB128Bytes(stackGrowth);
2591 Asm->EOL("CIE Data Alignment Factor");
2592 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2593 Asm->EOL("CIE RA Column");
2595 std::vector<MachineMove> Moves;
2596 RI->getInitialFrameState(Moves);
2598 EmitFrameMoves(NULL, 0, Moves, false);
2600 Asm->EmitAlignment(2, 0, 0, false);
2601 EmitLabel("debug_frame_common_end", 0);
2606 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2609 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2610 if (!MAI->doesDwarfRequireFrameSection())
2613 // Start the dwarf frame section.
2614 Asm->OutStreamer.SwitchSection(
2615 Asm->getObjFileLowering().getDwarfFrameSection());
2617 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2618 "debug_frame_begin", DebugFrameInfo.Number, true);
2619 Asm->EOL("Length of Frame Information Entry");
2621 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2623 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2625 Asm->EOL("FDE CIE offset");
2627 EmitReference("func_begin", DebugFrameInfo.Number);
2628 Asm->EOL("FDE initial location");
2629 EmitDifference("func_end", DebugFrameInfo.Number,
2630 "func_begin", DebugFrameInfo.Number);
2631 Asm->EOL("FDE address range");
2633 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2636 Asm->EmitAlignment(2, 0, 0, false);
2637 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2642 void DwarfDebug::emitDebugPubNamesPerCU(CompileUnit *Unit) {
2643 EmitDifference("pubnames_end", Unit->getID(),
2644 "pubnames_begin", Unit->getID(), true);
2645 Asm->EOL("Length of Public Names Info");
2647 EmitLabel("pubnames_begin", Unit->getID());
2649 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2651 EmitSectionOffset("info_begin", "section_info",
2652 Unit->getID(), 0, true, false);
2653 Asm->EOL("Offset of Compilation Unit Info");
2655 EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(),
2657 Asm->EOL("Compilation Unit Length");
2659 StringMap<DIE*> &Globals = Unit->getGlobals();
2660 for (StringMap<DIE*>::const_iterator
2661 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2662 const char *Name = GI->getKeyData();
2663 DIE * Entity = GI->second;
2665 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2666 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2669 Asm->EmitInt32(0); Asm->EOL("End Mark");
2670 EmitLabel("pubnames_end", Unit->getID());
2675 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2677 void DwarfDebug::emitDebugPubNames() {
2678 // Start the dwarf pubnames section.
2679 Asm->OutStreamer.SwitchSection(
2680 Asm->getObjFileLowering().getDwarfPubNamesSection());
2682 emitDebugPubNamesPerCU(ModuleCU);
2685 /// emitDebugStr - Emit visible names into a debug str section.
2687 void DwarfDebug::emitDebugStr() {
2688 // Check to see if it is worth the effort.
2689 if (!StringPool.empty()) {
2690 // Start the dwarf str section.
2691 Asm->OutStreamer.SwitchSection(
2692 Asm->getObjFileLowering().getDwarfStrSection());
2694 // For each of strings in the string pool.
2695 for (unsigned StringID = 1, N = StringPool.size();
2696 StringID <= N; ++StringID) {
2697 // Emit a label for reference from debug information entries.
2698 EmitLabel("string", StringID);
2700 // Emit the string itself.
2701 const std::string &String = StringPool[StringID];
2702 Asm->EmitString(String); Asm->EOL();
2709 /// emitDebugLoc - Emit visible names into a debug loc section.
2711 void DwarfDebug::emitDebugLoc() {
2712 // Start the dwarf loc section.
2713 Asm->OutStreamer.SwitchSection(
2714 Asm->getObjFileLowering().getDwarfLocSection());
2718 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2720 void DwarfDebug::EmitDebugARanges() {
2721 // Start the dwarf aranges section.
2722 Asm->OutStreamer.SwitchSection(
2723 Asm->getObjFileLowering().getDwarfARangesSection());
2727 CompileUnit *Unit = GetBaseCompileUnit();
2729 // Don't include size of length
2730 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
2732 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2734 EmitReference("info_begin", Unit->getID());
2735 Asm->EOL("Offset of Compilation Unit Info");
2737 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2739 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2741 Asm->EmitInt16(0); Asm->EOL("Pad (1)");
2742 Asm->EmitInt16(0); Asm->EOL("Pad (2)");
2745 EmitReference("text_begin", 0); Asm->EOL("Address");
2746 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2748 Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2749 Asm->EmitInt32(0); Asm->EOL("EOM (2)");
2755 /// emitDebugRanges - Emit visible names into a debug ranges section.
2757 void DwarfDebug::emitDebugRanges() {
2758 // Start the dwarf ranges section.
2759 Asm->OutStreamer.SwitchSection(
2760 Asm->getObjFileLowering().getDwarfRangesSection());
2764 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2766 void DwarfDebug::emitDebugMacInfo() {
2767 if (const MCSection *LineInfo =
2768 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2769 // Start the dwarf macinfo section.
2770 Asm->OutStreamer.SwitchSection(LineInfo);
2775 /// emitDebugInlineInfo - Emit inline info using following format.
2777 /// 1. length of section
2778 /// 2. Dwarf version number
2779 /// 3. address size.
2781 /// Entries (one "entry" for each function that was inlined):
2783 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2784 /// otherwise offset into __debug_str for regular function name.
2785 /// 2. offset into __debug_str section for regular function name.
2786 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2787 /// instances for the function.
2789 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2790 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2791 /// __debug_info section, and the low_pc is the starting address for the
2792 /// inlining instance.
2793 void DwarfDebug::emitDebugInlineInfo() {
2794 if (!MAI->doesDwarfUsesInlineInfoSection())
2800 Asm->OutStreamer.SwitchSection(
2801 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2803 EmitDifference("debug_inlined_end", 1,
2804 "debug_inlined_begin", 1, true);
2805 Asm->EOL("Length of Debug Inlined Information Entry");
2807 EmitLabel("debug_inlined_begin", 1);
2809 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2810 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2812 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2813 E = InlinedSPNodes.end(); I != E; ++I) {
2815 // for (ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
2816 // I = InlineInfo.begin(), E = InlineInfo.end(); I != E; ++I) {
2818 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2819 = InlineInfo.find(Node);
2820 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2821 DISubprogram SP(Node);
2822 const char *LName = SP.getLinkageName();
2823 const char *Name = SP.getName();
2826 Asm->EmitString(Name);
2828 // Skip special LLVM prefix that is used to inform the asm printer to not
2829 // emit usual symbol prefix before the symbol name. This happens for
2830 // Objective-C symbol names and symbol whose name is replaced using GCC's
2831 // __asm__ attribute.
2834 // Asm->EmitString(LName);
2835 EmitSectionOffset("string", "section_str",
2836 StringPool.idFor(LName), false, true);
2839 Asm->EOL("MIPS linkage name");
2840 // Asm->EmitString(Name);
2841 EmitSectionOffset("string", "section_str",
2842 StringPool.idFor(Name), false, true);
2843 Asm->EOL("Function name");
2844 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2846 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2847 LE = Labels.end(); LI != LE; ++LI) {
2848 DIE *SP = LI->second;
2849 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2851 if (TD->getPointerSize() == sizeof(int32_t))
2852 O << MAI->getData32bitsDirective();
2854 O << MAI->getData64bitsDirective();
2856 PrintLabelName("label", LI->first); Asm->EOL("low_pc");
2860 EmitLabel("debug_inlined_end", 1);