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