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