DwarfDebug.cpp revision d6747df5e0354256a9e440d38f21c0b3ca82af28
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 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 815 816 if (TRI->getFrameRegister(*Asm->MF) == Location.getReg() 817 && Location.getOffset()) { 818 // If variable offset is based in frame register then use fbreg. 819 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg); 820 addSInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 821 addBlock(Die, Attribute, 0, Block); 822 return; 823 } 824 825 if (Location.isReg()) { 826 if (Reg < 32) { 827 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg); 828 } else { 829 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx); 830 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 831 } 832 } else { 833 if (Reg < 32) { 834 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 835 } else { 836 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 837 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 838 } 839 840 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 841 } 842 843 addBlock(Die, Attribute, 0, Block); 844} 845 846/// addRegisterAddress - Add register location entry in variable DIE. 847bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS, 848 const MachineOperand &MO) { 849 assert (MO.isReg() && "Invalid machine operand!"); 850 if (!MO.getReg()) 851 return false; 852 MachineLocation Location; 853 Location.set(MO.getReg()); 854 addAddress(Die, dwarf::DW_AT_location, Location); 855 if (VS) 856 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS); 857 return true; 858} 859 860/// addConstantValue - Add constant value entry in variable DIE. 861bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS, 862 const MachineOperand &MO) { 863 assert (MO.isImm() && "Invalid machine operand!"); 864 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 865 unsigned Imm = MO.getImm(); 866 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm); 867 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 868 if (VS) 869 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS); 870 return true; 871} 872 873/// addConstantFPValue - Add constant value entry in variable DIE. 874bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS, 875 const MachineOperand &MO) { 876 assert (MO.isFPImm() && "Invalid machine operand!"); 877 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 878 APFloat FPImm = MO.getFPImm()->getValueAPF(); 879 880 // Get the raw data form of the floating point. 881 const APInt FltVal = FPImm.bitcastToAPInt(); 882 const char *FltPtr = (const char*)FltVal.getRawData(); 883 884 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte. 885 bool LittleEndian = Asm->getTargetData().isLittleEndian(); 886 int Incr = (LittleEndian ? 1 : -1); 887 int Start = (LittleEndian ? 0 : NumBytes - 1); 888 int Stop = (LittleEndian ? NumBytes : -1); 889 890 // Output the constant to DWARF one byte at a time. 891 for (; Start != Stop; Start += Incr) 892 addUInt(Block, 0, dwarf::DW_FORM_data1, 893 (unsigned char)0xFF & FltPtr[Start]); 894 895 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 896 if (VS) 897 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS); 898 return true; 899} 900 901 902/// addToContextOwner - Add Die into the list of its context owner's children. 903void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) { 904 if (Context.isType()) { 905 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context)); 906 ContextDIE->addChild(Die); 907 } else if (Context.isNameSpace()) { 908 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context)); 909 ContextDIE->addChild(Die); 910 } else if (Context.isSubprogram()) { 911 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context)); 912 ContextDIE->addChild(Die); 913 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context)) 914 ContextDIE->addChild(Die); 915 else 916 getCompileUnit(Context)->addDie(Die); 917} 918 919/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the 920/// given DIType. 921DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) { 922 CompileUnit *TypeCU = getCompileUnit(Ty); 923 DIE *TyDIE = TypeCU->getDIE(Ty); 924 if (TyDIE) 925 return TyDIE; 926 927 // Create new type. 928 TyDIE = new DIE(dwarf::DW_TAG_base_type); 929 TypeCU->insertDIE(Ty, TyDIE); 930 if (Ty.isBasicType()) 931 constructTypeDIE(*TyDIE, DIBasicType(Ty)); 932 else if (Ty.isCompositeType()) 933 constructTypeDIE(*TyDIE, DICompositeType(Ty)); 934 else { 935 assert(Ty.isDerivedType() && "Unknown kind of DIType"); 936 constructTypeDIE(*TyDIE, DIDerivedType(Ty)); 937 } 938 939 addToContextOwner(TyDIE, Ty.getContext()); 940 return TyDIE; 941} 942 943/// addType - Add a new type attribute to the specified entity. 944void DwarfDebug::addType(DIE *Entity, DIType Ty) { 945 if (!Ty.Verify()) 946 return; 947 948 // Check for pre-existence. 949 CompileUnit *TypeCU = getCompileUnit(Ty); 950 DIEEntry *Entry = TypeCU->getDIEEntry(Ty); 951 // If it exists then use the existing value. 952 if (Entry) { 953 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry); 954 return; 955 } 956 957 // Construct type. 958 DIE *Buffer = getOrCreateTypeDIE(Ty); 959 960 // Set up proxy. 961 Entry = createDIEEntry(Buffer); 962 TypeCU->insertDIEEntry(Ty, Entry); 963 964 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry); 965} 966 967/// constructTypeDIE - Construct basic type die from DIBasicType. 968void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) { 969 // Get core information. 970 StringRef Name = BTy.getName(); 971 Buffer.setTag(dwarf::DW_TAG_base_type); 972 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 973 BTy.getEncoding()); 974 975 // Add name if not anonymous or intermediate type. 976 if (!Name.empty()) 977 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 978 uint64_t Size = BTy.getSizeInBits() >> 3; 979 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 980} 981 982/// constructTypeDIE - Construct derived type die from DIDerivedType. 983void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) { 984 // Get core information. 985 StringRef Name = DTy.getName(); 986 uint64_t Size = DTy.getSizeInBits() >> 3; 987 unsigned Tag = DTy.getTag(); 988 989 // FIXME - Workaround for templates. 990 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type; 991 992 Buffer.setTag(Tag); 993 994 // Map to main type, void will not have a type. 995 DIType FromTy = DTy.getTypeDerivedFrom(); 996 addType(&Buffer, FromTy); 997 998 // Add name if not anonymous or intermediate type. 999 if (!Name.empty()) 1000 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1001 1002 // Add size if non-zero (derived types might be zero-sized.) 1003 if (Size) 1004 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 1005 1006 // Add source line info if available and TyDesc is not a forward declaration. 1007 if (!DTy.isForwardDecl()) 1008 addSourceLine(&Buffer, DTy); 1009} 1010 1011/// constructTypeDIE - Construct type DIE from DICompositeType. 1012void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) { 1013 // Get core information. 1014 StringRef Name = CTy.getName(); 1015 1016 uint64_t Size = CTy.getSizeInBits() >> 3; 1017 unsigned Tag = CTy.getTag(); 1018 Buffer.setTag(Tag); 1019 1020 switch (Tag) { 1021 case dwarf::DW_TAG_vector_type: 1022 case dwarf::DW_TAG_array_type: 1023 constructArrayTypeDIE(Buffer, &CTy); 1024 break; 1025 case dwarf::DW_TAG_enumeration_type: { 1026 DIArray Elements = CTy.getTypeArray(); 1027 1028 // Add enumerators to enumeration type. 1029 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1030 DIE *ElemDie = NULL; 1031 DIDescriptor Enum(Elements.getElement(i)); 1032 if (Enum.isEnumerator()) { 1033 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum)); 1034 Buffer.addChild(ElemDie); 1035 } 1036 } 1037 } 1038 break; 1039 case dwarf::DW_TAG_subroutine_type: { 1040 // Add return type. 1041 DIArray Elements = CTy.getTypeArray(); 1042 DIDescriptor RTy = Elements.getElement(0); 1043 addType(&Buffer, DIType(RTy)); 1044 1045 bool isPrototyped = true; 1046 // Add arguments. 1047 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) { 1048 DIDescriptor Ty = Elements.getElement(i); 1049 if (Ty.isUnspecifiedParameter()) { 1050 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters); 1051 Buffer.addChild(Arg); 1052 isPrototyped = false; 1053 } else { 1054 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1055 addType(Arg, DIType(Ty)); 1056 Buffer.addChild(Arg); 1057 } 1058 } 1059 // Add prototype flag. 1060 if (isPrototyped) 1061 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1); 1062 1063 1064 } 1065 break; 1066 case dwarf::DW_TAG_structure_type: 1067 case dwarf::DW_TAG_union_type: 1068 case dwarf::DW_TAG_class_type: { 1069 // Add elements to structure type. 1070 DIArray Elements = CTy.getTypeArray(); 1071 1072 // A forward struct declared type may not have elements available. 1073 unsigned N = Elements.getNumElements(); 1074 if (N == 0) 1075 break; 1076 1077 // Add elements to structure type. 1078 for (unsigned i = 0; i < N; ++i) { 1079 DIDescriptor Element = Elements.getElement(i); 1080 DIE *ElemDie = NULL; 1081 if (Element.isSubprogram()) { 1082 DISubprogram SP(Element); 1083 ElemDie = createSubprogramDIE(DISubprogram(Element)); 1084 if (SP.isProtected()) 1085 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1086 dwarf::DW_ACCESS_protected); 1087 else if (SP.isPrivate()) 1088 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1089 dwarf::DW_ACCESS_private); 1090 else 1091 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1092 dwarf::DW_ACCESS_public); 1093 if (SP.isExplicit()) 1094 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1); 1095 } 1096 else if (Element.isVariable()) { 1097 DIVariable DV(Element); 1098 ElemDie = new DIE(dwarf::DW_TAG_variable); 1099 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, 1100 DV.getName()); 1101 addType(ElemDie, DV.getType()); 1102 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1103 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1104 addSourceLine(ElemDie, DV); 1105 } else if (Element.isDerivedType()) 1106 ElemDie = createMemberDIE(DIDerivedType(Element)); 1107 else 1108 continue; 1109 Buffer.addChild(ElemDie); 1110 } 1111 1112 if (CTy.isAppleBlockExtension()) 1113 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1); 1114 1115 unsigned RLang = CTy.getRunTimeLang(); 1116 if (RLang) 1117 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, 1118 dwarf::DW_FORM_data1, RLang); 1119 1120 DICompositeType ContainingType = CTy.getContainingType(); 1121 if (DIDescriptor(ContainingType).isCompositeType()) 1122 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 1123 getOrCreateTypeDIE(DIType(ContainingType))); 1124 else { 1125 DIDescriptor Context = CTy.getContext(); 1126 addToContextOwner(&Buffer, Context); 1127 } 1128 break; 1129 } 1130 default: 1131 break; 1132 } 1133 1134 // Add name if not anonymous or intermediate type. 1135 if (!Name.empty()) 1136 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1137 1138 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type 1139 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) 1140 { 1141 // Add size if non-zero (derived types might be zero-sized.) 1142 if (Size) 1143 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 1144 else { 1145 // Add zero size if it is not a forward declaration. 1146 if (CTy.isForwardDecl()) 1147 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1148 else 1149 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0); 1150 } 1151 1152 // Add source line info if available. 1153 if (!CTy.isForwardDecl()) 1154 addSourceLine(&Buffer, CTy); 1155 } 1156} 1157 1158/// constructSubrangeDIE - Construct subrange DIE from DISubrange. 1159void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){ 1160 int64_t L = SR.getLo(); 1161 int64_t H = SR.getHi(); 1162 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type); 1163 1164 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy); 1165 if (L) 1166 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L); 1167 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H); 1168 1169 Buffer.addChild(DW_Subrange); 1170} 1171 1172/// constructArrayTypeDIE - Construct array type DIE from DICompositeType. 1173void DwarfDebug::constructArrayTypeDIE(DIE &Buffer, 1174 DICompositeType *CTy) { 1175 Buffer.setTag(dwarf::DW_TAG_array_type); 1176 if (CTy->getTag() == dwarf::DW_TAG_vector_type) 1177 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1); 1178 1179 // Emit derived type. 1180 addType(&Buffer, CTy->getTypeDerivedFrom()); 1181 DIArray Elements = CTy->getTypeArray(); 1182 1183 // Get an anonymous type for index type. 1184 CompileUnit *TheCU = getCompileUnit(*CTy); 1185 DIE *IdxTy = TheCU->getIndexTyDie(); 1186 if (!IdxTy) { 1187 // Construct an anonymous type for index type. 1188 IdxTy = new DIE(dwarf::DW_TAG_base_type); 1189 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t)); 1190 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 1191 dwarf::DW_ATE_signed); 1192 TheCU->addDie(IdxTy); 1193 TheCU->setIndexTyDie(IdxTy); 1194 } 1195 1196 // Add subranges to array type. 1197 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1198 DIDescriptor Element = Elements.getElement(i); 1199 if (Element.getTag() == dwarf::DW_TAG_subrange_type) 1200 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy); 1201 } 1202} 1203 1204/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator. 1205DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) { 1206 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator); 1207 StringRef Name = ETy.getName(); 1208 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1209 int64_t Value = ETy.getEnumValue(); 1210 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value); 1211 return Enumerator; 1212} 1213 1214/// getRealLinkageName - If special LLVM prefix that is used to inform the asm 1215/// printer to not emit usual symbol prefix before the symbol name is used then 1216/// return linkage name after skipping this special LLVM prefix. 1217static StringRef getRealLinkageName(StringRef LinkageName) { 1218 char One = '\1'; 1219 if (LinkageName.startswith(StringRef(&One, 1))) 1220 return LinkageName.substr(1); 1221 return LinkageName; 1222} 1223 1224/// createMemberDIE - Create new member DIE. 1225DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) { 1226 DIE *MemberDie = new DIE(DT.getTag()); 1227 StringRef Name = DT.getName(); 1228 if (!Name.empty()) 1229 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1230 1231 addType(MemberDie, DT.getTypeDerivedFrom()); 1232 1233 addSourceLine(MemberDie, DT); 1234 1235 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock(); 1236 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 1237 1238 uint64_t Size = DT.getSizeInBits(); 1239 uint64_t FieldSize = DT.getOriginalTypeSize(); 1240 1241 if (Size != FieldSize) { 1242 // Handle bitfield. 1243 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3); 1244 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits()); 1245 1246 uint64_t Offset = DT.getOffsetInBits(); 1247 uint64_t AlignMask = ~(DT.getAlignInBits() - 1); 1248 uint64_t HiMark = (Offset + FieldSize) & AlignMask; 1249 uint64_t FieldOffset = (HiMark - FieldSize); 1250 Offset -= FieldOffset; 1251 1252 // Maybe we need to work from the other end. 1253 if (Asm->getTargetData().isLittleEndian()) 1254 Offset = FieldSize - (Offset + Size); 1255 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset); 1256 1257 // Here WD_AT_data_member_location points to the anonymous 1258 // field that includes this bit field. 1259 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3); 1260 1261 } else 1262 // This is not a bitfield. 1263 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3); 1264 1265 if (DT.getTag() == dwarf::DW_TAG_inheritance 1266 && DT.isVirtual()) { 1267 1268 // For C++, virtual base classes are not at fixed offset. Use following 1269 // expression to extract appropriate offset from vtable. 1270 // BaseAddr = ObAddr + *((*ObAddr) - Offset) 1271 1272 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock(); 1273 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup); 1274 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1275 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1276 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits()); 1277 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus); 1278 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1279 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1280 1281 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, 1282 VBaseLocationDie); 1283 } else 1284 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie); 1285 1286 if (DT.isProtected()) 1287 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1288 dwarf::DW_ACCESS_protected); 1289 else if (DT.isPrivate()) 1290 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1291 dwarf::DW_ACCESS_private); 1292 // Otherwise C++ member and base classes are considered public. 1293 else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus) 1294 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1295 dwarf::DW_ACCESS_public); 1296 if (DT.isVirtual()) 1297 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, 1298 dwarf::DW_VIRTUALITY_virtual); 1299 return MemberDie; 1300} 1301 1302/// createSubprogramDIE - Create new DIE using SP. 1303DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) { 1304 CompileUnit *SPCU = getCompileUnit(SP); 1305 DIE *SPDie = SPCU->getDIE(SP); 1306 if (SPDie) 1307 return SPDie; 1308 1309 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1310 // Constructors and operators for anonymous aggregates do not have names. 1311 if (!SP.getName().empty()) 1312 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName()); 1313 1314 StringRef LinkageName = SP.getLinkageName(); 1315 if (!LinkageName.empty()) 1316 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string, 1317 getRealLinkageName(LinkageName)); 1318 1319 addSourceLine(SPDie, SP); 1320 1321 // Add prototyped tag, if C or ObjC. 1322 unsigned Lang = SP.getCompileUnit().getLanguage(); 1323 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 || 1324 Lang == dwarf::DW_LANG_ObjC) 1325 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1); 1326 1327 // Add Return Type. 1328 DICompositeType SPTy = SP.getType(); 1329 DIArray Args = SPTy.getTypeArray(); 1330 unsigned SPTag = SPTy.getTag(); 1331 1332 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type) 1333 addType(SPDie, SPTy); 1334 else 1335 addType(SPDie, DIType(Args.getElement(0))); 1336 1337 unsigned VK = SP.getVirtuality(); 1338 if (VK) { 1339 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK); 1340 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1341 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1342 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex()); 1343 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block); 1344 ContainingTypeMap.insert(std::make_pair(SPDie, 1345 SP.getContainingType())); 1346 } 1347 1348 if (!SP.isDefinition()) { 1349 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1350 1351 // Add arguments. Do not add arguments for subprogram definition. They will 1352 // be handled while processing variables. 1353 DICompositeType SPTy = SP.getType(); 1354 DIArray Args = SPTy.getTypeArray(); 1355 unsigned SPTag = SPTy.getTag(); 1356 1357 if (SPTag == dwarf::DW_TAG_subroutine_type) 1358 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1359 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1360 DIType ATy = DIType(DIType(Args.getElement(i))); 1361 addType(Arg, ATy); 1362 if (ATy.isArtificial()) 1363 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1364 SPDie->addChild(Arg); 1365 } 1366 } 1367 1368 if (SP.isArtificial()) 1369 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1370 1371 if (!SP.isLocalToUnit()) 1372 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1373 1374 if (SP.isOptimized()) 1375 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 1376 1377 if (unsigned isa = Asm->getISAEncoding()) { 1378 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa); 1379 } 1380 1381 // DW_TAG_inlined_subroutine may refer to this DIE. 1382 SPCU->insertDIE(SP, SPDie); 1383 1384 // Add to context owner. 1385 addToContextOwner(SPDie, SP.getContext()); 1386 1387 return SPDie; 1388} 1389 1390DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) { 1391 assert(N && "Invalid Scope encoding!"); 1392 1393 DbgScope *AScope = AbstractScopes.lookup(N); 1394 if (AScope) 1395 return AScope; 1396 1397 DbgScope *Parent = NULL; 1398 1399 DIDescriptor Scope(N); 1400 if (Scope.isLexicalBlock()) { 1401 DILexicalBlock DB(N); 1402 DIDescriptor ParentDesc = DB.getContext(); 1403 Parent = getOrCreateAbstractScope(ParentDesc); 1404 } 1405 1406 AScope = new DbgScope(Parent, DIDescriptor(N), NULL); 1407 1408 if (Parent) 1409 Parent->addScope(AScope); 1410 AScope->setAbstractScope(); 1411 AbstractScopes[N] = AScope; 1412 if (DIDescriptor(N).isSubprogram()) 1413 AbstractScopesList.push_back(AScope); 1414 return AScope; 1415} 1416 1417/// isSubprogramContext - Return true if Context is either a subprogram 1418/// or another context nested inside a subprogram. 1419static bool isSubprogramContext(const MDNode *Context) { 1420 if (!Context) 1421 return false; 1422 DIDescriptor D(Context); 1423 if (D.isSubprogram()) 1424 return true; 1425 if (D.isType()) 1426 return isSubprogramContext(DIType(Context).getContext()); 1427 return false; 1428} 1429 1430/// updateSubprogramScopeDIE - Find DIE for the given subprogram and 1431/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes. 1432/// If there are global variables in this scope then create and insert 1433/// DIEs for these variables. 1434DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) { 1435 CompileUnit *SPCU = getCompileUnit(SPNode); 1436 DIE *SPDie = SPCU->getDIE(SPNode); 1437 1438 assert(SPDie && "Unable to find subprogram DIE!"); 1439 DISubprogram SP(SPNode); 1440 1441 // There is not any need to generate specification DIE for a function 1442 // defined at compile unit level. If a function is defined inside another 1443 // function then gdb prefers the definition at top level and but does not 1444 // expect specification DIE in parent function. So avoid creating 1445 // specification DIE for a function defined inside a function. 1446 if (SP.isDefinition() && !SP.getContext().isCompileUnit() && 1447 !SP.getContext().isFile() && 1448 !isSubprogramContext(SP.getContext())) { 1449 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1450 1451 // Add arguments. 1452 DICompositeType SPTy = SP.getType(); 1453 DIArray Args = SPTy.getTypeArray(); 1454 unsigned SPTag = SPTy.getTag(); 1455 if (SPTag == dwarf::DW_TAG_subroutine_type) 1456 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1457 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1458 DIType ATy = DIType(DIType(Args.getElement(i))); 1459 addType(Arg, ATy); 1460 if (ATy.isArtificial()) 1461 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1462 SPDie->addChild(Arg); 1463 } 1464 DIE *SPDeclDie = SPDie; 1465 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1466 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4, 1467 SPDeclDie); 1468 SPCU->addDie(SPDie); 1469 } 1470 1471 // Pick up abstract subprogram DIE. 1472 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) { 1473 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1474 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, 1475 dwarf::DW_FORM_ref4, AbsSPDIE); 1476 SPCU->addDie(SPDie); 1477 } 1478 1479 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 1480 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber())); 1481 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, 1482 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber())); 1483 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 1484 MachineLocation Location(RI->getFrameRegister(*Asm->MF)); 1485 addAddress(SPDie, dwarf::DW_AT_frame_base, Location); 1486 1487 return SPDie; 1488} 1489 1490/// constructLexicalScope - Construct new DW_TAG_lexical_block 1491/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels. 1492DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) { 1493 1494 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block); 1495 if (Scope->isAbstractScope()) 1496 return ScopeDIE; 1497 1498 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges(); 1499 if (Ranges.empty()) 1500 return 0; 1501 1502 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(); 1503 if (Ranges.size() > 1) { 1504 // .debug_range section has not been laid out yet. Emit offset in 1505 // .debug_range as a uint, size 4, for now. emitDIE will handle 1506 // DW_AT_ranges appropriately. 1507 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4, 1508 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize()); 1509 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 1510 RE = Ranges.end(); RI != RE; ++RI) { 1511 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first)); 1512 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second)); 1513 } 1514 DebugRangeSymbols.push_back(NULL); 1515 DebugRangeSymbols.push_back(NULL); 1516 return ScopeDIE; 1517 } 1518 1519 const MCSymbol *Start = getLabelBeforeInsn(RI->first); 1520 const MCSymbol *End = getLabelAfterInsn(RI->second); 1521 1522 if (End == 0) return 0; 1523 1524 assert(Start->isDefined() && "Invalid starting label for an inlined scope!"); 1525 assert(End->isDefined() && "Invalid end label for an inlined scope!"); 1526 1527 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start); 1528 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End); 1529 1530 return ScopeDIE; 1531} 1532 1533/// constructInlinedScopeDIE - This scope represents inlined body of 1534/// a function. Construct DIE to represent this concrete inlined copy 1535/// of the function. 1536DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) { 1537 1538 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges(); 1539 assert (Ranges.empty() == false 1540 && "DbgScope does not have instruction markers!"); 1541 1542 // FIXME : .debug_inlined section specification does not clearly state how 1543 // to emit inlined scope that is split into multiple instruction ranges. 1544 // For now, use first instruction range and emit low_pc/high_pc pair and 1545 // corresponding .debug_inlined section entry for this pair. 1546 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(); 1547 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first); 1548 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second); 1549 1550 if (StartLabel == 0 || EndLabel == 0) { 1551 assert (0 && "Unexpected Start and End labels for a inlined scope!"); 1552 return 0; 1553 } 1554 assert(StartLabel->isDefined() && 1555 "Invalid starting label for an inlined scope!"); 1556 assert(EndLabel->isDefined() && 1557 "Invalid end label for an inlined scope!"); 1558 1559 if (!Scope->getScopeNode()) 1560 return NULL; 1561 DIScope DS(Scope->getScopeNode()); 1562 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine); 1563 1564 DISubprogram InlinedSP = getDISubprogram(DS); 1565 CompileUnit *TheCU = getCompileUnit(InlinedSP); 1566 DIE *OriginDIE = TheCU->getDIE(InlinedSP); 1567 assert(OriginDIE && "Unable to find Origin DIE!"); 1568 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, 1569 dwarf::DW_FORM_ref4, OriginDIE); 1570 1571 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel); 1572 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel); 1573 1574 InlinedSubprogramDIEs.insert(OriginDIE); 1575 1576 // Track the start label for this inlined function. 1577 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator 1578 I = InlineInfo.find(InlinedSP); 1579 1580 if (I == InlineInfo.end()) { 1581 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, 1582 ScopeDIE)); 1583 InlinedSPNodes.push_back(InlinedSP); 1584 } else 1585 I->second.push_back(std::make_pair(StartLabel, ScopeDIE)); 1586 1587 DILocation DL(Scope->getInlinedAt()); 1588 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID()); 1589 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber()); 1590 1591 return ScopeDIE; 1592} 1593 1594 1595/// constructVariableDIE - Construct a DIE for the given DbgVariable. 1596DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) { 1597 StringRef Name = DV->getName(); 1598 if (Name.empty()) 1599 return NULL; 1600 1601 // Translate tag to proper Dwarf tag. The result variable is dropped for 1602 // now. 1603 unsigned Tag; 1604 switch (DV->getTag()) { 1605 case dwarf::DW_TAG_return_variable: 1606 return NULL; 1607 case dwarf::DW_TAG_arg_variable: 1608 Tag = dwarf::DW_TAG_formal_parameter; 1609 break; 1610 case dwarf::DW_TAG_auto_variable: // fall thru 1611 default: 1612 Tag = dwarf::DW_TAG_variable; 1613 break; 1614 } 1615 1616 // Define variable debug information entry. 1617 DIE *VariableDie = new DIE(Tag); 1618 1619 DIE *AbsDIE = NULL; 1620 DenseMap<const DbgVariable *, const DbgVariable *>::iterator 1621 V2AVI = VarToAbstractVarMap.find(DV); 1622 if (V2AVI != VarToAbstractVarMap.end()) 1623 AbsDIE = V2AVI->second->getDIE(); 1624 1625 if (AbsDIE) 1626 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, 1627 dwarf::DW_FORM_ref4, AbsDIE); 1628 else { 1629 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1630 addSourceLine(VariableDie, DV->getVariable()); 1631 1632 // Add variable type. 1633 addType(VariableDie, DV->getType()); 1634 } 1635 1636 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial()) 1637 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1638 else if (DIVariable(DV->getVariable()).isArtificial()) 1639 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1640 1641 if (Scope->isAbstractScope()) { 1642 DV->setDIE(VariableDie); 1643 return VariableDie; 1644 } 1645 1646 // Add variable address. 1647 1648 unsigned Offset = DV->getDotDebugLocOffset(); 1649 if (Offset != ~0U) { 1650 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4, 1651 Asm->GetTempSymbol("debug_loc", Offset)); 1652 DV->setDIE(VariableDie); 1653 UseDotDebugLocEntry.insert(VariableDie); 1654 return VariableDie; 1655 } 1656 1657 // Check if variable is described by a DBG_VALUE instruction. 1658 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI = 1659 DbgVariableToDbgInstMap.find(DV); 1660 if (DVI != DbgVariableToDbgInstMap.end()) { 1661 const MachineInstr *DVInsn = DVI->second; 1662 const MCSymbol *DVLabel = findVariableLabel(DV); 1663 bool updated = false; 1664 // FIXME : Handle getNumOperands != 3 1665 if (DVInsn->getNumOperands() == 3) { 1666 if (DVInsn->getOperand(0).isReg()) { 1667 const MachineOperand RegOp = DVInsn->getOperand(0); 1668 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 1669 if (DVInsn->getOperand(1).isImm() && 1670 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) { 1671 addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm()); 1672 updated = true; 1673 } else 1674 updated = addRegisterAddress(VariableDie, DVLabel, RegOp); 1675 } 1676 else if (DVInsn->getOperand(0).isImm()) 1677 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0)); 1678 else if (DVInsn->getOperand(0).isFPImm()) 1679 updated = 1680 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0)); 1681 } else { 1682 MachineLocation Location = Asm->getDebugValueLocation(DVInsn); 1683 if (Location.getReg()) { 1684 addAddress(VariableDie, dwarf::DW_AT_location, Location); 1685 if (DVLabel) 1686 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, 1687 DVLabel); 1688 updated = true; 1689 } 1690 } 1691 if (!updated) { 1692 // If variableDie is not updated then DBG_VALUE instruction does not 1693 // have valid variable info. 1694 delete VariableDie; 1695 return NULL; 1696 } 1697 DV->setDIE(VariableDie); 1698 return VariableDie; 1699 } 1700 1701 // .. else use frame index, if available. 1702 int FI = 0; 1703 if (findVariableFrameIndex(DV, &FI)) 1704 addVariableAddress(DV, VariableDie, FI); 1705 1706 DV->setDIE(VariableDie); 1707 return VariableDie; 1708 1709} 1710 1711void DwarfDebug::addPubTypes(DISubprogram SP) { 1712 DICompositeType SPTy = SP.getType(); 1713 unsigned SPTag = SPTy.getTag(); 1714 if (SPTag != dwarf::DW_TAG_subroutine_type) 1715 return; 1716 1717 DIArray Args = SPTy.getTypeArray(); 1718 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) { 1719 DIType ATy(Args.getElement(i)); 1720 if (!ATy.Verify()) 1721 continue; 1722 DICompositeType CATy = getDICompositeType(ATy); 1723 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty() 1724 && !CATy.isForwardDecl()) { 1725 CompileUnit *TheCU = getCompileUnit(CATy); 1726 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy)) 1727 TheCU->addGlobalType(CATy.getName(), Entry->getEntry()); 1728 } 1729 } 1730} 1731 1732/// constructScopeDIE - Construct a DIE for this scope. 1733DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) { 1734 if (!Scope || !Scope->getScopeNode()) 1735 return NULL; 1736 1737 DIScope DS(Scope->getScopeNode()); 1738 DIE *ScopeDIE = NULL; 1739 if (Scope->getInlinedAt()) 1740 ScopeDIE = constructInlinedScopeDIE(Scope); 1741 else if (DS.isSubprogram()) { 1742 ProcessedSPNodes.insert(DS); 1743 if (Scope->isAbstractScope()) { 1744 ScopeDIE = getCompileUnit(DS)->getDIE(DS); 1745 // Note down abstract DIE. 1746 if (ScopeDIE) 1747 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE)); 1748 } 1749 else 1750 ScopeDIE = updateSubprogramScopeDIE(DS); 1751 } 1752 else 1753 ScopeDIE = constructLexicalScopeDIE(Scope); 1754 if (!ScopeDIE) return NULL; 1755 1756 // Add variables to scope. 1757 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables(); 1758 for (unsigned i = 0, N = Variables.size(); i < N; ++i) { 1759 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope); 1760 if (VariableDIE) 1761 ScopeDIE->addChild(VariableDIE); 1762 } 1763 1764 // Add nested scopes. 1765 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes(); 1766 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) { 1767 // Define the Scope debug information entry. 1768 DIE *NestedDIE = constructScopeDIE(Scopes[j]); 1769 if (NestedDIE) 1770 ScopeDIE->addChild(NestedDIE); 1771 } 1772 1773 if (DS.isSubprogram()) 1774 addPubTypes(DISubprogram(DS)); 1775 1776 return ScopeDIE; 1777} 1778 1779/// GetOrCreateSourceID - Look up the source id with the given directory and 1780/// source file names. If none currently exists, create a new id and insert it 1781/// in the SourceIds map. This can update DirectoryNames and SourceFileNames 1782/// maps as well. 1783unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){ 1784 unsigned DId; 1785 assert (DirName.empty() == false && "Invalid directory name!"); 1786 1787 // If FE did not provide a file name, then assume stdin. 1788 if (FileName.empty()) 1789 return GetOrCreateSourceID(DirName, "<stdin>"); 1790 1791 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName); 1792 if (DI != DirectoryIdMap.end()) { 1793 DId = DI->getValue(); 1794 } else { 1795 DId = DirectoryNames.size() + 1; 1796 DirectoryIdMap[DirName] = DId; 1797 DirectoryNames.push_back(DirName); 1798 } 1799 1800 unsigned FId; 1801 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName); 1802 if (FI != SourceFileIdMap.end()) { 1803 FId = FI->getValue(); 1804 } else { 1805 FId = SourceFileNames.size() + 1; 1806 SourceFileIdMap[FileName] = FId; 1807 SourceFileNames.push_back(FileName); 1808 } 1809 1810 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI = 1811 SourceIdMap.find(std::make_pair(DId, FId)); 1812 if (SI != SourceIdMap.end()) 1813 return SI->second; 1814 1815 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0. 1816 SourceIdMap[std::make_pair(DId, FId)] = SrcId; 1817 SourceIds.push_back(std::make_pair(DId, FId)); 1818 1819 return SrcId; 1820} 1821 1822/// getOrCreateNameSpace - Create a DIE for DINameSpace. 1823DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) { 1824 CompileUnit *TheCU = getCompileUnit(NS); 1825 DIE *NDie = TheCU->getDIE(NS); 1826 if (NDie) 1827 return NDie; 1828 NDie = new DIE(dwarf::DW_TAG_namespace); 1829 TheCU->insertDIE(NS, NDie); 1830 if (!NS.getName().empty()) 1831 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName()); 1832 addSourceLine(NDie, NS); 1833 addToContextOwner(NDie, NS.getContext()); 1834 return NDie; 1835} 1836 1837/// constructCompileUnit - Create new CompileUnit for the given 1838/// metadata node with tag DW_TAG_compile_unit. 1839void DwarfDebug::constructCompileUnit(const MDNode *N) { 1840 DICompileUnit DIUnit(N); 1841 StringRef FN = DIUnit.getFilename(); 1842 StringRef Dir = DIUnit.getDirectory(); 1843 unsigned ID = GetOrCreateSourceID(Dir, FN); 1844 1845 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 1846 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string, 1847 DIUnit.getProducer()); 1848 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1, 1849 DIUnit.getLanguage()); 1850 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN); 1851 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This 1852 // simplifies debug range entries. 1853 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0); 1854 // DW_AT_stmt_list is a offset of line number information for this 1855 // compile unit in debug_line section. 1856 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList()) 1857 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr, 1858 Asm->GetTempSymbol("section_line")); 1859 else 1860 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0); 1861 1862 if (!Dir.empty()) 1863 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir); 1864 if (DIUnit.isOptimized()) 1865 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 1866 1867 StringRef Flags = DIUnit.getFlags(); 1868 if (!Flags.empty()) 1869 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags); 1870 1871 unsigned RVer = DIUnit.getRunTimeVersion(); 1872 if (RVer) 1873 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers, 1874 dwarf::DW_FORM_data1, RVer); 1875 1876 CompileUnit *NewCU = new CompileUnit(ID, Die); 1877 if (!FirstCU) 1878 FirstCU = NewCU; 1879 CUMap.insert(std::make_pair(N, NewCU)); 1880} 1881 1882/// getCompielUnit - Get CompileUnit DIE. 1883CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const { 1884 assert (N && "Invalid DwarfDebug::getCompileUnit argument!"); 1885 DIDescriptor D(N); 1886 const MDNode *CUNode = NULL; 1887 if (D.isCompileUnit()) 1888 CUNode = N; 1889 else if (D.isSubprogram()) 1890 CUNode = DISubprogram(N).getCompileUnit(); 1891 else if (D.isType()) 1892 CUNode = DIType(N).getCompileUnit(); 1893 else if (D.isGlobalVariable()) 1894 CUNode = DIGlobalVariable(N).getCompileUnit(); 1895 else if (D.isVariable()) 1896 CUNode = DIVariable(N).getCompileUnit(); 1897 else if (D.isNameSpace()) 1898 CUNode = DINameSpace(N).getCompileUnit(); 1899 else if (D.isFile()) 1900 CUNode = DIFile(N).getCompileUnit(); 1901 else 1902 return FirstCU; 1903 1904 DenseMap<const MDNode *, CompileUnit *>::const_iterator I 1905 = CUMap.find(CUNode); 1906 if (I == CUMap.end()) 1907 return FirstCU; 1908 return I->second; 1909} 1910 1911/// isUnsignedDIType - Return true if type encoding is unsigned. 1912static bool isUnsignedDIType(DIType Ty) { 1913 DIDerivedType DTy(Ty); 1914 if (DTy.Verify()) 1915 return isUnsignedDIType(DTy.getTypeDerivedFrom()); 1916 1917 DIBasicType BTy(Ty); 1918 if (BTy.Verify()) { 1919 unsigned Encoding = BTy.getEncoding(); 1920 if (Encoding == dwarf::DW_ATE_unsigned || 1921 Encoding == dwarf::DW_ATE_unsigned_char) 1922 return true; 1923 } 1924 return false; 1925} 1926 1927/// constructGlobalVariableDIE - Construct global variable DIE. 1928void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) { 1929 DIGlobalVariable GV(N); 1930 1931 // If debug information is malformed then ignore it. 1932 if (GV.Verify() == false) 1933 return; 1934 1935 // Check for pre-existence. 1936 CompileUnit *TheCU = getCompileUnit(N); 1937 if (TheCU->getDIE(GV)) 1938 return; 1939 1940 DIType GTy = GV.getType(); 1941 DIE *VariableDIE = new DIE(GV.getTag()); 1942 1943 bool isGlobalVariable = GV.getGlobal() != NULL; 1944 1945 // Add name. 1946 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, 1947 GV.getDisplayName()); 1948 StringRef LinkageName = GV.getLinkageName(); 1949 if (!LinkageName.empty() && isGlobalVariable) 1950 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string, 1951 getRealLinkageName(LinkageName)); 1952 // Add type. 1953 addType(VariableDIE, GTy); 1954 if (GTy.isCompositeType() && !GTy.getName().empty() 1955 && !GTy.isForwardDecl()) { 1956 DIEEntry *Entry = TheCU->getDIEEntry(GTy); 1957 assert(Entry && "Missing global type!"); 1958 TheCU->addGlobalType(GTy.getName(), Entry->getEntry()); 1959 } 1960 // Add scoping info. 1961 if (!GV.isLocalToUnit()) { 1962 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1963 // Expose as global. 1964 TheCU->addGlobal(GV.getName(), VariableDIE); 1965 } 1966 // Add line number info. 1967 addSourceLine(VariableDIE, GV); 1968 // Add to map. 1969 TheCU->insertDIE(N, VariableDIE); 1970 // Add to context owner. 1971 DIDescriptor GVContext = GV.getContext(); 1972 addToContextOwner(VariableDIE, GVContext); 1973 // Add location. 1974 if (isGlobalVariable) { 1975 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1976 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 1977 addLabel(Block, 0, dwarf::DW_FORM_udata, 1978 Asm->Mang->getSymbol(GV.getGlobal())); 1979 // Do not create specification DIE if context is either compile unit 1980 // or a subprogram. 1981 if (GV.isDefinition() && !GVContext.isCompileUnit() && 1982 !GVContext.isFile() && !isSubprogramContext(GVContext)) { 1983 // Create specification DIE. 1984 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable); 1985 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, 1986 dwarf::DW_FORM_ref4, VariableDIE); 1987 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block); 1988 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1989 TheCU->addDie(VariableSpecDIE); 1990 } else { 1991 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block); 1992 } 1993 } else if (Constant *C = GV.getConstant()) { 1994 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) { 1995 if (isUnsignedDIType(GTy)) 1996 addUInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata, 1997 CI->getZExtValue()); 1998 else 1999 addSInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, 2000 CI->getSExtValue()); 2001 } 2002 } 2003 return; 2004} 2005 2006/// construct SubprogramDIE - Construct subprogram DIE. 2007void DwarfDebug::constructSubprogramDIE(const MDNode *N) { 2008 DISubprogram SP(N); 2009 2010 // Check for pre-existence. 2011 CompileUnit *TheCU = getCompileUnit(N); 2012 if (TheCU->getDIE(N)) 2013 return; 2014 2015 if (!SP.isDefinition()) 2016 // This is a method declaration which will be handled while constructing 2017 // class type. 2018 return; 2019 2020 DIE *SubprogramDie = createSubprogramDIE(SP); 2021 2022 // Add to map. 2023 TheCU->insertDIE(N, SubprogramDie); 2024 2025 // Add to context owner. 2026 addToContextOwner(SubprogramDie, SP.getContext()); 2027 2028 // Expose as global. 2029 TheCU->addGlobal(SP.getName(), SubprogramDie); 2030 2031 return; 2032} 2033 2034/// beginModule - Emit all Dwarf sections that should come prior to the 2035/// content. Create global DIEs and emit initial debug info sections. 2036/// This is inovked by the target AsmPrinter. 2037void DwarfDebug::beginModule(Module *M) { 2038 if (DisableDebugInfoPrinting) 2039 return; 2040 2041 DebugInfoFinder DbgFinder; 2042 DbgFinder.processModule(*M); 2043 2044 bool HasDebugInfo = false; 2045 2046 // Scan all the compile-units to see if there are any marked as the main unit. 2047 // if not, we do not generate debug info. 2048 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 2049 E = DbgFinder.compile_unit_end(); I != E; ++I) { 2050 if (DICompileUnit(*I).isMain()) { 2051 HasDebugInfo = true; 2052 break; 2053 } 2054 } 2055 2056 if (!HasDebugInfo) return; 2057 2058 // Tell MMI that we have debug info. 2059 MMI->setDebugInfoAvailability(true); 2060 2061 // Emit initial sections. 2062 EmitSectionLabels(); 2063 2064 // Create all the compile unit DIEs. 2065 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 2066 E = DbgFinder.compile_unit_end(); I != E; ++I) 2067 constructCompileUnit(*I); 2068 2069 // Create DIEs for each subprogram. 2070 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(), 2071 E = DbgFinder.subprogram_end(); I != E; ++I) 2072 constructSubprogramDIE(*I); 2073 2074 // Create DIEs for each global variable. 2075 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(), 2076 E = DbgFinder.global_variable_end(); I != E; ++I) 2077 constructGlobalVariableDIE(*I); 2078 2079 //getOrCreateTypeDIE 2080 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum")) 2081 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) 2082 getOrCreateTypeDIE(DIType(NMD->getOperand(i))); 2083 2084 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty")) 2085 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) 2086 getOrCreateTypeDIE(DIType(NMD->getOperand(i))); 2087 2088 // Prime section data. 2089 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 2090 2091 // Print out .file directives to specify files for .loc directives. These are 2092 // printed out early so that they precede any .loc directives. 2093 if (Asm->MAI->hasDotLocAndDotFile()) { 2094 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) { 2095 // Remember source id starts at 1. 2096 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i); 2097 // FIXME: don't use sys::path for this! This should not depend on the 2098 // host. 2099 sys::Path FullPath(getSourceDirectoryName(Id.first)); 2100 bool AppendOk = 2101 FullPath.appendComponent(getSourceFileName(Id.second)); 2102 assert(AppendOk && "Could not append filename to directory!"); 2103 AppendOk = false; 2104 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str()); 2105 } 2106 } 2107} 2108 2109/// endModule - Emit all Dwarf sections that should come after the content. 2110/// 2111void DwarfDebug::endModule() { 2112 if (!FirstCU) return; 2113 const Module *M = MMI->getModule(); 2114 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap; 2115 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) { 2116 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) { 2117 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue; 2118 DISubprogram SP(AllSPs->getOperand(SI)); 2119 if (!SP.Verify()) continue; 2120 2121 // Collect info for variables that were optimized out. 2122 if (!SP.isDefinition()) continue; 2123 StringRef FName = SP.getLinkageName(); 2124 if (FName.empty()) 2125 FName = SP.getName(); 2126 NamedMDNode *NMD = 2127 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName))); 2128 if (!NMD) continue; 2129 unsigned E = NMD->getNumOperands(); 2130 if (!E) continue; 2131 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL); 2132 DeadFnScopeMap[SP] = Scope; 2133 for (unsigned I = 0; I != E; ++I) { 2134 DIVariable DV(NMD->getOperand(I)); 2135 if (!DV.Verify()) continue; 2136 Scope->addVariable(new DbgVariable(DV)); 2137 } 2138 2139 // Construct subprogram DIE and add variables DIEs. 2140 constructSubprogramDIE(SP); 2141 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP); 2142 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables(); 2143 for (unsigned i = 0, N = Variables.size(); i < N; ++i) { 2144 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope); 2145 if (VariableDIE) 2146 ScopeDIE->addChild(VariableDIE); 2147 } 2148 } 2149 } 2150 2151 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 2152 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 2153 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 2154 DIE *ISP = *AI; 2155 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 2156 } 2157 2158 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(), 2159 CE = ContainingTypeMap.end(); CI != CE; ++CI) { 2160 DIE *SPDie = CI->first; 2161 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second); 2162 if (!N) continue; 2163 DIE *NDie = getCompileUnit(N)->getDIE(N); 2164 if (!NDie) continue; 2165 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie); 2166 } 2167 2168 // Standard sections final addresses. 2169 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 2170 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end")); 2171 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 2172 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end")); 2173 2174 // End text sections. 2175 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) { 2176 Asm->OutStreamer.SwitchSection(SectionMap[i]); 2177 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i)); 2178 } 2179 2180 // Emit common frame information. 2181 emitCommonDebugFrame(); 2182 2183 // Emit function debug frame information 2184 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(), 2185 E = DebugFrames.end(); I != E; ++I) 2186 emitFunctionDebugFrame(*I); 2187 2188 // Compute DIE offsets and sizes. 2189 computeSizeAndOffsets(); 2190 2191 // Emit all the DIEs into a debug info section 2192 emitDebugInfo(); 2193 2194 // Corresponding abbreviations into a abbrev section. 2195 emitAbbreviations(); 2196 2197 // Emit source line correspondence into a debug line section. 2198 emitDebugLines(); 2199 2200 // Emit info into a debug pubnames section. 2201 emitDebugPubNames(); 2202 2203 // Emit info into a debug pubtypes section. 2204 emitDebugPubTypes(); 2205 2206 // Emit info into a debug loc section. 2207 emitDebugLoc(); 2208 2209 // Emit info into a debug aranges section. 2210 EmitDebugARanges(); 2211 2212 // Emit info into a debug ranges section. 2213 emitDebugRanges(); 2214 2215 // Emit info into a debug macinfo section. 2216 emitDebugMacInfo(); 2217 2218 // Emit inline info. 2219 emitDebugInlineInfo(); 2220 2221 // Emit info into a debug str section. 2222 emitDebugStr(); 2223 2224 // clean up. 2225 DeleteContainerSeconds(DeadFnScopeMap); 2226 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2227 E = CUMap.end(); I != E; ++I) 2228 delete I->second; 2229 FirstCU = NULL; // Reset for the next Module, if any. 2230} 2231 2232/// findAbstractVariable - Find abstract variable, if any, associated with Var. 2233DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var, 2234 DebugLoc ScopeLoc) { 2235 2236 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var); 2237 if (AbsDbgVariable) 2238 return AbsDbgVariable; 2239 2240 LLVMContext &Ctx = Var->getContext(); 2241 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx)); 2242 if (!Scope) 2243 return NULL; 2244 2245 AbsDbgVariable = new DbgVariable(Var); 2246 Scope->addVariable(AbsDbgVariable); 2247 AbstractVariables[Var] = AbsDbgVariable; 2248 return AbsDbgVariable; 2249} 2250 2251/// collectVariableInfoFromMMITable - Collect variable information from 2252/// side table maintained by MMI. 2253void 2254DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF, 2255 SmallPtrSet<const MDNode *, 16> &Processed) { 2256 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2257 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 2258 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 2259 VE = VMap.end(); VI != VE; ++VI) { 2260 const MDNode *Var = VI->first; 2261 if (!Var) continue; 2262 Processed.insert(Var); 2263 DIVariable DV(Var); 2264 const std::pair<unsigned, DebugLoc> &VP = VI->second; 2265 2266 DbgScope *Scope = 0; 2267 if (const MDNode *IA = VP.second.getInlinedAt(Ctx)) 2268 Scope = ConcreteScopes.lookup(IA); 2269 if (Scope == 0) 2270 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx)); 2271 2272 // If variable scope is not found then skip this variable. 2273 if (Scope == 0) 2274 continue; 2275 2276 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second); 2277 DbgVariable *RegVar = new DbgVariable(DV); 2278 recordVariableFrameIndex(RegVar, VP.first); 2279 Scope->addVariable(RegVar); 2280 if (AbsDbgVariable) { 2281 recordVariableFrameIndex(AbsDbgVariable, VP.first); 2282 VarToAbstractVarMap[RegVar] = AbsDbgVariable; 2283 } 2284 } 2285} 2286 2287/// isDbgValueInUndefinedReg - Return true if debug value, encoded by 2288/// DBG_VALUE instruction, is in undefined reg. 2289static bool isDbgValueInUndefinedReg(const MachineInstr *MI) { 2290 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 2291 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg()) 2292 return true; 2293 return false; 2294} 2295 2296/// isDbgValueInDefinedReg - Return true if debug value, encoded by 2297/// DBG_VALUE instruction, is in a defined reg. 2298static bool isDbgValueInDefinedReg(const MachineInstr *MI) { 2299 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 2300 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg()) 2301 return true; 2302 return false; 2303} 2304 2305/// collectVariableInfo - Populate DbgScope entries with variables' info. 2306void 2307DwarfDebug::collectVariableInfo(const MachineFunction *MF, 2308 SmallPtrSet<const MDNode *, 16> &Processed) { 2309 2310 /// collection info from MMI table. 2311 collectVariableInfoFromMMITable(MF, Processed); 2312 2313 SmallVector<const MachineInstr *, 8> DbgValues; 2314 // Collect variable information from DBG_VALUE machine instructions; 2315 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 2316 I != E; ++I) 2317 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2318 II != IE; ++II) { 2319 const MachineInstr *MInsn = II; 2320 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn)) 2321 continue; 2322 DbgValues.push_back(MInsn); 2323 } 2324 2325 // This is a collection of DBV_VALUE instructions describing same variable. 2326 SmallVector<const MachineInstr *, 4> MultipleValues; 2327 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(), 2328 E = DbgValues.end(); I != E; ++I) { 2329 const MachineInstr *MInsn = *I; 2330 MultipleValues.clear(); 2331 if (isDbgValueInDefinedReg(MInsn)) 2332 MultipleValues.push_back(MInsn); 2333 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata()); 2334 if (Processed.count(DV) != 0) 2335 continue; 2336 2337 const MachineInstr *PrevMI = MInsn; 2338 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1, 2339 ME = DbgValues.end(); MI != ME; ++MI) { 2340 const MDNode *Var = 2341 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata(); 2342 if (Var == DV && isDbgValueInDefinedReg(*MI) && 2343 !PrevMI->isIdenticalTo(*MI)) 2344 MultipleValues.push_back(*MI); 2345 PrevMI = *MI; 2346 } 2347 2348 DbgScope *Scope = findDbgScope(MInsn); 2349 bool CurFnArg = false; 2350 if (DV.getTag() == dwarf::DW_TAG_arg_variable && 2351 DISubprogram(DV.getContext()).describes(MF->getFunction())) 2352 CurFnArg = true; 2353 if (!Scope && CurFnArg) 2354 Scope = CurrentFnDbgScope; 2355 // If variable scope is not found then skip this variable. 2356 if (!Scope) 2357 continue; 2358 2359 Processed.insert(DV); 2360 DbgVariable *RegVar = new DbgVariable(DV); 2361 Scope->addVariable(RegVar); 2362 if (!CurFnArg) 2363 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn); 2364 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) { 2365 DbgVariableToDbgInstMap[AbsVar] = MInsn; 2366 VarToAbstractVarMap[RegVar] = AbsVar; 2367 } 2368 if (MultipleValues.size() <= 1) { 2369 DbgVariableToDbgInstMap[RegVar] = MInsn; 2370 continue; 2371 } 2372 2373 // handle multiple DBG_VALUE instructions describing one variable. 2374 if (DotDebugLocEntries.empty()) 2375 RegVar->setDotDebugLocOffset(0); 2376 else 2377 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size()); 2378 const MachineInstr *Begin = NULL; 2379 const MachineInstr *End = NULL; 2380 for (SmallVector<const MachineInstr *, 4>::iterator 2381 MVI = MultipleValues.begin(), MVE = MultipleValues.end(); 2382 MVI != MVE; ++MVI) { 2383 if (!Begin) { 2384 Begin = *MVI; 2385 continue; 2386 } 2387 End = *MVI; 2388 MachineLocation MLoc; 2389 if (Begin->getNumOperands() == 3) { 2390 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm()) 2391 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm()); 2392 } else 2393 MLoc = Asm->getDebugValueLocation(Begin); 2394 2395 const MCSymbol *FLabel = getLabelBeforeInsn(Begin); 2396 const MCSymbol *SLabel = getLabelBeforeInsn(End); 2397 if (MLoc.getReg()) 2398 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc)); 2399 2400 Begin = End; 2401 if (MVI + 1 == MVE) { 2402 // If End is the last instruction then its value is valid 2403 // until the end of the funtion. 2404 MachineLocation EMLoc; 2405 if (End->getNumOperands() == 3) { 2406 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm()) 2407 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm()); 2408 } else 2409 EMLoc = Asm->getDebugValueLocation(End); 2410 if (EMLoc.getReg()) 2411 DotDebugLocEntries. 2412 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc)); 2413 } 2414 } 2415 DotDebugLocEntries.push_back(DotDebugLocEntry()); 2416 } 2417 2418 // Collect info for variables that were optimized out. 2419 const Function *F = MF->getFunction(); 2420 const Module *M = F->getParent(); 2421 if (NamedMDNode *NMD = 2422 M->getNamedMetadata(Twine("llvm.dbg.lv.", 2423 getRealLinkageName(F->getName())))) { 2424 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2425 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 2426 if (!DV || !Processed.insert(DV)) 2427 continue; 2428 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext()); 2429 if (Scope) 2430 Scope->addVariable(new DbgVariable(DV)); 2431 } 2432 } 2433} 2434 2435/// getLabelBeforeInsn - Return Label preceding the instruction. 2436const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { 2437 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 2438 LabelsBeforeInsn.find(MI); 2439 if (I == LabelsBeforeInsn.end()) 2440 // FunctionBeginSym always preceeds all the instruction in current function. 2441 return FunctionBeginSym; 2442 return I->second; 2443} 2444 2445/// getLabelAfterInsn - Return Label immediately following the instruction. 2446const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { 2447 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 2448 LabelsAfterInsn.find(MI); 2449 if (I == LabelsAfterInsn.end()) 2450 return NULL; 2451 return I->second; 2452} 2453 2454/// beginScope - Process beginning of a scope. 2455void DwarfDebug::beginScope(const MachineInstr *MI) { 2456 if (InsnNeedsLabel.count(MI) == 0) { 2457 LabelsBeforeInsn[MI] = PrevLabel; 2458 return; 2459 } 2460 2461 // Check location. 2462 DebugLoc DL = MI->getDebugLoc(); 2463 if (!DL.isUnknown()) { 2464 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 2465 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope); 2466 PrevInstLoc = DL; 2467 LabelsBeforeInsn[MI] = PrevLabel; 2468 return; 2469 } 2470 2471 // If location is unknown then use temp label for this DBG_VALUE 2472 // instruction. 2473 if (MI->isDebugValue()) { 2474 PrevLabel = MMI->getContext().CreateTempSymbol(); 2475 Asm->OutStreamer.EmitLabel(PrevLabel); 2476 LabelsBeforeInsn[MI] = PrevLabel; 2477 return; 2478 } 2479 2480 if (UnknownLocations) { 2481 PrevLabel = recordSourceLine(0, 0, 0); 2482 LabelsBeforeInsn[MI] = PrevLabel; 2483 return; 2484 } 2485 2486 assert (0 && "Instruction is not processed!"); 2487} 2488 2489/// endScope - Process end of a scope. 2490void DwarfDebug::endScope(const MachineInstr *MI) { 2491 if (InsnsEndScopeSet.count(MI) != 0) { 2492 // Emit a label if this instruction ends a scope. 2493 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2494 Asm->OutStreamer.EmitLabel(Label); 2495 LabelsAfterInsn[MI] = Label; 2496 } 2497} 2498 2499/// getOrCreateDbgScope - Create DbgScope for the scope. 2500DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, 2501 const MDNode *InlinedAt) { 2502 if (!InlinedAt) { 2503 DbgScope *WScope = DbgScopeMap.lookup(Scope); 2504 if (WScope) 2505 return WScope; 2506 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL); 2507 DbgScopeMap.insert(std::make_pair(Scope, WScope)); 2508 if (DIDescriptor(Scope).isLexicalBlock()) { 2509 DbgScope *Parent = 2510 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL); 2511 WScope->setParent(Parent); 2512 Parent->addScope(WScope); 2513 } 2514 2515 if (!WScope->getParent()) { 2516 StringRef SPName = DISubprogram(Scope).getLinkageName(); 2517 // We used to check only for a linkage name, but that fails 2518 // since we began omitting the linkage name for private 2519 // functions. The new way is to check for the name in metadata, 2520 // but that's not supported in old .ll test cases. Ergo, we 2521 // check both. 2522 if (SPName == Asm->MF->getFunction()->getName() || 2523 DISubprogram(Scope).getFunction() == Asm->MF->getFunction()) 2524 CurrentFnDbgScope = WScope; 2525 } 2526 2527 return WScope; 2528 } 2529 2530 getOrCreateAbstractScope(Scope); 2531 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt); 2532 if (WScope) 2533 return WScope; 2534 2535 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt); 2536 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope)); 2537 DILocation DL(InlinedAt); 2538 DbgScope *Parent = 2539 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation()); 2540 WScope->setParent(Parent); 2541 Parent->addScope(WScope); 2542 2543 ConcreteScopes[InlinedAt] = WScope; 2544 2545 return WScope; 2546} 2547 2548/// hasValidLocation - Return true if debug location entry attached with 2549/// machine instruction encodes valid location info. 2550static bool hasValidLocation(LLVMContext &Ctx, 2551 const MachineInstr *MInsn, 2552 const MDNode *&Scope, const MDNode *&InlinedAt) { 2553 DebugLoc DL = MInsn->getDebugLoc(); 2554 if (DL.isUnknown()) return false; 2555 2556 const MDNode *S = DL.getScope(Ctx); 2557 2558 // There is no need to create another DIE for compile unit. For all 2559 // other scopes, create one DbgScope now. This will be translated 2560 // into a scope DIE at the end. 2561 if (DIScope(S).isCompileUnit()) return false; 2562 2563 Scope = S; 2564 InlinedAt = DL.getInlinedAt(Ctx); 2565 return true; 2566} 2567 2568/// calculateDominanceGraph - Calculate dominance graph for DbgScope 2569/// hierarchy. 2570static void calculateDominanceGraph(DbgScope *Scope) { 2571 assert (Scope && "Unable to calculate scop edominance graph!"); 2572 SmallVector<DbgScope *, 4> WorkStack; 2573 WorkStack.push_back(Scope); 2574 unsigned Counter = 0; 2575 while (!WorkStack.empty()) { 2576 DbgScope *WS = WorkStack.back(); 2577 const SmallVector<DbgScope *, 4> &Children = WS->getScopes(); 2578 bool visitedChildren = false; 2579 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2580 SE = Children.end(); SI != SE; ++SI) { 2581 DbgScope *ChildScope = *SI; 2582 if (!ChildScope->getDFSOut()) { 2583 WorkStack.push_back(ChildScope); 2584 visitedChildren = true; 2585 ChildScope->setDFSIn(++Counter); 2586 break; 2587 } 2588 } 2589 if (!visitedChildren) { 2590 WorkStack.pop_back(); 2591 WS->setDFSOut(++Counter); 2592 } 2593 } 2594} 2595 2596/// printDbgScopeInfo - Print DbgScope info for each machine instruction. 2597static 2598void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF, 2599 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap) 2600{ 2601#ifndef NDEBUG 2602 unsigned PrevDFSIn = 0; 2603 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2604 I != E; ++I) { 2605 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2606 II != IE; ++II) { 2607 const MachineInstr *MInsn = II; 2608 const MDNode *Scope = NULL; 2609 const MDNode *InlinedAt = NULL; 2610 2611 // Check if instruction has valid location information. 2612 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2613 dbgs() << " [ "; 2614 if (InlinedAt) 2615 dbgs() << "*"; 2616 DenseMap<const MachineInstr *, DbgScope *>::iterator DI = 2617 MI2ScopeMap.find(MInsn); 2618 if (DI != MI2ScopeMap.end()) { 2619 DbgScope *S = DI->second; 2620 dbgs() << S->getDFSIn(); 2621 PrevDFSIn = S->getDFSIn(); 2622 } else 2623 dbgs() << PrevDFSIn; 2624 } else 2625 dbgs() << " [ x" << PrevDFSIn; 2626 dbgs() << " ]"; 2627 MInsn->dump(); 2628 } 2629 dbgs() << "\n"; 2630 } 2631#endif 2632} 2633/// extractScopeInformation - Scan machine instructions in this function 2634/// and collect DbgScopes. Return true, if at least one scope was found. 2635bool DwarfDebug::extractScopeInformation() { 2636 // If scope information was extracted using .dbg intrinsics then there is not 2637 // any need to extract these information by scanning each instruction. 2638 if (!DbgScopeMap.empty()) 2639 return false; 2640 2641 // Scan each instruction and create scopes. First build working set of scopes. 2642 LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2643 SmallVector<DbgRange, 4> MIRanges; 2644 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap; 2645 const MDNode *PrevScope = NULL; 2646 const MDNode *PrevInlinedAt = NULL; 2647 const MachineInstr *RangeBeginMI = NULL; 2648 const MachineInstr *PrevMI = NULL; 2649 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 2650 I != E; ++I) { 2651 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2652 II != IE; ++II) { 2653 const MachineInstr *MInsn = II; 2654 const MDNode *Scope = NULL; 2655 const MDNode *InlinedAt = NULL; 2656 2657 // Check if instruction has valid location information. 2658 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2659 PrevMI = MInsn; 2660 continue; 2661 } 2662 2663 // If scope has not changed then skip this instruction. 2664 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) { 2665 PrevMI = MInsn; 2666 continue; 2667 } 2668 2669 if (RangeBeginMI) { 2670 // If we have alread seen a beginning of a instruction range and 2671 // current instruction scope does not match scope of first instruction 2672 // in this range then create a new instruction range. 2673 DbgRange R(RangeBeginMI, PrevMI); 2674 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, 2675 PrevInlinedAt); 2676 MIRanges.push_back(R); 2677 } 2678 2679 // This is a beginning of a new instruction range. 2680 RangeBeginMI = MInsn; 2681 2682 // Reset previous markers. 2683 PrevMI = MInsn; 2684 PrevScope = Scope; 2685 PrevInlinedAt = InlinedAt; 2686 } 2687 } 2688 2689 // Create last instruction range. 2690 if (RangeBeginMI && PrevMI && PrevScope) { 2691 DbgRange R(RangeBeginMI, PrevMI); 2692 MIRanges.push_back(R); 2693 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt); 2694 } 2695 2696 if (!CurrentFnDbgScope) 2697 return false; 2698 2699 calculateDominanceGraph(CurrentFnDbgScope); 2700 if (PrintDbgScope) 2701 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap); 2702 2703 // Find ranges of instructions covered by each DbgScope; 2704 DbgScope *PrevDbgScope = NULL; 2705 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(), 2706 RE = MIRanges.end(); RI != RE; ++RI) { 2707 const DbgRange &R = *RI; 2708 DbgScope *S = MI2ScopeMap.lookup(R.first); 2709 assert (S && "Lost DbgScope for a machine instruction!"); 2710 if (PrevDbgScope && !PrevDbgScope->dominates(S)) 2711 PrevDbgScope->closeInsnRange(S); 2712 S->openInsnRange(R.first); 2713 S->extendInsnRange(R.second); 2714 PrevDbgScope = S; 2715 } 2716 2717 if (PrevDbgScope) 2718 PrevDbgScope->closeInsnRange(); 2719 2720 identifyScopeMarkers(); 2721 2722 return !DbgScopeMap.empty(); 2723} 2724 2725/// identifyScopeMarkers() - 2726/// Each DbgScope has first instruction and last instruction to mark beginning 2727/// and end of a scope respectively. Create an inverse map that list scopes 2728/// starts (and ends) with an instruction. One instruction may start (or end) 2729/// multiple scopes. Ignore scopes that are not reachable. 2730void DwarfDebug::identifyScopeMarkers() { 2731 SmallVector<DbgScope *, 4> WorkList; 2732 WorkList.push_back(CurrentFnDbgScope); 2733 while (!WorkList.empty()) { 2734 DbgScope *S = WorkList.pop_back_val(); 2735 2736 const SmallVector<DbgScope *, 4> &Children = S->getScopes(); 2737 if (!Children.empty()) 2738 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2739 SE = Children.end(); SI != SE; ++SI) 2740 WorkList.push_back(*SI); 2741 2742 if (S->isAbstractScope()) 2743 continue; 2744 2745 const SmallVector<DbgRange, 4> &Ranges = S->getRanges(); 2746 if (Ranges.empty()) 2747 continue; 2748 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 2749 RE = Ranges.end(); RI != RE; ++RI) { 2750 assert(RI->first && "DbgRange does not have first instruction!"); 2751 assert(RI->second && "DbgRange does not have second instruction!"); 2752 InsnsEndScopeSet.insert(RI->second); 2753 } 2754 } 2755} 2756 2757/// FindFirstDebugLoc - Find the first debug location in the function. This 2758/// is intended to be an approximation for the source position of the 2759/// beginning of the function. 2760static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) { 2761 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2762 I != E; ++I) 2763 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end(); 2764 MBBI != MBBE; ++MBBI) { 2765 DebugLoc DL = MBBI->getDebugLoc(); 2766 if (!DL.isUnknown()) 2767 return DL; 2768 } 2769 return DebugLoc(); 2770} 2771 2772/// beginFunction - Gather pre-function debug information. Assumes being 2773/// emitted immediately after the function entry point. 2774void DwarfDebug::beginFunction(const MachineFunction *MF) { 2775 if (!MMI->hasDebugInfo()) return; 2776 if (!extractScopeInformation()) return; 2777 2778 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 2779 Asm->getFunctionNumber()); 2780 // Assumes in correct section after the entry point. 2781 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 2782 2783 // Emit label for the implicitly defined dbg.stoppoint at the start of the 2784 // function. 2785 DebugLoc FDL = FindFirstDebugLoc(MF); 2786 if (FDL.isUnknown()) return; 2787 2788 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext()); 2789 const MDNode *TheScope = 0; 2790 2791 DISubprogram SP = getDISubprogram(Scope); 2792 unsigned Line, Col; 2793 if (SP.Verify()) { 2794 Line = SP.getLineNumber(); 2795 Col = 0; 2796 TheScope = SP; 2797 } else { 2798 Line = FDL.getLine(); 2799 Col = FDL.getCol(); 2800 TheScope = Scope; 2801 } 2802 2803 recordSourceLine(Line, Col, TheScope); 2804 2805 /// ProcessedArgs - Collection of arguments already processed. 2806 SmallPtrSet<const MDNode *, 8> ProcessedArgs; 2807 2808 DebugLoc PrevLoc; 2809 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2810 I != E; ++I) 2811 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2812 II != IE; ++II) { 2813 const MachineInstr *MI = II; 2814 DebugLoc DL = MI->getDebugLoc(); 2815 if (MI->isDebugValue()) { 2816 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!"); 2817 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata()); 2818 if (!DV.Verify()) continue; 2819 // If DBG_VALUE is for a local variable then it needs a label. 2820 if (DV.getTag() != dwarf::DW_TAG_arg_variable 2821 && isDbgValueInUndefinedReg(MI) == false) 2822 InsnNeedsLabel.insert(MI); 2823 // DBG_VALUE for inlined functions argument needs a label. 2824 else if (!DISubprogram(getDISubprogram(DV.getContext())). 2825 describes(MF->getFunction())) 2826 InsnNeedsLabel.insert(MI); 2827 // DBG_VALUE indicating argument location change needs a label. 2828 else if (isDbgValueInUndefinedReg(MI) == false 2829 && !ProcessedArgs.insert(DV)) 2830 InsnNeedsLabel.insert(MI); 2831 } else { 2832 // If location is unknown then instruction needs a location only if 2833 // UnknownLocations flag is set. 2834 if (DL.isUnknown()) { 2835 if (UnknownLocations && !PrevLoc.isUnknown()) 2836 InsnNeedsLabel.insert(MI); 2837 } else if (DL != PrevLoc) 2838 // Otherwise, instruction needs a location only if it is new location. 2839 InsnNeedsLabel.insert(MI); 2840 } 2841 2842 if (!DL.isUnknown() || UnknownLocations) 2843 PrevLoc = DL; 2844 } 2845 2846 PrevLabel = FunctionBeginSym; 2847} 2848 2849/// endFunction - Gather and emit post-function debug information. 2850/// 2851void DwarfDebug::endFunction(const MachineFunction *MF) { 2852 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return; 2853 2854 if (CurrentFnDbgScope) { 2855 2856 // Define end label for subprogram. 2857 FunctionEndSym = Asm->GetTempSymbol("func_end", 2858 Asm->getFunctionNumber()); 2859 // Assumes in correct section after the entry point. 2860 Asm->OutStreamer.EmitLabel(FunctionEndSym); 2861 2862 SmallPtrSet<const MDNode *, 16> ProcessedVars; 2863 collectVariableInfo(MF, ProcessedVars); 2864 2865 // Get function line info. 2866 if (!Lines.empty()) { 2867 // Get section line info. 2868 unsigned ID = SectionMap.insert(Asm->getCurrentSection()); 2869 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID); 2870 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1]; 2871 // Append the function info to section info. 2872 SectionLineInfos.insert(SectionLineInfos.end(), 2873 Lines.begin(), Lines.end()); 2874 } 2875 2876 // Construct abstract scopes. 2877 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2878 AE = AbstractScopesList.end(); AI != AE; ++AI) { 2879 DISubprogram SP((*AI)->getScopeNode()); 2880 if (SP.Verify()) { 2881 // Collect info for variables that were optimized out. 2882 StringRef FName = SP.getLinkageName(); 2883 if (FName.empty()) 2884 FName = SP.getName(); 2885 const Module *M = MF->getFunction()->getParent(); 2886 if (NamedMDNode *NMD = 2887 M->getNamedMetadata(Twine("llvm.dbg.lv.", 2888 getRealLinkageName(FName)))) { 2889 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2890 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 2891 if (!DV || !ProcessedVars.insert(DV)) 2892 continue; 2893 DbgScope *Scope = AbstractScopes.lookup(DV.getContext()); 2894 if (Scope) 2895 Scope->addVariable(new DbgVariable(DV)); 2896 } 2897 } 2898 } 2899 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0) 2900 constructScopeDIE(*AI); 2901 } 2902 2903 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope); 2904 2905 if (!DisableFramePointerElim(*MF)) 2906 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr, 2907 dwarf::DW_FORM_flag, 1); 2908 2909 2910 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(), 2911 MMI->getFrameMoves())); 2912 } 2913 2914 // Clear debug info 2915 CurrentFnDbgScope = NULL; 2916 InsnNeedsLabel.clear(); 2917 DbgVariableToFrameIndexMap.clear(); 2918 VarToAbstractVarMap.clear(); 2919 DbgVariableToDbgInstMap.clear(); 2920 DbgVariableLabelsMap.clear(); 2921 DeleteContainerSeconds(DbgScopeMap); 2922 InsnsEndScopeSet.clear(); 2923 ConcreteScopes.clear(); 2924 DeleteContainerSeconds(AbstractScopes); 2925 AbstractScopesList.clear(); 2926 AbstractVariables.clear(); 2927 LabelsBeforeInsn.clear(); 2928 LabelsAfterInsn.clear(); 2929 Lines.clear(); 2930 PrevLabel = NULL; 2931} 2932 2933/// recordVariableFrameIndex - Record a variable's index. 2934void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) { 2935 assert (V && "Invalid DbgVariable!"); 2936 DbgVariableToFrameIndexMap[V] = Index; 2937} 2938 2939/// findVariableFrameIndex - Return true if frame index for the variable 2940/// is found. Update FI to hold value of the index. 2941bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) { 2942 assert (V && "Invalid DbgVariable!"); 2943 DenseMap<const DbgVariable *, int>::iterator I = 2944 DbgVariableToFrameIndexMap.find(V); 2945 if (I == DbgVariableToFrameIndexMap.end()) 2946 return false; 2947 *FI = I->second; 2948 return true; 2949} 2950 2951/// findVariableLabel - Find MCSymbol for the variable. 2952const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) { 2953 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I 2954 = DbgVariableLabelsMap.find(V); 2955 if (I == DbgVariableLabelsMap.end()) 2956 return NULL; 2957 else return I->second; 2958} 2959 2960/// findDbgScope - Find DbgScope for the debug loc attached with an 2961/// instruction. 2962DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) { 2963 DbgScope *Scope = NULL; 2964 LLVMContext &Ctx = 2965 MInsn->getParent()->getParent()->getFunction()->getContext(); 2966 DebugLoc DL = MInsn->getDebugLoc(); 2967 2968 if (DL.isUnknown()) 2969 return Scope; 2970 2971 if (const MDNode *IA = DL.getInlinedAt(Ctx)) 2972 Scope = ConcreteScopes.lookup(IA); 2973 if (Scope == 0) 2974 Scope = DbgScopeMap.lookup(DL.getScope(Ctx)); 2975 2976 return Scope; 2977} 2978 2979 2980/// recordSourceLine - Register a source line with debug info. Returns the 2981/// unique label that was emitted and which provides correspondence to 2982/// the source line list. 2983MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, 2984 const MDNode *S) { 2985 StringRef Dir; 2986 StringRef Fn; 2987 2988 unsigned Src = 1; 2989 if (S) { 2990 DIDescriptor Scope(S); 2991 2992 if (Scope.isCompileUnit()) { 2993 DICompileUnit CU(S); 2994 Dir = CU.getDirectory(); 2995 Fn = CU.getFilename(); 2996 } else if (Scope.isSubprogram()) { 2997 DISubprogram SP(S); 2998 Dir = SP.getDirectory(); 2999 Fn = SP.getFilename(); 3000 } else if (Scope.isLexicalBlock()) { 3001 DILexicalBlock DB(S); 3002 Dir = DB.getDirectory(); 3003 Fn = DB.getFilename(); 3004 } else 3005 assert(0 && "Unexpected scope info"); 3006 3007 Src = GetOrCreateSourceID(Dir, Fn); 3008 } 3009 3010 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 3011 Lines.push_back(SrcLineInfo(Line, Col, Src, Label)); 3012 3013 Asm->OutStreamer.EmitLabel(Label); 3014 return Label; 3015} 3016 3017//===----------------------------------------------------------------------===// 3018// Emit Methods 3019//===----------------------------------------------------------------------===// 3020 3021/// computeSizeAndOffset - Compute the size and offset of a DIE. 3022/// 3023unsigned 3024DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) { 3025 // Get the children. 3026 const std::vector<DIE *> &Children = Die->getChildren(); 3027 3028 // If not last sibling and has children then add sibling offset attribute. 3029 if (!Last && !Children.empty()) 3030 Die->addSiblingOffset(DIEValueAllocator); 3031 3032 // Record the abbreviation. 3033 assignAbbrevNumber(Die->getAbbrev()); 3034 3035 // Get the abbreviation for this DIE. 3036 unsigned AbbrevNumber = Die->getAbbrevNumber(); 3037 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 3038 3039 // Set DIE offset 3040 Die->setOffset(Offset); 3041 3042 // Start the size with the size of abbreviation code. 3043 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 3044 3045 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 3046 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 3047 3048 // Size the DIE attribute values. 3049 for (unsigned i = 0, N = Values.size(); i < N; ++i) 3050 // Size attribute value. 3051 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm()); 3052 3053 // Size the DIE children if any. 3054 if (!Children.empty()) { 3055 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 3056 "Children flag not set"); 3057 3058 for (unsigned j = 0, M = Children.size(); j < M; ++j) 3059 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M); 3060 3061 // End of children marker. 3062 Offset += sizeof(int8_t); 3063 } 3064 3065 Die->setSize(Offset - Die->getOffset()); 3066 return Offset; 3067} 3068 3069/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 3070/// 3071void DwarfDebug::computeSizeAndOffsets() { 3072 unsigned PrevOffset = 0; 3073 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3074 E = CUMap.end(); I != E; ++I) { 3075 // Compute size of compile unit header. 3076 static unsigned Offset = PrevOffset + 3077 sizeof(int32_t) + // Length of Compilation Unit Info 3078 sizeof(int16_t) + // DWARF version number 3079 sizeof(int32_t) + // Offset Into Abbrev. Section 3080 sizeof(int8_t); // Pointer Size (in bytes) 3081 computeSizeAndOffset(I->second->getCUDie(), Offset, true); 3082 PrevOffset = Offset; 3083 } 3084} 3085 3086/// EmitSectionSym - Switch to the specified MCSection and emit an assembler 3087/// temporary label to it if SymbolStem is specified. 3088static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section, 3089 const char *SymbolStem = 0) { 3090 Asm->OutStreamer.SwitchSection(Section); 3091 if (!SymbolStem) return 0; 3092 3093 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem); 3094 Asm->OutStreamer.EmitLabel(TmpSym); 3095 return TmpSym; 3096} 3097 3098/// EmitSectionLabels - Emit initial Dwarf sections with a label at 3099/// the start of each one. 3100void DwarfDebug::EmitSectionLabels() { 3101 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 3102 3103 // Dwarf sections base addresses. 3104 if (Asm->MAI->doesDwarfRequireFrameSection()) { 3105 DwarfFrameSectionSym = 3106 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame"); 3107 } 3108 3109 DwarfInfoSectionSym = 3110 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 3111 DwarfAbbrevSectionSym = 3112 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 3113 EmitSectionSym(Asm, TLOF.getDwarfARangesSection()); 3114 3115 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 3116 EmitSectionSym(Asm, MacroInfo); 3117 3118 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line"); 3119 EmitSectionSym(Asm, TLOF.getDwarfLocSection()); 3120 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 3121 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 3122 DwarfStrSectionSym = 3123 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str"); 3124 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(), 3125 "debug_range"); 3126 3127 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(), 3128 "section_debug_loc"); 3129 3130 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 3131 EmitSectionSym(Asm, TLOF.getDataSection()); 3132} 3133 3134/// emitDIE - Recusively Emits a debug information entry. 3135/// 3136void DwarfDebug::emitDIE(DIE *Die) { 3137 // Get the abbreviation for this DIE. 3138 unsigned AbbrevNumber = Die->getAbbrevNumber(); 3139 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 3140 3141 // Emit the code (index) for the abbreviation. 3142 if (Asm->isVerbose()) 3143 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 3144 Twine::utohexstr(Die->getOffset()) + ":0x" + 3145 Twine::utohexstr(Die->getSize()) + " " + 3146 dwarf::TagString(Abbrev->getTag())); 3147 Asm->EmitULEB128(AbbrevNumber); 3148 3149 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 3150 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 3151 3152 // Emit the DIE attribute values. 3153 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 3154 unsigned Attr = AbbrevData[i].getAttribute(); 3155 unsigned Form = AbbrevData[i].getForm(); 3156 assert(Form && "Too many attributes for DIE (check abbreviation)"); 3157 3158 if (Asm->isVerbose()) 3159 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 3160 3161 switch (Attr) { 3162 case dwarf::DW_AT_sibling: 3163 Asm->EmitInt32(Die->getSiblingOffset()); 3164 break; 3165 case dwarf::DW_AT_abstract_origin: { 3166 DIEEntry *E = cast<DIEEntry>(Values[i]); 3167 DIE *Origin = E->getEntry(); 3168 unsigned Addr = Origin->getOffset(); 3169 Asm->EmitInt32(Addr); 3170 break; 3171 } 3172 case dwarf::DW_AT_ranges: { 3173 // DW_AT_range Value encodes offset in debug_range section. 3174 DIEInteger *V = cast<DIEInteger>(Values[i]); 3175 3176 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) { 3177 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym, 3178 V->getValue(), 3179 4); 3180 } else { 3181 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym, 3182 V->getValue(), 3183 DwarfDebugRangeSectionSym, 3184 4); 3185 } 3186 break; 3187 } 3188 case dwarf::DW_AT_location: { 3189 if (UseDotDebugLocEntry.count(Die) != 0) { 3190 DIELabel *L = cast<DIELabel>(Values[i]); 3191 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4); 3192 } else 3193 Values[i]->EmitValue(Asm, Form); 3194 break; 3195 } 3196 case dwarf::DW_AT_accessibility: { 3197 if (Asm->isVerbose()) { 3198 DIEInteger *V = cast<DIEInteger>(Values[i]); 3199 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue())); 3200 } 3201 Values[i]->EmitValue(Asm, Form); 3202 break; 3203 } 3204 default: 3205 // Emit an attribute using the defined form. 3206 Values[i]->EmitValue(Asm, Form); 3207 break; 3208 } 3209 } 3210 3211 // Emit the DIE children if any. 3212 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 3213 const std::vector<DIE *> &Children = Die->getChildren(); 3214 3215 for (unsigned j = 0, M = Children.size(); j < M; ++j) 3216 emitDIE(Children[j]); 3217 3218 if (Asm->isVerbose()) 3219 Asm->OutStreamer.AddComment("End Of Children Mark"); 3220 Asm->EmitInt8(0); 3221 } 3222} 3223 3224/// emitDebugInfo - Emit the debug info section. 3225/// 3226void DwarfDebug::emitDebugInfo() { 3227 // Start debug info section. 3228 Asm->OutStreamer.SwitchSection( 3229 Asm->getObjFileLowering().getDwarfInfoSection()); 3230 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3231 E = CUMap.end(); I != E; ++I) { 3232 CompileUnit *TheCU = I->second; 3233 DIE *Die = TheCU->getCUDie(); 3234 3235 // Emit the compile units header. 3236 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin", 3237 TheCU->getID())); 3238 3239 // Emit size of content not including length itself 3240 unsigned ContentSize = Die->getSize() + 3241 sizeof(int16_t) + // DWARF version number 3242 sizeof(int32_t) + // Offset Into Abbrev. Section 3243 sizeof(int8_t) + // Pointer Size (in bytes) 3244 sizeof(int32_t); // FIXME - extra pad for gdb bug. 3245 3246 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 3247 Asm->EmitInt32(ContentSize); 3248 Asm->OutStreamer.AddComment("DWARF version number"); 3249 Asm->EmitInt16(dwarf::DWARF_VERSION); 3250 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 3251 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"), 3252 DwarfAbbrevSectionSym); 3253 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 3254 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 3255 3256 emitDIE(Die); 3257 // FIXME - extra padding for gdb bug. 3258 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB"); 3259 Asm->EmitInt8(0); 3260 Asm->EmitInt8(0); 3261 Asm->EmitInt8(0); 3262 Asm->EmitInt8(0); 3263 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID())); 3264 } 3265} 3266 3267/// emitAbbreviations - Emit the abbreviation section. 3268/// 3269void DwarfDebug::emitAbbreviations() const { 3270 // Check to see if it is worth the effort. 3271 if (!Abbreviations.empty()) { 3272 // Start the debug abbrev section. 3273 Asm->OutStreamer.SwitchSection( 3274 Asm->getObjFileLowering().getDwarfAbbrevSection()); 3275 3276 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin")); 3277 3278 // For each abbrevation. 3279 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 3280 // Get abbreviation data 3281 const DIEAbbrev *Abbrev = Abbreviations[i]; 3282 3283 // Emit the abbrevations code (base 1 index.) 3284 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 3285 3286 // Emit the abbreviations data. 3287 Abbrev->Emit(Asm); 3288 } 3289 3290 // Mark end of abbreviations. 3291 Asm->EmitULEB128(0, "EOM(3)"); 3292 3293 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end")); 3294 } 3295} 3296 3297/// emitEndOfLineMatrix - Emit the last address of the section and the end of 3298/// the line matrix. 3299/// 3300void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 3301 // Define last address of section. 3302 Asm->OutStreamer.AddComment("Extended Op"); 3303 Asm->EmitInt8(0); 3304 3305 Asm->OutStreamer.AddComment("Op size"); 3306 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1); 3307 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 3308 Asm->EmitInt8(dwarf::DW_LNE_set_address); 3309 3310 Asm->OutStreamer.AddComment("Section end label"); 3311 3312 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 3313 Asm->getTargetData().getPointerSize(), 3314 0/*AddrSpace*/); 3315 3316 // Mark end of matrix. 3317 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 3318 Asm->EmitInt8(0); 3319 Asm->EmitInt8(1); 3320 Asm->EmitInt8(1); 3321} 3322 3323/// emitDebugLines - Emit source line information. 3324/// 3325void DwarfDebug::emitDebugLines() { 3326 // If the target is using .loc/.file, the assembler will be emitting the 3327 // .debug_line table automatically. 3328 if (Asm->MAI->hasDotLocAndDotFile()) 3329 return; 3330 3331 // Minimum line delta, thus ranging from -10..(255-10). 3332 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1); 3333 // Maximum line delta, thus ranging from -10..(255-10). 3334 const int MaxLineDelta = 255 + MinLineDelta; 3335 3336 // Start the dwarf line section. 3337 Asm->OutStreamer.SwitchSection( 3338 Asm->getObjFileLowering().getDwarfLineSection()); 3339 3340 // Construct the section header. 3341 Asm->OutStreamer.AddComment("Length of Source Line Info"); 3342 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"), 3343 Asm->GetTempSymbol("line_begin"), 4); 3344 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin")); 3345 3346 Asm->OutStreamer.AddComment("DWARF version number"); 3347 Asm->EmitInt16(dwarf::DWARF_VERSION); 3348 3349 Asm->OutStreamer.AddComment("Prolog Length"); 3350 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"), 3351 Asm->GetTempSymbol("line_prolog_begin"), 4); 3352 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin")); 3353 3354 Asm->OutStreamer.AddComment("Minimum Instruction Length"); 3355 Asm->EmitInt8(1); 3356 Asm->OutStreamer.AddComment("Default is_stmt_start flag"); 3357 Asm->EmitInt8(1); 3358 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)"); 3359 Asm->EmitInt8(MinLineDelta); 3360 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)"); 3361 Asm->EmitInt8(MaxLineDelta); 3362 Asm->OutStreamer.AddComment("Special Opcode Base"); 3363 Asm->EmitInt8(-MinLineDelta); 3364 3365 // Line number standard opcode encodings argument count 3366 Asm->OutStreamer.AddComment("DW_LNS_copy arg count"); 3367 Asm->EmitInt8(0); 3368 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count"); 3369 Asm->EmitInt8(1); 3370 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count"); 3371 Asm->EmitInt8(1); 3372 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count"); 3373 Asm->EmitInt8(1); 3374 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count"); 3375 Asm->EmitInt8(1); 3376 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count"); 3377 Asm->EmitInt8(0); 3378 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count"); 3379 Asm->EmitInt8(0); 3380 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count"); 3381 Asm->EmitInt8(0); 3382 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count"); 3383 Asm->EmitInt8(1); 3384 3385 // Emit directories. 3386 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) { 3387 const std::string &Dir = getSourceDirectoryName(DI); 3388 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory"); 3389 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0); 3390 } 3391 3392 Asm->OutStreamer.AddComment("End of directories"); 3393 Asm->EmitInt8(0); 3394 3395 // Emit files. 3396 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) { 3397 // Remember source id starts at 1. 3398 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI); 3399 const std::string &FN = getSourceFileName(Id.second); 3400 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source"); 3401 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0); 3402 3403 Asm->EmitULEB128(Id.first, "Directory #"); 3404 Asm->EmitULEB128(0, "Mod date"); 3405 Asm->EmitULEB128(0, "File size"); 3406 } 3407 3408 Asm->OutStreamer.AddComment("End of files"); 3409 Asm->EmitInt8(0); 3410 3411 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end")); 3412 3413 // A sequence for each text section. 3414 unsigned SecSrcLinesSize = SectionSourceLines.size(); 3415 3416 for (unsigned j = 0; j < SecSrcLinesSize; ++j) { 3417 // Isolate current sections line info. 3418 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j]; 3419 3420 // Dwarf assumes we start with first line of first source file. 3421 unsigned Source = 1; 3422 unsigned Line = 1; 3423 3424 // Construct rows of the address, source, line, column matrix. 3425 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) { 3426 const SrcLineInfo &LineInfo = LineInfos[i]; 3427 MCSymbol *Label = LineInfo.getLabel(); 3428 if (!Label->isDefined()) continue; // Not emitted, in dead code. 3429 3430 if (Asm->isVerbose()) { 3431 std::pair<unsigned, unsigned> SrcID = 3432 getSourceDirectoryAndFileIds(LineInfo.getSourceID()); 3433 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) + 3434 "/" + 3435 Twine(getSourceFileName(SrcID.second)) + 3436 ":" + Twine(LineInfo.getLine())); 3437 } 3438 3439 // Define the line address. 3440 Asm->OutStreamer.AddComment("Extended Op"); 3441 Asm->EmitInt8(0); 3442 Asm->OutStreamer.AddComment("Op size"); 3443 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1); 3444 3445 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 3446 Asm->EmitInt8(dwarf::DW_LNE_set_address); 3447 3448 Asm->OutStreamer.AddComment("Location label"); 3449 Asm->OutStreamer.EmitSymbolValue(Label, 3450 Asm->getTargetData().getPointerSize(), 3451 0/*AddrSpace*/); 3452 3453 // If change of source, then switch to the new source. 3454 if (Source != LineInfo.getSourceID()) { 3455 Source = LineInfo.getSourceID(); 3456 Asm->OutStreamer.AddComment("DW_LNS_set_file"); 3457 Asm->EmitInt8(dwarf::DW_LNS_set_file); 3458 Asm->EmitULEB128(Source, "New Source"); 3459 } 3460 3461 // If change of line. 3462 if (Line != LineInfo.getLine()) { 3463 // Determine offset. 3464 int Offset = LineInfo.getLine() - Line; 3465 int Delta = Offset - MinLineDelta; 3466 3467 // Update line. 3468 Line = LineInfo.getLine(); 3469 3470 // If delta is small enough and in range... 3471 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { 3472 // ... then use fast opcode. 3473 Asm->OutStreamer.AddComment("Line Delta"); 3474 Asm->EmitInt8(Delta - MinLineDelta); 3475 } else { 3476 // ... otherwise use long hand. 3477 Asm->OutStreamer.AddComment("DW_LNS_advance_line"); 3478 Asm->EmitInt8(dwarf::DW_LNS_advance_line); 3479 Asm->EmitSLEB128(Offset, "Line Offset"); 3480 Asm->OutStreamer.AddComment("DW_LNS_copy"); 3481 Asm->EmitInt8(dwarf::DW_LNS_copy); 3482 } 3483 } else { 3484 // Copy the previous row (different address or source) 3485 Asm->OutStreamer.AddComment("DW_LNS_copy"); 3486 Asm->EmitInt8(dwarf::DW_LNS_copy); 3487 } 3488 } 3489 3490 emitEndOfLineMatrix(j + 1); 3491 } 3492 3493 if (SecSrcLinesSize == 0) 3494 // Because we're emitting a debug_line section, we still need a line 3495 // table. The linker and friends expect it to exist. If there's nothing to 3496 // put into it, emit an empty table. 3497 emitEndOfLineMatrix(1); 3498 3499 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end")); 3500} 3501 3502/// emitCommonDebugFrame - Emit common frame info into a debug frame section. 3503/// 3504void DwarfDebug::emitCommonDebugFrame() { 3505 if (!Asm->MAI->doesDwarfRequireFrameSection()) 3506 return; 3507 3508 int stackGrowth = Asm->getTargetData().getPointerSize(); 3509 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() == 3510 TargetFrameInfo::StackGrowsDown) 3511 stackGrowth *= -1; 3512 3513 // Start the dwarf frame section. 3514 Asm->OutStreamer.SwitchSection( 3515 Asm->getObjFileLowering().getDwarfFrameSection()); 3516 3517 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common")); 3518 Asm->OutStreamer.AddComment("Length of Common Information Entry"); 3519 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"), 3520 Asm->GetTempSymbol("debug_frame_common_begin"), 4); 3521 3522 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin")); 3523 Asm->OutStreamer.AddComment("CIE Identifier Tag"); 3524 Asm->EmitInt32((int)dwarf::DW_CIE_ID); 3525 Asm->OutStreamer.AddComment("CIE Version"); 3526 Asm->EmitInt8(dwarf::DW_CIE_VERSION); 3527 Asm->OutStreamer.AddComment("CIE Augmentation"); 3528 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator. 3529 Asm->EmitULEB128(1, "CIE Code Alignment Factor"); 3530 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor"); 3531 Asm->OutStreamer.AddComment("CIE RA Column"); 3532 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 3533 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); 3534 3535 std::vector<MachineMove> Moves; 3536 RI->getInitialFrameState(Moves); 3537 3538 Asm->EmitFrameMoves(Moves, 0, false); 3539 3540 Asm->EmitAlignment(2); 3541 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end")); 3542} 3543 3544/// emitFunctionDebugFrame - Emit per function frame info into a debug frame 3545/// section. 3546void DwarfDebug:: 3547emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) { 3548 if (!Asm->MAI->doesDwarfRequireFrameSection()) 3549 return; 3550 3551 // Start the dwarf frame section. 3552 Asm->OutStreamer.SwitchSection( 3553 Asm->getObjFileLowering().getDwarfFrameSection()); 3554 3555 Asm->OutStreamer.AddComment("Length of Frame Information Entry"); 3556 MCSymbol *DebugFrameBegin = 3557 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number); 3558 MCSymbol *DebugFrameEnd = 3559 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number); 3560 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4); 3561 3562 Asm->OutStreamer.EmitLabel(DebugFrameBegin); 3563 3564 Asm->OutStreamer.AddComment("FDE CIE offset"); 3565 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"), 3566 DwarfFrameSectionSym); 3567 3568 Asm->OutStreamer.AddComment("FDE initial location"); 3569 MCSymbol *FuncBeginSym = 3570 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number); 3571 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym, 3572 Asm->getTargetData().getPointerSize(), 3573 0/*AddrSpace*/); 3574 3575 3576 Asm->OutStreamer.AddComment("FDE address range"); 3577 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number), 3578 FuncBeginSym, Asm->getTargetData().getPointerSize()); 3579 3580 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false); 3581 3582 Asm->EmitAlignment(2); 3583 Asm->OutStreamer.EmitLabel(DebugFrameEnd); 3584} 3585 3586/// emitDebugPubNames - Emit visible names into a debug pubnames section. 3587/// 3588void DwarfDebug::emitDebugPubNames() { 3589 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3590 E = CUMap.end(); I != E; ++I) { 3591 CompileUnit *TheCU = I->second; 3592 // Start the dwarf pubnames section. 3593 Asm->OutStreamer.SwitchSection( 3594 Asm->getObjFileLowering().getDwarfPubNamesSection()); 3595 3596 Asm->OutStreamer.AddComment("Length of Public Names Info"); 3597 Asm->EmitLabelDifference( 3598 Asm->GetTempSymbol("pubnames_end", TheCU->getID()), 3599 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4); 3600 3601 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", 3602 TheCU->getID())); 3603 3604 Asm->OutStreamer.AddComment("DWARF Version"); 3605 Asm->EmitInt16(dwarf::DWARF_VERSION); 3606 3607 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 3608 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 3609 DwarfInfoSectionSym); 3610 3611 Asm->OutStreamer.AddComment("Compilation Unit Length"); 3612 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 3613 Asm->GetTempSymbol("info_begin", TheCU->getID()), 3614 4); 3615 3616 const StringMap<DIE*> &Globals = TheCU->getGlobals(); 3617 for (StringMap<DIE*>::const_iterator 3618 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 3619 const char *Name = GI->getKeyData(); 3620 DIE *Entity = GI->second; 3621 3622 Asm->OutStreamer.AddComment("DIE offset"); 3623 Asm->EmitInt32(Entity->getOffset()); 3624 3625 if (Asm->isVerbose()) 3626 Asm->OutStreamer.AddComment("External Name"); 3627 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0); 3628 } 3629 3630 Asm->OutStreamer.AddComment("End Mark"); 3631 Asm->EmitInt32(0); 3632 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", 3633 TheCU->getID())); 3634 } 3635} 3636 3637void DwarfDebug::emitDebugPubTypes() { 3638 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3639 E = CUMap.end(); I != E; ++I) { 3640 CompileUnit *TheCU = I->second; 3641 // Start the dwarf pubnames section. 3642 Asm->OutStreamer.SwitchSection( 3643 Asm->getObjFileLowering().getDwarfPubTypesSection()); 3644 Asm->OutStreamer.AddComment("Length of Public Types Info"); 3645 Asm->EmitLabelDifference( 3646 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()), 3647 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4); 3648 3649 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 3650 TheCU->getID())); 3651 3652 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 3653 Asm->EmitInt16(dwarf::DWARF_VERSION); 3654 3655 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 3656 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 3657 DwarfInfoSectionSym); 3658 3659 Asm->OutStreamer.AddComment("Compilation Unit Length"); 3660 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 3661 Asm->GetTempSymbol("info_begin", TheCU->getID()), 3662 4); 3663 3664 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes(); 3665 for (StringMap<DIE*>::const_iterator 3666 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 3667 const char *Name = GI->getKeyData(); 3668 DIE * Entity = GI->second; 3669 3670 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 3671 Asm->EmitInt32(Entity->getOffset()); 3672 3673 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 3674 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0); 3675 } 3676 3677 Asm->OutStreamer.AddComment("End Mark"); 3678 Asm->EmitInt32(0); 3679 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 3680 TheCU->getID())); 3681 } 3682} 3683 3684/// emitDebugStr - Emit visible names into a debug str section. 3685/// 3686void DwarfDebug::emitDebugStr() { 3687 // Check to see if it is worth the effort. 3688 if (StringPool.empty()) return; 3689 3690 // Start the dwarf str section. 3691 Asm->OutStreamer.SwitchSection( 3692 Asm->getObjFileLowering().getDwarfStrSection()); 3693 3694 // Get all of the string pool entries and put them in an array by their ID so 3695 // we can sort them. 3696 SmallVector<std::pair<unsigned, 3697 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 3698 3699 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 3700 I = StringPool.begin(), E = StringPool.end(); I != E; ++I) 3701 Entries.push_back(std::make_pair(I->second.second, &*I)); 3702 3703 array_pod_sort(Entries.begin(), Entries.end()); 3704 3705 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 3706 // Emit a label for reference from debug information entries. 3707 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 3708 3709 // Emit the string itself. 3710 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/); 3711 } 3712} 3713 3714/// emitDebugLoc - Emit visible names into a debug loc section. 3715/// 3716void DwarfDebug::emitDebugLoc() { 3717 if (DotDebugLocEntries.empty()) 3718 return; 3719 3720 // Start the dwarf loc section. 3721 Asm->OutStreamer.SwitchSection( 3722 Asm->getObjFileLowering().getDwarfLocSection()); 3723 unsigned char Size = Asm->getTargetData().getPointerSize(); 3724 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0)); 3725 unsigned index = 1; 3726 for (SmallVector<DotDebugLocEntry, 4>::iterator 3727 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 3728 I != E; ++I, ++index) { 3729 DotDebugLocEntry Entry = *I; 3730 if (Entry.isEmpty()) { 3731 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3732 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3733 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index)); 3734 } else { 3735 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0); 3736 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0); 3737 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 3738 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false); 3739 if (int Offset = Entry.Loc.getOffset()) { 3740 // If the value is at a certain offset from frame register then 3741 // use DW_OP_fbreg. 3742 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1; 3743 Asm->OutStreamer.AddComment("Loc expr size"); 3744 Asm->EmitInt16(1 + OffsetSize); 3745 Asm->OutStreamer.AddComment( 3746 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg)); 3747 Asm->EmitInt8(dwarf::DW_OP_fbreg); 3748 Asm->OutStreamer.AddComment("Offset"); 3749 Asm->EmitSLEB128(Offset); 3750 } else { 3751 if (Reg < 32) { 3752 Asm->OutStreamer.AddComment("Loc expr size"); 3753 Asm->EmitInt16(1); 3754 Asm->OutStreamer.AddComment( 3755 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg)); 3756 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg); 3757 } else { 3758 Asm->OutStreamer.AddComment("Loc expr size"); 3759 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg)); 3760 Asm->EmitInt8(dwarf::DW_OP_regx); 3761 Asm->EmitULEB128(Reg); 3762 } 3763 } 3764 } 3765 } 3766} 3767 3768/// EmitDebugARanges - Emit visible names into a debug aranges section. 3769/// 3770void DwarfDebug::EmitDebugARanges() { 3771 // Start the dwarf aranges section. 3772 Asm->OutStreamer.SwitchSection( 3773 Asm->getObjFileLowering().getDwarfARangesSection()); 3774} 3775 3776/// emitDebugRanges - Emit visible names into a debug ranges section. 3777/// 3778void DwarfDebug::emitDebugRanges() { 3779 // Start the dwarf ranges section. 3780 Asm->OutStreamer.SwitchSection( 3781 Asm->getObjFileLowering().getDwarfRangesSection()); 3782 unsigned char Size = Asm->getTargetData().getPointerSize(); 3783 for (SmallVector<const MCSymbol *, 8>::iterator 3784 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end(); 3785 I != E; ++I) { 3786 if (*I) 3787 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0); 3788 else 3789 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3790 } 3791} 3792 3793/// emitDebugMacInfo - Emit visible names into a debug macinfo section. 3794/// 3795void DwarfDebug::emitDebugMacInfo() { 3796 if (const MCSection *LineInfo = 3797 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 3798 // Start the dwarf macinfo section. 3799 Asm->OutStreamer.SwitchSection(LineInfo); 3800 } 3801} 3802 3803/// emitDebugInlineInfo - Emit inline info using following format. 3804/// Section Header: 3805/// 1. length of section 3806/// 2. Dwarf version number 3807/// 3. address size. 3808/// 3809/// Entries (one "entry" for each function that was inlined): 3810/// 3811/// 1. offset into __debug_str section for MIPS linkage name, if exists; 3812/// otherwise offset into __debug_str for regular function name. 3813/// 2. offset into __debug_str section for regular function name. 3814/// 3. an unsigned LEB128 number indicating the number of distinct inlining 3815/// instances for the function. 3816/// 3817/// The rest of the entry consists of a {die_offset, low_pc} pair for each 3818/// inlined instance; the die_offset points to the inlined_subroutine die in the 3819/// __debug_info section, and the low_pc is the starting address for the 3820/// inlining instance. 3821void DwarfDebug::emitDebugInlineInfo() { 3822 if (!Asm->MAI->doesDwarfUsesInlineInfoSection()) 3823 return; 3824 3825 if (!FirstCU) 3826 return; 3827 3828 Asm->OutStreamer.SwitchSection( 3829 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 3830 3831 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry"); 3832 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1), 3833 Asm->GetTempSymbol("debug_inlined_begin", 1), 4); 3834 3835 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1)); 3836 3837 Asm->OutStreamer.AddComment("Dwarf Version"); 3838 Asm->EmitInt16(dwarf::DWARF_VERSION); 3839 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 3840 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 3841 3842 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 3843 E = InlinedSPNodes.end(); I != E; ++I) { 3844 3845 const MDNode *Node = *I; 3846 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 3847 = InlineInfo.find(Node); 3848 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 3849 DISubprogram SP(Node); 3850 StringRef LName = SP.getLinkageName(); 3851 StringRef Name = SP.getName(); 3852 3853 Asm->OutStreamer.AddComment("MIPS linkage name"); 3854 if (LName.empty()) { 3855 Asm->OutStreamer.EmitBytes(Name, 0); 3856 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator. 3857 } else 3858 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)), 3859 DwarfStrSectionSym); 3860 3861 Asm->OutStreamer.AddComment("Function name"); 3862 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym); 3863 Asm->EmitULEB128(Labels.size(), "Inline count"); 3864 3865 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 3866 LE = Labels.end(); LI != LE; ++LI) { 3867 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 3868 Asm->EmitInt32(LI->second->getOffset()); 3869 3870 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc"); 3871 Asm->OutStreamer.EmitSymbolValue(LI->first, 3872 Asm->getTargetData().getPointerSize(),0); 3873 } 3874 } 3875 3876 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1)); 3877} 3878