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