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