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