DwarfDebug.cpp revision 017c7f97bb1d77c393f15ebba21c92c31631df9f
1//===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file contains support for writing dwarf debug info into asm files. 11// 12//===----------------------------------------------------------------------===// 13 14#define DEBUG_TYPE "dwarfdebug" 15#include "DwarfDebug.h" 16#include "llvm/Module.h" 17#include "llvm/CodeGen/MachineFunction.h" 18#include "llvm/CodeGen/MachineModuleInfo.h" 19#include "llvm/MC/MCAsmInfo.h" 20#include "llvm/MC/MCSection.h" 21#include "llvm/MC/MCStreamer.h" 22#include "llvm/MC/MCSymbol.h" 23#include "llvm/Target/Mangler.h" 24#include "llvm/Target/TargetData.h" 25#include "llvm/Target/TargetFrameInfo.h" 26#include "llvm/Target/TargetLoweringObjectFile.h" 27#include "llvm/Target/TargetMachine.h" 28#include "llvm/Target/TargetRegisterInfo.h" 29#include "llvm/ADT/STLExtras.h" 30#include "llvm/ADT/StringExtras.h" 31#include "llvm/Support/Debug.h" 32#include "llvm/Support/ErrorHandling.h" 33#include "llvm/Support/ValueHandle.h" 34#include "llvm/Support/FormattedStream.h" 35#include "llvm/Support/Timer.h" 36#include "llvm/System/Path.h" 37using namespace llvm; 38 39//===----------------------------------------------------------------------===// 40 41/// Configuration values for initial hash set sizes (log2). 42/// 43static const unsigned InitAbbreviationsSetSize = 9; // log2(512) 44 45namespace llvm { 46 47//===----------------------------------------------------------------------===// 48/// CompileUnit - This dwarf writer support class manages information associate 49/// with a source file. 50class CompileUnit { 51 /// ID - File identifier for source. 52 /// 53 unsigned ID; 54 55 /// Die - Compile unit debug information entry. 56 /// 57 const OwningPtr<DIE> CUDie; 58 59 /// IndexTyDie - An anonymous type for index type. Owned by CUDie. 60 DIE *IndexTyDie; 61 62 /// GVToDieMap - Tracks the mapping of unit level debug informaton 63 /// variables to debug information entries. 64 /// FIXME : Rename GVToDieMap -> NodeToDieMap 65 DenseMap<MDNode *, DIE *> GVToDieMap; 66 67 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton 68 /// descriptors to debug information entries using a DIEEntry proxy. 69 /// FIXME : Rename 70 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap; 71 72 /// Globals - A map of globally visible named entities for this unit. 73 /// 74 StringMap<DIE*> Globals; 75 76 /// GlobalTypes - A map of globally visible types for this unit. 77 /// 78 StringMap<DIE*> GlobalTypes; 79 80public: 81 CompileUnit(unsigned I, DIE *D) 82 : ID(I), CUDie(D), IndexTyDie(0) {} 83 84 // Accessors. 85 unsigned getID() const { return ID; } 86 DIE* getCUDie() const { return CUDie.get(); } 87 const StringMap<DIE*> &getGlobals() const { return Globals; } 88 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; } 89 90 /// hasContent - Return true if this compile unit has something to write out. 91 /// 92 bool hasContent() const { return !CUDie->getChildren().empty(); } 93 94 /// addGlobal - Add a new global entity to the compile unit. 95 /// 96 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; } 97 98 /// addGlobalType - Add a new global type to the compile unit. 99 /// 100 void addGlobalType(StringRef Name, DIE *Die) { 101 GlobalTypes[Name] = Die; 102 } 103 104 /// getDIE - Returns the debug information entry map slot for the 105 /// specified debug variable. 106 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); } 107 108 /// insertDIE - Insert DIE into the map. 109 void insertDIE(MDNode *N, DIE *D) { 110 GVToDieMap.insert(std::make_pair(N, D)); 111 } 112 113 /// getDIEEntry - Returns the debug information entry for the speciefied 114 /// debug variable. 115 DIEEntry *getDIEEntry(MDNode *N) { 116 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N); 117 if (I == GVToDIEEntryMap.end()) 118 return NULL; 119 return I->second; 120 } 121 122 /// insertDIEEntry - Insert debug information entry into the map. 123 void insertDIEEntry(MDNode *N, DIEEntry *E) { 124 GVToDIEEntryMap.insert(std::make_pair(N, E)); 125 } 126 127 /// addDie - Adds or interns the DIE to the compile unit. 128 /// 129 void addDie(DIE *Buffer) { 130 this->CUDie->addChild(Buffer); 131 } 132 133 // getIndexTyDie - Get an anonymous type for index type. 134 DIE *getIndexTyDie() { 135 return IndexTyDie; 136 } 137 138 // setIndexTyDie - Set D as anonymous type for index which can be reused 139 // later. 140 void setIndexTyDie(DIE *D) { 141 IndexTyDie = D; 142 } 143 144}; 145 146//===----------------------------------------------------------------------===// 147/// DbgVariable - This class is used to track local variable information. 148/// 149class DbgVariable { 150 DIVariable Var; // Variable Descriptor. 151 unsigned FrameIndex; // Variable frame index. 152 const MachineInstr *DbgValueMInsn; // DBG_VALUE 153 // DbgValueLabel - DBG_VALUE is effective from this label. 154 MCSymbol *DbgValueLabel; 155 DbgVariable *const AbstractVar; // Abstract variable for this variable. 156 DIE *TheDIE; 157public: 158 // AbsVar may be NULL. 159 DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar) 160 : Var(V), FrameIndex(I), DbgValueMInsn(0), 161 DbgValueLabel(0), AbstractVar(AbsVar), TheDIE(0) {} 162 DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar) 163 : Var(V), FrameIndex(0), DbgValueMInsn(MI), DbgValueLabel(0), 164 AbstractVar(AbsVar), TheDIE(0) 165 {} 166 167 // Accessors. 168 DIVariable getVariable() const { return Var; } 169 unsigned getFrameIndex() const { return FrameIndex; } 170 const MachineInstr *getDbgValue() const { return DbgValueMInsn; } 171 MCSymbol *getDbgValueLabel() const { return DbgValueLabel; } 172 void setDbgValueLabel(MCSymbol *L) { DbgValueLabel = L; } 173 DbgVariable *getAbstractVariable() const { return AbstractVar; } 174 void setDIE(DIE *D) { TheDIE = D; } 175 DIE *getDIE() const { return TheDIE; } 176}; 177 178//===----------------------------------------------------------------------===// 179/// DbgScope - This class is used to track scope information. 180/// 181class DbgScope { 182 DbgScope *Parent; // Parent to this scope. 183 DIDescriptor Desc; // Debug info descriptor for scope. 184 // Location at which this scope is inlined. 185 AssertingVH<MDNode> InlinedAtLocation; 186 bool AbstractScope; // Abstract Scope 187 MCSymbol *StartLabel; // Label ID of the beginning of scope. 188 MCSymbol *EndLabel; // Label ID of the end of scope. 189 const MachineInstr *LastInsn; // Last instruction of this scope. 190 const MachineInstr *FirstInsn; // First instruction of this scope. 191 // Scopes defined in scope. Contents not owned. 192 SmallVector<DbgScope *, 4> Scopes; 193 // Variables declared in scope. Contents owned. 194 SmallVector<DbgVariable *, 8> Variables; 195 196 // Private state for dump() 197 mutable unsigned IndentLevel; 198public: 199 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0) 200 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false), 201 StartLabel(0), EndLabel(0), 202 LastInsn(0), FirstInsn(0), IndentLevel(0) {} 203 virtual ~DbgScope(); 204 205 // Accessors. 206 DbgScope *getParent() const { return Parent; } 207 void setParent(DbgScope *P) { Parent = P; } 208 DIDescriptor getDesc() const { return Desc; } 209 MDNode *getInlinedAt() const { return InlinedAtLocation; } 210 MDNode *getScopeNode() const { return Desc.getNode(); } 211 MCSymbol *getStartLabel() const { return StartLabel; } 212 MCSymbol *getEndLabel() const { return EndLabel; } 213 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; } 214 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; } 215 void setStartLabel(MCSymbol *S) { StartLabel = S; } 216 void setEndLabel(MCSymbol *E) { EndLabel = E; } 217 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; } 218 const MachineInstr *getLastInsn() { return LastInsn; } 219 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; } 220 void setAbstractScope() { AbstractScope = true; } 221 bool isAbstractScope() const { return AbstractScope; } 222 const MachineInstr *getFirstInsn() { return FirstInsn; } 223 224 /// addScope - Add a scope to the scope. 225 /// 226 void addScope(DbgScope *S) { Scopes.push_back(S); } 227 228 /// addVariable - Add a variable to the scope. 229 /// 230 void addVariable(DbgVariable *V) { Variables.push_back(V); } 231 232 void fixInstructionMarkers(DenseMap<const MachineInstr *, 233 unsigned> &MIIndexMap) { 234 assert(getFirstInsn() && "First instruction is missing!"); 235 236 // Use the end of last child scope as end of this scope. 237 const SmallVector<DbgScope *, 4> &Scopes = getScopes(); 238 const MachineInstr *LastInsn = getFirstInsn(); 239 unsigned LIndex = 0; 240 if (Scopes.empty()) { 241 assert(getLastInsn() && "Inner most scope does not have last insn!"); 242 return; 243 } 244 for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(), 245 SE = Scopes.end(); SI != SE; ++SI) { 246 DbgScope *DS = *SI; 247 DS->fixInstructionMarkers(MIIndexMap); 248 const MachineInstr *DSLastInsn = DS->getLastInsn(); 249 unsigned DSI = MIIndexMap[DSLastInsn]; 250 if (DSI > LIndex) { 251 LastInsn = DSLastInsn; 252 LIndex = DSI; 253 } 254 } 255 256 unsigned CurrentLastInsnIndex = 0; 257 if (const MachineInstr *CL = getLastInsn()) 258 CurrentLastInsnIndex = MIIndexMap[CL]; 259 unsigned FIndex = MIIndexMap[getFirstInsn()]; 260 261 // Set LastInsn as the last instruction for this scope only if 262 // it follows 263 // 1) this scope's first instruction and 264 // 2) current last instruction for this scope, if any. 265 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex) 266 setLastInsn(LastInsn); 267 } 268 269#ifndef NDEBUG 270 void dump() const; 271#endif 272}; 273 274#ifndef NDEBUG 275void DbgScope::dump() const { 276 raw_ostream &err = dbgs(); 277 err.indent(IndentLevel); 278 MDNode *N = Desc.getNode(); 279 N->dump(); 280 err << " [" << StartLabel << ", " << EndLabel << "]\n"; 281 if (AbstractScope) 282 err << "Abstract Scope\n"; 283 284 IndentLevel += 2; 285 if (!Scopes.empty()) 286 err << "Children ...\n"; 287 for (unsigned i = 0, e = Scopes.size(); i != e; ++i) 288 if (Scopes[i] != this) 289 Scopes[i]->dump(); 290 291 IndentLevel -= 2; 292} 293#endif 294 295DbgScope::~DbgScope() { 296 for (unsigned j = 0, M = Variables.size(); j < M; ++j) 297 delete Variables[j]; 298} 299 300} // end llvm namespace 301 302DwarfDebug::DwarfDebug(AsmPrinter *A) 303 : DwarfPrinter(A), ModuleCU(0), 304 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(), 305 DIEBlocks(), SectionSourceLines(), didInitial(false), shouldEmit(false), 306 CurrentFnDbgScope(0), DebugTimer(0) { 307 NextStringPoolNumber = 0; 308 if (TimePassesIsEnabled) 309 DebugTimer = new Timer("Dwarf Debug Writer"); 310} 311DwarfDebug::~DwarfDebug() { 312 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j) 313 DIEBlocks[j]->~DIEBlock(); 314 315 delete DebugTimer; 316} 317 318MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) { 319 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str]; 320 if (Entry.first) return Entry.first; 321 322 Entry.second = NextStringPoolNumber++; 323 return Entry.first = getDWLabel("string", Entry.second); 324} 325 326 327/// assignAbbrevNumber - Define a unique number for the abbreviation. 328/// 329void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) { 330 // Profile the node so that we can make it unique. 331 FoldingSetNodeID ID; 332 Abbrev.Profile(ID); 333 334 // Check the set for priors. 335 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev); 336 337 // If it's newly added. 338 if (InSet == &Abbrev) { 339 // Add to abbreviation list. 340 Abbreviations.push_back(&Abbrev); 341 342 // Assign the vector position + 1 as its number. 343 Abbrev.setNumber(Abbreviations.size()); 344 } else { 345 // Assign existing abbreviation number. 346 Abbrev.setNumber(InSet->getNumber()); 347 } 348} 349 350/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug 351/// information entry. 352DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) { 353 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry); 354 return Value; 355} 356 357/// addUInt - Add an unsigned integer attribute data and value. 358/// 359void DwarfDebug::addUInt(DIE *Die, unsigned Attribute, 360 unsigned Form, uint64_t Integer) { 361 if (!Form) Form = DIEInteger::BestForm(false, Integer); 362 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer); 363 Die->addValue(Attribute, Form, Value); 364} 365 366/// addSInt - Add an signed integer attribute data and value. 367/// 368void DwarfDebug::addSInt(DIE *Die, unsigned Attribute, 369 unsigned Form, int64_t Integer) { 370 if (!Form) Form = DIEInteger::BestForm(true, Integer); 371 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer); 372 Die->addValue(Attribute, Form, Value); 373} 374 375/// addString - Add a string attribute data and value. DIEString only 376/// keeps string reference. 377void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form, 378 StringRef String) { 379 DIEValue *Value = new (DIEValueAllocator) DIEString(String); 380 Die->addValue(Attribute, Form, Value); 381} 382 383/// addLabel - Add a Dwarf label attribute data and value. 384/// 385void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form, 386 const MCSymbol *Label) { 387 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label); 388 Die->addValue(Attribute, Form, Value); 389} 390 391/// addDelta - Add a label delta attribute data and value. 392/// 393void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form, 394 const MCSymbol *Hi, const MCSymbol *Lo) { 395 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo); 396 Die->addValue(Attribute, Form, Value); 397} 398 399/// addBlock - Add block data. 400/// 401void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form, 402 DIEBlock *Block) { 403 Block->ComputeSize(TD); 404 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on. 405 Die->addValue(Attribute, Block->BestForm(), Block); 406} 407 408/// addSourceLine - Add location information to specified debug information 409/// entry. 410void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) { 411 // If there is no compile unit specified, don't add a line #. 412 if (!V->getCompileUnit().Verify()) 413 return; 414 415 unsigned Line = V->getLineNumber(); 416 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(), 417 V->getContext().getFilename()); 418 assert(FileID && "Invalid file id"); 419 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 420 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 421} 422 423/// addSourceLine - Add location information to specified debug information 424/// entry. 425void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) { 426 // If there is no compile unit specified, don't add a line #. 427 if (!G->getCompileUnit().Verify()) 428 return; 429 430 unsigned Line = G->getLineNumber(); 431 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(), 432 G->getContext().getFilename()); 433 assert(FileID && "Invalid file id"); 434 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 435 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 436} 437 438/// addSourceLine - Add location information to specified debug information 439/// entry. 440void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) { 441 // If there is no compile unit specified, don't add a line #. 442 if (!SP->getCompileUnit().Verify()) 443 return; 444 // If the line number is 0, don't add it. 445 if (SP->getLineNumber() == 0) 446 return; 447 448 unsigned Line = SP->getLineNumber(); 449 if (!SP->getContext().Verify()) 450 return; 451 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(), 452 SP->getFilename()); 453 assert(FileID && "Invalid file id"); 454 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 455 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 456} 457 458/// addSourceLine - Add location information to specified debug information 459/// entry. 460void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) { 461 // If there is no compile unit specified, don't add a line #. 462 DICompileUnit CU = Ty->getCompileUnit(); 463 if (!CU.Verify()) 464 return; 465 466 unsigned Line = Ty->getLineNumber(); 467 if (!Ty->getContext().Verify()) 468 return; 469 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(), 470 Ty->getContext().getFilename()); 471 assert(FileID && "Invalid file id"); 472 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 473 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 474} 475 476/// addSourceLine - Add location information to specified debug information 477/// entry. 478void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) { 479 // If there is no compile unit specified, don't add a line #. 480 if (!NS->getCompileUnit().Verify()) 481 return; 482 483 unsigned Line = NS->getLineNumber(); 484 StringRef FN = NS->getFilename(); 485 StringRef Dir = NS->getDirectory(); 486 487 unsigned FileID = GetOrCreateSourceID(Dir, FN); 488 assert(FileID && "Invalid file id"); 489 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 490 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 491} 492 493/* Byref variables, in Blocks, are declared by the programmer as 494 "SomeType VarName;", but the compiler creates a 495 __Block_byref_x_VarName struct, and gives the variable VarName 496 either the struct, or a pointer to the struct, as its type. This 497 is necessary for various behind-the-scenes things the compiler 498 needs to do with by-reference variables in blocks. 499 500 However, as far as the original *programmer* is concerned, the 501 variable should still have type 'SomeType', as originally declared. 502 503 The following function dives into the __Block_byref_x_VarName 504 struct to find the original type of the variable. This will be 505 passed back to the code generating the type for the Debug 506 Information Entry for the variable 'VarName'. 'VarName' will then 507 have the original type 'SomeType' in its debug information. 508 509 The original type 'SomeType' will be the type of the field named 510 'VarName' inside the __Block_byref_x_VarName struct. 511 512 NOTE: In order for this to not completely fail on the debugger 513 side, the Debug Information Entry for the variable VarName needs to 514 have a DW_AT_location that tells the debugger how to unwind through 515 the pointers and __Block_byref_x_VarName struct to find the actual 516 value of the variable. The function addBlockByrefType does this. */ 517 518/// Find the type the programmer originally declared the variable to be 519/// and return that type. 520/// 521DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) { 522 523 DIType subType = Ty; 524 unsigned tag = Ty.getTag(); 525 526 if (tag == dwarf::DW_TAG_pointer_type) { 527 DIDerivedType DTy = DIDerivedType(Ty.getNode()); 528 subType = DTy.getTypeDerivedFrom(); 529 } 530 531 DICompositeType blockStruct = DICompositeType(subType.getNode()); 532 DIArray Elements = blockStruct.getTypeArray(); 533 534 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 535 DIDescriptor Element = Elements.getElement(i); 536 DIDerivedType DT = DIDerivedType(Element.getNode()); 537 if (Name == DT.getName()) 538 return (DT.getTypeDerivedFrom()); 539 } 540 541 return Ty; 542} 543 544/// addComplexAddress - Start with the address based on the location provided, 545/// and generate the DWARF information necessary to find the actual variable 546/// given the extra address information encoded in the DIVariable, starting from 547/// the starting location. Add the DWARF information to the die. 548/// 549void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die, 550 unsigned Attribute, 551 const MachineLocation &Location) { 552 const DIVariable &VD = DV->getVariable(); 553 DIType Ty = VD.getType(); 554 555 // Decode the original location, and use that as the start of the byref 556 // variable's location. 557 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false); 558 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 559 560 if (Location.isReg()) { 561 if (Reg < 32) { 562 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg); 563 } else { 564 Reg = Reg - dwarf::DW_OP_reg0; 565 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 566 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 567 } 568 } else { 569 if (Reg < 32) 570 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 571 else { 572 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 573 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 574 } 575 576 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 577 } 578 579 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) { 580 uint64_t Element = VD.getAddrElement(i); 581 582 if (Element == DIFactory::OpPlus) { 583 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 584 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i)); 585 } else if (Element == DIFactory::OpDeref) { 586 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 587 } else llvm_unreachable("unknown DIFactory Opcode"); 588 } 589 590 // Now attach the location information to the DIE. 591 addBlock(Die, Attribute, 0, Block); 592} 593 594/* Byref variables, in Blocks, are declared by the programmer as "SomeType 595 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and 596 gives the variable VarName either the struct, or a pointer to the struct, as 597 its type. This is necessary for various behind-the-scenes things the 598 compiler needs to do with by-reference variables in Blocks. 599 600 However, as far as the original *programmer* is concerned, the variable 601 should still have type 'SomeType', as originally declared. 602 603 The function getBlockByrefType dives into the __Block_byref_x_VarName 604 struct to find the original type of the variable, which is then assigned to 605 the variable's Debug Information Entry as its real type. So far, so good. 606 However now the debugger will expect the variable VarName to have the type 607 SomeType. So we need the location attribute for the variable to be an 608 expression that explains to the debugger how to navigate through the 609 pointers and struct to find the actual variable of type SomeType. 610 611 The following function does just that. We start by getting 612 the "normal" location for the variable. This will be the location 613 of either the struct __Block_byref_x_VarName or the pointer to the 614 struct __Block_byref_x_VarName. 615 616 The struct will look something like: 617 618 struct __Block_byref_x_VarName { 619 ... <various fields> 620 struct __Block_byref_x_VarName *forwarding; 621 ... <various other fields> 622 SomeType VarName; 623 ... <maybe more fields> 624 }; 625 626 If we are given the struct directly (as our starting point) we 627 need to tell the debugger to: 628 629 1). Add the offset of the forwarding field. 630 631 2). Follow that pointer to get the real __Block_byref_x_VarName 632 struct to use (the real one may have been copied onto the heap). 633 634 3). Add the offset for the field VarName, to find the actual variable. 635 636 If we started with a pointer to the struct, then we need to 637 dereference that pointer first, before the other steps. 638 Translating this into DWARF ops, we will need to append the following 639 to the current location description for the variable: 640 641 DW_OP_deref -- optional, if we start with a pointer 642 DW_OP_plus_uconst <forward_fld_offset> 643 DW_OP_deref 644 DW_OP_plus_uconst <varName_fld_offset> 645 646 That is what this function does. */ 647 648/// addBlockByrefAddress - Start with the address based on the location 649/// provided, and generate the DWARF information necessary to find the 650/// actual Block variable (navigating the Block struct) based on the 651/// starting location. Add the DWARF information to the die. For 652/// more information, read large comment just above here. 653/// 654void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die, 655 unsigned Attribute, 656 const MachineLocation &Location) { 657 const DIVariable &VD = DV->getVariable(); 658 DIType Ty = VD.getType(); 659 DIType TmpTy = Ty; 660 unsigned Tag = Ty.getTag(); 661 bool isPointer = false; 662 663 StringRef varName = VD.getName(); 664 665 if (Tag == dwarf::DW_TAG_pointer_type) { 666 DIDerivedType DTy = DIDerivedType(Ty.getNode()); 667 TmpTy = DTy.getTypeDerivedFrom(); 668 isPointer = true; 669 } 670 671 DICompositeType blockStruct = DICompositeType(TmpTy.getNode()); 672 673 // Find the __forwarding field and the variable field in the __Block_byref 674 // struct. 675 DIArray Fields = blockStruct.getTypeArray(); 676 DIDescriptor varField = DIDescriptor(); 677 DIDescriptor forwardingField = DIDescriptor(); 678 679 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) { 680 DIDescriptor Element = Fields.getElement(i); 681 DIDerivedType DT = DIDerivedType(Element.getNode()); 682 StringRef fieldName = DT.getName(); 683 if (fieldName == "__forwarding") 684 forwardingField = Element; 685 else if (fieldName == varName) 686 varField = Element; 687 } 688 689 // Get the offsets for the forwarding field and the variable field. 690 unsigned forwardingFieldOffset = 691 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3; 692 unsigned varFieldOffset = 693 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3; 694 695 // Decode the original location, and use that as the start of the byref 696 // variable's location. 697 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false); 698 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 699 700 if (Location.isReg()) { 701 if (Reg < 32) 702 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg); 703 else { 704 Reg = Reg - dwarf::DW_OP_reg0; 705 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 706 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 707 } 708 } else { 709 if (Reg < 32) 710 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 711 else { 712 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 713 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 714 } 715 716 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 717 } 718 719 // If we started with a pointer to the __Block_byref... struct, then 720 // the first thing we need to do is dereference the pointer (DW_OP_deref). 721 if (isPointer) 722 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 723 724 // Next add the offset for the '__forwarding' field: 725 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in 726 // adding the offset if it's 0. 727 if (forwardingFieldOffset > 0) { 728 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 729 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset); 730 } 731 732 // Now dereference the __forwarding field to get to the real __Block_byref 733 // struct: DW_OP_deref. 734 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 735 736 // Now that we've got the real __Block_byref... struct, add the offset 737 // for the variable's field to get to the location of the actual variable: 738 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0. 739 if (varFieldOffset > 0) { 740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 741 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset); 742 } 743 744 // Now attach the location information to the DIE. 745 addBlock(Die, Attribute, 0, Block); 746} 747 748/// addAddress - Add an address attribute to a die based on the location 749/// provided. 750void DwarfDebug::addAddress(DIE *Die, unsigned Attribute, 751 const MachineLocation &Location) { 752 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false); 753 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 754 755 if (Location.isReg()) { 756 if (Reg < 32) { 757 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg); 758 } else { 759 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx); 760 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 761 } 762 } else { 763 if (Reg < 32) { 764 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 765 } else { 766 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 767 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 768 } 769 770 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 771 } 772 773 addBlock(Die, Attribute, 0, Block); 774} 775 776/// addToContextOwner - Add Die into the list of its context owner's children. 777void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) { 778 if (Context.isType()) { 779 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode())); 780 ContextDIE->addChild(Die); 781 } else if (Context.isNameSpace()) { 782 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode())); 783 ContextDIE->addChild(Die); 784 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode())) 785 ContextDIE->addChild(Die); 786 else 787 ModuleCU->addDie(Die); 788} 789 790/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the 791/// given DIType. 792DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) { 793 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode()); 794 if (TyDIE) 795 return TyDIE; 796 797 // Create new type. 798 TyDIE = new DIE(dwarf::DW_TAG_base_type); 799 ModuleCU->insertDIE(Ty.getNode(), TyDIE); 800 if (Ty.isBasicType()) 801 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode())); 802 else if (Ty.isCompositeType()) 803 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode())); 804 else { 805 assert(Ty.isDerivedType() && "Unknown kind of DIType"); 806 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode())); 807 } 808 809 addToContextOwner(TyDIE, Ty.getContext()); 810 return TyDIE; 811} 812 813/// addType - Add a new type attribute to the specified entity. 814void DwarfDebug::addType(DIE *Entity, DIType Ty) { 815 if (!Ty.isValid()) 816 return; 817 818 // Check for pre-existence. 819 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode()); 820 // If it exists then use the existing value. 821 if (Entry) { 822 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry); 823 return; 824 } 825 826 // Construct type. 827 DIE *Buffer = getOrCreateTypeDIE(Ty); 828 829 // Set up proxy. 830 Entry = createDIEEntry(Buffer); 831 ModuleCU->insertDIEEntry(Ty.getNode(), Entry); 832 833 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry); 834} 835 836/// constructTypeDIE - Construct basic type die from DIBasicType. 837void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) { 838 // Get core information. 839 StringRef Name = BTy.getName(); 840 Buffer.setTag(dwarf::DW_TAG_base_type); 841 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 842 BTy.getEncoding()); 843 844 // Add name if not anonymous or intermediate type. 845 if (!Name.empty()) 846 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 847 uint64_t Size = BTy.getSizeInBits() >> 3; 848 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 849} 850 851/// constructTypeDIE - Construct derived type die from DIDerivedType. 852void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) { 853 // Get core information. 854 StringRef Name = DTy.getName(); 855 uint64_t Size = DTy.getSizeInBits() >> 3; 856 unsigned Tag = DTy.getTag(); 857 858 // FIXME - Workaround for templates. 859 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type; 860 861 Buffer.setTag(Tag); 862 863 // Map to main type, void will not have a type. 864 DIType FromTy = DTy.getTypeDerivedFrom(); 865 addType(&Buffer, FromTy); 866 867 // Add name if not anonymous or intermediate type. 868 if (!Name.empty()) 869 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 870 871 // Add size if non-zero (derived types might be zero-sized.) 872 if (Size) 873 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 874 875 // Add source line info if available and TyDesc is not a forward declaration. 876 if (!DTy.isForwardDecl()) 877 addSourceLine(&Buffer, &DTy); 878} 879 880/// constructTypeDIE - Construct type DIE from DICompositeType. 881void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) { 882 // Get core information. 883 StringRef Name = CTy.getName(); 884 885 uint64_t Size = CTy.getSizeInBits() >> 3; 886 unsigned Tag = CTy.getTag(); 887 Buffer.setTag(Tag); 888 889 switch (Tag) { 890 case dwarf::DW_TAG_vector_type: 891 case dwarf::DW_TAG_array_type: 892 constructArrayTypeDIE(Buffer, &CTy); 893 break; 894 case dwarf::DW_TAG_enumeration_type: { 895 DIArray Elements = CTy.getTypeArray(); 896 897 // Add enumerators to enumeration type. 898 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 899 DIE *ElemDie = NULL; 900 DIDescriptor Enum(Elements.getElement(i).getNode()); 901 if (Enum.isEnumerator()) { 902 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode())); 903 Buffer.addChild(ElemDie); 904 } 905 } 906 } 907 break; 908 case dwarf::DW_TAG_subroutine_type: { 909 // Add return type. 910 DIArray Elements = CTy.getTypeArray(); 911 DIDescriptor RTy = Elements.getElement(0); 912 addType(&Buffer, DIType(RTy.getNode())); 913 914 // Add prototype flag. 915 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1); 916 917 // Add arguments. 918 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) { 919 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 920 DIDescriptor Ty = Elements.getElement(i); 921 addType(Arg, DIType(Ty.getNode())); 922 Buffer.addChild(Arg); 923 } 924 } 925 break; 926 case dwarf::DW_TAG_structure_type: 927 case dwarf::DW_TAG_union_type: 928 case dwarf::DW_TAG_class_type: { 929 // Add elements to structure type. 930 DIArray Elements = CTy.getTypeArray(); 931 932 // A forward struct declared type may not have elements available. 933 unsigned N = Elements.getNumElements(); 934 if (N == 0) 935 break; 936 937 // Add elements to structure type. 938 for (unsigned i = 0; i < N; ++i) { 939 DIDescriptor Element = Elements.getElement(i); 940 DIE *ElemDie = NULL; 941 if (Element.isSubprogram()) 942 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode())); 943 else if (Element.isVariable()) { 944 DIVariable DV(Element.getNode()); 945 ElemDie = new DIE(dwarf::DW_TAG_variable); 946 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, 947 DV.getName()); 948 addType(ElemDie, DV.getType()); 949 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 950 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 951 addSourceLine(ElemDie, &DV); 952 } else if (Element.isDerivedType()) 953 ElemDie = createMemberDIE(DIDerivedType(Element.getNode())); 954 else 955 continue; 956 Buffer.addChild(ElemDie); 957 } 958 959 if (CTy.isAppleBlockExtension()) 960 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1); 961 962 unsigned RLang = CTy.getRunTimeLang(); 963 if (RLang) 964 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, 965 dwarf::DW_FORM_data1, RLang); 966 967 DICompositeType ContainingType = CTy.getContainingType(); 968 if (DIDescriptor(ContainingType.getNode()).isCompositeType()) 969 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 970 getOrCreateTypeDIE(DIType(ContainingType.getNode()))); 971 break; 972 } 973 default: 974 break; 975 } 976 977 // Add name if not anonymous or intermediate type. 978 if (!Name.empty()) 979 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 980 981 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type || 982 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) { 983 // Add size if non-zero (derived types might be zero-sized.) 984 if (Size) 985 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 986 else { 987 // Add zero size if it is not a forward declaration. 988 if (CTy.isForwardDecl()) 989 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 990 else 991 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0); 992 } 993 994 // Add source line info if available. 995 if (!CTy.isForwardDecl()) 996 addSourceLine(&Buffer, &CTy); 997 } 998} 999 1000/// constructSubrangeDIE - Construct subrange DIE from DISubrange. 1001void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){ 1002 int64_t L = SR.getLo(); 1003 int64_t H = SR.getHi(); 1004 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type); 1005 1006 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy); 1007 if (L) 1008 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L); 1009 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H); 1010 1011 Buffer.addChild(DW_Subrange); 1012} 1013 1014/// constructArrayTypeDIE - Construct array type DIE from DICompositeType. 1015void DwarfDebug::constructArrayTypeDIE(DIE &Buffer, 1016 DICompositeType *CTy) { 1017 Buffer.setTag(dwarf::DW_TAG_array_type); 1018 if (CTy->getTag() == dwarf::DW_TAG_vector_type) 1019 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1); 1020 1021 // Emit derived type. 1022 addType(&Buffer, CTy->getTypeDerivedFrom()); 1023 DIArray Elements = CTy->getTypeArray(); 1024 1025 // Get an anonymous type for index type. 1026 DIE *IdxTy = ModuleCU->getIndexTyDie(); 1027 if (!IdxTy) { 1028 // Construct an anonymous type for index type. 1029 IdxTy = new DIE(dwarf::DW_TAG_base_type); 1030 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t)); 1031 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 1032 dwarf::DW_ATE_signed); 1033 ModuleCU->addDie(IdxTy); 1034 ModuleCU->setIndexTyDie(IdxTy); 1035 } 1036 1037 // Add subranges to array type. 1038 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1039 DIDescriptor Element = Elements.getElement(i); 1040 if (Element.getTag() == dwarf::DW_TAG_subrange_type) 1041 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy); 1042 } 1043} 1044 1045/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator. 1046DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) { 1047 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator); 1048 StringRef Name = ETy.getName(); 1049 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1050 int64_t Value = ETy.getEnumValue(); 1051 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value); 1052 return Enumerator; 1053} 1054 1055/// getRealLinkageName - If special LLVM prefix that is used to inform the asm 1056/// printer to not emit usual symbol prefix before the symbol name is used then 1057/// return linkage name after skipping this special LLVM prefix. 1058static StringRef getRealLinkageName(StringRef LinkageName) { 1059 char One = '\1'; 1060 if (LinkageName.startswith(StringRef(&One, 1))) 1061 return LinkageName.substr(1); 1062 return LinkageName; 1063} 1064 1065/// createGlobalVariableDIE - Create new DIE using GV. 1066DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) { 1067 // If the global variable was optmized out then no need to create debug info 1068 // entry. 1069 if (!GV.getGlobal()) return NULL; 1070 if (GV.getDisplayName().empty()) return NULL; 1071 1072 DIE *GVDie = new DIE(dwarf::DW_TAG_variable); 1073 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, 1074 GV.getDisplayName()); 1075 1076 StringRef LinkageName = GV.getLinkageName(); 1077 if (!LinkageName.empty()) 1078 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string, 1079 getRealLinkageName(LinkageName)); 1080 1081 addType(GVDie, GV.getType()); 1082 if (!GV.isLocalToUnit()) 1083 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1084 addSourceLine(GVDie, &GV); 1085 1086 return GVDie; 1087} 1088 1089/// createMemberDIE - Create new member DIE. 1090DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) { 1091 DIE *MemberDie = new DIE(DT.getTag()); 1092 StringRef Name = DT.getName(); 1093 if (!Name.empty()) 1094 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1095 1096 addType(MemberDie, DT.getTypeDerivedFrom()); 1097 1098 addSourceLine(MemberDie, &DT); 1099 1100 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock(); 1101 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 1102 1103 uint64_t Size = DT.getSizeInBits(); 1104 uint64_t FieldSize = DT.getOriginalTypeSize(); 1105 1106 if (Size != FieldSize) { 1107 // Handle bitfield. 1108 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3); 1109 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits()); 1110 1111 uint64_t Offset = DT.getOffsetInBits(); 1112 uint64_t AlignMask = ~(DT.getAlignInBits() - 1); 1113 uint64_t HiMark = (Offset + FieldSize) & AlignMask; 1114 uint64_t FieldOffset = (HiMark - FieldSize); 1115 Offset -= FieldOffset; 1116 1117 // Maybe we need to work from the other end. 1118 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size); 1119 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset); 1120 1121 // Here WD_AT_data_member_location points to the anonymous 1122 // field that includes this bit field. 1123 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3); 1124 1125 } else 1126 // This is not a bitfield. 1127 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3); 1128 1129 if (DT.getTag() == dwarf::DW_TAG_inheritance 1130 && DT.isVirtual()) { 1131 1132 // For C++, virtual base classes are not at fixed offset. Use following 1133 // expression to extract appropriate offset from vtable. 1134 // BaseAddr = ObAddr + *((*ObAddr) - Offset) 1135 1136 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock(); 1137 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup); 1138 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1139 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1140 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits()); 1141 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus); 1142 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1143 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1144 1145 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, 1146 VBaseLocationDie); 1147 } else 1148 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie); 1149 1150 if (DT.isProtected()) 1151 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1152 dwarf::DW_ACCESS_protected); 1153 else if (DT.isPrivate()) 1154 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1155 dwarf::DW_ACCESS_private); 1156 else if (DT.getTag() == dwarf::DW_TAG_inheritance) 1157 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1158 dwarf::DW_ACCESS_public); 1159 if (DT.isVirtual()) 1160 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, 1161 dwarf::DW_VIRTUALITY_virtual); 1162 return MemberDie; 1163} 1164 1165/// createSubprogramDIE - Create new DIE using SP. 1166DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) { 1167 DIE *SPDie = ModuleCU->getDIE(SP.getNode()); 1168 if (SPDie) 1169 return SPDie; 1170 1171 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1172 // Constructors and operators for anonymous aggregates do not have names. 1173 if (!SP.getName().empty()) 1174 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName()); 1175 1176 StringRef LinkageName = SP.getLinkageName(); 1177 if (!LinkageName.empty()) 1178 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string, 1179 getRealLinkageName(LinkageName)); 1180 1181 addSourceLine(SPDie, &SP); 1182 1183 // Add prototyped tag, if C or ObjC. 1184 unsigned Lang = SP.getCompileUnit().getLanguage(); 1185 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 || 1186 Lang == dwarf::DW_LANG_ObjC) 1187 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1); 1188 1189 // Add Return Type. 1190 DICompositeType SPTy = SP.getType(); 1191 DIArray Args = SPTy.getTypeArray(); 1192 unsigned SPTag = SPTy.getTag(); 1193 1194 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type) 1195 addType(SPDie, SPTy); 1196 else 1197 addType(SPDie, DIType(Args.getElement(0).getNode())); 1198 1199 unsigned VK = SP.getVirtuality(); 1200 if (VK) { 1201 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK); 1202 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1203 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1204 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex()); 1205 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block); 1206 ContainingTypeMap.insert(std::make_pair(SPDie, 1207 SP.getContainingType().getNode())); 1208 } 1209 1210 if (MakeDecl || !SP.isDefinition()) { 1211 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1212 1213 // Add arguments. Do not add arguments for subprogram definition. They will 1214 // be handled while processing variables. 1215 DICompositeType SPTy = SP.getType(); 1216 DIArray Args = SPTy.getTypeArray(); 1217 unsigned SPTag = SPTy.getTag(); 1218 1219 if (SPTag == dwarf::DW_TAG_subroutine_type) 1220 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1221 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1222 DIType ATy = DIType(DIType(Args.getElement(i).getNode())); 1223 addType(Arg, ATy); 1224 if (ATy.isArtificial()) 1225 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1226 SPDie->addChild(Arg); 1227 } 1228 } 1229 1230 if (SP.isArtificial()) 1231 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1232 1233 // DW_TAG_inlined_subroutine may refer to this DIE. 1234 ModuleCU->insertDIE(SP.getNode(), SPDie); 1235 return SPDie; 1236} 1237 1238/// getUpdatedDbgScope - Find DbgScope assicated with the instruction. 1239/// Update scope hierarchy. Create abstract scope if required. 1240DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI, 1241 MDNode *InlinedAt) { 1242 assert(N && "Invalid Scope encoding!"); 1243 assert(MI && "Missing machine instruction!"); 1244 bool isAConcreteScope = InlinedAt != 0; 1245 1246 DbgScope *NScope = NULL; 1247 1248 if (InlinedAt) 1249 NScope = DbgScopeMap.lookup(InlinedAt); 1250 else 1251 NScope = DbgScopeMap.lookup(N); 1252 assert(NScope && "Unable to find working scope!"); 1253 1254 if (NScope->getFirstInsn()) 1255 return NScope; 1256 1257 DbgScope *Parent = NULL; 1258 if (isAConcreteScope) { 1259 DILocation IL(InlinedAt); 1260 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI, 1261 IL.getOrigLocation().getNode()); 1262 assert(Parent && "Unable to find Parent scope!"); 1263 NScope->setParent(Parent); 1264 Parent->addScope(NScope); 1265 } else if (DIDescriptor(N).isLexicalBlock()) { 1266 DILexicalBlock DB(N); 1267 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt); 1268 NScope->setParent(Parent); 1269 Parent->addScope(NScope); 1270 } 1271 1272 NScope->setFirstInsn(MI); 1273 1274 if (!Parent && !InlinedAt) { 1275 StringRef SPName = DISubprogram(N).getLinkageName(); 1276 if (SPName == MF->getFunction()->getName()) 1277 CurrentFnDbgScope = NScope; 1278 } 1279 1280 if (isAConcreteScope) { 1281 ConcreteScopes[InlinedAt] = NScope; 1282 getOrCreateAbstractScope(N); 1283 } 1284 1285 return NScope; 1286} 1287 1288DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) { 1289 assert(N && "Invalid Scope encoding!"); 1290 1291 DbgScope *AScope = AbstractScopes.lookup(N); 1292 if (AScope) 1293 return AScope; 1294 1295 DbgScope *Parent = NULL; 1296 1297 DIDescriptor Scope(N); 1298 if (Scope.isLexicalBlock()) { 1299 DILexicalBlock DB(N); 1300 DIDescriptor ParentDesc = DB.getContext(); 1301 Parent = getOrCreateAbstractScope(ParentDesc.getNode()); 1302 } 1303 1304 AScope = new DbgScope(Parent, DIDescriptor(N), NULL); 1305 1306 if (Parent) 1307 Parent->addScope(AScope); 1308 AScope->setAbstractScope(); 1309 AbstractScopes[N] = AScope; 1310 if (DIDescriptor(N).isSubprogram()) 1311 AbstractScopesList.push_back(AScope); 1312 return AScope; 1313} 1314 1315/// updateSubprogramScopeDIE - Find DIE for the given subprogram and 1316/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes. 1317/// If there are global variables in this scope then create and insert 1318/// DIEs for these variables. 1319DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) { 1320 DIE *SPDie = ModuleCU->getDIE(SPNode); 1321 assert(SPDie && "Unable to find subprogram DIE!"); 1322 DISubprogram SP(SPNode); 1323 1324 // There is not any need to generate specification DIE for a function 1325 // defined at compile unit level. If a function is defined inside another 1326 // function then gdb prefers the definition at top level and but does not 1327 // expect specification DIE in parent function. So avoid creating 1328 // specification DIE for a function defined inside a function. 1329 if (SP.isDefinition() && !SP.getContext().isCompileUnit() && 1330 !SP.getContext().isFile() && !SP.getContext().isSubprogram()) { 1331 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1332 1333 // Add arguments. 1334 DICompositeType SPTy = SP.getType(); 1335 DIArray Args = SPTy.getTypeArray(); 1336 unsigned SPTag = SPTy.getTag(); 1337 if (SPTag == dwarf::DW_TAG_subroutine_type) 1338 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1339 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1340 DIType ATy = DIType(DIType(Args.getElement(i).getNode())); 1341 addType(Arg, ATy); 1342 if (ATy.isArtificial()) 1343 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1344 SPDie->addChild(Arg); 1345 } 1346 DIE *SPDeclDie = SPDie; 1347 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1348 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4, 1349 SPDeclDie); 1350 ModuleCU->addDie(SPDie); 1351 } 1352 1353 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 1354 getDWLabel("func_begin", SubprogramCount)); 1355 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, 1356 getDWLabel("func_end", SubprogramCount)); 1357 MachineLocation Location(RI->getFrameRegister(*MF)); 1358 addAddress(SPDie, dwarf::DW_AT_frame_base, Location); 1359 1360 if (!DISubprogram(SPNode).isLocalToUnit()) 1361 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1362 1363 return SPDie; 1364} 1365 1366/// constructLexicalScope - Construct new DW_TAG_lexical_block 1367/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels. 1368DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) { 1369 MCSymbol *Start = Scope->getStartLabel(); 1370 MCSymbol *End = Scope->getEndLabel(); 1371 if (Start == 0 || End == 0) return 0; 1372 1373 assert(Start->isDefined() && "Invalid starting label for an inlined scope!"); 1374 assert(End->isDefined() && "Invalid end label for an inlined scope!"); 1375 1376 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block); 1377 if (Scope->isAbstractScope()) 1378 return ScopeDIE; 1379 1380 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 1381 Start ? Start : getDWLabel("func_begin", SubprogramCount)); 1382 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, 1383 End ? End : getDWLabel("func_end", SubprogramCount)); 1384 1385 return ScopeDIE; 1386} 1387 1388/// constructInlinedScopeDIE - This scope represents inlined body of 1389/// a function. Construct DIE to represent this concrete inlined copy 1390/// of the function. 1391DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) { 1392 MCSymbol *StartLabel = Scope->getStartLabel(); 1393 MCSymbol *EndLabel = Scope->getEndLabel(); 1394 if (StartLabel == 0 || EndLabel == 0) return 0; 1395 1396 assert(StartLabel->isDefined() && 1397 "Invalid starting label for an inlined scope!"); 1398 assert(EndLabel->isDefined() && 1399 "Invalid end label for an inlined scope!"); 1400 if (!Scope->getScopeNode()) 1401 return NULL; 1402 DIScope DS(Scope->getScopeNode()); 1403 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine); 1404 1405 DISubprogram InlinedSP = getDISubprogram(DS.getNode()); 1406 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode()); 1407 assert(OriginDIE && "Unable to find Origin DIE!"); 1408 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, 1409 dwarf::DW_FORM_ref4, OriginDIE); 1410 1411 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel); 1412 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel); 1413 1414 InlinedSubprogramDIEs.insert(OriginDIE); 1415 1416 // Track the start label for this inlined function. 1417 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator 1418 I = InlineInfo.find(InlinedSP.getNode()); 1419 1420 if (I == InlineInfo.end()) { 1421 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel, 1422 ScopeDIE)); 1423 InlinedSPNodes.push_back(InlinedSP.getNode()); 1424 } else 1425 I->second.push_back(std::make_pair(StartLabel, ScopeDIE)); 1426 1427 DILocation DL(Scope->getInlinedAt()); 1428 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID()); 1429 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber()); 1430 1431 return ScopeDIE; 1432} 1433 1434 1435/// constructVariableDIE - Construct a DIE for the given DbgVariable. 1436DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) { 1437 // Get the descriptor. 1438 const DIVariable &VD = DV->getVariable(); 1439 StringRef Name = VD.getName(); 1440 if (Name.empty()) 1441 return NULL; 1442 1443 // Translate tag to proper Dwarf tag. The result variable is dropped for 1444 // now. 1445 unsigned Tag; 1446 switch (VD.getTag()) { 1447 case dwarf::DW_TAG_return_variable: 1448 return NULL; 1449 case dwarf::DW_TAG_arg_variable: 1450 Tag = dwarf::DW_TAG_formal_parameter; 1451 break; 1452 case dwarf::DW_TAG_auto_variable: // fall thru 1453 default: 1454 Tag = dwarf::DW_TAG_variable; 1455 break; 1456 } 1457 1458 // Define variable debug information entry. 1459 DIE *VariableDie = new DIE(Tag); 1460 1461 1462 DIE *AbsDIE = NULL; 1463 if (DbgVariable *AV = DV->getAbstractVariable()) 1464 AbsDIE = AV->getDIE(); 1465 1466 if (AbsDIE) { 1467 DIScope DS(Scope->getScopeNode()); 1468 DISubprogram InlinedSP = getDISubprogram(DS.getNode()); 1469 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode()); 1470 (void) OriginSPDIE; 1471 assert(OriginSPDIE && "Unable to find Origin DIE for the SP!"); 1472 DIE *AbsDIE = DV->getAbstractVariable()->getDIE(); 1473 assert(AbsDIE && "Unable to find Origin DIE for the Variable!"); 1474 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, 1475 dwarf::DW_FORM_ref4, AbsDIE); 1476 } 1477 else { 1478 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1479 addSourceLine(VariableDie, &VD); 1480 1481 // Add variable type. 1482 // FIXME: isBlockByrefVariable should be reformulated in terms of complex 1483 // addresses instead. 1484 if (VD.isBlockByrefVariable()) 1485 addType(VariableDie, getBlockByrefType(VD.getType(), Name)); 1486 else 1487 addType(VariableDie, VD.getType()); 1488 } 1489 1490 // Add variable address. 1491 if (!Scope->isAbstractScope()) { 1492 // Check if variable is described by DBG_VALUE instruction. 1493 if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) { 1494 if (DbgValueInsn->getNumOperands() == 3) { 1495 // FIXME : Handle getNumOperands != 3 1496 if (DbgValueInsn->getOperand(0).getType() 1497 == MachineOperand::MO_Register 1498 && DbgValueInsn->getOperand(0).getReg()) { 1499 MachineLocation Location; 1500 Location.set(DbgValueInsn->getOperand(0).getReg()); 1501 addAddress(VariableDie, dwarf::DW_AT_location, Location); 1502 if (MCSymbol *VS = DV->getDbgValueLabel()) 1503 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, 1504 VS); 1505 } else if (DbgValueInsn->getOperand(0).getType() == 1506 MachineOperand::MO_Immediate) { 1507 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1508 unsigned Imm = DbgValueInsn->getOperand(0).getImm(); 1509 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm); 1510 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block); 1511 if (MCSymbol *VS = DV->getDbgValueLabel()) 1512 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, 1513 VS); 1514 } else { 1515 //FIXME : Handle other operand types. 1516 delete VariableDie; 1517 return NULL; 1518 } 1519 } 1520 } else { 1521 MachineLocation Location; 1522 unsigned FrameReg; 1523 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), 1524 FrameReg); 1525 Location.set(FrameReg, Offset); 1526 1527 if (VD.hasComplexAddress()) 1528 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location); 1529 else if (VD.isBlockByrefVariable()) 1530 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location); 1531 else 1532 addAddress(VariableDie, dwarf::DW_AT_location, Location); 1533 } 1534 } 1535 1536 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial()) 1537 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1538 DV->setDIE(VariableDie); 1539 return VariableDie; 1540 1541} 1542 1543void DwarfDebug::addPubTypes(DISubprogram SP) { 1544 DICompositeType SPTy = SP.getType(); 1545 unsigned SPTag = SPTy.getTag(); 1546 if (SPTag != dwarf::DW_TAG_subroutine_type) 1547 return; 1548 1549 DIArray Args = SPTy.getTypeArray(); 1550 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) { 1551 DIType ATy(Args.getElement(i).getNode()); 1552 if (!ATy.isValid()) 1553 continue; 1554 DICompositeType CATy = getDICompositeType(ATy); 1555 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) { 1556 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode())) 1557 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry()); 1558 } 1559 } 1560} 1561 1562/// constructScopeDIE - Construct a DIE for this scope. 1563DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) { 1564 if (!Scope || !Scope->getScopeNode()) 1565 return NULL; 1566 1567 DIScope DS(Scope->getScopeNode()); 1568 DIE *ScopeDIE = NULL; 1569 if (Scope->getInlinedAt()) 1570 ScopeDIE = constructInlinedScopeDIE(Scope); 1571 else if (DS.isSubprogram()) { 1572 if (Scope->isAbstractScope()) 1573 ScopeDIE = ModuleCU->getDIE(DS.getNode()); 1574 else 1575 ScopeDIE = updateSubprogramScopeDIE(DS.getNode()); 1576 } 1577 else 1578 ScopeDIE = constructLexicalScopeDIE(Scope); 1579 if (!ScopeDIE) return NULL; 1580 1581 // Add variables to scope. 1582 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables(); 1583 for (unsigned i = 0, N = Variables.size(); i < N; ++i) { 1584 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope); 1585 if (VariableDIE) 1586 ScopeDIE->addChild(VariableDIE); 1587 } 1588 1589 // Add nested scopes. 1590 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes(); 1591 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) { 1592 // Define the Scope debug information entry. 1593 DIE *NestedDIE = constructScopeDIE(Scopes[j]); 1594 if (NestedDIE) 1595 ScopeDIE->addChild(NestedDIE); 1596 } 1597 1598 if (DS.isSubprogram()) 1599 addPubTypes(DISubprogram(DS.getNode())); 1600 1601 return ScopeDIE; 1602} 1603 1604/// GetOrCreateSourceID - Look up the source id with the given directory and 1605/// source file names. If none currently exists, create a new id and insert it 1606/// in the SourceIds map. This can update DirectoryNames and SourceFileNames 1607/// maps as well. 1608unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){ 1609 unsigned DId; 1610 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName); 1611 if (DI != DirectoryIdMap.end()) { 1612 DId = DI->getValue(); 1613 } else { 1614 DId = DirectoryNames.size() + 1; 1615 DirectoryIdMap[DirName] = DId; 1616 DirectoryNames.push_back(DirName); 1617 } 1618 1619 unsigned FId; 1620 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName); 1621 if (FI != SourceFileIdMap.end()) { 1622 FId = FI->getValue(); 1623 } else { 1624 FId = SourceFileNames.size() + 1; 1625 SourceFileIdMap[FileName] = FId; 1626 SourceFileNames.push_back(FileName); 1627 } 1628 1629 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI = 1630 SourceIdMap.find(std::make_pair(DId, FId)); 1631 if (SI != SourceIdMap.end()) 1632 return SI->second; 1633 1634 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0. 1635 SourceIdMap[std::make_pair(DId, FId)] = SrcId; 1636 SourceIds.push_back(std::make_pair(DId, FId)); 1637 1638 return SrcId; 1639} 1640 1641/// getOrCreateNameSpace - Create a DIE for DINameSpace. 1642DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) { 1643 DIE *NDie = ModuleCU->getDIE(NS.getNode()); 1644 if (NDie) 1645 return NDie; 1646 NDie = new DIE(dwarf::DW_TAG_namespace); 1647 ModuleCU->insertDIE(NS.getNode(), NDie); 1648 if (!NS.getName().empty()) 1649 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName()); 1650 addSourceLine(NDie, &NS); 1651 addToContextOwner(NDie, NS.getContext()); 1652 return NDie; 1653} 1654 1655void DwarfDebug::constructCompileUnit(MDNode *N) { 1656 DICompileUnit DIUnit(N); 1657 // Use first compile unit marked as isMain as the compile unit for this 1658 // module. 1659 if (ModuleCU || !DIUnit.isMain()) 1660 return; 1661 StringRef FN = DIUnit.getFilename(); 1662 StringRef Dir = DIUnit.getDirectory(); 1663 unsigned ID = GetOrCreateSourceID(Dir, FN); 1664 1665 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 1666 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string, 1667 DIUnit.getProducer()); 1668 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1, 1669 DIUnit.getLanguage()); 1670 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN); 1671 addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 1672 getTempLabel("text_begin")); 1673 addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, 1674 getTempLabel("text_end")); 1675 // DW_AT_stmt_list is a offset of line number information for this 1676 // compile unit in debug_line section. It is always zero when only one 1677 // compile unit is emitted in one object file. 1678 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0); 1679 1680 if (!Dir.empty()) 1681 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir); 1682 if (DIUnit.isOptimized()) 1683 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 1684 1685 StringRef Flags = DIUnit.getFlags(); 1686 if (!Flags.empty()) 1687 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags); 1688 1689 unsigned RVer = DIUnit.getRunTimeVersion(); 1690 if (RVer) 1691 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers, 1692 dwarf::DW_FORM_data1, RVer); 1693 1694 assert(!ModuleCU && 1695 "ModuleCU assigned since the top of constructCompileUnit"); 1696 ModuleCU = new CompileUnit(ID, Die); 1697} 1698 1699void DwarfDebug::constructGlobalVariableDIE(MDNode *N) { 1700 DIGlobalVariable DI_GV(N); 1701 1702 // If debug information is malformed then ignore it. 1703 if (DI_GV.Verify() == false) 1704 return; 1705 1706 // Check for pre-existence. 1707 if (ModuleCU->getDIE(DI_GV.getNode())) 1708 return; 1709 1710 DIE *VariableDie = createGlobalVariableDIE(DI_GV); 1711 if (!VariableDie) 1712 return; 1713 1714 // Add to map. 1715 ModuleCU->insertDIE(N, VariableDie); 1716 1717 // Add to context owner. 1718 DIDescriptor GVContext = DI_GV.getContext(); 1719 // Do not create specification DIE if context is either compile unit 1720 // or a subprogram. 1721 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() && 1722 !GVContext.isFile() && !GVContext.isSubprogram()) { 1723 // Create specification DIE. 1724 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable); 1725 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, 1726 dwarf::DW_FORM_ref4, VariableDie); 1727 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1728 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 1729 addLabel(Block, 0, dwarf::DW_FORM_udata, 1730 Asm->Mang->getSymbol(DI_GV.getGlobal())); 1731 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block); 1732 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1733 ModuleCU->addDie(VariableSpecDIE); 1734 } else { 1735 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1736 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 1737 addLabel(Block, 0, dwarf::DW_FORM_udata, 1738 Asm->Mang->getSymbol(DI_GV.getGlobal())); 1739 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block); 1740 } 1741 addToContextOwner(VariableDie, GVContext); 1742 1743 // Expose as global. FIXME - need to check external flag. 1744 ModuleCU->addGlobal(DI_GV.getName(), VariableDie); 1745 1746 DIType GTy = DI_GV.getType(); 1747 if (GTy.isCompositeType() && !GTy.getName().empty()) { 1748 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode()); 1749 assert(Entry && "Missing global type!"); 1750 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry()); 1751 } 1752 return; 1753} 1754 1755void DwarfDebug::constructSubprogramDIE(MDNode *N) { 1756 DISubprogram SP(N); 1757 1758 // Check for pre-existence. 1759 if (ModuleCU->getDIE(N)) 1760 return; 1761 1762 if (!SP.isDefinition()) 1763 // This is a method declaration which will be handled while constructing 1764 // class type. 1765 return; 1766 1767 DIE *SubprogramDie = createSubprogramDIE(SP); 1768 1769 // Add to map. 1770 ModuleCU->insertDIE(N, SubprogramDie); 1771 1772 // Add to context owner. 1773 addToContextOwner(SubprogramDie, SP.getContext()); 1774 1775 // Expose as global. 1776 ModuleCU->addGlobal(SP.getName(), SubprogramDie); 1777 1778 return; 1779} 1780 1781/// beginModule - Emit all Dwarf sections that should come prior to the 1782/// content. Create global DIEs and emit initial debug info sections. 1783/// This is inovked by the target AsmPrinter. 1784void DwarfDebug::beginModule(Module *M) { 1785 this->M = M; 1786 1787 if (!MAI->doesSupportDebugInformation()) 1788 return; 1789 1790 TimeRegion Timer(DebugTimer); 1791 1792 DebugInfoFinder DbgFinder; 1793 DbgFinder.processModule(*M); 1794 1795 // Create all the compile unit DIEs. 1796 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 1797 E = DbgFinder.compile_unit_end(); I != E; ++I) 1798 constructCompileUnit(*I); 1799 1800 if (!ModuleCU) 1801 return; 1802 1803 // Create DIEs for each subprogram. 1804 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(), 1805 E = DbgFinder.subprogram_end(); I != E; ++I) 1806 constructSubprogramDIE(*I); 1807 1808 // Create DIEs for each global variable. 1809 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(), 1810 E = DbgFinder.global_variable_end(); I != E; ++I) 1811 constructGlobalVariableDIE(*I); 1812 1813 MMI = Asm->MMI; 1814 shouldEmit = true; 1815 MMI->setDebugInfoAvailability(true); 1816 1817 // Prime section data. 1818 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 1819 1820 // Print out .file directives to specify files for .loc directives. These are 1821 // printed out early so that they precede any .loc directives. 1822 if (MAI->hasDotLocAndDotFile()) { 1823 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) { 1824 // Remember source id starts at 1. 1825 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i); 1826 // FIXME: don't use sys::path for this! This should not depend on the 1827 // host. 1828 sys::Path FullPath(getSourceDirectoryName(Id.first)); 1829 bool AppendOk = 1830 FullPath.appendComponent(getSourceFileName(Id.second)); 1831 assert(AppendOk && "Could not append filename to directory!"); 1832 AppendOk = false; 1833 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str()); 1834 } 1835 } 1836 1837 // Emit initial sections 1838 emitInitial(); 1839} 1840 1841/// endModule - Emit all Dwarf sections that should come after the content. 1842/// 1843void DwarfDebug::endModule() { 1844 if (!ModuleCU) 1845 return; 1846 1847 TimeRegion Timer(DebugTimer); 1848 1849 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 1850 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 1851 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 1852 DIE *ISP = *AI; 1853 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 1854 } 1855 1856 // Insert top level DIEs. 1857 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(), 1858 TE = TopLevelDIEsVector.end(); TI != TE; ++TI) 1859 ModuleCU->getCUDie()->addChild(*TI); 1860 1861 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(), 1862 CE = ContainingTypeMap.end(); CI != CE; ++CI) { 1863 DIE *SPDie = CI->first; 1864 MDNode *N = dyn_cast_or_null<MDNode>(CI->second); 1865 if (!N) continue; 1866 DIE *NDie = ModuleCU->getDIE(N); 1867 if (!NDie) continue; 1868 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie); 1869 // FIXME - This is not the correct approach. 1870 //addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie 1871 } 1872 1873 // Standard sections final addresses. 1874 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 1875 Asm->OutStreamer.EmitLabel(getTempLabel("text_end")); 1876 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 1877 Asm->OutStreamer.EmitLabel(getTempLabel("data_end")); 1878 1879 // End text sections. 1880 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) { 1881 Asm->OutStreamer.SwitchSection(SectionMap[i]); 1882 Asm->OutStreamer.EmitLabel(getDWLabel("section_end", i)); 1883 } 1884 1885 // Emit common frame information. 1886 emitCommonDebugFrame(); 1887 1888 // Emit function debug frame information 1889 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(), 1890 E = DebugFrames.end(); I != E; ++I) 1891 emitFunctionDebugFrame(*I); 1892 1893 // Compute DIE offsets and sizes. 1894 computeSizeAndOffsets(); 1895 1896 // Emit all the DIEs into a debug info section 1897 emitDebugInfo(); 1898 1899 // Corresponding abbreviations into a abbrev section. 1900 emitAbbreviations(); 1901 1902 // Emit source line correspondence into a debug line section. 1903 emitDebugLines(); 1904 1905 // Emit info into a debug pubnames section. 1906 emitDebugPubNames(); 1907 1908 // Emit info into a debug pubtypes section. 1909 emitDebugPubTypes(); 1910 1911 // Emit info into a debug loc section. 1912 emitDebugLoc(); 1913 1914 // Emit info into a debug aranges section. 1915 EmitDebugARanges(); 1916 1917 // Emit info into a debug ranges section. 1918 emitDebugRanges(); 1919 1920 // Emit info into a debug macinfo section. 1921 emitDebugMacInfo(); 1922 1923 // Emit inline info. 1924 emitDebugInlineInfo(); 1925 1926 // Emit info into a debug str section. 1927 emitDebugStr(); 1928 1929 delete ModuleCU; 1930 ModuleCU = NULL; // Reset for the next Module, if any. 1931} 1932 1933/// findAbstractVariable - Find abstract variable, if any, associated with Var. 1934DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var, 1935 unsigned FrameIdx, 1936 DebugLoc ScopeLoc) { 1937 1938 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode()); 1939 if (AbsDbgVariable) 1940 return AbsDbgVariable; 1941 1942 LLVMContext &Ctx = Var.getNode()->getContext(); 1943 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx)); 1944 if (!Scope) 1945 return NULL; 1946 1947 AbsDbgVariable = new DbgVariable(Var, FrameIdx, 1948 NULL /* No more-abstract variable*/); 1949 Scope->addVariable(AbsDbgVariable); 1950 AbstractVariables[Var.getNode()] = AbsDbgVariable; 1951 return AbsDbgVariable; 1952} 1953 1954/// findAbstractVariable - Find abstract variable, if any, associated with Var. 1955/// FIXME : Refactor findAbstractVariable. 1956DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var, 1957 const MachineInstr *MI, 1958 DebugLoc ScopeLoc) { 1959 1960 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode()); 1961 if (AbsDbgVariable) 1962 return AbsDbgVariable; 1963 1964 LLVMContext &Ctx = Var.getNode()->getContext(); 1965 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx)); 1966 if (!Scope) 1967 return NULL; 1968 1969 AbsDbgVariable = new DbgVariable(Var, MI, 1970 NULL /* No more-abstract variable*/); 1971 Scope->addVariable(AbsDbgVariable); 1972 AbstractVariables[Var.getNode()] = AbsDbgVariable; 1973 DbgValueStartMap[MI] = AbsDbgVariable; 1974 return AbsDbgVariable; 1975} 1976 1977/// collectVariableInfo - Populate DbgScope entries with variables' info. 1978void DwarfDebug::collectVariableInfo() { 1979 if (!MMI) return; 1980 1981 const LLVMContext &Ctx = MF->getFunction()->getContext(); 1982 1983 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 1984 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 1985 VE = VMap.end(); VI != VE; ++VI) { 1986 MDNode *Var = VI->first; 1987 if (!Var) continue; 1988 DIVariable DV(Var); 1989 const std::pair<unsigned, DebugLoc> &VP = VI->second; 1990 1991 DbgScope *Scope = 0; 1992 if (MDNode *IA = VP.second.getInlinedAt(Ctx)) 1993 Scope = ConcreteScopes.lookup(IA); 1994 if (Scope == 0) 1995 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx)); 1996 1997 // If variable scope is not found then skip this variable. 1998 if (Scope == 0) 1999 continue; 2000 2001 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second); 2002 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable); 2003 Scope->addVariable(RegVar); 2004 } 2005 2006 // Collect variable information from DBG_VALUE machine instructions; 2007 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2008 I != E; ++I) { 2009 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2010 II != IE; ++II) { 2011 const MachineInstr *MInsn = II; 2012 if (!MInsn->isDebugValue()) 2013 continue; 2014 2015 // FIXME : Lift this restriction. 2016 if (MInsn->getNumOperands() != 3) 2017 continue; 2018 DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands() 2019 - 1).getMetadata())); 2020 if (DV.getTag() == dwarf::DW_TAG_arg_variable) { 2021 // FIXME Handle inlined subroutine arguments. 2022 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL); 2023 CurrentFnDbgScope->addVariable(ArgVar); 2024 DbgValueStartMap[MInsn] = ArgVar; 2025 continue; 2026 } 2027 2028 DebugLoc DL = MInsn->getDebugLoc(); 2029 if (DL.isUnknown()) continue; 2030 DbgScope *Scope = 0; 2031 if (MDNode *IA = DL.getInlinedAt(Ctx)) 2032 Scope = ConcreteScopes.lookup(IA); 2033 if (Scope == 0) 2034 Scope = DbgScopeMap.lookup(DL.getScope(Ctx)); 2035 2036 // If variable scope is not found then skip this variable. 2037 if (Scope == 0) 2038 continue; 2039 2040 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL); 2041 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable); 2042 DbgValueStartMap[MInsn] = RegVar; 2043 Scope->addVariable(RegVar); 2044 } 2045 } 2046} 2047 2048/// beginScope - Process beginning of a scope. 2049void DwarfDebug::beginScope(const MachineInstr *MI) { 2050 // Check location. 2051 DebugLoc DL = MI->getDebugLoc(); 2052 if (DL.isUnknown()) 2053 return; 2054 2055 // Check and update last known location info. 2056 if (DL == PrevInstLoc) 2057 return; 2058 2059 MDNode *Scope = DL.getScope(MF->getFunction()->getContext()); 2060 2061 // FIXME: Should only verify each scope once! 2062 if (!DIScope(Scope).Verify()) 2063 return; 2064 2065 // DBG_VALUE instruction establishes new value. 2066 if (MI->isDebugValue()) { 2067 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI 2068 = DbgValueStartMap.find(MI); 2069 if (DI != DbgValueStartMap.end()) { 2070 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope); 2071 PrevInstLoc = DL; 2072 DI->second->setDbgValueLabel(Label); 2073 } 2074 return; 2075 } 2076 2077 // Emit a label to indicate location change. This is used for line 2078 // table even if this instruction does start a new scope. 2079 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope); 2080 PrevInstLoc = DL; 2081 2082 // update DbgScope if this instruction starts a new scope. 2083 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI); 2084 if (I == DbgScopeBeginMap.end()) 2085 return; 2086 2087 ScopeVector &SD = I->second; 2088 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end(); 2089 SDI != SDE; ++SDI) 2090 (*SDI)->setStartLabel(Label); 2091} 2092 2093/// endScope - Process end of a scope. 2094void DwarfDebug::endScope(const MachineInstr *MI) { 2095 // Ignore DBG_VALUE instruction. 2096 if (MI->isDebugValue()) 2097 return; 2098 2099 // Check location. 2100 DebugLoc DL = MI->getDebugLoc(); 2101 if (DL.isUnknown()) 2102 return; 2103 2104 // Emit a label and update DbgScope if this instruction ends a scope. 2105 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI); 2106 if (I == DbgScopeEndMap.end()) 2107 return; 2108 2109 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2110 Asm->OutStreamer.EmitLabel(Label); 2111 2112 SmallVector<DbgScope*, 2> &SD = I->second; 2113 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end(); 2114 SDI != SDE; ++SDI) 2115 (*SDI)->setEndLabel(Label); 2116 return; 2117} 2118 2119/// createDbgScope - Create DbgScope for the scope. 2120void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) { 2121 if (!InlinedAt) { 2122 DbgScope *WScope = DbgScopeMap.lookup(Scope); 2123 if (WScope) 2124 return; 2125 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL); 2126 DbgScopeMap.insert(std::make_pair(Scope, WScope)); 2127 if (DIDescriptor(Scope).isLexicalBlock()) 2128 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL); 2129 return; 2130 } 2131 2132 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt); 2133 if (WScope) 2134 return; 2135 2136 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt); 2137 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope)); 2138 DILocation DL(InlinedAt); 2139 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode()); 2140} 2141 2142/// extractScopeInformation - Scan machine instructions in this function 2143/// and collect DbgScopes. Return true, if at least one scope was found. 2144bool DwarfDebug::extractScopeInformation() { 2145 // If scope information was extracted using .dbg intrinsics then there is not 2146 // any need to extract these information by scanning each instruction. 2147 if (!DbgScopeMap.empty()) 2148 return false; 2149 2150 DenseMap<const MachineInstr *, unsigned> MIIndexMap; 2151 unsigned MIIndex = 0; 2152 LLVMContext &Ctx = MF->getFunction()->getContext(); 2153 2154 // Scan each instruction and create scopes. First build working set of scopes. 2155 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2156 I != E; ++I) { 2157 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2158 II != IE; ++II) { 2159 const MachineInstr *MInsn = II; 2160 // FIXME : Remove DBG_VALUE check. 2161 if (MInsn->isDebugValue()) continue; 2162 MIIndexMap[MInsn] = MIIndex++; 2163 2164 DebugLoc DL = MInsn->getDebugLoc(); 2165 if (DL.isUnknown()) continue; 2166 2167 MDNode *Scope = DL.getScope(Ctx); 2168 2169 // There is no need to create another DIE for compile unit. For all 2170 // other scopes, create one DbgScope now. This will be translated 2171 // into a scope DIE at the end. 2172 if (DIScope(Scope).isCompileUnit()) continue; 2173 createDbgScope(Scope, DL.getInlinedAt(Ctx)); 2174 } 2175 } 2176 2177 2178 // Build scope hierarchy using working set of scopes. 2179 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2180 I != E; ++I) { 2181 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2182 II != IE; ++II) { 2183 const MachineInstr *MInsn = II; 2184 // FIXME : Remove DBG_VALUE check. 2185 if (MInsn->isDebugValue()) continue; 2186 DebugLoc DL = MInsn->getDebugLoc(); 2187 if (DL.isUnknown()) continue; 2188 2189 MDNode *Scope = DL.getScope(Ctx); 2190 if (Scope == 0) continue; 2191 2192 // There is no need to create another DIE for compile unit. For all 2193 // other scopes, create one DbgScope now. This will be translated 2194 // into a scope DIE at the end. 2195 if (DIScope(Scope).isCompileUnit()) continue; 2196 DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx)); 2197 DScope->setLastInsn(MInsn); 2198 } 2199 } 2200 2201 if (!CurrentFnDbgScope) 2202 return false; 2203 2204 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap); 2205 2206 // Each scope has first instruction and last instruction to mark beginning 2207 // and end of a scope respectively. Create an inverse map that list scopes 2208 // starts (and ends) with an instruction. One instruction may start (or end) 2209 // multiple scopes. Ignore scopes that are not reachable. 2210 SmallVector<DbgScope *, 4> WorkList; 2211 WorkList.push_back(CurrentFnDbgScope); 2212 while (!WorkList.empty()) { 2213 DbgScope *S = WorkList.pop_back_val(); 2214 2215 const SmallVector<DbgScope *, 4> &Children = S->getScopes(); 2216 if (!Children.empty()) 2217 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2218 SE = Children.end(); SI != SE; ++SI) 2219 WorkList.push_back(*SI); 2220 2221 if (S->isAbstractScope()) 2222 continue; 2223 const MachineInstr *MI = S->getFirstInsn(); 2224 assert(MI && "DbgScope does not have first instruction!"); 2225 2226 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI); 2227 if (IDI != DbgScopeBeginMap.end()) 2228 IDI->second.push_back(S); 2229 else 2230 DbgScopeBeginMap[MI].push_back(S); 2231 2232 MI = S->getLastInsn(); 2233 assert(MI && "DbgScope does not have last instruction!"); 2234 IDI = DbgScopeEndMap.find(MI); 2235 if (IDI != DbgScopeEndMap.end()) 2236 IDI->second.push_back(S); 2237 else 2238 DbgScopeEndMap[MI].push_back(S); 2239 } 2240 2241 return !DbgScopeMap.empty(); 2242} 2243 2244/// beginFunction - Gather pre-function debug information. Assumes being 2245/// emitted immediately after the function entry point. 2246void DwarfDebug::beginFunction(const MachineFunction *MF) { 2247 this->MF = MF; 2248 2249 if (!ShouldEmitDwarfDebug()) return; 2250 if (!extractScopeInformation()) 2251 return; 2252 2253 TimeRegion Timer(DebugTimer); 2254 2255 collectVariableInfo(); 2256 2257 // Assumes in correct section after the entry point. 2258 Asm->OutStreamer.EmitLabel(getDWLabel("func_begin", ++SubprogramCount)); 2259 2260 // Emit label for the implicitly defined dbg.stoppoint at the start of the 2261 // function. 2262 DebugLoc FDL = MF->getDefaultDebugLoc(); 2263 if (FDL.isUnknown()) return; 2264 2265 MDNode *Scope = FDL.getScope(MF->getFunction()->getContext()); 2266 2267 DISubprogram SP = getDISubprogram(Scope); 2268 unsigned Line, Col; 2269 if (SP.Verify()) { 2270 Line = SP.getLineNumber(); 2271 Col = 0; 2272 } else { 2273 Line = FDL.getLine(); 2274 Col = FDL.getCol(); 2275 } 2276 2277 recordSourceLine(Line, Col, Scope); 2278} 2279 2280/// endFunction - Gather and emit post-function debug information. 2281/// 2282void DwarfDebug::endFunction(const MachineFunction *MF) { 2283 if (!ShouldEmitDwarfDebug()) return; 2284 if (DbgScopeMap.empty()) return; 2285 2286 TimeRegion Timer(DebugTimer); 2287 2288 if (CurrentFnDbgScope) { 2289 // Define end label for subprogram. 2290 Asm->OutStreamer.EmitLabel(getDWLabel("func_end", SubprogramCount)); 2291 2292 // Get function line info. 2293 if (!Lines.empty()) { 2294 // Get section line info. 2295 unsigned ID = SectionMap.insert(Asm->getCurrentSection()); 2296 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID); 2297 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1]; 2298 // Append the function info to section info. 2299 SectionLineInfos.insert(SectionLineInfos.end(), 2300 Lines.begin(), Lines.end()); 2301 } 2302 2303 // Construct abstract scopes. 2304 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2305 AE = AbstractScopesList.end(); AI != AE; ++AI) 2306 constructScopeDIE(*AI); 2307 2308 constructScopeDIE(CurrentFnDbgScope); 2309 2310 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount, 2311 MMI->getFrameMoves())); 2312 } 2313 2314 // Clear debug info 2315 CurrentFnDbgScope = NULL; 2316 DeleteContainerSeconds(DbgScopeMap); 2317 DbgScopeBeginMap.clear(); 2318 DbgScopeEndMap.clear(); 2319 DbgValueStartMap.clear(); 2320 ConcreteScopes.clear(); 2321 DeleteContainerSeconds(AbstractScopes); 2322 AbstractScopesList.clear(); 2323 AbstractVariables.clear(); 2324 Lines.clear(); 2325} 2326 2327/// recordSourceLine - Register a source line with debug info. Returns the 2328/// unique label that was emitted and which provides correspondence to 2329/// the source line list. 2330MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) { 2331 if (!MMI) 2332 return 0; 2333 2334 TimeRegion Timer(DebugTimer); 2335 2336 StringRef Dir; 2337 StringRef Fn; 2338 2339 DIDescriptor Scope(S); 2340 if (Scope.isCompileUnit()) { 2341 DICompileUnit CU(S); 2342 Dir = CU.getDirectory(); 2343 Fn = CU.getFilename(); 2344 } else if (Scope.isSubprogram()) { 2345 DISubprogram SP(S); 2346 Dir = SP.getDirectory(); 2347 Fn = SP.getFilename(); 2348 } else if (Scope.isLexicalBlock()) { 2349 DILexicalBlock DB(S); 2350 Dir = DB.getDirectory(); 2351 Fn = DB.getFilename(); 2352 } else 2353 assert(0 && "Unexpected scope info"); 2354 2355 unsigned Src = GetOrCreateSourceID(Dir, Fn); 2356 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2357 Lines.push_back(SrcLineInfo(Line, Col, Src, Label)); 2358 2359 Asm->OutStreamer.EmitLabel(Label); 2360 return Label; 2361} 2362 2363/// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be 2364/// timed. Look up the source id with the given directory and source file 2365/// names. If none currently exists, create a new id and insert it in the 2366/// SourceIds map. This can update DirectoryNames and SourceFileNames maps as 2367/// well. 2368unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName, 2369 const std::string &FileName) { 2370 TimeRegion Timer(DebugTimer); 2371 return GetOrCreateSourceID(DirName.c_str(), FileName.c_str()); 2372} 2373 2374//===----------------------------------------------------------------------===// 2375// Emit Methods 2376//===----------------------------------------------------------------------===// 2377 2378/// computeSizeAndOffset - Compute the size and offset of a DIE. 2379/// 2380unsigned 2381DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) { 2382 // Get the children. 2383 const std::vector<DIE *> &Children = Die->getChildren(); 2384 2385 // If not last sibling and has children then add sibling offset attribute. 2386 if (!Last && !Children.empty()) 2387 Die->addSiblingOffset(DIEValueAllocator); 2388 2389 // Record the abbreviation. 2390 assignAbbrevNumber(Die->getAbbrev()); 2391 2392 // Get the abbreviation for this DIE. 2393 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2394 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2395 2396 // Set DIE offset 2397 Die->setOffset(Offset); 2398 2399 // Start the size with the size of abbreviation code. 2400 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 2401 2402 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2403 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2404 2405 // Size the DIE attribute values. 2406 for (unsigned i = 0, N = Values.size(); i < N; ++i) 2407 // Size attribute value. 2408 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm()); 2409 2410 // Size the DIE children if any. 2411 if (!Children.empty()) { 2412 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 2413 "Children flag not set"); 2414 2415 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2416 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M); 2417 2418 // End of children marker. 2419 Offset += sizeof(int8_t); 2420 } 2421 2422 Die->setSize(Offset - Die->getOffset()); 2423 return Offset; 2424} 2425 2426/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 2427/// 2428void DwarfDebug::computeSizeAndOffsets() { 2429 // Compute size of compile unit header. 2430 static unsigned Offset = 2431 sizeof(int32_t) + // Length of Compilation Unit Info 2432 sizeof(int16_t) + // DWARF version number 2433 sizeof(int32_t) + // Offset Into Abbrev. Section 2434 sizeof(int8_t); // Pointer Size (in bytes) 2435 2436 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true); 2437 CompileUnitOffsets[ModuleCU] = 0; 2438} 2439 2440/// emitInitial - Emit initial Dwarf declarations. This is necessary for cc 2441/// tools to recognize the object file contains Dwarf information. 2442void DwarfDebug::emitInitial() { 2443 // Check to see if we already emitted intial headers. 2444 if (didInitial) return; 2445 didInitial = true; 2446 2447 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 2448 2449 // Dwarf sections base addresses. 2450 if (MAI->doesDwarfRequireFrameSection()) { 2451 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection()); 2452 Asm->OutStreamer.EmitLabel(getTempLabel("section_debug_frame")); 2453 } 2454 2455 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection()); 2456 Asm->OutStreamer.EmitLabel(getTempLabel("section_info")); 2457 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection()); 2458 Asm->OutStreamer.EmitLabel(getTempLabel("section_abbrev")); 2459 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection()); 2460 Asm->OutStreamer.EmitLabel(getTempLabel("section_aranges")); 2461 2462 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) { 2463 Asm->OutStreamer.SwitchSection(LineInfoDirective); 2464 Asm->OutStreamer.EmitLabel(getTempLabel("section_macinfo")); 2465 } 2466 2467 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection()); 2468 Asm->OutStreamer.EmitLabel(getTempLabel("section_line")); 2469 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection()); 2470 Asm->OutStreamer.EmitLabel(getTempLabel("section_loc")); 2471 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection()); 2472 Asm->OutStreamer.EmitLabel(getTempLabel("section_pubnames")); 2473 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection()); 2474 Asm->OutStreamer.EmitLabel(getTempLabel("section_pubtypes")); 2475 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection()); 2476 Asm->OutStreamer.EmitLabel(getTempLabel("section_str")); 2477 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection()); 2478 Asm->OutStreamer.EmitLabel(getTempLabel("section_ranges")); 2479 2480 Asm->OutStreamer.SwitchSection(TLOF.getTextSection()); 2481 Asm->OutStreamer.EmitLabel(getTempLabel("text_begin")); 2482 Asm->OutStreamer.SwitchSection(TLOF.getDataSection()); 2483 Asm->OutStreamer.EmitLabel(getTempLabel("data_begin")); 2484} 2485 2486/// emitDIE - Recusively Emits a debug information entry. 2487/// 2488void DwarfDebug::emitDIE(DIE *Die) { 2489 // Get the abbreviation for this DIE. 2490 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2491 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2492 2493 // Emit the code (index) for the abbreviation. 2494 if (Asm->VerboseAsm) 2495 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 2496 Twine::utohexstr(Die->getOffset()) + ":0x" + 2497 Twine::utohexstr(Die->getSize()) + " " + 2498 dwarf::TagString(Abbrev->getTag())); 2499 EmitULEB128(AbbrevNumber); 2500 2501 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2502 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2503 2504 // Emit the DIE attribute values. 2505 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 2506 unsigned Attr = AbbrevData[i].getAttribute(); 2507 unsigned Form = AbbrevData[i].getForm(); 2508 assert(Form && "Too many attributes for DIE (check abbreviation)"); 2509 2510 if (Asm->VerboseAsm) 2511 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 2512 2513 switch (Attr) { 2514 case dwarf::DW_AT_sibling: 2515 Asm->EmitInt32(Die->getSiblingOffset()); 2516 break; 2517 case dwarf::DW_AT_abstract_origin: { 2518 DIEEntry *E = cast<DIEEntry>(Values[i]); 2519 DIE *Origin = E->getEntry(); 2520 unsigned Addr = Origin->getOffset(); 2521 Asm->EmitInt32(Addr); 2522 break; 2523 } 2524 default: 2525 // Emit an attribute using the defined form. 2526 Values[i]->EmitValue(this, Form); 2527 break; 2528 } 2529 } 2530 2531 // Emit the DIE children if any. 2532 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 2533 const std::vector<DIE *> &Children = Die->getChildren(); 2534 2535 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2536 emitDIE(Children[j]); 2537 2538 if (Asm->VerboseAsm) 2539 Asm->OutStreamer.AddComment("End Of Children Mark"); 2540 Asm->EmitInt8(0); 2541 } 2542} 2543 2544/// emitDebugInfo - Emit the debug info section. 2545/// 2546void DwarfDebug::emitDebugInfo() { 2547 // Start debug info section. 2548 Asm->OutStreamer.SwitchSection( 2549 Asm->getObjFileLowering().getDwarfInfoSection()); 2550 DIE *Die = ModuleCU->getCUDie(); 2551 2552 // Emit the compile units header. 2553 Asm->OutStreamer.EmitLabel(getDWLabel("info_begin", ModuleCU->getID())); 2554 2555 // Emit size of content not including length itself 2556 unsigned ContentSize = Die->getSize() + 2557 sizeof(int16_t) + // DWARF version number 2558 sizeof(int32_t) + // Offset Into Abbrev. Section 2559 sizeof(int8_t) + // Pointer Size (in bytes) 2560 sizeof(int32_t); // FIXME - extra pad for gdb bug. 2561 2562 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 2563 Asm->EmitInt32(ContentSize); 2564 Asm->OutStreamer.AddComment("DWARF version number"); 2565 Asm->EmitInt16(dwarf::DWARF_VERSION); 2566 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 2567 EmitSectionOffset(getTempLabel("abbrev_begin"),getTempLabel("section_abbrev"), 2568 true); 2569 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2570 Asm->EmitInt8(TD->getPointerSize()); 2571 2572 emitDIE(Die); 2573 // FIXME - extra padding for gdb bug. 2574 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB"); 2575 Asm->EmitInt8(0); 2576 Asm->EmitInt8(0); 2577 Asm->EmitInt8(0); 2578 Asm->EmitInt8(0); 2579 Asm->OutStreamer.EmitLabel(getDWLabel("info_end", ModuleCU->getID())); 2580} 2581 2582/// emitAbbreviations - Emit the abbreviation section. 2583/// 2584void DwarfDebug::emitAbbreviations() const { 2585 // Check to see if it is worth the effort. 2586 if (!Abbreviations.empty()) { 2587 // Start the debug abbrev section. 2588 Asm->OutStreamer.SwitchSection( 2589 Asm->getObjFileLowering().getDwarfAbbrevSection()); 2590 2591 Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_begin")); 2592 2593 // For each abbrevation. 2594 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 2595 // Get abbreviation data 2596 const DIEAbbrev *Abbrev = Abbreviations[i]; 2597 2598 // Emit the abbrevations code (base 1 index.) 2599 EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 2600 2601 // Emit the abbreviations data. 2602 Abbrev->Emit(this); 2603 } 2604 2605 // Mark end of abbreviations. 2606 EmitULEB128(0, "EOM(3)"); 2607 2608 Asm->OutStreamer.EmitLabel(getTempLabel("abbrev_end")); 2609 } 2610} 2611 2612/// emitEndOfLineMatrix - Emit the last address of the section and the end of 2613/// the line matrix. 2614/// 2615void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 2616 // Define last address of section. 2617 Asm->OutStreamer.AddComment("Extended Op"); 2618 Asm->EmitInt8(0); 2619 2620 Asm->OutStreamer.AddComment("Op size"); 2621 Asm->EmitInt8(TD->getPointerSize() + 1); 2622 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 2623 Asm->EmitInt8(dwarf::DW_LNE_set_address); 2624 2625 Asm->OutStreamer.AddComment("Section end label"); 2626 2627 Asm->OutStreamer.EmitSymbolValue(getDWLabel("section_end", SectionEnd), 2628 TD->getPointerSize(), 0/*AddrSpace*/); 2629 2630 // Mark end of matrix. 2631 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 2632 Asm->EmitInt8(0); 2633 Asm->EmitInt8(1); 2634 Asm->EmitInt8(1); 2635} 2636 2637/// emitDebugLines - Emit source line information. 2638/// 2639void DwarfDebug::emitDebugLines() { 2640 // If the target is using .loc/.file, the assembler will be emitting the 2641 // .debug_line table automatically. 2642 if (MAI->hasDotLocAndDotFile()) 2643 return; 2644 2645 // Minimum line delta, thus ranging from -10..(255-10). 2646 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1); 2647 // Maximum line delta, thus ranging from -10..(255-10). 2648 const int MaxLineDelta = 255 + MinLineDelta; 2649 2650 // Start the dwarf line section. 2651 Asm->OutStreamer.SwitchSection( 2652 Asm->getObjFileLowering().getDwarfLineSection()); 2653 2654 // Construct the section header. 2655 Asm->OutStreamer.AddComment("Length of Source Line Info"); 2656 EmitDifference(getTempLabel("line_end"), getTempLabel("line_begin"), true); 2657 Asm->OutStreamer.EmitLabel(getTempLabel("line_begin")); 2658 2659 Asm->OutStreamer.AddComment("DWARF version number"); 2660 Asm->EmitInt16(dwarf::DWARF_VERSION); 2661 2662 Asm->OutStreamer.AddComment("Prolog Length"); 2663 EmitDifference(getTempLabel("line_prolog_end"), 2664 getTempLabel("line_prolog_begin"), true); 2665 Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_begin")); 2666 2667 Asm->OutStreamer.AddComment("Minimum Instruction Length"); 2668 Asm->EmitInt8(1); 2669 Asm->OutStreamer.AddComment("Default is_stmt_start flag"); 2670 Asm->EmitInt8(1); 2671 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)"); 2672 Asm->EmitInt8(MinLineDelta); 2673 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)"); 2674 Asm->EmitInt8(MaxLineDelta); 2675 Asm->OutStreamer.AddComment("Special Opcode Base"); 2676 Asm->EmitInt8(-MinLineDelta); 2677 2678 // Line number standard opcode encodings argument count 2679 Asm->OutStreamer.AddComment("DW_LNS_copy arg count"); 2680 Asm->EmitInt8(0); 2681 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count"); 2682 Asm->EmitInt8(1); 2683 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count"); 2684 Asm->EmitInt8(1); 2685 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count"); 2686 Asm->EmitInt8(1); 2687 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count"); 2688 Asm->EmitInt8(1); 2689 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count"); 2690 Asm->EmitInt8(0); 2691 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count"); 2692 Asm->EmitInt8(0); 2693 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count"); 2694 Asm->EmitInt8(0); 2695 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count"); 2696 Asm->EmitInt8(1); 2697 2698 // Emit directories. 2699 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) { 2700 const std::string &Dir = getSourceDirectoryName(DI); 2701 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory"); 2702 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0); 2703 } 2704 2705 Asm->OutStreamer.AddComment("End of directories"); 2706 Asm->EmitInt8(0); 2707 2708 // Emit files. 2709 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) { 2710 // Remember source id starts at 1. 2711 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI); 2712 const std::string &FN = getSourceFileName(Id.second); 2713 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source"); 2714 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0); 2715 2716 EmitULEB128(Id.first, "Directory #"); 2717 EmitULEB128(0, "Mod date"); 2718 EmitULEB128(0, "File size"); 2719 } 2720 2721 Asm->OutStreamer.AddComment("End of files"); 2722 Asm->EmitInt8(0); 2723 2724 Asm->OutStreamer.EmitLabel(getTempLabel("line_prolog_end")); 2725 2726 // A sequence for each text section. 2727 unsigned SecSrcLinesSize = SectionSourceLines.size(); 2728 2729 for (unsigned j = 0; j < SecSrcLinesSize; ++j) { 2730 // Isolate current sections line info. 2731 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j]; 2732 2733 // Dwarf assumes we start with first line of first source file. 2734 unsigned Source = 1; 2735 unsigned Line = 1; 2736 2737 // Construct rows of the address, source, line, column matrix. 2738 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) { 2739 const SrcLineInfo &LineInfo = LineInfos[i]; 2740 MCSymbol *Label = LineInfo.getLabel(); 2741 if (!Label->isDefined()) continue; // Not emitted, in dead code. 2742 2743 if (LineInfo.getLine() == 0) continue; 2744 2745 if (Asm->isVerbose()) { 2746 std::pair<unsigned, unsigned> SrcID = 2747 getSourceDirectoryAndFileIds(LineInfo.getSourceID()); 2748 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) + 2749 "/" + 2750 Twine(getSourceFileName(SrcID.second)) + 2751 ":" + Twine(LineInfo.getLine())); 2752 } 2753 2754 // Define the line address. 2755 Asm->OutStreamer.AddComment("Extended Op"); 2756 Asm->EmitInt8(0); 2757 Asm->OutStreamer.AddComment("Op size"); 2758 Asm->EmitInt8(TD->getPointerSize() + 1); 2759 2760 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 2761 Asm->EmitInt8(dwarf::DW_LNE_set_address); 2762 2763 Asm->OutStreamer.AddComment("Location label"); 2764 Asm->OutStreamer.EmitSymbolValue(Label, TD->getPointerSize(), 2765 0/*AddrSpace*/); 2766 2767 // If change of source, then switch to the new source. 2768 if (Source != LineInfo.getSourceID()) { 2769 Source = LineInfo.getSourceID(); 2770 Asm->OutStreamer.AddComment("DW_LNS_set_file"); 2771 Asm->EmitInt8(dwarf::DW_LNS_set_file); 2772 EmitULEB128(Source, "New Source"); 2773 } 2774 2775 // If change of line. 2776 if (Line != LineInfo.getLine()) { 2777 // Determine offset. 2778 int Offset = LineInfo.getLine() - Line; 2779 int Delta = Offset - MinLineDelta; 2780 2781 // Update line. 2782 Line = LineInfo.getLine(); 2783 2784 // If delta is small enough and in range... 2785 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { 2786 // ... then use fast opcode. 2787 Asm->OutStreamer.AddComment("Line Delta"); 2788 Asm->EmitInt8(Delta - MinLineDelta); 2789 } else { 2790 // ... otherwise use long hand. 2791 Asm->OutStreamer.AddComment("DW_LNS_advance_line"); 2792 Asm->EmitInt8(dwarf::DW_LNS_advance_line); 2793 EmitSLEB128(Offset, "Line Offset"); 2794 Asm->OutStreamer.AddComment("DW_LNS_copy"); 2795 Asm->EmitInt8(dwarf::DW_LNS_copy); 2796 } 2797 } else { 2798 // Copy the previous row (different address or source) 2799 Asm->OutStreamer.AddComment("DW_LNS_copy"); 2800 Asm->EmitInt8(dwarf::DW_LNS_copy); 2801 } 2802 } 2803 2804 emitEndOfLineMatrix(j + 1); 2805 } 2806 2807 if (SecSrcLinesSize == 0) 2808 // Because we're emitting a debug_line section, we still need a line 2809 // table. The linker and friends expect it to exist. If there's nothing to 2810 // put into it, emit an empty table. 2811 emitEndOfLineMatrix(1); 2812 2813 Asm->OutStreamer.EmitLabel(getTempLabel("line_end")); 2814} 2815 2816/// emitCommonDebugFrame - Emit common frame info into a debug frame section. 2817/// 2818void DwarfDebug::emitCommonDebugFrame() { 2819 if (!MAI->doesDwarfRequireFrameSection()) 2820 return; 2821 2822 int stackGrowth = 2823 Asm->TM.getFrameInfo()->getStackGrowthDirection() == 2824 TargetFrameInfo::StackGrowsUp ? 2825 TD->getPointerSize() : -TD->getPointerSize(); 2826 2827 // Start the dwarf frame section. 2828 Asm->OutStreamer.SwitchSection( 2829 Asm->getObjFileLowering().getDwarfFrameSection()); 2830 2831 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common")); 2832 Asm->OutStreamer.AddComment("Length of Common Information Entry"); 2833 EmitDifference(getTempLabel("debug_frame_common_end"), 2834 getTempLabel("debug_frame_common_begin"), true); 2835 2836 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_begin")); 2837 Asm->OutStreamer.AddComment("CIE Identifier Tag"); 2838 Asm->EmitInt32((int)dwarf::DW_CIE_ID); 2839 Asm->OutStreamer.AddComment("CIE Version"); 2840 Asm->EmitInt8(dwarf::DW_CIE_VERSION); 2841 Asm->OutStreamer.AddComment("CIE Augmentation"); 2842 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator. 2843 EmitULEB128(1, "CIE Code Alignment Factor"); 2844 EmitSLEB128(stackGrowth, "CIE Data Alignment Factor"); 2845 Asm->OutStreamer.AddComment("CIE RA Column"); 2846 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); 2847 2848 std::vector<MachineMove> Moves; 2849 RI->getInitialFrameState(Moves); 2850 2851 EmitFrameMoves(0, Moves, false); 2852 2853 Asm->EmitAlignment(2, 0, 0, false); 2854 Asm->OutStreamer.EmitLabel(getTempLabel("debug_frame_common_end")); 2855} 2856 2857/// emitFunctionDebugFrame - Emit per function frame info into a debug frame 2858/// section. 2859void DwarfDebug:: 2860emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) { 2861 if (!MAI->doesDwarfRequireFrameSection()) 2862 return; 2863 2864 // Start the dwarf frame section. 2865 Asm->OutStreamer.SwitchSection( 2866 Asm->getObjFileLowering().getDwarfFrameSection()); 2867 2868 Asm->OutStreamer.AddComment("Length of Frame Information Entry"); 2869 MCSymbol *DebugFrameBegin = 2870 getDWLabel("debug_frame_begin", DebugFrameInfo.Number); 2871 MCSymbol *DebugFrameEnd = 2872 getDWLabel("debug_frame_end", DebugFrameInfo.Number); 2873 EmitDifference(DebugFrameEnd, DebugFrameBegin, true); 2874 2875 Asm->OutStreamer.EmitLabel(DebugFrameBegin); 2876 2877 Asm->OutStreamer.AddComment("FDE CIE offset"); 2878 EmitSectionOffset(getTempLabel("debug_frame_common"), 2879 getTempLabel("section_debug_frame"), true); 2880 2881 Asm->OutStreamer.AddComment("FDE initial location"); 2882 MCSymbol *FuncBeginSym = getDWLabel("func_begin", DebugFrameInfo.Number); 2883 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym, 2884 TD->getPointerSize(), 0/*AddrSpace*/); 2885 2886 2887 Asm->OutStreamer.AddComment("FDE address range"); 2888 EmitDifference(getDWLabel("func_end", DebugFrameInfo.Number), FuncBeginSym); 2889 2890 EmitFrameMoves(FuncBeginSym, DebugFrameInfo.Moves, false); 2891 2892 Asm->EmitAlignment(2, 0, 0, false); 2893 Asm->OutStreamer.EmitLabel(DebugFrameEnd); 2894} 2895 2896/// emitDebugPubNames - Emit visible names into a debug pubnames section. 2897/// 2898void DwarfDebug::emitDebugPubNames() { 2899 // Start the dwarf pubnames section. 2900 Asm->OutStreamer.SwitchSection( 2901 Asm->getObjFileLowering().getDwarfPubNamesSection()); 2902 2903 Asm->OutStreamer.AddComment("Length of Public Names Info"); 2904 EmitDifference(getDWLabel("pubnames_end", ModuleCU->getID()), 2905 getDWLabel("pubnames_begin", ModuleCU->getID()), true); 2906 2907 Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_begin", ModuleCU->getID())); 2908 2909 Asm->OutStreamer.AddComment("DWARF Version"); 2910 Asm->EmitInt16(dwarf::DWARF_VERSION); 2911 2912 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2913 EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()), 2914 getTempLabel("section_info"), true); 2915 2916 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2917 EmitDifference(getDWLabel("info_end", ModuleCU->getID()), 2918 getDWLabel("info_begin", ModuleCU->getID()), 2919 true); 2920 2921 const StringMap<DIE*> &Globals = ModuleCU->getGlobals(); 2922 for (StringMap<DIE*>::const_iterator 2923 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2924 const char *Name = GI->getKeyData(); 2925 DIE *Entity = GI->second; 2926 2927 Asm->OutStreamer.AddComment("DIE offset"); 2928 Asm->EmitInt32(Entity->getOffset()); 2929 2930 if (Asm->VerboseAsm) 2931 Asm->OutStreamer.AddComment("External Name"); 2932 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0); 2933 } 2934 2935 Asm->OutStreamer.AddComment("End Mark"); 2936 Asm->EmitInt32(0); 2937 Asm->OutStreamer.EmitLabel(getDWLabel("pubnames_end", ModuleCU->getID())); 2938} 2939 2940void DwarfDebug::emitDebugPubTypes() { 2941 // Start the dwarf pubnames section. 2942 Asm->OutStreamer.SwitchSection( 2943 Asm->getObjFileLowering().getDwarfPubTypesSection()); 2944 Asm->OutStreamer.AddComment("Length of Public Types Info"); 2945 EmitDifference(getDWLabel("pubtypes_end", ModuleCU->getID()), 2946 getDWLabel("pubtypes_begin", ModuleCU->getID()), true); 2947 2948 Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_begin", ModuleCU->getID())); 2949 2950 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DWARF Version"); 2951 Asm->EmitInt16(dwarf::DWARF_VERSION); 2952 2953 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info"); 2954 EmitSectionOffset(getDWLabel("info_begin", ModuleCU->getID()), 2955 getTempLabel("section_info"), true); 2956 2957 Asm->OutStreamer.AddComment("Compilation ModuleCU Length"); 2958 EmitDifference(getDWLabel("info_end", ModuleCU->getID()), 2959 getDWLabel("info_begin", ModuleCU->getID()), 2960 true); 2961 2962 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes(); 2963 for (StringMap<DIE*>::const_iterator 2964 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2965 const char *Name = GI->getKeyData(); 2966 DIE * Entity = GI->second; 2967 2968 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset"); 2969 Asm->EmitInt32(Entity->getOffset()); 2970 2971 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name"); 2972 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0); 2973 } 2974 2975 Asm->OutStreamer.AddComment("End Mark"); 2976 Asm->EmitInt32(0); 2977 Asm->OutStreamer.EmitLabel(getDWLabel("pubtypes_end", ModuleCU->getID())); 2978} 2979 2980/// emitDebugStr - Emit visible names into a debug str section. 2981/// 2982void DwarfDebug::emitDebugStr() { 2983 // Check to see if it is worth the effort. 2984 if (StringPool.empty()) return; 2985 2986 // Start the dwarf str section. 2987 Asm->OutStreamer.SwitchSection( 2988 Asm->getObjFileLowering().getDwarfStrSection()); 2989 2990 // Get all of the string pool entries and put them in an array by their ID so 2991 // we can sort them. 2992 SmallVector<std::pair<unsigned, 2993 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 2994 2995 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 2996 I = StringPool.begin(), E = StringPool.end(); I != E; ++I) 2997 Entries.push_back(std::make_pair(I->second.second, &*I)); 2998 2999 array_pod_sort(Entries.begin(), Entries.end()); 3000 3001 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 3002 // Emit a label for reference from debug information entries. 3003 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 3004 3005 // Emit the string itself. 3006 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/); 3007 } 3008} 3009 3010/// emitDebugLoc - Emit visible names into a debug loc section. 3011/// 3012void DwarfDebug::emitDebugLoc() { 3013 // Start the dwarf loc section. 3014 Asm->OutStreamer.SwitchSection( 3015 Asm->getObjFileLowering().getDwarfLocSection()); 3016} 3017 3018/// EmitDebugARanges - Emit visible names into a debug aranges section. 3019/// 3020void DwarfDebug::EmitDebugARanges() { 3021 // Start the dwarf aranges section. 3022 Asm->OutStreamer.SwitchSection( 3023 Asm->getObjFileLowering().getDwarfARangesSection()); 3024} 3025 3026/// emitDebugRanges - Emit visible names into a debug ranges section. 3027/// 3028void DwarfDebug::emitDebugRanges() { 3029 // Start the dwarf ranges section. 3030 Asm->OutStreamer.SwitchSection( 3031 Asm->getObjFileLowering().getDwarfRangesSection()); 3032} 3033 3034/// emitDebugMacInfo - Emit visible names into a debug macinfo section. 3035/// 3036void DwarfDebug::emitDebugMacInfo() { 3037 if (const MCSection *LineInfo = 3038 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 3039 // Start the dwarf macinfo section. 3040 Asm->OutStreamer.SwitchSection(LineInfo); 3041 } 3042} 3043 3044/// emitDebugInlineInfo - Emit inline info using following format. 3045/// Section Header: 3046/// 1. length of section 3047/// 2. Dwarf version number 3048/// 3. address size. 3049/// 3050/// Entries (one "entry" for each function that was inlined): 3051/// 3052/// 1. offset into __debug_str section for MIPS linkage name, if exists; 3053/// otherwise offset into __debug_str for regular function name. 3054/// 2. offset into __debug_str section for regular function name. 3055/// 3. an unsigned LEB128 number indicating the number of distinct inlining 3056/// instances for the function. 3057/// 3058/// The rest of the entry consists of a {die_offset, low_pc} pair for each 3059/// inlined instance; the die_offset points to the inlined_subroutine die in the 3060/// __debug_info section, and the low_pc is the starting address for the 3061/// inlining instance. 3062void DwarfDebug::emitDebugInlineInfo() { 3063 if (!MAI->doesDwarfUsesInlineInfoSection()) 3064 return; 3065 3066 if (!ModuleCU) 3067 return; 3068 3069 Asm->OutStreamer.SwitchSection( 3070 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 3071 3072 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry"); 3073 EmitDifference(getDWLabel("debug_inlined_end", 1), 3074 getDWLabel("debug_inlined_begin", 1), true); 3075 3076 Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_begin", 1)); 3077 3078 Asm->OutStreamer.AddComment("Dwarf Version"); 3079 Asm->EmitInt16(dwarf::DWARF_VERSION); 3080 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 3081 Asm->EmitInt8(TD->getPointerSize()); 3082 3083 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 3084 E = InlinedSPNodes.end(); I != E; ++I) { 3085 3086 MDNode *Node = *I; 3087 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 3088 = InlineInfo.find(Node); 3089 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 3090 DISubprogram SP(Node); 3091 StringRef LName = SP.getLinkageName(); 3092 StringRef Name = SP.getName(); 3093 3094 Asm->OutStreamer.AddComment("MIPS linkage name"); 3095 if (LName.empty()) { 3096 Asm->OutStreamer.EmitBytes(Name, 0); 3097 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator. 3098 } else 3099 EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)), 3100 getTempLabel("section_str"), true); 3101 3102 Asm->OutStreamer.AddComment("Function name"); 3103 EmitSectionOffset(getStringPoolEntry(Name), getTempLabel("section_str"), 3104 true); 3105 EmitULEB128(Labels.size(), "Inline count"); 3106 3107 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 3108 LE = Labels.end(); LI != LE; ++LI) { 3109 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("DIE offset"); 3110 Asm->EmitInt32(LI->second->getOffset()); 3111 3112 if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("low_pc"); 3113 Asm->OutStreamer.EmitSymbolValue(LI->first, TD->getPointerSize(), 0); 3114 } 3115 } 3116 3117 Asm->OutStreamer.EmitLabel(getDWLabel("debug_inlined_end", 1)); 3118} 3119