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