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