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