DwarfDebug.cpp revision 0b48eade42022c929fcf0f2afcffdf849c5bd05a
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 "DIE.h" 17#include "llvm/Constants.h" 18#include "llvm/Module.h" 19#include "llvm/CodeGen/MachineFunction.h" 20#include "llvm/CodeGen/MachineModuleInfo.h" 21#include "llvm/MC/MCAsmInfo.h" 22#include "llvm/MC/MCSection.h" 23#include "llvm/MC/MCStreamer.h" 24#include "llvm/MC/MCSymbol.h" 25#include "llvm/Target/Mangler.h" 26#include "llvm/Target/TargetData.h" 27#include "llvm/Target/TargetFrameInfo.h" 28#include "llvm/Target/TargetLoweringObjectFile.h" 29#include "llvm/Target/TargetMachine.h" 30#include "llvm/Target/TargetRegisterInfo.h" 31#include "llvm/Target/TargetOptions.h" 32#include "llvm/Analysis/DebugInfo.h" 33#include "llvm/ADT/STLExtras.h" 34#include "llvm/ADT/StringExtras.h" 35#include "llvm/Support/CommandLine.h" 36#include "llvm/Support/Debug.h" 37#include "llvm/Support/ErrorHandling.h" 38#include "llvm/Support/ValueHandle.h" 39#include "llvm/Support/FormattedStream.h" 40#include "llvm/Support/Timer.h" 41#include "llvm/System/Path.h" 42using namespace llvm; 43 44static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden, 45 cl::desc("Print DbgScope information for each machine instruction")); 46 47static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print", 48 cl::Hidden, 49 cl::desc("Disable debug info printing")); 50 51static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden, 52 cl::desc("Make an absense of debug location information explicit."), 53 cl::init(false)); 54 55namespace { 56 const char *DWARFGroupName = "DWARF Emission"; 57 const char *DbgTimerName = "DWARF Debug Writer"; 58} // end anonymous namespace 59 60//===----------------------------------------------------------------------===// 61 62/// Configuration values for initial hash set sizes (log2). 63/// 64static const unsigned InitAbbreviationsSetSize = 9; // log2(512) 65 66namespace llvm { 67 68//===----------------------------------------------------------------------===// 69/// CompileUnit - This dwarf writer support class manages information associate 70/// with a source file. 71class CompileUnit { 72 /// ID - File identifier for source. 73 /// 74 unsigned ID; 75 76 /// Die - Compile unit debug information entry. 77 /// 78 const OwningPtr<DIE> CUDie; 79 80 /// IndexTyDie - An anonymous type for index type. Owned by CUDie. 81 DIE *IndexTyDie; 82 83 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton 84 /// variables to debug information entries. 85 DenseMap<const MDNode *, DIE *> MDNodeToDieMap; 86 87 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton 88 /// descriptors to debug information entries using a DIEEntry proxy. 89 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap; 90 91 /// Globals - A map of globally visible named entities for this unit. 92 /// 93 StringMap<DIE*> Globals; 94 95 /// GlobalTypes - A map of globally visible types for this unit. 96 /// 97 StringMap<DIE*> GlobalTypes; 98 99public: 100 CompileUnit(unsigned I, DIE *D) 101 : ID(I), CUDie(D), IndexTyDie(0) {} 102 103 // Accessors. 104 unsigned getID() const { return ID; } 105 DIE* getCUDie() const { return CUDie.get(); } 106 const StringMap<DIE*> &getGlobals() const { return Globals; } 107 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; } 108 109 /// hasContent - Return true if this compile unit has something to write out. 110 /// 111 bool hasContent() const { return !CUDie->getChildren().empty(); } 112 113 /// addGlobal - Add a new global entity to the compile unit. 114 /// 115 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; } 116 117 /// addGlobalType - Add a new global type to the compile unit. 118 /// 119 void addGlobalType(StringRef Name, DIE *Die) { 120 GlobalTypes[Name] = Die; 121 } 122 123 /// getDIE - Returns the debug information entry map slot for the 124 /// specified debug variable. 125 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); } 126 127 /// insertDIE - Insert DIE into the map. 128 void insertDIE(const MDNode *N, DIE *D) { 129 MDNodeToDieMap.insert(std::make_pair(N, D)); 130 } 131 132 /// getDIEEntry - Returns the debug information entry for the speciefied 133 /// debug variable. 134 DIEEntry *getDIEEntry(const MDNode *N) { 135 DenseMap<const MDNode *, DIEEntry *>::iterator I = 136 MDNodeToDIEEntryMap.find(N); 137 if (I == MDNodeToDIEEntryMap.end()) 138 return NULL; 139 return I->second; 140 } 141 142 /// insertDIEEntry - Insert debug information entry into the map. 143 void insertDIEEntry(const MDNode *N, DIEEntry *E) { 144 MDNodeToDIEEntryMap.insert(std::make_pair(N, E)); 145 } 146 147 /// addDie - Adds or interns the DIE to the compile unit. 148 /// 149 void addDie(DIE *Buffer) { 150 this->CUDie->addChild(Buffer); 151 } 152 153 // getIndexTyDie - Get an anonymous type for index type. 154 DIE *getIndexTyDie() { 155 return IndexTyDie; 156 } 157 158 // setIndexTyDie - Set D as anonymous type for index which can be reused 159 // later. 160 void setIndexTyDie(DIE *D) { 161 IndexTyDie = D; 162 } 163 164}; 165 166//===----------------------------------------------------------------------===// 167/// DbgVariable - This class is used to track local variable information. 168/// 169class DbgVariable { 170 DIVariable Var; // Variable Descriptor. 171 DIE *TheDIE; // Variable DIE. 172 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries. 173public: 174 // AbsVar may be NULL. 175 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {} 176 177 // Accessors. 178 DIVariable getVariable() const { return Var; } 179 void setDIE(DIE *D) { TheDIE = D; } 180 DIE *getDIE() const { return TheDIE; } 181 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; } 182 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; } 183 StringRef getName() const { return Var.getName(); } 184 unsigned getTag() const { return Var.getTag(); } 185 bool variableHasComplexAddress() const { 186 assert(Var.Verify() && "Invalid complex DbgVariable!"); 187 return Var.hasComplexAddress(); 188 } 189 bool isBlockByrefVariable() const { 190 assert(Var.Verify() && "Invalid complex DbgVariable!"); 191 return Var.isBlockByrefVariable(); 192 } 193 unsigned getNumAddrElements() const { 194 assert(Var.Verify() && "Invalid complex DbgVariable!"); 195 return Var.getNumAddrElements(); 196 } 197 uint64_t getAddrElement(unsigned i) const { 198 return Var.getAddrElement(i); 199 } 200 DIType getType() const { 201 DIType Ty = Var.getType(); 202 // FIXME: isBlockByrefVariable should be reformulated in terms of complex 203 // addresses instead. 204 if (Var.isBlockByrefVariable()) { 205 /* Byref variables, in Blocks, are declared by the programmer as 206 "SomeType VarName;", but the compiler creates a 207 __Block_byref_x_VarName struct, and gives the variable VarName 208 either the struct, or a pointer to the struct, as its type. This 209 is necessary for various behind-the-scenes things the compiler 210 needs to do with by-reference variables in blocks. 211 212 However, as far as the original *programmer* is concerned, the 213 variable should still have type 'SomeType', as originally declared. 214 215 The following function dives into the __Block_byref_x_VarName 216 struct to find the original type of the variable. This will be 217 passed back to the code generating the type for the Debug 218 Information Entry for the variable 'VarName'. 'VarName' will then 219 have the original type 'SomeType' in its debug information. 220 221 The original type 'SomeType' will be the type of the field named 222 'VarName' inside the __Block_byref_x_VarName struct. 223 224 NOTE: In order for this to not completely fail on the debugger 225 side, the Debug Information Entry for the variable VarName needs to 226 have a DW_AT_location that tells the debugger how to unwind through 227 the pointers and __Block_byref_x_VarName struct to find the actual 228 value of the variable. The function addBlockByrefType does this. */ 229 DIType subType = Ty; 230 unsigned tag = Ty.getTag(); 231 232 if (tag == dwarf::DW_TAG_pointer_type) { 233 DIDerivedType DTy = DIDerivedType(Ty); 234 subType = DTy.getTypeDerivedFrom(); 235 } 236 237 DICompositeType blockStruct = DICompositeType(subType); 238 DIArray Elements = blockStruct.getTypeArray(); 239 240 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 241 DIDescriptor Element = Elements.getElement(i); 242 DIDerivedType DT = DIDerivedType(Element); 243 if (getName() == DT.getName()) 244 return (DT.getTypeDerivedFrom()); 245 } 246 return Ty; 247 } 248 return Ty; 249 } 250}; 251 252//===----------------------------------------------------------------------===// 253/// DbgRange - This is used to track range of instructions with identical 254/// debug info scope. 255/// 256typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange; 257 258//===----------------------------------------------------------------------===// 259/// DbgScope - This class is used to track scope information. 260/// 261class DbgScope { 262 DbgScope *Parent; // Parent to this scope. 263 DIDescriptor Desc; // Debug info descriptor for scope. 264 // Location at which this scope is inlined. 265 AssertingVH<const MDNode> InlinedAtLocation; 266 bool AbstractScope; // Abstract Scope 267 const MachineInstr *LastInsn; // Last instruction of this scope. 268 const MachineInstr *FirstInsn; // First instruction of this scope. 269 unsigned DFSIn, DFSOut; 270 // Scopes defined in scope. Contents not owned. 271 SmallVector<DbgScope *, 4> Scopes; 272 // Variables declared in scope. Contents owned. 273 SmallVector<DbgVariable *, 8> Variables; 274 SmallVector<DbgRange, 4> Ranges; 275 // Private state for dump() 276 mutable unsigned IndentLevel; 277public: 278 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0) 279 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false), 280 LastInsn(0), FirstInsn(0), 281 DFSIn(0), DFSOut(0), IndentLevel(0) {} 282 virtual ~DbgScope(); 283 284 // Accessors. 285 DbgScope *getParent() const { return Parent; } 286 void setParent(DbgScope *P) { Parent = P; } 287 DIDescriptor getDesc() const { return Desc; } 288 const MDNode *getInlinedAt() const { return InlinedAtLocation; } 289 const MDNode *getScopeNode() const { return Desc; } 290 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; } 291 const SmallVector<DbgVariable *, 8> &getDbgVariables() { return Variables; } 292 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; } 293 294 /// openInsnRange - This scope covers instruction range starting from MI. 295 void openInsnRange(const MachineInstr *MI) { 296 if (!FirstInsn) 297 FirstInsn = MI; 298 299 if (Parent) 300 Parent->openInsnRange(MI); 301 } 302 303 /// extendInsnRange - Extend the current instruction range covered by 304 /// this scope. 305 void extendInsnRange(const MachineInstr *MI) { 306 assert (FirstInsn && "MI Range is not open!"); 307 LastInsn = MI; 308 if (Parent) 309 Parent->extendInsnRange(MI); 310 } 311 312 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected 313 /// until now. This is used when a new scope is encountered while walking 314 /// machine instructions. 315 void closeInsnRange(DbgScope *NewScope = NULL) { 316 assert (LastInsn && "Last insn missing!"); 317 Ranges.push_back(DbgRange(FirstInsn, LastInsn)); 318 FirstInsn = NULL; 319 LastInsn = NULL; 320 // If Parent dominates NewScope then do not close Parent's instruction 321 // range. 322 if (Parent && (!NewScope || !Parent->dominates(NewScope))) 323 Parent->closeInsnRange(NewScope); 324 } 325 326 void setAbstractScope() { AbstractScope = true; } 327 bool isAbstractScope() const { return AbstractScope; } 328 329 // Depth First Search support to walk and mainpluate DbgScope hierarchy. 330 unsigned getDFSOut() const { return DFSOut; } 331 void setDFSOut(unsigned O) { DFSOut = O; } 332 unsigned getDFSIn() const { return DFSIn; } 333 void setDFSIn(unsigned I) { DFSIn = I; } 334 bool dominates(const DbgScope *S) { 335 if (S == this) 336 return true; 337 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut()) 338 return true; 339 return false; 340 } 341 342 /// addScope - Add a scope to the scope. 343 /// 344 void addScope(DbgScope *S) { Scopes.push_back(S); } 345 346 /// addVariable - Add a variable to the scope. 347 /// 348 void addVariable(DbgVariable *V) { Variables.push_back(V); } 349 350#ifndef NDEBUG 351 void dump() const; 352#endif 353}; 354 355} // end llvm namespace 356 357#ifndef NDEBUG 358void DbgScope::dump() const { 359 raw_ostream &err = dbgs(); 360 err.indent(IndentLevel); 361 const MDNode *N = Desc; 362 N->dump(); 363 if (AbstractScope) 364 err << "Abstract Scope\n"; 365 366 IndentLevel += 2; 367 if (!Scopes.empty()) 368 err << "Children ...\n"; 369 for (unsigned i = 0, e = Scopes.size(); i != e; ++i) 370 if (Scopes[i] != this) 371 Scopes[i]->dump(); 372 373 IndentLevel -= 2; 374} 375#endif 376 377DbgScope::~DbgScope() { 378 for (unsigned j = 0, M = Variables.size(); j < M; ++j) 379 delete Variables[j]; 380} 381 382DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M) 383 : Asm(A), MMI(Asm->MMI), FirstCU(0), 384 AbbreviationsSet(InitAbbreviationsSetSize), 385 CurrentFnDbgScope(0), PrevLabel(NULL) { 386 NextStringPoolNumber = 0; 387 388 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0; 389 DwarfStrSectionSym = TextSectionSym = 0; 390 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0; 391 FunctionBeginSym = FunctionEndSym = 0; 392 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1); 393 { 394 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled); 395 beginModule(M); 396 } 397} 398DwarfDebug::~DwarfDebug() { 399 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j) 400 DIEBlocks[j]->~DIEBlock(); 401} 402 403MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) { 404 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str]; 405 if (Entry.first) return Entry.first; 406 407 Entry.second = NextStringPoolNumber++; 408 return Entry.first = Asm->GetTempSymbol("string", Entry.second); 409} 410 411 412/// assignAbbrevNumber - Define a unique number for the abbreviation. 413/// 414void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) { 415 // Profile the node so that we can make it unique. 416 FoldingSetNodeID ID; 417 Abbrev.Profile(ID); 418 419 // Check the set for priors. 420 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev); 421 422 // If it's newly added. 423 if (InSet == &Abbrev) { 424 // Add to abbreviation list. 425 Abbreviations.push_back(&Abbrev); 426 427 // Assign the vector position + 1 as its number. 428 Abbrev.setNumber(Abbreviations.size()); 429 } else { 430 // Assign existing abbreviation number. 431 Abbrev.setNumber(InSet->getNumber()); 432 } 433} 434 435/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug 436/// information entry. 437DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) { 438 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry); 439 return Value; 440} 441 442/// addUInt - Add an unsigned integer attribute data and value. 443/// 444void DwarfDebug::addUInt(DIE *Die, unsigned Attribute, 445 unsigned Form, uint64_t Integer) { 446 if (!Form) Form = DIEInteger::BestForm(false, Integer); 447 DIEValue *Value = Integer == 1 ? 448 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer); 449 Die->addValue(Attribute, Form, Value); 450} 451 452/// addSInt - Add an signed integer attribute data and value. 453/// 454void DwarfDebug::addSInt(DIE *Die, unsigned Attribute, 455 unsigned Form, int64_t Integer) { 456 if (!Form) Form = DIEInteger::BestForm(true, Integer); 457 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer); 458 Die->addValue(Attribute, Form, Value); 459} 460 461/// addString - Add a string attribute data and value. DIEString only 462/// keeps string reference. 463void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form, 464 StringRef String) { 465 DIEValue *Value = new (DIEValueAllocator) DIEString(String); 466 Die->addValue(Attribute, Form, Value); 467} 468 469/// addLabel - Add a Dwarf label attribute data and value. 470/// 471void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form, 472 const MCSymbol *Label) { 473 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label); 474 Die->addValue(Attribute, Form, Value); 475} 476 477/// addDelta - Add a label delta attribute data and value. 478/// 479void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form, 480 const MCSymbol *Hi, const MCSymbol *Lo) { 481 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo); 482 Die->addValue(Attribute, Form, Value); 483} 484 485/// addDIEEntry - Add a DIE attribute data and value. 486/// 487void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form, 488 DIE *Entry) { 489 Die->addValue(Attribute, Form, createDIEEntry(Entry)); 490} 491 492 493/// addBlock - Add block data. 494/// 495void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form, 496 DIEBlock *Block) { 497 Block->ComputeSize(Asm); 498 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on. 499 Die->addValue(Attribute, Block->BestForm(), Block); 500} 501 502/// addSourceLine - Add location information to specified debug information 503/// entry. 504void DwarfDebug::addSourceLine(DIE *Die, DIVariable V) { 505 // Verify variable. 506 if (!V.Verify()) 507 return; 508 509 unsigned Line = V.getLineNumber(); 510 unsigned FileID = GetOrCreateSourceID(V.getContext().getDirectory(), 511 V.getContext().getFilename()); 512 assert(FileID && "Invalid file id"); 513 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 514 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 515} 516 517/// addSourceLine - Add location information to specified debug information 518/// entry. 519void DwarfDebug::addSourceLine(DIE *Die, DIGlobalVariable G) { 520 // Verify global variable. 521 if (!G.Verify()) 522 return; 523 524 unsigned Line = G.getLineNumber(); 525 unsigned FileID = GetOrCreateSourceID(G.getContext().getDirectory(), 526 G.getContext().getFilename()); 527 assert(FileID && "Invalid file id"); 528 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 529 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 530} 531 532/// addSourceLine - Add location information to specified debug information 533/// entry. 534void DwarfDebug::addSourceLine(DIE *Die, DISubprogram SP) { 535 // Verify subprogram. 536 if (!SP.Verify()) 537 return; 538 // If the line number is 0, don't add it. 539 if (SP.getLineNumber() == 0) 540 return; 541 542 unsigned Line = SP.getLineNumber(); 543 if (!SP.getContext().Verify()) 544 return; 545 unsigned FileID = GetOrCreateSourceID(SP.getDirectory(), 546 SP.getFilename()); 547 assert(FileID && "Invalid file id"); 548 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 549 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 550} 551 552/// addSourceLine - Add location information to specified debug information 553/// entry. 554void DwarfDebug::addSourceLine(DIE *Die, DIType Ty) { 555 // Verify type. 556 if (!Ty.Verify()) 557 return; 558 559 unsigned Line = Ty.getLineNumber(); 560 if (!Ty.getContext().Verify()) 561 return; 562 unsigned FileID = GetOrCreateSourceID(Ty.getContext().getDirectory(), 563 Ty.getContext().getFilename()); 564 assert(FileID && "Invalid file id"); 565 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 566 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 567} 568 569/// addSourceLine - Add location information to specified debug information 570/// entry. 571void DwarfDebug::addSourceLine(DIE *Die, DINameSpace NS) { 572 // Verify namespace. 573 if (!NS.Verify()) 574 return; 575 576 unsigned Line = NS.getLineNumber(); 577 StringRef FN = NS.getFilename(); 578 StringRef Dir = NS.getDirectory(); 579 580 unsigned FileID = GetOrCreateSourceID(Dir, FN); 581 assert(FileID && "Invalid file id"); 582 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 583 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 584} 585 586/// addVariableAddress - Add DW_AT_location attribute for a DbgVariable based 587/// on provided frame index. 588void DwarfDebug::addVariableAddress(DbgVariable *&DV, DIE *Die, int64_t FI) { 589 MachineLocation Location; 590 unsigned FrameReg; 591 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 592 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg); 593 Location.set(FrameReg, Offset); 594 595 if (DV->variableHasComplexAddress()) 596 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location); 597 else if (DV->isBlockByrefVariable()) 598 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location); 599 else 600 addAddress(Die, dwarf::DW_AT_location, Location); 601} 602 603/// addComplexAddress - Start with the address based on the location provided, 604/// and generate the DWARF information necessary to find the actual variable 605/// given the extra address information encoded in the DIVariable, starting from 606/// the starting location. Add the DWARF information to the die. 607/// 608void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die, 609 unsigned Attribute, 610 const MachineLocation &Location) { 611 DIType Ty = DV->getType(); 612 613 // Decode the original location, and use that as the start of the byref 614 // variable's location. 615 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 616 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false); 617 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 618 619 if (Location.isReg()) { 620 if (Reg < 32) { 621 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg); 622 } else { 623 Reg = Reg - dwarf::DW_OP_reg0; 624 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 625 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 626 } 627 } else { 628 if (Reg < 32) 629 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 630 else { 631 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 632 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 633 } 634 635 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 636 } 637 638 for (unsigned i = 0, N = DV->getNumAddrElements(); i < N; ++i) { 639 uint64_t Element = DV->getAddrElement(i); 640 641 if (Element == DIFactory::OpPlus) { 642 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 643 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i)); 644 } else if (Element == DIFactory::OpDeref) { 645 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 646 } else llvm_unreachable("unknown DIFactory Opcode"); 647 } 648 649 // Now attach the location information to the DIE. 650 addBlock(Die, Attribute, 0, Block); 651} 652 653/* Byref variables, in Blocks, are declared by the programmer as "SomeType 654 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and 655 gives the variable VarName either the struct, or a pointer to the struct, as 656 its type. This is necessary for various behind-the-scenes things the 657 compiler needs to do with by-reference variables in Blocks. 658 659 However, as far as the original *programmer* is concerned, the variable 660 should still have type 'SomeType', as originally declared. 661 662 The function getBlockByrefType dives into the __Block_byref_x_VarName 663 struct to find the original type of the variable, which is then assigned to 664 the variable's Debug Information Entry as its real type. So far, so good. 665 However now the debugger will expect the variable VarName to have the type 666 SomeType. So we need the location attribute for the variable to be an 667 expression that explains to the debugger how to navigate through the 668 pointers and struct to find the actual variable of type SomeType. 669 670 The following function does just that. We start by getting 671 the "normal" location for the variable. This will be the location 672 of either the struct __Block_byref_x_VarName or the pointer to the 673 struct __Block_byref_x_VarName. 674 675 The struct will look something like: 676 677 struct __Block_byref_x_VarName { 678 ... <various fields> 679 struct __Block_byref_x_VarName *forwarding; 680 ... <various other fields> 681 SomeType VarName; 682 ... <maybe more fields> 683 }; 684 685 If we are given the struct directly (as our starting point) we 686 need to tell the debugger to: 687 688 1). Add the offset of the forwarding field. 689 690 2). Follow that pointer to get the real __Block_byref_x_VarName 691 struct to use (the real one may have been copied onto the heap). 692 693 3). Add the offset for the field VarName, to find the actual variable. 694 695 If we started with a pointer to the struct, then we need to 696 dereference that pointer first, before the other steps. 697 Translating this into DWARF ops, we will need to append the following 698 to the current location description for the variable: 699 700 DW_OP_deref -- optional, if we start with a pointer 701 DW_OP_plus_uconst <forward_fld_offset> 702 DW_OP_deref 703 DW_OP_plus_uconst <varName_fld_offset> 704 705 That is what this function does. */ 706 707/// addBlockByrefAddress - Start with the address based on the location 708/// provided, and generate the DWARF information necessary to find the 709/// actual Block variable (navigating the Block struct) based on the 710/// starting location. Add the DWARF information to the die. For 711/// more information, read large comment just above here. 712/// 713void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die, 714 unsigned Attribute, 715 const MachineLocation &Location) { 716 DIType Ty = DV->getType(); 717 DIType TmpTy = Ty; 718 unsigned Tag = Ty.getTag(); 719 bool isPointer = false; 720 721 StringRef varName = DV->getName(); 722 723 if (Tag == dwarf::DW_TAG_pointer_type) { 724 DIDerivedType DTy = DIDerivedType(Ty); 725 TmpTy = DTy.getTypeDerivedFrom(); 726 isPointer = true; 727 } 728 729 DICompositeType blockStruct = DICompositeType(TmpTy); 730 731 // Find the __forwarding field and the variable field in the __Block_byref 732 // struct. 733 DIArray Fields = blockStruct.getTypeArray(); 734 DIDescriptor varField = DIDescriptor(); 735 DIDescriptor forwardingField = DIDescriptor(); 736 737 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) { 738 DIDescriptor Element = Fields.getElement(i); 739 DIDerivedType DT = DIDerivedType(Element); 740 StringRef fieldName = DT.getName(); 741 if (fieldName == "__forwarding") 742 forwardingField = Element; 743 else if (fieldName == varName) 744 varField = Element; 745 } 746 747 // Get the offsets for the forwarding field and the variable field. 748 unsigned forwardingFieldOffset = 749 DIDerivedType(forwardingField).getOffsetInBits() >> 3; 750 unsigned varFieldOffset = 751 DIDerivedType(varField).getOffsetInBits() >> 3; 752 753 // Decode the original location, and use that as the start of the byref 754 // variable's location. 755 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 756 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false); 757 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 758 759 if (Location.isReg()) { 760 if (Reg < 32) 761 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg); 762 else { 763 Reg = Reg - dwarf::DW_OP_reg0; 764 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 765 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 766 } 767 } else { 768 if (Reg < 32) 769 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 770 else { 771 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 772 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 773 } 774 775 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 776 } 777 778 // If we started with a pointer to the __Block_byref... struct, then 779 // the first thing we need to do is dereference the pointer (DW_OP_deref). 780 if (isPointer) 781 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 782 783 // Next add the offset for the '__forwarding' field: 784 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in 785 // adding the offset if it's 0. 786 if (forwardingFieldOffset > 0) { 787 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 788 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset); 789 } 790 791 // Now dereference the __forwarding field to get to the real __Block_byref 792 // struct: DW_OP_deref. 793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 794 795 // Now that we've got the real __Block_byref... struct, add the offset 796 // for the variable's field to get to the location of the actual variable: 797 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0. 798 if (varFieldOffset > 0) { 799 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 800 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset); 801 } 802 803 // Now attach the location information to the DIE. 804 addBlock(Die, Attribute, 0, Block); 805} 806 807/// addAddress - Add an address attribute to a die based on the location 808/// provided. 809void DwarfDebug::addAddress(DIE *Die, unsigned Attribute, 810 const MachineLocation &Location) { 811 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 812 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false); 813 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 814 815 if (Location.isReg()) { 816 if (Reg < 32) { 817 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg); 818 } else { 819 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx); 820 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 821 } 822 } else { 823 if (Reg < 32) { 824 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 825 } else { 826 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 827 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 828 } 829 830 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 831 } 832 833 addBlock(Die, Attribute, 0, Block); 834} 835 836/// addRegisterAddress - Add register location entry in variable DIE. 837bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS, 838 const MachineOperand &MO) { 839 assert (MO.isReg() && "Invalid machine operand!"); 840 if (!MO.getReg()) 841 return false; 842 MachineLocation Location; 843 Location.set(MO.getReg()); 844 addAddress(Die, dwarf::DW_AT_location, Location); 845 if (VS) 846 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS); 847 return true; 848} 849 850/// addConstantValue - Add constant value entry in variable DIE. 851bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS, 852 const MachineOperand &MO) { 853 assert (MO.isImm() && "Invalid machine operand!"); 854 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 855 unsigned Imm = MO.getImm(); 856 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm); 857 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 858 if (VS) 859 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS); 860 return true; 861} 862 863/// addConstantFPValue - Add constant value entry in variable DIE. 864bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS, 865 const MachineOperand &MO) { 866 assert (MO.isFPImm() && "Invalid machine operand!"); 867 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 868 APFloat FPImm = MO.getFPImm()->getValueAPF(); 869 870 // Get the raw data form of the floating point. 871 const APInt FltVal = FPImm.bitcastToAPInt(); 872 const char *FltPtr = (const char*)FltVal.getRawData(); 873 874 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte. 875 bool LittleEndian = Asm->getTargetData().isLittleEndian(); 876 int Incr = (LittleEndian ? 1 : -1); 877 int Start = (LittleEndian ? 0 : NumBytes - 1); 878 int Stop = (LittleEndian ? NumBytes : -1); 879 880 // Output the constant to DWARF one byte at a time. 881 for (; Start != Stop; Start += Incr) 882 addUInt(Block, 0, dwarf::DW_FORM_data1, 883 (unsigned char)0xFF & FltPtr[Start]); 884 885 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 886 if (VS) 887 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS); 888 return true; 889} 890 891 892/// addToContextOwner - Add Die into the list of its context owner's children. 893void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) { 894 if (Context.isType()) { 895 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context)); 896 ContextDIE->addChild(Die); 897 } else if (Context.isNameSpace()) { 898 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context)); 899 ContextDIE->addChild(Die); 900 } else if (Context.isSubprogram()) { 901 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context), 902 /*MakeDecl=*/false); 903 ContextDIE->addChild(Die); 904 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context)) 905 ContextDIE->addChild(Die); 906 else 907 getCompileUnit(Context)->addDie(Die); 908} 909 910/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the 911/// given DIType. 912DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) { 913 CompileUnit *TypeCU = getCompileUnit(Ty); 914 DIE *TyDIE = TypeCU->getDIE(Ty); 915 if (TyDIE) 916 return TyDIE; 917 918 // Create new type. 919 TyDIE = new DIE(dwarf::DW_TAG_base_type); 920 TypeCU->insertDIE(Ty, TyDIE); 921 if (Ty.isBasicType()) 922 constructTypeDIE(*TyDIE, DIBasicType(Ty)); 923 else if (Ty.isCompositeType()) 924 constructTypeDIE(*TyDIE, DICompositeType(Ty)); 925 else { 926 assert(Ty.isDerivedType() && "Unknown kind of DIType"); 927 constructTypeDIE(*TyDIE, DIDerivedType(Ty)); 928 } 929 930 addToContextOwner(TyDIE, Ty.getContext()); 931 return TyDIE; 932} 933 934/// addType - Add a new type attribute to the specified entity. 935void DwarfDebug::addType(DIE *Entity, DIType Ty) { 936 if (!Ty.Verify()) 937 return; 938 939 // Check for pre-existence. 940 CompileUnit *TypeCU = getCompileUnit(Ty); 941 DIEEntry *Entry = TypeCU->getDIEEntry(Ty); 942 // If it exists then use the existing value. 943 if (Entry) { 944 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry); 945 return; 946 } 947 948 // Construct type. 949 DIE *Buffer = getOrCreateTypeDIE(Ty); 950 951 // Set up proxy. 952 Entry = createDIEEntry(Buffer); 953 TypeCU->insertDIEEntry(Ty, Entry); 954 955 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry); 956} 957 958/// constructTypeDIE - Construct basic type die from DIBasicType. 959void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) { 960 // Get core information. 961 StringRef Name = BTy.getName(); 962 Buffer.setTag(dwarf::DW_TAG_base_type); 963 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 964 BTy.getEncoding()); 965 966 // Add name if not anonymous or intermediate type. 967 if (!Name.empty()) 968 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 969 uint64_t Size = BTy.getSizeInBits() >> 3; 970 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 971} 972 973/// constructTypeDIE - Construct derived type die from DIDerivedType. 974void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) { 975 // Get core information. 976 StringRef Name = DTy.getName(); 977 uint64_t Size = DTy.getSizeInBits() >> 3; 978 unsigned Tag = DTy.getTag(); 979 980 // FIXME - Workaround for templates. 981 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type; 982 983 Buffer.setTag(Tag); 984 985 // Map to main type, void will not have a type. 986 DIType FromTy = DTy.getTypeDerivedFrom(); 987 addType(&Buffer, FromTy); 988 989 // Add name if not anonymous or intermediate type. 990 if (!Name.empty()) 991 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 992 993 // Add size if non-zero (derived types might be zero-sized.) 994 if (Size) 995 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 996 997 // Add source line info if available and TyDesc is not a forward declaration. 998 if (!DTy.isForwardDecl()) 999 addSourceLine(&Buffer, DTy); 1000} 1001 1002/// constructTypeDIE - Construct type DIE from DICompositeType. 1003void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) { 1004 // Get core information. 1005 StringRef Name = CTy.getName(); 1006 1007 uint64_t Size = CTy.getSizeInBits() >> 3; 1008 unsigned Tag = CTy.getTag(); 1009 Buffer.setTag(Tag); 1010 1011 switch (Tag) { 1012 case dwarf::DW_TAG_vector_type: 1013 case dwarf::DW_TAG_array_type: 1014 constructArrayTypeDIE(Buffer, &CTy); 1015 break; 1016 case dwarf::DW_TAG_enumeration_type: { 1017 DIArray Elements = CTy.getTypeArray(); 1018 1019 // Add enumerators to enumeration type. 1020 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1021 DIE *ElemDie = NULL; 1022 DIDescriptor Enum(Elements.getElement(i)); 1023 if (Enum.isEnumerator()) { 1024 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum)); 1025 Buffer.addChild(ElemDie); 1026 } 1027 } 1028 } 1029 break; 1030 case dwarf::DW_TAG_subroutine_type: { 1031 // Add return type. 1032 DIArray Elements = CTy.getTypeArray(); 1033 DIDescriptor RTy = Elements.getElement(0); 1034 addType(&Buffer, DIType(RTy)); 1035 1036 // Add prototype flag. 1037 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1); 1038 1039 // Add arguments. 1040 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) { 1041 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1042 DIDescriptor Ty = Elements.getElement(i); 1043 addType(Arg, DIType(Ty)); 1044 Buffer.addChild(Arg); 1045 } 1046 } 1047 break; 1048 case dwarf::DW_TAG_structure_type: 1049 case dwarf::DW_TAG_union_type: 1050 case dwarf::DW_TAG_class_type: { 1051 // Add elements to structure type. 1052 DIArray Elements = CTy.getTypeArray(); 1053 1054 // A forward struct declared type may not have elements available. 1055 unsigned N = Elements.getNumElements(); 1056 if (N == 0) 1057 break; 1058 1059 // Add elements to structure type. 1060 for (unsigned i = 0; i < N; ++i) { 1061 DIDescriptor Element = Elements.getElement(i); 1062 DIE *ElemDie = NULL; 1063 if (Element.isSubprogram()) 1064 ElemDie = createSubprogramDIE(DISubprogram(Element)); 1065 else if (Element.isVariable()) { 1066 DIVariable DV(Element); 1067 ElemDie = new DIE(dwarf::DW_TAG_variable); 1068 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, 1069 DV.getName()); 1070 addType(ElemDie, DV.getType()); 1071 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1072 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1073 addSourceLine(ElemDie, DV); 1074 } else if (Element.isDerivedType()) 1075 ElemDie = createMemberDIE(DIDerivedType(Element)); 1076 else 1077 continue; 1078 Buffer.addChild(ElemDie); 1079 } 1080 1081 if (CTy.isAppleBlockExtension()) 1082 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1); 1083 1084 unsigned RLang = CTy.getRunTimeLang(); 1085 if (RLang) 1086 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, 1087 dwarf::DW_FORM_data1, RLang); 1088 1089 DICompositeType ContainingType = CTy.getContainingType(); 1090 if (DIDescriptor(ContainingType).isCompositeType()) 1091 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 1092 getOrCreateTypeDIE(DIType(ContainingType))); 1093 else { 1094 DIDescriptor Context = CTy.getContext(); 1095 addToContextOwner(&Buffer, Context); 1096 } 1097 break; 1098 } 1099 default: 1100 break; 1101 } 1102 1103 // Add name if not anonymous or intermediate type. 1104 if (!Name.empty()) 1105 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1106 1107 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type 1108 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) 1109 { 1110 // Add size if non-zero (derived types might be zero-sized.) 1111 if (Size) 1112 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 1113 else { 1114 // Add zero size if it is not a forward declaration. 1115 if (CTy.isForwardDecl()) 1116 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1117 else 1118 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0); 1119 } 1120 1121 // Add source line info if available. 1122 if (!CTy.isForwardDecl()) 1123 addSourceLine(&Buffer, CTy); 1124 } 1125} 1126 1127/// constructSubrangeDIE - Construct subrange DIE from DISubrange. 1128void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){ 1129 int64_t L = SR.getLo(); 1130 int64_t H = SR.getHi(); 1131 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type); 1132 1133 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy); 1134 if (L) 1135 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L); 1136 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H); 1137 1138 Buffer.addChild(DW_Subrange); 1139} 1140 1141/// constructArrayTypeDIE - Construct array type DIE from DICompositeType. 1142void DwarfDebug::constructArrayTypeDIE(DIE &Buffer, 1143 DICompositeType *CTy) { 1144 Buffer.setTag(dwarf::DW_TAG_array_type); 1145 if (CTy->getTag() == dwarf::DW_TAG_vector_type) 1146 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1); 1147 1148 // Emit derived type. 1149 addType(&Buffer, CTy->getTypeDerivedFrom()); 1150 DIArray Elements = CTy->getTypeArray(); 1151 1152 // Get an anonymous type for index type. 1153 CompileUnit *TheCU = getCompileUnit(*CTy); 1154 DIE *IdxTy = TheCU->getIndexTyDie(); 1155 if (!IdxTy) { 1156 // Construct an anonymous type for index type. 1157 IdxTy = new DIE(dwarf::DW_TAG_base_type); 1158 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t)); 1159 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 1160 dwarf::DW_ATE_signed); 1161 TheCU->addDie(IdxTy); 1162 TheCU->setIndexTyDie(IdxTy); 1163 } 1164 1165 // Add subranges to array type. 1166 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1167 DIDescriptor Element = Elements.getElement(i); 1168 if (Element.getTag() == dwarf::DW_TAG_subrange_type) 1169 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy); 1170 } 1171} 1172 1173/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator. 1174DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) { 1175 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator); 1176 StringRef Name = ETy.getName(); 1177 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1178 int64_t Value = ETy.getEnumValue(); 1179 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value); 1180 return Enumerator; 1181} 1182 1183/// getRealLinkageName - If special LLVM prefix that is used to inform the asm 1184/// printer to not emit usual symbol prefix before the symbol name is used then 1185/// return linkage name after skipping this special LLVM prefix. 1186static StringRef getRealLinkageName(StringRef LinkageName) { 1187 char One = '\1'; 1188 if (LinkageName.startswith(StringRef(&One, 1))) 1189 return LinkageName.substr(1); 1190 return LinkageName; 1191} 1192 1193/// createMemberDIE - Create new member DIE. 1194DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) { 1195 DIE *MemberDie = new DIE(DT.getTag()); 1196 StringRef Name = DT.getName(); 1197 if (!Name.empty()) 1198 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1199 1200 addType(MemberDie, DT.getTypeDerivedFrom()); 1201 1202 addSourceLine(MemberDie, DT); 1203 1204 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock(); 1205 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 1206 1207 uint64_t Size = DT.getSizeInBits(); 1208 uint64_t FieldSize = DT.getOriginalTypeSize(); 1209 1210 if (Size != FieldSize) { 1211 // Handle bitfield. 1212 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3); 1213 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits()); 1214 1215 uint64_t Offset = DT.getOffsetInBits(); 1216 uint64_t AlignMask = ~(DT.getAlignInBits() - 1); 1217 uint64_t HiMark = (Offset + FieldSize) & AlignMask; 1218 uint64_t FieldOffset = (HiMark - FieldSize); 1219 Offset -= FieldOffset; 1220 1221 // Maybe we need to work from the other end. 1222 if (Asm->getTargetData().isLittleEndian()) 1223 Offset = FieldSize - (Offset + Size); 1224 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset); 1225 1226 // Here WD_AT_data_member_location points to the anonymous 1227 // field that includes this bit field. 1228 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3); 1229 1230 } else 1231 // This is not a bitfield. 1232 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3); 1233 1234 if (DT.getTag() == dwarf::DW_TAG_inheritance 1235 && DT.isVirtual()) { 1236 1237 // For C++, virtual base classes are not at fixed offset. Use following 1238 // expression to extract appropriate offset from vtable. 1239 // BaseAddr = ObAddr + *((*ObAddr) - Offset) 1240 1241 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock(); 1242 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup); 1243 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1244 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1245 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits()); 1246 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus); 1247 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1248 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1249 1250 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, 1251 VBaseLocationDie); 1252 } else 1253 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie); 1254 1255 if (DT.isProtected()) 1256 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1257 dwarf::DW_ACCESS_protected); 1258 else if (DT.isPrivate()) 1259 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1260 dwarf::DW_ACCESS_private); 1261 else if (DT.getTag() == dwarf::DW_TAG_inheritance) 1262 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1263 dwarf::DW_ACCESS_public); 1264 if (DT.isVirtual()) 1265 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, 1266 dwarf::DW_VIRTUALITY_virtual); 1267 return MemberDie; 1268} 1269 1270/// createSubprogramDIE - Create new DIE using SP. 1271DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP, bool MakeDecl) { 1272 CompileUnit *SPCU = getCompileUnit(SP); 1273 DIE *SPDie = SPCU->getDIE(SP); 1274 if (SPDie) 1275 return SPDie; 1276 1277 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1278 // Constructors and operators for anonymous aggregates do not have names. 1279 if (!SP.getName().empty()) 1280 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName()); 1281 1282 StringRef LinkageName = SP.getLinkageName(); 1283 if (!LinkageName.empty()) 1284 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string, 1285 getRealLinkageName(LinkageName)); 1286 1287 addSourceLine(SPDie, SP); 1288 1289 // Add prototyped tag, if C or ObjC. 1290 unsigned Lang = SP.getCompileUnit().getLanguage(); 1291 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 || 1292 Lang == dwarf::DW_LANG_ObjC) 1293 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1); 1294 1295 // Add Return Type. 1296 DICompositeType SPTy = SP.getType(); 1297 DIArray Args = SPTy.getTypeArray(); 1298 unsigned SPTag = SPTy.getTag(); 1299 1300 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type) 1301 addType(SPDie, SPTy); 1302 else 1303 addType(SPDie, DIType(Args.getElement(0))); 1304 1305 unsigned VK = SP.getVirtuality(); 1306 if (VK) { 1307 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK); 1308 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1309 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1310 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex()); 1311 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block); 1312 ContainingTypeMap.insert(std::make_pair(SPDie, 1313 SP.getContainingType())); 1314 } 1315 1316 if (MakeDecl || !SP.isDefinition()) { 1317 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1318 1319 // Add arguments. Do not add arguments for subprogram definition. They will 1320 // be handled while processing variables. 1321 DICompositeType SPTy = SP.getType(); 1322 DIArray Args = SPTy.getTypeArray(); 1323 unsigned SPTag = SPTy.getTag(); 1324 1325 if (SPTag == dwarf::DW_TAG_subroutine_type) 1326 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1327 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1328 DIType ATy = DIType(DIType(Args.getElement(i))); 1329 addType(Arg, ATy); 1330 if (ATy.isArtificial()) 1331 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1332 SPDie->addChild(Arg); 1333 } 1334 } 1335 1336 if (SP.isArtificial()) 1337 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1338 1339 if (!SP.isLocalToUnit()) 1340 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1341 1342 if (SP.isOptimized()) 1343 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 1344 1345 if (unsigned isa = Asm->getISAEncoding()) { 1346 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa); 1347 } 1348 1349 // DW_TAG_inlined_subroutine may refer to this DIE. 1350 SPCU->insertDIE(SP, SPDie); 1351 1352 // Add to context owner. 1353 addToContextOwner(SPDie, SP.getContext()); 1354 1355 return SPDie; 1356} 1357 1358DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) { 1359 assert(N && "Invalid Scope encoding!"); 1360 1361 DbgScope *AScope = AbstractScopes.lookup(N); 1362 if (AScope) 1363 return AScope; 1364 1365 DbgScope *Parent = NULL; 1366 1367 DIDescriptor Scope(N); 1368 if (Scope.isLexicalBlock()) { 1369 DILexicalBlock DB(N); 1370 DIDescriptor ParentDesc = DB.getContext(); 1371 Parent = getOrCreateAbstractScope(ParentDesc); 1372 } 1373 1374 AScope = new DbgScope(Parent, DIDescriptor(N), NULL); 1375 1376 if (Parent) 1377 Parent->addScope(AScope); 1378 AScope->setAbstractScope(); 1379 AbstractScopes[N] = AScope; 1380 if (DIDescriptor(N).isSubprogram()) 1381 AbstractScopesList.push_back(AScope); 1382 return AScope; 1383} 1384 1385/// isSubprogramContext - Return true if Context is either a subprogram 1386/// or another context nested inside a subprogram. 1387static bool isSubprogramContext(const MDNode *Context) { 1388 if (!Context) 1389 return false; 1390 DIDescriptor D(Context); 1391 if (D.isSubprogram()) 1392 return true; 1393 if (D.isType()) 1394 return isSubprogramContext(DIType(Context).getContext()); 1395 return false; 1396} 1397 1398/// updateSubprogramScopeDIE - Find DIE for the given subprogram and 1399/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes. 1400/// If there are global variables in this scope then create and insert 1401/// DIEs for these variables. 1402DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) { 1403 CompileUnit *SPCU = getCompileUnit(SPNode); 1404 DIE *SPDie = SPCU->getDIE(SPNode); 1405 1406 assert(SPDie && "Unable to find subprogram DIE!"); 1407 DISubprogram SP(SPNode); 1408 1409 // There is not any need to generate specification DIE for a function 1410 // defined at compile unit level. If a function is defined inside another 1411 // function then gdb prefers the definition at top level and but does not 1412 // expect specification DIE in parent function. So avoid creating 1413 // specification DIE for a function defined inside a function. 1414 if (SP.isDefinition() && !SP.getContext().isCompileUnit() && 1415 !SP.getContext().isFile() && 1416 !isSubprogramContext(SP.getContext())) { 1417 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1418 1419 // Add arguments. 1420 DICompositeType SPTy = SP.getType(); 1421 DIArray Args = SPTy.getTypeArray(); 1422 unsigned SPTag = SPTy.getTag(); 1423 if (SPTag == dwarf::DW_TAG_subroutine_type) 1424 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1425 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1426 DIType ATy = DIType(DIType(Args.getElement(i))); 1427 addType(Arg, ATy); 1428 if (ATy.isArtificial()) 1429 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1430 SPDie->addChild(Arg); 1431 } 1432 DIE *SPDeclDie = SPDie; 1433 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1434 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4, 1435 SPDeclDie); 1436 SPCU->addDie(SPDie); 1437 } 1438 1439 // Pick up abstract subprogram DIE. 1440 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) { 1441 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1442 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, 1443 dwarf::DW_FORM_ref4, AbsSPDIE); 1444 SPCU->addDie(SPDie); 1445 } 1446 1447 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 1448 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber())); 1449 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, 1450 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber())); 1451 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 1452 MachineLocation Location(RI->getFrameRegister(*Asm->MF)); 1453 addAddress(SPDie, dwarf::DW_AT_frame_base, Location); 1454 1455 return SPDie; 1456} 1457 1458/// constructLexicalScope - Construct new DW_TAG_lexical_block 1459/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels. 1460DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) { 1461 1462 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block); 1463 if (Scope->isAbstractScope()) 1464 return ScopeDIE; 1465 1466 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges(); 1467 if (Ranges.empty()) 1468 return 0; 1469 1470 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(); 1471 if (Ranges.size() > 1) { 1472 // .debug_range section has not been laid out yet. Emit offset in 1473 // .debug_range as a uint, size 4, for now. emitDIE will handle 1474 // DW_AT_ranges appropriately. 1475 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4, 1476 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize()); 1477 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 1478 RE = Ranges.end(); RI != RE; ++RI) { 1479 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first)); 1480 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second)); 1481 } 1482 DebugRangeSymbols.push_back(NULL); 1483 DebugRangeSymbols.push_back(NULL); 1484 return ScopeDIE; 1485 } 1486 1487 const MCSymbol *Start = getLabelBeforeInsn(RI->first); 1488 const MCSymbol *End = getLabelAfterInsn(RI->second); 1489 1490 if (End == 0) return 0; 1491 1492 assert(Start->isDefined() && "Invalid starting label for an inlined scope!"); 1493 assert(End->isDefined() && "Invalid end label for an inlined scope!"); 1494 1495 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start); 1496 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End); 1497 1498 return ScopeDIE; 1499} 1500 1501/// constructInlinedScopeDIE - This scope represents inlined body of 1502/// a function. Construct DIE to represent this concrete inlined copy 1503/// of the function. 1504DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) { 1505 1506 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges(); 1507 assert (Ranges.empty() == false 1508 && "DbgScope does not have instruction markers!"); 1509 1510 // FIXME : .debug_inlined section specification does not clearly state how 1511 // to emit inlined scope that is split into multiple instruction ranges. 1512 // For now, use first instruction range and emit low_pc/high_pc pair and 1513 // corresponding .debug_inlined section entry for this pair. 1514 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(); 1515 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first); 1516 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second); 1517 1518 if (StartLabel == 0 || EndLabel == 0) { 1519 assert (0 && "Unexpected Start and End labels for a inlined scope!"); 1520 return 0; 1521 } 1522 assert(StartLabel->isDefined() && 1523 "Invalid starting label for an inlined scope!"); 1524 assert(EndLabel->isDefined() && 1525 "Invalid end label for an inlined scope!"); 1526 1527 if (!Scope->getScopeNode()) 1528 return NULL; 1529 DIScope DS(Scope->getScopeNode()); 1530 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine); 1531 1532 DISubprogram InlinedSP = getDISubprogram(DS); 1533 CompileUnit *TheCU = getCompileUnit(InlinedSP); 1534 DIE *OriginDIE = TheCU->getDIE(InlinedSP); 1535 assert(OriginDIE && "Unable to find Origin DIE!"); 1536 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, 1537 dwarf::DW_FORM_ref4, OriginDIE); 1538 1539 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel); 1540 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel); 1541 1542 InlinedSubprogramDIEs.insert(OriginDIE); 1543 1544 // Track the start label for this inlined function. 1545 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator 1546 I = InlineInfo.find(InlinedSP); 1547 1548 if (I == InlineInfo.end()) { 1549 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, 1550 ScopeDIE)); 1551 InlinedSPNodes.push_back(InlinedSP); 1552 } else 1553 I->second.push_back(std::make_pair(StartLabel, ScopeDIE)); 1554 1555 DILocation DL(Scope->getInlinedAt()); 1556 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID()); 1557 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber()); 1558 1559 return ScopeDIE; 1560} 1561 1562 1563/// constructVariableDIE - Construct a DIE for the given DbgVariable. 1564DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) { 1565 StringRef Name = DV->getName(); 1566 if (Name.empty()) 1567 return NULL; 1568 1569 // Translate tag to proper Dwarf tag. The result variable is dropped for 1570 // now. 1571 unsigned Tag; 1572 switch (DV->getTag()) { 1573 case dwarf::DW_TAG_return_variable: 1574 return NULL; 1575 case dwarf::DW_TAG_arg_variable: 1576 Tag = dwarf::DW_TAG_formal_parameter; 1577 break; 1578 case dwarf::DW_TAG_auto_variable: // fall thru 1579 default: 1580 Tag = dwarf::DW_TAG_variable; 1581 break; 1582 } 1583 1584 // Define variable debug information entry. 1585 DIE *VariableDie = new DIE(Tag); 1586 1587 DIE *AbsDIE = NULL; 1588 DenseMap<const DbgVariable *, const DbgVariable *>::iterator 1589 V2AVI = VarToAbstractVarMap.find(DV); 1590 if (V2AVI != VarToAbstractVarMap.end()) 1591 AbsDIE = V2AVI->second->getDIE(); 1592 1593 if (AbsDIE) 1594 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, 1595 dwarf::DW_FORM_ref4, AbsDIE); 1596 else { 1597 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1598 addSourceLine(VariableDie, DV->getVariable()); 1599 1600 // Add variable type. 1601 addType(VariableDie, DV->getType()); 1602 } 1603 1604 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial()) 1605 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1606 1607 if (Scope->isAbstractScope()) { 1608 DV->setDIE(VariableDie); 1609 return VariableDie; 1610 } 1611 1612 // Add variable address. 1613 1614 unsigned Offset = DV->getDotDebugLocOffset(); 1615 if (Offset != ~0U) { 1616 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4, 1617 Asm->GetTempSymbol("debug_loc", Offset)); 1618 DV->setDIE(VariableDie); 1619 UseDotDebugLocEntry.insert(VariableDie); 1620 return VariableDie; 1621 } 1622 1623 // Check if variable is described by a DBG_VALUE instruction. 1624 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI = 1625 DbgVariableToDbgInstMap.find(DV); 1626 if (DVI != DbgVariableToDbgInstMap.end()) { 1627 const MachineInstr *DVInsn = DVI->second; 1628 const MCSymbol *DVLabel = findVariableLabel(DV); 1629 bool updated = false; 1630 // FIXME : Handle getNumOperands != 3 1631 if (DVInsn->getNumOperands() == 3) { 1632 if (DVInsn->getOperand(0).isReg()) { 1633 const MachineOperand RegOp = DVInsn->getOperand(0); 1634 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 1635 if (DVInsn->getOperand(1).isImm() && 1636 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) { 1637 addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm()); 1638 updated = true; 1639 } else 1640 updated = addRegisterAddress(VariableDie, DVLabel, RegOp); 1641 } 1642 else if (DVInsn->getOperand(0).isImm()) 1643 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0)); 1644 else if (DVInsn->getOperand(0).isFPImm()) 1645 updated = 1646 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0)); 1647 } else { 1648 MachineLocation Location = Asm->getDebugValueLocation(DVInsn); 1649 if (Location.getReg()) { 1650 addAddress(VariableDie, dwarf::DW_AT_location, Location); 1651 if (DVLabel) 1652 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, 1653 DVLabel); 1654 updated = true; 1655 } 1656 } 1657 if (!updated) { 1658 // If variableDie is not updated then DBG_VALUE instruction does not 1659 // have valid variable info. 1660 delete VariableDie; 1661 return NULL; 1662 } 1663 DV->setDIE(VariableDie); 1664 return VariableDie; 1665 } 1666 1667 // .. else use frame index, if available. 1668 int FI = 0; 1669 if (findVariableFrameIndex(DV, &FI)) 1670 addVariableAddress(DV, VariableDie, FI); 1671 1672 DV->setDIE(VariableDie); 1673 return VariableDie; 1674 1675} 1676 1677void DwarfDebug::addPubTypes(DISubprogram SP) { 1678 DICompositeType SPTy = SP.getType(); 1679 unsigned SPTag = SPTy.getTag(); 1680 if (SPTag != dwarf::DW_TAG_subroutine_type) 1681 return; 1682 1683 DIArray Args = SPTy.getTypeArray(); 1684 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) { 1685 DIType ATy(Args.getElement(i)); 1686 if (!ATy.Verify()) 1687 continue; 1688 DICompositeType CATy = getDICompositeType(ATy); 1689 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty() 1690 && !CATy.isForwardDecl()) { 1691 CompileUnit *TheCU = getCompileUnit(CATy); 1692 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy)) 1693 TheCU->addGlobalType(CATy.getName(), Entry->getEntry()); 1694 } 1695 } 1696} 1697 1698/// constructScopeDIE - Construct a DIE for this scope. 1699DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) { 1700 if (!Scope || !Scope->getScopeNode()) 1701 return NULL; 1702 1703 DIScope DS(Scope->getScopeNode()); 1704 DIE *ScopeDIE = NULL; 1705 if (Scope->getInlinedAt()) 1706 ScopeDIE = constructInlinedScopeDIE(Scope); 1707 else if (DS.isSubprogram()) { 1708 ProcessedSPNodes.insert(DS); 1709 if (Scope->isAbstractScope()) { 1710 ScopeDIE = getCompileUnit(DS)->getDIE(DS); 1711 // Note down abstract DIE. 1712 if (ScopeDIE) 1713 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE)); 1714 } 1715 else 1716 ScopeDIE = updateSubprogramScopeDIE(DS); 1717 } 1718 else 1719 ScopeDIE = constructLexicalScopeDIE(Scope); 1720 if (!ScopeDIE) return NULL; 1721 1722 // Add variables to scope. 1723 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables(); 1724 for (unsigned i = 0, N = Variables.size(); i < N; ++i) { 1725 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope); 1726 if (VariableDIE) 1727 ScopeDIE->addChild(VariableDIE); 1728 } 1729 1730 // Add nested scopes. 1731 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes(); 1732 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) { 1733 // Define the Scope debug information entry. 1734 DIE *NestedDIE = constructScopeDIE(Scopes[j]); 1735 if (NestedDIE) 1736 ScopeDIE->addChild(NestedDIE); 1737 } 1738 1739 if (DS.isSubprogram()) 1740 addPubTypes(DISubprogram(DS)); 1741 1742 return ScopeDIE; 1743} 1744 1745/// GetOrCreateSourceID - Look up the source id with the given directory and 1746/// source file names. If none currently exists, create a new id and insert it 1747/// in the SourceIds map. This can update DirectoryNames and SourceFileNames 1748/// maps as well. 1749unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){ 1750 unsigned DId; 1751 assert (DirName.empty() == false && "Invalid directory name!"); 1752 1753 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName); 1754 if (DI != DirectoryIdMap.end()) { 1755 DId = DI->getValue(); 1756 } else { 1757 DId = DirectoryNames.size() + 1; 1758 DirectoryIdMap[DirName] = DId; 1759 DirectoryNames.push_back(DirName); 1760 } 1761 1762 unsigned FId; 1763 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName); 1764 if (FI != SourceFileIdMap.end()) { 1765 FId = FI->getValue(); 1766 } else { 1767 FId = SourceFileNames.size() + 1; 1768 SourceFileIdMap[FileName] = FId; 1769 SourceFileNames.push_back(FileName); 1770 } 1771 1772 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI = 1773 SourceIdMap.find(std::make_pair(DId, FId)); 1774 if (SI != SourceIdMap.end()) 1775 return SI->second; 1776 1777 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0. 1778 SourceIdMap[std::make_pair(DId, FId)] = SrcId; 1779 SourceIds.push_back(std::make_pair(DId, FId)); 1780 1781 return SrcId; 1782} 1783 1784/// getOrCreateNameSpace - Create a DIE for DINameSpace. 1785DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) { 1786 CompileUnit *TheCU = getCompileUnit(NS); 1787 DIE *NDie = TheCU->getDIE(NS); 1788 if (NDie) 1789 return NDie; 1790 NDie = new DIE(dwarf::DW_TAG_namespace); 1791 TheCU->insertDIE(NS, NDie); 1792 if (!NS.getName().empty()) 1793 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName()); 1794 addSourceLine(NDie, NS); 1795 addToContextOwner(NDie, NS.getContext()); 1796 return NDie; 1797} 1798 1799/// constructCompileUnit - Create new CompileUnit for the given 1800/// metadata node with tag DW_TAG_compile_unit. 1801void DwarfDebug::constructCompileUnit(const MDNode *N) { 1802 DICompileUnit DIUnit(N); 1803 StringRef FN = DIUnit.getFilename(); 1804 StringRef Dir = DIUnit.getDirectory(); 1805 unsigned ID = GetOrCreateSourceID(Dir, FN); 1806 1807 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 1808 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string, 1809 DIUnit.getProducer()); 1810 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1, 1811 DIUnit.getLanguage()); 1812 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN); 1813 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This 1814 // simplifies debug range entries. 1815 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0); 1816 // DW_AT_stmt_list is a offset of line number information for this 1817 // compile unit in debug_line section. 1818 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0); 1819 1820 if (!Dir.empty()) 1821 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir); 1822 if (DIUnit.isOptimized()) 1823 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 1824 1825 StringRef Flags = DIUnit.getFlags(); 1826 if (!Flags.empty()) 1827 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags); 1828 1829 unsigned RVer = DIUnit.getRunTimeVersion(); 1830 if (RVer) 1831 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers, 1832 dwarf::DW_FORM_data1, RVer); 1833 1834 CompileUnit *NewCU = new CompileUnit(ID, Die); 1835 if (!FirstCU) 1836 FirstCU = NewCU; 1837 CUMap.insert(std::make_pair(N, NewCU)); 1838} 1839 1840/// getCompielUnit - Get CompileUnit DIE. 1841CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const { 1842 assert (N && "Invalid DwarfDebug::getCompileUnit argument!"); 1843 DIDescriptor D(N); 1844 const MDNode *CUNode = NULL; 1845 if (D.isCompileUnit()) 1846 CUNode = N; 1847 else if (D.isSubprogram()) 1848 CUNode = DISubprogram(N).getCompileUnit(); 1849 else if (D.isType()) 1850 CUNode = DIType(N).getCompileUnit(); 1851 else if (D.isGlobalVariable()) 1852 CUNode = DIGlobalVariable(N).getCompileUnit(); 1853 else if (D.isVariable()) 1854 CUNode = DIVariable(N).getCompileUnit(); 1855 else if (D.isNameSpace()) 1856 CUNode = DINameSpace(N).getCompileUnit(); 1857 else if (D.isFile()) 1858 CUNode = DIFile(N).getCompileUnit(); 1859 else 1860 return FirstCU; 1861 1862 DenseMap<const MDNode *, CompileUnit *>::const_iterator I 1863 = CUMap.find(CUNode); 1864 if (I == CUMap.end()) 1865 return FirstCU; 1866 return I->second; 1867} 1868 1869/// isUnsignedDIType - Return true if type encoding is unsigned. 1870static bool isUnsignedDIType(DIType Ty) { 1871 DIDerivedType DTy(Ty); 1872 if (DTy.Verify()) 1873 return isUnsignedDIType(DTy.getTypeDerivedFrom()); 1874 1875 DIBasicType BTy(Ty); 1876 if (BTy.Verify()) { 1877 unsigned Encoding = BTy.getEncoding(); 1878 if (Encoding == dwarf::DW_ATE_unsigned || 1879 Encoding == dwarf::DW_ATE_unsigned_char) 1880 return true; 1881 } 1882 return false; 1883} 1884 1885/// constructGlobalVariableDIE - Construct global variable DIE. 1886void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) { 1887 DIGlobalVariable GV(N); 1888 1889 // If debug information is malformed then ignore it. 1890 if (GV.Verify() == false) 1891 return; 1892 1893 // Check for pre-existence. 1894 CompileUnit *TheCU = getCompileUnit(N); 1895 if (TheCU->getDIE(GV)) 1896 return; 1897 1898 DIType GTy = GV.getType(); 1899 DIE *VariableDIE = new DIE(GV.getTag()); 1900 1901 bool isGlobalVariable = GV.getGlobal() != NULL; 1902 1903 // Add name. 1904 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, 1905 GV.getDisplayName()); 1906 StringRef LinkageName = GV.getLinkageName(); 1907 if (!LinkageName.empty() && isGlobalVariable) 1908 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string, 1909 getRealLinkageName(LinkageName)); 1910 // Add type. 1911 addType(VariableDIE, GTy); 1912 if (GTy.isCompositeType() && !GTy.getName().empty() 1913 && !GTy.isForwardDecl()) { 1914 DIEEntry *Entry = TheCU->getDIEEntry(GTy); 1915 assert(Entry && "Missing global type!"); 1916 TheCU->addGlobalType(GTy.getName(), Entry->getEntry()); 1917 } 1918 // Add scoping info. 1919 if (!GV.isLocalToUnit()) { 1920 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1921 // Expose as global. 1922 TheCU->addGlobal(GV.getName(), VariableDIE); 1923 } 1924 // Add line number info. 1925 addSourceLine(VariableDIE, GV); 1926 // Add to map. 1927 TheCU->insertDIE(N, VariableDIE); 1928 // Add to context owner. 1929 DIDescriptor GVContext = GV.getContext(); 1930 addToContextOwner(VariableDIE, GVContext); 1931 // Add location. 1932 if (isGlobalVariable) { 1933 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1934 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 1935 addLabel(Block, 0, dwarf::DW_FORM_udata, 1936 Asm->Mang->getSymbol(GV.getGlobal())); 1937 // Do not create specification DIE if context is either compile unit 1938 // or a subprogram. 1939 if (GV.isDefinition() && !GVContext.isCompileUnit() && 1940 !GVContext.isFile() && !isSubprogramContext(GVContext)) { 1941 // Create specification DIE. 1942 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable); 1943 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, 1944 dwarf::DW_FORM_ref4, VariableDIE); 1945 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block); 1946 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1947 TheCU->addDie(VariableSpecDIE); 1948 } else { 1949 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block); 1950 } 1951 } else if (Constant *C = GV.getConstant()) { 1952 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) { 1953 if (isUnsignedDIType(GTy)) 1954 addUInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata, 1955 CI->getZExtValue()); 1956 else 1957 addSInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, 1958 CI->getSExtValue()); 1959 } 1960 } 1961 return; 1962} 1963 1964/// construct SubprogramDIE - Construct subprogram DIE. 1965void DwarfDebug::constructSubprogramDIE(const MDNode *N) { 1966 DISubprogram SP(N); 1967 1968 // Check for pre-existence. 1969 CompileUnit *TheCU = getCompileUnit(N); 1970 if (TheCU->getDIE(N)) 1971 return; 1972 1973 if (!SP.isDefinition()) 1974 // This is a method declaration which will be handled while constructing 1975 // class type. 1976 return; 1977 1978 DIE *SubprogramDie = createSubprogramDIE(SP); 1979 1980 // Add to map. 1981 TheCU->insertDIE(N, SubprogramDie); 1982 1983 // Add to context owner. 1984 addToContextOwner(SubprogramDie, SP.getContext()); 1985 1986 // Expose as global. 1987 TheCU->addGlobal(SP.getName(), SubprogramDie); 1988 1989 return; 1990} 1991 1992/// beginModule - Emit all Dwarf sections that should come prior to the 1993/// content. Create global DIEs and emit initial debug info sections. 1994/// This is inovked by the target AsmPrinter. 1995void DwarfDebug::beginModule(Module *M) { 1996 if (DisableDebugInfoPrinting) 1997 return; 1998 1999 DebugInfoFinder DbgFinder; 2000 DbgFinder.processModule(*M); 2001 2002 bool HasDebugInfo = false; 2003 2004 // Scan all the compile-units to see if there are any marked as the main unit. 2005 // if not, we do not generate debug info. 2006 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 2007 E = DbgFinder.compile_unit_end(); I != E; ++I) { 2008 if (DICompileUnit(*I).isMain()) { 2009 HasDebugInfo = true; 2010 break; 2011 } 2012 } 2013 2014 if (!HasDebugInfo) return; 2015 2016 // Tell MMI that we have debug info. 2017 MMI->setDebugInfoAvailability(true); 2018 2019 // Emit initial sections. 2020 EmitSectionLabels(); 2021 2022 // Create all the compile unit DIEs. 2023 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 2024 E = DbgFinder.compile_unit_end(); I != E; ++I) 2025 constructCompileUnit(*I); 2026 2027 // Create DIEs for each subprogram. 2028 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(), 2029 E = DbgFinder.subprogram_end(); I != E; ++I) 2030 constructSubprogramDIE(*I); 2031 2032 // Create DIEs for each global variable. 2033 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(), 2034 E = DbgFinder.global_variable_end(); I != E; ++I) 2035 constructGlobalVariableDIE(*I); 2036 2037 //getOrCreateTypeDIE 2038 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum")) 2039 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) 2040 getOrCreateTypeDIE(DIType(NMD->getOperand(i))); 2041 2042 // Prime section data. 2043 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 2044 2045 // Print out .file directives to specify files for .loc directives. These are 2046 // printed out early so that they precede any .loc directives. 2047 if (Asm->MAI->hasDotLocAndDotFile()) { 2048 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) { 2049 // Remember source id starts at 1. 2050 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i); 2051 // FIXME: don't use sys::path for this! This should not depend on the 2052 // host. 2053 sys::Path FullPath(getSourceDirectoryName(Id.first)); 2054 bool AppendOk = 2055 FullPath.appendComponent(getSourceFileName(Id.second)); 2056 assert(AppendOk && "Could not append filename to directory!"); 2057 AppendOk = false; 2058 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str()); 2059 } 2060 } 2061} 2062 2063/// endModule - Emit all Dwarf sections that should come after the content. 2064/// 2065void DwarfDebug::endModule() { 2066 if (!FirstCU) return; 2067 const Module *M = MMI->getModule(); 2068 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap; 2069 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) { 2070 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) { 2071 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue; 2072 DISubprogram SP(AllSPs->getOperand(SI)); 2073 if (!SP.Verify()) continue; 2074 2075 // Collect info for variables that were optimized out. 2076 if (!SP.isDefinition()) continue; 2077 StringRef FName = SP.getLinkageName(); 2078 if (FName.empty()) 2079 FName = SP.getName(); 2080 NamedMDNode *NMD = 2081 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName))); 2082 if (!NMD) continue; 2083 unsigned E = NMD->getNumOperands(); 2084 if (!E) continue; 2085 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL); 2086 DeadFnScopeMap[SP] = Scope; 2087 for (unsigned I = 0; I != E; ++I) { 2088 DIVariable DV(NMD->getOperand(I)); 2089 if (!DV.Verify()) continue; 2090 Scope->addVariable(new DbgVariable(DV)); 2091 } 2092 2093 // Construct subprogram DIE and add variables DIEs. 2094 constructSubprogramDIE(SP); 2095 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP); 2096 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables(); 2097 for (unsigned i = 0, N = Variables.size(); i < N; ++i) { 2098 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope); 2099 if (VariableDIE) 2100 ScopeDIE->addChild(VariableDIE); 2101 } 2102 } 2103 } 2104 2105 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 2106 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 2107 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 2108 DIE *ISP = *AI; 2109 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 2110 } 2111 2112 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(), 2113 CE = ContainingTypeMap.end(); CI != CE; ++CI) { 2114 DIE *SPDie = CI->first; 2115 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second); 2116 if (!N) continue; 2117 DIE *NDie = getCompileUnit(N)->getDIE(N); 2118 if (!NDie) continue; 2119 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie); 2120 } 2121 2122 // Standard sections final addresses. 2123 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 2124 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end")); 2125 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 2126 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end")); 2127 2128 // End text sections. 2129 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) { 2130 Asm->OutStreamer.SwitchSection(SectionMap[i]); 2131 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i)); 2132 } 2133 2134 // Emit common frame information. 2135 emitCommonDebugFrame(); 2136 2137 // Emit function debug frame information 2138 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(), 2139 E = DebugFrames.end(); I != E; ++I) 2140 emitFunctionDebugFrame(*I); 2141 2142 // Compute DIE offsets and sizes. 2143 computeSizeAndOffsets(); 2144 2145 // Emit all the DIEs into a debug info section 2146 emitDebugInfo(); 2147 2148 // Corresponding abbreviations into a abbrev section. 2149 emitAbbreviations(); 2150 2151 // Emit source line correspondence into a debug line section. 2152 emitDebugLines(); 2153 2154 // Emit info into a debug pubnames section. 2155 emitDebugPubNames(); 2156 2157 // Emit info into a debug pubtypes section. 2158 emitDebugPubTypes(); 2159 2160 // Emit info into a debug loc section. 2161 emitDebugLoc(); 2162 2163 // Emit info into a debug aranges section. 2164 EmitDebugARanges(); 2165 2166 // Emit info into a debug ranges section. 2167 emitDebugRanges(); 2168 2169 // Emit info into a debug macinfo section. 2170 emitDebugMacInfo(); 2171 2172 // Emit inline info. 2173 emitDebugInlineInfo(); 2174 2175 // Emit info into a debug str section. 2176 emitDebugStr(); 2177 2178 // clean up. 2179 DeleteContainerSeconds(DeadFnScopeMap); 2180 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2181 E = CUMap.end(); I != E; ++I) 2182 delete I->second; 2183 FirstCU = NULL; // Reset for the next Module, if any. 2184} 2185 2186/// findAbstractVariable - Find abstract variable, if any, associated with Var. 2187DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var, 2188 DebugLoc ScopeLoc) { 2189 2190 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var); 2191 if (AbsDbgVariable) 2192 return AbsDbgVariable; 2193 2194 LLVMContext &Ctx = Var->getContext(); 2195 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx)); 2196 if (!Scope) 2197 return NULL; 2198 2199 AbsDbgVariable = new DbgVariable(Var); 2200 Scope->addVariable(AbsDbgVariable); 2201 AbstractVariables[Var] = AbsDbgVariable; 2202 return AbsDbgVariable; 2203} 2204 2205/// collectVariableInfoFromMMITable - Collect variable information from 2206/// side table maintained by MMI. 2207void 2208DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF, 2209 SmallPtrSet<const MDNode *, 16> &Processed) { 2210 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2211 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 2212 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 2213 VE = VMap.end(); VI != VE; ++VI) { 2214 const MDNode *Var = VI->first; 2215 if (!Var) continue; 2216 Processed.insert(Var); 2217 DIVariable DV(Var); 2218 const std::pair<unsigned, DebugLoc> &VP = VI->second; 2219 2220 DbgScope *Scope = 0; 2221 if (const MDNode *IA = VP.second.getInlinedAt(Ctx)) 2222 Scope = ConcreteScopes.lookup(IA); 2223 if (Scope == 0) 2224 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx)); 2225 2226 // If variable scope is not found then skip this variable. 2227 if (Scope == 0) 2228 continue; 2229 2230 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second); 2231 DbgVariable *RegVar = new DbgVariable(DV); 2232 recordVariableFrameIndex(RegVar, VP.first); 2233 Scope->addVariable(RegVar); 2234 if (AbsDbgVariable) { 2235 recordVariableFrameIndex(AbsDbgVariable, VP.first); 2236 VarToAbstractVarMap[RegVar] = AbsDbgVariable; 2237 } 2238 } 2239} 2240 2241/// isDbgValueInUndefinedReg - Return true if debug value, encoded by 2242/// DBG_VALUE instruction, is in undefined reg. 2243static bool isDbgValueInUndefinedReg(const MachineInstr *MI) { 2244 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 2245 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg()) 2246 return true; 2247 return false; 2248} 2249 2250/// isDbgValueInDefinedReg - Return true if debug value, encoded by 2251/// DBG_VALUE instruction, is in a defined reg. 2252static bool isDbgValueInDefinedReg(const MachineInstr *MI) { 2253 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 2254 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg()) 2255 return true; 2256 return false; 2257} 2258 2259/// collectVariableInfo - Populate DbgScope entries with variables' info. 2260void 2261DwarfDebug::collectVariableInfo(const MachineFunction *MF, 2262 SmallPtrSet<const MDNode *, 16> &Processed) { 2263 2264 /// collection info from MMI table. 2265 collectVariableInfoFromMMITable(MF, Processed); 2266 2267 SmallVector<const MachineInstr *, 8> DbgValues; 2268 // Collect variable information from DBG_VALUE machine instructions; 2269 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 2270 I != E; ++I) 2271 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2272 II != IE; ++II) { 2273 const MachineInstr *MInsn = II; 2274 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn)) 2275 continue; 2276 DbgValues.push_back(MInsn); 2277 } 2278 2279 // This is a collection of DBV_VALUE instructions describing same variable. 2280 SmallVector<const MachineInstr *, 4> MultipleValues; 2281 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(), 2282 E = DbgValues.end(); I != E; ++I) { 2283 const MachineInstr *MInsn = *I; 2284 MultipleValues.clear(); 2285 if (isDbgValueInDefinedReg(MInsn)) 2286 MultipleValues.push_back(MInsn); 2287 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata()); 2288 if (Processed.count(DV) != 0) 2289 continue; 2290 2291 const MachineInstr *PrevMI = MInsn; 2292 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1, 2293 ME = DbgValues.end(); MI != ME; ++MI) { 2294 const MDNode *Var = 2295 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata(); 2296 if (Var == DV && isDbgValueInDefinedReg(*MI) && 2297 !PrevMI->isIdenticalTo(*MI)) 2298 MultipleValues.push_back(*MI); 2299 PrevMI = *MI; 2300 } 2301 2302 DbgScope *Scope = findDbgScope(MInsn); 2303 bool CurFnArg = false; 2304 if (DV.getTag() == dwarf::DW_TAG_arg_variable && 2305 DISubprogram(DV.getContext()).describes(MF->getFunction())) 2306 CurFnArg = true; 2307 if (!Scope && CurFnArg) 2308 Scope = CurrentFnDbgScope; 2309 // If variable scope is not found then skip this variable. 2310 if (!Scope) 2311 continue; 2312 2313 Processed.insert(DV); 2314 DbgVariable *RegVar = new DbgVariable(DV); 2315 Scope->addVariable(RegVar); 2316 if (!CurFnArg) 2317 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn); 2318 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) { 2319 DbgVariableToDbgInstMap[AbsVar] = MInsn; 2320 VarToAbstractVarMap[RegVar] = AbsVar; 2321 } 2322 if (MultipleValues.size() <= 1) { 2323 DbgVariableToDbgInstMap[RegVar] = MInsn; 2324 continue; 2325 } 2326 2327 // handle multiple DBG_VALUE instructions describing one variable. 2328 if (DotDebugLocEntries.empty()) 2329 RegVar->setDotDebugLocOffset(0); 2330 else 2331 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size()); 2332 const MachineInstr *Begin = NULL; 2333 const MachineInstr *End = NULL; 2334 for (SmallVector<const MachineInstr *, 4>::iterator 2335 MVI = MultipleValues.begin(), MVE = MultipleValues.end(); 2336 MVI != MVE; ++MVI) { 2337 if (!Begin) { 2338 Begin = *MVI; 2339 continue; 2340 } 2341 End = *MVI; 2342 MachineLocation MLoc; 2343 if (Begin->getNumOperands() == 3) { 2344 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm()) 2345 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm()); 2346 } else 2347 MLoc = Asm->getDebugValueLocation(Begin); 2348 2349 const MCSymbol *FLabel = getLabelBeforeInsn(Begin); 2350 const MCSymbol *SLabel = getLabelBeforeInsn(End); 2351 if (MLoc.getReg()) 2352 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc)); 2353 2354 Begin = End; 2355 if (MVI + 1 == MVE) { 2356 // If End is the last instruction then its value is valid 2357 // until the end of the funtion. 2358 MachineLocation EMLoc; 2359 if (End->getNumOperands() == 3) { 2360 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm()) 2361 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm()); 2362 } else 2363 EMLoc = Asm->getDebugValueLocation(End); 2364 if (EMLoc.getReg()) 2365 DotDebugLocEntries. 2366 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc)); 2367 } 2368 } 2369 DotDebugLocEntries.push_back(DotDebugLocEntry()); 2370 } 2371 2372 // Collect info for variables that were optimized out. 2373 const Function *F = MF->getFunction(); 2374 const Module *M = F->getParent(); 2375 if (NamedMDNode *NMD = 2376 M->getNamedMetadata(Twine("llvm.dbg.lv.", 2377 getRealLinkageName(F->getName())))) { 2378 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2379 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 2380 if (!DV || !Processed.insert(DV)) 2381 continue; 2382 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext()); 2383 if (Scope) 2384 Scope->addVariable(new DbgVariable(DV)); 2385 } 2386 } 2387} 2388 2389/// getLabelBeforeInsn - Return Label preceding the instruction. 2390const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { 2391 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 2392 LabelsBeforeInsn.find(MI); 2393 if (I == LabelsBeforeInsn.end()) 2394 // FunctionBeginSym always preceeds all the instruction in current function. 2395 return FunctionBeginSym; 2396 return I->second; 2397} 2398 2399/// getLabelAfterInsn - Return Label immediately following the instruction. 2400const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { 2401 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 2402 LabelsAfterInsn.find(MI); 2403 if (I == LabelsAfterInsn.end()) 2404 return NULL; 2405 return I->second; 2406} 2407 2408/// beginScope - Process beginning of a scope. 2409void DwarfDebug::beginScope(const MachineInstr *MI) { 2410 if (InsnNeedsLabel.count(MI) == 0) { 2411 LabelsBeforeInsn[MI] = PrevLabel; 2412 return; 2413 } 2414 2415 // Check location. 2416 DebugLoc DL = MI->getDebugLoc(); 2417 if (!DL.isUnknown()) { 2418 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 2419 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope); 2420 PrevInstLoc = DL; 2421 LabelsBeforeInsn[MI] = PrevLabel; 2422 return; 2423 } 2424 2425 // If location is unknown then use temp label for this DBG_VALUE 2426 // instruction. 2427 if (MI->isDebugValue()) { 2428 PrevLabel = MMI->getContext().CreateTempSymbol(); 2429 Asm->OutStreamer.EmitLabel(PrevLabel); 2430 LabelsBeforeInsn[MI] = PrevLabel; 2431 return; 2432 } 2433 2434 if (UnknownLocations) { 2435 PrevLabel = recordSourceLine(0, 0, 0); 2436 LabelsBeforeInsn[MI] = PrevLabel; 2437 return; 2438 } 2439 2440 assert (0 && "Instruction is not processed!"); 2441} 2442 2443/// endScope - Process end of a scope. 2444void DwarfDebug::endScope(const MachineInstr *MI) { 2445 if (InsnsEndScopeSet.count(MI) != 0) { 2446 // Emit a label if this instruction ends a scope. 2447 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2448 Asm->OutStreamer.EmitLabel(Label); 2449 LabelsAfterInsn[MI] = Label; 2450 } 2451} 2452 2453/// getOrCreateDbgScope - Create DbgScope for the scope. 2454DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, 2455 const MDNode *InlinedAt) { 2456 if (!InlinedAt) { 2457 DbgScope *WScope = DbgScopeMap.lookup(Scope); 2458 if (WScope) 2459 return WScope; 2460 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL); 2461 DbgScopeMap.insert(std::make_pair(Scope, WScope)); 2462 if (DIDescriptor(Scope).isLexicalBlock()) { 2463 DbgScope *Parent = 2464 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL); 2465 WScope->setParent(Parent); 2466 Parent->addScope(WScope); 2467 } 2468 2469 if (!WScope->getParent()) { 2470 StringRef SPName = DISubprogram(Scope).getLinkageName(); 2471 // We used to check only for a linkage name, but that fails 2472 // since we began omitting the linkage name for private 2473 // functions. The new way is to check for the name in metadata, 2474 // but that's not supported in old .ll test cases. Ergo, we 2475 // check both. 2476 if (SPName == Asm->MF->getFunction()->getName() || 2477 DISubprogram(Scope).getFunction() == Asm->MF->getFunction()) 2478 CurrentFnDbgScope = WScope; 2479 } 2480 2481 return WScope; 2482 } 2483 2484 getOrCreateAbstractScope(Scope); 2485 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt); 2486 if (WScope) 2487 return WScope; 2488 2489 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt); 2490 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope)); 2491 DILocation DL(InlinedAt); 2492 DbgScope *Parent = 2493 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation()); 2494 WScope->setParent(Parent); 2495 Parent->addScope(WScope); 2496 2497 ConcreteScopes[InlinedAt] = WScope; 2498 2499 return WScope; 2500} 2501 2502/// hasValidLocation - Return true if debug location entry attached with 2503/// machine instruction encodes valid location info. 2504static bool hasValidLocation(LLVMContext &Ctx, 2505 const MachineInstr *MInsn, 2506 const MDNode *&Scope, const MDNode *&InlinedAt) { 2507 DebugLoc DL = MInsn->getDebugLoc(); 2508 if (DL.isUnknown()) return false; 2509 2510 const MDNode *S = DL.getScope(Ctx); 2511 2512 // There is no need to create another DIE for compile unit. For all 2513 // other scopes, create one DbgScope now. This will be translated 2514 // into a scope DIE at the end. 2515 if (DIScope(S).isCompileUnit()) return false; 2516 2517 Scope = S; 2518 InlinedAt = DL.getInlinedAt(Ctx); 2519 return true; 2520} 2521 2522/// calculateDominanceGraph - Calculate dominance graph for DbgScope 2523/// hierarchy. 2524static void calculateDominanceGraph(DbgScope *Scope) { 2525 assert (Scope && "Unable to calculate scop edominance graph!"); 2526 SmallVector<DbgScope *, 4> WorkStack; 2527 WorkStack.push_back(Scope); 2528 unsigned Counter = 0; 2529 while (!WorkStack.empty()) { 2530 DbgScope *WS = WorkStack.back(); 2531 const SmallVector<DbgScope *, 4> &Children = WS->getScopes(); 2532 bool visitedChildren = false; 2533 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2534 SE = Children.end(); SI != SE; ++SI) { 2535 DbgScope *ChildScope = *SI; 2536 if (!ChildScope->getDFSOut()) { 2537 WorkStack.push_back(ChildScope); 2538 visitedChildren = true; 2539 ChildScope->setDFSIn(++Counter); 2540 break; 2541 } 2542 } 2543 if (!visitedChildren) { 2544 WorkStack.pop_back(); 2545 WS->setDFSOut(++Counter); 2546 } 2547 } 2548} 2549 2550/// printDbgScopeInfo - Print DbgScope info for each machine instruction. 2551static 2552void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF, 2553 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap) 2554{ 2555#ifndef NDEBUG 2556 unsigned PrevDFSIn = 0; 2557 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2558 I != E; ++I) { 2559 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2560 II != IE; ++II) { 2561 const MachineInstr *MInsn = II; 2562 const MDNode *Scope = NULL; 2563 const MDNode *InlinedAt = NULL; 2564 2565 // Check if instruction has valid location information. 2566 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2567 dbgs() << " [ "; 2568 if (InlinedAt) 2569 dbgs() << "*"; 2570 DenseMap<const MachineInstr *, DbgScope *>::iterator DI = 2571 MI2ScopeMap.find(MInsn); 2572 if (DI != MI2ScopeMap.end()) { 2573 DbgScope *S = DI->second; 2574 dbgs() << S->getDFSIn(); 2575 PrevDFSIn = S->getDFSIn(); 2576 } else 2577 dbgs() << PrevDFSIn; 2578 } else 2579 dbgs() << " [ x" << PrevDFSIn; 2580 dbgs() << " ]"; 2581 MInsn->dump(); 2582 } 2583 dbgs() << "\n"; 2584 } 2585#endif 2586} 2587/// extractScopeInformation - Scan machine instructions in this function 2588/// and collect DbgScopes. Return true, if at least one scope was found. 2589bool DwarfDebug::extractScopeInformation() { 2590 // If scope information was extracted using .dbg intrinsics then there is not 2591 // any need to extract these information by scanning each instruction. 2592 if (!DbgScopeMap.empty()) 2593 return false; 2594 2595 // Scan each instruction and create scopes. First build working set of scopes. 2596 LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2597 SmallVector<DbgRange, 4> MIRanges; 2598 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap; 2599 const MDNode *PrevScope = NULL; 2600 const MDNode *PrevInlinedAt = NULL; 2601 const MachineInstr *RangeBeginMI = NULL; 2602 const MachineInstr *PrevMI = NULL; 2603 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 2604 I != E; ++I) { 2605 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2606 II != IE; ++II) { 2607 const MachineInstr *MInsn = II; 2608 const MDNode *Scope = NULL; 2609 const MDNode *InlinedAt = NULL; 2610 2611 // Check if instruction has valid location information. 2612 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2613 PrevMI = MInsn; 2614 continue; 2615 } 2616 2617 // If scope has not changed then skip this instruction. 2618 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) { 2619 PrevMI = MInsn; 2620 continue; 2621 } 2622 2623 if (RangeBeginMI) { 2624 // If we have alread seen a beginning of a instruction range and 2625 // current instruction scope does not match scope of first instruction 2626 // in this range then create a new instruction range. 2627 DbgRange R(RangeBeginMI, PrevMI); 2628 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, 2629 PrevInlinedAt); 2630 MIRanges.push_back(R); 2631 } 2632 2633 // This is a beginning of a new instruction range. 2634 RangeBeginMI = MInsn; 2635 2636 // Reset previous markers. 2637 PrevMI = MInsn; 2638 PrevScope = Scope; 2639 PrevInlinedAt = InlinedAt; 2640 } 2641 } 2642 2643 // Create last instruction range. 2644 if (RangeBeginMI && PrevMI && PrevScope) { 2645 DbgRange R(RangeBeginMI, PrevMI); 2646 MIRanges.push_back(R); 2647 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt); 2648 } 2649 2650 if (!CurrentFnDbgScope) 2651 return false; 2652 2653 calculateDominanceGraph(CurrentFnDbgScope); 2654 if (PrintDbgScope) 2655 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap); 2656 2657 // Find ranges of instructions covered by each DbgScope; 2658 DbgScope *PrevDbgScope = NULL; 2659 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(), 2660 RE = MIRanges.end(); RI != RE; ++RI) { 2661 const DbgRange &R = *RI; 2662 DbgScope *S = MI2ScopeMap.lookup(R.first); 2663 assert (S && "Lost DbgScope for a machine instruction!"); 2664 if (PrevDbgScope && !PrevDbgScope->dominates(S)) 2665 PrevDbgScope->closeInsnRange(S); 2666 S->openInsnRange(R.first); 2667 S->extendInsnRange(R.second); 2668 PrevDbgScope = S; 2669 } 2670 2671 if (PrevDbgScope) 2672 PrevDbgScope->closeInsnRange(); 2673 2674 identifyScopeMarkers(); 2675 2676 return !DbgScopeMap.empty(); 2677} 2678 2679/// identifyScopeMarkers() - 2680/// Each DbgScope has first instruction and last instruction to mark beginning 2681/// and end of a scope respectively. Create an inverse map that list scopes 2682/// starts (and ends) with an instruction. One instruction may start (or end) 2683/// multiple scopes. Ignore scopes that are not reachable. 2684void DwarfDebug::identifyScopeMarkers() { 2685 SmallVector<DbgScope *, 4> WorkList; 2686 WorkList.push_back(CurrentFnDbgScope); 2687 while (!WorkList.empty()) { 2688 DbgScope *S = WorkList.pop_back_val(); 2689 2690 const SmallVector<DbgScope *, 4> &Children = S->getScopes(); 2691 if (!Children.empty()) 2692 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2693 SE = Children.end(); SI != SE; ++SI) 2694 WorkList.push_back(*SI); 2695 2696 if (S->isAbstractScope()) 2697 continue; 2698 2699 const SmallVector<DbgRange, 4> &Ranges = S->getRanges(); 2700 if (Ranges.empty()) 2701 continue; 2702 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 2703 RE = Ranges.end(); RI != RE; ++RI) { 2704 assert(RI->first && "DbgRange does not have first instruction!"); 2705 assert(RI->second && "DbgRange does not have second instruction!"); 2706 InsnsEndScopeSet.insert(RI->second); 2707 } 2708 } 2709} 2710 2711/// FindFirstDebugLoc - Find the first debug location in the function. This 2712/// is intended to be an approximation for the source position of the 2713/// beginning of the function. 2714static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) { 2715 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2716 I != E; ++I) 2717 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end(); 2718 MBBI != MBBE; ++MBBI) { 2719 DebugLoc DL = MBBI->getDebugLoc(); 2720 if (!DL.isUnknown()) 2721 return DL; 2722 } 2723 return DebugLoc(); 2724} 2725 2726/// beginFunction - Gather pre-function debug information. Assumes being 2727/// emitted immediately after the function entry point. 2728void DwarfDebug::beginFunction(const MachineFunction *MF) { 2729 if (!MMI->hasDebugInfo()) return; 2730 if (!extractScopeInformation()) return; 2731 2732 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 2733 Asm->getFunctionNumber()); 2734 // Assumes in correct section after the entry point. 2735 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 2736 2737 // Emit label for the implicitly defined dbg.stoppoint at the start of the 2738 // function. 2739 DebugLoc FDL = FindFirstDebugLoc(MF); 2740 if (FDL.isUnknown()) return; 2741 2742 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext()); 2743 const MDNode *TheScope = 0; 2744 2745 DISubprogram SP = getDISubprogram(Scope); 2746 unsigned Line, Col; 2747 if (SP.Verify()) { 2748 Line = SP.getLineNumber(); 2749 Col = 0; 2750 TheScope = SP; 2751 } else { 2752 Line = FDL.getLine(); 2753 Col = FDL.getCol(); 2754 TheScope = Scope; 2755 } 2756 2757 recordSourceLine(Line, Col, TheScope); 2758 2759 /// ProcessedArgs - Collection of arguments already processed. 2760 SmallPtrSet<const MDNode *, 8> ProcessedArgs; 2761 2762 DebugLoc PrevLoc; 2763 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2764 I != E; ++I) 2765 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2766 II != IE; ++II) { 2767 const MachineInstr *MI = II; 2768 DebugLoc DL = MI->getDebugLoc(); 2769 if (MI->isDebugValue()) { 2770 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!"); 2771 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata()); 2772 if (!DV.Verify()) continue; 2773 // If DBG_VALUE is for a local variable then it needs a label. 2774 if (DV.getTag() != dwarf::DW_TAG_arg_variable 2775 && isDbgValueInUndefinedReg(MI) == false) 2776 InsnNeedsLabel.insert(MI); 2777 // DBG_VALUE for inlined functions argument needs a label. 2778 else if (!DISubprogram(getDISubprogram(DV.getContext())). 2779 describes(MF->getFunction())) 2780 InsnNeedsLabel.insert(MI); 2781 // DBG_VALUE indicating argument location change needs a label. 2782 else if (isDbgValueInUndefinedReg(MI) == false 2783 && !ProcessedArgs.insert(DV)) 2784 InsnNeedsLabel.insert(MI); 2785 } else { 2786 // If location is unknown then instruction needs a location only if 2787 // UnknownLocations flag is set. 2788 if (DL.isUnknown()) { 2789 if (UnknownLocations && !PrevLoc.isUnknown()) 2790 InsnNeedsLabel.insert(MI); 2791 } else if (DL != PrevLoc) 2792 // Otherwise, instruction needs a location only if it is new location. 2793 InsnNeedsLabel.insert(MI); 2794 } 2795 2796 if (!DL.isUnknown() || UnknownLocations) 2797 PrevLoc = DL; 2798 } 2799 2800 PrevLabel = FunctionBeginSym; 2801} 2802 2803/// endFunction - Gather and emit post-function debug information. 2804/// 2805void DwarfDebug::endFunction(const MachineFunction *MF) { 2806 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return; 2807 2808 if (CurrentFnDbgScope) { 2809 2810 // Define end label for subprogram. 2811 FunctionEndSym = Asm->GetTempSymbol("func_end", 2812 Asm->getFunctionNumber()); 2813 // Assumes in correct section after the entry point. 2814 Asm->OutStreamer.EmitLabel(FunctionEndSym); 2815 2816 SmallPtrSet<const MDNode *, 16> ProcessedVars; 2817 collectVariableInfo(MF, ProcessedVars); 2818 2819 // Get function line info. 2820 if (!Lines.empty()) { 2821 // Get section line info. 2822 unsigned ID = SectionMap.insert(Asm->getCurrentSection()); 2823 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID); 2824 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1]; 2825 // Append the function info to section info. 2826 SectionLineInfos.insert(SectionLineInfos.end(), 2827 Lines.begin(), Lines.end()); 2828 } 2829 2830 // Construct abstract scopes. 2831 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2832 AE = AbstractScopesList.end(); AI != AE; ++AI) { 2833 DISubprogram SP((*AI)->getScopeNode()); 2834 if (SP.Verify()) { 2835 // Collect info for variables that were optimized out. 2836 StringRef FName = SP.getLinkageName(); 2837 if (FName.empty()) 2838 FName = SP.getName(); 2839 const Module *M = MF->getFunction()->getParent(); 2840 if (NamedMDNode *NMD = 2841 M->getNamedMetadata(Twine("llvm.dbg.lv.", 2842 getRealLinkageName(FName)))) { 2843 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2844 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 2845 if (!DV || !ProcessedVars.insert(DV)) 2846 continue; 2847 DbgScope *Scope = AbstractScopes.lookup(DV.getContext()); 2848 if (Scope) 2849 Scope->addVariable(new DbgVariable(DV)); 2850 } 2851 } 2852 } 2853 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0) 2854 constructScopeDIE(*AI); 2855 } 2856 2857 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope); 2858 2859 if (!DisableFramePointerElim(*MF)) 2860 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr, 2861 dwarf::DW_FORM_flag, 1); 2862 2863 2864 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(), 2865 MMI->getFrameMoves())); 2866 } 2867 2868 // Clear debug info 2869 CurrentFnDbgScope = NULL; 2870 InsnNeedsLabel.clear(); 2871 DbgVariableToFrameIndexMap.clear(); 2872 VarToAbstractVarMap.clear(); 2873 DbgVariableToDbgInstMap.clear(); 2874 DbgVariableLabelsMap.clear(); 2875 DeleteContainerSeconds(DbgScopeMap); 2876 InsnsEndScopeSet.clear(); 2877 ConcreteScopes.clear(); 2878 DeleteContainerSeconds(AbstractScopes); 2879 AbstractScopesList.clear(); 2880 AbstractVariables.clear(); 2881 LabelsBeforeInsn.clear(); 2882 LabelsAfterInsn.clear(); 2883 Lines.clear(); 2884 PrevLabel = NULL; 2885} 2886 2887/// recordVariableFrameIndex - Record a variable's index. 2888void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) { 2889 assert (V && "Invalid DbgVariable!"); 2890 DbgVariableToFrameIndexMap[V] = Index; 2891} 2892 2893/// findVariableFrameIndex - Return true if frame index for the variable 2894/// is found. Update FI to hold value of the index. 2895bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) { 2896 assert (V && "Invalid DbgVariable!"); 2897 DenseMap<const DbgVariable *, int>::iterator I = 2898 DbgVariableToFrameIndexMap.find(V); 2899 if (I == DbgVariableToFrameIndexMap.end()) 2900 return false; 2901 *FI = I->second; 2902 return true; 2903} 2904 2905/// findVariableLabel - Find MCSymbol for the variable. 2906const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) { 2907 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I 2908 = DbgVariableLabelsMap.find(V); 2909 if (I == DbgVariableLabelsMap.end()) 2910 return NULL; 2911 else return I->second; 2912} 2913 2914/// findDbgScope - Find DbgScope for the debug loc attached with an 2915/// instruction. 2916DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) { 2917 DbgScope *Scope = NULL; 2918 LLVMContext &Ctx = 2919 MInsn->getParent()->getParent()->getFunction()->getContext(); 2920 DebugLoc DL = MInsn->getDebugLoc(); 2921 2922 if (DL.isUnknown()) 2923 return Scope; 2924 2925 if (const MDNode *IA = DL.getInlinedAt(Ctx)) 2926 Scope = ConcreteScopes.lookup(IA); 2927 if (Scope == 0) 2928 Scope = DbgScopeMap.lookup(DL.getScope(Ctx)); 2929 2930 return Scope; 2931} 2932 2933 2934/// recordSourceLine - Register a source line with debug info. Returns the 2935/// unique label that was emitted and which provides correspondence to 2936/// the source line list. 2937MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, 2938 const MDNode *S) { 2939 StringRef Dir; 2940 StringRef Fn; 2941 2942 unsigned Src = 1; 2943 if (S) { 2944 DIDescriptor Scope(S); 2945 2946 if (Scope.isCompileUnit()) { 2947 DICompileUnit CU(S); 2948 Dir = CU.getDirectory(); 2949 Fn = CU.getFilename(); 2950 } else if (Scope.isSubprogram()) { 2951 DISubprogram SP(S); 2952 Dir = SP.getDirectory(); 2953 Fn = SP.getFilename(); 2954 } else if (Scope.isLexicalBlock()) { 2955 DILexicalBlock DB(S); 2956 Dir = DB.getDirectory(); 2957 Fn = DB.getFilename(); 2958 } else 2959 assert(0 && "Unexpected scope info"); 2960 2961 Src = GetOrCreateSourceID(Dir, Fn); 2962 } 2963 2964 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2965 Lines.push_back(SrcLineInfo(Line, Col, Src, Label)); 2966 2967 Asm->OutStreamer.EmitLabel(Label); 2968 return Label; 2969} 2970 2971//===----------------------------------------------------------------------===// 2972// Emit Methods 2973//===----------------------------------------------------------------------===// 2974 2975/// computeSizeAndOffset - Compute the size and offset of a DIE. 2976/// 2977unsigned 2978DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) { 2979 // Get the children. 2980 const std::vector<DIE *> &Children = Die->getChildren(); 2981 2982 // If not last sibling and has children then add sibling offset attribute. 2983 if (!Last && !Children.empty()) 2984 Die->addSiblingOffset(DIEValueAllocator); 2985 2986 // Record the abbreviation. 2987 assignAbbrevNumber(Die->getAbbrev()); 2988 2989 // Get the abbreviation for this DIE. 2990 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2991 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2992 2993 // Set DIE offset 2994 Die->setOffset(Offset); 2995 2996 // Start the size with the size of abbreviation code. 2997 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 2998 2999 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 3000 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 3001 3002 // Size the DIE attribute values. 3003 for (unsigned i = 0, N = Values.size(); i < N; ++i) 3004 // Size attribute value. 3005 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm()); 3006 3007 // Size the DIE children if any. 3008 if (!Children.empty()) { 3009 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 3010 "Children flag not set"); 3011 3012 for (unsigned j = 0, M = Children.size(); j < M; ++j) 3013 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M); 3014 3015 // End of children marker. 3016 Offset += sizeof(int8_t); 3017 } 3018 3019 Die->setSize(Offset - Die->getOffset()); 3020 return Offset; 3021} 3022 3023/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 3024/// 3025void DwarfDebug::computeSizeAndOffsets() { 3026 unsigned PrevOffset = 0; 3027 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3028 E = CUMap.end(); I != E; ++I) { 3029 // Compute size of compile unit header. 3030 static unsigned Offset = PrevOffset + 3031 sizeof(int32_t) + // Length of Compilation Unit Info 3032 sizeof(int16_t) + // DWARF version number 3033 sizeof(int32_t) + // Offset Into Abbrev. Section 3034 sizeof(int8_t); // Pointer Size (in bytes) 3035 computeSizeAndOffset(I->second->getCUDie(), Offset, true); 3036 PrevOffset = Offset; 3037 } 3038} 3039 3040/// EmitSectionSym - Switch to the specified MCSection and emit an assembler 3041/// temporary label to it if SymbolStem is specified. 3042static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section, 3043 const char *SymbolStem = 0) { 3044 Asm->OutStreamer.SwitchSection(Section); 3045 if (!SymbolStem) return 0; 3046 3047 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem); 3048 Asm->OutStreamer.EmitLabel(TmpSym); 3049 return TmpSym; 3050} 3051 3052/// EmitSectionLabels - Emit initial Dwarf sections with a label at 3053/// the start of each one. 3054void DwarfDebug::EmitSectionLabels() { 3055 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 3056 3057 // Dwarf sections base addresses. 3058 if (Asm->MAI->doesDwarfRequireFrameSection()) { 3059 DwarfFrameSectionSym = 3060 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame"); 3061 } 3062 3063 DwarfInfoSectionSym = 3064 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 3065 DwarfAbbrevSectionSym = 3066 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 3067 EmitSectionSym(Asm, TLOF.getDwarfARangesSection()); 3068 3069 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 3070 EmitSectionSym(Asm, MacroInfo); 3071 3072 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line"); 3073 EmitSectionSym(Asm, TLOF.getDwarfLocSection()); 3074 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 3075 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 3076 DwarfStrSectionSym = 3077 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str"); 3078 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(), 3079 "debug_range"); 3080 3081 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(), 3082 "section_debug_loc"); 3083 3084 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 3085 EmitSectionSym(Asm, TLOF.getDataSection()); 3086} 3087 3088/// emitDIE - Recusively Emits a debug information entry. 3089/// 3090void DwarfDebug::emitDIE(DIE *Die) { 3091 // Get the abbreviation for this DIE. 3092 unsigned AbbrevNumber = Die->getAbbrevNumber(); 3093 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 3094 3095 // Emit the code (index) for the abbreviation. 3096 if (Asm->isVerbose()) 3097 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 3098 Twine::utohexstr(Die->getOffset()) + ":0x" + 3099 Twine::utohexstr(Die->getSize()) + " " + 3100 dwarf::TagString(Abbrev->getTag())); 3101 Asm->EmitULEB128(AbbrevNumber); 3102 3103 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 3104 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 3105 3106 // Emit the DIE attribute values. 3107 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 3108 unsigned Attr = AbbrevData[i].getAttribute(); 3109 unsigned Form = AbbrevData[i].getForm(); 3110 assert(Form && "Too many attributes for DIE (check abbreviation)"); 3111 3112 if (Asm->isVerbose()) 3113 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 3114 3115 switch (Attr) { 3116 case dwarf::DW_AT_sibling: 3117 Asm->EmitInt32(Die->getSiblingOffset()); 3118 break; 3119 case dwarf::DW_AT_abstract_origin: { 3120 DIEEntry *E = cast<DIEEntry>(Values[i]); 3121 DIE *Origin = E->getEntry(); 3122 unsigned Addr = Origin->getOffset(); 3123 Asm->EmitInt32(Addr); 3124 break; 3125 } 3126 case dwarf::DW_AT_ranges: { 3127 // DW_AT_range Value encodes offset in debug_range section. 3128 DIEInteger *V = cast<DIEInteger>(Values[i]); 3129 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym, 3130 V->getValue(), 3131 DwarfDebugRangeSectionSym, 3132 4); 3133 break; 3134 } 3135 case dwarf::DW_AT_location: { 3136 if (UseDotDebugLocEntry.count(Die) != 0) { 3137 DIELabel *L = cast<DIELabel>(Values[i]); 3138 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4); 3139 } else 3140 Values[i]->EmitValue(Asm, Form); 3141 break; 3142 } 3143 default: 3144 // Emit an attribute using the defined form. 3145 Values[i]->EmitValue(Asm, Form); 3146 break; 3147 } 3148 } 3149 3150 // Emit the DIE children if any. 3151 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 3152 const std::vector<DIE *> &Children = Die->getChildren(); 3153 3154 for (unsigned j = 0, M = Children.size(); j < M; ++j) 3155 emitDIE(Children[j]); 3156 3157 if (Asm->isVerbose()) 3158 Asm->OutStreamer.AddComment("End Of Children Mark"); 3159 Asm->EmitInt8(0); 3160 } 3161} 3162 3163/// emitDebugInfo - Emit the debug info section. 3164/// 3165void DwarfDebug::emitDebugInfo() { 3166 // Start debug info section. 3167 Asm->OutStreamer.SwitchSection( 3168 Asm->getObjFileLowering().getDwarfInfoSection()); 3169 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3170 E = CUMap.end(); I != E; ++I) { 3171 CompileUnit *TheCU = I->second; 3172 DIE *Die = TheCU->getCUDie(); 3173 3174 // Emit the compile units header. 3175 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin", 3176 TheCU->getID())); 3177 3178 // Emit size of content not including length itself 3179 unsigned ContentSize = Die->getSize() + 3180 sizeof(int16_t) + // DWARF version number 3181 sizeof(int32_t) + // Offset Into Abbrev. Section 3182 sizeof(int8_t) + // Pointer Size (in bytes) 3183 sizeof(int32_t); // FIXME - extra pad for gdb bug. 3184 3185 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 3186 Asm->EmitInt32(ContentSize); 3187 Asm->OutStreamer.AddComment("DWARF version number"); 3188 Asm->EmitInt16(dwarf::DWARF_VERSION); 3189 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 3190 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"), 3191 DwarfAbbrevSectionSym); 3192 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 3193 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 3194 3195 emitDIE(Die); 3196 // FIXME - extra padding for gdb bug. 3197 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB"); 3198 Asm->EmitInt8(0); 3199 Asm->EmitInt8(0); 3200 Asm->EmitInt8(0); 3201 Asm->EmitInt8(0); 3202 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID())); 3203 } 3204} 3205 3206/// emitAbbreviations - Emit the abbreviation section. 3207/// 3208void DwarfDebug::emitAbbreviations() const { 3209 // Check to see if it is worth the effort. 3210 if (!Abbreviations.empty()) { 3211 // Start the debug abbrev section. 3212 Asm->OutStreamer.SwitchSection( 3213 Asm->getObjFileLowering().getDwarfAbbrevSection()); 3214 3215 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin")); 3216 3217 // For each abbrevation. 3218 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 3219 // Get abbreviation data 3220 const DIEAbbrev *Abbrev = Abbreviations[i]; 3221 3222 // Emit the abbrevations code (base 1 index.) 3223 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 3224 3225 // Emit the abbreviations data. 3226 Abbrev->Emit(Asm); 3227 } 3228 3229 // Mark end of abbreviations. 3230 Asm->EmitULEB128(0, "EOM(3)"); 3231 3232 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end")); 3233 } 3234} 3235 3236/// emitEndOfLineMatrix - Emit the last address of the section and the end of 3237/// the line matrix. 3238/// 3239void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 3240 // Define last address of section. 3241 Asm->OutStreamer.AddComment("Extended Op"); 3242 Asm->EmitInt8(0); 3243 3244 Asm->OutStreamer.AddComment("Op size"); 3245 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1); 3246 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 3247 Asm->EmitInt8(dwarf::DW_LNE_set_address); 3248 3249 Asm->OutStreamer.AddComment("Section end label"); 3250 3251 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 3252 Asm->getTargetData().getPointerSize(), 3253 0/*AddrSpace*/); 3254 3255 // Mark end of matrix. 3256 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 3257 Asm->EmitInt8(0); 3258 Asm->EmitInt8(1); 3259 Asm->EmitInt8(1); 3260} 3261 3262/// emitDebugLines - Emit source line information. 3263/// 3264void DwarfDebug::emitDebugLines() { 3265 // If the target is using .loc/.file, the assembler will be emitting the 3266 // .debug_line table automatically. 3267 if (Asm->MAI->hasDotLocAndDotFile()) 3268 return; 3269 3270 // Minimum line delta, thus ranging from -10..(255-10). 3271 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1); 3272 // Maximum line delta, thus ranging from -10..(255-10). 3273 const int MaxLineDelta = 255 + MinLineDelta; 3274 3275 // Start the dwarf line section. 3276 Asm->OutStreamer.SwitchSection( 3277 Asm->getObjFileLowering().getDwarfLineSection()); 3278 3279 // Construct the section header. 3280 Asm->OutStreamer.AddComment("Length of Source Line Info"); 3281 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"), 3282 Asm->GetTempSymbol("line_begin"), 4); 3283 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin")); 3284 3285 Asm->OutStreamer.AddComment("DWARF version number"); 3286 Asm->EmitInt16(dwarf::DWARF_VERSION); 3287 3288 Asm->OutStreamer.AddComment("Prolog Length"); 3289 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"), 3290 Asm->GetTempSymbol("line_prolog_begin"), 4); 3291 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin")); 3292 3293 Asm->OutStreamer.AddComment("Minimum Instruction Length"); 3294 Asm->EmitInt8(1); 3295 Asm->OutStreamer.AddComment("Default is_stmt_start flag"); 3296 Asm->EmitInt8(1); 3297 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)"); 3298 Asm->EmitInt8(MinLineDelta); 3299 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)"); 3300 Asm->EmitInt8(MaxLineDelta); 3301 Asm->OutStreamer.AddComment("Special Opcode Base"); 3302 Asm->EmitInt8(-MinLineDelta); 3303 3304 // Line number standard opcode encodings argument count 3305 Asm->OutStreamer.AddComment("DW_LNS_copy arg count"); 3306 Asm->EmitInt8(0); 3307 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count"); 3308 Asm->EmitInt8(1); 3309 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count"); 3310 Asm->EmitInt8(1); 3311 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count"); 3312 Asm->EmitInt8(1); 3313 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count"); 3314 Asm->EmitInt8(1); 3315 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count"); 3316 Asm->EmitInt8(0); 3317 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count"); 3318 Asm->EmitInt8(0); 3319 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count"); 3320 Asm->EmitInt8(0); 3321 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count"); 3322 Asm->EmitInt8(1); 3323 3324 // Emit directories. 3325 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) { 3326 const std::string &Dir = getSourceDirectoryName(DI); 3327 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory"); 3328 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0); 3329 } 3330 3331 Asm->OutStreamer.AddComment("End of directories"); 3332 Asm->EmitInt8(0); 3333 3334 // Emit files. 3335 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) { 3336 // Remember source id starts at 1. 3337 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI); 3338 const std::string &FN = getSourceFileName(Id.second); 3339 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source"); 3340 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0); 3341 3342 Asm->EmitULEB128(Id.first, "Directory #"); 3343 Asm->EmitULEB128(0, "Mod date"); 3344 Asm->EmitULEB128(0, "File size"); 3345 } 3346 3347 Asm->OutStreamer.AddComment("End of files"); 3348 Asm->EmitInt8(0); 3349 3350 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end")); 3351 3352 // A sequence for each text section. 3353 unsigned SecSrcLinesSize = SectionSourceLines.size(); 3354 3355 for (unsigned j = 0; j < SecSrcLinesSize; ++j) { 3356 // Isolate current sections line info. 3357 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j]; 3358 3359 // Dwarf assumes we start with first line of first source file. 3360 unsigned Source = 1; 3361 unsigned Line = 1; 3362 3363 // Construct rows of the address, source, line, column matrix. 3364 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) { 3365 const SrcLineInfo &LineInfo = LineInfos[i]; 3366 MCSymbol *Label = LineInfo.getLabel(); 3367 if (!Label->isDefined()) continue; // Not emitted, in dead code. 3368 3369 if (Asm->isVerbose()) { 3370 std::pair<unsigned, unsigned> SrcID = 3371 getSourceDirectoryAndFileIds(LineInfo.getSourceID()); 3372 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) + 3373 "/" + 3374 Twine(getSourceFileName(SrcID.second)) + 3375 ":" + Twine(LineInfo.getLine())); 3376 } 3377 3378 // Define the line address. 3379 Asm->OutStreamer.AddComment("Extended Op"); 3380 Asm->EmitInt8(0); 3381 Asm->OutStreamer.AddComment("Op size"); 3382 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1); 3383 3384 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 3385 Asm->EmitInt8(dwarf::DW_LNE_set_address); 3386 3387 Asm->OutStreamer.AddComment("Location label"); 3388 Asm->OutStreamer.EmitSymbolValue(Label, 3389 Asm->getTargetData().getPointerSize(), 3390 0/*AddrSpace*/); 3391 3392 // If change of source, then switch to the new source. 3393 if (Source != LineInfo.getSourceID()) { 3394 Source = LineInfo.getSourceID(); 3395 Asm->OutStreamer.AddComment("DW_LNS_set_file"); 3396 Asm->EmitInt8(dwarf::DW_LNS_set_file); 3397 Asm->EmitULEB128(Source, "New Source"); 3398 } 3399 3400 // If change of line. 3401 if (Line != LineInfo.getLine()) { 3402 // Determine offset. 3403 int Offset = LineInfo.getLine() - Line; 3404 int Delta = Offset - MinLineDelta; 3405 3406 // Update line. 3407 Line = LineInfo.getLine(); 3408 3409 // If delta is small enough and in range... 3410 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { 3411 // ... then use fast opcode. 3412 Asm->OutStreamer.AddComment("Line Delta"); 3413 Asm->EmitInt8(Delta - MinLineDelta); 3414 } else { 3415 // ... otherwise use long hand. 3416 Asm->OutStreamer.AddComment("DW_LNS_advance_line"); 3417 Asm->EmitInt8(dwarf::DW_LNS_advance_line); 3418 Asm->EmitSLEB128(Offset, "Line Offset"); 3419 Asm->OutStreamer.AddComment("DW_LNS_copy"); 3420 Asm->EmitInt8(dwarf::DW_LNS_copy); 3421 } 3422 } else { 3423 // Copy the previous row (different address or source) 3424 Asm->OutStreamer.AddComment("DW_LNS_copy"); 3425 Asm->EmitInt8(dwarf::DW_LNS_copy); 3426 } 3427 } 3428 3429 emitEndOfLineMatrix(j + 1); 3430 } 3431 3432 if (SecSrcLinesSize == 0) 3433 // Because we're emitting a debug_line section, we still need a line 3434 // table. The linker and friends expect it to exist. If there's nothing to 3435 // put into it, emit an empty table. 3436 emitEndOfLineMatrix(1); 3437 3438 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end")); 3439} 3440 3441/// emitCommonDebugFrame - Emit common frame info into a debug frame section. 3442/// 3443void DwarfDebug::emitCommonDebugFrame() { 3444 if (!Asm->MAI->doesDwarfRequireFrameSection()) 3445 return; 3446 3447 int stackGrowth = Asm->getTargetData().getPointerSize(); 3448 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() == 3449 TargetFrameInfo::StackGrowsDown) 3450 stackGrowth *= -1; 3451 3452 // Start the dwarf frame section. 3453 Asm->OutStreamer.SwitchSection( 3454 Asm->getObjFileLowering().getDwarfFrameSection()); 3455 3456 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common")); 3457 Asm->OutStreamer.AddComment("Length of Common Information Entry"); 3458 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"), 3459 Asm->GetTempSymbol("debug_frame_common_begin"), 4); 3460 3461 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin")); 3462 Asm->OutStreamer.AddComment("CIE Identifier Tag"); 3463 Asm->EmitInt32((int)dwarf::DW_CIE_ID); 3464 Asm->OutStreamer.AddComment("CIE Version"); 3465 Asm->EmitInt8(dwarf::DW_CIE_VERSION); 3466 Asm->OutStreamer.AddComment("CIE Augmentation"); 3467 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator. 3468 Asm->EmitULEB128(1, "CIE Code Alignment Factor"); 3469 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor"); 3470 Asm->OutStreamer.AddComment("CIE RA Column"); 3471 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 3472 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); 3473 3474 std::vector<MachineMove> Moves; 3475 RI->getInitialFrameState(Moves); 3476 3477 Asm->EmitFrameMoves(Moves, 0, false); 3478 3479 Asm->EmitAlignment(2); 3480 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end")); 3481} 3482 3483/// emitFunctionDebugFrame - Emit per function frame info into a debug frame 3484/// section. 3485void DwarfDebug:: 3486emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) { 3487 if (!Asm->MAI->doesDwarfRequireFrameSection()) 3488 return; 3489 3490 // Start the dwarf frame section. 3491 Asm->OutStreamer.SwitchSection( 3492 Asm->getObjFileLowering().getDwarfFrameSection()); 3493 3494 Asm->OutStreamer.AddComment("Length of Frame Information Entry"); 3495 MCSymbol *DebugFrameBegin = 3496 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number); 3497 MCSymbol *DebugFrameEnd = 3498 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number); 3499 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4); 3500 3501 Asm->OutStreamer.EmitLabel(DebugFrameBegin); 3502 3503 Asm->OutStreamer.AddComment("FDE CIE offset"); 3504 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"), 3505 DwarfFrameSectionSym); 3506 3507 Asm->OutStreamer.AddComment("FDE initial location"); 3508 MCSymbol *FuncBeginSym = 3509 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number); 3510 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym, 3511 Asm->getTargetData().getPointerSize(), 3512 0/*AddrSpace*/); 3513 3514 3515 Asm->OutStreamer.AddComment("FDE address range"); 3516 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number), 3517 FuncBeginSym, Asm->getTargetData().getPointerSize()); 3518 3519 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false); 3520 3521 Asm->EmitAlignment(2); 3522 Asm->OutStreamer.EmitLabel(DebugFrameEnd); 3523} 3524 3525/// emitDebugPubNames - Emit visible names into a debug pubnames section. 3526/// 3527void DwarfDebug::emitDebugPubNames() { 3528 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3529 E = CUMap.end(); I != E; ++I) { 3530 CompileUnit *TheCU = I->second; 3531 // Start the dwarf pubnames section. 3532 Asm->OutStreamer.SwitchSection( 3533 Asm->getObjFileLowering().getDwarfPubNamesSection()); 3534 3535 Asm->OutStreamer.AddComment("Length of Public Names Info"); 3536 Asm->EmitLabelDifference( 3537 Asm->GetTempSymbol("pubnames_end", TheCU->getID()), 3538 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4); 3539 3540 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", 3541 TheCU->getID())); 3542 3543 Asm->OutStreamer.AddComment("DWARF Version"); 3544 Asm->EmitInt16(dwarf::DWARF_VERSION); 3545 3546 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 3547 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 3548 DwarfInfoSectionSym); 3549 3550 Asm->OutStreamer.AddComment("Compilation Unit Length"); 3551 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 3552 Asm->GetTempSymbol("info_begin", TheCU->getID()), 3553 4); 3554 3555 const StringMap<DIE*> &Globals = TheCU->getGlobals(); 3556 for (StringMap<DIE*>::const_iterator 3557 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 3558 const char *Name = GI->getKeyData(); 3559 DIE *Entity = GI->second; 3560 3561 Asm->OutStreamer.AddComment("DIE offset"); 3562 Asm->EmitInt32(Entity->getOffset()); 3563 3564 if (Asm->isVerbose()) 3565 Asm->OutStreamer.AddComment("External Name"); 3566 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0); 3567 } 3568 3569 Asm->OutStreamer.AddComment("End Mark"); 3570 Asm->EmitInt32(0); 3571 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", 3572 TheCU->getID())); 3573 } 3574} 3575 3576void DwarfDebug::emitDebugPubTypes() { 3577 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3578 E = CUMap.end(); I != E; ++I) { 3579 CompileUnit *TheCU = I->second; 3580 // Start the dwarf pubnames section. 3581 Asm->OutStreamer.SwitchSection( 3582 Asm->getObjFileLowering().getDwarfPubTypesSection()); 3583 Asm->OutStreamer.AddComment("Length of Public Types Info"); 3584 Asm->EmitLabelDifference( 3585 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()), 3586 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4); 3587 3588 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 3589 TheCU->getID())); 3590 3591 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 3592 Asm->EmitInt16(dwarf::DWARF_VERSION); 3593 3594 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 3595 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 3596 DwarfInfoSectionSym); 3597 3598 Asm->OutStreamer.AddComment("Compilation Unit Length"); 3599 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 3600 Asm->GetTempSymbol("info_begin", TheCU->getID()), 3601 4); 3602 3603 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes(); 3604 for (StringMap<DIE*>::const_iterator 3605 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 3606 const char *Name = GI->getKeyData(); 3607 DIE * Entity = GI->second; 3608 3609 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 3610 Asm->EmitInt32(Entity->getOffset()); 3611 3612 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 3613 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0); 3614 } 3615 3616 Asm->OutStreamer.AddComment("End Mark"); 3617 Asm->EmitInt32(0); 3618 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 3619 TheCU->getID())); 3620 } 3621} 3622 3623/// emitDebugStr - Emit visible names into a debug str section. 3624/// 3625void DwarfDebug::emitDebugStr() { 3626 // Check to see if it is worth the effort. 3627 if (StringPool.empty()) return; 3628 3629 // Start the dwarf str section. 3630 Asm->OutStreamer.SwitchSection( 3631 Asm->getObjFileLowering().getDwarfStrSection()); 3632 3633 // Get all of the string pool entries and put them in an array by their ID so 3634 // we can sort them. 3635 SmallVector<std::pair<unsigned, 3636 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 3637 3638 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 3639 I = StringPool.begin(), E = StringPool.end(); I != E; ++I) 3640 Entries.push_back(std::make_pair(I->second.second, &*I)); 3641 3642 array_pod_sort(Entries.begin(), Entries.end()); 3643 3644 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 3645 // Emit a label for reference from debug information entries. 3646 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 3647 3648 // Emit the string itself. 3649 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/); 3650 } 3651} 3652 3653/// emitDebugLoc - Emit visible names into a debug loc section. 3654/// 3655void DwarfDebug::emitDebugLoc() { 3656 if (DotDebugLocEntries.empty()) 3657 return; 3658 3659 // Start the dwarf loc section. 3660 Asm->OutStreamer.SwitchSection( 3661 Asm->getObjFileLowering().getDwarfLocSection()); 3662 unsigned char Size = Asm->getTargetData().getPointerSize(); 3663 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0)); 3664 unsigned index = 1; 3665 for (SmallVector<DotDebugLocEntry, 4>::iterator 3666 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 3667 I != E; ++I, ++index) { 3668 DotDebugLocEntry Entry = *I; 3669 if (Entry.isEmpty()) { 3670 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3671 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3672 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index)); 3673 } else { 3674 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0); 3675 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0); 3676 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 3677 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false); 3678 if (int Offset = Entry.Loc.getOffset()) { 3679 // If the value is at a certain offset from frame register then 3680 // use DW_OP_fbreg. 3681 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1; 3682 Asm->OutStreamer.AddComment("Loc expr size"); 3683 Asm->EmitInt16(1 + OffsetSize); 3684 Asm->OutStreamer.AddComment( 3685 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg)); 3686 Asm->EmitInt8(dwarf::DW_OP_fbreg); 3687 Asm->OutStreamer.AddComment("Offset"); 3688 Asm->EmitSLEB128(Offset); 3689 } else { 3690 if (Reg < 32) { 3691 Asm->OutStreamer.AddComment("Loc expr size"); 3692 Asm->EmitInt16(1); 3693 Asm->OutStreamer.AddComment( 3694 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg)); 3695 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg); 3696 } else { 3697 Asm->OutStreamer.AddComment("Loc expr size"); 3698 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg)); 3699 Asm->EmitInt8(dwarf::DW_OP_regx); 3700 Asm->EmitULEB128(Reg); 3701 } 3702 } 3703 } 3704 } 3705} 3706 3707/// EmitDebugARanges - Emit visible names into a debug aranges section. 3708/// 3709void DwarfDebug::EmitDebugARanges() { 3710 // Start the dwarf aranges section. 3711 Asm->OutStreamer.SwitchSection( 3712 Asm->getObjFileLowering().getDwarfARangesSection()); 3713} 3714 3715/// emitDebugRanges - Emit visible names into a debug ranges section. 3716/// 3717void DwarfDebug::emitDebugRanges() { 3718 // Start the dwarf ranges section. 3719 Asm->OutStreamer.SwitchSection( 3720 Asm->getObjFileLowering().getDwarfRangesSection()); 3721 unsigned char Size = Asm->getTargetData().getPointerSize(); 3722 for (SmallVector<const MCSymbol *, 8>::iterator 3723 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end(); 3724 I != E; ++I) { 3725 if (*I) 3726 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0); 3727 else 3728 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3729 } 3730} 3731 3732/// emitDebugMacInfo - Emit visible names into a debug macinfo section. 3733/// 3734void DwarfDebug::emitDebugMacInfo() { 3735 if (const MCSection *LineInfo = 3736 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 3737 // Start the dwarf macinfo section. 3738 Asm->OutStreamer.SwitchSection(LineInfo); 3739 } 3740} 3741 3742/// emitDebugInlineInfo - Emit inline info using following format. 3743/// Section Header: 3744/// 1. length of section 3745/// 2. Dwarf version number 3746/// 3. address size. 3747/// 3748/// Entries (one "entry" for each function that was inlined): 3749/// 3750/// 1. offset into __debug_str section for MIPS linkage name, if exists; 3751/// otherwise offset into __debug_str for regular function name. 3752/// 2. offset into __debug_str section for regular function name. 3753/// 3. an unsigned LEB128 number indicating the number of distinct inlining 3754/// instances for the function. 3755/// 3756/// The rest of the entry consists of a {die_offset, low_pc} pair for each 3757/// inlined instance; the die_offset points to the inlined_subroutine die in the 3758/// __debug_info section, and the low_pc is the starting address for the 3759/// inlining instance. 3760void DwarfDebug::emitDebugInlineInfo() { 3761 if (!Asm->MAI->doesDwarfUsesInlineInfoSection()) 3762 return; 3763 3764 if (!FirstCU) 3765 return; 3766 3767 Asm->OutStreamer.SwitchSection( 3768 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 3769 3770 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry"); 3771 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1), 3772 Asm->GetTempSymbol("debug_inlined_begin", 1), 4); 3773 3774 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1)); 3775 3776 Asm->OutStreamer.AddComment("Dwarf Version"); 3777 Asm->EmitInt16(dwarf::DWARF_VERSION); 3778 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 3779 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 3780 3781 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 3782 E = InlinedSPNodes.end(); I != E; ++I) { 3783 3784 const MDNode *Node = *I; 3785 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 3786 = InlineInfo.find(Node); 3787 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 3788 DISubprogram SP(Node); 3789 StringRef LName = SP.getLinkageName(); 3790 StringRef Name = SP.getName(); 3791 3792 Asm->OutStreamer.AddComment("MIPS linkage name"); 3793 if (LName.empty()) { 3794 Asm->OutStreamer.EmitBytes(Name, 0); 3795 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator. 3796 } else 3797 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)), 3798 DwarfStrSectionSym); 3799 3800 Asm->OutStreamer.AddComment("Function name"); 3801 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym); 3802 Asm->EmitULEB128(Labels.size(), "Inline count"); 3803 3804 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 3805 LE = Labels.end(); LI != LE; ++LI) { 3806 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 3807 Asm->EmitInt32(LI->second->getOffset()); 3808 3809 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc"); 3810 Asm->OutStreamer.EmitSymbolValue(LI->first, 3811 Asm->getTargetData().getPointerSize(),0); 3812 } 3813 } 3814 3815 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1)); 3816} 3817