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,
347 const StringRef String) {
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);
958 // Add name if not anonymous or intermediate type.
960 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
962 if (Tag == dwarf::DW_TAG_enumeration_type ||
963 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
964 // Add size if non-zero (derived types might be zero-sized.)
966 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
968 // Add zero size if it is not a forward declaration.
969 if (CTy.isForwardDecl())
970 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
972 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
975 // Add source line info if available.
976 if (!CTy.isForwardDecl())
977 addSourceLine(&Buffer, &CTy);
981 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
982 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
983 int64_t L = SR.getLo();
984 int64_t H = SR.getHi();
985 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
987 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
989 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
990 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
992 Buffer.addChild(DW_Subrange);
995 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
996 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
997 DICompositeType *CTy) {
998 Buffer.setTag(dwarf::DW_TAG_array_type);
999 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1000 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1002 // Emit derived type.
1003 addType(&Buffer, CTy->getTypeDerivedFrom());
1004 DIArray Elements = CTy->getTypeArray();
1006 // Get an anonymous type for index type.
1007 DIE *IdxTy = ModuleCU->getIndexTyDie();
1009 // Construct an anonymous type for index type.
1010 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1011 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1012 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1013 dwarf::DW_ATE_signed);
1014 ModuleCU->addDie(IdxTy);
1015 ModuleCU->setIndexTyDie(IdxTy);
1018 // Add subranges to array type.
1019 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1020 DIDescriptor Element = Elements.getElement(i);
1021 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1022 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1026 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1027 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator *ETy) {
1028 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1029 StringRef Name = ETy->getName();
1030 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1031 int64_t Value = ETy->getEnumValue();
1032 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1036 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1037 /// printer to not emit usual symbol prefix before the symbol name is used then
1038 /// return linkage name after skipping this special LLVM prefix.
1039 static StringRef getRealLinkageName(StringRef LinkageName) {
1041 if (LinkageName.startswith(StringRef(&One, 1)))
1042 return LinkageName.substr(1);
1046 /// createGlobalVariableDIE - Create new DIE using GV.
1047 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1048 // If the global variable was optmized out then no need to create debug info
1050 if (!GV.getGlobal()) return NULL;
1051 if (GV.getDisplayName().empty()) return NULL;
1053 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1054 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1055 GV.getDisplayName());
1057 StringRef LinkageName = GV.getLinkageName();
1058 if (!LinkageName.empty())
1059 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1060 getRealLinkageName(LinkageName));
1062 addType(GVDie, GV.getType());
1063 if (!GV.isLocalToUnit())
1064 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1065 addSourceLine(GVDie, &GV);
1070 /// createMemberDIE - Create new member DIE.
1071 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1072 DIE *MemberDie = new DIE(DT.getTag());
1073 StringRef Name = DT.getName();
1075 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1077 addType(MemberDie, DT.getTypeDerivedFrom());
1079 addSourceLine(MemberDie, &DT);
1081 DIEBlock *MemLocationDie = new DIEBlock();
1082 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1084 uint64_t Size = DT.getSizeInBits();
1085 uint64_t FieldSize = DT.getOriginalTypeSize();
1087 if (Size != FieldSize) {
1089 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1090 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1092 uint64_t Offset = DT.getOffsetInBits();
1093 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1094 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1095 uint64_t FieldOffset = (HiMark - FieldSize);
1096 Offset -= FieldOffset;
1098 // Maybe we need to work from the other end.
1099 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1100 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1102 // Here WD_AT_data_member_location points to the anonymous
1103 // field that includes this bit field.
1104 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1107 // This is not a bitfield.
1108 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1110 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1112 if (DT.isProtected())
1113 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1114 dwarf::DW_ACCESS_protected);
1115 else if (DT.isPrivate())
1116 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1117 dwarf::DW_ACCESS_private);
1118 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1119 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1120 dwarf::DW_ACCESS_public);
1122 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1123 dwarf::DW_VIRTUALITY_virtual);
1127 /// createSubprogramDIE - Create new DIE using SP.
1128 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1129 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1133 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1134 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1136 StringRef LinkageName = SP.getLinkageName();
1137 if (!LinkageName.empty())
1138 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1139 getRealLinkageName(LinkageName));
1141 addSourceLine(SPDie, &SP);
1143 // Add prototyped tag, if C or ObjC.
1144 unsigned Lang = SP.getCompileUnit().getLanguage();
1145 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1146 Lang == dwarf::DW_LANG_ObjC)
1147 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1150 DICompositeType SPTy = SP.getType();
1151 DIArray Args = SPTy.getTypeArray();
1152 unsigned SPTag = SPTy.getTag();
1154 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1155 addType(SPDie, SPTy);
1157 addType(SPDie, DIType(Args.getElement(0).getNode()));
1159 unsigned VK = SP.getVirtuality();
1161 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1162 DIEBlock *Block = new DIEBlock();
1163 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1164 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1165 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1166 ContainingTypeMap.insert(std::make_pair(SPDie,
1167 SP.getContainingType().getNode()));
1170 if (MakeDecl || !SP.isDefinition()) {
1171 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1173 // Add arguments. Do not add arguments for subprogram definition. They will
1174 // be handled while processing variables.
1175 DICompositeType SPTy = SP.getType();
1176 DIArray Args = SPTy.getTypeArray();
1177 unsigned SPTag = SPTy.getTag();
1179 if (SPTag == dwarf::DW_TAG_subroutine_type)
1180 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1181 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1182 addType(Arg, DIType(Args.getElement(i).getNode()));
1183 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1184 SPDie->addChild(Arg);
1188 // DW_TAG_inlined_subroutine may refer to this DIE.
1189 ModuleCU->insertDIE(SP.getNode(), SPDie);
1193 /// findCompileUnit - Get the compile unit for the given descriptor.
1195 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1196 DenseMap<Value *, CompileUnit *>::const_iterator I =
1197 CompileUnitMap.find(Unit.getNode());
1198 if (I == CompileUnitMap.end())
1199 return constructCompileUnit(Unit.getNode());
1203 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1204 /// Initialize scope and update scope hierarchy.
1205 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1206 MDNode *InlinedAt) {
1207 assert (N && "Invalid Scope encoding!");
1208 assert (MI && "Missing machine instruction!");
1209 bool GetConcreteScope = (MI && InlinedAt);
1211 DbgScope *NScope = NULL;
1214 NScope = DbgScopeMap.lookup(InlinedAt);
1216 NScope = DbgScopeMap.lookup(N);
1217 assert (NScope && "Unable to find working scope!");
1219 if (NScope->getFirstInsn())
1222 DbgScope *Parent = NULL;
1223 if (GetConcreteScope) {
1224 DILocation IL(InlinedAt);
1225 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1226 IL.getOrigLocation().getNode());
1227 assert (Parent && "Unable to find Parent scope!");
1228 NScope->setParent(Parent);
1229 Parent->addScope(NScope);
1230 } else if (DIDescriptor(N).isLexicalBlock()) {
1231 DILexicalBlock DB(N);
1232 if (!DB.getContext().isNull()) {
1233 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1234 NScope->setParent(Parent);
1235 Parent->addScope(NScope);
1239 NScope->setFirstInsn(MI);
1241 if (!Parent && !InlinedAt) {
1242 StringRef SPName = DISubprogram(N).getLinkageName();
1243 if (SPName == MF->getFunction()->getName())
1244 CurrentFnDbgScope = NScope;
1247 if (GetConcreteScope) {
1248 ConcreteScopes[InlinedAt] = NScope;
1249 getOrCreateAbstractScope(N);
1255 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1256 assert (N && "Invalid Scope encoding!");
1258 DbgScope *AScope = AbstractScopes.lookup(N);
1262 DbgScope *Parent = NULL;
1264 DIDescriptor Scope(N);
1265 if (Scope.isLexicalBlock()) {
1266 DILexicalBlock DB(N);
1267 DIDescriptor ParentDesc = DB.getContext();
1268 if (!ParentDesc.isNull())
1269 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1272 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1275 Parent->addScope(AScope);
1276 AScope->setAbstractScope();
1277 AbstractScopes[N] = AScope;
1278 if (DIDescriptor(N).isSubprogram())
1279 AbstractScopesList.push_back(AScope);
1283 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1284 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1285 /// If there are global variables in this scope then create and insert
1286 /// DIEs for these variables.
1287 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1289 DIE *SPDie = ModuleCU->getDIE(SPNode);
1290 assert (SPDie && "Unable to find subprogram DIE!");
1291 DISubprogram SP(SPNode);
1292 if (SP.isDefinition() && !SP.getContext().isCompileUnit()) {
1293 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1295 DICompositeType SPTy = SP.getType();
1296 DIArray Args = SPTy.getTypeArray();
1297 unsigned SPTag = SPTy.getTag();
1298 if (SPTag == dwarf::DW_TAG_subroutine_type)
1299 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1300 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1301 addType(Arg, DIType(Args.getElement(i).getNode()));
1302 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1303 SPDie->addChild(Arg);
1305 DIE *SPDeclDie = SPDie;
1306 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1307 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1309 ModuleCU->addDie(SPDie);
1312 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1313 DWLabel("func_begin", SubprogramCount));
1314 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1315 DWLabel("func_end", SubprogramCount));
1316 MachineLocation Location(RI->getFrameRegister(*MF));
1317 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1319 if (!DISubprogram(SPNode).isLocalToUnit())
1320 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1325 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1326 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1327 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1328 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1329 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1331 // Ignore empty scopes.
1332 if (StartID == EndID && StartID != 0)
1335 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1336 if (Scope->isAbstractScope())
1339 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1341 DWLabel("label", StartID)
1342 : DWLabel("func_begin", SubprogramCount));
1343 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1345 DWLabel("label", EndID)
1346 : DWLabel("func_end", SubprogramCount));
1353 /// constructInlinedScopeDIE - This scope represents inlined body of
1354 /// a function. Construct DIE to represent this concrete inlined copy
1355 /// of the function.
1356 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1357 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1358 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1359 assert (StartID && "Invalid starting label for an inlined scope!");
1360 assert (EndID && "Invalid end label for an inlined scope!");
1361 // Ignore empty scopes.
1362 if (StartID == EndID && StartID != 0)
1365 DIScope DS(Scope->getScopeNode());
1368 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1370 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1371 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1372 assert (OriginDIE && "Unable to find Origin DIE!");
1373 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1374 dwarf::DW_FORM_ref4, OriginDIE);
1376 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1377 DWLabel("label", StartID));
1378 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1379 DWLabel("label", EndID));
1381 InlinedSubprogramDIEs.insert(OriginDIE);
1383 // Track the start label for this inlined function.
1384 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1385 I = InlineInfo.find(InlinedSP.getNode());
1387 if (I == InlineInfo.end()) {
1388 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1390 InlinedSPNodes.push_back(InlinedSP.getNode());
1392 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1394 StringPool.insert(InlinedSP.getName());
1395 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1397 DILocation DL(Scope->getInlinedAt());
1398 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1399 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1405 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1406 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1407 // Get the descriptor.
1408 const DIVariable &VD = DV->getVariable();
1409 StringRef Name = VD.getName();
1413 // Translate tag to proper Dwarf tag. The result variable is dropped for
1416 switch (VD.getTag()) {
1417 case dwarf::DW_TAG_return_variable:
1419 case dwarf::DW_TAG_arg_variable:
1420 Tag = dwarf::DW_TAG_formal_parameter;
1422 case dwarf::DW_TAG_auto_variable: // fall thru
1424 Tag = dwarf::DW_TAG_variable;
1428 // Define variable debug information entry.
1429 DIE *VariableDie = new DIE(Tag);
1433 if (DbgVariable *AV = DV->getAbstractVariable())
1434 AbsDIE = AV->getDIE();
1437 DIScope DS(Scope->getScopeNode());
1438 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1439 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1441 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1442 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1443 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1444 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1445 dwarf::DW_FORM_ref4, AbsDIE);
1448 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1449 addSourceLine(VariableDie, &VD);
1451 // Add variable type.
1452 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1453 // addresses instead.
1454 if (VD.isBlockByrefVariable())
1455 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1457 addType(VariableDie, VD.getType());
1460 // Add variable address.
1461 if (!Scope->isAbstractScope()) {
1462 MachineLocation Location;
1464 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1465 Location.set(FrameReg, Offset);
1467 if (VD.hasComplexAddress())
1468 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1469 else if (VD.isBlockByrefVariable())
1470 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1472 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1474 DV->setDIE(VariableDie);
1479 void DwarfDebug::addPubTypes(DISubprogram SP) {
1480 DICompositeType SPTy = SP.getType();
1481 unsigned SPTag = SPTy.getTag();
1482 if (SPTag != dwarf::DW_TAG_subroutine_type)
1485 DIArray Args = SPTy.getTypeArray();
1489 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1490 DIType ATy(Args.getElement(i).getNode());
1493 DICompositeType CATy = getDICompositeType(ATy);
1494 if (!CATy.isNull() && !CATy.getName().empty()) {
1495 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1496 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1501 /// constructScopeDIE - Construct a DIE for this scope.
1502 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1505 DIScope DS(Scope->getScopeNode());
1509 DIE *ScopeDIE = NULL;
1510 if (Scope->getInlinedAt())
1511 ScopeDIE = constructInlinedScopeDIE(Scope);
1512 else if (DS.isSubprogram()) {
1513 if (Scope->isAbstractScope())
1514 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1516 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1519 ScopeDIE = constructLexicalScopeDIE(Scope);
1520 if (!ScopeDIE) return NULL;
1523 // Add variables to scope.
1524 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1525 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1526 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1528 ScopeDIE->addChild(VariableDIE);
1531 // Add nested scopes.
1532 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1533 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1534 // Define the Scope debug information entry.
1535 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1537 ScopeDIE->addChild(NestedDIE);
1540 if (DS.isSubprogram())
1541 addPubTypes(DISubprogram(DS.getNode()));
1546 /// GetOrCreateSourceID - Look up the source id with the given directory and
1547 /// source file names. If none currently exists, create a new id and insert it
1548 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1550 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1552 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1553 if (DI != DirectoryIdMap.end()) {
1554 DId = DI->getValue();
1556 DId = DirectoryNames.size() + 1;
1557 DirectoryIdMap[DirName] = DId;
1558 DirectoryNames.push_back(DirName);
1562 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1563 if (FI != SourceFileIdMap.end()) {
1564 FId = FI->getValue();
1566 FId = SourceFileNames.size() + 1;
1567 SourceFileIdMap[FileName] = FId;
1568 SourceFileNames.push_back(FileName);
1571 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1572 SourceIdMap.find(std::make_pair(DId, FId));
1573 if (SI != SourceIdMap.end())
1576 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1577 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1578 SourceIds.push_back(std::make_pair(DId, FId));
1583 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1584 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1585 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1588 NDie = new DIE(dwarf::DW_TAG_namespace);
1589 ModuleCU->insertDIE(NS.getNode(), NDie);
1590 if (!NS.getName().empty())
1591 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1592 addSourceLine(NDie, &NS);
1593 addToContextOwner(NDie, NS.getContext());
1597 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1598 DICompileUnit DIUnit(N);
1599 StringRef FN = DIUnit.getFilename();
1600 StringRef Dir = DIUnit.getDirectory();
1601 unsigned ID = GetOrCreateSourceID(Dir, FN);
1603 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1604 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1605 DWLabel("section_line", 0), DWLabel("section_line", 0),
1607 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1608 DIUnit.getProducer());
1609 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1610 DIUnit.getLanguage());
1611 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1614 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1615 if (DIUnit.isOptimized())
1616 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1618 StringRef Flags = DIUnit.getFlags();
1620 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1622 unsigned RVer = DIUnit.getRunTimeVersion();
1624 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1625 dwarf::DW_FORM_data1, RVer);
1627 CompileUnit *Unit = new CompileUnit(ID, Die);
1628 if (!ModuleCU && DIUnit.isMain()) {
1629 // Use first compile unit marked as isMain as the compile unit
1634 CompileUnitMap[DIUnit.getNode()] = Unit;
1635 CompileUnits.push_back(Unit);
1639 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1640 DIGlobalVariable DI_GV(N);
1642 // If debug information is malformed then ignore it.
1643 if (DI_GV.Verify() == false)
1646 // Check for pre-existence.
1647 if (ModuleCU->getDIE(DI_GV.getNode()))
1650 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1655 ModuleCU->insertDIE(N, VariableDie);
1657 // Add to context owner.
1658 DIDescriptor GVContext = DI_GV.getContext();
1659 // Do not create specification DIE if context is either compile unit
1661 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1662 && !GVContext.isSubprogram()) {
1663 // Create specification DIE.
1664 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1665 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1666 dwarf::DW_FORM_ref4, VariableDie);
1667 DIEBlock *Block = new DIEBlock();
1668 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1669 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1670 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1671 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1672 ModuleCU->addDie(VariableSpecDIE);
1674 DIEBlock *Block = new DIEBlock();
1675 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1676 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1677 Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1678 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1680 addToContextOwner(VariableDie, GVContext);
1682 // Expose as global. FIXME - need to check external flag.
1683 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1685 DIType GTy = DI_GV.getType();
1686 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1687 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1688 assert (Entry && "Missing global type!");
1689 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1694 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1697 // Check for pre-existence.
1698 if (ModuleCU->getDIE(N))
1701 if (!SP.isDefinition())
1702 // This is a method declaration which will be handled while constructing
1706 DIE *SubprogramDie = createSubprogramDIE(SP);
1709 ModuleCU->insertDIE(N, SubprogramDie);
1711 // Add to context owner.
1712 addToContextOwner(SubprogramDie, SP.getContext());
1714 // Expose as global.
1715 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1720 /// beginModule - Emit all Dwarf sections that should come prior to the
1721 /// content. Create global DIEs and emit initial debug info sections.
1722 /// This is inovked by the target AsmPrinter.
1723 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1726 if (TimePassesIsEnabled)
1727 DebugTimer->startTimer();
1729 if (!MAI->doesSupportDebugInformation())
1732 DebugInfoFinder DbgFinder;
1733 DbgFinder.processModule(*M);
1735 // Create all the compile unit DIEs.
1736 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1737 E = DbgFinder.compile_unit_end(); I != E; ++I)
1738 constructCompileUnit(*I);
1740 if (CompileUnits.empty()) {
1741 if (TimePassesIsEnabled)
1742 DebugTimer->stopTimer();
1747 // If main compile unit for this module is not seen than randomly
1748 // select first compile unit.
1750 ModuleCU = CompileUnits[0];
1752 // Create DIEs for each subprogram.
1753 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1754 E = DbgFinder.subprogram_end(); I != E; ++I)
1755 constructSubprogramDIE(*I);
1757 // Create DIEs for each global variable.
1758 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1759 E = DbgFinder.global_variable_end(); I != E; ++I)
1760 constructGlobalVariableDIE(*I);
1764 MMI->setDebugInfoAvailability(true);
1766 // Prime section data.
1767 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1769 // Print out .file directives to specify files for .loc directives. These are
1770 // printed out early so that they precede any .loc directives.
1771 if (MAI->hasDotLocAndDotFile()) {
1772 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1773 // Remember source id starts at 1.
1774 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1775 // FIXME: don't use sys::path for this! This should not depend on the
1777 sys::Path FullPath(getSourceDirectoryName(Id.first));
1779 FullPath.appendComponent(getSourceFileName(Id.second));
1780 assert(AppendOk && "Could not append filename to directory!");
1782 Asm->EmitFile(i, FullPath.str());
1787 // Emit initial sections
1790 if (TimePassesIsEnabled)
1791 DebugTimer->stopTimer();
1794 /// endModule - Emit all Dwarf sections that should come after the content.
1796 void DwarfDebug::endModule() {
1800 if (TimePassesIsEnabled)
1801 DebugTimer->startTimer();
1803 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1804 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1805 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1807 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1810 // Insert top level DIEs.
1811 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1812 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1813 ModuleCU->getCUDie()->addChild(*TI);
1815 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1816 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1817 DIE *SPDie = CI->first;
1818 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1820 DIE *NDie = ModuleCU->getDIE(N);
1821 if (!NDie) continue;
1822 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1823 // FIXME - This is not the correct approach.
1824 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1827 // Standard sections final addresses.
1828 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1829 EmitLabel("text_end", 0);
1830 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1831 EmitLabel("data_end", 0);
1833 // End text sections.
1834 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1835 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1836 EmitLabel("section_end", i);
1839 // Emit common frame information.
1840 emitCommonDebugFrame();
1842 // Emit function debug frame information
1843 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1844 E = DebugFrames.end(); I != E; ++I)
1845 emitFunctionDebugFrame(*I);
1847 // Compute DIE offsets and sizes.
1848 computeSizeAndOffsets();
1850 // Emit all the DIEs into a debug info section
1853 // Corresponding abbreviations into a abbrev section.
1854 emitAbbreviations();
1856 // Emit source line correspondence into a debug line section.
1859 // Emit info into a debug pubnames section.
1860 emitDebugPubNames();
1862 // Emit info into a debug pubtypes section.
1863 emitDebugPubTypes();
1865 // Emit info into a debug str section.
1868 // Emit info into a debug loc section.
1871 // Emit info into a debug aranges section.
1874 // Emit info into a debug ranges section.
1877 // Emit info into a debug macinfo section.
1880 // Emit inline info.
1881 emitDebugInlineInfo();
1883 if (TimePassesIsEnabled)
1884 DebugTimer->stopTimer();
1887 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1888 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1890 DILocation &ScopeLoc) {
1892 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1894 return AbsDbgVariable;
1896 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1900 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1901 Scope->addVariable(AbsDbgVariable);
1902 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1903 return AbsDbgVariable;
1906 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1907 void DwarfDebug::collectVariableInfo() {
1910 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1911 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1912 VE = VMap.end(); VI != VE; ++VI) {
1913 MetadataBase *MB = VI->first;
1914 MDNode *Var = dyn_cast_or_null<MDNode>(MB);
1916 DIVariable DV (Var);
1917 std::pair< unsigned, MDNode *> VP = VI->second;
1918 DILocation ScopeLoc(VP.second);
1921 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1923 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1924 // If variable scope is not found then skip this variable.
1928 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1929 Scope->addVariable(RegVar);
1930 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1932 RegVar->setAbstractVariable(AbsDbgVariable);
1936 /// beginScope - Process beginning of a scope starting at Label.
1937 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1938 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1939 if (I == DbgScopeBeginMap.end())
1941 ScopeVector &SD = I->second;
1942 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1944 (*SDI)->setStartLabelID(Label);
1947 /// endScope - Process end of a scope.
1948 void DwarfDebug::endScope(const MachineInstr *MI) {
1949 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1950 if (I == DbgScopeEndMap.end())
1953 unsigned Label = MMI->NextLabelID();
1954 Asm->printLabel(Label);
1957 SmallVector<DbgScope *, 2> &SD = I->second;
1958 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1960 (*SDI)->setEndLabelID(Label);
1964 /// createDbgScope - Create DbgScope for the scope.
1965 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1968 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1971 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1972 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1973 if (DIDescriptor(Scope).isLexicalBlock())
1974 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1978 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1982 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1983 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1984 DILocation DL(InlinedAt);
1985 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1988 /// extractScopeInformation - Scan machine instructions in this function
1989 /// and collect DbgScopes. Return true, if atleast one scope was found.
1990 bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
1991 // If scope information was extracted using .dbg intrinsics then there is not
1992 // any need to extract these information by scanning each instruction.
1993 if (!DbgScopeMap.empty())
1996 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
1997 unsigned MIIndex = 0;
1998 // Scan each instruction and create scopes. First build working set of scopes.
1999 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2001 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2003 const MachineInstr *MInsn = II;
2004 MIIndexMap[MInsn] = MIIndex++;
2005 DebugLoc DL = MInsn->getDebugLoc();
2006 if (DL.isUnknown()) continue;
2007 DILocation DLT = MF->getDILocation(DL);
2008 DIScope DLTScope = DLT.getScope();
2009 if (DLTScope.isNull()) continue;
2010 // There is no need to create another DIE for compile unit. For all
2011 // other scopes, create one DbgScope now. This will be translated
2012 // into a scope DIE at the end.
2013 if (DLTScope.isCompileUnit()) continue;
2014 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2019 // Build scope hierarchy using working set of scopes.
2020 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2022 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2024 const MachineInstr *MInsn = II;
2025 DebugLoc DL = MInsn->getDebugLoc();
2026 if (DL.isUnknown()) continue;
2027 DILocation DLT = MF->getDILocation(DL);
2028 DIScope DLTScope = DLT.getScope();
2029 if (DLTScope.isNull()) continue;
2030 // There is no need to create another DIE for compile unit. For all
2031 // other scopes, create one DbgScope now. This will be translated
2032 // into a scope DIE at the end.
2033 if (DLTScope.isCompileUnit()) continue;
2034 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2035 DLT.getOrigLocation().getNode());
2036 Scope->setLastInsn(MInsn);
2040 if (!CurrentFnDbgScope)
2043 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2045 // Each scope has first instruction and last instruction to mark beginning
2046 // and end of a scope respectively. Create an inverse map that list scopes
2047 // starts (and ends) with an instruction. One instruction may start (or end)
2048 // multiple scopes. Ignore scopes that are not reachable.
2049 SmallVector<DbgScope *, 4> WorkList;
2050 WorkList.push_back(CurrentFnDbgScope);
2051 while (!WorkList.empty()) {
2052 DbgScope *S = WorkList.back(); WorkList.pop_back();
2054 SmallVector<DbgScope *, 4> &Children = S->getScopes();
2055 if (!Children.empty())
2056 for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2057 SE = Children.end(); SI != SE; ++SI)
2058 WorkList.push_back(*SI);
2060 if (S->isAbstractScope())
2062 const MachineInstr *MI = S->getFirstInsn();
2063 assert (MI && "DbgScope does not have first instruction!");
2065 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2066 if (IDI != DbgScopeBeginMap.end())
2067 IDI->second.push_back(S);
2069 DbgScopeBeginMap[MI].push_back(S);
2071 MI = S->getLastInsn();
2072 assert (MI && "DbgScope does not have last instruction!");
2073 IDI = DbgScopeEndMap.find(MI);
2074 if (IDI != DbgScopeEndMap.end())
2075 IDI->second.push_back(S);
2077 DbgScopeEndMap[MI].push_back(S);
2080 return !DbgScopeMap.empty();
2083 /// beginFunction - Gather pre-function debug information. Assumes being
2084 /// emitted immediately after the function entry point.
2085 void DwarfDebug::beginFunction(MachineFunction *MF) {
2088 if (!ShouldEmitDwarfDebug()) return;
2090 if (TimePassesIsEnabled)
2091 DebugTimer->startTimer();
2093 if (!extractScopeInformation(MF))
2096 collectVariableInfo();
2098 // Begin accumulating function debug information.
2099 MMI->BeginFunction(MF);
2101 // Assumes in correct section after the entry point.
2102 EmitLabel("func_begin", ++SubprogramCount);
2104 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2106 DebugLoc FDL = MF->getDefaultDebugLoc();
2107 if (!FDL.isUnknown()) {
2108 DILocation DLT = MF->getDILocation(FDL);
2109 unsigned LabelID = 0;
2110 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2112 LabelID = recordSourceLine(SP.getLineNumber(), 0,
2113 DLT.getScope().getNode());
2115 LabelID = recordSourceLine(DLT.getLineNumber(),
2116 DLT.getColumnNumber(),
2117 DLT.getScope().getNode());
2118 Asm->printLabel(LabelID);
2121 if (TimePassesIsEnabled)
2122 DebugTimer->stopTimer();
2125 /// endFunction - Gather and emit post-function debug information.
2127 void DwarfDebug::endFunction(MachineFunction *MF) {
2128 if (!ShouldEmitDwarfDebug()) return;
2130 if (TimePassesIsEnabled)
2131 DebugTimer->startTimer();
2133 if (DbgScopeMap.empty())
2136 if (CurrentFnDbgScope) {
2137 // Define end label for subprogram.
2138 EmitLabel("func_end", SubprogramCount);
2140 // Get function line info.
2141 if (!Lines.empty()) {
2142 // Get section line info.
2143 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2144 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2145 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2146 // Append the function info to section info.
2147 SectionLineInfos.insert(SectionLineInfos.end(),
2148 Lines.begin(), Lines.end());
2151 // Construct abstract scopes.
2152 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2153 AE = AbstractScopesList.end(); AI != AE; ++AI)
2154 constructScopeDIE(*AI);
2156 constructScopeDIE(CurrentFnDbgScope);
2158 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2159 MMI->getFrameMoves()));
2163 CurrentFnDbgScope = NULL;
2164 DbgScopeMap.clear();
2165 DbgScopeBeginMap.clear();
2166 DbgScopeEndMap.clear();
2167 ConcreteScopes.clear();
2168 AbstractScopesList.clear();
2171 if (TimePassesIsEnabled)
2172 DebugTimer->stopTimer();
2175 /// recordSourceLine - Records location information and associates it with a
2176 /// label. Returns a unique label ID used to generate a label and provide
2177 /// correspondence to the source line list.
2178 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2183 if (TimePassesIsEnabled)
2184 DebugTimer->startTimer();
2189 DIDescriptor Scope(S);
2190 if (Scope.isCompileUnit()) {
2191 DICompileUnit CU(S);
2192 Dir = CU.getDirectory();
2193 Fn = CU.getFilename();
2194 } else if (Scope.isSubprogram()) {
2196 Dir = SP.getDirectory();
2197 Fn = SP.getFilename();
2198 } else if (Scope.isLexicalBlock()) {
2199 DILexicalBlock DB(S);
2200 Dir = DB.getDirectory();
2201 Fn = DB.getFilename();
2203 assert (0 && "Unexpected scope info");
2205 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2206 unsigned ID = MMI->NextLabelID();
2207 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2209 if (TimePassesIsEnabled)
2210 DebugTimer->stopTimer();
2215 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2216 /// timed. Look up the source id with the given directory and source file
2217 /// names. If none currently exists, create a new id and insert it in the
2218 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2220 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2221 const std::string &FileName) {
2222 if (TimePassesIsEnabled)
2223 DebugTimer->startTimer();
2225 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2227 if (TimePassesIsEnabled)
2228 DebugTimer->stopTimer();
2233 //===----------------------------------------------------------------------===//
2235 //===----------------------------------------------------------------------===//
2237 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2240 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2241 // Get the children.
2242 const std::vector<DIE *> &Children = Die->getChildren();
2244 // If not last sibling and has children then add sibling offset attribute.
2245 if (!Last && !Children.empty()) Die->addSiblingOffset();
2247 // Record the abbreviation.
2248 assignAbbrevNumber(Die->getAbbrev());
2250 // Get the abbreviation for this DIE.
2251 unsigned AbbrevNumber = Die->getAbbrevNumber();
2252 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2255 Die->setOffset(Offset);
2257 // Start the size with the size of abbreviation code.
2258 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2260 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2261 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2263 // Size the DIE attribute values.
2264 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2265 // Size attribute value.
2266 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2268 // Size the DIE children if any.
2269 if (!Children.empty()) {
2270 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2271 "Children flag not set");
2273 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2274 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2276 // End of children marker.
2277 Offset += sizeof(int8_t);
2280 Die->setSize(Offset - Die->getOffset());
2284 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2286 void DwarfDebug::computeSizeAndOffsets() {
2287 // Compute size of compile unit header.
2288 static unsigned Offset =
2289 sizeof(int32_t) + // Length of Compilation Unit Info
2290 sizeof(int16_t) + // DWARF version number
2291 sizeof(int32_t) + // Offset Into Abbrev. Section
2292 sizeof(int8_t); // Pointer Size (in bytes)
2294 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2295 CompileUnitOffsets[ModuleCU] = 0;
2298 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2299 /// tools to recognize the object file contains Dwarf information.
2300 void DwarfDebug::emitInitial() {
2301 // Check to see if we already emitted intial headers.
2302 if (didInitial) return;
2305 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2307 // Dwarf sections base addresses.
2308 if (MAI->doesDwarfRequireFrameSection()) {
2309 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2310 EmitLabel("section_debug_frame", 0);
2313 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2314 EmitLabel("section_info", 0);
2315 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2316 EmitLabel("section_abbrev", 0);
2317 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2318 EmitLabel("section_aranges", 0);
2320 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2321 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2322 EmitLabel("section_macinfo", 0);
2325 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2326 EmitLabel("section_line", 0);
2327 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2328 EmitLabel("section_loc", 0);
2329 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2330 EmitLabel("section_pubnames", 0);
2331 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2332 EmitLabel("section_pubtypes", 0);
2333 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2334 EmitLabel("section_str", 0);
2335 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2336 EmitLabel("section_ranges", 0);
2338 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2339 EmitLabel("text_begin", 0);
2340 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2341 EmitLabel("data_begin", 0);
2344 /// emitDIE - Recusively Emits a debug information entry.
2346 void DwarfDebug::emitDIE(DIE *Die) {
2347 // Get the abbreviation for this DIE.
2348 unsigned AbbrevNumber = Die->getAbbrevNumber();
2349 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2353 // Emit the code (index) for the abbreviation.
2354 Asm->EmitULEB128Bytes(AbbrevNumber);
2356 Asm->EOL("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2357 Twine::utohexstr(Die->getOffset()) + ":0x" +
2358 Twine::utohexstr(Die->getSize()) + " " +
2359 dwarf::TagString(Abbrev->getTag()));
2361 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2362 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2364 // Emit the DIE attribute values.
2365 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2366 unsigned Attr = AbbrevData[i].getAttribute();
2367 unsigned Form = AbbrevData[i].getForm();
2368 assert(Form && "Too many attributes for DIE (check abbreviation)");
2371 case dwarf::DW_AT_sibling:
2372 Asm->EmitInt32(Die->getSiblingOffset());
2374 case dwarf::DW_AT_abstract_origin: {
2375 DIEEntry *E = cast<DIEEntry>(Values[i]);
2376 DIE *Origin = E->getEntry();
2377 unsigned Addr = Origin->getOffset();
2378 Asm->EmitInt32(Addr);
2382 // Emit an attribute using the defined form.
2383 Values[i]->EmitValue(this, Form);
2387 Asm->EOL(dwarf::AttributeString(Attr));
2390 // Emit the DIE children if any.
2391 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2392 const std::vector<DIE *> &Children = Die->getChildren();
2394 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2395 emitDIE(Children[j]);
2397 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2401 /// emitDebugInfo - Emit the debug info section.
2403 void DwarfDebug::emitDebugInfo() {
2404 // Start debug info section.
2405 Asm->OutStreamer.SwitchSection(
2406 Asm->getObjFileLowering().getDwarfInfoSection());
2407 DIE *Die = ModuleCU->getCUDie();
2409 // Emit the compile units header.
2410 EmitLabel("info_begin", ModuleCU->getID());
2412 // Emit size of content not including length itself
2413 unsigned ContentSize = Die->getSize() +
2414 sizeof(int16_t) + // DWARF version number
2415 sizeof(int32_t) + // Offset Into Abbrev. Section
2416 sizeof(int8_t) + // Pointer Size (in bytes)
2417 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2419 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
2420 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2421 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2422 Asm->EOL("Offset Into Abbrev. Section");
2423 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2426 // FIXME - extra padding for gdb bug.
2427 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2428 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2429 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2430 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2431 EmitLabel("info_end", ModuleCU->getID());
2435 /// emitAbbreviations - Emit the abbreviation section.
2437 void DwarfDebug::emitAbbreviations() const {
2438 // Check to see if it is worth the effort.
2439 if (!Abbreviations.empty()) {
2440 // Start the debug abbrev section.
2441 Asm->OutStreamer.SwitchSection(
2442 Asm->getObjFileLowering().getDwarfAbbrevSection());
2444 EmitLabel("abbrev_begin", 0);
2446 // For each abbrevation.
2447 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2448 // Get abbreviation data
2449 const DIEAbbrev *Abbrev = Abbreviations[i];
2451 // Emit the abbrevations code (base 1 index.)
2452 Asm->EmitULEB128Bytes(Abbrev->getNumber());
2453 Asm->EOL("Abbreviation Code");
2455 // Emit the abbreviations data.
2460 // Mark end of abbreviations.
2461 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2463 EmitLabel("abbrev_end", 0);
2468 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2469 /// the line matrix.
2471 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2472 // Define last address of section.
2473 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2474 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2475 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2476 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2478 // Mark end of matrix.
2479 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2480 Asm->EmitULEB128Bytes(1);
2486 /// emitDebugLines - Emit source line information.
2488 void DwarfDebug::emitDebugLines() {
2489 // If the target is using .loc/.file, the assembler will be emitting the
2490 // .debug_line table automatically.
2491 if (MAI->hasDotLocAndDotFile())
2494 // Minimum line delta, thus ranging from -10..(255-10).
2495 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2496 // Maximum line delta, thus ranging from -10..(255-10).
2497 const int MaxLineDelta = 255 + MinLineDelta;
2499 // Start the dwarf line section.
2500 Asm->OutStreamer.SwitchSection(
2501 Asm->getObjFileLowering().getDwarfLineSection());
2503 // Construct the section header.
2504 EmitDifference("line_end", 0, "line_begin", 0, true);
2505 Asm->EOL("Length of Source Line Info");
2506 EmitLabel("line_begin", 0);
2508 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2510 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2511 Asm->EOL("Prolog Length");
2512 EmitLabel("line_prolog_begin", 0);
2514 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2516 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2518 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2520 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2522 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2524 // Line number standard opcode encodings argument count
2525 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2526 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2527 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2528 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2529 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2530 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2531 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2532 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2533 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2535 // Emit directories.
2536 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2537 Asm->EmitString(getSourceDirectoryName(DI));
2538 Asm->EOL("Directory");
2541 Asm->EmitInt8(0); Asm->EOL("End of directories");
2544 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2545 // Remember source id starts at 1.
2546 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2547 Asm->EmitString(getSourceFileName(Id.second));
2549 Asm->EmitULEB128Bytes(Id.first);
2550 Asm->EOL("Directory #");
2551 Asm->EmitULEB128Bytes(0);
2552 Asm->EOL("Mod date");
2553 Asm->EmitULEB128Bytes(0);
2554 Asm->EOL("File size");
2557 Asm->EmitInt8(0); Asm->EOL("End of files");
2559 EmitLabel("line_prolog_end", 0);
2561 // A sequence for each text section.
2562 unsigned SecSrcLinesSize = SectionSourceLines.size();
2564 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2565 // Isolate current sections line info.
2566 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2568 /*if (Asm->isVerbose()) {
2569 const MCSection *S = SectionMap[j + 1];
2570 O << '\t' << MAI->getCommentString() << " Section"
2571 << S->getName() << '\n';
2575 // Dwarf assumes we start with first line of first source file.
2576 unsigned Source = 1;
2579 // Construct rows of the address, source, line, column matrix.
2580 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2581 const SrcLineInfo &LineInfo = LineInfos[i];
2582 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2583 if (!LabelID) continue;
2585 if (LineInfo.getLine() == 0) continue;
2587 if (!Asm->isVerbose())
2590 std::pair<unsigned, unsigned> SourceID =
2591 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2592 O << '\t' << MAI->getCommentString() << ' '
2593 << getSourceDirectoryName(SourceID.first) << '/'
2594 << getSourceFileName(SourceID.second)
2595 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2598 // Define the line address.
2599 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2600 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2601 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2602 EmitReference("label", LabelID); Asm->EOL("Location label");
2604 // If change of source, then switch to the new source.
2605 if (Source != LineInfo.getSourceID()) {
2606 Source = LineInfo.getSourceID();
2607 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2608 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2611 // If change of line.
2612 if (Line != LineInfo.getLine()) {
2613 // Determine offset.
2614 int Offset = LineInfo.getLine() - Line;
2615 int Delta = Offset - MinLineDelta;
2618 Line = LineInfo.getLine();
2620 // If delta is small enough and in range...
2621 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2622 // ... then use fast opcode.
2623 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2625 // ... otherwise use long hand.
2626 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2627 Asm->EOL("DW_LNS_advance_line");
2628 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2629 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2632 // Copy the previous row (different address or source)
2633 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2637 emitEndOfLineMatrix(j + 1);
2640 if (SecSrcLinesSize == 0)
2641 // Because we're emitting a debug_line section, we still need a line
2642 // table. The linker and friends expect it to exist. If there's nothing to
2643 // put into it, emit an empty table.
2644 emitEndOfLineMatrix(1);
2646 EmitLabel("line_end", 0);
2650 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2652 void DwarfDebug::emitCommonDebugFrame() {
2653 if (!MAI->doesDwarfRequireFrameSection())
2657 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2658 TargetFrameInfo::StackGrowsUp ?
2659 TD->getPointerSize() : -TD->getPointerSize();
2661 // Start the dwarf frame section.
2662 Asm->OutStreamer.SwitchSection(
2663 Asm->getObjFileLowering().getDwarfFrameSection());
2665 EmitLabel("debug_frame_common", 0);
2666 EmitDifference("debug_frame_common_end", 0,
2667 "debug_frame_common_begin", 0, true);
2668 Asm->EOL("Length of Common Information Entry");
2670 EmitLabel("debug_frame_common_begin", 0);
2671 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2672 Asm->EOL("CIE Identifier Tag");
2673 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2674 Asm->EOL("CIE Version");
2675 Asm->EmitString("");
2676 Asm->EOL("CIE Augmentation");
2677 Asm->EmitULEB128Bytes(1);
2678 Asm->EOL("CIE Code Alignment Factor");
2679 Asm->EmitSLEB128Bytes(stackGrowth);
2680 Asm->EOL("CIE Data Alignment Factor");
2681 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2682 Asm->EOL("CIE RA Column");
2684 std::vector<MachineMove> Moves;
2685 RI->getInitialFrameState(Moves);
2687 EmitFrameMoves(NULL, 0, Moves, false);
2689 Asm->EmitAlignment(2, 0, 0, false);
2690 EmitLabel("debug_frame_common_end", 0);
2694 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2697 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2698 if (!MAI->doesDwarfRequireFrameSection())
2701 // Start the dwarf frame section.
2702 Asm->OutStreamer.SwitchSection(
2703 Asm->getObjFileLowering().getDwarfFrameSection());
2705 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2706 "debug_frame_begin", DebugFrameInfo.Number, true);
2707 Asm->EOL("Length of Frame Information Entry");
2709 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2711 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2713 Asm->EOL("FDE CIE offset");
2715 EmitReference("func_begin", DebugFrameInfo.Number);
2716 Asm->EOL("FDE initial location");
2717 EmitDifference("func_end", DebugFrameInfo.Number,
2718 "func_begin", DebugFrameInfo.Number);
2719 Asm->EOL("FDE address range");
2721 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2724 Asm->EmitAlignment(2, 0, 0, false);
2725 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2729 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2731 void DwarfDebug::emitDebugPubNames() {
2732 // Start the dwarf pubnames section.
2733 Asm->OutStreamer.SwitchSection(
2734 Asm->getObjFileLowering().getDwarfPubNamesSection());
2736 EmitDifference("pubnames_end", ModuleCU->getID(),
2737 "pubnames_begin", ModuleCU->getID(), true);
2738 Asm->EOL("Length of Public Names Info");
2740 EmitLabel("pubnames_begin", ModuleCU->getID());
2742 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2744 EmitSectionOffset("info_begin", "section_info",
2745 ModuleCU->getID(), 0, true, false);
2746 Asm->EOL("Offset of Compilation Unit Info");
2748 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2750 Asm->EOL("Compilation Unit Length");
2752 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2753 for (StringMap<DIE*>::const_iterator
2754 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2755 const char *Name = GI->getKeyData();
2756 DIE * Entity = GI->second;
2758 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2759 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2762 Asm->EmitInt32(0); Asm->EOL("End Mark");
2763 EmitLabel("pubnames_end", ModuleCU->getID());
2767 void DwarfDebug::emitDebugPubTypes() {
2768 // Start the dwarf pubnames section.
2769 Asm->OutStreamer.SwitchSection(
2770 Asm->getObjFileLowering().getDwarfPubTypesSection());
2771 EmitDifference("pubtypes_end", ModuleCU->getID(),
2772 "pubtypes_begin", ModuleCU->getID(), true);
2773 Asm->EOL("Length of Public Types Info");
2775 EmitLabel("pubtypes_begin", ModuleCU->getID());
2777 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2779 EmitSectionOffset("info_begin", "section_info",
2780 ModuleCU->getID(), 0, true, false);
2781 Asm->EOL("Offset of Compilation ModuleCU Info");
2783 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2785 Asm->EOL("Compilation ModuleCU Length");
2787 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2788 for (StringMap<DIE*>::const_iterator
2789 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2790 const char *Name = GI->getKeyData();
2791 DIE * Entity = GI->second;
2793 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2794 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2797 Asm->EmitInt32(0); Asm->EOL("End Mark");
2798 EmitLabel("pubtypes_end", ModuleCU->getID());
2802 /// emitDebugStr - Emit visible names into a debug str section.
2804 void DwarfDebug::emitDebugStr() {
2805 // Check to see if it is worth the effort.
2806 if (!StringPool.empty()) {
2807 // Start the dwarf str section.
2808 Asm->OutStreamer.SwitchSection(
2809 Asm->getObjFileLowering().getDwarfStrSection());
2811 // For each of strings in the string pool.
2812 for (unsigned StringID = 1, N = StringPool.size();
2813 StringID <= N; ++StringID) {
2814 // Emit a label for reference from debug information entries.
2815 EmitLabel("string", StringID);
2817 // Emit the string itself.
2818 const std::string &String = StringPool[StringID];
2819 Asm->EmitString(String);
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); Asm->EOL("Length of Address Ranges Info");
2849 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2851 EmitReference("info_begin", Unit->getID());
2852 Asm->EOL("Offset of Compilation Unit Info");
2854 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2856 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2858 Asm->EmitInt16(0); Asm->EOL("Pad (1)");
2859 Asm->EmitInt16(0); Asm->EOL("Pad (2)");
2862 EmitReference("text_begin", 0); Asm->EOL("Address");
2863 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2865 Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2866 Asm->EmitInt32(0); Asm->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 Asm->EOL("Length of Debug Inlined Information Entry");
2920 EmitLabel("debug_inlined_begin", 1);
2922 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2923 Asm->EmitInt8(TD->getPointerSize()); Asm->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();
2937 Asm->EmitString(Name);
2939 EmitSectionOffset("string", "section_str",
2940 StringPool.idFor(getRealLinkageName(LName)), false, true);
2942 Asm->EOL("MIPS linkage name");
2943 EmitSectionOffset("string", "section_str",
2944 StringPool.idFor(Name), false, true);
2945 Asm->EOL("Function name");
2946 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2948 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2949 LE = Labels.end(); LI != LE; ++LI) {
2950 DIE *SP = LI->second;
2951 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2953 if (TD->getPointerSize() == sizeof(int32_t))
2954 O << MAI->getData32bitsDirective();
2956 O << MAI->getData64bitsDirective();
2958 PrintLabelName("label", LI->first); Asm->EOL("low_pc");
2962 EmitLabel("debug_inlined_end", 1);