DwarfDebug.cpp revision 4ad1efec925f36cb5ab461fc3c7e40baaf70ae1a
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 EmitSectionLabels(); 1799 1800 // Create all the compile unit DIEs. 1801 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 1802 E = DbgFinder.compile_unit_end(); I != E; ++I) 1803 constructCompileUnit(*I); 1804 1805 if (!ModuleCU) 1806 return; 1807 1808 // Create DIEs for each subprogram. 1809 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(), 1810 E = DbgFinder.subprogram_end(); I != E; ++I) 1811 constructSubprogramDIE(*I); 1812 1813 // Create DIEs for each global variable. 1814 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(), 1815 E = DbgFinder.global_variable_end(); I != E; ++I) 1816 constructGlobalVariableDIE(*I); 1817 1818 MMI = Asm->MMI; 1819 shouldEmit = true; 1820 MMI->setDebugInfoAvailability(true); 1821 1822 // Prime section data. 1823 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 1824 1825 // Print out .file directives to specify files for .loc directives. These are 1826 // printed out early so that they precede any .loc directives. 1827 if (MAI->hasDotLocAndDotFile()) { 1828 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) { 1829 // Remember source id starts at 1. 1830 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i); 1831 // FIXME: don't use sys::path for this! This should not depend on the 1832 // host. 1833 sys::Path FullPath(getSourceDirectoryName(Id.first)); 1834 bool AppendOk = 1835 FullPath.appendComponent(getSourceFileName(Id.second)); 1836 assert(AppendOk && "Could not append filename to directory!"); 1837 AppendOk = false; 1838 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str()); 1839 } 1840 } 1841} 1842 1843/// endModule - Emit all Dwarf sections that should come after the content. 1844/// 1845void DwarfDebug::endModule() { 1846 if (!ModuleCU) 1847 return; 1848 1849 TimeRegion Timer(DebugTimer); 1850 1851 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 1852 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 1853 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 1854 DIE *ISP = *AI; 1855 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 1856 } 1857 1858 // Insert top level DIEs. 1859 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(), 1860 TE = TopLevelDIEsVector.end(); TI != TE; ++TI) 1861 ModuleCU->getCUDie()->addChild(*TI); 1862 1863 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(), 1864 CE = ContainingTypeMap.end(); CI != CE; ++CI) { 1865 DIE *SPDie = CI->first; 1866 MDNode *N = dyn_cast_or_null<MDNode>(CI->second); 1867 if (!N) continue; 1868 DIE *NDie = ModuleCU->getDIE(N); 1869 if (!NDie) continue; 1870 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie); 1871 // FIXME - This is not the correct approach. 1872 //addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie 1873 } 1874 1875 // Standard sections final addresses. 1876 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 1877 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end")); 1878 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 1879 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end")); 1880 1881 // End text sections. 1882 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) { 1883 Asm->OutStreamer.SwitchSection(SectionMap[i]); 1884 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i)); 1885 } 1886 1887 // Emit common frame information. 1888 emitCommonDebugFrame(); 1889 1890 // Emit function debug frame information 1891 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(), 1892 E = DebugFrames.end(); I != E; ++I) 1893 emitFunctionDebugFrame(*I); 1894 1895 // Compute DIE offsets and sizes. 1896 computeSizeAndOffsets(); 1897 1898 // Emit all the DIEs into a debug info section 1899 emitDebugInfo(); 1900 1901 // Corresponding abbreviations into a abbrev section. 1902 emitAbbreviations(); 1903 1904 // Emit source line correspondence into a debug line section. 1905 emitDebugLines(); 1906 1907 // Emit info into a debug pubnames section. 1908 emitDebugPubNames(); 1909 1910 // Emit info into a debug pubtypes section. 1911 emitDebugPubTypes(); 1912 1913 // Emit info into a debug loc section. 1914 emitDebugLoc(); 1915 1916 // Emit info into a debug aranges section. 1917 EmitDebugARanges(); 1918 1919 // Emit info into a debug ranges section. 1920 emitDebugRanges(); 1921 1922 // Emit info into a debug macinfo section. 1923 emitDebugMacInfo(); 1924 1925 // Emit inline info. 1926 emitDebugInlineInfo(); 1927 1928 // Emit info into a debug str section. 1929 emitDebugStr(); 1930 1931 delete ModuleCU; 1932 ModuleCU = NULL; // Reset for the next Module, if any. 1933} 1934 1935/// findAbstractVariable - Find abstract variable, if any, associated with Var. 1936DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var, 1937 unsigned FrameIdx, 1938 DebugLoc ScopeLoc) { 1939 1940 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode()); 1941 if (AbsDbgVariable) 1942 return AbsDbgVariable; 1943 1944 LLVMContext &Ctx = Var.getNode()->getContext(); 1945 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx)); 1946 if (!Scope) 1947 return NULL; 1948 1949 AbsDbgVariable = new DbgVariable(Var, FrameIdx, 1950 NULL /* No more-abstract variable*/); 1951 Scope->addVariable(AbsDbgVariable); 1952 AbstractVariables[Var.getNode()] = AbsDbgVariable; 1953 return AbsDbgVariable; 1954} 1955 1956/// findAbstractVariable - Find abstract variable, if any, associated with Var. 1957/// FIXME : Refactor findAbstractVariable. 1958DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var, 1959 const MachineInstr *MI, 1960 DebugLoc ScopeLoc) { 1961 1962 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode()); 1963 if (AbsDbgVariable) 1964 return AbsDbgVariable; 1965 1966 LLVMContext &Ctx = Var.getNode()->getContext(); 1967 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx)); 1968 if (!Scope) 1969 return NULL; 1970 1971 AbsDbgVariable = new DbgVariable(Var, MI, 1972 NULL /* No more-abstract variable*/); 1973 Scope->addVariable(AbsDbgVariable); 1974 AbstractVariables[Var.getNode()] = AbsDbgVariable; 1975 DbgValueStartMap[MI] = AbsDbgVariable; 1976 return AbsDbgVariable; 1977} 1978 1979/// collectVariableInfo - Populate DbgScope entries with variables' info. 1980void DwarfDebug::collectVariableInfo() { 1981 if (!MMI) return; 1982 1983 const LLVMContext &Ctx = MF->getFunction()->getContext(); 1984 1985 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 1986 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 1987 VE = VMap.end(); VI != VE; ++VI) { 1988 MDNode *Var = VI->first; 1989 if (!Var) continue; 1990 DIVariable DV(Var); 1991 const std::pair<unsigned, DebugLoc> &VP = VI->second; 1992 1993 DbgScope *Scope = 0; 1994 if (MDNode *IA = VP.second.getInlinedAt(Ctx)) 1995 Scope = ConcreteScopes.lookup(IA); 1996 if (Scope == 0) 1997 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx)); 1998 1999 // If variable scope is not found then skip this variable. 2000 if (Scope == 0) 2001 continue; 2002 2003 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second); 2004 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable); 2005 Scope->addVariable(RegVar); 2006 } 2007 2008 // Collect variable information from DBG_VALUE machine instructions; 2009 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2010 I != E; ++I) { 2011 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2012 II != IE; ++II) { 2013 const MachineInstr *MInsn = II; 2014 if (!MInsn->isDebugValue()) 2015 continue; 2016 2017 // FIXME : Lift this restriction. 2018 if (MInsn->getNumOperands() != 3) 2019 continue; 2020 DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands() 2021 - 1).getMetadata())); 2022 if (DV.getTag() == dwarf::DW_TAG_arg_variable) { 2023 // FIXME Handle inlined subroutine arguments. 2024 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL); 2025 CurrentFnDbgScope->addVariable(ArgVar); 2026 DbgValueStartMap[MInsn] = ArgVar; 2027 continue; 2028 } 2029 2030 DebugLoc DL = MInsn->getDebugLoc(); 2031 if (DL.isUnknown()) continue; 2032 DbgScope *Scope = 0; 2033 if (MDNode *IA = DL.getInlinedAt(Ctx)) 2034 Scope = ConcreteScopes.lookup(IA); 2035 if (Scope == 0) 2036 Scope = DbgScopeMap.lookup(DL.getScope(Ctx)); 2037 2038 // If variable scope is not found then skip this variable. 2039 if (Scope == 0) 2040 continue; 2041 2042 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL); 2043 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable); 2044 DbgValueStartMap[MInsn] = RegVar; 2045 Scope->addVariable(RegVar); 2046 } 2047 } 2048} 2049 2050/// beginScope - Process beginning of a scope. 2051void DwarfDebug::beginScope(const MachineInstr *MI) { 2052 // Check location. 2053 DebugLoc DL = MI->getDebugLoc(); 2054 if (DL.isUnknown()) 2055 return; 2056 2057 // Check and update last known location info. 2058 if (DL == PrevInstLoc) 2059 return; 2060 2061 MDNode *Scope = DL.getScope(MF->getFunction()->getContext()); 2062 2063 // FIXME: Should only verify each scope once! 2064 if (!DIScope(Scope).Verify()) 2065 return; 2066 2067 // DBG_VALUE instruction establishes new value. 2068 if (MI->isDebugValue()) { 2069 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI 2070 = DbgValueStartMap.find(MI); 2071 if (DI != DbgValueStartMap.end()) { 2072 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope); 2073 PrevInstLoc = DL; 2074 DI->second->setDbgValueLabel(Label); 2075 } 2076 return; 2077 } 2078 2079 // Emit a label to indicate location change. This is used for line 2080 // table even if this instruction does start a new scope. 2081 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope); 2082 PrevInstLoc = DL; 2083 2084 // update DbgScope if this instruction starts a new scope. 2085 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI); 2086 if (I == DbgScopeBeginMap.end()) 2087 return; 2088 2089 ScopeVector &SD = I->second; 2090 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end(); 2091 SDI != SDE; ++SDI) 2092 (*SDI)->setStartLabel(Label); 2093} 2094 2095/// endScope - Process end of a scope. 2096void DwarfDebug::endScope(const MachineInstr *MI) { 2097 // Ignore DBG_VALUE instruction. 2098 if (MI->isDebugValue()) 2099 return; 2100 2101 // Check location. 2102 DebugLoc DL = MI->getDebugLoc(); 2103 if (DL.isUnknown()) 2104 return; 2105 2106 // Emit a label and update DbgScope if this instruction ends a scope. 2107 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI); 2108 if (I == DbgScopeEndMap.end()) 2109 return; 2110 2111 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2112 Asm->OutStreamer.EmitLabel(Label); 2113 2114 SmallVector<DbgScope*, 2> &SD = I->second; 2115 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end(); 2116 SDI != SDE; ++SDI) 2117 (*SDI)->setEndLabel(Label); 2118 return; 2119} 2120 2121/// createDbgScope - Create DbgScope for the scope. 2122void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) { 2123 if (!InlinedAt) { 2124 DbgScope *WScope = DbgScopeMap.lookup(Scope); 2125 if (WScope) 2126 return; 2127 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL); 2128 DbgScopeMap.insert(std::make_pair(Scope, WScope)); 2129 if (DIDescriptor(Scope).isLexicalBlock()) 2130 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL); 2131 return; 2132 } 2133 2134 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt); 2135 if (WScope) 2136 return; 2137 2138 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt); 2139 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope)); 2140 DILocation DL(InlinedAt); 2141 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode()); 2142} 2143 2144/// extractScopeInformation - Scan machine instructions in this function 2145/// and collect DbgScopes. Return true, if at least one scope was found. 2146bool DwarfDebug::extractScopeInformation() { 2147 // If scope information was extracted using .dbg intrinsics then there is not 2148 // any need to extract these information by scanning each instruction. 2149 if (!DbgScopeMap.empty()) 2150 return false; 2151 2152 DenseMap<const MachineInstr *, unsigned> MIIndexMap; 2153 unsigned MIIndex = 0; 2154 LLVMContext &Ctx = MF->getFunction()->getContext(); 2155 2156 // Scan each instruction and create scopes. First build working set of scopes. 2157 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2158 I != E; ++I) { 2159 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2160 II != IE; ++II) { 2161 const MachineInstr *MInsn = II; 2162 // FIXME : Remove DBG_VALUE check. 2163 if (MInsn->isDebugValue()) continue; 2164 MIIndexMap[MInsn] = MIIndex++; 2165 2166 DebugLoc DL = MInsn->getDebugLoc(); 2167 if (DL.isUnknown()) continue; 2168 2169 MDNode *Scope = DL.getScope(Ctx); 2170 2171 // There is no need to create another DIE for compile unit. For all 2172 // other scopes, create one DbgScope now. This will be translated 2173 // into a scope DIE at the end. 2174 if (DIScope(Scope).isCompileUnit()) continue; 2175 createDbgScope(Scope, DL.getInlinedAt(Ctx)); 2176 } 2177 } 2178 2179 2180 // Build scope hierarchy using working set of scopes. 2181 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2182 I != E; ++I) { 2183 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2184 II != IE; ++II) { 2185 const MachineInstr *MInsn = II; 2186 // FIXME : Remove DBG_VALUE check. 2187 if (MInsn->isDebugValue()) continue; 2188 DebugLoc DL = MInsn->getDebugLoc(); 2189 if (DL.isUnknown()) continue; 2190 2191 MDNode *Scope = DL.getScope(Ctx); 2192 if (Scope == 0) continue; 2193 2194 // There is no need to create another DIE for compile unit. For all 2195 // other scopes, create one DbgScope now. This will be translated 2196 // into a scope DIE at the end. 2197 if (DIScope(Scope).isCompileUnit()) continue; 2198 DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx)); 2199 DScope->setLastInsn(MInsn); 2200 } 2201 } 2202 2203 if (!CurrentFnDbgScope) 2204 return false; 2205 2206 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap); 2207 2208 // Each scope has first instruction and last instruction to mark beginning 2209 // and end of a scope respectively. Create an inverse map that list scopes 2210 // starts (and ends) with an instruction. One instruction may start (or end) 2211 // multiple scopes. Ignore scopes that are not reachable. 2212 SmallVector<DbgScope *, 4> WorkList; 2213 WorkList.push_back(CurrentFnDbgScope); 2214 while (!WorkList.empty()) { 2215 DbgScope *S = WorkList.pop_back_val(); 2216 2217 const SmallVector<DbgScope *, 4> &Children = S->getScopes(); 2218 if (!Children.empty()) 2219 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2220 SE = Children.end(); SI != SE; ++SI) 2221 WorkList.push_back(*SI); 2222 2223 if (S->isAbstractScope()) 2224 continue; 2225 const MachineInstr *MI = S->getFirstInsn(); 2226 assert(MI && "DbgScope does not have first instruction!"); 2227 2228 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI); 2229 if (IDI != DbgScopeBeginMap.end()) 2230 IDI->second.push_back(S); 2231 else 2232 DbgScopeBeginMap[MI].push_back(S); 2233 2234 MI = S->getLastInsn(); 2235 assert(MI && "DbgScope does not have last instruction!"); 2236 IDI = DbgScopeEndMap.find(MI); 2237 if (IDI != DbgScopeEndMap.end()) 2238 IDI->second.push_back(S); 2239 else 2240 DbgScopeEndMap[MI].push_back(S); 2241 } 2242 2243 return !DbgScopeMap.empty(); 2244} 2245 2246/// beginFunction - Gather pre-function debug information. Assumes being 2247/// emitted immediately after the function entry point. 2248void DwarfDebug::beginFunction(const MachineFunction *MF) { 2249 this->MF = MF; 2250 2251 if (!ShouldEmitDwarfDebug()) return; 2252 if (!extractScopeInformation()) 2253 return; 2254 2255 TimeRegion Timer(DebugTimer); 2256 2257 collectVariableInfo(); 2258 2259 // Assumes in correct section after the entry point. 2260 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_begin", 2261 ++SubprogramCount)); 2262 2263 // Emit label for the implicitly defined dbg.stoppoint at the start of the 2264 // function. 2265 DebugLoc FDL = MF->getDefaultDebugLoc(); 2266 if (FDL.isUnknown()) return; 2267 2268 MDNode *Scope = FDL.getScope(MF->getFunction()->getContext()); 2269 2270 DISubprogram SP = getDISubprogram(Scope); 2271 unsigned Line, Col; 2272 if (SP.Verify()) { 2273 Line = SP.getLineNumber(); 2274 Col = 0; 2275 } else { 2276 Line = FDL.getLine(); 2277 Col = FDL.getCol(); 2278 } 2279 2280 recordSourceLine(Line, Col, Scope); 2281} 2282 2283/// endFunction - Gather and emit post-function debug information. 2284/// 2285void DwarfDebug::endFunction(const MachineFunction *MF) { 2286 if (!ShouldEmitDwarfDebug()) return; 2287 if (DbgScopeMap.empty()) return; 2288 2289 TimeRegion Timer(DebugTimer); 2290 2291 if (CurrentFnDbgScope) { 2292 // Define end label for subprogram. 2293 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end", SubprogramCount)); 2294 2295 // Get function line info. 2296 if (!Lines.empty()) { 2297 // Get section line info. 2298 unsigned ID = SectionMap.insert(Asm->getCurrentSection()); 2299 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID); 2300 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1]; 2301 // Append the function info to section info. 2302 SectionLineInfos.insert(SectionLineInfos.end(), 2303 Lines.begin(), Lines.end()); 2304 } 2305 2306 // Construct abstract scopes. 2307 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2308 AE = AbstractScopesList.end(); AI != AE; ++AI) 2309 constructScopeDIE(*AI); 2310 2311 constructScopeDIE(CurrentFnDbgScope); 2312 2313 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount, 2314 MMI->getFrameMoves())); 2315 } 2316 2317 // Clear debug info 2318 CurrentFnDbgScope = NULL; 2319 DeleteContainerSeconds(DbgScopeMap); 2320 DbgScopeBeginMap.clear(); 2321 DbgScopeEndMap.clear(); 2322 DbgValueStartMap.clear(); 2323 ConcreteScopes.clear(); 2324 DeleteContainerSeconds(AbstractScopes); 2325 AbstractScopesList.clear(); 2326 AbstractVariables.clear(); 2327 Lines.clear(); 2328} 2329 2330/// recordSourceLine - Register a source line with debug info. Returns the 2331/// unique label that was emitted and which provides correspondence to 2332/// the source line list. 2333MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) { 2334 if (!MMI) 2335 return 0; 2336 2337 TimeRegion Timer(DebugTimer); 2338 2339 StringRef Dir; 2340 StringRef Fn; 2341 2342 DIDescriptor Scope(S); 2343 if (Scope.isCompileUnit()) { 2344 DICompileUnit CU(S); 2345 Dir = CU.getDirectory(); 2346 Fn = CU.getFilename(); 2347 } else if (Scope.isSubprogram()) { 2348 DISubprogram SP(S); 2349 Dir = SP.getDirectory(); 2350 Fn = SP.getFilename(); 2351 } else if (Scope.isLexicalBlock()) { 2352 DILexicalBlock DB(S); 2353 Dir = DB.getDirectory(); 2354 Fn = DB.getFilename(); 2355 } else 2356 assert(0 && "Unexpected scope info"); 2357 2358 unsigned Src = GetOrCreateSourceID(Dir, Fn); 2359 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2360 Lines.push_back(SrcLineInfo(Line, Col, Src, Label)); 2361 2362 Asm->OutStreamer.EmitLabel(Label); 2363 return Label; 2364} 2365 2366/// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be 2367/// timed. Look up the source id with the given directory and source file 2368/// names. If none currently exists, create a new id and insert it in the 2369/// SourceIds map. This can update DirectoryNames and SourceFileNames maps as 2370/// well. 2371unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName, 2372 const std::string &FileName) { 2373 TimeRegion Timer(DebugTimer); 2374 return GetOrCreateSourceID(DirName.c_str(), FileName.c_str()); 2375} 2376 2377//===----------------------------------------------------------------------===// 2378// Emit Methods 2379//===----------------------------------------------------------------------===// 2380 2381/// computeSizeAndOffset - Compute the size and offset of a DIE. 2382/// 2383unsigned 2384DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) { 2385 // Get the children. 2386 const std::vector<DIE *> &Children = Die->getChildren(); 2387 2388 // If not last sibling and has children then add sibling offset attribute. 2389 if (!Last && !Children.empty()) 2390 Die->addSiblingOffset(DIEValueAllocator); 2391 2392 // Record the abbreviation. 2393 assignAbbrevNumber(Die->getAbbrev()); 2394 2395 // Get the abbreviation for this DIE. 2396 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2397 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2398 2399 // Set DIE offset 2400 Die->setOffset(Offset); 2401 2402 // Start the size with the size of abbreviation code. 2403 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 2404 2405 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2406 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2407 2408 // Size the DIE attribute values. 2409 for (unsigned i = 0, N = Values.size(); i < N; ++i) 2410 // Size attribute value. 2411 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm()); 2412 2413 // Size the DIE children if any. 2414 if (!Children.empty()) { 2415 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 2416 "Children flag not set"); 2417 2418 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2419 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M); 2420 2421 // End of children marker. 2422 Offset += sizeof(int8_t); 2423 } 2424 2425 Die->setSize(Offset - Die->getOffset()); 2426 return Offset; 2427} 2428 2429/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 2430/// 2431void DwarfDebug::computeSizeAndOffsets() { 2432 // Compute size of compile unit header. 2433 static unsigned Offset = 2434 sizeof(int32_t) + // Length of Compilation Unit Info 2435 sizeof(int16_t) + // DWARF version number 2436 sizeof(int32_t) + // Offset Into Abbrev. Section 2437 sizeof(int8_t); // Pointer Size (in bytes) 2438 2439 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true); 2440 CompileUnitOffsets[ModuleCU] = 0; 2441} 2442 2443/// EmitSectionSym - Switch to the specified MCSection and emit an assembler 2444/// temporary label to it if SymbolStem is specified. 2445static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section, 2446 const char *SymbolStem = 0) { 2447 Asm->OutStreamer.SwitchSection(Section); 2448 if (!SymbolStem) return 0; 2449 2450 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem); 2451 Asm->OutStreamer.EmitLabel(TmpSym); 2452 return TmpSym; 2453} 2454 2455/// EmitSectionLabels - Emit initial Dwarf sections with a label at 2456/// the start of each one. 2457void DwarfDebug::EmitSectionLabels() { 2458 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 2459 2460 // Dwarf sections base addresses. 2461 if (MAI->doesDwarfRequireFrameSection()) { 2462 DwarfFrameSectionSym = 2463 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame"); 2464 } 2465 2466 DwarfInfoSectionSym = 2467 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 2468 DwarfAbbrevSectionSym = 2469 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 2470 EmitSectionSym(Asm, TLOF.getDwarfARangesSection()); 2471 2472 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 2473 EmitSectionSym(Asm, MacroInfo); 2474 2475 EmitSectionSym(Asm, TLOF.getDwarfLineSection()); 2476 EmitSectionSym(Asm, TLOF.getDwarfLocSection()); 2477 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 2478 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 2479 DwarfStrSectionSym = 2480 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str"); 2481 EmitSectionSym(Asm, TLOF.getDwarfRangesSection()); 2482 2483 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 2484 EmitSectionSym(Asm, TLOF.getDataSection()); 2485} 2486 2487/// emitDIE - Recusively Emits a debug information entry. 2488/// 2489void DwarfDebug::emitDIE(DIE *Die) { 2490 // Get the abbreviation for this DIE. 2491 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2492 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2493 2494 // Emit the code (index) for the abbreviation. 2495 if (Asm->isVerbose()) 2496 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 2497 Twine::utohexstr(Die->getOffset()) + ":0x" + 2498 Twine::utohexstr(Die->getSize()) + " " + 2499 dwarf::TagString(Abbrev->getTag())); 2500 Asm->EmitULEB128(AbbrevNumber); 2501 2502 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2503 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2504 2505 // Emit the DIE attribute values. 2506 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 2507 unsigned Attr = AbbrevData[i].getAttribute(); 2508 unsigned Form = AbbrevData[i].getForm(); 2509 assert(Form && "Too many attributes for DIE (check abbreviation)"); 2510 2511 if (Asm->isVerbose()) 2512 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 2513 2514 switch (Attr) { 2515 case dwarf::DW_AT_sibling: 2516 Asm->EmitInt32(Die->getSiblingOffset()); 2517 break; 2518 case dwarf::DW_AT_abstract_origin: { 2519 DIEEntry *E = cast<DIEEntry>(Values[i]); 2520 DIE *Origin = E->getEntry(); 2521 unsigned Addr = Origin->getOffset(); 2522 Asm->EmitInt32(Addr); 2523 break; 2524 } 2525 default: 2526 // Emit an attribute using the defined form. 2527 Values[i]->EmitValue(this, Form); 2528 break; 2529 } 2530 } 2531 2532 // Emit the DIE children if any. 2533 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 2534 const std::vector<DIE *> &Children = Die->getChildren(); 2535 2536 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2537 emitDIE(Children[j]); 2538 2539 if (Asm->isVerbose()) 2540 Asm->OutStreamer.AddComment("End Of Children Mark"); 2541 Asm->EmitInt8(0); 2542 } 2543} 2544 2545/// emitDebugInfo - Emit the debug info section. 2546/// 2547void DwarfDebug::emitDebugInfo() { 2548 // Start debug info section. 2549 Asm->OutStreamer.SwitchSection( 2550 Asm->getObjFileLowering().getDwarfInfoSection()); 2551 DIE *Die = ModuleCU->getCUDie(); 2552 2553 // Emit the compile units header. 2554 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin", 2555 ModuleCU->getID())); 2556 2557 // Emit size of content not including length itself 2558 unsigned ContentSize = Die->getSize() + 2559 sizeof(int16_t) + // DWARF version number 2560 sizeof(int32_t) + // Offset Into Abbrev. Section 2561 sizeof(int8_t) + // Pointer Size (in bytes) 2562 sizeof(int32_t); // FIXME - extra pad for gdb bug. 2563 2564 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 2565 Asm->EmitInt32(ContentSize); 2566 Asm->OutStreamer.AddComment("DWARF version number"); 2567 Asm->EmitInt16(dwarf::DWARF_VERSION); 2568 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 2569 EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"), DwarfAbbrevSectionSym); 2570 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2571 Asm->EmitInt8(TD->getPointerSize()); 2572 2573 emitDIE(Die); 2574 // FIXME - extra padding for gdb bug. 2575 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB"); 2576 Asm->EmitInt8(0); 2577 Asm->EmitInt8(0); 2578 Asm->EmitInt8(0); 2579 Asm->EmitInt8(0); 2580 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", ModuleCU->getID())); 2581} 2582 2583/// emitAbbreviations - Emit the abbreviation section. 2584/// 2585void DwarfDebug::emitAbbreviations() const { 2586 // Check to see if it is worth the effort. 2587 if (!Abbreviations.empty()) { 2588 // Start the debug abbrev section. 2589 Asm->OutStreamer.SwitchSection( 2590 Asm->getObjFileLowering().getDwarfAbbrevSection()); 2591 2592 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin")); 2593 2594 // For each abbrevation. 2595 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 2596 // Get abbreviation data 2597 const DIEAbbrev *Abbrev = Abbreviations[i]; 2598 2599 // Emit the abbrevations code (base 1 index.) 2600 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 2601 2602 // Emit the abbreviations data. 2603 Abbrev->Emit(this); 2604 } 2605 2606 // Mark end of abbreviations. 2607 Asm->EmitULEB128(0, "EOM(3)"); 2608 2609 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end")); 2610 } 2611} 2612 2613/// emitEndOfLineMatrix - Emit the last address of the section and the end of 2614/// the line matrix. 2615/// 2616void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 2617 // Define last address of section. 2618 Asm->OutStreamer.AddComment("Extended Op"); 2619 Asm->EmitInt8(0); 2620 2621 Asm->OutStreamer.AddComment("Op size"); 2622 Asm->EmitInt8(TD->getPointerSize() + 1); 2623 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 2624 Asm->EmitInt8(dwarf::DW_LNE_set_address); 2625 2626 Asm->OutStreamer.AddComment("Section end label"); 2627 2628 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 2629 TD->getPointerSize(), 0/*AddrSpace*/); 2630 2631 // Mark end of matrix. 2632 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 2633 Asm->EmitInt8(0); 2634 Asm->EmitInt8(1); 2635 Asm->EmitInt8(1); 2636} 2637 2638/// emitDebugLines - Emit source line information. 2639/// 2640void DwarfDebug::emitDebugLines() { 2641 // If the target is using .loc/.file, the assembler will be emitting the 2642 // .debug_line table automatically. 2643 if (MAI->hasDotLocAndDotFile()) 2644 return; 2645 2646 // Minimum line delta, thus ranging from -10..(255-10). 2647 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1); 2648 // Maximum line delta, thus ranging from -10..(255-10). 2649 const int MaxLineDelta = 255 + MinLineDelta; 2650 2651 // Start the dwarf line section. 2652 Asm->OutStreamer.SwitchSection( 2653 Asm->getObjFileLowering().getDwarfLineSection()); 2654 2655 // Construct the section header. 2656 Asm->OutStreamer.AddComment("Length of Source Line Info"); 2657 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"), 2658 Asm->GetTempSymbol("line_begin"), 4); 2659 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin")); 2660 2661 Asm->OutStreamer.AddComment("DWARF version number"); 2662 Asm->EmitInt16(dwarf::DWARF_VERSION); 2663 2664 Asm->OutStreamer.AddComment("Prolog Length"); 2665 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"), 2666 Asm->GetTempSymbol("line_prolog_begin"), 4); 2667 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin")); 2668 2669 Asm->OutStreamer.AddComment("Minimum Instruction Length"); 2670 Asm->EmitInt8(1); 2671 Asm->OutStreamer.AddComment("Default is_stmt_start flag"); 2672 Asm->EmitInt8(1); 2673 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)"); 2674 Asm->EmitInt8(MinLineDelta); 2675 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)"); 2676 Asm->EmitInt8(MaxLineDelta); 2677 Asm->OutStreamer.AddComment("Special Opcode Base"); 2678 Asm->EmitInt8(-MinLineDelta); 2679 2680 // Line number standard opcode encodings argument count 2681 Asm->OutStreamer.AddComment("DW_LNS_copy arg count"); 2682 Asm->EmitInt8(0); 2683 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count"); 2684 Asm->EmitInt8(1); 2685 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count"); 2686 Asm->EmitInt8(1); 2687 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count"); 2688 Asm->EmitInt8(1); 2689 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count"); 2690 Asm->EmitInt8(1); 2691 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count"); 2692 Asm->EmitInt8(0); 2693 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count"); 2694 Asm->EmitInt8(0); 2695 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count"); 2696 Asm->EmitInt8(0); 2697 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count"); 2698 Asm->EmitInt8(1); 2699 2700 // Emit directories. 2701 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) { 2702 const std::string &Dir = getSourceDirectoryName(DI); 2703 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory"); 2704 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0); 2705 } 2706 2707 Asm->OutStreamer.AddComment("End of directories"); 2708 Asm->EmitInt8(0); 2709 2710 // Emit files. 2711 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) { 2712 // Remember source id starts at 1. 2713 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI); 2714 const std::string &FN = getSourceFileName(Id.second); 2715 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source"); 2716 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0); 2717 2718 Asm->EmitULEB128(Id.first, "Directory #"); 2719 Asm->EmitULEB128(0, "Mod date"); 2720 Asm->EmitULEB128(0, "File size"); 2721 } 2722 2723 Asm->OutStreamer.AddComment("End of files"); 2724 Asm->EmitInt8(0); 2725 2726 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end")); 2727 2728 // A sequence for each text section. 2729 unsigned SecSrcLinesSize = SectionSourceLines.size(); 2730 2731 for (unsigned j = 0; j < SecSrcLinesSize; ++j) { 2732 // Isolate current sections line info. 2733 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j]; 2734 2735 // Dwarf assumes we start with first line of first source file. 2736 unsigned Source = 1; 2737 unsigned Line = 1; 2738 2739 // Construct rows of the address, source, line, column matrix. 2740 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) { 2741 const SrcLineInfo &LineInfo = LineInfos[i]; 2742 MCSymbol *Label = LineInfo.getLabel(); 2743 if (!Label->isDefined()) continue; // Not emitted, in dead code. 2744 2745 if (LineInfo.getLine() == 0) continue; 2746 2747 if (Asm->isVerbose()) { 2748 std::pair<unsigned, unsigned> SrcID = 2749 getSourceDirectoryAndFileIds(LineInfo.getSourceID()); 2750 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) + 2751 "/" + 2752 Twine(getSourceFileName(SrcID.second)) + 2753 ":" + Twine(LineInfo.getLine())); 2754 } 2755 2756 // Define the line address. 2757 Asm->OutStreamer.AddComment("Extended Op"); 2758 Asm->EmitInt8(0); 2759 Asm->OutStreamer.AddComment("Op size"); 2760 Asm->EmitInt8(TD->getPointerSize() + 1); 2761 2762 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 2763 Asm->EmitInt8(dwarf::DW_LNE_set_address); 2764 2765 Asm->OutStreamer.AddComment("Location label"); 2766 Asm->OutStreamer.EmitSymbolValue(Label, TD->getPointerSize(), 2767 0/*AddrSpace*/); 2768 2769 // If change of source, then switch to the new source. 2770 if (Source != LineInfo.getSourceID()) { 2771 Source = LineInfo.getSourceID(); 2772 Asm->OutStreamer.AddComment("DW_LNS_set_file"); 2773 Asm->EmitInt8(dwarf::DW_LNS_set_file); 2774 Asm->EmitULEB128(Source, "New Source"); 2775 } 2776 2777 // If change of line. 2778 if (Line != LineInfo.getLine()) { 2779 // Determine offset. 2780 int Offset = LineInfo.getLine() - Line; 2781 int Delta = Offset - MinLineDelta; 2782 2783 // Update line. 2784 Line = LineInfo.getLine(); 2785 2786 // If delta is small enough and in range... 2787 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { 2788 // ... then use fast opcode. 2789 Asm->OutStreamer.AddComment("Line Delta"); 2790 Asm->EmitInt8(Delta - MinLineDelta); 2791 } else { 2792 // ... otherwise use long hand. 2793 Asm->OutStreamer.AddComment("DW_LNS_advance_line"); 2794 Asm->EmitInt8(dwarf::DW_LNS_advance_line); 2795 Asm->EmitSLEB128(Offset, "Line Offset"); 2796 Asm->OutStreamer.AddComment("DW_LNS_copy"); 2797 Asm->EmitInt8(dwarf::DW_LNS_copy); 2798 } 2799 } else { 2800 // Copy the previous row (different address or source) 2801 Asm->OutStreamer.AddComment("DW_LNS_copy"); 2802 Asm->EmitInt8(dwarf::DW_LNS_copy); 2803 } 2804 } 2805 2806 emitEndOfLineMatrix(j + 1); 2807 } 2808 2809 if (SecSrcLinesSize == 0) 2810 // Because we're emitting a debug_line section, we still need a line 2811 // table. The linker and friends expect it to exist. If there's nothing to 2812 // put into it, emit an empty table. 2813 emitEndOfLineMatrix(1); 2814 2815 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end")); 2816} 2817 2818/// emitCommonDebugFrame - Emit common frame info into a debug frame section. 2819/// 2820void DwarfDebug::emitCommonDebugFrame() { 2821 if (!MAI->doesDwarfRequireFrameSection()) 2822 return; 2823 2824 int stackGrowth = 2825 Asm->TM.getFrameInfo()->getStackGrowthDirection() == 2826 TargetFrameInfo::StackGrowsUp ? 2827 TD->getPointerSize() : -TD->getPointerSize(); 2828 2829 // Start the dwarf frame section. 2830 Asm->OutStreamer.SwitchSection( 2831 Asm->getObjFileLowering().getDwarfFrameSection()); 2832 2833 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common")); 2834 Asm->OutStreamer.AddComment("Length of Common Information Entry"); 2835 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"), 2836 Asm->GetTempSymbol("debug_frame_common_begin"), 4); 2837 2838 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin")); 2839 Asm->OutStreamer.AddComment("CIE Identifier Tag"); 2840 Asm->EmitInt32((int)dwarf::DW_CIE_ID); 2841 Asm->OutStreamer.AddComment("CIE Version"); 2842 Asm->EmitInt8(dwarf::DW_CIE_VERSION); 2843 Asm->OutStreamer.AddComment("CIE Augmentation"); 2844 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator. 2845 Asm->EmitULEB128(1, "CIE Code Alignment Factor"); 2846 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor"); 2847 Asm->OutStreamer.AddComment("CIE RA Column"); 2848 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); 2849 2850 std::vector<MachineMove> Moves; 2851 RI->getInitialFrameState(Moves); 2852 2853 EmitFrameMoves(0, Moves, false); 2854 2855 Asm->EmitAlignment(2, 0, 0, false); 2856 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end")); 2857} 2858 2859/// emitFunctionDebugFrame - Emit per function frame info into a debug frame 2860/// section. 2861void DwarfDebug:: 2862emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) { 2863 if (!MAI->doesDwarfRequireFrameSection()) 2864 return; 2865 2866 // Start the dwarf frame section. 2867 Asm->OutStreamer.SwitchSection( 2868 Asm->getObjFileLowering().getDwarfFrameSection()); 2869 2870 Asm->OutStreamer.AddComment("Length of Frame Information Entry"); 2871 MCSymbol *DebugFrameBegin = 2872 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number); 2873 MCSymbol *DebugFrameEnd = 2874 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number); 2875 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4); 2876 2877 Asm->OutStreamer.EmitLabel(DebugFrameBegin); 2878 2879 Asm->OutStreamer.AddComment("FDE CIE offset"); 2880 EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"), 2881 DwarfFrameSectionSym); 2882 2883 Asm->OutStreamer.AddComment("FDE initial location"); 2884 MCSymbol *FuncBeginSym = 2885 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number); 2886 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym, 2887 TD->getPointerSize(), 0/*AddrSpace*/); 2888 2889 2890 Asm->OutStreamer.AddComment("FDE address range"); 2891 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number), 2892 FuncBeginSym, TD->getPointerSize()); 2893 2894 EmitFrameMoves(FuncBeginSym, DebugFrameInfo.Moves, false); 2895 2896 Asm->EmitAlignment(2, 0, 0, false); 2897 Asm->OutStreamer.EmitLabel(DebugFrameEnd); 2898} 2899 2900/// emitDebugPubNames - Emit visible names into a debug pubnames section. 2901/// 2902void DwarfDebug::emitDebugPubNames() { 2903 // Start the dwarf pubnames section. 2904 Asm->OutStreamer.SwitchSection( 2905 Asm->getObjFileLowering().getDwarfPubNamesSection()); 2906 2907 Asm->OutStreamer.AddComment("Length of Public Names Info"); 2908 Asm->EmitLabelDifference( 2909 Asm->GetTempSymbol("pubnames_end", ModuleCU->getID()), 2910 Asm->GetTempSymbol("pubnames_begin", ModuleCU->getID()), 4); 2911 2912 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", 2913 ModuleCU->getID())); 2914 2915 Asm->OutStreamer.AddComment("DWARF Version"); 2916 Asm->EmitInt16(dwarf::DWARF_VERSION); 2917 2918 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2919 EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()), 2920 DwarfInfoSectionSym); 2921 2922 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2923 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()), 2924 Asm->GetTempSymbol("info_begin", ModuleCU->getID()), 2925 4); 2926 2927 const StringMap<DIE*> &Globals = ModuleCU->getGlobals(); 2928 for (StringMap<DIE*>::const_iterator 2929 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2930 const char *Name = GI->getKeyData(); 2931 DIE *Entity = GI->second; 2932 2933 Asm->OutStreamer.AddComment("DIE offset"); 2934 Asm->EmitInt32(Entity->getOffset()); 2935 2936 if (Asm->isVerbose()) 2937 Asm->OutStreamer.AddComment("External Name"); 2938 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0); 2939 } 2940 2941 Asm->OutStreamer.AddComment("End Mark"); 2942 Asm->EmitInt32(0); 2943 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", 2944 ModuleCU->getID())); 2945} 2946 2947void DwarfDebug::emitDebugPubTypes() { 2948 // Start the dwarf pubnames section. 2949 Asm->OutStreamer.SwitchSection( 2950 Asm->getObjFileLowering().getDwarfPubTypesSection()); 2951 Asm->OutStreamer.AddComment("Length of Public Types Info"); 2952 Asm->EmitLabelDifference( 2953 Asm->GetTempSymbol("pubtypes_end", ModuleCU->getID()), 2954 Asm->GetTempSymbol("pubtypes_begin", ModuleCU->getID()), 4); 2955 2956 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 2957 ModuleCU->getID())); 2958 2959 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 2960 Asm->EmitInt16(dwarf::DWARF_VERSION); 2961 2962 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info"); 2963 EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()), 2964 DwarfInfoSectionSym); 2965 2966 Asm->OutStreamer.AddComment("Compilation ModuleCU Length"); 2967 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()), 2968 Asm->GetTempSymbol("info_begin", ModuleCU->getID()), 2969 4); 2970 2971 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes(); 2972 for (StringMap<DIE*>::const_iterator 2973 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2974 const char *Name = GI->getKeyData(); 2975 DIE * Entity = GI->second; 2976 2977 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 2978 Asm->EmitInt32(Entity->getOffset()); 2979 2980 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 2981 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0); 2982 } 2983 2984 Asm->OutStreamer.AddComment("End Mark"); 2985 Asm->EmitInt32(0); 2986 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 2987 ModuleCU->getID())); 2988} 2989 2990/// emitDebugStr - Emit visible names into a debug str section. 2991/// 2992void DwarfDebug::emitDebugStr() { 2993 // Check to see if it is worth the effort. 2994 if (StringPool.empty()) return; 2995 2996 // Start the dwarf str section. 2997 Asm->OutStreamer.SwitchSection( 2998 Asm->getObjFileLowering().getDwarfStrSection()); 2999 3000 // Get all of the string pool entries and put them in an array by their ID so 3001 // we can sort them. 3002 SmallVector<std::pair<unsigned, 3003 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 3004 3005 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 3006 I = StringPool.begin(), E = StringPool.end(); I != E; ++I) 3007 Entries.push_back(std::make_pair(I->second.second, &*I)); 3008 3009 array_pod_sort(Entries.begin(), Entries.end()); 3010 3011 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 3012 // Emit a label for reference from debug information entries. 3013 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 3014 3015 // Emit the string itself. 3016 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/); 3017 } 3018} 3019 3020/// emitDebugLoc - Emit visible names into a debug loc section. 3021/// 3022void DwarfDebug::emitDebugLoc() { 3023 // Start the dwarf loc section. 3024 Asm->OutStreamer.SwitchSection( 3025 Asm->getObjFileLowering().getDwarfLocSection()); 3026} 3027 3028/// EmitDebugARanges - Emit visible names into a debug aranges section. 3029/// 3030void DwarfDebug::EmitDebugARanges() { 3031 // Start the dwarf aranges section. 3032 Asm->OutStreamer.SwitchSection( 3033 Asm->getObjFileLowering().getDwarfARangesSection()); 3034} 3035 3036/// emitDebugRanges - Emit visible names into a debug ranges section. 3037/// 3038void DwarfDebug::emitDebugRanges() { 3039 // Start the dwarf ranges section. 3040 Asm->OutStreamer.SwitchSection( 3041 Asm->getObjFileLowering().getDwarfRangesSection()); 3042} 3043 3044/// emitDebugMacInfo - Emit visible names into a debug macinfo section. 3045/// 3046void DwarfDebug::emitDebugMacInfo() { 3047 if (const MCSection *LineInfo = 3048 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 3049 // Start the dwarf macinfo section. 3050 Asm->OutStreamer.SwitchSection(LineInfo); 3051 } 3052} 3053 3054/// emitDebugInlineInfo - Emit inline info using following format. 3055/// Section Header: 3056/// 1. length of section 3057/// 2. Dwarf version number 3058/// 3. address size. 3059/// 3060/// Entries (one "entry" for each function that was inlined): 3061/// 3062/// 1. offset into __debug_str section for MIPS linkage name, if exists; 3063/// otherwise offset into __debug_str for regular function name. 3064/// 2. offset into __debug_str section for regular function name. 3065/// 3. an unsigned LEB128 number indicating the number of distinct inlining 3066/// instances for the function. 3067/// 3068/// The rest of the entry consists of a {die_offset, low_pc} pair for each 3069/// inlined instance; the die_offset points to the inlined_subroutine die in the 3070/// __debug_info section, and the low_pc is the starting address for the 3071/// inlining instance. 3072void DwarfDebug::emitDebugInlineInfo() { 3073 if (!MAI->doesDwarfUsesInlineInfoSection()) 3074 return; 3075 3076 if (!ModuleCU) 3077 return; 3078 3079 Asm->OutStreamer.SwitchSection( 3080 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 3081 3082 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry"); 3083 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1), 3084 Asm->GetTempSymbol("debug_inlined_begin", 1), 4); 3085 3086 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1)); 3087 3088 Asm->OutStreamer.AddComment("Dwarf Version"); 3089 Asm->EmitInt16(dwarf::DWARF_VERSION); 3090 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 3091 Asm->EmitInt8(TD->getPointerSize()); 3092 3093 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 3094 E = InlinedSPNodes.end(); I != E; ++I) { 3095 3096 MDNode *Node = *I; 3097 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 3098 = InlineInfo.find(Node); 3099 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 3100 DISubprogram SP(Node); 3101 StringRef LName = SP.getLinkageName(); 3102 StringRef Name = SP.getName(); 3103 3104 Asm->OutStreamer.AddComment("MIPS linkage name"); 3105 if (LName.empty()) { 3106 Asm->OutStreamer.EmitBytes(Name, 0); 3107 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator. 3108 } else 3109 EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)), 3110 DwarfStrSectionSym); 3111 3112 Asm->OutStreamer.AddComment("Function name"); 3113 EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym); 3114 Asm->EmitULEB128(Labels.size(), "Inline count"); 3115 3116 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 3117 LE = Labels.end(); LI != LE; ++LI) { 3118 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 3119 Asm->EmitInt32(LI->second->getOffset()); 3120 3121 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc"); 3122 Asm->OutStreamer.EmitSymbolValue(LI->first, TD->getPointerSize(), 0); 3123 } 3124 } 3125 3126 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1)); 3127} 3128