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