DwarfDebug.cpp revision 265228e6020c662fb1b22998a4a374a065914081
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 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList()) 1819 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr, 1820 Asm->GetTempSymbol("section_line")); 1821 else 1822 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0); 1823 1824 if (!Dir.empty()) 1825 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir); 1826 if (DIUnit.isOptimized()) 1827 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 1828 1829 StringRef Flags = DIUnit.getFlags(); 1830 if (!Flags.empty()) 1831 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags); 1832 1833 unsigned RVer = DIUnit.getRunTimeVersion(); 1834 if (RVer) 1835 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers, 1836 dwarf::DW_FORM_data1, RVer); 1837 1838 CompileUnit *NewCU = new CompileUnit(ID, Die); 1839 if (!FirstCU) 1840 FirstCU = NewCU; 1841 CUMap.insert(std::make_pair(N, NewCU)); 1842} 1843 1844/// getCompielUnit - Get CompileUnit DIE. 1845CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const { 1846 assert (N && "Invalid DwarfDebug::getCompileUnit argument!"); 1847 DIDescriptor D(N); 1848 const MDNode *CUNode = NULL; 1849 if (D.isCompileUnit()) 1850 CUNode = N; 1851 else if (D.isSubprogram()) 1852 CUNode = DISubprogram(N).getCompileUnit(); 1853 else if (D.isType()) 1854 CUNode = DIType(N).getCompileUnit(); 1855 else if (D.isGlobalVariable()) 1856 CUNode = DIGlobalVariable(N).getCompileUnit(); 1857 else if (D.isVariable()) 1858 CUNode = DIVariable(N).getCompileUnit(); 1859 else if (D.isNameSpace()) 1860 CUNode = DINameSpace(N).getCompileUnit(); 1861 else if (D.isFile()) 1862 CUNode = DIFile(N).getCompileUnit(); 1863 else 1864 return FirstCU; 1865 1866 DenseMap<const MDNode *, CompileUnit *>::const_iterator I 1867 = CUMap.find(CUNode); 1868 if (I == CUMap.end()) 1869 return FirstCU; 1870 return I->second; 1871} 1872 1873/// isUnsignedDIType - Return true if type encoding is unsigned. 1874static bool isUnsignedDIType(DIType Ty) { 1875 DIDerivedType DTy(Ty); 1876 if (DTy.Verify()) 1877 return isUnsignedDIType(DTy.getTypeDerivedFrom()); 1878 1879 DIBasicType BTy(Ty); 1880 if (BTy.Verify()) { 1881 unsigned Encoding = BTy.getEncoding(); 1882 if (Encoding == dwarf::DW_ATE_unsigned || 1883 Encoding == dwarf::DW_ATE_unsigned_char) 1884 return true; 1885 } 1886 return false; 1887} 1888 1889/// constructGlobalVariableDIE - Construct global variable DIE. 1890void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) { 1891 DIGlobalVariable GV(N); 1892 1893 // If debug information is malformed then ignore it. 1894 if (GV.Verify() == false) 1895 return; 1896 1897 // Check for pre-existence. 1898 CompileUnit *TheCU = getCompileUnit(N); 1899 if (TheCU->getDIE(GV)) 1900 return; 1901 1902 DIType GTy = GV.getType(); 1903 DIE *VariableDIE = new DIE(GV.getTag()); 1904 1905 bool isGlobalVariable = GV.getGlobal() != NULL; 1906 1907 // Add name. 1908 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, 1909 GV.getDisplayName()); 1910 StringRef LinkageName = GV.getLinkageName(); 1911 if (!LinkageName.empty() && isGlobalVariable) 1912 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string, 1913 getRealLinkageName(LinkageName)); 1914 // Add type. 1915 addType(VariableDIE, GTy); 1916 if (GTy.isCompositeType() && !GTy.getName().empty() 1917 && !GTy.isForwardDecl()) { 1918 DIEEntry *Entry = TheCU->getDIEEntry(GTy); 1919 assert(Entry && "Missing global type!"); 1920 TheCU->addGlobalType(GTy.getName(), Entry->getEntry()); 1921 } 1922 // Add scoping info. 1923 if (!GV.isLocalToUnit()) { 1924 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1925 // Expose as global. 1926 TheCU->addGlobal(GV.getName(), VariableDIE); 1927 } 1928 // Add line number info. 1929 addSourceLine(VariableDIE, GV); 1930 // Add to map. 1931 TheCU->insertDIE(N, VariableDIE); 1932 // Add to context owner. 1933 DIDescriptor GVContext = GV.getContext(); 1934 addToContextOwner(VariableDIE, GVContext); 1935 // Add location. 1936 if (isGlobalVariable) { 1937 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1938 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 1939 addLabel(Block, 0, dwarf::DW_FORM_udata, 1940 Asm->Mang->getSymbol(GV.getGlobal())); 1941 // Do not create specification DIE if context is either compile unit 1942 // or a subprogram. 1943 if (GV.isDefinition() && !GVContext.isCompileUnit() && 1944 !GVContext.isFile() && !isSubprogramContext(GVContext)) { 1945 // Create specification DIE. 1946 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable); 1947 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, 1948 dwarf::DW_FORM_ref4, VariableDIE); 1949 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block); 1950 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1951 TheCU->addDie(VariableSpecDIE); 1952 } else { 1953 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block); 1954 } 1955 } else if (Constant *C = GV.getConstant()) { 1956 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) { 1957 if (isUnsignedDIType(GTy)) 1958 addUInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata, 1959 CI->getZExtValue()); 1960 else 1961 addSInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, 1962 CI->getSExtValue()); 1963 } 1964 } 1965 return; 1966} 1967 1968/// construct SubprogramDIE - Construct subprogram DIE. 1969void DwarfDebug::constructSubprogramDIE(const MDNode *N) { 1970 DISubprogram SP(N); 1971 1972 // Check for pre-existence. 1973 CompileUnit *TheCU = getCompileUnit(N); 1974 if (TheCU->getDIE(N)) 1975 return; 1976 1977 if (!SP.isDefinition()) 1978 // This is a method declaration which will be handled while constructing 1979 // class type. 1980 return; 1981 1982 DIE *SubprogramDie = createSubprogramDIE(SP); 1983 1984 // Add to map. 1985 TheCU->insertDIE(N, SubprogramDie); 1986 1987 // Add to context owner. 1988 addToContextOwner(SubprogramDie, SP.getContext()); 1989 1990 // Expose as global. 1991 TheCU->addGlobal(SP.getName(), SubprogramDie); 1992 1993 return; 1994} 1995 1996/// beginModule - Emit all Dwarf sections that should come prior to the 1997/// content. Create global DIEs and emit initial debug info sections. 1998/// This is inovked by the target AsmPrinter. 1999void DwarfDebug::beginModule(Module *M) { 2000 if (DisableDebugInfoPrinting) 2001 return; 2002 2003 DebugInfoFinder DbgFinder; 2004 DbgFinder.processModule(*M); 2005 2006 bool HasDebugInfo = false; 2007 2008 // Scan all the compile-units to see if there are any marked as the main unit. 2009 // if not, we do not generate debug info. 2010 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 2011 E = DbgFinder.compile_unit_end(); I != E; ++I) { 2012 if (DICompileUnit(*I).isMain()) { 2013 HasDebugInfo = true; 2014 break; 2015 } 2016 } 2017 2018 if (!HasDebugInfo) return; 2019 2020 // Tell MMI that we have debug info. 2021 MMI->setDebugInfoAvailability(true); 2022 2023 // Emit initial sections. 2024 EmitSectionLabels(); 2025 2026 // Create all the compile unit DIEs. 2027 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 2028 E = DbgFinder.compile_unit_end(); I != E; ++I) 2029 constructCompileUnit(*I); 2030 2031 // Create DIEs for each subprogram. 2032 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(), 2033 E = DbgFinder.subprogram_end(); I != E; ++I) 2034 constructSubprogramDIE(*I); 2035 2036 // Create DIEs for each global variable. 2037 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(), 2038 E = DbgFinder.global_variable_end(); I != E; ++I) 2039 constructGlobalVariableDIE(*I); 2040 2041 //getOrCreateTypeDIE 2042 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum")) 2043 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) 2044 getOrCreateTypeDIE(DIType(NMD->getOperand(i))); 2045 2046 // Prime section data. 2047 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 2048 2049 // Print out .file directives to specify files for .loc directives. These are 2050 // printed out early so that they precede any .loc directives. 2051 if (Asm->MAI->hasDotLocAndDotFile()) { 2052 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) { 2053 // Remember source id starts at 1. 2054 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i); 2055 // FIXME: don't use sys::path for this! This should not depend on the 2056 // host. 2057 sys::Path FullPath(getSourceDirectoryName(Id.first)); 2058 bool AppendOk = 2059 FullPath.appendComponent(getSourceFileName(Id.second)); 2060 assert(AppendOk && "Could not append filename to directory!"); 2061 AppendOk = false; 2062 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str()); 2063 } 2064 } 2065} 2066 2067/// endModule - Emit all Dwarf sections that should come after the content. 2068/// 2069void DwarfDebug::endModule() { 2070 if (!FirstCU) return; 2071 const Module *M = MMI->getModule(); 2072 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap; 2073 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) { 2074 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) { 2075 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue; 2076 DISubprogram SP(AllSPs->getOperand(SI)); 2077 if (!SP.Verify()) continue; 2078 2079 // Collect info for variables that were optimized out. 2080 if (!SP.isDefinition()) continue; 2081 StringRef FName = SP.getLinkageName(); 2082 if (FName.empty()) 2083 FName = SP.getName(); 2084 NamedMDNode *NMD = 2085 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName))); 2086 if (!NMD) continue; 2087 unsigned E = NMD->getNumOperands(); 2088 if (!E) continue; 2089 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL); 2090 DeadFnScopeMap[SP] = Scope; 2091 for (unsigned I = 0; I != E; ++I) { 2092 DIVariable DV(NMD->getOperand(I)); 2093 if (!DV.Verify()) continue; 2094 Scope->addVariable(new DbgVariable(DV)); 2095 } 2096 2097 // Construct subprogram DIE and add variables DIEs. 2098 constructSubprogramDIE(SP); 2099 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP); 2100 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables(); 2101 for (unsigned i = 0, N = Variables.size(); i < N; ++i) { 2102 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope); 2103 if (VariableDIE) 2104 ScopeDIE->addChild(VariableDIE); 2105 } 2106 } 2107 } 2108 2109 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 2110 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 2111 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 2112 DIE *ISP = *AI; 2113 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 2114 } 2115 2116 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(), 2117 CE = ContainingTypeMap.end(); CI != CE; ++CI) { 2118 DIE *SPDie = CI->first; 2119 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second); 2120 if (!N) continue; 2121 DIE *NDie = getCompileUnit(N)->getDIE(N); 2122 if (!NDie) continue; 2123 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie); 2124 } 2125 2126 // Standard sections final addresses. 2127 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 2128 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end")); 2129 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 2130 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end")); 2131 2132 // End text sections. 2133 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) { 2134 Asm->OutStreamer.SwitchSection(SectionMap[i]); 2135 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i)); 2136 } 2137 2138 // Emit common frame information. 2139 emitCommonDebugFrame(); 2140 2141 // Emit function debug frame information 2142 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(), 2143 E = DebugFrames.end(); I != E; ++I) 2144 emitFunctionDebugFrame(*I); 2145 2146 // Compute DIE offsets and sizes. 2147 computeSizeAndOffsets(); 2148 2149 // Emit all the DIEs into a debug info section 2150 emitDebugInfo(); 2151 2152 // Corresponding abbreviations into a abbrev section. 2153 emitAbbreviations(); 2154 2155 // Emit source line correspondence into a debug line section. 2156 emitDebugLines(); 2157 2158 // Emit info into a debug pubnames section. 2159 emitDebugPubNames(); 2160 2161 // Emit info into a debug pubtypes section. 2162 emitDebugPubTypes(); 2163 2164 // Emit info into a debug loc section. 2165 emitDebugLoc(); 2166 2167 // Emit info into a debug aranges section. 2168 EmitDebugARanges(); 2169 2170 // Emit info into a debug ranges section. 2171 emitDebugRanges(); 2172 2173 // Emit info into a debug macinfo section. 2174 emitDebugMacInfo(); 2175 2176 // Emit inline info. 2177 emitDebugInlineInfo(); 2178 2179 // Emit info into a debug str section. 2180 emitDebugStr(); 2181 2182 // clean up. 2183 DeleteContainerSeconds(DeadFnScopeMap); 2184 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2185 E = CUMap.end(); I != E; ++I) 2186 delete I->second; 2187 FirstCU = NULL; // Reset for the next Module, if any. 2188} 2189 2190/// findAbstractVariable - Find abstract variable, if any, associated with Var. 2191DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var, 2192 DebugLoc ScopeLoc) { 2193 2194 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var); 2195 if (AbsDbgVariable) 2196 return AbsDbgVariable; 2197 2198 LLVMContext &Ctx = Var->getContext(); 2199 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx)); 2200 if (!Scope) 2201 return NULL; 2202 2203 AbsDbgVariable = new DbgVariable(Var); 2204 Scope->addVariable(AbsDbgVariable); 2205 AbstractVariables[Var] = AbsDbgVariable; 2206 return AbsDbgVariable; 2207} 2208 2209/// collectVariableInfoFromMMITable - Collect variable information from 2210/// side table maintained by MMI. 2211void 2212DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF, 2213 SmallPtrSet<const MDNode *, 16> &Processed) { 2214 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2215 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 2216 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 2217 VE = VMap.end(); VI != VE; ++VI) { 2218 const MDNode *Var = VI->first; 2219 if (!Var) continue; 2220 Processed.insert(Var); 2221 DIVariable DV(Var); 2222 const std::pair<unsigned, DebugLoc> &VP = VI->second; 2223 2224 DbgScope *Scope = 0; 2225 if (const MDNode *IA = VP.second.getInlinedAt(Ctx)) 2226 Scope = ConcreteScopes.lookup(IA); 2227 if (Scope == 0) 2228 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx)); 2229 2230 // If variable scope is not found then skip this variable. 2231 if (Scope == 0) 2232 continue; 2233 2234 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second); 2235 DbgVariable *RegVar = new DbgVariable(DV); 2236 recordVariableFrameIndex(RegVar, VP.first); 2237 Scope->addVariable(RegVar); 2238 if (AbsDbgVariable) { 2239 recordVariableFrameIndex(AbsDbgVariable, VP.first); 2240 VarToAbstractVarMap[RegVar] = AbsDbgVariable; 2241 } 2242 } 2243} 2244 2245/// isDbgValueInUndefinedReg - Return true if debug value, encoded by 2246/// DBG_VALUE instruction, is in undefined reg. 2247static bool isDbgValueInUndefinedReg(const MachineInstr *MI) { 2248 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 2249 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg()) 2250 return true; 2251 return false; 2252} 2253 2254/// isDbgValueInDefinedReg - Return true if debug value, encoded by 2255/// DBG_VALUE instruction, is in a defined reg. 2256static bool isDbgValueInDefinedReg(const MachineInstr *MI) { 2257 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 2258 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg()) 2259 return true; 2260 return false; 2261} 2262 2263/// collectVariableInfo - Populate DbgScope entries with variables' info. 2264void 2265DwarfDebug::collectVariableInfo(const MachineFunction *MF, 2266 SmallPtrSet<const MDNode *, 16> &Processed) { 2267 2268 /// collection info from MMI table. 2269 collectVariableInfoFromMMITable(MF, Processed); 2270 2271 SmallVector<const MachineInstr *, 8> DbgValues; 2272 // Collect variable information from DBG_VALUE machine instructions; 2273 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 2274 I != E; ++I) 2275 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2276 II != IE; ++II) { 2277 const MachineInstr *MInsn = II; 2278 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn)) 2279 continue; 2280 DbgValues.push_back(MInsn); 2281 } 2282 2283 // This is a collection of DBV_VALUE instructions describing same variable. 2284 SmallVector<const MachineInstr *, 4> MultipleValues; 2285 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(), 2286 E = DbgValues.end(); I != E; ++I) { 2287 const MachineInstr *MInsn = *I; 2288 MultipleValues.clear(); 2289 if (isDbgValueInDefinedReg(MInsn)) 2290 MultipleValues.push_back(MInsn); 2291 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata()); 2292 if (Processed.count(DV) != 0) 2293 continue; 2294 2295 const MachineInstr *PrevMI = MInsn; 2296 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1, 2297 ME = DbgValues.end(); MI != ME; ++MI) { 2298 const MDNode *Var = 2299 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata(); 2300 if (Var == DV && isDbgValueInDefinedReg(*MI) && 2301 !PrevMI->isIdenticalTo(*MI)) 2302 MultipleValues.push_back(*MI); 2303 PrevMI = *MI; 2304 } 2305 2306 DbgScope *Scope = findDbgScope(MInsn); 2307 bool CurFnArg = false; 2308 if (DV.getTag() == dwarf::DW_TAG_arg_variable && 2309 DISubprogram(DV.getContext()).describes(MF->getFunction())) 2310 CurFnArg = true; 2311 if (!Scope && CurFnArg) 2312 Scope = CurrentFnDbgScope; 2313 // If variable scope is not found then skip this variable. 2314 if (!Scope) 2315 continue; 2316 2317 Processed.insert(DV); 2318 DbgVariable *RegVar = new DbgVariable(DV); 2319 Scope->addVariable(RegVar); 2320 if (!CurFnArg) 2321 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn); 2322 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) { 2323 DbgVariableToDbgInstMap[AbsVar] = MInsn; 2324 VarToAbstractVarMap[RegVar] = AbsVar; 2325 } 2326 if (MultipleValues.size() <= 1) { 2327 DbgVariableToDbgInstMap[RegVar] = MInsn; 2328 continue; 2329 } 2330 2331 // handle multiple DBG_VALUE instructions describing one variable. 2332 if (DotDebugLocEntries.empty()) 2333 RegVar->setDotDebugLocOffset(0); 2334 else 2335 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size()); 2336 const MachineInstr *Begin = NULL; 2337 const MachineInstr *End = NULL; 2338 for (SmallVector<const MachineInstr *, 4>::iterator 2339 MVI = MultipleValues.begin(), MVE = MultipleValues.end(); 2340 MVI != MVE; ++MVI) { 2341 if (!Begin) { 2342 Begin = *MVI; 2343 continue; 2344 } 2345 End = *MVI; 2346 MachineLocation MLoc; 2347 if (Begin->getNumOperands() == 3) { 2348 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm()) 2349 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm()); 2350 } else 2351 MLoc = Asm->getDebugValueLocation(Begin); 2352 2353 const MCSymbol *FLabel = getLabelBeforeInsn(Begin); 2354 const MCSymbol *SLabel = getLabelBeforeInsn(End); 2355 if (MLoc.getReg()) 2356 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc)); 2357 2358 Begin = End; 2359 if (MVI + 1 == MVE) { 2360 // If End is the last instruction then its value is valid 2361 // until the end of the funtion. 2362 MachineLocation EMLoc; 2363 if (End->getNumOperands() == 3) { 2364 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm()) 2365 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm()); 2366 } else 2367 EMLoc = Asm->getDebugValueLocation(End); 2368 if (EMLoc.getReg()) 2369 DotDebugLocEntries. 2370 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc)); 2371 } 2372 } 2373 DotDebugLocEntries.push_back(DotDebugLocEntry()); 2374 } 2375 2376 // Collect info for variables that were optimized out. 2377 const Function *F = MF->getFunction(); 2378 const Module *M = F->getParent(); 2379 if (NamedMDNode *NMD = 2380 M->getNamedMetadata(Twine("llvm.dbg.lv.", 2381 getRealLinkageName(F->getName())))) { 2382 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2383 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 2384 if (!DV || !Processed.insert(DV)) 2385 continue; 2386 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext()); 2387 if (Scope) 2388 Scope->addVariable(new DbgVariable(DV)); 2389 } 2390 } 2391} 2392 2393/// getLabelBeforeInsn - Return Label preceding the instruction. 2394const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { 2395 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 2396 LabelsBeforeInsn.find(MI); 2397 if (I == LabelsBeforeInsn.end()) 2398 // FunctionBeginSym always preceeds all the instruction in current function. 2399 return FunctionBeginSym; 2400 return I->second; 2401} 2402 2403/// getLabelAfterInsn - Return Label immediately following the instruction. 2404const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { 2405 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 2406 LabelsAfterInsn.find(MI); 2407 if (I == LabelsAfterInsn.end()) 2408 return NULL; 2409 return I->second; 2410} 2411 2412/// beginScope - Process beginning of a scope. 2413void DwarfDebug::beginScope(const MachineInstr *MI) { 2414 if (InsnNeedsLabel.count(MI) == 0) { 2415 LabelsBeforeInsn[MI] = PrevLabel; 2416 return; 2417 } 2418 2419 // Check location. 2420 DebugLoc DL = MI->getDebugLoc(); 2421 if (!DL.isUnknown()) { 2422 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 2423 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope); 2424 PrevInstLoc = DL; 2425 LabelsBeforeInsn[MI] = PrevLabel; 2426 return; 2427 } 2428 2429 // If location is unknown then use temp label for this DBG_VALUE 2430 // instruction. 2431 if (MI->isDebugValue()) { 2432 PrevLabel = MMI->getContext().CreateTempSymbol(); 2433 Asm->OutStreamer.EmitLabel(PrevLabel); 2434 LabelsBeforeInsn[MI] = PrevLabel; 2435 return; 2436 } 2437 2438 if (UnknownLocations) { 2439 PrevLabel = recordSourceLine(0, 0, 0); 2440 LabelsBeforeInsn[MI] = PrevLabel; 2441 return; 2442 } 2443 2444 assert (0 && "Instruction is not processed!"); 2445} 2446 2447/// endScope - Process end of a scope. 2448void DwarfDebug::endScope(const MachineInstr *MI) { 2449 if (InsnsEndScopeSet.count(MI) != 0) { 2450 // Emit a label if this instruction ends a scope. 2451 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2452 Asm->OutStreamer.EmitLabel(Label); 2453 LabelsAfterInsn[MI] = Label; 2454 } 2455} 2456 2457/// getOrCreateDbgScope - Create DbgScope for the scope. 2458DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, 2459 const MDNode *InlinedAt) { 2460 if (!InlinedAt) { 2461 DbgScope *WScope = DbgScopeMap.lookup(Scope); 2462 if (WScope) 2463 return WScope; 2464 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL); 2465 DbgScopeMap.insert(std::make_pair(Scope, WScope)); 2466 if (DIDescriptor(Scope).isLexicalBlock()) { 2467 DbgScope *Parent = 2468 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL); 2469 WScope->setParent(Parent); 2470 Parent->addScope(WScope); 2471 } 2472 2473 if (!WScope->getParent()) { 2474 StringRef SPName = DISubprogram(Scope).getLinkageName(); 2475 // We used to check only for a linkage name, but that fails 2476 // since we began omitting the linkage name for private 2477 // functions. The new way is to check for the name in metadata, 2478 // but that's not supported in old .ll test cases. Ergo, we 2479 // check both. 2480 if (SPName == Asm->MF->getFunction()->getName() || 2481 DISubprogram(Scope).getFunction() == Asm->MF->getFunction()) 2482 CurrentFnDbgScope = WScope; 2483 } 2484 2485 return WScope; 2486 } 2487 2488 getOrCreateAbstractScope(Scope); 2489 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt); 2490 if (WScope) 2491 return WScope; 2492 2493 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt); 2494 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope)); 2495 DILocation DL(InlinedAt); 2496 DbgScope *Parent = 2497 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation()); 2498 WScope->setParent(Parent); 2499 Parent->addScope(WScope); 2500 2501 ConcreteScopes[InlinedAt] = WScope; 2502 2503 return WScope; 2504} 2505 2506/// hasValidLocation - Return true if debug location entry attached with 2507/// machine instruction encodes valid location info. 2508static bool hasValidLocation(LLVMContext &Ctx, 2509 const MachineInstr *MInsn, 2510 const MDNode *&Scope, const MDNode *&InlinedAt) { 2511 DebugLoc DL = MInsn->getDebugLoc(); 2512 if (DL.isUnknown()) return false; 2513 2514 const MDNode *S = DL.getScope(Ctx); 2515 2516 // There is no need to create another DIE for compile unit. For all 2517 // other scopes, create one DbgScope now. This will be translated 2518 // into a scope DIE at the end. 2519 if (DIScope(S).isCompileUnit()) return false; 2520 2521 Scope = S; 2522 InlinedAt = DL.getInlinedAt(Ctx); 2523 return true; 2524} 2525 2526/// calculateDominanceGraph - Calculate dominance graph for DbgScope 2527/// hierarchy. 2528static void calculateDominanceGraph(DbgScope *Scope) { 2529 assert (Scope && "Unable to calculate scop edominance graph!"); 2530 SmallVector<DbgScope *, 4> WorkStack; 2531 WorkStack.push_back(Scope); 2532 unsigned Counter = 0; 2533 while (!WorkStack.empty()) { 2534 DbgScope *WS = WorkStack.back(); 2535 const SmallVector<DbgScope *, 4> &Children = WS->getScopes(); 2536 bool visitedChildren = false; 2537 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2538 SE = Children.end(); SI != SE; ++SI) { 2539 DbgScope *ChildScope = *SI; 2540 if (!ChildScope->getDFSOut()) { 2541 WorkStack.push_back(ChildScope); 2542 visitedChildren = true; 2543 ChildScope->setDFSIn(++Counter); 2544 break; 2545 } 2546 } 2547 if (!visitedChildren) { 2548 WorkStack.pop_back(); 2549 WS->setDFSOut(++Counter); 2550 } 2551 } 2552} 2553 2554/// printDbgScopeInfo - Print DbgScope info for each machine instruction. 2555static 2556void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF, 2557 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap) 2558{ 2559#ifndef NDEBUG 2560 unsigned PrevDFSIn = 0; 2561 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2562 I != E; ++I) { 2563 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2564 II != IE; ++II) { 2565 const MachineInstr *MInsn = II; 2566 const MDNode *Scope = NULL; 2567 const MDNode *InlinedAt = NULL; 2568 2569 // Check if instruction has valid location information. 2570 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2571 dbgs() << " [ "; 2572 if (InlinedAt) 2573 dbgs() << "*"; 2574 DenseMap<const MachineInstr *, DbgScope *>::iterator DI = 2575 MI2ScopeMap.find(MInsn); 2576 if (DI != MI2ScopeMap.end()) { 2577 DbgScope *S = DI->second; 2578 dbgs() << S->getDFSIn(); 2579 PrevDFSIn = S->getDFSIn(); 2580 } else 2581 dbgs() << PrevDFSIn; 2582 } else 2583 dbgs() << " [ x" << PrevDFSIn; 2584 dbgs() << " ]"; 2585 MInsn->dump(); 2586 } 2587 dbgs() << "\n"; 2588 } 2589#endif 2590} 2591/// extractScopeInformation - Scan machine instructions in this function 2592/// and collect DbgScopes. Return true, if at least one scope was found. 2593bool DwarfDebug::extractScopeInformation() { 2594 // If scope information was extracted using .dbg intrinsics then there is not 2595 // any need to extract these information by scanning each instruction. 2596 if (!DbgScopeMap.empty()) 2597 return false; 2598 2599 // Scan each instruction and create scopes. First build working set of scopes. 2600 LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2601 SmallVector<DbgRange, 4> MIRanges; 2602 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap; 2603 const MDNode *PrevScope = NULL; 2604 const MDNode *PrevInlinedAt = NULL; 2605 const MachineInstr *RangeBeginMI = NULL; 2606 const MachineInstr *PrevMI = NULL; 2607 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 2608 I != E; ++I) { 2609 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2610 II != IE; ++II) { 2611 const MachineInstr *MInsn = II; 2612 const MDNode *Scope = NULL; 2613 const MDNode *InlinedAt = NULL; 2614 2615 // Check if instruction has valid location information. 2616 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2617 PrevMI = MInsn; 2618 continue; 2619 } 2620 2621 // If scope has not changed then skip this instruction. 2622 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) { 2623 PrevMI = MInsn; 2624 continue; 2625 } 2626 2627 if (RangeBeginMI) { 2628 // If we have alread seen a beginning of a instruction range and 2629 // current instruction scope does not match scope of first instruction 2630 // in this range then create a new instruction range. 2631 DbgRange R(RangeBeginMI, PrevMI); 2632 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, 2633 PrevInlinedAt); 2634 MIRanges.push_back(R); 2635 } 2636 2637 // This is a beginning of a new instruction range. 2638 RangeBeginMI = MInsn; 2639 2640 // Reset previous markers. 2641 PrevMI = MInsn; 2642 PrevScope = Scope; 2643 PrevInlinedAt = InlinedAt; 2644 } 2645 } 2646 2647 // Create last instruction range. 2648 if (RangeBeginMI && PrevMI && PrevScope) { 2649 DbgRange R(RangeBeginMI, PrevMI); 2650 MIRanges.push_back(R); 2651 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt); 2652 } 2653 2654 if (!CurrentFnDbgScope) 2655 return false; 2656 2657 calculateDominanceGraph(CurrentFnDbgScope); 2658 if (PrintDbgScope) 2659 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap); 2660 2661 // Find ranges of instructions covered by each DbgScope; 2662 DbgScope *PrevDbgScope = NULL; 2663 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(), 2664 RE = MIRanges.end(); RI != RE; ++RI) { 2665 const DbgRange &R = *RI; 2666 DbgScope *S = MI2ScopeMap.lookup(R.first); 2667 assert (S && "Lost DbgScope for a machine instruction!"); 2668 if (PrevDbgScope && !PrevDbgScope->dominates(S)) 2669 PrevDbgScope->closeInsnRange(S); 2670 S->openInsnRange(R.first); 2671 S->extendInsnRange(R.second); 2672 PrevDbgScope = S; 2673 } 2674 2675 if (PrevDbgScope) 2676 PrevDbgScope->closeInsnRange(); 2677 2678 identifyScopeMarkers(); 2679 2680 return !DbgScopeMap.empty(); 2681} 2682 2683/// identifyScopeMarkers() - 2684/// Each DbgScope has first instruction and last instruction to mark beginning 2685/// and end of a scope respectively. Create an inverse map that list scopes 2686/// starts (and ends) with an instruction. One instruction may start (or end) 2687/// multiple scopes. Ignore scopes that are not reachable. 2688void DwarfDebug::identifyScopeMarkers() { 2689 SmallVector<DbgScope *, 4> WorkList; 2690 WorkList.push_back(CurrentFnDbgScope); 2691 while (!WorkList.empty()) { 2692 DbgScope *S = WorkList.pop_back_val(); 2693 2694 const SmallVector<DbgScope *, 4> &Children = S->getScopes(); 2695 if (!Children.empty()) 2696 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2697 SE = Children.end(); SI != SE; ++SI) 2698 WorkList.push_back(*SI); 2699 2700 if (S->isAbstractScope()) 2701 continue; 2702 2703 const SmallVector<DbgRange, 4> &Ranges = S->getRanges(); 2704 if (Ranges.empty()) 2705 continue; 2706 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 2707 RE = Ranges.end(); RI != RE; ++RI) { 2708 assert(RI->first && "DbgRange does not have first instruction!"); 2709 assert(RI->second && "DbgRange does not have second instruction!"); 2710 InsnsEndScopeSet.insert(RI->second); 2711 } 2712 } 2713} 2714 2715/// FindFirstDebugLoc - Find the first debug location in the function. This 2716/// is intended to be an approximation for the source position of the 2717/// beginning of the function. 2718static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) { 2719 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2720 I != E; ++I) 2721 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end(); 2722 MBBI != MBBE; ++MBBI) { 2723 DebugLoc DL = MBBI->getDebugLoc(); 2724 if (!DL.isUnknown()) 2725 return DL; 2726 } 2727 return DebugLoc(); 2728} 2729 2730/// beginFunction - Gather pre-function debug information. Assumes being 2731/// emitted immediately after the function entry point. 2732void DwarfDebug::beginFunction(const MachineFunction *MF) { 2733 if (!MMI->hasDebugInfo()) return; 2734 if (!extractScopeInformation()) return; 2735 2736 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 2737 Asm->getFunctionNumber()); 2738 // Assumes in correct section after the entry point. 2739 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 2740 2741 // Emit label for the implicitly defined dbg.stoppoint at the start of the 2742 // function. 2743 DebugLoc FDL = FindFirstDebugLoc(MF); 2744 if (FDL.isUnknown()) return; 2745 2746 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext()); 2747 const MDNode *TheScope = 0; 2748 2749 DISubprogram SP = getDISubprogram(Scope); 2750 unsigned Line, Col; 2751 if (SP.Verify()) { 2752 Line = SP.getLineNumber(); 2753 Col = 0; 2754 TheScope = SP; 2755 } else { 2756 Line = FDL.getLine(); 2757 Col = FDL.getCol(); 2758 TheScope = Scope; 2759 } 2760 2761 recordSourceLine(Line, Col, TheScope); 2762 2763 /// ProcessedArgs - Collection of arguments already processed. 2764 SmallPtrSet<const MDNode *, 8> ProcessedArgs; 2765 2766 DebugLoc PrevLoc; 2767 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2768 I != E; ++I) 2769 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2770 II != IE; ++II) { 2771 const MachineInstr *MI = II; 2772 DebugLoc DL = MI->getDebugLoc(); 2773 if (MI->isDebugValue()) { 2774 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!"); 2775 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata()); 2776 if (!DV.Verify()) continue; 2777 // If DBG_VALUE is for a local variable then it needs a label. 2778 if (DV.getTag() != dwarf::DW_TAG_arg_variable 2779 && isDbgValueInUndefinedReg(MI) == false) 2780 InsnNeedsLabel.insert(MI); 2781 // DBG_VALUE for inlined functions argument needs a label. 2782 else if (!DISubprogram(getDISubprogram(DV.getContext())). 2783 describes(MF->getFunction())) 2784 InsnNeedsLabel.insert(MI); 2785 // DBG_VALUE indicating argument location change needs a label. 2786 else if (isDbgValueInUndefinedReg(MI) == false 2787 && !ProcessedArgs.insert(DV)) 2788 InsnNeedsLabel.insert(MI); 2789 } else { 2790 // If location is unknown then instruction needs a location only if 2791 // UnknownLocations flag is set. 2792 if (DL.isUnknown()) { 2793 if (UnknownLocations && !PrevLoc.isUnknown()) 2794 InsnNeedsLabel.insert(MI); 2795 } else if (DL != PrevLoc) 2796 // Otherwise, instruction needs a location only if it is new location. 2797 InsnNeedsLabel.insert(MI); 2798 } 2799 2800 if (!DL.isUnknown() || UnknownLocations) 2801 PrevLoc = DL; 2802 } 2803 2804 PrevLabel = FunctionBeginSym; 2805} 2806 2807/// endFunction - Gather and emit post-function debug information. 2808/// 2809void DwarfDebug::endFunction(const MachineFunction *MF) { 2810 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return; 2811 2812 if (CurrentFnDbgScope) { 2813 2814 // Define end label for subprogram. 2815 FunctionEndSym = Asm->GetTempSymbol("func_end", 2816 Asm->getFunctionNumber()); 2817 // Assumes in correct section after the entry point. 2818 Asm->OutStreamer.EmitLabel(FunctionEndSym); 2819 2820 SmallPtrSet<const MDNode *, 16> ProcessedVars; 2821 collectVariableInfo(MF, ProcessedVars); 2822 2823 // Get function line info. 2824 if (!Lines.empty()) { 2825 // Get section line info. 2826 unsigned ID = SectionMap.insert(Asm->getCurrentSection()); 2827 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID); 2828 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1]; 2829 // Append the function info to section info. 2830 SectionLineInfos.insert(SectionLineInfos.end(), 2831 Lines.begin(), Lines.end()); 2832 } 2833 2834 // Construct abstract scopes. 2835 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2836 AE = AbstractScopesList.end(); AI != AE; ++AI) { 2837 DISubprogram SP((*AI)->getScopeNode()); 2838 if (SP.Verify()) { 2839 // Collect info for variables that were optimized out. 2840 StringRef FName = SP.getLinkageName(); 2841 if (FName.empty()) 2842 FName = SP.getName(); 2843 const Module *M = MF->getFunction()->getParent(); 2844 if (NamedMDNode *NMD = 2845 M->getNamedMetadata(Twine("llvm.dbg.lv.", 2846 getRealLinkageName(FName)))) { 2847 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2848 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 2849 if (!DV || !ProcessedVars.insert(DV)) 2850 continue; 2851 DbgScope *Scope = AbstractScopes.lookup(DV.getContext()); 2852 if (Scope) 2853 Scope->addVariable(new DbgVariable(DV)); 2854 } 2855 } 2856 } 2857 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0) 2858 constructScopeDIE(*AI); 2859 } 2860 2861 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope); 2862 2863 if (!DisableFramePointerElim(*MF)) 2864 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr, 2865 dwarf::DW_FORM_flag, 1); 2866 2867 2868 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(), 2869 MMI->getFrameMoves())); 2870 } 2871 2872 // Clear debug info 2873 CurrentFnDbgScope = NULL; 2874 InsnNeedsLabel.clear(); 2875 DbgVariableToFrameIndexMap.clear(); 2876 VarToAbstractVarMap.clear(); 2877 DbgVariableToDbgInstMap.clear(); 2878 DbgVariableLabelsMap.clear(); 2879 DeleteContainerSeconds(DbgScopeMap); 2880 InsnsEndScopeSet.clear(); 2881 ConcreteScopes.clear(); 2882 DeleteContainerSeconds(AbstractScopes); 2883 AbstractScopesList.clear(); 2884 AbstractVariables.clear(); 2885 LabelsBeforeInsn.clear(); 2886 LabelsAfterInsn.clear(); 2887 Lines.clear(); 2888 PrevLabel = NULL; 2889} 2890 2891/// recordVariableFrameIndex - Record a variable's index. 2892void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) { 2893 assert (V && "Invalid DbgVariable!"); 2894 DbgVariableToFrameIndexMap[V] = Index; 2895} 2896 2897/// findVariableFrameIndex - Return true if frame index for the variable 2898/// is found. Update FI to hold value of the index. 2899bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) { 2900 assert (V && "Invalid DbgVariable!"); 2901 DenseMap<const DbgVariable *, int>::iterator I = 2902 DbgVariableToFrameIndexMap.find(V); 2903 if (I == DbgVariableToFrameIndexMap.end()) 2904 return false; 2905 *FI = I->second; 2906 return true; 2907} 2908 2909/// findVariableLabel - Find MCSymbol for the variable. 2910const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) { 2911 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I 2912 = DbgVariableLabelsMap.find(V); 2913 if (I == DbgVariableLabelsMap.end()) 2914 return NULL; 2915 else return I->second; 2916} 2917 2918/// findDbgScope - Find DbgScope for the debug loc attached with an 2919/// instruction. 2920DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) { 2921 DbgScope *Scope = NULL; 2922 LLVMContext &Ctx = 2923 MInsn->getParent()->getParent()->getFunction()->getContext(); 2924 DebugLoc DL = MInsn->getDebugLoc(); 2925 2926 if (DL.isUnknown()) 2927 return Scope; 2928 2929 if (const MDNode *IA = DL.getInlinedAt(Ctx)) 2930 Scope = ConcreteScopes.lookup(IA); 2931 if (Scope == 0) 2932 Scope = DbgScopeMap.lookup(DL.getScope(Ctx)); 2933 2934 return Scope; 2935} 2936 2937 2938/// recordSourceLine - Register a source line with debug info. Returns the 2939/// unique label that was emitted and which provides correspondence to 2940/// the source line list. 2941MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, 2942 const MDNode *S) { 2943 StringRef Dir; 2944 StringRef Fn; 2945 2946 unsigned Src = 1; 2947 if (S) { 2948 DIDescriptor Scope(S); 2949 2950 if (Scope.isCompileUnit()) { 2951 DICompileUnit CU(S); 2952 Dir = CU.getDirectory(); 2953 Fn = CU.getFilename(); 2954 } else if (Scope.isSubprogram()) { 2955 DISubprogram SP(S); 2956 Dir = SP.getDirectory(); 2957 Fn = SP.getFilename(); 2958 } else if (Scope.isLexicalBlock()) { 2959 DILexicalBlock DB(S); 2960 Dir = DB.getDirectory(); 2961 Fn = DB.getFilename(); 2962 } else 2963 assert(0 && "Unexpected scope info"); 2964 2965 Src = GetOrCreateSourceID(Dir, Fn); 2966 } 2967 2968 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2969 Lines.push_back(SrcLineInfo(Line, Col, Src, Label)); 2970 2971 Asm->OutStreamer.EmitLabel(Label); 2972 return Label; 2973} 2974 2975//===----------------------------------------------------------------------===// 2976// Emit Methods 2977//===----------------------------------------------------------------------===// 2978 2979/// computeSizeAndOffset - Compute the size and offset of a DIE. 2980/// 2981unsigned 2982DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) { 2983 // Get the children. 2984 const std::vector<DIE *> &Children = Die->getChildren(); 2985 2986 // If not last sibling and has children then add sibling offset attribute. 2987 if (!Last && !Children.empty()) 2988 Die->addSiblingOffset(DIEValueAllocator); 2989 2990 // Record the abbreviation. 2991 assignAbbrevNumber(Die->getAbbrev()); 2992 2993 // Get the abbreviation for this DIE. 2994 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2995 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2996 2997 // Set DIE offset 2998 Die->setOffset(Offset); 2999 3000 // Start the size with the size of abbreviation code. 3001 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 3002 3003 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 3004 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 3005 3006 // Size the DIE attribute values. 3007 for (unsigned i = 0, N = Values.size(); i < N; ++i) 3008 // Size attribute value. 3009 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm()); 3010 3011 // Size the DIE children if any. 3012 if (!Children.empty()) { 3013 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 3014 "Children flag not set"); 3015 3016 for (unsigned j = 0, M = Children.size(); j < M; ++j) 3017 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M); 3018 3019 // End of children marker. 3020 Offset += sizeof(int8_t); 3021 } 3022 3023 Die->setSize(Offset - Die->getOffset()); 3024 return Offset; 3025} 3026 3027/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 3028/// 3029void DwarfDebug::computeSizeAndOffsets() { 3030 unsigned PrevOffset = 0; 3031 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3032 E = CUMap.end(); I != E; ++I) { 3033 // Compute size of compile unit header. 3034 static unsigned Offset = PrevOffset + 3035 sizeof(int32_t) + // Length of Compilation Unit Info 3036 sizeof(int16_t) + // DWARF version number 3037 sizeof(int32_t) + // Offset Into Abbrev. Section 3038 sizeof(int8_t); // Pointer Size (in bytes) 3039 computeSizeAndOffset(I->second->getCUDie(), Offset, true); 3040 PrevOffset = Offset; 3041 } 3042} 3043 3044/// EmitSectionSym - Switch to the specified MCSection and emit an assembler 3045/// temporary label to it if SymbolStem is specified. 3046static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section, 3047 const char *SymbolStem = 0) { 3048 Asm->OutStreamer.SwitchSection(Section); 3049 if (!SymbolStem) return 0; 3050 3051 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem); 3052 Asm->OutStreamer.EmitLabel(TmpSym); 3053 return TmpSym; 3054} 3055 3056/// EmitSectionLabels - Emit initial Dwarf sections with a label at 3057/// the start of each one. 3058void DwarfDebug::EmitSectionLabels() { 3059 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 3060 3061 // Dwarf sections base addresses. 3062 if (Asm->MAI->doesDwarfRequireFrameSection()) { 3063 DwarfFrameSectionSym = 3064 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame"); 3065 } 3066 3067 DwarfInfoSectionSym = 3068 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 3069 DwarfAbbrevSectionSym = 3070 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 3071 EmitSectionSym(Asm, TLOF.getDwarfARangesSection()); 3072 3073 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 3074 EmitSectionSym(Asm, MacroInfo); 3075 3076 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line"); 3077 EmitSectionSym(Asm, TLOF.getDwarfLocSection()); 3078 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 3079 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 3080 DwarfStrSectionSym = 3081 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str"); 3082 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(), 3083 "debug_range"); 3084 3085 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(), 3086 "section_debug_loc"); 3087 3088 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 3089 EmitSectionSym(Asm, TLOF.getDataSection()); 3090} 3091 3092/// emitDIE - Recusively Emits a debug information entry. 3093/// 3094void DwarfDebug::emitDIE(DIE *Die) { 3095 // Get the abbreviation for this DIE. 3096 unsigned AbbrevNumber = Die->getAbbrevNumber(); 3097 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 3098 3099 // Emit the code (index) for the abbreviation. 3100 if (Asm->isVerbose()) 3101 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 3102 Twine::utohexstr(Die->getOffset()) + ":0x" + 3103 Twine::utohexstr(Die->getSize()) + " " + 3104 dwarf::TagString(Abbrev->getTag())); 3105 Asm->EmitULEB128(AbbrevNumber); 3106 3107 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 3108 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 3109 3110 // Emit the DIE attribute values. 3111 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 3112 unsigned Attr = AbbrevData[i].getAttribute(); 3113 unsigned Form = AbbrevData[i].getForm(); 3114 assert(Form && "Too many attributes for DIE (check abbreviation)"); 3115 3116 if (Asm->isVerbose()) 3117 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 3118 3119 switch (Attr) { 3120 case dwarf::DW_AT_sibling: 3121 Asm->EmitInt32(Die->getSiblingOffset()); 3122 break; 3123 case dwarf::DW_AT_abstract_origin: { 3124 DIEEntry *E = cast<DIEEntry>(Values[i]); 3125 DIE *Origin = E->getEntry(); 3126 unsigned Addr = Origin->getOffset(); 3127 Asm->EmitInt32(Addr); 3128 break; 3129 } 3130 case dwarf::DW_AT_ranges: { 3131 // DW_AT_range Value encodes offset in debug_range section. 3132 DIEInteger *V = cast<DIEInteger>(Values[i]); 3133 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym, 3134 V->getValue(), 3135 DwarfDebugRangeSectionSym, 3136 4); 3137 break; 3138 } 3139 case dwarf::DW_AT_location: { 3140 if (UseDotDebugLocEntry.count(Die) != 0) { 3141 DIELabel *L = cast<DIELabel>(Values[i]); 3142 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4); 3143 } else 3144 Values[i]->EmitValue(Asm, Form); 3145 break; 3146 } 3147 default: 3148 // Emit an attribute using the defined form. 3149 Values[i]->EmitValue(Asm, Form); 3150 break; 3151 } 3152 } 3153 3154 // Emit the DIE children if any. 3155 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 3156 const std::vector<DIE *> &Children = Die->getChildren(); 3157 3158 for (unsigned j = 0, M = Children.size(); j < M; ++j) 3159 emitDIE(Children[j]); 3160 3161 if (Asm->isVerbose()) 3162 Asm->OutStreamer.AddComment("End Of Children Mark"); 3163 Asm->EmitInt8(0); 3164 } 3165} 3166 3167/// emitDebugInfo - Emit the debug info section. 3168/// 3169void DwarfDebug::emitDebugInfo() { 3170 // Start debug info section. 3171 Asm->OutStreamer.SwitchSection( 3172 Asm->getObjFileLowering().getDwarfInfoSection()); 3173 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3174 E = CUMap.end(); I != E; ++I) { 3175 CompileUnit *TheCU = I->second; 3176 DIE *Die = TheCU->getCUDie(); 3177 3178 // Emit the compile units header. 3179 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin", 3180 TheCU->getID())); 3181 3182 // Emit size of content not including length itself 3183 unsigned ContentSize = Die->getSize() + 3184 sizeof(int16_t) + // DWARF version number 3185 sizeof(int32_t) + // Offset Into Abbrev. Section 3186 sizeof(int8_t) + // Pointer Size (in bytes) 3187 sizeof(int32_t); // FIXME - extra pad for gdb bug. 3188 3189 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 3190 Asm->EmitInt32(ContentSize); 3191 Asm->OutStreamer.AddComment("DWARF version number"); 3192 Asm->EmitInt16(dwarf::DWARF_VERSION); 3193 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 3194 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"), 3195 DwarfAbbrevSectionSym); 3196 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 3197 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 3198 3199 emitDIE(Die); 3200 // FIXME - extra padding for gdb bug. 3201 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB"); 3202 Asm->EmitInt8(0); 3203 Asm->EmitInt8(0); 3204 Asm->EmitInt8(0); 3205 Asm->EmitInt8(0); 3206 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID())); 3207 } 3208} 3209 3210/// emitAbbreviations - Emit the abbreviation section. 3211/// 3212void DwarfDebug::emitAbbreviations() const { 3213 // Check to see if it is worth the effort. 3214 if (!Abbreviations.empty()) { 3215 // Start the debug abbrev section. 3216 Asm->OutStreamer.SwitchSection( 3217 Asm->getObjFileLowering().getDwarfAbbrevSection()); 3218 3219 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin")); 3220 3221 // For each abbrevation. 3222 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 3223 // Get abbreviation data 3224 const DIEAbbrev *Abbrev = Abbreviations[i]; 3225 3226 // Emit the abbrevations code (base 1 index.) 3227 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 3228 3229 // Emit the abbreviations data. 3230 Abbrev->Emit(Asm); 3231 } 3232 3233 // Mark end of abbreviations. 3234 Asm->EmitULEB128(0, "EOM(3)"); 3235 3236 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end")); 3237 } 3238} 3239 3240/// emitEndOfLineMatrix - Emit the last address of the section and the end of 3241/// the line matrix. 3242/// 3243void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 3244 // Define last address of section. 3245 Asm->OutStreamer.AddComment("Extended Op"); 3246 Asm->EmitInt8(0); 3247 3248 Asm->OutStreamer.AddComment("Op size"); 3249 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1); 3250 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 3251 Asm->EmitInt8(dwarf::DW_LNE_set_address); 3252 3253 Asm->OutStreamer.AddComment("Section end label"); 3254 3255 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 3256 Asm->getTargetData().getPointerSize(), 3257 0/*AddrSpace*/); 3258 3259 // Mark end of matrix. 3260 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 3261 Asm->EmitInt8(0); 3262 Asm->EmitInt8(1); 3263 Asm->EmitInt8(1); 3264} 3265 3266/// emitDebugLines - Emit source line information. 3267/// 3268void DwarfDebug::emitDebugLines() { 3269 // If the target is using .loc/.file, the assembler will be emitting the 3270 // .debug_line table automatically. 3271 if (Asm->MAI->hasDotLocAndDotFile()) 3272 return; 3273 3274 // Minimum line delta, thus ranging from -10..(255-10). 3275 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1); 3276 // Maximum line delta, thus ranging from -10..(255-10). 3277 const int MaxLineDelta = 255 + MinLineDelta; 3278 3279 // Start the dwarf line section. 3280 Asm->OutStreamer.SwitchSection( 3281 Asm->getObjFileLowering().getDwarfLineSection()); 3282 3283 // Construct the section header. 3284 Asm->OutStreamer.AddComment("Length of Source Line Info"); 3285 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"), 3286 Asm->GetTempSymbol("line_begin"), 4); 3287 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin")); 3288 3289 Asm->OutStreamer.AddComment("DWARF version number"); 3290 Asm->EmitInt16(dwarf::DWARF_VERSION); 3291 3292 Asm->OutStreamer.AddComment("Prolog Length"); 3293 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"), 3294 Asm->GetTempSymbol("line_prolog_begin"), 4); 3295 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin")); 3296 3297 Asm->OutStreamer.AddComment("Minimum Instruction Length"); 3298 Asm->EmitInt8(1); 3299 Asm->OutStreamer.AddComment("Default is_stmt_start flag"); 3300 Asm->EmitInt8(1); 3301 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)"); 3302 Asm->EmitInt8(MinLineDelta); 3303 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)"); 3304 Asm->EmitInt8(MaxLineDelta); 3305 Asm->OutStreamer.AddComment("Special Opcode Base"); 3306 Asm->EmitInt8(-MinLineDelta); 3307 3308 // Line number standard opcode encodings argument count 3309 Asm->OutStreamer.AddComment("DW_LNS_copy arg count"); 3310 Asm->EmitInt8(0); 3311 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count"); 3312 Asm->EmitInt8(1); 3313 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count"); 3314 Asm->EmitInt8(1); 3315 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count"); 3316 Asm->EmitInt8(1); 3317 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count"); 3318 Asm->EmitInt8(1); 3319 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count"); 3320 Asm->EmitInt8(0); 3321 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count"); 3322 Asm->EmitInt8(0); 3323 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count"); 3324 Asm->EmitInt8(0); 3325 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count"); 3326 Asm->EmitInt8(1); 3327 3328 // Emit directories. 3329 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) { 3330 const std::string &Dir = getSourceDirectoryName(DI); 3331 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory"); 3332 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0); 3333 } 3334 3335 Asm->OutStreamer.AddComment("End of directories"); 3336 Asm->EmitInt8(0); 3337 3338 // Emit files. 3339 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) { 3340 // Remember source id starts at 1. 3341 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI); 3342 const std::string &FN = getSourceFileName(Id.second); 3343 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source"); 3344 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0); 3345 3346 Asm->EmitULEB128(Id.first, "Directory #"); 3347 Asm->EmitULEB128(0, "Mod date"); 3348 Asm->EmitULEB128(0, "File size"); 3349 } 3350 3351 Asm->OutStreamer.AddComment("End of files"); 3352 Asm->EmitInt8(0); 3353 3354 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end")); 3355 3356 // A sequence for each text section. 3357 unsigned SecSrcLinesSize = SectionSourceLines.size(); 3358 3359 for (unsigned j = 0; j < SecSrcLinesSize; ++j) { 3360 // Isolate current sections line info. 3361 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j]; 3362 3363 // Dwarf assumes we start with first line of first source file. 3364 unsigned Source = 1; 3365 unsigned Line = 1; 3366 3367 // Construct rows of the address, source, line, column matrix. 3368 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) { 3369 const SrcLineInfo &LineInfo = LineInfos[i]; 3370 MCSymbol *Label = LineInfo.getLabel(); 3371 if (!Label->isDefined()) continue; // Not emitted, in dead code. 3372 3373 if (Asm->isVerbose()) { 3374 std::pair<unsigned, unsigned> SrcID = 3375 getSourceDirectoryAndFileIds(LineInfo.getSourceID()); 3376 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) + 3377 "/" + 3378 Twine(getSourceFileName(SrcID.second)) + 3379 ":" + Twine(LineInfo.getLine())); 3380 } 3381 3382 // Define the line address. 3383 Asm->OutStreamer.AddComment("Extended Op"); 3384 Asm->EmitInt8(0); 3385 Asm->OutStreamer.AddComment("Op size"); 3386 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1); 3387 3388 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 3389 Asm->EmitInt8(dwarf::DW_LNE_set_address); 3390 3391 Asm->OutStreamer.AddComment("Location label"); 3392 Asm->OutStreamer.EmitSymbolValue(Label, 3393 Asm->getTargetData().getPointerSize(), 3394 0/*AddrSpace*/); 3395 3396 // If change of source, then switch to the new source. 3397 if (Source != LineInfo.getSourceID()) { 3398 Source = LineInfo.getSourceID(); 3399 Asm->OutStreamer.AddComment("DW_LNS_set_file"); 3400 Asm->EmitInt8(dwarf::DW_LNS_set_file); 3401 Asm->EmitULEB128(Source, "New Source"); 3402 } 3403 3404 // If change of line. 3405 if (Line != LineInfo.getLine()) { 3406 // Determine offset. 3407 int Offset = LineInfo.getLine() - Line; 3408 int Delta = Offset - MinLineDelta; 3409 3410 // Update line. 3411 Line = LineInfo.getLine(); 3412 3413 // If delta is small enough and in range... 3414 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { 3415 // ... then use fast opcode. 3416 Asm->OutStreamer.AddComment("Line Delta"); 3417 Asm->EmitInt8(Delta - MinLineDelta); 3418 } else { 3419 // ... otherwise use long hand. 3420 Asm->OutStreamer.AddComment("DW_LNS_advance_line"); 3421 Asm->EmitInt8(dwarf::DW_LNS_advance_line); 3422 Asm->EmitSLEB128(Offset, "Line Offset"); 3423 Asm->OutStreamer.AddComment("DW_LNS_copy"); 3424 Asm->EmitInt8(dwarf::DW_LNS_copy); 3425 } 3426 } else { 3427 // Copy the previous row (different address or source) 3428 Asm->OutStreamer.AddComment("DW_LNS_copy"); 3429 Asm->EmitInt8(dwarf::DW_LNS_copy); 3430 } 3431 } 3432 3433 emitEndOfLineMatrix(j + 1); 3434 } 3435 3436 if (SecSrcLinesSize == 0) 3437 // Because we're emitting a debug_line section, we still need a line 3438 // table. The linker and friends expect it to exist. If there's nothing to 3439 // put into it, emit an empty table. 3440 emitEndOfLineMatrix(1); 3441 3442 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end")); 3443} 3444 3445/// emitCommonDebugFrame - Emit common frame info into a debug frame section. 3446/// 3447void DwarfDebug::emitCommonDebugFrame() { 3448 if (!Asm->MAI->doesDwarfRequireFrameSection()) 3449 return; 3450 3451 int stackGrowth = Asm->getTargetData().getPointerSize(); 3452 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() == 3453 TargetFrameInfo::StackGrowsDown) 3454 stackGrowth *= -1; 3455 3456 // Start the dwarf frame section. 3457 Asm->OutStreamer.SwitchSection( 3458 Asm->getObjFileLowering().getDwarfFrameSection()); 3459 3460 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common")); 3461 Asm->OutStreamer.AddComment("Length of Common Information Entry"); 3462 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"), 3463 Asm->GetTempSymbol("debug_frame_common_begin"), 4); 3464 3465 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin")); 3466 Asm->OutStreamer.AddComment("CIE Identifier Tag"); 3467 Asm->EmitInt32((int)dwarf::DW_CIE_ID); 3468 Asm->OutStreamer.AddComment("CIE Version"); 3469 Asm->EmitInt8(dwarf::DW_CIE_VERSION); 3470 Asm->OutStreamer.AddComment("CIE Augmentation"); 3471 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator. 3472 Asm->EmitULEB128(1, "CIE Code Alignment Factor"); 3473 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor"); 3474 Asm->OutStreamer.AddComment("CIE RA Column"); 3475 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 3476 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); 3477 3478 std::vector<MachineMove> Moves; 3479 RI->getInitialFrameState(Moves); 3480 3481 Asm->EmitFrameMoves(Moves, 0, false); 3482 3483 Asm->EmitAlignment(2); 3484 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end")); 3485} 3486 3487/// emitFunctionDebugFrame - Emit per function frame info into a debug frame 3488/// section. 3489void DwarfDebug:: 3490emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) { 3491 if (!Asm->MAI->doesDwarfRequireFrameSection()) 3492 return; 3493 3494 // Start the dwarf frame section. 3495 Asm->OutStreamer.SwitchSection( 3496 Asm->getObjFileLowering().getDwarfFrameSection()); 3497 3498 Asm->OutStreamer.AddComment("Length of Frame Information Entry"); 3499 MCSymbol *DebugFrameBegin = 3500 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number); 3501 MCSymbol *DebugFrameEnd = 3502 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number); 3503 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4); 3504 3505 Asm->OutStreamer.EmitLabel(DebugFrameBegin); 3506 3507 Asm->OutStreamer.AddComment("FDE CIE offset"); 3508 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"), 3509 DwarfFrameSectionSym); 3510 3511 Asm->OutStreamer.AddComment("FDE initial location"); 3512 MCSymbol *FuncBeginSym = 3513 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number); 3514 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym, 3515 Asm->getTargetData().getPointerSize(), 3516 0/*AddrSpace*/); 3517 3518 3519 Asm->OutStreamer.AddComment("FDE address range"); 3520 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number), 3521 FuncBeginSym, Asm->getTargetData().getPointerSize()); 3522 3523 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false); 3524 3525 Asm->EmitAlignment(2); 3526 Asm->OutStreamer.EmitLabel(DebugFrameEnd); 3527} 3528 3529/// emitDebugPubNames - Emit visible names into a debug pubnames section. 3530/// 3531void DwarfDebug::emitDebugPubNames() { 3532 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3533 E = CUMap.end(); I != E; ++I) { 3534 CompileUnit *TheCU = I->second; 3535 // Start the dwarf pubnames section. 3536 Asm->OutStreamer.SwitchSection( 3537 Asm->getObjFileLowering().getDwarfPubNamesSection()); 3538 3539 Asm->OutStreamer.AddComment("Length of Public Names Info"); 3540 Asm->EmitLabelDifference( 3541 Asm->GetTempSymbol("pubnames_end", TheCU->getID()), 3542 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4); 3543 3544 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", 3545 TheCU->getID())); 3546 3547 Asm->OutStreamer.AddComment("DWARF Version"); 3548 Asm->EmitInt16(dwarf::DWARF_VERSION); 3549 3550 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 3551 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 3552 DwarfInfoSectionSym); 3553 3554 Asm->OutStreamer.AddComment("Compilation Unit Length"); 3555 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 3556 Asm->GetTempSymbol("info_begin", TheCU->getID()), 3557 4); 3558 3559 const StringMap<DIE*> &Globals = TheCU->getGlobals(); 3560 for (StringMap<DIE*>::const_iterator 3561 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 3562 const char *Name = GI->getKeyData(); 3563 DIE *Entity = GI->second; 3564 3565 Asm->OutStreamer.AddComment("DIE offset"); 3566 Asm->EmitInt32(Entity->getOffset()); 3567 3568 if (Asm->isVerbose()) 3569 Asm->OutStreamer.AddComment("External Name"); 3570 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0); 3571 } 3572 3573 Asm->OutStreamer.AddComment("End Mark"); 3574 Asm->EmitInt32(0); 3575 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", 3576 TheCU->getID())); 3577 } 3578} 3579 3580void DwarfDebug::emitDebugPubTypes() { 3581 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3582 E = CUMap.end(); I != E; ++I) { 3583 CompileUnit *TheCU = I->second; 3584 // Start the dwarf pubnames section. 3585 Asm->OutStreamer.SwitchSection( 3586 Asm->getObjFileLowering().getDwarfPubTypesSection()); 3587 Asm->OutStreamer.AddComment("Length of Public Types Info"); 3588 Asm->EmitLabelDifference( 3589 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()), 3590 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4); 3591 3592 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 3593 TheCU->getID())); 3594 3595 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 3596 Asm->EmitInt16(dwarf::DWARF_VERSION); 3597 3598 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 3599 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 3600 DwarfInfoSectionSym); 3601 3602 Asm->OutStreamer.AddComment("Compilation Unit Length"); 3603 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 3604 Asm->GetTempSymbol("info_begin", TheCU->getID()), 3605 4); 3606 3607 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes(); 3608 for (StringMap<DIE*>::const_iterator 3609 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 3610 const char *Name = GI->getKeyData(); 3611 DIE * Entity = GI->second; 3612 3613 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 3614 Asm->EmitInt32(Entity->getOffset()); 3615 3616 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 3617 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0); 3618 } 3619 3620 Asm->OutStreamer.AddComment("End Mark"); 3621 Asm->EmitInt32(0); 3622 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 3623 TheCU->getID())); 3624 } 3625} 3626 3627/// emitDebugStr - Emit visible names into a debug str section. 3628/// 3629void DwarfDebug::emitDebugStr() { 3630 // Check to see if it is worth the effort. 3631 if (StringPool.empty()) return; 3632 3633 // Start the dwarf str section. 3634 Asm->OutStreamer.SwitchSection( 3635 Asm->getObjFileLowering().getDwarfStrSection()); 3636 3637 // Get all of the string pool entries and put them in an array by their ID so 3638 // we can sort them. 3639 SmallVector<std::pair<unsigned, 3640 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 3641 3642 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 3643 I = StringPool.begin(), E = StringPool.end(); I != E; ++I) 3644 Entries.push_back(std::make_pair(I->second.second, &*I)); 3645 3646 array_pod_sort(Entries.begin(), Entries.end()); 3647 3648 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 3649 // Emit a label for reference from debug information entries. 3650 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 3651 3652 // Emit the string itself. 3653 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/); 3654 } 3655} 3656 3657/// emitDebugLoc - Emit visible names into a debug loc section. 3658/// 3659void DwarfDebug::emitDebugLoc() { 3660 if (DotDebugLocEntries.empty()) 3661 return; 3662 3663 // Start the dwarf loc section. 3664 Asm->OutStreamer.SwitchSection( 3665 Asm->getObjFileLowering().getDwarfLocSection()); 3666 unsigned char Size = Asm->getTargetData().getPointerSize(); 3667 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0)); 3668 unsigned index = 1; 3669 for (SmallVector<DotDebugLocEntry, 4>::iterator 3670 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 3671 I != E; ++I, ++index) { 3672 DotDebugLocEntry Entry = *I; 3673 if (Entry.isEmpty()) { 3674 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3675 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3676 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index)); 3677 } else { 3678 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0); 3679 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0); 3680 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 3681 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false); 3682 if (int Offset = Entry.Loc.getOffset()) { 3683 // If the value is at a certain offset from frame register then 3684 // use DW_OP_fbreg. 3685 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1; 3686 Asm->OutStreamer.AddComment("Loc expr size"); 3687 Asm->EmitInt16(1 + OffsetSize); 3688 Asm->OutStreamer.AddComment( 3689 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg)); 3690 Asm->EmitInt8(dwarf::DW_OP_fbreg); 3691 Asm->OutStreamer.AddComment("Offset"); 3692 Asm->EmitSLEB128(Offset); 3693 } else { 3694 if (Reg < 32) { 3695 Asm->OutStreamer.AddComment("Loc expr size"); 3696 Asm->EmitInt16(1); 3697 Asm->OutStreamer.AddComment( 3698 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg)); 3699 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg); 3700 } else { 3701 Asm->OutStreamer.AddComment("Loc expr size"); 3702 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg)); 3703 Asm->EmitInt8(dwarf::DW_OP_regx); 3704 Asm->EmitULEB128(Reg); 3705 } 3706 } 3707 } 3708 } 3709} 3710 3711/// EmitDebugARanges - Emit visible names into a debug aranges section. 3712/// 3713void DwarfDebug::EmitDebugARanges() { 3714 // Start the dwarf aranges section. 3715 Asm->OutStreamer.SwitchSection( 3716 Asm->getObjFileLowering().getDwarfARangesSection()); 3717} 3718 3719/// emitDebugRanges - Emit visible names into a debug ranges section. 3720/// 3721void DwarfDebug::emitDebugRanges() { 3722 // Start the dwarf ranges section. 3723 Asm->OutStreamer.SwitchSection( 3724 Asm->getObjFileLowering().getDwarfRangesSection()); 3725 unsigned char Size = Asm->getTargetData().getPointerSize(); 3726 for (SmallVector<const MCSymbol *, 8>::iterator 3727 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end(); 3728 I != E; ++I) { 3729 if (*I) 3730 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0); 3731 else 3732 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3733 } 3734} 3735 3736/// emitDebugMacInfo - Emit visible names into a debug macinfo section. 3737/// 3738void DwarfDebug::emitDebugMacInfo() { 3739 if (const MCSection *LineInfo = 3740 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 3741 // Start the dwarf macinfo section. 3742 Asm->OutStreamer.SwitchSection(LineInfo); 3743 } 3744} 3745 3746/// emitDebugInlineInfo - Emit inline info using following format. 3747/// Section Header: 3748/// 1. length of section 3749/// 2. Dwarf version number 3750/// 3. address size. 3751/// 3752/// Entries (one "entry" for each function that was inlined): 3753/// 3754/// 1. offset into __debug_str section for MIPS linkage name, if exists; 3755/// otherwise offset into __debug_str for regular function name. 3756/// 2. offset into __debug_str section for regular function name. 3757/// 3. an unsigned LEB128 number indicating the number of distinct inlining 3758/// instances for the function. 3759/// 3760/// The rest of the entry consists of a {die_offset, low_pc} pair for each 3761/// inlined instance; the die_offset points to the inlined_subroutine die in the 3762/// __debug_info section, and the low_pc is the starting address for the 3763/// inlining instance. 3764void DwarfDebug::emitDebugInlineInfo() { 3765 if (!Asm->MAI->doesDwarfUsesInlineInfoSection()) 3766 return; 3767 3768 if (!FirstCU) 3769 return; 3770 3771 Asm->OutStreamer.SwitchSection( 3772 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 3773 3774 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry"); 3775 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1), 3776 Asm->GetTempSymbol("debug_inlined_begin", 1), 4); 3777 3778 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1)); 3779 3780 Asm->OutStreamer.AddComment("Dwarf Version"); 3781 Asm->EmitInt16(dwarf::DWARF_VERSION); 3782 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 3783 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 3784 3785 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 3786 E = InlinedSPNodes.end(); I != E; ++I) { 3787 3788 const MDNode *Node = *I; 3789 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 3790 = InlineInfo.find(Node); 3791 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 3792 DISubprogram SP(Node); 3793 StringRef LName = SP.getLinkageName(); 3794 StringRef Name = SP.getName(); 3795 3796 Asm->OutStreamer.AddComment("MIPS linkage name"); 3797 if (LName.empty()) { 3798 Asm->OutStreamer.EmitBytes(Name, 0); 3799 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator. 3800 } else 3801 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)), 3802 DwarfStrSectionSym); 3803 3804 Asm->OutStreamer.AddComment("Function name"); 3805 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym); 3806 Asm->EmitULEB128(Labels.size(), "Inline count"); 3807 3808 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 3809 LE = Labels.end(); LI != LE; ++LI) { 3810 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 3811 Asm->EmitInt32(LI->second->getOffset()); 3812 3813 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc"); 3814 Asm->OutStreamer.EmitSymbolValue(LI->first, 3815 Asm->getTargetData().getPointerSize(),0); 3816 } 3817 } 3818 3819 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1)); 3820} 3821