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