1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
13 #define DEBUG_TYPE "dwarfdebug"
14 #include "DwarfDebug.h"
15 #include "llvm/Module.h"
16 #include "llvm/CodeGen/MachineFunction.h"
17 #include "llvm/CodeGen/MachineModuleInfo.h"
18 #include "llvm/MC/MCSection.h"
19 #include "llvm/MC/MCStreamer.h"
20 #include "llvm/MC/MCAsmInfo.h"
21 #include "llvm/Target/TargetData.h"
22 #include "llvm/Target/TargetFrameInfo.h"
23 #include "llvm/Target/TargetLoweringObjectFile.h"
24 #include "llvm/Target/TargetRegisterInfo.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/Support/Debug.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/Mangler.h"
29 #include "llvm/Support/Timer.h"
30 #include "llvm/System/Path.h"
33 //===----------------------------------------------------------------------===//
35 /// Configuration values for initial hash set sizes (log2).
37 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
41 //===----------------------------------------------------------------------===//
42 /// CompileUnit - This dwarf writer support class manages information associate
43 /// with a source file.
45 /// ID - File identifier for source.
49 /// Die - Compile unit debug information entry.
53 /// IndexTyDie - An anonymous type for index type.
56 /// GVToDieMap - Tracks the mapping of unit level debug informaton
57 /// variables to debug information entries.
58 /// FIXME : Rename GVToDieMap -> NodeToDieMap
59 ValueMap<MDNode *, DIE *> GVToDieMap;
61 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
62 /// descriptors to debug information entries using a DIEEntry proxy.
64 ValueMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
66 /// Globals - A map of globally visible named entities for this unit.
68 StringMap<DIE*> Globals;
70 /// GlobalTypes - A map of globally visible types for this unit.
72 StringMap<DIE*> GlobalTypes;
75 CompileUnit(unsigned I, DIE *D)
76 : ID(I), CUDie(D), IndexTyDie(0) {}
77 ~CompileUnit() { delete CUDie; delete IndexTyDie; }
80 unsigned getID() const { return ID; }
81 DIE* getCUDie() const { return CUDie; }
82 const StringMap<DIE*> &getGlobals() const { return Globals; }
83 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
85 /// hasContent - Return true if this compile unit has something to write out.
87 bool hasContent() const { return !CUDie->getChildren().empty(); }
89 /// addGlobal - Add a new global entity to the compile unit.
91 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
93 /// addGlobalType - Add a new global type to the compile unit.
95 void addGlobalType(const std::string &Name, DIE *Die) {
96 GlobalTypes[Name] = Die;
99 /// getDIE - Returns the debug information entry map slot for the
100 /// specified debug variable.
101 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
103 /// insertDIE - Insert DIE into the map.
104 void insertDIE(MDNode *N, DIE *D) {
105 GVToDieMap.insert(std::make_pair(N, D));
108 /// getDIEEntry - Returns the debug information entry for the speciefied
110 DIEEntry *getDIEEntry(MDNode *N) {
111 ValueMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
112 if (I == GVToDIEEntryMap.end())
117 /// insertDIEEntry - Insert debug information entry into the map.
118 void insertDIEEntry(MDNode *N, DIEEntry *E) {
119 GVToDIEEntryMap.insert(std::make_pair(N, E));
122 /// addDie - Adds or interns the DIE to the compile unit.
124 void addDie(DIE *Buffer) {
125 this->CUDie->addChild(Buffer);
128 // getIndexTyDie - Get an anonymous type for index type.
129 DIE *getIndexTyDie() {
133 // setIndexTyDie - Set D as anonymous type for index which can be reused
135 void setIndexTyDie(DIE *D) {
141 //===----------------------------------------------------------------------===//
142 /// DbgVariable - This class is used to track local variable information.
145 DIVariable Var; // Variable Descriptor.
146 unsigned FrameIndex; // Variable frame index.
147 DbgVariable *AbstractVar; // Abstract variable for this variable.
150 DbgVariable(DIVariable V, unsigned I)
151 : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0) {}
154 DIVariable getVariable() const { return Var; }
155 unsigned getFrameIndex() const { return FrameIndex; }
156 void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
157 DbgVariable *getAbstractVariable() const { return AbstractVar; }
158 void setDIE(DIE *D) { TheDIE = D; }
159 DIE *getDIE() const { return TheDIE; }
162 //===----------------------------------------------------------------------===//
163 /// DbgScope - This class is used to track scope information.
166 DbgScope *Parent; // Parent to this scope.
167 DIDescriptor Desc; // Debug info descriptor for scope.
168 // FIXME : Use of WeakVH may be expensive here.
169 WeakVH 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 : Dwarf(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 std::string &Label) {
366 DIEValue *Value = new DIEObjectLabel(Label);
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, WeakVH(SP.getContainingType().getNode())));
1169 if (MakeDecl || !SP.isDefinition()) {
1170 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1172 // Add arguments. Do not add arguments for subprogram definition. They will
1173 // be handled while processing variables.
1174 DICompositeType SPTy = SP.getType();
1175 DIArray Args = SPTy.getTypeArray();
1176 unsigned SPTag = SPTy.getTag();
1178 if (SPTag == dwarf::DW_TAG_subroutine_type)
1179 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1180 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1181 addType(Arg, DIType(Args.getElement(i).getNode()));
1182 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1183 SPDie->addChild(Arg);
1187 // DW_TAG_inlined_subroutine may refer to this DIE.
1188 ModuleCU->insertDIE(SP.getNode(), SPDie);
1192 /// findCompileUnit - Get the compile unit for the given descriptor.
1194 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1195 DenseMap<Value *, CompileUnit *>::const_iterator I =
1196 CompileUnitMap.find(Unit.getNode());
1197 if (I == CompileUnitMap.end())
1198 return constructCompileUnit(Unit.getNode());
1202 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1203 /// Initialize scope and update scope hierarchy.
1204 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1205 MDNode *InlinedAt) {
1206 assert (N && "Invalid Scope encoding!");
1207 assert (MI && "Missing machine instruction!");
1208 bool GetConcreteScope = (MI && InlinedAt);
1210 DbgScope *NScope = NULL;
1213 NScope = DbgScopeMap.lookup(InlinedAt);
1215 NScope = DbgScopeMap.lookup(N);
1216 assert (NScope && "Unable to find working scope!");
1218 if (NScope->getFirstInsn())
1221 DbgScope *Parent = NULL;
1222 if (GetConcreteScope) {
1223 DILocation IL(InlinedAt);
1224 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1225 IL.getOrigLocation().getNode());
1226 assert (Parent && "Unable to find Parent scope!");
1227 NScope->setParent(Parent);
1228 Parent->addScope(NScope);
1229 } else if (DIDescriptor(N).isLexicalBlock()) {
1230 DILexicalBlock DB(N);
1231 if (!DB.getContext().isNull()) {
1232 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1233 NScope->setParent(Parent);
1234 Parent->addScope(NScope);
1238 NScope->setFirstInsn(MI);
1240 if (!Parent && !InlinedAt) {
1241 StringRef SPName = DISubprogram(N).getLinkageName();
1242 if (SPName == MF->getFunction()->getName())
1243 CurrentFnDbgScope = NScope;
1246 if (GetConcreteScope) {
1247 ConcreteScopes[InlinedAt] = NScope;
1248 getOrCreateAbstractScope(N);
1254 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1255 assert (N && "Invalid Scope encoding!");
1257 DbgScope *AScope = AbstractScopes.lookup(N);
1261 DbgScope *Parent = NULL;
1263 DIDescriptor Scope(N);
1264 if (Scope.isLexicalBlock()) {
1265 DILexicalBlock DB(N);
1266 DIDescriptor ParentDesc = DB.getContext();
1267 if (!ParentDesc.isNull())
1268 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1271 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1274 Parent->addScope(AScope);
1275 AScope->setAbstractScope();
1276 AbstractScopes[N] = AScope;
1277 if (DIDescriptor(N).isSubprogram())
1278 AbstractScopesList.push_back(AScope);
1282 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1283 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1284 /// If there are global variables in this scope then create and insert
1285 /// DIEs for these variables.
1286 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1288 DIE *SPDie = ModuleCU->getDIE(SPNode);
1289 assert (SPDie && "Unable to find subprogram DIE!");
1290 DISubprogram SP(SPNode);
1291 if (SP.isDefinition() && !SP.getContext().isCompileUnit()) {
1292 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1294 DICompositeType SPTy = SP.getType();
1295 DIArray Args = SPTy.getTypeArray();
1296 unsigned SPTag = SPTy.getTag();
1297 if (SPTag == dwarf::DW_TAG_subroutine_type)
1298 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1299 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1300 addType(Arg, DIType(Args.getElement(i).getNode()));
1301 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1302 SPDie->addChild(Arg);
1304 DIE *SPDeclDie = SPDie;
1305 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1306 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1308 ModuleCU->addDie(SPDie);
1311 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1312 DWLabel("func_begin", SubprogramCount));
1313 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1314 DWLabel("func_end", SubprogramCount));
1315 MachineLocation Location(RI->getFrameRegister(*MF));
1316 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1318 if (!DISubprogram(SPNode).isLocalToUnit())
1319 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1324 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1325 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1326 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1327 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1328 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1330 // Ignore empty scopes.
1331 if (StartID == EndID && StartID != 0)
1334 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1335 if (Scope->isAbstractScope())
1338 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1340 DWLabel("label", StartID)
1341 : DWLabel("func_begin", SubprogramCount));
1342 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1344 DWLabel("label", EndID)
1345 : DWLabel("func_end", SubprogramCount));
1352 /// constructInlinedScopeDIE - This scope represents inlined body of
1353 /// a function. Construct DIE to represent this concrete inlined copy
1354 /// of the function.
1355 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1356 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1357 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1358 assert (StartID && "Invalid starting label for an inlined scope!");
1359 assert (EndID && "Invalid end label for an inlined scope!");
1360 // Ignore empty scopes.
1361 if (StartID == EndID && StartID != 0)
1364 DIScope DS(Scope->getScopeNode());
1367 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1369 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1370 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1371 assert (OriginDIE && "Unable to find Origin DIE!");
1372 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1373 dwarf::DW_FORM_ref4, OriginDIE);
1375 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1376 DWLabel("label", StartID));
1377 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1378 DWLabel("label", EndID));
1380 InlinedSubprogramDIEs.insert(OriginDIE);
1382 // Track the start label for this inlined function.
1383 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1384 I = InlineInfo.find(InlinedSP.getNode());
1386 if (I == InlineInfo.end()) {
1387 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1389 InlinedSPNodes.push_back(InlinedSP.getNode());
1391 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1393 StringPool.insert(InlinedSP.getName());
1394 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1396 DILocation DL(Scope->getInlinedAt());
1397 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1398 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1404 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1405 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1406 // Get the descriptor.
1407 const DIVariable &VD = DV->getVariable();
1408 StringRef Name = VD.getName();
1412 // Translate tag to proper Dwarf tag. The result variable is dropped for
1415 switch (VD.getTag()) {
1416 case dwarf::DW_TAG_return_variable:
1418 case dwarf::DW_TAG_arg_variable:
1419 Tag = dwarf::DW_TAG_formal_parameter;
1421 case dwarf::DW_TAG_auto_variable: // fall thru
1423 Tag = dwarf::DW_TAG_variable;
1427 // Define variable debug information entry.
1428 DIE *VariableDie = new DIE(Tag);
1432 if (DbgVariable *AV = DV->getAbstractVariable())
1433 AbsDIE = AV->getDIE();
1436 DIScope DS(Scope->getScopeNode());
1437 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1438 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1440 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1441 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1442 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1443 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1444 dwarf::DW_FORM_ref4, AbsDIE);
1447 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1448 addSourceLine(VariableDie, &VD);
1450 // Add variable type.
1451 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1452 // addresses instead.
1453 if (VD.isBlockByrefVariable())
1454 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1456 addType(VariableDie, VD.getType());
1459 // Add variable address.
1460 if (!Scope->isAbstractScope()) {
1461 MachineLocation Location;
1463 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1464 Location.set(FrameReg, Offset);
1466 if (VD.hasComplexAddress())
1467 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1468 else if (VD.isBlockByrefVariable())
1469 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1471 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1473 DV->setDIE(VariableDie);
1478 void DwarfDebug::addPubTypes(DISubprogram SP) {
1479 DICompositeType SPTy = SP.getType();
1480 unsigned SPTag = SPTy.getTag();
1481 if (SPTag != dwarf::DW_TAG_subroutine_type)
1484 DIArray Args = SPTy.getTypeArray();
1488 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1489 DIType ATy(Args.getElement(i).getNode());
1492 DICompositeType CATy = getDICompositeType(ATy);
1493 if (!CATy.isNull() && !CATy.getName().empty()) {
1494 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1495 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1500 /// constructScopeDIE - Construct a DIE for this scope.
1501 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1504 DIScope DS(Scope->getScopeNode());
1508 DIE *ScopeDIE = NULL;
1509 if (Scope->getInlinedAt())
1510 ScopeDIE = constructInlinedScopeDIE(Scope);
1511 else if (DS.isSubprogram()) {
1512 if (Scope->isAbstractScope())
1513 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1515 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1518 ScopeDIE = constructLexicalScopeDIE(Scope);
1519 if (!ScopeDIE) return NULL;
1522 // Add variables to scope.
1523 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1524 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1525 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1527 ScopeDIE->addChild(VariableDIE);
1530 // Add nested scopes.
1531 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1532 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1533 // Define the Scope debug information entry.
1534 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1536 ScopeDIE->addChild(NestedDIE);
1539 if (DS.isSubprogram())
1540 addPubTypes(DISubprogram(DS.getNode()));
1545 /// GetOrCreateSourceID - Look up the source id with the given directory and
1546 /// source file names. If none currently exists, create a new id and insert it
1547 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1549 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1551 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1552 if (DI != DirectoryIdMap.end()) {
1553 DId = DI->getValue();
1555 DId = DirectoryNames.size() + 1;
1556 DirectoryIdMap[DirName] = DId;
1557 DirectoryNames.push_back(DirName);
1561 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1562 if (FI != SourceFileIdMap.end()) {
1563 FId = FI->getValue();
1565 FId = SourceFileNames.size() + 1;
1566 SourceFileIdMap[FileName] = FId;
1567 SourceFileNames.push_back(FileName);
1570 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1571 SourceIdMap.find(std::make_pair(DId, FId));
1572 if (SI != SourceIdMap.end())
1575 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1576 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1577 SourceIds.push_back(std::make_pair(DId, FId));
1582 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1583 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1584 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1587 NDie = new DIE(dwarf::DW_TAG_namespace);
1588 ModuleCU->insertDIE(NS.getNode(), NDie);
1589 if (!NS.getName().empty())
1590 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1591 addSourceLine(NDie, &NS);
1592 addToContextOwner(NDie, NS.getContext());
1596 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1597 DICompileUnit DIUnit(N);
1598 StringRef FN = DIUnit.getFilename();
1599 StringRef Dir = DIUnit.getDirectory();
1600 unsigned ID = GetOrCreateSourceID(Dir, FN);
1602 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1603 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1604 DWLabel("section_line", 0), DWLabel("section_line", 0),
1606 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1607 DIUnit.getProducer());
1608 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1609 DIUnit.getLanguage());
1610 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1613 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1614 if (DIUnit.isOptimized())
1615 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1617 StringRef Flags = DIUnit.getFlags();
1619 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1621 unsigned RVer = DIUnit.getRunTimeVersion();
1623 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1624 dwarf::DW_FORM_data1, RVer);
1626 CompileUnit *Unit = new CompileUnit(ID, Die);
1627 if (!ModuleCU && DIUnit.isMain()) {
1628 // Use first compile unit marked as isMain as the compile unit
1633 CompileUnitMap[DIUnit.getNode()] = Unit;
1634 CompileUnits.push_back(Unit);
1638 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1639 DIGlobalVariable DI_GV(N);
1641 // If debug information is malformed then ignore it.
1642 if (DI_GV.Verify() == false)
1645 // Check for pre-existence.
1646 if (ModuleCU->getDIE(DI_GV.getNode()))
1649 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1654 ModuleCU->insertDIE(N, VariableDie);
1656 // Add to context owner.
1657 DIDescriptor GVContext = DI_GV.getContext();
1658 // Do not create specification DIE if context is either compile unit
1660 if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1661 && !GVContext.isSubprogram()) {
1662 // Create specification DIE.
1663 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1664 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1665 dwarf::DW_FORM_ref4, VariableDie);
1666 DIEBlock *Block = new DIEBlock();
1667 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1668 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1669 Asm->Mang->getMangledName(DI_GV.getGlobal()));
1670 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1671 ModuleCU->addDie(VariableSpecDIE);
1673 DIEBlock *Block = new DIEBlock();
1674 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1675 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1676 Asm->Mang->getMangledName(DI_GV.getGlobal()));
1677 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1679 addToContextOwner(VariableDie, GVContext);
1681 // Expose as global. FIXME - need to check external flag.
1682 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1684 DIType GTy = DI_GV.getType();
1685 if (GTy.isCompositeType() && !GTy.getName().empty()) {
1686 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1687 assert (Entry && "Missing global type!");
1688 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1693 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1696 // Check for pre-existence.
1697 if (ModuleCU->getDIE(N))
1700 if (!SP.isDefinition())
1701 // This is a method declaration which will be handled while constructing
1705 DIE *SubprogramDie = createSubprogramDIE(SP);
1708 ModuleCU->insertDIE(N, SubprogramDie);
1710 // Add to context owner.
1711 addToContextOwner(SubprogramDie, SP.getContext());
1713 // Expose as global.
1714 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1719 /// beginModule - Emit all Dwarf sections that should come prior to the
1720 /// content. Create global DIEs and emit initial debug info sections.
1721 /// This is inovked by the target AsmPrinter.
1722 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1725 if (TimePassesIsEnabled)
1726 DebugTimer->startTimer();
1728 if (!MAI->doesSupportDebugInformation())
1731 DebugInfoFinder DbgFinder;
1732 DbgFinder.processModule(*M);
1734 // Create all the compile unit DIEs.
1735 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1736 E = DbgFinder.compile_unit_end(); I != E; ++I)
1737 constructCompileUnit(*I);
1739 if (CompileUnits.empty()) {
1740 if (TimePassesIsEnabled)
1741 DebugTimer->stopTimer();
1746 // If main compile unit for this module is not seen than randomly
1747 // select first compile unit.
1749 ModuleCU = CompileUnits[0];
1751 // Create DIEs for each subprogram.
1752 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1753 E = DbgFinder.subprogram_end(); I != E; ++I)
1754 constructSubprogramDIE(*I);
1756 // Create DIEs for each global variable.
1757 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1758 E = DbgFinder.global_variable_end(); I != E; ++I)
1759 constructGlobalVariableDIE(*I);
1763 MMI->setDebugInfoAvailability(true);
1765 // Prime section data.
1766 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1768 // Print out .file directives to specify files for .loc directives. These are
1769 // printed out early so that they precede any .loc directives.
1770 if (MAI->hasDotLocAndDotFile()) {
1771 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1772 // Remember source id starts at 1.
1773 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1774 sys::Path FullPath(getSourceDirectoryName(Id.first));
1776 FullPath.appendComponent(getSourceFileName(Id.second));
1777 assert(AppendOk && "Could not append filename to directory!");
1779 Asm->EmitFile(i, FullPath.str());
1784 // Emit initial sections
1787 if (TimePassesIsEnabled)
1788 DebugTimer->stopTimer();
1791 /// endModule - Emit all Dwarf sections that should come after the content.
1793 void DwarfDebug::endModule() {
1797 if (TimePassesIsEnabled)
1798 DebugTimer->startTimer();
1800 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1801 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1802 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1804 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1807 // Insert top level DIEs.
1808 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1809 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1810 ModuleCU->getCUDie()->addChild(*TI);
1812 for (DenseMap<DIE *, WeakVH>::iterator CI = ContainingTypeMap.begin(),
1813 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1814 DIE *SPDie = CI->first;
1815 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1817 DIE *NDie = ModuleCU->getDIE(N);
1818 if (!NDie) continue;
1819 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1820 // FIXME - This is not the correct approach.
1821 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1824 // Standard sections final addresses.
1825 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1826 EmitLabel("text_end", 0);
1827 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1828 EmitLabel("data_end", 0);
1830 // End text sections.
1831 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1832 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1833 EmitLabel("section_end", i);
1836 // Emit common frame information.
1837 emitCommonDebugFrame();
1839 // Emit function debug frame information
1840 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1841 E = DebugFrames.end(); I != E; ++I)
1842 emitFunctionDebugFrame(*I);
1844 // Compute DIE offsets and sizes.
1845 computeSizeAndOffsets();
1847 // Emit all the DIEs into a debug info section
1850 // Corresponding abbreviations into a abbrev section.
1851 emitAbbreviations();
1853 // Emit source line correspondence into a debug line section.
1856 // Emit info into a debug pubnames section.
1857 emitDebugPubNames();
1859 // Emit info into a debug pubtypes section.
1860 emitDebugPubTypes();
1862 // Emit info into a debug str section.
1865 // Emit info into a debug loc section.
1868 // Emit info into a debug aranges section.
1871 // Emit info into a debug ranges section.
1874 // Emit info into a debug macinfo section.
1877 // Emit inline info.
1878 emitDebugInlineInfo();
1880 if (TimePassesIsEnabled)
1881 DebugTimer->stopTimer();
1884 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1885 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1887 DILocation &ScopeLoc) {
1889 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1891 return AbsDbgVariable;
1893 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1897 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1898 Scope->addVariable(AbsDbgVariable);
1899 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1900 return AbsDbgVariable;
1903 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1904 void DwarfDebug::collectVariableInfo() {
1907 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1908 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1909 VE = VMap.end(); VI != VE; ++VI) {
1910 MetadataBase *MB = VI->first;
1911 MDNode *Var = dyn_cast_or_null<MDNode>(MB);
1913 DIVariable DV (Var);
1914 std::pair< unsigned, MDNode *> VP = VI->second;
1915 DILocation ScopeLoc(VP.second);
1918 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1920 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1921 // If variable scope is not found then skip this variable.
1925 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1926 Scope->addVariable(RegVar);
1927 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1929 RegVar->setAbstractVariable(AbsDbgVariable);
1933 /// beginScope - Process beginning of a scope starting at Label.
1934 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1935 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1936 if (I == DbgScopeBeginMap.end())
1938 ScopeVector &SD = I->second;
1939 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1941 (*SDI)->setStartLabelID(Label);
1944 /// endScope - Process end of a scope.
1945 void DwarfDebug::endScope(const MachineInstr *MI) {
1946 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1947 if (I == DbgScopeEndMap.end())
1950 unsigned Label = MMI->NextLabelID();
1951 Asm->printLabel(Label);
1954 SmallVector<DbgScope *, 2> &SD = I->second;
1955 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1957 (*SDI)->setEndLabelID(Label);
1961 /// createDbgScope - Create DbgScope for the scope.
1962 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1965 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1968 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1969 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1970 if (DIDescriptor(Scope).isLexicalBlock())
1971 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1975 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1979 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1980 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1981 DILocation DL(InlinedAt);
1982 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1985 /// extractScopeInformation - Scan machine instructions in this function
1986 /// and collect DbgScopes. Return true, if atleast one scope was found.
1987 bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
1988 // If scope information was extracted using .dbg intrinsics then there is not
1989 // any need to extract these information by scanning each instruction.
1990 if (!DbgScopeMap.empty())
1993 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
1994 unsigned MIIndex = 0;
1995 // Scan each instruction and create scopes. First build working set of scopes.
1996 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1998 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2000 const MachineInstr *MInsn = II;
2001 MIIndexMap[MInsn] = MIIndex++;
2002 DebugLoc DL = MInsn->getDebugLoc();
2003 if (DL.isUnknown()) continue;
2004 DILocation DLT = MF->getDILocation(DL);
2005 DIScope DLTScope = DLT.getScope();
2006 if (DLTScope.isNull()) continue;
2007 // There is no need to create another DIE for compile unit. For all
2008 // other scopes, create one DbgScope now. This will be translated
2009 // into a scope DIE at the end.
2010 if (DLTScope.isCompileUnit()) continue;
2011 createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2016 // Build scope hierarchy using working set of scopes.
2017 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2019 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2021 const MachineInstr *MInsn = II;
2022 DebugLoc DL = MInsn->getDebugLoc();
2023 if (DL.isUnknown()) continue;
2024 DILocation DLT = MF->getDILocation(DL);
2025 DIScope DLTScope = DLT.getScope();
2026 if (DLTScope.isNull()) continue;
2027 // There is no need to create another DIE for compile unit. For all
2028 // other scopes, create one DbgScope now. This will be translated
2029 // into a scope DIE at the end.
2030 if (DLTScope.isCompileUnit()) continue;
2031 DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
2032 DLT.getOrigLocation().getNode());
2033 Scope->setLastInsn(MInsn);
2037 if (!CurrentFnDbgScope)
2040 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2042 // Each scope has first instruction and last instruction to mark beginning
2043 // and end of a scope respectively. Create an inverse map that list scopes
2044 // starts (and ends) with an instruction. One instruction may start (or end)
2046 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
2047 DE = DbgScopeMap.end(); DI != DE; ++DI) {
2048 DbgScope *S = DI->second;
2049 if (S->isAbstractScope())
2051 const MachineInstr *MI = S->getFirstInsn();
2052 assert (MI && "DbgScope does not have first instruction!");
2054 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2055 if (IDI != DbgScopeBeginMap.end())
2056 IDI->second.push_back(S);
2058 DbgScopeBeginMap[MI].push_back(S);
2060 MI = S->getLastInsn();
2061 assert (MI && "DbgScope does not have last instruction!");
2062 IDI = DbgScopeEndMap.find(MI);
2063 if (IDI != DbgScopeEndMap.end())
2064 IDI->second.push_back(S);
2066 DbgScopeEndMap[MI].push_back(S);
2069 return !DbgScopeMap.empty();
2072 /// beginFunction - Gather pre-function debug information. Assumes being
2073 /// emitted immediately after the function entry point.
2074 void DwarfDebug::beginFunction(MachineFunction *MF) {
2077 if (!ShouldEmitDwarfDebug()) return;
2079 if (TimePassesIsEnabled)
2080 DebugTimer->startTimer();
2082 if (!extractScopeInformation(MF))
2085 collectVariableInfo();
2087 // Begin accumulating function debug information.
2088 MMI->BeginFunction(MF);
2090 // Assumes in correct section after the entry point.
2091 EmitLabel("func_begin", ++SubprogramCount);
2093 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2095 DebugLoc FDL = MF->getDefaultDebugLoc();
2096 if (!FDL.isUnknown()) {
2097 DILocation DLT = MF->getDILocation(FDL);
2098 unsigned LabelID = 0;
2099 DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2101 LabelID = recordSourceLine(SP.getLineNumber(), 0,
2102 DLT.getScope().getNode());
2104 LabelID = recordSourceLine(DLT.getLineNumber(),
2105 DLT.getColumnNumber(),
2106 DLT.getScope().getNode());
2107 Asm->printLabel(LabelID);
2110 if (TimePassesIsEnabled)
2111 DebugTimer->stopTimer();
2114 /// endFunction - Gather and emit post-function debug information.
2116 void DwarfDebug::endFunction(MachineFunction *MF) {
2117 if (!ShouldEmitDwarfDebug()) return;
2119 if (TimePassesIsEnabled)
2120 DebugTimer->startTimer();
2122 if (DbgScopeMap.empty())
2125 if (CurrentFnDbgScope) {
2126 // Define end label for subprogram.
2127 EmitLabel("func_end", SubprogramCount);
2129 // Get function line info.
2130 if (!Lines.empty()) {
2131 // Get section line info.
2132 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2133 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2134 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2135 // Append the function info to section info.
2136 SectionLineInfos.insert(SectionLineInfos.end(),
2137 Lines.begin(), Lines.end());
2140 // Construct abstract scopes.
2141 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2142 AE = AbstractScopesList.end(); AI != AE; ++AI)
2143 constructScopeDIE(*AI);
2145 constructScopeDIE(CurrentFnDbgScope);
2147 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2148 MMI->getFrameMoves()));
2152 if (CurrentFnDbgScope) {
2153 CurrentFnDbgScope = NULL;
2154 DbgScopeMap.clear();
2155 DbgScopeBeginMap.clear();
2156 DbgScopeEndMap.clear();
2157 ConcreteScopes.clear();
2158 AbstractScopesList.clear();
2162 if (TimePassesIsEnabled)
2163 DebugTimer->stopTimer();
2166 /// recordSourceLine - Records location information and associates it with a
2167 /// label. Returns a unique label ID used to generate a label and provide
2168 /// correspondence to the source line list.
2169 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2174 if (TimePassesIsEnabled)
2175 DebugTimer->startTimer();
2180 DIDescriptor Scope(S);
2181 if (Scope.isCompileUnit()) {
2182 DICompileUnit CU(S);
2183 Dir = CU.getDirectory();
2184 Fn = CU.getFilename();
2185 } else if (Scope.isSubprogram()) {
2187 Dir = SP.getDirectory();
2188 Fn = SP.getFilename();
2189 } else if (Scope.isLexicalBlock()) {
2190 DILexicalBlock DB(S);
2191 Dir = DB.getDirectory();
2192 Fn = DB.getFilename();
2194 assert (0 && "Unexpected scope info");
2196 unsigned Src = GetOrCreateSourceID(Dir, Fn);
2197 unsigned ID = MMI->NextLabelID();
2198 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2200 if (TimePassesIsEnabled)
2201 DebugTimer->stopTimer();
2206 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2207 /// timed. Look up the source id with the given directory and source file
2208 /// names. If none currently exists, create a new id and insert it in the
2209 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2211 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2212 const std::string &FileName) {
2213 if (TimePassesIsEnabled)
2214 DebugTimer->startTimer();
2216 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2218 if (TimePassesIsEnabled)
2219 DebugTimer->stopTimer();
2224 //===----------------------------------------------------------------------===//
2226 //===----------------------------------------------------------------------===//
2228 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2231 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2232 // Get the children.
2233 const std::vector<DIE *> &Children = Die->getChildren();
2235 // If not last sibling and has children then add sibling offset attribute.
2236 if (!Last && !Children.empty()) Die->addSiblingOffset();
2238 // Record the abbreviation.
2239 assignAbbrevNumber(Die->getAbbrev());
2241 // Get the abbreviation for this DIE.
2242 unsigned AbbrevNumber = Die->getAbbrevNumber();
2243 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2246 Die->setOffset(Offset);
2248 // Start the size with the size of abbreviation code.
2249 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2251 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2252 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2254 // Size the DIE attribute values.
2255 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2256 // Size attribute value.
2257 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2259 // Size the DIE children if any.
2260 if (!Children.empty()) {
2261 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2262 "Children flag not set");
2264 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2265 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2267 // End of children marker.
2268 Offset += sizeof(int8_t);
2271 Die->setSize(Offset - Die->getOffset());
2275 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2277 void DwarfDebug::computeSizeAndOffsets() {
2278 // Compute size of compile unit header.
2279 static unsigned Offset =
2280 sizeof(int32_t) + // Length of Compilation Unit Info
2281 sizeof(int16_t) + // DWARF version number
2282 sizeof(int32_t) + // Offset Into Abbrev. Section
2283 sizeof(int8_t); // Pointer Size (in bytes)
2285 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2286 CompileUnitOffsets[ModuleCU] = 0;
2289 /// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
2290 /// tools to recognize the object file contains Dwarf information.
2291 void DwarfDebug::emitInitial() {
2292 // Check to see if we already emitted intial headers.
2293 if (didInitial) return;
2296 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2298 // Dwarf sections base addresses.
2299 if (MAI->doesDwarfRequireFrameSection()) {
2300 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2301 EmitLabel("section_debug_frame", 0);
2304 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2305 EmitLabel("section_info", 0);
2306 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2307 EmitLabel("section_abbrev", 0);
2308 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2309 EmitLabel("section_aranges", 0);
2311 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2312 Asm->OutStreamer.SwitchSection(LineInfoDirective);
2313 EmitLabel("section_macinfo", 0);
2316 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2317 EmitLabel("section_line", 0);
2318 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2319 EmitLabel("section_loc", 0);
2320 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2321 EmitLabel("section_pubnames", 0);
2322 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2323 EmitLabel("section_pubtypes", 0);
2324 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2325 EmitLabel("section_str", 0);
2326 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2327 EmitLabel("section_ranges", 0);
2329 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2330 EmitLabel("text_begin", 0);
2331 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2332 EmitLabel("data_begin", 0);
2335 /// emitDIE - Recusively Emits a debug information entry.
2337 void DwarfDebug::emitDIE(DIE *Die) {
2338 // Get the abbreviation for this DIE.
2339 unsigned AbbrevNumber = Die->getAbbrevNumber();
2340 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2344 // Emit the code (index) for the abbreviation.
2345 Asm->EmitULEB128Bytes(AbbrevNumber);
2347 if (Asm->isVerbose())
2348 Asm->EOL(std::string("Abbrev [" +
2349 utostr(AbbrevNumber) +
2350 "] 0x" + utohexstr(Die->getOffset()) +
2351 ":0x" + utohexstr(Die->getSize()) + " " +
2352 dwarf::TagString(Abbrev->getTag())));
2356 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2357 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2359 // Emit the DIE attribute values.
2360 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2361 unsigned Attr = AbbrevData[i].getAttribute();
2362 unsigned Form = AbbrevData[i].getForm();
2363 assert(Form && "Too many attributes for DIE (check abbreviation)");
2366 case dwarf::DW_AT_sibling:
2367 Asm->EmitInt32(Die->getSiblingOffset());
2369 case dwarf::DW_AT_abstract_origin: {
2370 DIEEntry *E = cast<DIEEntry>(Values[i]);
2371 DIE *Origin = E->getEntry();
2372 unsigned Addr = Origin->getOffset();
2373 Asm->EmitInt32(Addr);
2377 // Emit an attribute using the defined form.
2378 Values[i]->EmitValue(this, Form);
2382 Asm->EOL(dwarf::AttributeString(Attr));
2385 // Emit the DIE children if any.
2386 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2387 const std::vector<DIE *> &Children = Die->getChildren();
2389 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2390 emitDIE(Children[j]);
2392 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2396 /// emitDebugInfo - Emit the debug info section.
2398 void DwarfDebug::emitDebugInfo() {
2399 // Start debug info section.
2400 Asm->OutStreamer.SwitchSection(
2401 Asm->getObjFileLowering().getDwarfInfoSection());
2402 DIE *Die = ModuleCU->getCUDie();
2404 // Emit the compile units header.
2405 EmitLabel("info_begin", ModuleCU->getID());
2407 // Emit size of content not including length itself
2408 unsigned ContentSize = Die->getSize() +
2409 sizeof(int16_t) + // DWARF version number
2410 sizeof(int32_t) + // Offset Into Abbrev. Section
2411 sizeof(int8_t) + // Pointer Size (in bytes)
2412 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2414 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
2415 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2416 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2417 Asm->EOL("Offset Into Abbrev. Section");
2418 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2421 // FIXME - extra padding for gdb bug.
2422 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2423 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2424 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2425 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2426 EmitLabel("info_end", ModuleCU->getID());
2431 /// emitAbbreviations - Emit the abbreviation section.
2433 void DwarfDebug::emitAbbreviations() const {
2434 // Check to see if it is worth the effort.
2435 if (!Abbreviations.empty()) {
2436 // Start the debug abbrev section.
2437 Asm->OutStreamer.SwitchSection(
2438 Asm->getObjFileLowering().getDwarfAbbrevSection());
2440 EmitLabel("abbrev_begin", 0);
2442 // For each abbrevation.
2443 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2444 // Get abbreviation data
2445 const DIEAbbrev *Abbrev = Abbreviations[i];
2447 // Emit the abbrevations code (base 1 index.)
2448 Asm->EmitULEB128Bytes(Abbrev->getNumber());
2449 Asm->EOL("Abbreviation Code");
2451 // Emit the abbreviations data.
2457 // Mark end of abbreviations.
2458 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2460 EmitLabel("abbrev_end", 0);
2465 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2466 /// the line matrix.
2468 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2469 // Define last address of section.
2470 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2471 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2472 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2473 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2475 // Mark end of matrix.
2476 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2477 Asm->EmitULEB128Bytes(1); Asm->EOL();
2478 Asm->EmitInt8(1); Asm->EOL();
2481 /// emitDebugLines - Emit source line information.
2483 void DwarfDebug::emitDebugLines() {
2484 // If the target is using .loc/.file, the assembler will be emitting the
2485 // .debug_line table automatically.
2486 if (MAI->hasDotLocAndDotFile())
2489 // Minimum line delta, thus ranging from -10..(255-10).
2490 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2491 // Maximum line delta, thus ranging from -10..(255-10).
2492 const int MaxLineDelta = 255 + MinLineDelta;
2494 // Start the dwarf line section.
2495 Asm->OutStreamer.SwitchSection(
2496 Asm->getObjFileLowering().getDwarfLineSection());
2498 // Construct the section header.
2499 EmitDifference("line_end", 0, "line_begin", 0, true);
2500 Asm->EOL("Length of Source Line Info");
2501 EmitLabel("line_begin", 0);
2503 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2505 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2506 Asm->EOL("Prolog Length");
2507 EmitLabel("line_prolog_begin", 0);
2509 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2511 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2513 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2515 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2517 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2519 // Line number standard opcode encodings argument count
2520 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2521 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2522 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2523 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2524 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2525 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2526 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2527 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2528 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2530 // Emit directories.
2531 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2532 Asm->EmitString(getSourceDirectoryName(DI));
2533 Asm->EOL("Directory");
2536 Asm->EmitInt8(0); Asm->EOL("End of directories");
2539 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2540 // Remember source id starts at 1.
2541 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2542 Asm->EmitString(getSourceFileName(Id.second));
2544 Asm->EmitULEB128Bytes(Id.first);
2545 Asm->EOL("Directory #");
2546 Asm->EmitULEB128Bytes(0);
2547 Asm->EOL("Mod date");
2548 Asm->EmitULEB128Bytes(0);
2549 Asm->EOL("File size");
2552 Asm->EmitInt8(0); Asm->EOL("End of files");
2554 EmitLabel("line_prolog_end", 0);
2556 // A sequence for each text section.
2557 unsigned SecSrcLinesSize = SectionSourceLines.size();
2559 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2560 // Isolate current sections line info.
2561 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2563 /*if (Asm->isVerbose()) {
2564 const MCSection *S = SectionMap[j + 1];
2565 O << '\t' << MAI->getCommentString() << " Section"
2566 << S->getName() << '\n';
2570 // Dwarf assumes we start with first line of first source file.
2571 unsigned Source = 1;
2574 // Construct rows of the address, source, line, column matrix.
2575 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2576 const SrcLineInfo &LineInfo = LineInfos[i];
2577 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2578 if (!LabelID) continue;
2580 if (LineInfo.getLine() == 0) continue;
2582 if (!Asm->isVerbose())
2585 std::pair<unsigned, unsigned> SourceID =
2586 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2587 O << '\t' << MAI->getCommentString() << ' '
2588 << getSourceDirectoryName(SourceID.first) << '/'
2589 << getSourceFileName(SourceID.second)
2590 << ':' << utostr_32(LineInfo.getLine()) << '\n';
2593 // Define the line address.
2594 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2595 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2596 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2597 EmitReference("label", LabelID); Asm->EOL("Location label");
2599 // If change of source, then switch to the new source.
2600 if (Source != LineInfo.getSourceID()) {
2601 Source = LineInfo.getSourceID();
2602 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2603 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2606 // If change of line.
2607 if (Line != LineInfo.getLine()) {
2608 // Determine offset.
2609 int Offset = LineInfo.getLine() - Line;
2610 int Delta = Offset - MinLineDelta;
2613 Line = LineInfo.getLine();
2615 // If delta is small enough and in range...
2616 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2617 // ... then use fast opcode.
2618 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2620 // ... otherwise use long hand.
2621 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2622 Asm->EOL("DW_LNS_advance_line");
2623 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2624 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2627 // Copy the previous row (different address or source)
2628 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2632 emitEndOfLineMatrix(j + 1);
2635 if (SecSrcLinesSize == 0)
2636 // Because we're emitting a debug_line section, we still need a line
2637 // table. The linker and friends expect it to exist. If there's nothing to
2638 // put into it, emit an empty table.
2639 emitEndOfLineMatrix(1);
2641 EmitLabel("line_end", 0);
2645 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2647 void DwarfDebug::emitCommonDebugFrame() {
2648 if (!MAI->doesDwarfRequireFrameSection())
2652 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2653 TargetFrameInfo::StackGrowsUp ?
2654 TD->getPointerSize() : -TD->getPointerSize();
2656 // Start the dwarf frame section.
2657 Asm->OutStreamer.SwitchSection(
2658 Asm->getObjFileLowering().getDwarfFrameSection());
2660 EmitLabel("debug_frame_common", 0);
2661 EmitDifference("debug_frame_common_end", 0,
2662 "debug_frame_common_begin", 0, true);
2663 Asm->EOL("Length of Common Information Entry");
2665 EmitLabel("debug_frame_common_begin", 0);
2666 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2667 Asm->EOL("CIE Identifier Tag");
2668 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2669 Asm->EOL("CIE Version");
2670 Asm->EmitString("");
2671 Asm->EOL("CIE Augmentation");
2672 Asm->EmitULEB128Bytes(1);
2673 Asm->EOL("CIE Code Alignment Factor");
2674 Asm->EmitSLEB128Bytes(stackGrowth);
2675 Asm->EOL("CIE Data Alignment Factor");
2676 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2677 Asm->EOL("CIE RA Column");
2679 std::vector<MachineMove> Moves;
2680 RI->getInitialFrameState(Moves);
2682 EmitFrameMoves(NULL, 0, Moves, false);
2684 Asm->EmitAlignment(2, 0, 0, false);
2685 EmitLabel("debug_frame_common_end", 0);
2690 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2693 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2694 if (!MAI->doesDwarfRequireFrameSection())
2697 // Start the dwarf frame section.
2698 Asm->OutStreamer.SwitchSection(
2699 Asm->getObjFileLowering().getDwarfFrameSection());
2701 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2702 "debug_frame_begin", DebugFrameInfo.Number, true);
2703 Asm->EOL("Length of Frame Information Entry");
2705 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2707 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2709 Asm->EOL("FDE CIE offset");
2711 EmitReference("func_begin", DebugFrameInfo.Number);
2712 Asm->EOL("FDE initial location");
2713 EmitDifference("func_end", DebugFrameInfo.Number,
2714 "func_begin", DebugFrameInfo.Number);
2715 Asm->EOL("FDE address range");
2717 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2720 Asm->EmitAlignment(2, 0, 0, false);
2721 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2726 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2728 void DwarfDebug::emitDebugPubNames() {
2729 // Start the dwarf pubnames section.
2730 Asm->OutStreamer.SwitchSection(
2731 Asm->getObjFileLowering().getDwarfPubNamesSection());
2733 EmitDifference("pubnames_end", ModuleCU->getID(),
2734 "pubnames_begin", ModuleCU->getID(), true);
2735 Asm->EOL("Length of Public Names Info");
2737 EmitLabel("pubnames_begin", ModuleCU->getID());
2739 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2741 EmitSectionOffset("info_begin", "section_info",
2742 ModuleCU->getID(), 0, true, false);
2743 Asm->EOL("Offset of Compilation Unit Info");
2745 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2747 Asm->EOL("Compilation Unit Length");
2749 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2750 for (StringMap<DIE*>::const_iterator
2751 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2752 const char *Name = GI->getKeyData();
2753 DIE * Entity = GI->second;
2755 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2756 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2759 Asm->EmitInt32(0); Asm->EOL("End Mark");
2760 EmitLabel("pubnames_end", ModuleCU->getID());
2765 void DwarfDebug::emitDebugPubTypes() {
2766 // Start the dwarf pubnames section.
2767 Asm->OutStreamer.SwitchSection(
2768 Asm->getObjFileLowering().getDwarfPubTypesSection());
2769 EmitDifference("pubtypes_end", ModuleCU->getID(),
2770 "pubtypes_begin", ModuleCU->getID(), true);
2771 Asm->EOL("Length of Public Types Info");
2773 EmitLabel("pubtypes_begin", ModuleCU->getID());
2775 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2777 EmitSectionOffset("info_begin", "section_info",
2778 ModuleCU->getID(), 0, true, false);
2779 Asm->EOL("Offset of Compilation ModuleCU Info");
2781 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2783 Asm->EOL("Compilation ModuleCU Length");
2785 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2786 for (StringMap<DIE*>::const_iterator
2787 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2788 const char *Name = GI->getKeyData();
2789 DIE * Entity = GI->second;
2791 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2792 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2795 Asm->EmitInt32(0); Asm->EOL("End Mark");
2796 EmitLabel("pubtypes_end", ModuleCU->getID());
2801 /// emitDebugStr - Emit visible names into a debug str section.
2803 void DwarfDebug::emitDebugStr() {
2804 // Check to see if it is worth the effort.
2805 if (!StringPool.empty()) {
2806 // Start the dwarf str section.
2807 Asm->OutStreamer.SwitchSection(
2808 Asm->getObjFileLowering().getDwarfStrSection());
2810 // For each of strings in the string pool.
2811 for (unsigned StringID = 1, N = StringPool.size();
2812 StringID <= N; ++StringID) {
2813 // Emit a label for reference from debug information entries.
2814 EmitLabel("string", StringID);
2816 // Emit the string itself.
2817 const std::string &String = StringPool[StringID];
2818 Asm->EmitString(String); Asm->EOL();
2825 /// emitDebugLoc - Emit visible names into a debug loc section.
2827 void DwarfDebug::emitDebugLoc() {
2828 // Start the dwarf loc section.
2829 Asm->OutStreamer.SwitchSection(
2830 Asm->getObjFileLowering().getDwarfLocSection());
2834 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2836 void DwarfDebug::EmitDebugARanges() {
2837 // Start the dwarf aranges section.
2838 Asm->OutStreamer.SwitchSection(
2839 Asm->getObjFileLowering().getDwarfARangesSection());
2843 CompileUnit *Unit = GetBaseCompileUnit();
2845 // Don't include size of length
2846 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
2848 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2850 EmitReference("info_begin", Unit->getID());
2851 Asm->EOL("Offset of Compilation Unit Info");
2853 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2855 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2857 Asm->EmitInt16(0); Asm->EOL("Pad (1)");
2858 Asm->EmitInt16(0); Asm->EOL("Pad (2)");
2861 EmitReference("text_begin", 0); Asm->EOL("Address");
2862 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2864 Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2865 Asm->EmitInt32(0); Asm->EOL("EOM (2)");
2871 /// emitDebugRanges - Emit visible names into a debug ranges section.
2873 void DwarfDebug::emitDebugRanges() {
2874 // Start the dwarf ranges section.
2875 Asm->OutStreamer.SwitchSection(
2876 Asm->getObjFileLowering().getDwarfRangesSection());
2880 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2882 void DwarfDebug::emitDebugMacInfo() {
2883 if (const MCSection *LineInfo =
2884 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2885 // Start the dwarf macinfo section.
2886 Asm->OutStreamer.SwitchSection(LineInfo);
2891 /// emitDebugInlineInfo - Emit inline info using following format.
2893 /// 1. length of section
2894 /// 2. Dwarf version number
2895 /// 3. address size.
2897 /// Entries (one "entry" for each function that was inlined):
2899 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2900 /// otherwise offset into __debug_str for regular function name.
2901 /// 2. offset into __debug_str section for regular function name.
2902 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2903 /// instances for the function.
2905 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2906 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2907 /// __debug_info section, and the low_pc is the starting address for the
2908 /// inlining instance.
2909 void DwarfDebug::emitDebugInlineInfo() {
2910 if (!MAI->doesDwarfUsesInlineInfoSection())
2916 Asm->OutStreamer.SwitchSection(
2917 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2919 EmitDifference("debug_inlined_end", 1,
2920 "debug_inlined_begin", 1, true);
2921 Asm->EOL("Length of Debug Inlined Information Entry");
2923 EmitLabel("debug_inlined_begin", 1);
2925 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2926 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2928 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2929 E = InlinedSPNodes.end(); I != E; ++I) {
2932 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2933 = InlineInfo.find(Node);
2934 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2935 DISubprogram SP(Node);
2936 StringRef LName = SP.getLinkageName();
2937 StringRef Name = SP.getName();
2940 Asm->EmitString(Name);
2942 EmitSectionOffset("string", "section_str",
2943 StringPool.idFor(getRealLinkageName(LName)), false, true);
2945 Asm->EOL("MIPS linkage name");
2946 EmitSectionOffset("string", "section_str",
2947 StringPool.idFor(Name), false, true);
2948 Asm->EOL("Function name");
2949 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2951 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2952 LE = Labels.end(); LI != LE; ++LI) {
2953 DIE *SP = LI->second;
2954 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2956 if (TD->getPointerSize() == sizeof(int32_t))
2957 O << MAI->getData32bitsDirective();
2959 O << MAI->getData64bitsDirective();
2961 PrintLabelName("label", LI->first); Asm->EOL("low_pc");
2965 EmitLabel("debug_inlined_end", 1);