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