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/Mangler.h"
22 #include "llvm/Target/TargetData.h"
23 #include "llvm/Target/TargetFrameInfo.h"
24 #include "llvm/Target/TargetLoweringObjectFile.h"
25 #include "llvm/Target/TargetRegisterInfo.h"
26 #include "llvm/ADT/StringExtras.h"
27 #include "llvm/Support/Debug.h"
28 #include "llvm/Support/ErrorHandling.h"
29 #include "llvm/Support/FormattedStream.h"
30 #include "llvm/Support/Timer.h"
31 #include "llvm/System/Path.h"
34 //===----------------------------------------------------------------------===//
36 /// Configuration values for initial hash set sizes (log2).
38 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
42 //===----------------------------------------------------------------------===//
43 /// CompileUnit - This dwarf writer support class manages information associate
44 /// with a source file.
46 /// ID - File identifier for source.
50 /// Die - Compile unit debug information entry.
54 /// IndexTyDie - An anonymous type for index type.
57 /// GVToDieMap - Tracks the mapping of unit level debug informaton
58 /// variables to debug information entries.
59 /// FIXME : Rename GVToDieMap -> NodeToDieMap
60 DenseMap<MDNode *, DIE *> GVToDieMap;
62 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
63 /// descriptors to debug information entries using a DIEEntry proxy.
65 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
67 /// Globals - A map of globally visible named entities for this unit.
69 StringMap<DIE*> Globals;
71 /// GlobalTypes - A map of globally visible types for this unit.
73 StringMap<DIE*> GlobalTypes;
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 const StringMap<DIE*> &getGlobals() const { return Globals; }
84 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
86 /// hasContent - Return true if this compile unit has something to write out.
88 bool hasContent() const { return !CUDie->getChildren().empty(); }
90 /// addGlobal - Add a new global entity to the compile unit.
92 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
94 /// addGlobalType - Add a new global type to the compile unit.
96 void addGlobalType(const std::string &Name, DIE *Die) {
97 GlobalTypes[Name] = Die;
100 /// getDIE - Returns the debug information entry map slot for the
101 /// specified debug variable.
102 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
104 /// insertDIE - Insert DIE into the map.
105 void insertDIE(MDNode *N, DIE *D) {
106 GVToDieMap.insert(std::make_pair(N, D));
109 /// getDIEEntry - Returns the debug information entry for the speciefied
111 DIEEntry *getDIEEntry(MDNode *N) {
112 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
113 if (I == GVToDIEEntryMap.end())
118 /// insertDIEEntry - Insert debug information entry into the map.
119 void insertDIEEntry(MDNode *N, DIEEntry *E) {
120 GVToDIEEntryMap.insert(std::make_pair(N, E));
123 /// addDie - Adds or interns the DIE to the compile unit.
125 void addDie(DIE *Buffer) {
126 this->CUDie->addChild(Buffer);
129 // getIndexTyDie - Get an anonymous type for index type.
130 DIE *getIndexTyDie() {
134 // setIndexTyDie - Set D as anonymous type for index which can be reused
136 void setIndexTyDie(DIE *D) {
142 //===----------------------------------------------------------------------===//
143 /// DbgVariable - This class is used to track local variable information.
146 DIVariable Var; // Variable Descriptor.
147 unsigned FrameIndex; // Variable frame index.
148 DbgVariable *AbstractVar; // Abstract variable for this variable.
151 DbgVariable(DIVariable V, unsigned I)
152 : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0) {}
155 DIVariable getVariable() const { return Var; }
156 unsigned getFrameIndex() const { return FrameIndex; }
157 void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
158 DbgVariable *getAbstractVariable() const { return AbstractVar; }
159 void setDIE(DIE *D) { TheDIE = D; }
160 DIE *getDIE() const { return TheDIE; }
163 //===----------------------------------------------------------------------===//
164 /// DbgScope - This class is used to track scope information.
167 DbgScope *Parent; // Parent to this scope.
168 DIDescriptor Desc; // Debug info descriptor for scope.
169 MDNode * InlinedAtLocation; // Location at which scope is inlined.
170 bool AbstractScope; // Abstract Scope
171 unsigned StartLabelID; // Label ID of the beginning of scope.
172 unsigned EndLabelID; // Label ID of the end of scope.
173 const MachineInstr *LastInsn; // Last instruction of this scope.
174 const MachineInstr *FirstInsn; // First instruction of this scope.
175 SmallVector<DbgScope *, 4> Scopes; // Scopes defined in scope.
176 SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
178 // Private state for dump()
179 mutable unsigned IndentLevel;
181 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
182 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
183 StartLabelID(0), EndLabelID(0),
184 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
188 DbgScope *getParent() const { return Parent; }
189 void setParent(DbgScope *P) { Parent = P; }
190 DIDescriptor getDesc() const { return Desc; }
191 MDNode *getInlinedAt() const {
192 return dyn_cast_or_null<MDNode>(InlinedAtLocation);
194 MDNode *getScopeNode() const { return Desc.getNode(); }
195 unsigned getStartLabelID() const { return StartLabelID; }
196 unsigned getEndLabelID() const { return EndLabelID; }
197 SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
198 SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
199 void setStartLabelID(unsigned S) { StartLabelID = S; }
200 void setEndLabelID(unsigned E) { EndLabelID = E; }
201 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
202 const MachineInstr *getLastInsn() { return LastInsn; }
203 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
204 void setAbstractScope() { AbstractScope = true; }
205 bool isAbstractScope() const { return AbstractScope; }
206 const MachineInstr *getFirstInsn() { return FirstInsn; }
208 /// addScope - Add a scope to the scope.
210 void addScope(DbgScope *S) { Scopes.push_back(S); }
212 /// addVariable - Add a variable to the scope.
214 void addVariable(DbgVariable *V) { Variables.push_back(V); }
216 void fixInstructionMarkers(DenseMap<const MachineInstr *,
217 unsigned> &MIIndexMap) {
218 assert (getFirstInsn() && "First instruction is missing!");
220 // Use the end of last child scope as end of this scope.
221 SmallVector<DbgScope *, 4> &Scopes = getScopes();
222 const MachineInstr *LastInsn = getFirstInsn();
224 if (Scopes.empty()) {
225 assert (getLastInsn() && "Inner most scope does not have last insn!");
228 for (SmallVector<DbgScope *, 4>::iterator SI = Scopes.begin(),
229 SE = Scopes.end(); SI != SE; ++SI) {
231 DS->fixInstructionMarkers(MIIndexMap);
232 const MachineInstr *DSLastInsn = DS->getLastInsn();
233 unsigned DSI = MIIndexMap[DSLastInsn];
235 LastInsn = DSLastInsn;
239 setLastInsn(LastInsn);
248 void DbgScope::dump() const {
249 raw_ostream &err = dbgs();
250 err.indent(IndentLevel);
251 MDNode *N = Desc.getNode();
253 err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
255 err << "Abstract Scope\n";
259 err << "Children ...\n";
260 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
261 if (Scopes[i] != this)
268 DbgScope::~DbgScope() {
269 for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
271 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
275 } // end llvm namespace
277 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
278 : DwarfPrinter(OS, A, T, "dbg"), ModuleCU(0),
279 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
280 DIEValues(), StringPool(),
281 SectionSourceLines(), didInitial(false), shouldEmit(false),
282 CurrentFnDbgScope(0), DebugTimer(0) {
283 if (TimePassesIsEnabled)
284 DebugTimer = new Timer("Dwarf Debug Writer");
286 DwarfDebug::~DwarfDebug() {
287 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
293 /// assignAbbrevNumber - Define a unique number for the abbreviation.
295 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
296 // Profile the node so that we can make it unique.
300 // Check the set for priors.
301 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
303 // If it's newly added.
304 if (InSet == &Abbrev) {
305 // Add to abbreviation list.
306 Abbreviations.push_back(&Abbrev);
308 // Assign the vector position + 1 as its number.
309 Abbrev.setNumber(Abbreviations.size());
311 // Assign existing abbreviation number.
312 Abbrev.setNumber(InSet->getNumber());
316 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
317 /// information entry.
318 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
319 DIEEntry *Value = new DIEEntry(Entry);
320 DIEValues.push_back(Value);
324 /// addUInt - Add an unsigned integer attribute data and value.
326 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
327 unsigned Form, uint64_t Integer) {
328 if (!Form) Form = DIEInteger::BestForm(false, Integer);
329 DIEValue *Value = new DIEInteger(Integer);
330 DIEValues.push_back(Value);
331 Die->addValue(Attribute, Form, Value);
334 /// addSInt - Add an signed integer attribute data and value.
336 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
337 unsigned Form, int64_t Integer) {
338 if (!Form) Form = DIEInteger::BestForm(true, Integer);
339 DIEValue *Value = new DIEInteger(Integer);
340 DIEValues.push_back(Value);
341 Die->addValue(Attribute, Form, Value);
344 /// addString - Add a string attribute data and value. DIEString only
345 /// keeps string reference.
346 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
348 DIEValue *Value = new DIEString(String);
349 DIEValues.push_back(Value);
350 Die->addValue(Attribute, Form, Value);
353 /// addLabel - Add a Dwarf label attribute data and value.
355 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
356 const DWLabel &Label) {
357 DIEValue *Value = new DIEDwarfLabel(Label);
358 DIEValues.push_back(Value);
359 Die->addValue(Attribute, Form, Value);
362 /// addObjectLabel - Add an non-Dwarf label attribute data and value.
364 void DwarfDebug::addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
365 const MCSymbol *Sym) {
366 DIEValue *Value = new DIEObjectLabel(Sym);
367 DIEValues.push_back(Value);
368 Die->addValue(Attribute, Form, Value);
371 /// addSectionOffset - Add a section offset label attribute data and value.
373 void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
374 const DWLabel &Label, const DWLabel &Section,
375 bool isEH, bool useSet) {
376 DIEValue *Value = new DIESectionOffset(Label, Section, isEH, useSet);
377 DIEValues.push_back(Value);
378 Die->addValue(Attribute, Form, Value);
381 /// addDelta - Add a label delta attribute data and value.
383 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
384 const DWLabel &Hi, const DWLabel &Lo) {
385 DIEValue *Value = new DIEDelta(Hi, Lo);
386 DIEValues.push_back(Value);
387 Die->addValue(Attribute, Form, Value);
390 /// addBlock - Add block data.
392 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
394 Block->ComputeSize(TD);
395 DIEValues.push_back(Block);
396 Die->addValue(Attribute, Block->BestForm(), Block);
399 /// addSourceLine - Add location information to specified debug information
401 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
402 // If there is no compile unit specified, don't add a line #.
403 if (V->getCompileUnit().isNull())
406 unsigned Line = V->getLineNumber();
407 unsigned FileID = findCompileUnit(V->getCompileUnit())->getID();
408 assert(FileID && "Invalid file id");
409 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
410 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
413 /// addSourceLine - Add location information to specified debug information
415 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
416 // If there is no compile unit specified, don't add a line #.
417 if (G->getCompileUnit().isNull())
420 unsigned Line = G->getLineNumber();
421 unsigned FileID = findCompileUnit(G->getCompileUnit())->getID();
422 assert(FileID && "Invalid file id");
423 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
424 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
427 /// addSourceLine - Add location information to specified debug information
429 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
430 // If there is no compile unit specified, don't add a line #.
431 if (SP->getCompileUnit().isNull())
433 // If the line number is 0, don't add it.
434 if (SP->getLineNumber() == 0)
438 unsigned Line = SP->getLineNumber();
439 unsigned FileID = findCompileUnit(SP->getCompileUnit())->getID();
440 assert(FileID && "Invalid file id");
441 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
442 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
445 /// addSourceLine - Add location information to specified debug information
447 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
448 // If there is no compile unit specified, don't add a line #.
449 DICompileUnit CU = Ty->getCompileUnit();
453 unsigned Line = Ty->getLineNumber();
454 unsigned FileID = findCompileUnit(CU)->getID();
455 assert(FileID && "Invalid file id");
456 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
457 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
460 /// addSourceLine - Add location information to specified debug information
462 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
463 // If there is no compile unit specified, don't add a line #.
464 if (NS->getCompileUnit().isNull())
467 unsigned Line = NS->getLineNumber();
468 StringRef FN = NS->getFilename();
469 StringRef Dir = NS->getDirectory();
471 unsigned FileID = GetOrCreateSourceID(Dir, FN);
472 assert(FileID && "Invalid file id");
473 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
474 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
477 /* Byref variables, in Blocks, are declared by the programmer as
478 "SomeType VarName;", but the compiler creates a
479 __Block_byref_x_VarName struct, and gives the variable VarName
480 either the struct, or a pointer to the struct, as its type. This
481 is necessary for various behind-the-scenes things the compiler
482 needs to do with by-reference variables in blocks.
484 However, as far as the original *programmer* is concerned, the
485 variable should still have type 'SomeType', as originally declared.
487 The following function dives into the __Block_byref_x_VarName
488 struct to find the original type of the variable. This will be
489 passed back to the code generating the type for the Debug
490 Information Entry for the variable 'VarName'. 'VarName' will then
491 have the original type 'SomeType' in its debug information.
493 The original type 'SomeType' will be the type of the field named
494 'VarName' inside the __Block_byref_x_VarName struct.
496 NOTE: In order for this to not completely fail on the debugger
497 side, the Debug Information Entry for the variable VarName needs to
498 have a DW_AT_location that tells the debugger how to unwind through
499 the pointers and __Block_byref_x_VarName struct to find the actual
500 value of the variable. The function addBlockByrefType does this. */
502 /// Find the type the programmer originally declared the variable to be
503 /// and return that type.
505 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
508 unsigned tag = Ty.getTag();
510 if (tag == dwarf::DW_TAG_pointer_type) {
511 DIDerivedType DTy = DIDerivedType(Ty.getNode());
512 subType = DTy.getTypeDerivedFrom();
515 DICompositeType blockStruct = DICompositeType(subType.getNode());
517 DIArray Elements = blockStruct.getTypeArray();
519 if (Elements.isNull())
522 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
523 DIDescriptor Element = Elements.getElement(i);
524 DIDerivedType DT = DIDerivedType(Element.getNode());
525 if (Name == DT.getName())
526 return (DT.getTypeDerivedFrom());
532 /// addComplexAddress - Start with the address based on the location provided,
533 /// and generate the DWARF information necessary to find the actual variable
534 /// given the extra address information encoded in the DIVariable, starting from
535 /// the starting location. Add the DWARF information to the die.
537 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
539 const MachineLocation &Location) {
540 const DIVariable &VD = DV->getVariable();
541 DIType Ty = VD.getType();
543 // Decode the original location, and use that as the start of the byref
544 // variable's location.
545 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
546 DIEBlock *Block = new DIEBlock();
548 if (Location.isReg()) {
550 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
552 Reg = Reg - dwarf::DW_OP_reg0;
553 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
554 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
558 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
560 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
561 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
564 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
567 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
568 uint64_t Element = VD.getAddrElement(i);
570 if (Element == DIFactory::OpPlus) {
571 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
572 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
573 } else if (Element == DIFactory::OpDeref) {
574 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
575 } else llvm_unreachable("unknown DIFactory Opcode");
578 // Now attach the location information to the DIE.
579 addBlock(Die, Attribute, 0, Block);
582 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
583 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
584 gives the variable VarName either the struct, or a pointer to the struct, as
585 its type. This is necessary for various behind-the-scenes things the
586 compiler needs to do with by-reference variables in Blocks.
588 However, as far as the original *programmer* is concerned, the variable
589 should still have type 'SomeType', as originally declared.
591 The function getBlockByrefType dives into the __Block_byref_x_VarName
592 struct to find the original type of the variable, which is then assigned to
593 the variable's Debug Information Entry as its real type. So far, so good.
594 However now the debugger will expect the variable VarName to have the type
595 SomeType. So we need the location attribute for the variable to be an
596 expression that explains to the debugger how to navigate through the
597 pointers and struct to find the actual variable of type SomeType.
599 The following function does just that. We start by getting
600 the "normal" location for the variable. This will be the location
601 of either the struct __Block_byref_x_VarName or the pointer to the
602 struct __Block_byref_x_VarName.
604 The struct will look something like:
606 struct __Block_byref_x_VarName {
608 struct __Block_byref_x_VarName *forwarding;
609 ... <various other fields>
611 ... <maybe more fields>
614 If we are given the struct directly (as our starting point) we
615 need to tell the debugger to:
617 1). Add the offset of the forwarding field.
619 2). Follow that pointer to get the the real __Block_byref_x_VarName
620 struct to use (the real one may have been copied onto the heap).
622 3). Add the offset for the field VarName, to find the actual variable.
624 If we started with a pointer to the struct, then we need to
625 dereference that pointer first, before the other steps.
626 Translating this into DWARF ops, we will need to append the following
627 to the current location description for the variable:
629 DW_OP_deref -- optional, if we start with a pointer
630 DW_OP_plus_uconst <forward_fld_offset>
632 DW_OP_plus_uconst <varName_fld_offset>
634 That is what this function does. */
636 /// addBlockByrefAddress - Start with the address based on the location
637 /// provided, and generate the DWARF information necessary to find the
638 /// actual Block variable (navigating the Block struct) based on the
639 /// starting location. Add the DWARF information to the die. For
640 /// more information, read large comment just above here.
642 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
644 const MachineLocation &Location) {
645 const DIVariable &VD = DV->getVariable();
646 DIType Ty = VD.getType();
648 unsigned Tag = Ty.getTag();
649 bool isPointer = false;
651 StringRef varName = VD.getName();
653 if (Tag == dwarf::DW_TAG_pointer_type) {
654 DIDerivedType DTy = DIDerivedType(Ty.getNode());
655 TmpTy = DTy.getTypeDerivedFrom();
659 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
661 // Find the __forwarding field and the variable field in the __Block_byref
663 DIArray Fields = blockStruct.getTypeArray();
664 DIDescriptor varField = DIDescriptor();
665 DIDescriptor forwardingField = DIDescriptor();
668 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
669 DIDescriptor Element = Fields.getElement(i);
670 DIDerivedType DT = DIDerivedType(Element.getNode());
671 StringRef fieldName = DT.getName();
672 if (fieldName == "__forwarding")
673 forwardingField = Element;
674 else if (fieldName == varName)
678 assert(!varField.isNull() && "Can't find byref variable in Block struct");
679 assert(!forwardingField.isNull()
680 && "Can't find forwarding field in Block struct");
682 // Get the offsets for the forwarding field and the variable field.
683 unsigned int forwardingFieldOffset =
684 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
685 unsigned int varFieldOffset =
686 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
688 // Decode the original location, and use that as the start of the byref
689 // variable's location.
690 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
691 DIEBlock *Block = new DIEBlock();
693 if (Location.isReg()) {
695 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
697 Reg = Reg - dwarf::DW_OP_reg0;
698 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
699 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
703 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
705 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
706 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
709 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
712 // If we started with a pointer to the __Block_byref... struct, then
713 // the first thing we need to do is dereference the pointer (DW_OP_deref).
715 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
717 // Next add the offset for the '__forwarding' field:
718 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
719 // adding the offset if it's 0.
720 if (forwardingFieldOffset > 0) {
721 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
722 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
725 // Now dereference the __forwarding field to get to the real __Block_byref
726 // struct: DW_OP_deref.
727 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
729 // Now that we've got the real __Block_byref... struct, add the offset
730 // for the variable's field to get to the location of the actual variable:
731 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
732 if (varFieldOffset > 0) {
733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
734 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
737 // Now attach the location information to the DIE.
738 addBlock(Die, Attribute, 0, Block);
741 /// addAddress - Add an address attribute to a die based on the location
743 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
744 const MachineLocation &Location) {
745 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
746 DIEBlock *Block = new DIEBlock();
748 if (Location.isReg()) {
750 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
752 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
753 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
757 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
759 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
760 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
763 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
766 addBlock(Die, Attribute, 0, Block);
769 /// addToContextOwner - Add Die into the list of its context owner's children.
770 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
771 if (Context.isNull())
772 ModuleCU->addDie(Die);
773 else if (Context.isType()) {
774 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
775 ContextDIE->addChild(Die);
776 } else if (Context.isNameSpace()) {
777 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
778 ContextDIE->addChild(Die);
779 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
780 ContextDIE->addChild(Die);
782 ModuleCU->addDie(Die);
785 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
787 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
788 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
793 TyDIE = new DIE(dwarf::DW_TAG_base_type);
794 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
795 if (Ty.isBasicType())
796 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
797 else if (Ty.isCompositeType())
798 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
800 assert(Ty.isDerivedType() && "Unknown kind of DIType");
801 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
804 addToContextOwner(TyDIE, Ty.getContext());
808 /// addType - Add a new type attribute to the specified entity.
809 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
813 // Check for pre-existence.
814 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
815 // If it exists then use the existing value.
817 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
822 Entry = createDIEEntry();
823 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
826 DIE *Buffer = getOrCreateTypeDIE(Ty);
828 Entry->setEntry(Buffer);
829 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
832 /// constructTypeDIE - Construct basic type die from DIBasicType.
833 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
834 // Get core information.
835 StringRef Name = BTy.getName();
836 Buffer.setTag(dwarf::DW_TAG_base_type);
837 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
840 // Add name if not anonymous or intermediate type.
842 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
843 uint64_t Size = BTy.getSizeInBits() >> 3;
844 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
847 /// constructTypeDIE - Construct derived type die from DIDerivedType.
848 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
849 // Get core information.
850 StringRef Name = DTy.getName();
851 uint64_t Size = DTy.getSizeInBits() >> 3;
852 unsigned Tag = DTy.getTag();
854 // FIXME - Workaround for templates.
855 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
859 // Map to main type, void will not have a type.
860 DIType FromTy = DTy.getTypeDerivedFrom();
861 addType(&Buffer, FromTy);
863 // Add name if not anonymous or intermediate type.
865 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
867 // Add size if non-zero (derived types might be zero-sized.)
869 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
871 // Add source line info if available and TyDesc is not a forward declaration.
872 if (!DTy.isForwardDecl())
873 addSourceLine(&Buffer, &DTy);
876 /// constructTypeDIE - Construct type DIE from DICompositeType.
877 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
878 // Get core information.
879 StringRef Name = CTy.getName();
881 uint64_t Size = CTy.getSizeInBits() >> 3;
882 unsigned Tag = CTy.getTag();
886 case dwarf::DW_TAG_vector_type:
887 case dwarf::DW_TAG_array_type:
888 constructArrayTypeDIE(Buffer, &CTy);
890 case dwarf::DW_TAG_enumeration_type: {
891 DIArray Elements = CTy.getTypeArray();
893 // Add enumerators to enumeration type.
894 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
896 DIEnumerator Enum(Elements.getElement(i).getNode());
897 if (!Enum.isNull()) {
898 ElemDie = constructEnumTypeDIE(&Enum);
899 Buffer.addChild(ElemDie);
904 case dwarf::DW_TAG_subroutine_type: {
906 DIArray Elements = CTy.getTypeArray();
907 DIDescriptor RTy = Elements.getElement(0);
908 addType(&Buffer, DIType(RTy.getNode()));
910 // Add prototype flag.
911 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
914 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
915 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
916 DIDescriptor Ty = Elements.getElement(i);
917 addType(Arg, DIType(Ty.getNode()));
918 Buffer.addChild(Arg);
922 case dwarf::DW_TAG_structure_type:
923 case dwarf::DW_TAG_union_type:
924 case dwarf::DW_TAG_class_type: {
925 // Add elements to structure type.
926 DIArray Elements = CTy.getTypeArray();
928 // A forward struct declared type may not have elements available.
929 if (Elements.isNull())
932 // Add elements to structure type.
933 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
934 DIDescriptor Element = Elements.getElement(i);
935 if (Element.isNull())
938 if (Element.getTag() == dwarf::DW_TAG_subprogram)
939 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
941 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
942 Buffer.addChild(ElemDie);
945 if (CTy.isAppleBlockExtension())
946 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
948 unsigned RLang = CTy.getRunTimeLang();
950 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
951 dwarf::DW_FORM_data1, RLang);
953 DICompositeType ContainingType = CTy.getContainingType();
954 if (!ContainingType.isNull())
955 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
956 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
963 // Add name if not anonymous or intermediate type.
965 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
967 if (Tag == dwarf::DW_TAG_enumeration_type ||
968 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
969 // Add size if non-zero (derived types might be zero-sized.)
971 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
973 // Add zero size if it is not a forward declaration.
974 if (CTy.isForwardDecl())
975 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
977 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
980 // Add source line info if available.
981 if (!CTy.isForwardDecl())
982 addSourceLine(&Buffer, &CTy);
986 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
987 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
988 int64_t L = SR.getLo();
989 int64_t H = SR.getHi();
990 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
992 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
994 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
995 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
997 Buffer.addChild(DW_Subrange);
1000 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1001 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1002 DICompositeType *CTy) {
1003 Buffer.setTag(dwarf::DW_TAG_array_type);
1004 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1005 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1007 // Emit derived type.
1008 addType(&Buffer, CTy->getTypeDerivedFrom());
1009 DIArray Elements = CTy->getTypeArray();
1011 // Get an anonymous type for index type.
1012 DIE *IdxTy = ModuleCU->getIndexTyDie();
1014 // Construct an anonymous type for index type.
1015 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1016 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1017 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1018 dwarf::DW_ATE_signed);
1019 ModuleCU->addDie(IdxTy);
1020 ModuleCU->setIndexTyDie(IdxTy);
1023 // Add subranges to array type.
1024 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1025 DIDescriptor Element = Elements.getElement(i);
1026 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1027 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1031 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1032 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator *ETy) {
1033 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1034 StringRef Name = ETy->getName();
1035 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1036 int64_t Value = ETy->getEnumValue();
1037 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1041 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1042 /// printer to not emit usual symbol prefix before the symbol name is used then
1043 /// return linkage name after skipping this special LLVM prefix.
1044 static StringRef getRealLinkageName(StringRef LinkageName) {
1046 if (LinkageName.startswith(StringRef(&One, 1)))
1047 return LinkageName.substr(1);
1051 /// createGlobalVariableDIE - Create new DIE using GV.
1052 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1053 // If the global variable was optmized out then no need to create debug info
1055 if (!GV.getGlobal()) return NULL;
1056 if (GV.getDisplayName().empty()) return NULL;
1058 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1059 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1060 GV.getDisplayName());
1062 StringRef LinkageName = GV.getLinkageName();
1063 if (!LinkageName.empty())
1064 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1065 getRealLinkageName(LinkageName));
1067 addType(GVDie, GV.getType());
1068 if (!GV.isLocalToUnit())
1069 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1070 addSourceLine(GVDie, &GV);
1075 /// createMemberDIE - Create new member DIE.
1076 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1077 DIE *MemberDie = new DIE(DT.getTag());
1078 StringRef Name = DT.getName();
1080 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1082 addType(MemberDie, DT.getTypeDerivedFrom());
1084 addSourceLine(MemberDie, &DT);
1086 DIEBlock *MemLocationDie = new DIEBlock();
1087 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1089 uint64_t Size = DT.getSizeInBits();
1090 uint64_t FieldSize = DT.getOriginalTypeSize();
1092 if (Size != FieldSize) {
1094 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1095 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1097 uint64_t Offset = DT.getOffsetInBits();
1098 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1099 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1100 uint64_t FieldOffset = (HiMark - FieldSize);
1101 Offset -= FieldOffset;
1103 // Maybe we need to work from the other end.
1104 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1105 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1107 // Here WD_AT_data_member_location points to the anonymous
1108 // field that includes this bit field.
1109 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1112 // This is not a bitfield.
1113 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1115 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1117 if (DT.isProtected())
1118 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1119 dwarf::DW_ACCESS_protected);
1120 else if (DT.isPrivate())
1121 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1122 dwarf::DW_ACCESS_private);
1123 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1124 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1125 dwarf::DW_ACCESS_public);
1127 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1128 dwarf::DW_VIRTUALITY_virtual);
1132 /// createSubprogramDIE - Create new DIE using SP.
1133 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1134 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1138 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1139 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1141 StringRef LinkageName = SP.getLinkageName();
1142 if (!LinkageName.empty())
1143 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1144 getRealLinkageName(LinkageName));
1146 addSourceLine(SPDie, &SP);
1148 // Add prototyped tag, if C or ObjC.
1149 unsigned Lang = SP.getCompileUnit().getLanguage();
1150 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1151 Lang == dwarf::DW_LANG_ObjC)
1152 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1155 DICompositeType SPTy = SP.getType();
1156 DIArray Args = SPTy.getTypeArray();
1157 unsigned SPTag = SPTy.getTag();
1159 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1160 addType(SPDie, SPTy);
1162 addType(SPDie, DIType(Args.getElement(0).getNode()));
1164 unsigned VK = SP.getVirtuality();
1166 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1167 DIEBlock *Block = new DIEBlock();
1168 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1169 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1170 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1171 ContainingTypeMap.insert(std::make_pair(SPDie,
1172 SP.getContainingType().getNode()));
1175 if (MakeDecl || !SP.isDefinition()) {
1176 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1178 // Add arguments. Do not add arguments for subprogram definition. They will
1179 // be handled while processing variables.
1180 DICompositeType SPTy = SP.getType();
1181 DIArray Args = SPTy.getTypeArray();
1182 unsigned SPTag = SPTy.getTag();
1184 if (SPTag == dwarf::DW_TAG_subroutine_type)
1185 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1186 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1187 addType(Arg, DIType(Args.getElement(i).getNode()));
1188 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1189 SPDie->addChild(Arg);
1193 // DW_TAG_inlined_subroutine may refer to this DIE.
1194 ModuleCU->insertDIE(SP.getNode(), SPDie);
1198 /// findCompileUnit - Get the compile unit for the given descriptor.
1200 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1201 DenseMap<Value *, CompileUnit *>::const_iterator I =
1202 CompileUnitMap.find(Unit.getNode());
1203 if (I == CompileUnitMap.end())
1204 return constructCompileUnit(Unit.getNode());
1208 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1209 /// Initialize scope and update scope hierarchy.
1210 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1211 MDNode *InlinedAt) {
1212 assert (N && "Invalid Scope encoding!");
1213 assert (MI && "Missing machine instruction!");
1214 bool GetConcreteScope = (MI && InlinedAt);
1216 DbgScope *NScope = NULL;
1219 NScope = DbgScopeMap.lookup(InlinedAt);
1221 NScope = DbgScopeMap.lookup(N);
1222 assert (NScope && "Unable to find working scope!");
1224 if (NScope->getFirstInsn())
1227 DbgScope *Parent = NULL;
1228 if (GetConcreteScope) {
1229 DILocation IL(InlinedAt);
1230 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1231 IL.getOrigLocation().getNode());
1232 assert (Parent && "Unable to find Parent scope!");
1233 NScope->setParent(Parent);
1234 Parent->addScope(NScope);
1235 } else if (DIDescriptor(N).isLexicalBlock()) {
1236 DILexicalBlock DB(N);
1237 if (!DB.getContext().isNull()) {
1238 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1239 NScope->setParent(Parent);
1240 Parent->addScope(NScope);
1244 NScope->setFirstInsn(MI);
1246 if (!Parent && !InlinedAt) {
1247 StringRef SPName = DISubprogram(N).getLinkageName();
1248 if (SPName == MF->getFunction()->getName())
1249 CurrentFnDbgScope = NScope;
1252 if (GetConcreteScope) {
1253 ConcreteScopes[InlinedAt] = NScope;
1254 getOrCreateAbstractScope(N);
1260 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1261 assert (N && "Invalid Scope encoding!");
1263 DbgScope *AScope = AbstractScopes.lookup(N);
1267 DbgScope *Parent = NULL;
1269 DIDescriptor Scope(N);
1270 if (Scope.isLexicalBlock()) {
1271 DILexicalBlock DB(N);
1272 DIDescriptor ParentDesc = DB.getContext();
1273 if (!ParentDesc.isNull())
1274 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1277 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1280 Parent->addScope(AScope);
1281 AScope->setAbstractScope();
1282 AbstractScopes[N] = AScope;
1283 if (DIDescriptor(N).isSubprogram())
1284 AbstractScopesList.push_back(AScope);
1288 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1289 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1290 /// If there are global variables in this scope then create and insert
1291 /// DIEs for these variables.
1292 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1294 DIE *SPDie = ModuleCU->getDIE(SPNode);
1295 assert (SPDie && "Unable to find subprogram DIE!");
1296 DISubprogram SP(SPNode);
1297 if (SP.isDefinition() && !SP.getContext().isCompileUnit()) {
1298 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1300 DICompositeType SPTy = SP.getType();
1301 DIArray Args = SPTy.getTypeArray();
1302 unsigned SPTag = SPTy.getTag();
1303 if (SPTag == dwarf::DW_TAG_subroutine_type)
1304 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1305 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1306 addType(Arg, DIType(Args.getElement(i).getNode()));
1307 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1308 SPDie->addChild(Arg);
1310 DIE *SPDeclDie = SPDie;
1311 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1312 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1314 ModuleCU->addDie(SPDie);
1317 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1318 DWLabel("func_begin", SubprogramCount));
1319 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1320 DWLabel("func_end", SubprogramCount));
1321 MachineLocation Location(RI->getFrameRegister(*MF));
1322 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1324 if (!DISubprogram(SPNode).isLocalToUnit())
1325 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
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 DenseMap<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(getRealLinkageName(InlinedSP.getLinkageName()));
1402 DILocation DL(Scope->getInlinedAt());
1403 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1404 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1410 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1411 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1412 // Get the descriptor.
1413 const DIVariable &VD = DV->getVariable();
1414 StringRef 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(VariableDie, getBlockByrefType(VD.getType(), Name));
1462 addType(VariableDie, VD.getType());
1465 // Add variable address.
1466 if (!Scope->isAbstractScope()) {
1467 MachineLocation Location;
1469 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1470 Location.set(FrameReg, Offset);
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 void DwarfDebug::addPubTypes(DISubprogram SP) {
1485 DICompositeType SPTy = SP.getType();
1486 unsigned SPTag = SPTy.getTag();
1487 if (SPTag != dwarf::DW_TAG_subroutine_type)
1490 DIArray Args = SPTy.getTypeArray();
1494 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1495 DIType ATy(Args.getElement(i).getNode());
1498 DICompositeType CATy = getDICompositeType(ATy);
1499 if (!CATy.isNull() && !CATy.getName().empty()) {
1500 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1501 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1506 /// constructScopeDIE - Construct a DIE for this scope.
1507 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1510 DIScope DS(Scope->getScopeNode());
1514 DIE *ScopeDIE = NULL;
1515 if (Scope->getInlinedAt())
1516 ScopeDIE = constructInlinedScopeDIE(Scope);
1517 else if (DS.isSubprogram()) {
1518 if (Scope->isAbstractScope())
1519 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1521 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1524 ScopeDIE = constructLexicalScopeDIE(Scope);
1525 if (!ScopeDIE) return NULL;
1528 // Add variables to scope.
1529 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1530 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1531 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1533 ScopeDIE->addChild(VariableDIE);
1536 // Add nested scopes.
1537 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1538 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1539 // Define the Scope debug information entry.
1540 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1542 ScopeDIE->addChild(NestedDIE);
1545 if (DS.isSubprogram())
1546 addPubTypes(DISubprogram(DS.getNode()));
1551 /// GetOrCreateSourceID - Look up the source id with the given directory and
1552 /// source file names. If none currently exists, create a new id and insert it
1553 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1555 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1557 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1558 if (DI != DirectoryIdMap.end()) {
1559 DId = DI->getValue();
1561 DId = DirectoryNames.size() + 1;
1562 DirectoryIdMap[DirName] = DId;
1563 DirectoryNames.push_back(DirName);
1567 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1568 if (FI != SourceFileIdMap.end()) {
1569 FId = FI->getValue();
1571 FId = SourceFileNames.size() + 1;
1572 SourceFileIdMap[FileName] = FId;
1573 SourceFileNames.push_back(FileName);
1576 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1577 SourceIdMap.find(std::make_pair(DId, FId));
1578 if (SI != SourceIdMap.end())
1581 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1582 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1583 SourceIds.push_back(std::make_pair(DId, FId));
1588 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1589 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1590 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1593 NDie = new DIE(dwarf::DW_TAG_namespace);
1594 ModuleCU->insertDIE(NS.getNode(), NDie);
1595 if (!NS.getName().empty())
1596 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1597 addSourceLine(NDie, &NS);
1598 addToContextOwner(NDie, NS.getContext());
1602 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1603 DICompileUnit DIUnit(N);
1604 StringRef FN = DIUnit.getFilename();
1605 StringRef Dir = DIUnit.getDirectory();
1606 unsigned ID = GetOrCreateSourceID(Dir, FN);
1608 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1609 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1610 DWLabel("section_line", 0), DWLabel("section_line", 0),
1612 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1613 DIUnit.getProducer());
1614 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1615 DIUnit.getLanguage());
1616 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1619 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1620 if (DIUnit.isOptimized())
1621 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1623 StringRef Flags = DIUnit.getFlags();
1625 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1627 unsigned RVer = DIUnit.getRunTimeVersion();
1629 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1630 dwarf::DW_FORM_data1, RVer);
1632 CompileUnit *Unit = new CompileUnit(ID, Die);
1633 if (!ModuleCU && DIUnit.isMain()) {
1634 // Use first compile unit marked as isMain as the compile unit
1639 CompileUnitMap[DIUnit.getNode()] = Unit;
1640 CompileUnits.push_back(Unit);
1644 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1645 DIGlobalVariable DI_GV(N);
1647 // If debug information is malformed then ignore it.
1648 if (DI_GV.Verify() == false)
1651 // Check for pre-existence.
1652 if (ModuleCU->getDIE(DI_GV.getNode()))
1655 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1660 ModuleCU->insertDIE(N, VariableDie);
1662 // Add to context owner.
1663 DIDescriptor GVContext = DI_GV.getContext();
1664 // Do not create specification DIE if context is either compile unit
1666 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1667 && !GVContext.isSubprogram()) {
1668 // Create specification DIE.
1669 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1670 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1671 dwarf::DW_FORM_ref4, VariableDie);
1672 DIEBlock *Block = new DIEBlock();
1673 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1674 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1675 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1676 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1677 ModuleCU->addDie(VariableSpecDIE);
1679 DIEBlock *Block = new DIEBlock();
1680 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1681 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1682 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1683 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1685 addToContextOwner(VariableDie, GVContext);
1687 // Expose as global. FIXME - need to check external flag.
1688 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1690 DIType GTy = DI_GV.getType();
1691 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1692 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1693 assert (Entry && "Missing global type!");
1694 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1699 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1702 // Check for pre-existence.
1703 if (ModuleCU->getDIE(N))
1706 if (!SP.isDefinition())
1707 // This is a method declaration which will be handled while constructing
1711 DIE *SubprogramDie = createSubprogramDIE(SP);
1714 ModuleCU->insertDIE(N, SubprogramDie);
1716 // Add to context owner.
1717 addToContextOwner(SubprogramDie, SP.getContext());
1719 // Expose as global.
1720 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1725 /// beginModule - Emit all Dwarf sections that should come prior to the
1726 /// content. Create global DIEs and emit initial debug info sections.
1727 /// This is inovked by the target AsmPrinter.
1728 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1731 if (TimePassesIsEnabled)
1732 DebugTimer->startTimer();
1734 if (!MAI->doesSupportDebugInformation())
1737 DebugInfoFinder DbgFinder;
1738 DbgFinder.processModule(*M);
1740 // Create all the compile unit DIEs.
1741 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1742 E = DbgFinder.compile_unit_end(); I != E; ++I)
1743 constructCompileUnit(*I);
1745 if (CompileUnits.empty()) {
1746 if (TimePassesIsEnabled)
1747 DebugTimer->stopTimer();
1752 // If main compile unit for this module is not seen than randomly
1753 // select first compile unit.
1755 ModuleCU = CompileUnits[0];
1757 // Create DIEs for each subprogram.
1758 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1759 E = DbgFinder.subprogram_end(); I != E; ++I)
1760 constructSubprogramDIE(*I);
1762 // Create DIEs for each global variable.
1763 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1764 E = DbgFinder.global_variable_end(); I != E; ++I)
1765 constructGlobalVariableDIE(*I);
1769 MMI->setDebugInfoAvailability(true);
1771 // Prime section data.
1772 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1774 // Print out .file directives to specify files for .loc directives. These are
1775 // printed out early so that they precede any .loc directives.
1776 if (MAI->hasDotLocAndDotFile()) {
1777 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1778 // Remember source id starts at 1.
1779 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1780 // FIXME: don't use sys::path for this! This should not depend on the
1782 sys::Path FullPath(getSourceDirectoryName(Id.first));
1784 FullPath.appendComponent(getSourceFileName(Id.second));
1785 assert(AppendOk && "Could not append filename to directory!");
1787 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1791 // Emit initial sections
1794 if (TimePassesIsEnabled)
1795 DebugTimer->stopTimer();
1798 /// endModule - Emit all Dwarf sections that should come after the content.
1800 void DwarfDebug::endModule() {
1804 if (TimePassesIsEnabled)
1805 DebugTimer->startTimer();
1807 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1808 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1809 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1811 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1814 // Insert top level DIEs.
1815 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1816 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1817 ModuleCU->getCUDie()->addChild(*TI);
1819 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1820 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1821 DIE *SPDie = CI->first;
1822 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1824 DIE *NDie = ModuleCU->getDIE(N);
1825 if (!NDie) continue;
1826 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1827 // FIXME - This is not the correct approach.
1828 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1831 // Standard sections final addresses.
1832 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1833 EmitLabel("text_end", 0);
1834 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1835 EmitLabel("data_end", 0);
1837 // End text sections.
1838 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1839 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1840 EmitLabel("section_end", i);
1843 // Emit common frame information.
1844 emitCommonDebugFrame();
1846 // Emit function debug frame information
1847 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1848 E = DebugFrames.end(); I != E; ++I)
1849 emitFunctionDebugFrame(*I);
1851 // Compute DIE offsets and sizes.
1852 computeSizeAndOffsets();
1854 // Emit all the DIEs into a debug info section
1857 // Corresponding abbreviations into a abbrev section.
1858 emitAbbreviations();
1860 // Emit source line correspondence into a debug line section.
1863 // Emit info into a debug pubnames section.
1864 emitDebugPubNames();
1866 // Emit info into a debug pubtypes section.
1867 emitDebugPubTypes();
1869 // Emit info into a debug str section.
1872 // Emit info into a debug loc section.
1875 // Emit info into a debug aranges section.
1878 // Emit info into a debug ranges section.
1881 // Emit info into a debug macinfo section.
1884 // Emit inline info.
1885 emitDebugInlineInfo();
1887 if (TimePassesIsEnabled)
1888 DebugTimer->stopTimer();
1891 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1892 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1894 DILocation &ScopeLoc) {
1896 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1898 return AbsDbgVariable;
1900 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1904 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1905 Scope->addVariable(AbsDbgVariable);
1906 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1907 return AbsDbgVariable;
1910 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1911 void DwarfDebug::collectVariableInfo() {
1914 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1915 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1916 VE = VMap.end(); VI != VE; ++VI) {
1917 MDNode *Var = VI->first;
1919 DIVariable DV (Var);
1920 std::pair< unsigned, MDNode *> VP = VI->second;
1921 DILocation ScopeLoc(VP.second);
1924 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1926 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1927 // If variable scope is not found then skip this variable.
1931 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1932 Scope->addVariable(RegVar);
1933 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1935 RegVar->setAbstractVariable(AbsDbgVariable);
1939 /// beginScope - Process beginning of a scope starting at Label.
1940 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1941 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1942 if (I == DbgScopeBeginMap.end())
1944 ScopeVector &SD = I->second;
1945 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1947 (*SDI)->setStartLabelID(Label);
1950 /// endScope - Process end of a scope.
1951 void DwarfDebug::endScope(const MachineInstr *MI) {
1952 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1953 if (I == DbgScopeEndMap.end())
1956 unsigned Label = MMI->NextLabelID();
1957 Asm->printLabel(Label);
1960 SmallVector<DbgScope *, 2> &SD = I->second;
1961 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1963 (*SDI)->setEndLabelID(Label);
1967 /// createDbgScope - Create DbgScope for the scope.
1968 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1971 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1974 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1975 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1976 if (DIDescriptor(Scope).isLexicalBlock())
1977 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1981 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1985 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1986 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1987 DILocation DL(InlinedAt);
1988 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1991 /// extractScopeInformation - Scan machine instructions in this function
1992 /// and collect DbgScopes. Return true, if atleast one scope was found.
1993 bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
1994 // If scope information was extracted using .dbg intrinsics then there is not
1995 // any need to extract these information by scanning each instruction.
1996 if (!DbgScopeMap.empty())
1999 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2000 unsigned MIIndex = 0;
2001 // Scan each instruction and create scopes. First build working set of scopes.
2002 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2004 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2006 const MachineInstr *MInsn = II;
2007 MIIndexMap[MInsn] = MIIndex++;
2008 DebugLoc DL = MInsn->getDebugLoc();
2009 if (DL.isUnknown()) continue;
2010 DILocation DLT = MF->getDILocation(DL);
2011 DIScope DLTScope = DLT.getScope();
2012 if (DLTScope.isNull()) continue;
2013 // There is no need to create another DIE for compile unit. For all
2014 // other scopes, create one DbgScope now. This will be translated
2015 // into a scope DIE at the end.
2016 if (DLTScope.isCompileUnit()) continue;
2017 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2022 // Build scope hierarchy using working set of scopes.
2023 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2025 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2027 const MachineInstr *MInsn = II;
2028 DebugLoc DL = MInsn->getDebugLoc();
2029 if (DL.isUnknown()) continue;
2030 DILocation DLT = MF->getDILocation(DL);
2031 DIScope DLTScope = DLT.getScope();
2032 if (DLTScope.isNull()) continue;
2033 // There is no need to create another DIE for compile unit. For all
2034 // other scopes, create one DbgScope now. This will be translated
2035 // into a scope DIE at the end.
2036 if (DLTScope.isCompileUnit()) continue;
2037 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2038 DLT.getOrigLocation().getNode());
2039 Scope->setLastInsn(MInsn);
2043 if (!CurrentFnDbgScope)
2046 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2048 // Each scope has first instruction and last instruction to mark beginning
2049 // and end of a scope respectively. Create an inverse map that list scopes
2050 // starts (and ends) with an instruction. One instruction may start (or end)
2051 // multiple scopes. Ignore scopes that are not reachable.
2052 SmallVector<DbgScope *, 4> WorkList;
2053 WorkList.push_back(CurrentFnDbgScope);
2054 while (!WorkList.empty()) {
2055 DbgScope *S = WorkList.back(); WorkList.pop_back();
2057 SmallVector<DbgScope *, 4> &Children = S->getScopes();
2058 if (!Children.empty())
2059 for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2060 SE = Children.end(); SI != SE; ++SI)
2061 WorkList.push_back(*SI);
2063 if (S->isAbstractScope())
2065 const MachineInstr *MI = S->getFirstInsn();
2066 assert (MI && "DbgScope does not have first instruction!");
2068 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2069 if (IDI != DbgScopeBeginMap.end())
2070 IDI->second.push_back(S);
2072 DbgScopeBeginMap[MI].push_back(S);
2074 MI = S->getLastInsn();
2075 assert (MI && "DbgScope does not have last instruction!");
2076 IDI = DbgScopeEndMap.find(MI);
2077 if (IDI != DbgScopeEndMap.end())
2078 IDI->second.push_back(S);
2080 DbgScopeEndMap[MI].push_back(S);
2083 return !DbgScopeMap.empty();
2086 /// beginFunction - Gather pre-function debug information. Assumes being
2087 /// emitted immediately after the function entry point.
2088 void DwarfDebug::beginFunction(MachineFunction *MF) {
2091 if (!ShouldEmitDwarfDebug()) return;
2093 if (TimePassesIsEnabled)
2094 DebugTimer->startTimer();
2096 if (!extractScopeInformation(MF))
2099 collectVariableInfo();
2101 // Begin accumulating function debug information.
2102 MMI->BeginFunction(MF);
2104 // Assumes in correct section after the entry point.
2105 EmitLabel("func_begin", ++SubprogramCount);
2107 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2109 DebugLoc FDL = MF->getDefaultDebugLoc();
2110 if (!FDL.isUnknown()) {
2111 DILocation DLT = MF->getDILocation(FDL);
2112 unsigned LabelID = 0;
2113 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2115 LabelID = recordSourceLine(SP.getLineNumber(), 0,
2116 DLT.getScope().getNode());
2118 LabelID = recordSourceLine(DLT.getLineNumber(),
2119 DLT.getColumnNumber(),
2120 DLT.getScope().getNode());
2121 Asm->printLabel(LabelID);
2124 if (TimePassesIsEnabled)
2125 DebugTimer->stopTimer();
2128 /// endFunction - Gather and emit post-function debug information.
2130 void DwarfDebug::endFunction(MachineFunction *MF) {
2131 if (!ShouldEmitDwarfDebug()) return;
2133 if (TimePassesIsEnabled)
2134 DebugTimer->startTimer();
2136 if (DbgScopeMap.empty())
2139 if (CurrentFnDbgScope) {
2140 // Define end label for subprogram.
2141 EmitLabel("func_end", SubprogramCount);
2143 // Get function line info.
2144 if (!Lines.empty()) {
2145 // Get section line info.
2146 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2147 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2148 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2149 // Append the function info to section info.
2150 SectionLineInfos.insert(SectionLineInfos.end(),
2151 Lines.begin(), Lines.end());
2154 // Construct abstract scopes.
2155 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2156 AE = AbstractScopesList.end(); AI != AE; ++AI)
2157 constructScopeDIE(*AI);
2159 constructScopeDIE(CurrentFnDbgScope);
2161 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2162 MMI->getFrameMoves()));
2166 CurrentFnDbgScope = NULL;
2167 DbgScopeMap.clear();
2168 DbgScopeBeginMap.clear();
2169 DbgScopeEndMap.clear();
2170 ConcreteScopes.clear();
2171 AbstractScopesList.clear();
2174 if (TimePassesIsEnabled)
2175 DebugTimer->stopTimer();
2178 /// recordSourceLine - Records location information and associates it with a
2179 /// label. Returns a unique label ID used to generate a label and provide
2180 /// correspondence to the source line list.
2181 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2186 if (TimePassesIsEnabled)
2187 DebugTimer->startTimer();
2192 DIDescriptor Scope(S);
2193 if (Scope.isCompileUnit()) {
2194 DICompileUnit CU(S);
2195 Dir = CU.getDirectory();
2196 Fn = CU.getFilename();
2197 } else if (Scope.isSubprogram()) {
2199 Dir = SP.getDirectory();
2200 Fn = SP.getFilename();
2201 } else if (Scope.isLexicalBlock()) {
2202 DILexicalBlock DB(S);
2203 Dir = DB.getDirectory();
2204 Fn = DB.getFilename();
2206 assert (0 && "Unexpected scope info");
2208 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2209 unsigned ID = MMI->NextLabelID();
2210 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2212 if (TimePassesIsEnabled)
2213 DebugTimer->stopTimer();
2218 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2219 /// timed. Look up the source id with the given directory and source file
2220 /// names. If none currently exists, create a new id and insert it in the
2221 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2223 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2224 const std::string &FileName) {
2225 if (TimePassesIsEnabled)
2226 DebugTimer->startTimer();
2228 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2230 if (TimePassesIsEnabled)
2231 DebugTimer->stopTimer();
2236 //===----------------------------------------------------------------------===//
2238 //===----------------------------------------------------------------------===//
2240 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2243 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2244 // Get the children.
2245 const std::vector<DIE *> &Children = Die->getChildren();
2247 // If not last sibling and has children then add sibling offset attribute.
2248 if (!Last && !Children.empty()) Die->addSiblingOffset();
2250 // Record the abbreviation.
2251 assignAbbrevNumber(Die->getAbbrev());
2253 // Get the abbreviation for this DIE.
2254 unsigned AbbrevNumber = Die->getAbbrevNumber();
2255 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2258 Die->setOffset(Offset);
2260 // Start the size with the size of abbreviation code.
2261 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2263 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2264 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2266 // Size the DIE attribute values.
2267 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2268 // Size attribute value.
2269 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2271 // Size the DIE children if any.
2272 if (!Children.empty()) {
2273 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2274 "Children flag not set");
2276 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2277 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2279 // End of children marker.
2280 Offset += sizeof(int8_t);
2283 Die->setSize(Offset - Die->getOffset());
2287 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2289 void DwarfDebug::computeSizeAndOffsets() {
2290 // Compute size of compile unit header.
2291 static unsigned Offset =
2292 sizeof(int32_t) + // Length of Compilation Unit Info
2293 sizeof(int16_t) + // DWARF version number
2294 sizeof(int32_t) + // Offset Into Abbrev. Section
2295 sizeof(int8_t); // Pointer Size (in bytes)
2297 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2298 CompileUnitOffsets[ModuleCU] = 0;
2301 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2302 /// tools to recognize the object file contains Dwarf information.
2303 void DwarfDebug::emitInitial() {
2304 // Check to see if we already emitted intial headers.
2305 if (didInitial) return;
2308 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2310 // Dwarf sections base addresses.
2311 if (MAI->doesDwarfRequireFrameSection()) {
2312 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2313 EmitLabel("section_debug_frame", 0);
2316 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2317 EmitLabel("section_info", 0);
2318 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2319 EmitLabel("section_abbrev", 0);
2320 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2321 EmitLabel("section_aranges", 0);
2323 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2324 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2325 EmitLabel("section_macinfo", 0);
2328 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2329 EmitLabel("section_line", 0);
2330 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2331 EmitLabel("section_loc", 0);
2332 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2333 EmitLabel("section_pubnames", 0);
2334 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2335 EmitLabel("section_pubtypes", 0);
2336 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2337 EmitLabel("section_str", 0);
2338 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2339 EmitLabel("section_ranges", 0);
2341 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2342 EmitLabel("text_begin", 0);
2343 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2344 EmitLabel("data_begin", 0);
2347 /// emitDIE - Recusively Emits a debug information entry.
2349 void DwarfDebug::emitDIE(DIE *Die) {
2350 // Get the abbreviation for this DIE.
2351 unsigned AbbrevNumber = Die->getAbbrevNumber();
2352 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2356 // Emit the code (index) for the abbreviation.
2357 if (Asm->VerboseAsm)
2358 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2359 Twine::utohexstr(Die->getOffset()) + ":0x" +
2360 Twine::utohexstr(Die->getSize()) + " " +
2361 dwarf::TagString(Abbrev->getTag()));
2362 EmitULEB128(AbbrevNumber);
2364 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2365 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2367 // Emit the DIE attribute values.
2368 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2369 unsigned Attr = AbbrevData[i].getAttribute();
2370 unsigned Form = AbbrevData[i].getForm();
2371 assert(Form && "Too many attributes for DIE (check abbreviation)");
2373 if (Asm->VerboseAsm)
2374 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2377 case dwarf::DW_AT_sibling:
2378 Asm->EmitInt32(Die->getSiblingOffset());
2380 case dwarf::DW_AT_abstract_origin: {
2381 DIEEntry *E = cast<DIEEntry>(Values[i]);
2382 DIE *Origin = E->getEntry();
2383 unsigned Addr = Origin->getOffset();
2384 Asm->EmitInt32(Addr);
2388 // Emit an attribute using the defined form.
2389 Values[i]->EmitValue(this, Form);
2390 O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2395 // Emit the DIE children if any.
2396 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2397 const std::vector<DIE *> &Children = Die->getChildren();
2399 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2400 emitDIE(Children[j]);
2402 Asm->EmitInt8(0); EOL("End Of Children Mark");
2406 /// emitDebugInfo - Emit the debug info section.
2408 void DwarfDebug::emitDebugInfo() {
2409 // Start debug info section.
2410 Asm->OutStreamer.SwitchSection(
2411 Asm->getObjFileLowering().getDwarfInfoSection());
2412 DIE *Die = ModuleCU->getCUDie();
2414 // Emit the compile units header.
2415 EmitLabel("info_begin", ModuleCU->getID());
2417 // Emit size of content not including length itself
2418 unsigned ContentSize = Die->getSize() +
2419 sizeof(int16_t) + // DWARF version number
2420 sizeof(int32_t) + // Offset Into Abbrev. Section
2421 sizeof(int8_t) + // Pointer Size (in bytes)
2422 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2424 Asm->EmitInt32(ContentSize); EOL("Length of Compilation Unit Info");
2425 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2426 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2427 EOL("Offset Into Abbrev. Section");
2428 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2431 // FIXME - extra padding for gdb bug.
2432 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2433 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2434 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2435 Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2436 EmitLabel("info_end", ModuleCU->getID());
2440 /// emitAbbreviations - Emit the abbreviation section.
2442 void DwarfDebug::emitAbbreviations() const {
2443 // Check to see if it is worth the effort.
2444 if (!Abbreviations.empty()) {
2445 // Start the debug abbrev section.
2446 Asm->OutStreamer.SwitchSection(
2447 Asm->getObjFileLowering().getDwarfAbbrevSection());
2449 EmitLabel("abbrev_begin", 0);
2451 // For each abbrevation.
2452 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2453 // Get abbreviation data
2454 const DIEAbbrev *Abbrev = Abbreviations[i];
2456 // Emit the abbrevations code (base 1 index.)
2457 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2459 // Emit the abbreviations data.
2464 // Mark end of abbreviations.
2465 EmitULEB128(0, "EOM(3)");
2467 EmitLabel("abbrev_end", 0);
2472 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2473 /// the line matrix.
2475 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2476 // Define last address of section.
2477 Asm->EmitInt8(0); EOL("Extended Op");
2478 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2479 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2480 EmitReference("section_end", SectionEnd); EOL("Section end label");
2482 // Mark end of matrix.
2483 Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2488 /// emitDebugLines - Emit source line information.
2490 void DwarfDebug::emitDebugLines() {
2491 // If the target is using .loc/.file, the assembler will be emitting the
2492 // .debug_line table automatically.
2493 if (MAI->hasDotLocAndDotFile())
2496 // Minimum line delta, thus ranging from -10..(255-10).
2497 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2498 // Maximum line delta, thus ranging from -10..(255-10).
2499 const int MaxLineDelta = 255 + MinLineDelta;
2501 // Start the dwarf line section.
2502 Asm->OutStreamer.SwitchSection(
2503 Asm->getObjFileLowering().getDwarfLineSection());
2505 // Construct the section header.
2506 EmitDifference("line_end", 0, "line_begin", 0, true);
2507 EOL("Length of Source Line Info");
2508 EmitLabel("line_begin", 0);
2510 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2512 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2513 EOL("Prolog Length");
2514 EmitLabel("line_prolog_begin", 0);
2516 Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2517 Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2518 Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2519 Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2520 Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2522 // Line number standard opcode encodings argument count
2523 Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2524 Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2525 Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2526 Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2527 Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2528 Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2529 Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2530 Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2531 Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2533 // Emit directories.
2534 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2535 const std::string &Dir = getSourceDirectoryName(DI);
2536 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2537 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2540 Asm->EmitInt8(0); EOL("End of directories");
2543 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2544 // Remember source id starts at 1.
2545 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2546 const std::string &FN = getSourceFileName(Id.second);
2547 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2548 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2550 EmitULEB128(Id.first, "Directory #");
2551 EmitULEB128(0, "Mod date");
2552 EmitULEB128(0, "File size");
2555 Asm->EmitInt8(0); EOL("End of files");
2557 EmitLabel("line_prolog_end", 0);
2559 // A sequence for each text section.
2560 unsigned SecSrcLinesSize = SectionSourceLines.size();
2562 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2563 // Isolate current sections line info.
2564 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2566 /*if (Asm->isVerbose()) {
2567 const MCSection *S = SectionMap[j + 1];
2568 O << '\t' << MAI->getCommentString() << " Section"
2569 << S->getName() << '\n';
2573 // Dwarf assumes we start with first line of first source file.
2574 unsigned Source = 1;
2577 // Construct rows of the address, source, line, column matrix.
2578 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2579 const SrcLineInfo &LineInfo = LineInfos[i];
2580 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2581 if (!LabelID) continue;
2583 if (LineInfo.getLine() == 0) continue;
2585 if (!Asm->isVerbose())
2588 std::pair<unsigned, unsigned> SourceID =
2589 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2590 O << '\t' << MAI->getCommentString() << ' '
2591 << getSourceDirectoryName(SourceID.first) << '/'
2592 << getSourceFileName(SourceID.second)
2593 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2596 // Define the line address.
2597 Asm->EmitInt8(0); EOL("Extended Op");
2598 Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2599 Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2600 EmitReference("label", LabelID); EOL("Location label");
2602 // If change of source, then switch to the new source.
2603 if (Source != LineInfo.getSourceID()) {
2604 Source = LineInfo.getSourceID();
2605 Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2606 EmitULEB128(Source, "New Source");
2609 // If change of line.
2610 if (Line != LineInfo.getLine()) {
2611 // Determine offset.
2612 int Offset = LineInfo.getLine() - Line;
2613 int Delta = Offset - MinLineDelta;
2616 Line = LineInfo.getLine();
2618 // If delta is small enough and in range...
2619 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2620 // ... then use fast opcode.
2621 Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2623 // ... otherwise use long hand.
2624 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2625 EOL("DW_LNS_advance_line");
2626 EmitSLEB128(Offset, "Line Offset");
2627 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2630 // Copy the previous row (different address or source)
2631 Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2635 emitEndOfLineMatrix(j + 1);
2638 if (SecSrcLinesSize == 0)
2639 // Because we're emitting a debug_line section, we still need a line
2640 // table. The linker and friends expect it to exist. If there's nothing to
2641 // put into it, emit an empty table.
2642 emitEndOfLineMatrix(1);
2644 EmitLabel("line_end", 0);
2648 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2650 void DwarfDebug::emitCommonDebugFrame() {
2651 if (!MAI->doesDwarfRequireFrameSection())
2655 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2656 TargetFrameInfo::StackGrowsUp ?
2657 TD->getPointerSize() : -TD->getPointerSize();
2659 // Start the dwarf frame section.
2660 Asm->OutStreamer.SwitchSection(
2661 Asm->getObjFileLowering().getDwarfFrameSection());
2663 EmitLabel("debug_frame_common", 0);
2664 EmitDifference("debug_frame_common_end", 0,
2665 "debug_frame_common_begin", 0, true);
2666 EOL("Length of Common Information Entry");
2668 EmitLabel("debug_frame_common_begin", 0);
2669 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2670 EOL("CIE Identifier Tag");
2671 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2673 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2674 EOL("CIE Augmentation");
2675 EmitULEB128(1, "CIE Code Alignment Factor");
2676 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2677 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2678 EOL("CIE RA Column");
2680 std::vector<MachineMove> Moves;
2681 RI->getInitialFrameState(Moves);
2683 EmitFrameMoves(NULL, 0, Moves, false);
2685 Asm->EmitAlignment(2, 0, 0, false);
2686 EmitLabel("debug_frame_common_end", 0);
2690 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2693 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2694 if (!MAI->doesDwarfRequireFrameSection())
2697 // Start the dwarf frame section.
2698 Asm->OutStreamer.SwitchSection(
2699 Asm->getObjFileLowering().getDwarfFrameSection());
2701 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2702 "debug_frame_begin", DebugFrameInfo.Number, true);
2703 EOL("Length of Frame Information Entry");
2705 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2707 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2709 EOL("FDE CIE offset");
2711 EmitReference("func_begin", DebugFrameInfo.Number);
2712 EOL("FDE initial location");
2713 EmitDifference("func_end", DebugFrameInfo.Number,
2714 "func_begin", DebugFrameInfo.Number);
2715 EOL("FDE address range");
2717 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2720 Asm->EmitAlignment(2, 0, 0, false);
2721 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2725 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2727 void DwarfDebug::emitDebugPubNames() {
2728 // Start the dwarf pubnames section.
2729 Asm->OutStreamer.SwitchSection(
2730 Asm->getObjFileLowering().getDwarfPubNamesSection());
2732 EmitDifference("pubnames_end", ModuleCU->getID(),
2733 "pubnames_begin", ModuleCU->getID(), true);
2734 EOL("Length of Public Names Info");
2736 EmitLabel("pubnames_begin", ModuleCU->getID());
2738 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2740 EmitSectionOffset("info_begin", "section_info",
2741 ModuleCU->getID(), 0, true, false);
2742 EOL("Offset of Compilation Unit Info");
2744 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2746 EOL("Compilation Unit Length");
2748 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2749 for (StringMap<DIE*>::const_iterator
2750 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2751 const char *Name = GI->getKeyData();
2752 DIE * Entity = GI->second;
2754 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2756 if (Asm->VerboseAsm)
2757 Asm->OutStreamer.AddComment("External Name");
2758 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2761 Asm->EmitInt32(0); EOL("End Mark");
2762 EmitLabel("pubnames_end", ModuleCU->getID());
2766 void DwarfDebug::emitDebugPubTypes() {
2767 // Start the dwarf pubnames section.
2768 Asm->OutStreamer.SwitchSection(
2769 Asm->getObjFileLowering().getDwarfPubTypesSection());
2770 EmitDifference("pubtypes_end", ModuleCU->getID(),
2771 "pubtypes_begin", ModuleCU->getID(), true);
2772 EOL("Length of Public Types Info");
2774 EmitLabel("pubtypes_begin", ModuleCU->getID());
2776 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2778 EmitSectionOffset("info_begin", "section_info",
2779 ModuleCU->getID(), 0, true, false);
2780 EOL("Offset of Compilation ModuleCU Info");
2782 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2784 EOL("Compilation ModuleCU Length");
2786 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2787 for (StringMap<DIE*>::const_iterator
2788 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2789 const char *Name = GI->getKeyData();
2790 DIE * Entity = GI->second;
2792 Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2794 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2795 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)), 0);
2798 Asm->EmitInt32(0); EOL("End Mark");
2799 EmitLabel("pubtypes_end", ModuleCU->getID());
2803 /// emitDebugStr - Emit visible names into a debug str section.
2805 void DwarfDebug::emitDebugStr() {
2806 // Check to see if it is worth the effort.
2807 if (!StringPool.empty()) {
2808 // Start the dwarf str section.
2809 Asm->OutStreamer.SwitchSection(
2810 Asm->getObjFileLowering().getDwarfStrSection());
2812 // For each of strings in the string pool.
2813 for (unsigned StringID = 1, N = StringPool.size();
2814 StringID <= N; ++StringID) {
2815 // Emit a label for reference from debug information entries.
2816 EmitLabel("string", StringID);
2818 // Emit the string itself.
2819 const std::string &String = StringPool[StringID];
2820 Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2827 /// emitDebugLoc - Emit visible names into a debug loc section.
2829 void DwarfDebug::emitDebugLoc() {
2830 // Start the dwarf loc section.
2831 Asm->OutStreamer.SwitchSection(
2832 Asm->getObjFileLowering().getDwarfLocSection());
2835 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2837 void DwarfDebug::EmitDebugARanges() {
2838 // Start the dwarf aranges section.
2839 Asm->OutStreamer.SwitchSection(
2840 Asm->getObjFileLowering().getDwarfARangesSection());
2844 CompileUnit *Unit = GetBaseCompileUnit();
2846 // Don't include size of length
2847 Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2849 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2851 EmitReference("info_begin", Unit->getID());
2852 EOL("Offset of Compilation Unit Info");
2854 Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2856 Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2858 Asm->EmitInt16(0); EOL("Pad (1)");
2859 Asm->EmitInt16(0); EOL("Pad (2)");
2862 EmitReference("text_begin", 0); EOL("Address");
2863 EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
2865 Asm->EmitInt32(0); EOL("EOM (1)");
2866 Asm->EmitInt32(0); EOL("EOM (2)");
2870 /// emitDebugRanges - Emit visible names into a debug ranges section.
2872 void DwarfDebug::emitDebugRanges() {
2873 // Start the dwarf ranges section.
2874 Asm->OutStreamer.SwitchSection(
2875 Asm->getObjFileLowering().getDwarfRangesSection());
2878 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2880 void DwarfDebug::emitDebugMacInfo() {
2881 if (const MCSection *LineInfo =
2882 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2883 // Start the dwarf macinfo section.
2884 Asm->OutStreamer.SwitchSection(LineInfo);
2888 /// emitDebugInlineInfo - Emit inline info using following format.
2890 /// 1. length of section
2891 /// 2. Dwarf version number
2892 /// 3. address size.
2894 /// Entries (one "entry" for each function that was inlined):
2896 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2897 /// otherwise offset into __debug_str for regular function name.
2898 /// 2. offset into __debug_str section for regular function name.
2899 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2900 /// instances for the function.
2902 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2903 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2904 /// __debug_info section, and the low_pc is the starting address for the
2905 /// inlining instance.
2906 void DwarfDebug::emitDebugInlineInfo() {
2907 if (!MAI->doesDwarfUsesInlineInfoSection())
2913 Asm->OutStreamer.SwitchSection(
2914 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2916 EmitDifference("debug_inlined_end", 1,
2917 "debug_inlined_begin", 1, true);
2918 EOL("Length of Debug Inlined Information Entry");
2920 EmitLabel("debug_inlined_begin", 1);
2922 Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2923 Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2925 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2926 E = InlinedSPNodes.end(); I != E; ++I) {
2929 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2930 = InlineInfo.find(Node);
2931 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2932 DISubprogram SP(Node);
2933 StringRef LName = SP.getLinkageName();
2934 StringRef Name = SP.getName();
2936 if (LName.empty()) {
2937 Asm->OutStreamer.EmitBytes(Name, 0);
2938 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2940 EmitSectionOffset("string", "section_str",
2941 StringPool.idFor(getRealLinkageName(LName)), false, true);
2943 EOL("MIPS linkage name");
2944 EmitSectionOffset("string", "section_str",
2945 StringPool.idFor(Name), false, true);
2946 EOL("Function name");
2947 EmitULEB128(Labels.size(), "Inline count");
2949 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2950 LE = Labels.end(); LI != LE; ++LI) {
2951 DIE *SP = LI->second;
2952 Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
2954 if (TD->getPointerSize() == sizeof(int32_t))
2955 O << MAI->getData32bitsDirective();
2957 O << MAI->getData64bitsDirective();
2959 PrintLabelName("label", LI->first); EOL("low_pc");
2963 EmitLabel("debug_inlined_end", 1);