DwarfDebug.cpp revision 99cfb69f17ccf6dca7378fe6d1c60758e5cabd1f
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 = MDNodeToDIEEntryMap.find(N); 136 if (I == MDNodeToDIEEntryMap.end()) 137 return NULL; 138 return I->second; 139 } 140 141 /// insertDIEEntry - Insert debug information entry into the map. 142 void insertDIEEntry(const MDNode *N, DIEEntry *E) { 143 MDNodeToDIEEntryMap.insert(std::make_pair(N, E)); 144 } 145 146 /// addDie - Adds or interns the DIE to the compile unit. 147 /// 148 void addDie(DIE *Buffer) { 149 this->CUDie->addChild(Buffer); 150 } 151 152 // getIndexTyDie - Get an anonymous type for index type. 153 DIE *getIndexTyDie() { 154 return IndexTyDie; 155 } 156 157 // setIndexTyDie - Set D as anonymous type for index which can be reused 158 // later. 159 void setIndexTyDie(DIE *D) { 160 IndexTyDie = D; 161 } 162 163}; 164 165//===----------------------------------------------------------------------===// 166/// DbgVariable - This class is used to track local variable information. 167/// 168class DbgVariable { 169 DIVariable Var; // Variable Descriptor. 170 DIE *TheDIE; // Variable DIE. 171 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries. 172public: 173 // AbsVar may be NULL. 174 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {} 175 176 // Accessors. 177 DIVariable getVariable() const { return Var; } 178 void setDIE(DIE *D) { TheDIE = D; } 179 DIE *getDIE() const { return TheDIE; } 180 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; } 181 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; } 182}; 183 184//===----------------------------------------------------------------------===// 185/// DbgRange - This is used to track range of instructions with identical 186/// debug info scope. 187/// 188typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange; 189 190//===----------------------------------------------------------------------===// 191/// DbgScope - This class is used to track scope information. 192/// 193class DbgScope { 194 DbgScope *Parent; // Parent to this scope. 195 DIDescriptor Desc; // Debug info descriptor for scope. 196 // Location at which this scope is inlined. 197 AssertingVH<const MDNode> InlinedAtLocation; 198 bool AbstractScope; // Abstract Scope 199 const MachineInstr *LastInsn; // Last instruction of this scope. 200 const MachineInstr *FirstInsn; // First instruction of this scope. 201 unsigned DFSIn, DFSOut; 202 // Scopes defined in scope. Contents not owned. 203 SmallVector<DbgScope *, 4> Scopes; 204 // Variables declared in scope. Contents owned. 205 SmallVector<DbgVariable *, 8> Variables; 206 SmallVector<DbgRange, 4> Ranges; 207 // Private state for dump() 208 mutable unsigned IndentLevel; 209public: 210 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0) 211 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false), 212 LastInsn(0), FirstInsn(0), 213 DFSIn(0), DFSOut(0), IndentLevel(0) {} 214 virtual ~DbgScope(); 215 216 // Accessors. 217 DbgScope *getParent() const { return Parent; } 218 void setParent(DbgScope *P) { Parent = P; } 219 DIDescriptor getDesc() const { return Desc; } 220 const MDNode *getInlinedAt() const { return InlinedAtLocation; } 221 const MDNode *getScopeNode() const { return Desc; } 222 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; } 223 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; } 224 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; } 225 226 /// openInsnRange - This scope covers instruction range starting from MI. 227 void openInsnRange(const MachineInstr *MI) { 228 if (!FirstInsn) 229 FirstInsn = MI; 230 231 if (Parent) 232 Parent->openInsnRange(MI); 233 } 234 235 /// extendInsnRange - Extend the current instruction range covered by 236 /// this scope. 237 void extendInsnRange(const MachineInstr *MI) { 238 assert (FirstInsn && "MI Range is not open!"); 239 LastInsn = MI; 240 if (Parent) 241 Parent->extendInsnRange(MI); 242 } 243 244 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected 245 /// until now. This is used when a new scope is encountered while walking 246 /// machine instructions. 247 void closeInsnRange(DbgScope *NewScope = NULL) { 248 assert (LastInsn && "Last insn missing!"); 249 Ranges.push_back(DbgRange(FirstInsn, LastInsn)); 250 FirstInsn = NULL; 251 LastInsn = NULL; 252 // If Parent dominates NewScope then do not close Parent's instruction 253 // range. 254 if (Parent && (!NewScope || !Parent->dominates(NewScope))) 255 Parent->closeInsnRange(NewScope); 256 } 257 258 void setAbstractScope() { AbstractScope = true; } 259 bool isAbstractScope() const { return AbstractScope; } 260 261 // Depth First Search support to walk and mainpluate DbgScope hierarchy. 262 unsigned getDFSOut() const { return DFSOut; } 263 void setDFSOut(unsigned O) { DFSOut = O; } 264 unsigned getDFSIn() const { return DFSIn; } 265 void setDFSIn(unsigned I) { DFSIn = I; } 266 bool dominates(const DbgScope *S) { 267 if (S == this) 268 return true; 269 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut()) 270 return true; 271 return false; 272 } 273 274 /// addScope - Add a scope to the scope. 275 /// 276 void addScope(DbgScope *S) { Scopes.push_back(S); } 277 278 /// addVariable - Add a variable to the scope. 279 /// 280 void addVariable(DbgVariable *V) { Variables.push_back(V); } 281 282#ifndef NDEBUG 283 void dump() const; 284#endif 285}; 286 287} // end llvm namespace 288 289#ifndef NDEBUG 290void DbgScope::dump() const { 291 raw_ostream &err = dbgs(); 292 err.indent(IndentLevel); 293 const MDNode *N = Desc; 294 N->dump(); 295 if (AbstractScope) 296 err << "Abstract Scope\n"; 297 298 IndentLevel += 2; 299 if (!Scopes.empty()) 300 err << "Children ...\n"; 301 for (unsigned i = 0, e = Scopes.size(); i != e; ++i) 302 if (Scopes[i] != this) 303 Scopes[i]->dump(); 304 305 IndentLevel -= 2; 306} 307#endif 308 309DbgScope::~DbgScope() { 310 for (unsigned j = 0, M = Variables.size(); j < M; ++j) 311 delete Variables[j]; 312} 313 314DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M) 315 : Asm(A), MMI(Asm->MMI), FirstCU(0), 316 AbbreviationsSet(InitAbbreviationsSetSize), 317 CurrentFnDbgScope(0), PrevLabel(NULL) { 318 NextStringPoolNumber = 0; 319 320 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0; 321 DwarfStrSectionSym = TextSectionSym = 0; 322 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0; 323 DwarfDebugLineSectionSym = CurrentLineSectionSym = 0; 324 FunctionBeginSym = FunctionEndSym = 0; 325 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1); 326 { 327 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled); 328 beginModule(M); 329 } 330} 331DwarfDebug::~DwarfDebug() { 332 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j) 333 DIEBlocks[j]->~DIEBlock(); 334} 335 336MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) { 337 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str]; 338 if (Entry.first) return Entry.first; 339 340 Entry.second = NextStringPoolNumber++; 341 return Entry.first = Asm->GetTempSymbol("string", Entry.second); 342} 343 344 345/// assignAbbrevNumber - Define a unique number for the abbreviation. 346/// 347void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) { 348 // Profile the node so that we can make it unique. 349 FoldingSetNodeID ID; 350 Abbrev.Profile(ID); 351 352 // Check the set for priors. 353 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev); 354 355 // If it's newly added. 356 if (InSet == &Abbrev) { 357 // Add to abbreviation list. 358 Abbreviations.push_back(&Abbrev); 359 360 // Assign the vector position + 1 as its number. 361 Abbrev.setNumber(Abbreviations.size()); 362 } else { 363 // Assign existing abbreviation number. 364 Abbrev.setNumber(InSet->getNumber()); 365 } 366} 367 368/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug 369/// information entry. 370DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) { 371 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry); 372 return Value; 373} 374 375/// addUInt - Add an unsigned integer attribute data and value. 376/// 377void DwarfDebug::addUInt(DIE *Die, unsigned Attribute, 378 unsigned Form, uint64_t Integer) { 379 if (!Form) Form = DIEInteger::BestForm(false, Integer); 380 DIEValue *Value = Integer == 1 ? 381 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer); 382 Die->addValue(Attribute, Form, Value); 383} 384 385/// addSInt - Add an signed integer attribute data and value. 386/// 387void DwarfDebug::addSInt(DIE *Die, unsigned Attribute, 388 unsigned Form, int64_t Integer) { 389 if (!Form) Form = DIEInteger::BestForm(true, Integer); 390 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer); 391 Die->addValue(Attribute, Form, Value); 392} 393 394/// addString - Add a string attribute data and value. DIEString only 395/// keeps string reference. 396void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form, 397 StringRef String) { 398 DIEValue *Value = new (DIEValueAllocator) DIEString(String); 399 Die->addValue(Attribute, Form, Value); 400} 401 402/// addLabel - Add a Dwarf label attribute data and value. 403/// 404void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form, 405 const MCSymbol *Label) { 406 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label); 407 Die->addValue(Attribute, Form, Value); 408} 409 410/// addDelta - Add a label delta attribute data and value. 411/// 412void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form, 413 const MCSymbol *Hi, const MCSymbol *Lo) { 414 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo); 415 Die->addValue(Attribute, Form, Value); 416} 417 418/// addDIEEntry - Add a DIE attribute data and value. 419/// 420void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form, 421 DIE *Entry) { 422 Die->addValue(Attribute, Form, createDIEEntry(Entry)); 423} 424 425 426/// addBlock - Add block data. 427/// 428void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form, 429 DIEBlock *Block) { 430 Block->ComputeSize(Asm); 431 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on. 432 Die->addValue(Attribute, Block->BestForm(), Block); 433} 434 435/// addSourceLine - Add location information to specified debug information 436/// entry. 437void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) { 438 // Verify variable. 439 if (!V->Verify()) 440 return; 441 442 unsigned Line = V->getLineNumber(); 443 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(), 444 V->getContext().getFilename()); 445 assert(FileID && "Invalid file id"); 446 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 447 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 448} 449 450/// addSourceLine - Add location information to specified debug information 451/// entry. 452void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) { 453 // Verify global variable. 454 if (!G->Verify()) 455 return; 456 457 unsigned Line = G->getLineNumber(); 458 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(), 459 G->getContext().getFilename()); 460 assert(FileID && "Invalid file id"); 461 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 462 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 463} 464 465/// addSourceLine - Add location information to specified debug information 466/// entry. 467void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) { 468 // Verify subprogram. 469 if (!SP->Verify()) 470 return; 471 // If the line number is 0, don't add it. 472 if (SP->getLineNumber() == 0) 473 return; 474 475 unsigned Line = SP->getLineNumber(); 476 if (!SP->getContext().Verify()) 477 return; 478 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(), 479 SP->getFilename()); 480 assert(FileID && "Invalid file id"); 481 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 482 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 483} 484 485/// addSourceLine - Add location information to specified debug information 486/// entry. 487void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) { 488 // Verify type. 489 if (!Ty->Verify()) 490 return; 491 492 unsigned Line = Ty->getLineNumber(); 493 if (!Ty->getContext().Verify()) 494 return; 495 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(), 496 Ty->getContext().getFilename()); 497 assert(FileID && "Invalid file id"); 498 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 499 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 500} 501 502/// addSourceLine - Add location information to specified debug information 503/// entry. 504void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) { 505 // Verify namespace. 506 if (!NS->Verify()) 507 return; 508 509 unsigned Line = NS->getLineNumber(); 510 StringRef FN = NS->getFilename(); 511 StringRef Dir = NS->getDirectory(); 512 513 unsigned FileID = GetOrCreateSourceID(Dir, FN); 514 assert(FileID && "Invalid file id"); 515 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 516 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 517} 518 519/* Byref variables, in Blocks, are declared by the programmer as 520 "SomeType VarName;", but the compiler creates a 521 __Block_byref_x_VarName struct, and gives the variable VarName 522 either the struct, or a pointer to the struct, as its type. This 523 is necessary for various behind-the-scenes things the compiler 524 needs to do with by-reference variables in blocks. 525 526 However, as far as the original *programmer* is concerned, the 527 variable should still have type 'SomeType', as originally declared. 528 529 The following function dives into the __Block_byref_x_VarName 530 struct to find the original type of the variable. This will be 531 passed back to the code generating the type for the Debug 532 Information Entry for the variable 'VarName'. 'VarName' will then 533 have the original type 'SomeType' in its debug information. 534 535 The original type 'SomeType' will be the type of the field named 536 'VarName' inside the __Block_byref_x_VarName struct. 537 538 NOTE: In order for this to not completely fail on the debugger 539 side, the Debug Information Entry for the variable VarName needs to 540 have a DW_AT_location that tells the debugger how to unwind through 541 the pointers and __Block_byref_x_VarName struct to find the actual 542 value of the variable. The function addBlockByrefType does this. */ 543 544/// Find the type the programmer originally declared the variable to be 545/// and return that type. 546/// 547DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) { 548 549 DIType subType = Ty; 550 unsigned tag = Ty.getTag(); 551 552 if (tag == dwarf::DW_TAG_pointer_type) { 553 DIDerivedType DTy = DIDerivedType(Ty); 554 subType = DTy.getTypeDerivedFrom(); 555 } 556 557 DICompositeType blockStruct = DICompositeType(subType); 558 DIArray Elements = blockStruct.getTypeArray(); 559 560 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 561 DIDescriptor Element = Elements.getElement(i); 562 DIDerivedType DT = DIDerivedType(Element); 563 if (Name == DT.getName()) 564 return (DT.getTypeDerivedFrom()); 565 } 566 567 return Ty; 568} 569 570/// addComplexAddress - Start with the address based on the location provided, 571/// and generate the DWARF information necessary to find the actual variable 572/// given the extra address information encoded in the DIVariable, starting from 573/// the starting location. Add the DWARF information to the die. 574/// 575void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die, 576 unsigned Attribute, 577 const MachineLocation &Location) { 578 const DIVariable &VD = DV->getVariable(); 579 DIType Ty = VD.getType(); 580 581 // Decode the original location, and use that as the start of the byref 582 // variable's location. 583 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 584 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false); 585 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 586 587 if (Location.isReg()) { 588 if (Reg < 32) { 589 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg); 590 } else { 591 Reg = Reg - dwarf::DW_OP_reg0; 592 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 593 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 594 } 595 } else { 596 if (Reg < 32) 597 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 598 else { 599 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 600 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 601 } 602 603 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 604 } 605 606 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) { 607 uint64_t Element = VD.getAddrElement(i); 608 609 if (Element == DIFactory::OpPlus) { 610 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 611 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i)); 612 } else if (Element == DIFactory::OpDeref) { 613 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 614 } else llvm_unreachable("unknown DIFactory Opcode"); 615 } 616 617 // Now attach the location information to the DIE. 618 addBlock(Die, Attribute, 0, Block); 619} 620 621/* Byref variables, in Blocks, are declared by the programmer as "SomeType 622 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and 623 gives the variable VarName either the struct, or a pointer to the struct, as 624 its type. This is necessary for various behind-the-scenes things the 625 compiler needs to do with by-reference variables in Blocks. 626 627 However, as far as the original *programmer* is concerned, the variable 628 should still have type 'SomeType', as originally declared. 629 630 The function getBlockByrefType dives into the __Block_byref_x_VarName 631 struct to find the original type of the variable, which is then assigned to 632 the variable's Debug Information Entry as its real type. So far, so good. 633 However now the debugger will expect the variable VarName to have the type 634 SomeType. So we need the location attribute for the variable to be an 635 expression that explains to the debugger how to navigate through the 636 pointers and struct to find the actual variable of type SomeType. 637 638 The following function does just that. We start by getting 639 the "normal" location for the variable. This will be the location 640 of either the struct __Block_byref_x_VarName or the pointer to the 641 struct __Block_byref_x_VarName. 642 643 The struct will look something like: 644 645 struct __Block_byref_x_VarName { 646 ... <various fields> 647 struct __Block_byref_x_VarName *forwarding; 648 ... <various other fields> 649 SomeType VarName; 650 ... <maybe more fields> 651 }; 652 653 If we are given the struct directly (as our starting point) we 654 need to tell the debugger to: 655 656 1). Add the offset of the forwarding field. 657 658 2). Follow that pointer to get the real __Block_byref_x_VarName 659 struct to use (the real one may have been copied onto the heap). 660 661 3). Add the offset for the field VarName, to find the actual variable. 662 663 If we started with a pointer to the struct, then we need to 664 dereference that pointer first, before the other steps. 665 Translating this into DWARF ops, we will need to append the following 666 to the current location description for the variable: 667 668 DW_OP_deref -- optional, if we start with a pointer 669 DW_OP_plus_uconst <forward_fld_offset> 670 DW_OP_deref 671 DW_OP_plus_uconst <varName_fld_offset> 672 673 That is what this function does. */ 674 675/// addBlockByrefAddress - Start with the address based on the location 676/// provided, and generate the DWARF information necessary to find the 677/// actual Block variable (navigating the Block struct) based on the 678/// starting location. Add the DWARF information to the die. For 679/// more information, read large comment just above here. 680/// 681void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die, 682 unsigned Attribute, 683 const MachineLocation &Location) { 684 const DIVariable &VD = DV->getVariable(); 685 DIType Ty = VD.getType(); 686 DIType TmpTy = Ty; 687 unsigned Tag = Ty.getTag(); 688 bool isPointer = false; 689 690 StringRef varName = VD.getName(); 691 692 if (Tag == dwarf::DW_TAG_pointer_type) { 693 DIDerivedType DTy = DIDerivedType(Ty); 694 TmpTy = DTy.getTypeDerivedFrom(); 695 isPointer = true; 696 } 697 698 DICompositeType blockStruct = DICompositeType(TmpTy); 699 700 // Find the __forwarding field and the variable field in the __Block_byref 701 // struct. 702 DIArray Fields = blockStruct.getTypeArray(); 703 DIDescriptor varField = DIDescriptor(); 704 DIDescriptor forwardingField = DIDescriptor(); 705 706 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) { 707 DIDescriptor Element = Fields.getElement(i); 708 DIDerivedType DT = DIDerivedType(Element); 709 StringRef fieldName = DT.getName(); 710 if (fieldName == "__forwarding") 711 forwardingField = Element; 712 else if (fieldName == varName) 713 varField = Element; 714 } 715 716 // Get the offsets for the forwarding field and the variable field. 717 unsigned forwardingFieldOffset = 718 DIDerivedType(forwardingField).getOffsetInBits() >> 3; 719 unsigned varFieldOffset = 720 DIDerivedType(varField).getOffsetInBits() >> 3; 721 722 // Decode the original location, and use that as the start of the byref 723 // variable's location. 724 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 725 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false); 726 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 727 728 if (Location.isReg()) { 729 if (Reg < 32) 730 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg); 731 else { 732 Reg = Reg - dwarf::DW_OP_reg0; 733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 734 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 735 } 736 } else { 737 if (Reg < 32) 738 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 739 else { 740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 741 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 742 } 743 744 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 745 } 746 747 // If we started with a pointer to the __Block_byref... struct, then 748 // the first thing we need to do is dereference the pointer (DW_OP_deref). 749 if (isPointer) 750 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 751 752 // Next add the offset for the '__forwarding' field: 753 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in 754 // adding the offset if it's 0. 755 if (forwardingFieldOffset > 0) { 756 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 757 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset); 758 } 759 760 // Now dereference the __forwarding field to get to the real __Block_byref 761 // struct: DW_OP_deref. 762 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 763 764 // Now that we've got the real __Block_byref... struct, add the offset 765 // for the variable's field to get to the location of the actual variable: 766 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0. 767 if (varFieldOffset > 0) { 768 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 769 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset); 770 } 771 772 // Now attach the location information to the DIE. 773 addBlock(Die, Attribute, 0, Block); 774} 775 776/// addAddress - Add an address attribute to a die based on the location 777/// provided. 778void DwarfDebug::addAddress(DIE *Die, unsigned Attribute, 779 const MachineLocation &Location) { 780 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 781 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false); 782 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 783 784 if (Location.isReg()) { 785 if (Reg < 32) { 786 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg); 787 } else { 788 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx); 789 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 790 } 791 } else { 792 if (Reg < 32) { 793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 794 } else { 795 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 796 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 797 } 798 799 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 800 } 801 802 addBlock(Die, Attribute, 0, Block); 803} 804 805/// addRegisterAddress - Add register location entry in variable DIE. 806bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS, 807 const MachineOperand &MO) { 808 assert (MO.isReg() && "Invalid machine operand!"); 809 if (!MO.getReg()) 810 return false; 811 MachineLocation Location; 812 Location.set(MO.getReg()); 813 addAddress(Die, dwarf::DW_AT_location, Location); 814 if (VS) 815 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS); 816 return true; 817} 818 819/// addConstantValue - Add constant value entry in variable DIE. 820bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS, 821 const MachineOperand &MO) { 822 assert (MO.isImm() && "Invalid machine operand!"); 823 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 824 unsigned Imm = MO.getImm(); 825 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm); 826 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 827 if (VS) 828 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS); 829 return true; 830} 831 832/// addConstantFPValue - Add constant value entry in variable DIE. 833bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS, 834 const MachineOperand &MO) { 835 assert (MO.isFPImm() && "Invalid machine operand!"); 836 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 837 APFloat FPImm = MO.getFPImm()->getValueAPF(); 838 839 // Get the raw data form of the floating point. 840 const APInt FltVal = FPImm.bitcastToAPInt(); 841 const char *FltPtr = (const char*)FltVal.getRawData(); 842 843 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte. 844 bool LittleEndian = Asm->getTargetData().isLittleEndian(); 845 int Incr = (LittleEndian ? 1 : -1); 846 int Start = (LittleEndian ? 0 : NumBytes - 1); 847 int Stop = (LittleEndian ? NumBytes : -1); 848 849 // Output the constant to DWARF one byte at a time. 850 for (; Start != Stop; Start += Incr) 851 addUInt(Block, 0, dwarf::DW_FORM_data1, 852 (unsigned char)0xFF & FltPtr[Start]); 853 854 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 855 if (VS) 856 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS); 857 return true; 858} 859 860 861/// addToContextOwner - Add Die into the list of its context owner's children. 862void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) { 863 if (Context.isType()) { 864 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context)); 865 ContextDIE->addChild(Die); 866 } else if (Context.isNameSpace()) { 867 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context)); 868 ContextDIE->addChild(Die); 869 } else if (Context.isSubprogram()) { 870 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context), 871 /*MakeDecl=*/false); 872 ContextDIE->addChild(Die); 873 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context)) 874 ContextDIE->addChild(Die); 875 else 876 getCompileUnit(Context)->addDie(Die); 877} 878 879/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the 880/// given DIType. 881DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) { 882 CompileUnit *TypeCU = getCompileUnit(Ty); 883 DIE *TyDIE = TypeCU->getDIE(Ty); 884 if (TyDIE) 885 return TyDIE; 886 887 // Create new type. 888 TyDIE = new DIE(dwarf::DW_TAG_base_type); 889 TypeCU->insertDIE(Ty, TyDIE); 890 if (Ty.isBasicType()) 891 constructTypeDIE(*TyDIE, DIBasicType(Ty)); 892 else if (Ty.isCompositeType()) 893 constructTypeDIE(*TyDIE, DICompositeType(Ty)); 894 else { 895 assert(Ty.isDerivedType() && "Unknown kind of DIType"); 896 constructTypeDIE(*TyDIE, DIDerivedType(Ty)); 897 } 898 899 addToContextOwner(TyDIE, Ty.getContext()); 900 return TyDIE; 901} 902 903/// addType - Add a new type attribute to the specified entity. 904void DwarfDebug::addType(DIE *Entity, DIType Ty) { 905 if (!Ty.Verify()) 906 return; 907 908 // Check for pre-existence. 909 CompileUnit *TypeCU = getCompileUnit(Ty); 910 DIEEntry *Entry = TypeCU->getDIEEntry(Ty); 911 // If it exists then use the existing value. 912 if (Entry) { 913 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry); 914 return; 915 } 916 917 // Construct type. 918 DIE *Buffer = getOrCreateTypeDIE(Ty); 919 920 // Set up proxy. 921 Entry = createDIEEntry(Buffer); 922 TypeCU->insertDIEEntry(Ty, Entry); 923 924 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry); 925} 926 927/// constructTypeDIE - Construct basic type die from DIBasicType. 928void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) { 929 // Get core information. 930 StringRef Name = BTy.getName(); 931 Buffer.setTag(dwarf::DW_TAG_base_type); 932 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 933 BTy.getEncoding()); 934 935 // Add name if not anonymous or intermediate type. 936 if (!Name.empty()) 937 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 938 uint64_t Size = BTy.getSizeInBits() >> 3; 939 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 940} 941 942/// constructTypeDIE - Construct derived type die from DIDerivedType. 943void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) { 944 // Get core information. 945 StringRef Name = DTy.getName(); 946 uint64_t Size = DTy.getSizeInBits() >> 3; 947 unsigned Tag = DTy.getTag(); 948 949 // FIXME - Workaround for templates. 950 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type; 951 952 Buffer.setTag(Tag); 953 954 // Map to main type, void will not have a type. 955 DIType FromTy = DTy.getTypeDerivedFrom(); 956 addType(&Buffer, FromTy); 957 958 // Add name if not anonymous or intermediate type. 959 if (!Name.empty()) 960 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 961 962 // Add size if non-zero (derived types might be zero-sized.) 963 if (Size) 964 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 965 966 // Add source line info if available and TyDesc is not a forward declaration. 967 if (!DTy.isForwardDecl()) 968 addSourceLine(&Buffer, &DTy); 969} 970 971/// constructTypeDIE - Construct type DIE from DICompositeType. 972void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) { 973 // Get core information. 974 StringRef Name = CTy.getName(); 975 976 uint64_t Size = CTy.getSizeInBits() >> 3; 977 unsigned Tag = CTy.getTag(); 978 Buffer.setTag(Tag); 979 980 switch (Tag) { 981 case dwarf::DW_TAG_vector_type: 982 case dwarf::DW_TAG_array_type: 983 constructArrayTypeDIE(Buffer, &CTy); 984 break; 985 case dwarf::DW_TAG_enumeration_type: { 986 DIArray Elements = CTy.getTypeArray(); 987 988 // Add enumerators to enumeration type. 989 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 990 DIE *ElemDie = NULL; 991 DIDescriptor Enum(Elements.getElement(i)); 992 if (Enum.isEnumerator()) { 993 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum)); 994 Buffer.addChild(ElemDie); 995 } 996 } 997 } 998 break; 999 case dwarf::DW_TAG_subroutine_type: { 1000 // Add return type. 1001 DIArray Elements = CTy.getTypeArray(); 1002 DIDescriptor RTy = Elements.getElement(0); 1003 addType(&Buffer, DIType(RTy)); 1004 1005 // Add prototype flag. 1006 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1); 1007 1008 // Add arguments. 1009 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) { 1010 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1011 DIDescriptor Ty = Elements.getElement(i); 1012 addType(Arg, DIType(Ty)); 1013 Buffer.addChild(Arg); 1014 } 1015 } 1016 break; 1017 case dwarf::DW_TAG_structure_type: 1018 case dwarf::DW_TAG_union_type: 1019 case dwarf::DW_TAG_class_type: { 1020 // Add elements to structure type. 1021 DIArray Elements = CTy.getTypeArray(); 1022 1023 // A forward struct declared type may not have elements available. 1024 unsigned N = Elements.getNumElements(); 1025 if (N == 0) 1026 break; 1027 1028 // Add elements to structure type. 1029 for (unsigned i = 0; i < N; ++i) { 1030 DIDescriptor Element = Elements.getElement(i); 1031 DIE *ElemDie = NULL; 1032 if (Element.isSubprogram()) 1033 ElemDie = createSubprogramDIE(DISubprogram(Element)); 1034 else if (Element.isVariable()) { 1035 DIVariable DV(Element); 1036 ElemDie = new DIE(dwarf::DW_TAG_variable); 1037 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, 1038 DV.getName()); 1039 addType(ElemDie, DV.getType()); 1040 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1041 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1042 addSourceLine(ElemDie, &DV); 1043 } else if (Element.isDerivedType()) 1044 ElemDie = createMemberDIE(DIDerivedType(Element)); 1045 else 1046 continue; 1047 Buffer.addChild(ElemDie); 1048 } 1049 1050 if (CTy.isAppleBlockExtension()) 1051 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1); 1052 1053 unsigned RLang = CTy.getRunTimeLang(); 1054 if (RLang) 1055 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, 1056 dwarf::DW_FORM_data1, RLang); 1057 1058 DICompositeType ContainingType = CTy.getContainingType(); 1059 if (DIDescriptor(ContainingType).isCompositeType()) 1060 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 1061 getOrCreateTypeDIE(DIType(ContainingType))); 1062 else { 1063 DIDescriptor Context = CTy.getContext(); 1064 addToContextOwner(&Buffer, Context); 1065 } 1066 break; 1067 } 1068 default: 1069 break; 1070 } 1071 1072 // Add name if not anonymous or intermediate type. 1073 if (!Name.empty()) 1074 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1075 1076 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type 1077 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) 1078 { 1079 // Add size if non-zero (derived types might be zero-sized.) 1080 if (Size) 1081 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 1082 else { 1083 // Add zero size if it is not a forward declaration. 1084 if (CTy.isForwardDecl()) 1085 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1086 else 1087 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0); 1088 } 1089 1090 // Add source line info if available. 1091 if (!CTy.isForwardDecl()) 1092 addSourceLine(&Buffer, &CTy); 1093 } 1094} 1095 1096/// constructSubrangeDIE - Construct subrange DIE from DISubrange. 1097void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){ 1098 int64_t L = SR.getLo(); 1099 int64_t H = SR.getHi(); 1100 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type); 1101 1102 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy); 1103 if (L) 1104 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L); 1105 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H); 1106 1107 Buffer.addChild(DW_Subrange); 1108} 1109 1110/// constructArrayTypeDIE - Construct array type DIE from DICompositeType. 1111void DwarfDebug::constructArrayTypeDIE(DIE &Buffer, 1112 DICompositeType *CTy) { 1113 Buffer.setTag(dwarf::DW_TAG_array_type); 1114 if (CTy->getTag() == dwarf::DW_TAG_vector_type) 1115 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1); 1116 1117 // Emit derived type. 1118 addType(&Buffer, CTy->getTypeDerivedFrom()); 1119 DIArray Elements = CTy->getTypeArray(); 1120 1121 // Get an anonymous type for index type. 1122 CompileUnit *TheCU = getCompileUnit(*CTy); 1123 DIE *IdxTy = TheCU->getIndexTyDie(); 1124 if (!IdxTy) { 1125 // Construct an anonymous type for index type. 1126 IdxTy = new DIE(dwarf::DW_TAG_base_type); 1127 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t)); 1128 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 1129 dwarf::DW_ATE_signed); 1130 TheCU->addDie(IdxTy); 1131 TheCU->setIndexTyDie(IdxTy); 1132 } 1133 1134 // Add subranges to array type. 1135 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1136 DIDescriptor Element = Elements.getElement(i); 1137 if (Element.getTag() == dwarf::DW_TAG_subrange_type) 1138 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy); 1139 } 1140} 1141 1142/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator. 1143DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) { 1144 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator); 1145 StringRef Name = ETy.getName(); 1146 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1147 int64_t Value = ETy.getEnumValue(); 1148 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value); 1149 return Enumerator; 1150} 1151 1152/// getRealLinkageName - If special LLVM prefix that is used to inform the asm 1153/// printer to not emit usual symbol prefix before the symbol name is used then 1154/// return linkage name after skipping this special LLVM prefix. 1155static StringRef getRealLinkageName(StringRef LinkageName) { 1156 char One = '\1'; 1157 if (LinkageName.startswith(StringRef(&One, 1))) 1158 return LinkageName.substr(1); 1159 return LinkageName; 1160} 1161 1162/// createGlobalVariableDIE - Create new DIE using GV. 1163DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) { 1164 // If the global variable was optmized out then no need to create debug info 1165 // entry. 1166 if (!GV.getGlobal()) return NULL; 1167 if (GV.getDisplayName().empty()) return NULL; 1168 1169 DIE *GVDie = new DIE(dwarf::DW_TAG_variable); 1170 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, 1171 GV.getDisplayName()); 1172 1173 StringRef LinkageName = GV.getLinkageName(); 1174 if (!LinkageName.empty()) 1175 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string, 1176 getRealLinkageName(LinkageName)); 1177 1178 addType(GVDie, GV.getType()); 1179 if (!GV.isLocalToUnit()) 1180 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1181 addSourceLine(GVDie, &GV); 1182 1183 return GVDie; 1184} 1185 1186/// createMemberDIE - Create new member DIE. 1187DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) { 1188 DIE *MemberDie = new DIE(DT.getTag()); 1189 StringRef Name = DT.getName(); 1190 if (!Name.empty()) 1191 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1192 1193 addType(MemberDie, DT.getTypeDerivedFrom()); 1194 1195 addSourceLine(MemberDie, &DT); 1196 1197 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock(); 1198 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 1199 1200 uint64_t Size = DT.getSizeInBits(); 1201 uint64_t FieldSize = DT.getOriginalTypeSize(); 1202 1203 if (Size != FieldSize) { 1204 // Handle bitfield. 1205 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3); 1206 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits()); 1207 1208 uint64_t Offset = DT.getOffsetInBits(); 1209 uint64_t AlignMask = ~(DT.getAlignInBits() - 1); 1210 uint64_t HiMark = (Offset + FieldSize) & AlignMask; 1211 uint64_t FieldOffset = (HiMark - FieldSize); 1212 Offset -= FieldOffset; 1213 1214 // Maybe we need to work from the other end. 1215 if (Asm->getTargetData().isLittleEndian()) 1216 Offset = FieldSize - (Offset + Size); 1217 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset); 1218 1219 // Here WD_AT_data_member_location points to the anonymous 1220 // field that includes this bit field. 1221 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3); 1222 1223 } else 1224 // This is not a bitfield. 1225 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3); 1226 1227 if (DT.getTag() == dwarf::DW_TAG_inheritance 1228 && DT.isVirtual()) { 1229 1230 // For C++, virtual base classes are not at fixed offset. Use following 1231 // expression to extract appropriate offset from vtable. 1232 // BaseAddr = ObAddr + *((*ObAddr) - Offset) 1233 1234 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock(); 1235 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup); 1236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits()); 1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus); 1240 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1241 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1242 1243 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, 1244 VBaseLocationDie); 1245 } else 1246 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie); 1247 1248 if (DT.isProtected()) 1249 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1250 dwarf::DW_ACCESS_protected); 1251 else if (DT.isPrivate()) 1252 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1253 dwarf::DW_ACCESS_private); 1254 else if (DT.getTag() == dwarf::DW_TAG_inheritance) 1255 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 1256 dwarf::DW_ACCESS_public); 1257 if (DT.isVirtual()) 1258 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, 1259 dwarf::DW_VIRTUALITY_virtual); 1260 return MemberDie; 1261} 1262 1263/// createSubprogramDIE - Create new DIE using SP. 1264DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) { 1265 CompileUnit *SPCU = getCompileUnit(SP); 1266 DIE *SPDie = SPCU->getDIE(SP); 1267 if (SPDie) 1268 return SPDie; 1269 1270 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1271 // Constructors and operators for anonymous aggregates do not have names. 1272 if (!SP.getName().empty()) 1273 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName()); 1274 1275 StringRef LinkageName = SP.getLinkageName(); 1276 if (!LinkageName.empty()) 1277 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string, 1278 getRealLinkageName(LinkageName)); 1279 1280 addSourceLine(SPDie, &SP); 1281 1282 // Add prototyped tag, if C or ObjC. 1283 unsigned Lang = SP.getCompileUnit().getLanguage(); 1284 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 || 1285 Lang == dwarf::DW_LANG_ObjC) 1286 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1); 1287 1288 // Add Return Type. 1289 DICompositeType SPTy = SP.getType(); 1290 DIArray Args = SPTy.getTypeArray(); 1291 unsigned SPTag = SPTy.getTag(); 1292 1293 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type) 1294 addType(SPDie, SPTy); 1295 else 1296 addType(SPDie, DIType(Args.getElement(0))); 1297 1298 unsigned VK = SP.getVirtuality(); 1299 if (VK) { 1300 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK); 1301 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1302 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1303 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex()); 1304 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block); 1305 ContainingTypeMap.insert(std::make_pair(SPDie, 1306 SP.getContainingType())); 1307 } 1308 1309 if (MakeDecl || !SP.isDefinition()) { 1310 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1311 1312 // Add arguments. Do not add arguments for subprogram definition. They will 1313 // be handled while processing variables. 1314 DICompositeType SPTy = SP.getType(); 1315 DIArray Args = SPTy.getTypeArray(); 1316 unsigned SPTag = SPTy.getTag(); 1317 1318 if (SPTag == dwarf::DW_TAG_subroutine_type) 1319 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1320 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1321 DIType ATy = DIType(DIType(Args.getElement(i))); 1322 addType(Arg, ATy); 1323 if (ATy.isArtificial()) 1324 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1325 SPDie->addChild(Arg); 1326 } 1327 } 1328 1329 if (SP.isArtificial()) 1330 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1331 1332 if (!SP.isLocalToUnit()) 1333 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1334 1335 if (SP.isOptimized()) 1336 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 1337 1338 // DW_TAG_inlined_subroutine may refer to this DIE. 1339 SPCU->insertDIE(SP, SPDie); 1340 1341 // Add to context owner. 1342 addToContextOwner(SPDie, SP.getContext()); 1343 1344 return SPDie; 1345} 1346 1347DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) { 1348 assert(N && "Invalid Scope encoding!"); 1349 1350 DbgScope *AScope = AbstractScopes.lookup(N); 1351 if (AScope) 1352 return AScope; 1353 1354 DbgScope *Parent = NULL; 1355 1356 DIDescriptor Scope(N); 1357 if (Scope.isLexicalBlock()) { 1358 DILexicalBlock DB(N); 1359 DIDescriptor ParentDesc = DB.getContext(); 1360 Parent = getOrCreateAbstractScope(ParentDesc); 1361 } 1362 1363 AScope = new DbgScope(Parent, DIDescriptor(N), NULL); 1364 1365 if (Parent) 1366 Parent->addScope(AScope); 1367 AScope->setAbstractScope(); 1368 AbstractScopes[N] = AScope; 1369 if (DIDescriptor(N).isSubprogram()) 1370 AbstractScopesList.push_back(AScope); 1371 return AScope; 1372} 1373 1374/// isSubprogramContext - Return true if Context is either a subprogram 1375/// or another context nested inside a subprogram. 1376static bool isSubprogramContext(const MDNode *Context) { 1377 if (!Context) 1378 return false; 1379 DIDescriptor D(Context); 1380 if (D.isSubprogram()) 1381 return true; 1382 if (D.isType()) 1383 return isSubprogramContext(DIType(Context).getContext()); 1384 return false; 1385} 1386 1387/// updateSubprogramScopeDIE - Find DIE for the given subprogram and 1388/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes. 1389/// If there are global variables in this scope then create and insert 1390/// DIEs for these variables. 1391DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) { 1392 CompileUnit *SPCU = getCompileUnit(SPNode); 1393 DIE *SPDie = SPCU->getDIE(SPNode); 1394 1395 assert(SPDie && "Unable to find subprogram DIE!"); 1396 DISubprogram SP(SPNode); 1397 1398 // There is not any need to generate specification DIE for a function 1399 // defined at compile unit level. If a function is defined inside another 1400 // function then gdb prefers the definition at top level and but does not 1401 // expect specification DIE in parent function. So avoid creating 1402 // specification DIE for a function defined inside a function. 1403 if (SP.isDefinition() && !SP.getContext().isCompileUnit() && 1404 !SP.getContext().isFile() && 1405 !isSubprogramContext(SP.getContext())) { 1406 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1407 1408 // Add arguments. 1409 DICompositeType SPTy = SP.getType(); 1410 DIArray Args = SPTy.getTypeArray(); 1411 unsigned SPTag = SPTy.getTag(); 1412 if (SPTag == dwarf::DW_TAG_subroutine_type) 1413 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1414 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1415 DIType ATy = DIType(DIType(Args.getElement(i))); 1416 addType(Arg, ATy); 1417 if (ATy.isArtificial()) 1418 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1419 SPDie->addChild(Arg); 1420 } 1421 DIE *SPDeclDie = SPDie; 1422 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1423 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4, 1424 SPDeclDie); 1425 SPCU->addDie(SPDie); 1426 } 1427 1428 // Pick up abstract subprogram DIE. 1429 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) { 1430 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1431 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, 1432 dwarf::DW_FORM_ref4, AbsSPDIE); 1433 SPCU->addDie(SPDie); 1434 } 1435 1436 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 1437 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber())); 1438 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, 1439 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber())); 1440 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 1441 MachineLocation Location(RI->getFrameRegister(*Asm->MF)); 1442 addAddress(SPDie, dwarf::DW_AT_frame_base, Location); 1443 1444 return SPDie; 1445} 1446 1447/// constructLexicalScope - Construct new DW_TAG_lexical_block 1448/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels. 1449DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) { 1450 1451 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block); 1452 if (Scope->isAbstractScope()) 1453 return ScopeDIE; 1454 1455 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges(); 1456 if (Ranges.empty()) 1457 return 0; 1458 1459 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(); 1460 if (Ranges.size() > 1) { 1461 // .debug_range section has not been laid out yet. Emit offset in 1462 // .debug_range as a uint, size 4, for now. emitDIE will handle 1463 // DW_AT_ranges appropriately. 1464 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4, 1465 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize()); 1466 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 1467 RE = Ranges.end(); RI != RE; ++RI) { 1468 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first)); 1469 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second)); 1470 } 1471 DebugRangeSymbols.push_back(NULL); 1472 DebugRangeSymbols.push_back(NULL); 1473 return ScopeDIE; 1474 } 1475 1476 const MCSymbol *Start = getLabelBeforeInsn(RI->first); 1477 const MCSymbol *End = getLabelAfterInsn(RI->second); 1478 1479 if (End == 0) return 0; 1480 1481 assert(Start->isDefined() && "Invalid starting label for an inlined scope!"); 1482 assert(End->isDefined() && "Invalid end label for an inlined scope!"); 1483 1484 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start); 1485 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End); 1486 1487 return ScopeDIE; 1488} 1489 1490/// constructInlinedScopeDIE - This scope represents inlined body of 1491/// a function. Construct DIE to represent this concrete inlined copy 1492/// of the function. 1493DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) { 1494 1495 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges(); 1496 assert (Ranges.empty() == false 1497 && "DbgScope does not have instruction markers!"); 1498 1499 // FIXME : .debug_inlined section specification does not clearly state how 1500 // to emit inlined scope that is split into multiple instruction ranges. 1501 // For now, use first instruction range and emit low_pc/high_pc pair and 1502 // corresponding .debug_inlined section entry for this pair. 1503 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(); 1504 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first); 1505 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second); 1506 1507 if (StartLabel == 0 || EndLabel == 0) { 1508 assert (0 && "Unexpected Start and End labels for a inlined scope!"); 1509 return 0; 1510 } 1511 assert(StartLabel->isDefined() && 1512 "Invalid starting label for an inlined scope!"); 1513 assert(EndLabel->isDefined() && 1514 "Invalid end label for an inlined scope!"); 1515 1516 if (!Scope->getScopeNode()) 1517 return NULL; 1518 DIScope DS(Scope->getScopeNode()); 1519 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine); 1520 1521 DISubprogram InlinedSP = getDISubprogram(DS); 1522 CompileUnit *TheCU = getCompileUnit(InlinedSP); 1523 DIE *OriginDIE = TheCU->getDIE(InlinedSP); 1524 assert(OriginDIE && "Unable to find Origin DIE!"); 1525 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, 1526 dwarf::DW_FORM_ref4, OriginDIE); 1527 1528 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel); 1529 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel); 1530 1531 InlinedSubprogramDIEs.insert(OriginDIE); 1532 1533 // Track the start label for this inlined function. 1534 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator 1535 I = InlineInfo.find(InlinedSP); 1536 1537 if (I == InlineInfo.end()) { 1538 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, 1539 ScopeDIE)); 1540 InlinedSPNodes.push_back(InlinedSP); 1541 } else 1542 I->second.push_back(std::make_pair(StartLabel, ScopeDIE)); 1543 1544 DILocation DL(Scope->getInlinedAt()); 1545 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID()); 1546 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber()); 1547 1548 return ScopeDIE; 1549} 1550 1551 1552/// constructVariableDIE - Construct a DIE for the given DbgVariable. 1553DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) { 1554 // Get the descriptor. 1555 const DIVariable &VD = DV->getVariable(); 1556 StringRef Name = VD.getName(); 1557 if (Name.empty()) 1558 return NULL; 1559 1560 // Translate tag to proper Dwarf tag. The result variable is dropped for 1561 // now. 1562 unsigned Tag; 1563 switch (VD.getTag()) { 1564 case dwarf::DW_TAG_return_variable: 1565 return NULL; 1566 case dwarf::DW_TAG_arg_variable: 1567 Tag = dwarf::DW_TAG_formal_parameter; 1568 break; 1569 case dwarf::DW_TAG_auto_variable: // fall thru 1570 default: 1571 Tag = dwarf::DW_TAG_variable; 1572 break; 1573 } 1574 1575 // Define variable debug information entry. 1576 DIE *VariableDie = new DIE(Tag); 1577 1578 DIE *AbsDIE = NULL; 1579 DenseMap<const DbgVariable *, const DbgVariable *>::iterator 1580 V2AVI = VarToAbstractVarMap.find(DV); 1581 if (V2AVI != VarToAbstractVarMap.end()) 1582 AbsDIE = V2AVI->second->getDIE(); 1583 1584 if (AbsDIE) 1585 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, 1586 dwarf::DW_FORM_ref4, AbsDIE); 1587 else { 1588 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1589 addSourceLine(VariableDie, &VD); 1590 1591 // Add variable type. 1592 // FIXME: isBlockByrefVariable should be reformulated in terms of complex 1593 // addresses instead. 1594 if (VD.isBlockByrefVariable()) 1595 addType(VariableDie, getBlockByrefType(VD.getType(), Name)); 1596 else 1597 addType(VariableDie, VD.getType()); 1598 } 1599 1600 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial()) 1601 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 1602 1603 if (Scope->isAbstractScope()) { 1604 DV->setDIE(VariableDie); 1605 return VariableDie; 1606 } 1607 1608 // Add variable address. 1609 1610 unsigned Offset = DV->getDotDebugLocOffset(); 1611 if (Offset != ~0U) { 1612 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4, 1613 Asm->GetTempSymbol("debug_loc", Offset)); 1614 DV->setDIE(VariableDie); 1615 UseDotDebugLocEntry.insert(VariableDie); 1616 return VariableDie; 1617 } 1618 1619 // Check if variable is described by a DBG_VALUE instruction. 1620 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI = 1621 DbgVariableToDbgInstMap.find(DV); 1622 if (DVI != DbgVariableToDbgInstMap.end()) { 1623 const MachineInstr *DVInsn = DVI->second; 1624 const MCSymbol *DVLabel = findVariableLabel(DV); 1625 bool updated = false; 1626 // FIXME : Handle getNumOperands != 3 1627 if (DVInsn->getNumOperands() == 3) { 1628 if (DVInsn->getOperand(0).isReg()) 1629 updated = 1630 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0)); 1631 else if (DVInsn->getOperand(0).isImm()) 1632 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0)); 1633 else if (DVInsn->getOperand(0).isFPImm()) 1634 updated = 1635 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0)); 1636 } else { 1637 MachineLocation Location = Asm->getDebugValueLocation(DVInsn); 1638 if (Location.getReg()) { 1639 addAddress(VariableDie, dwarf::DW_AT_location, Location); 1640 if (DVLabel) 1641 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, 1642 DVLabel); 1643 updated = true; 1644 } 1645 } 1646 if (!updated) { 1647 // If variableDie is not updated then DBG_VALUE instruction does not 1648 // have valid variable info. 1649 delete VariableDie; 1650 return NULL; 1651 } 1652 DV->setDIE(VariableDie); 1653 return VariableDie; 1654 } 1655 1656 // .. else use frame index, if available. 1657 MachineLocation Location; 1658 unsigned FrameReg; 1659 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 1660 int FI = 0; 1661 if (findVariableFrameIndex(DV, &FI)) { 1662 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg); 1663 Location.set(FrameReg, Offset); 1664 1665 if (VD.hasComplexAddress()) 1666 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location); 1667 else if (VD.isBlockByrefVariable()) 1668 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location); 1669 else 1670 addAddress(VariableDie, dwarf::DW_AT_location, Location); 1671 } 1672 DV->setDIE(VariableDie); 1673 return VariableDie; 1674 1675} 1676 1677void DwarfDebug::addPubTypes(DISubprogram SP) { 1678 DICompositeType SPTy = SP.getType(); 1679 unsigned SPTag = SPTy.getTag(); 1680 if (SPTag != dwarf::DW_TAG_subroutine_type) 1681 return; 1682 1683 DIArray Args = SPTy.getTypeArray(); 1684 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) { 1685 DIType ATy(Args.getElement(i)); 1686 if (!ATy.Verify()) 1687 continue; 1688 DICompositeType CATy = getDICompositeType(ATy); 1689 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty() 1690 && !CATy.isForwardDecl()) { 1691 CompileUnit *TheCU = getCompileUnit(CATy); 1692 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy)) 1693 TheCU->addGlobalType(CATy.getName(), Entry->getEntry()); 1694 } 1695 } 1696} 1697 1698/// constructScopeDIE - Construct a DIE for this scope. 1699DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) { 1700 if (!Scope || !Scope->getScopeNode()) 1701 return NULL; 1702 1703 DIScope DS(Scope->getScopeNode()); 1704 DIE *ScopeDIE = NULL; 1705 if (Scope->getInlinedAt()) 1706 ScopeDIE = constructInlinedScopeDIE(Scope); 1707 else if (DS.isSubprogram()) { 1708 ProcessedSPNodes.insert(DS); 1709 if (Scope->isAbstractScope()) { 1710 ScopeDIE = getCompileUnit(DS)->getDIE(DS); 1711 // Note down abstract DIE. 1712 if (ScopeDIE) 1713 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE)); 1714 } 1715 else 1716 ScopeDIE = updateSubprogramScopeDIE(DS); 1717 } 1718 else 1719 ScopeDIE = constructLexicalScopeDIE(Scope); 1720 if (!ScopeDIE) return NULL; 1721 1722 // Add variables to scope. 1723 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables(); 1724 for (unsigned i = 0, N = Variables.size(); i < N; ++i) { 1725 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope); 1726 if (VariableDIE) 1727 ScopeDIE->addChild(VariableDIE); 1728 } 1729 1730 // Add nested scopes. 1731 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes(); 1732 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) { 1733 // Define the Scope debug information entry. 1734 DIE *NestedDIE = constructScopeDIE(Scopes[j]); 1735 if (NestedDIE) 1736 ScopeDIE->addChild(NestedDIE); 1737 } 1738 1739 if (DS.isSubprogram()) 1740 addPubTypes(DISubprogram(DS)); 1741 1742 return ScopeDIE; 1743} 1744 1745/// GetOrCreateSourceID - Look up the source id with the given directory and 1746/// source file names. If none currently exists, create a new id and insert it 1747/// in the SourceIds map. This can update DirectoryNames and SourceFileNames 1748/// maps as well. 1749unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){ 1750 unsigned DId; 1751 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName); 1752 if (DI != DirectoryIdMap.end()) { 1753 DId = DI->getValue(); 1754 } else { 1755 DId = DirectoryNames.size() + 1; 1756 DirectoryIdMap[DirName] = DId; 1757 DirectoryNames.push_back(DirName); 1758 } 1759 1760 unsigned FId; 1761 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName); 1762 if (FI != SourceFileIdMap.end()) { 1763 FId = FI->getValue(); 1764 } else { 1765 FId = SourceFileNames.size() + 1; 1766 SourceFileIdMap[FileName] = FId; 1767 SourceFileNames.push_back(FileName); 1768 } 1769 1770 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI = 1771 SourceIdMap.find(std::make_pair(DId, FId)); 1772 if (SI != SourceIdMap.end()) 1773 return SI->second; 1774 1775 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0. 1776 SourceIdMap[std::make_pair(DId, FId)] = SrcId; 1777 SourceIds.push_back(std::make_pair(DId, FId)); 1778 1779 return SrcId; 1780} 1781 1782/// getOrCreateNameSpace - Create a DIE for DINameSpace. 1783DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) { 1784 CompileUnit *TheCU = getCompileUnit(NS); 1785 DIE *NDie = TheCU->getDIE(NS); 1786 if (NDie) 1787 return NDie; 1788 NDie = new DIE(dwarf::DW_TAG_namespace); 1789 TheCU->insertDIE(NS, NDie); 1790 if (!NS.getName().empty()) 1791 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName()); 1792 addSourceLine(NDie, &NS); 1793 addToContextOwner(NDie, NS.getContext()); 1794 return NDie; 1795} 1796 1797/// constructCompileUnit - Create new CompileUnit for the given 1798/// metadata node with tag DW_TAG_compile_unit. 1799void DwarfDebug::constructCompileUnit(const MDNode *N) { 1800 DICompileUnit DIUnit(N); 1801 StringRef FN = DIUnit.getFilename(); 1802 StringRef Dir = DIUnit.getDirectory(); 1803 unsigned ID = GetOrCreateSourceID(Dir, FN); 1804 1805 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 1806 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string, 1807 DIUnit.getProducer()); 1808 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1, 1809 DIUnit.getLanguage()); 1810 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN); 1811 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This 1812 // simplifies debug range entries. 1813 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0); 1814 // DW_AT_stmt_list is a offset of line number information for this 1815 // compile unit in debug_line section. This offset is calculated 1816 // during endMoudle(). 1817 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0); 1818 1819 if (!Dir.empty()) 1820 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir); 1821 if (DIUnit.isOptimized()) 1822 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 1823 1824 StringRef Flags = DIUnit.getFlags(); 1825 if (!Flags.empty()) 1826 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags); 1827 1828 unsigned RVer = DIUnit.getRunTimeVersion(); 1829 if (RVer) 1830 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers, 1831 dwarf::DW_FORM_data1, RVer); 1832 1833 CompileUnit *NewCU = new CompileUnit(ID, Die); 1834 if (!FirstCU) 1835 FirstCU = NewCU; 1836 CUMap.insert(std::make_pair(N, NewCU)); 1837} 1838 1839/// getCompielUnit - Get CompileUnit DIE. 1840CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const { 1841 assert (N && "Invalid DwarfDebug::getCompileUnit argument!"); 1842 DIDescriptor D(N); 1843 const MDNode *CUNode = NULL; 1844 if (D.isCompileUnit()) 1845 CUNode = N; 1846 else if (D.isSubprogram()) 1847 CUNode = DISubprogram(N).getCompileUnit(); 1848 else if (D.isType()) 1849 CUNode = DIType(N).getCompileUnit(); 1850 else if (D.isGlobalVariable()) 1851 CUNode = DIGlobalVariable(N).getCompileUnit(); 1852 else if (D.isVariable()) 1853 CUNode = DIVariable(N).getCompileUnit(); 1854 else if (D.isNameSpace()) 1855 CUNode = DINameSpace(N).getCompileUnit(); 1856 else if (D.isFile()) 1857 CUNode = DIFile(N).getCompileUnit(); 1858 else 1859 return FirstCU; 1860 1861 DenseMap<const MDNode *, CompileUnit *>::const_iterator I 1862 = CUMap.find(CUNode); 1863 if (I == CUMap.end()) 1864 return FirstCU; 1865 return I->second; 1866} 1867 1868 1869/// constructGlobalVariableDIE - Construct global variable DIE. 1870void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) { 1871 DIGlobalVariable DI_GV(N); 1872 1873 // If debug information is malformed then ignore it. 1874 if (DI_GV.Verify() == false) 1875 return; 1876 1877 // Check for pre-existence. 1878 CompileUnit *TheCU = getCompileUnit(N); 1879 if (TheCU->getDIE(DI_GV)) 1880 return; 1881 1882 DIE *VariableDie = createGlobalVariableDIE(DI_GV); 1883 if (!VariableDie) 1884 return; 1885 1886 // Add to map. 1887 TheCU->insertDIE(N, VariableDie); 1888 1889 // Add to context owner. 1890 DIDescriptor GVContext = DI_GV.getContext(); 1891 // Do not create specification DIE if context is either compile unit 1892 // or a subprogram. 1893 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() && 1894 !GVContext.isFile() && 1895 !isSubprogramContext(GVContext)) { 1896 // Create specification DIE. 1897 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable); 1898 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, 1899 dwarf::DW_FORM_ref4, VariableDie); 1900 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1901 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 1902 addLabel(Block, 0, dwarf::DW_FORM_udata, 1903 Asm->Mang->getSymbol(DI_GV.getGlobal())); 1904 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block); 1905 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1906 TheCU->addDie(VariableSpecDIE); 1907 } else { 1908 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1909 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 1910 addLabel(Block, 0, dwarf::DW_FORM_udata, 1911 Asm->Mang->getSymbol(DI_GV.getGlobal())); 1912 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block); 1913 } 1914 addToContextOwner(VariableDie, GVContext); 1915 1916 // Expose as global. FIXME - need to check external flag. 1917 TheCU->addGlobal(DI_GV.getName(), VariableDie); 1918 1919 DIType GTy = DI_GV.getType(); 1920 if (GTy.isCompositeType() && !GTy.getName().empty() 1921 && !GTy.isForwardDecl()) { 1922 DIEEntry *Entry = TheCU->getDIEEntry(GTy); 1923 assert(Entry && "Missing global type!"); 1924 TheCU->addGlobalType(GTy.getName(), Entry->getEntry()); 1925 } 1926 return; 1927} 1928 1929/// construct SubprogramDIE - Construct subprogram DIE. 1930void DwarfDebug::constructSubprogramDIE(const MDNode *N) { 1931 DISubprogram SP(N); 1932 1933 // Check for pre-existence. 1934 CompileUnit *TheCU = getCompileUnit(N); 1935 if (TheCU->getDIE(N)) 1936 return; 1937 1938 if (!SP.isDefinition()) 1939 // This is a method declaration which will be handled while constructing 1940 // class type. 1941 return; 1942 1943 DIE *SubprogramDie = createSubprogramDIE(SP); 1944 1945 // Add to map. 1946 TheCU->insertDIE(N, SubprogramDie); 1947 1948 // Add to context owner. 1949 addToContextOwner(SubprogramDie, SP.getContext()); 1950 1951 // Expose as global. 1952 TheCU->addGlobal(SP.getName(), SubprogramDie); 1953 1954 return; 1955} 1956 1957/// beginModule - Emit all Dwarf sections that should come prior to the 1958/// content. Create global DIEs and emit initial debug info sections. 1959/// This is inovked by the target AsmPrinter. 1960void DwarfDebug::beginModule(Module *M) { 1961 if (DisableDebugInfoPrinting) 1962 return; 1963 1964 DebugInfoFinder DbgFinder; 1965 DbgFinder.processModule(*M); 1966 1967 bool HasDebugInfo = false; 1968 1969 // Scan all the compile-units to see if there are any marked as the main unit. 1970 // if not, we do not generate debug info. 1971 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 1972 E = DbgFinder.compile_unit_end(); I != E; ++I) { 1973 if (DICompileUnit(*I).isMain()) { 1974 HasDebugInfo = true; 1975 break; 1976 } 1977 } 1978 1979 if (!HasDebugInfo) return; 1980 1981 // Tell MMI that we have debug info. 1982 MMI->setDebugInfoAvailability(true); 1983 1984 // Emit initial sections. 1985 EmitSectionLabels(); 1986 1987 // Create all the compile unit DIEs. 1988 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 1989 E = DbgFinder.compile_unit_end(); I != E; ++I) 1990 constructCompileUnit(*I); 1991 1992 // Create DIEs for each subprogram. 1993 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(), 1994 E = DbgFinder.subprogram_end(); I != E; ++I) 1995 constructSubprogramDIE(*I); 1996 1997 // Create DIEs for each global variable. 1998 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(), 1999 E = DbgFinder.global_variable_end(); I != E; ++I) 2000 constructGlobalVariableDIE(*I); 2001 2002 // Prime section data. 2003 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 2004 2005 // Print out .file directives to specify files for .loc directives. These are 2006 // printed out early so that they precede any .loc directives. 2007 if (Asm->MAI->hasDotLocAndDotFile()) { 2008 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) { 2009 // Remember source id starts at 1. 2010 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i); 2011 // FIXME: don't use sys::path for this! This should not depend on the 2012 // host. 2013 sys::Path FullPath(getSourceDirectoryName(Id.first)); 2014 bool AppendOk = 2015 FullPath.appendComponent(getSourceFileName(Id.second)); 2016 assert(AppendOk && "Could not append filename to directory!"); 2017 AppendOk = false; 2018 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str()); 2019 } 2020 } 2021} 2022 2023/// endModule - Emit all Dwarf sections that should come after the content. 2024/// 2025void DwarfDebug::endModule() { 2026 if (!FirstCU) return; 2027 const Module *M = MMI->getModule(); 2028 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) { 2029 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) { 2030 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue; 2031 DISubprogram SP(AllSPs->getOperand(SI)); 2032 if (!SP.Verify()) continue; 2033 2034 // Collect info for variables that were optimized out. 2035 StringRef FName = SP.getLinkageName(); 2036 if (FName.empty()) 2037 FName = SP.getName(); 2038 NamedMDNode *NMD = 2039 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName))); 2040 if (!NMD) continue; 2041 unsigned E = NMD->getNumOperands(); 2042 if (!E) continue; 2043 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL); 2044 for (unsigned I = 0; I != E; ++I) { 2045 DIVariable DV(NMD->getOperand(I)); 2046 if (!DV.Verify()) continue; 2047 Scope->addVariable(new DbgVariable(DV)); 2048 } 2049 2050 // Construct subprogram DIE and add variables DIEs. 2051 constructSubprogramDIE(SP); 2052 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP); 2053 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables(); 2054 for (unsigned i = 0, N = Variables.size(); i < N; ++i) { 2055 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope); 2056 if (VariableDIE) 2057 ScopeDIE->addChild(VariableDIE); 2058 } 2059 } 2060 } 2061 2062 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 2063 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 2064 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 2065 DIE *ISP = *AI; 2066 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 2067 } 2068 2069 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(), 2070 CE = ContainingTypeMap.end(); CI != CE; ++CI) { 2071 DIE *SPDie = CI->first; 2072 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second); 2073 if (!N) continue; 2074 DIE *NDie = getCompileUnit(N)->getDIE(N); 2075 if (!NDie) continue; 2076 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie); 2077 } 2078 2079 // Standard sections final addresses. 2080 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 2081 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end")); 2082 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 2083 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end")); 2084 2085 // End text sections. 2086 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) { 2087 Asm->OutStreamer.SwitchSection(SectionMap[i]); 2088 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i)); 2089 } 2090 2091 // Emit common frame information. 2092 emitCommonDebugFrame(); 2093 2094 // Emit function debug frame information 2095 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(), 2096 E = DebugFrames.end(); I != E; ++I) 2097 emitFunctionDebugFrame(*I); 2098 2099 // Compute DIE offsets and sizes. 2100 computeSizeAndOffsets(); 2101 2102 // Emit source line correspondence into a debug line section. 2103 emitDebugLines(); 2104 2105 // Emit all the DIEs into a debug info section 2106 emitDebugInfo(); 2107 2108 // Corresponding abbreviations into a abbrev section. 2109 emitAbbreviations(); 2110 2111 // Emit info into a debug pubnames section. 2112 emitDebugPubNames(); 2113 2114 // Emit info into a debug pubtypes section. 2115 emitDebugPubTypes(); 2116 2117 // Emit info into a debug loc section. 2118 emitDebugLoc(); 2119 2120 // Emit info into a debug aranges section. 2121 EmitDebugARanges(); 2122 2123 // Emit info into a debug ranges section. 2124 emitDebugRanges(); 2125 2126 // Emit info into a debug macinfo section. 2127 emitDebugMacInfo(); 2128 2129 // Emit inline info. 2130 emitDebugInlineInfo(); 2131 2132 // Emit info into a debug str section. 2133 emitDebugStr(); 2134 2135 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2136 E = CUMap.end(); I != E; ++I) 2137 delete I->second; 2138 FirstCU = NULL; // Reset for the next Module, if any. 2139} 2140 2141/// findAbstractVariable - Find abstract variable, if any, associated with Var. 2142DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var, 2143 DebugLoc ScopeLoc) { 2144 2145 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var); 2146 if (AbsDbgVariable) 2147 return AbsDbgVariable; 2148 2149 LLVMContext &Ctx = Var->getContext(); 2150 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx)); 2151 if (!Scope) 2152 return NULL; 2153 2154 AbsDbgVariable = new DbgVariable(Var); 2155 Scope->addVariable(AbsDbgVariable); 2156 AbstractVariables[Var] = AbsDbgVariable; 2157 return AbsDbgVariable; 2158} 2159 2160/// collectVariableInfoFromMMITable - Collect variable information from 2161/// side table maintained by MMI. 2162void 2163DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF, 2164 SmallPtrSet<const MDNode *, 16> &Processed) { 2165 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2166 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 2167 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 2168 VE = VMap.end(); VI != VE; ++VI) { 2169 const MDNode *Var = VI->first; 2170 if (!Var) continue; 2171 Processed.insert(Var); 2172 DIVariable DV(Var); 2173 const std::pair<unsigned, DebugLoc> &VP = VI->second; 2174 2175 DbgScope *Scope = 0; 2176 if (const MDNode *IA = VP.second.getInlinedAt(Ctx)) 2177 Scope = ConcreteScopes.lookup(IA); 2178 if (Scope == 0) 2179 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx)); 2180 2181 // If variable scope is not found then skip this variable. 2182 if (Scope == 0) 2183 continue; 2184 2185 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second); 2186 DbgVariable *RegVar = new DbgVariable(DV); 2187 recordVariableFrameIndex(RegVar, VP.first); 2188 Scope->addVariable(RegVar); 2189 if (AbsDbgVariable) { 2190 recordVariableFrameIndex(AbsDbgVariable, VP.first); 2191 VarToAbstractVarMap[RegVar] = AbsDbgVariable; 2192 } 2193 } 2194} 2195 2196/// isDbgValueInUndefinedReg - Return true if debug value, encoded by 2197/// DBG_VALUE instruction, is in undefined reg. 2198static bool isDbgValueInUndefinedReg(const MachineInstr *MI) { 2199 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 2200 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg()) 2201 return true; 2202 return false; 2203} 2204 2205/// isDbgValueInDefinedReg - Return true if debug value, encoded by 2206/// DBG_VALUE instruction, is in a defined reg. 2207static bool isDbgValueInDefinedReg(const MachineInstr *MI) { 2208 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 2209 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg()) 2210 return true; 2211 return false; 2212} 2213 2214/// collectVariableInfo - Populate DbgScope entries with variables' info. 2215void 2216DwarfDebug::collectVariableInfo(const MachineFunction *MF, 2217 SmallPtrSet<const MDNode *, 16> &Processed) { 2218 2219 /// collection info from MMI table. 2220 collectVariableInfoFromMMITable(MF, Processed); 2221 2222 SmallVector<const MachineInstr *, 8> DbgValues; 2223 // Collect variable information from DBG_VALUE machine instructions; 2224 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 2225 I != E; ++I) 2226 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2227 II != IE; ++II) { 2228 const MachineInstr *MInsn = II; 2229 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn)) 2230 continue; 2231 DbgValues.push_back(MInsn); 2232 } 2233 2234 // This is a collection of DBV_VALUE instructions describing same variable. 2235 SmallVector<const MachineInstr *, 4> MultipleValues; 2236 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(), 2237 E = DbgValues.end(); I != E; ++I) { 2238 const MachineInstr *MInsn = *I; 2239 MultipleValues.clear(); 2240 if (isDbgValueInDefinedReg(MInsn)) 2241 MultipleValues.push_back(MInsn); 2242 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata()); 2243 if (Processed.count(DV) != 0) 2244 continue; 2245 2246 const MachineInstr *PrevMI = MInsn; 2247 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1, 2248 ME = DbgValues.end(); MI != ME; ++MI) { 2249 const MDNode *Var = 2250 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata(); 2251 if (Var == DV && isDbgValueInDefinedReg(*MI) && 2252 !PrevMI->isIdenticalTo(*MI)) 2253 MultipleValues.push_back(*MI); 2254 PrevMI = *MI; 2255 } 2256 2257 DbgScope *Scope = findDbgScope(MInsn); 2258 bool CurFnArg = false; 2259 if (DV.getTag() == dwarf::DW_TAG_arg_variable && 2260 DISubprogram(DV.getContext()).describes(MF->getFunction())) 2261 CurFnArg = true; 2262 if (!Scope && CurFnArg) 2263 Scope = CurrentFnDbgScope; 2264 // If variable scope is not found then skip this variable. 2265 if (!Scope) 2266 continue; 2267 2268 Processed.insert(DV); 2269 DbgVariable *RegVar = new DbgVariable(DV); 2270 Scope->addVariable(RegVar); 2271 if (!CurFnArg) 2272 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn); 2273 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) { 2274 DbgVariableToDbgInstMap[AbsVar] = MInsn; 2275 VarToAbstractVarMap[RegVar] = AbsVar; 2276 } 2277 if (MultipleValues.size() <= 1) { 2278 DbgVariableToDbgInstMap[RegVar] = MInsn; 2279 continue; 2280 } 2281 2282 // handle multiple DBG_VALUE instructions describing one variable. 2283 if (DotDebugLocEntries.empty()) 2284 RegVar->setDotDebugLocOffset(0); 2285 else 2286 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size()); 2287 const MachineInstr *Begin = NULL; 2288 const MachineInstr *End = NULL; 2289 for (SmallVector<const MachineInstr *, 4>::iterator 2290 MVI = MultipleValues.begin(), MVE = MultipleValues.end(); 2291 MVI != MVE; ++MVI) { 2292 if (!Begin) { 2293 Begin = *MVI; 2294 continue; 2295 } 2296 End = *MVI; 2297 MachineLocation MLoc; 2298 MLoc.set(Begin->getOperand(0).getReg(), 0); 2299 const MCSymbol *FLabel = getLabelBeforeInsn(Begin); 2300 const MCSymbol *SLabel = getLabelBeforeInsn(End); 2301 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc)); 2302 Begin = End; 2303 if (MVI + 1 == MVE) { 2304 // If End is the last instruction then its value is valid 2305 // until the end of the funtion. 2306 MLoc.set(End->getOperand(0).getReg(), 0); 2307 DotDebugLocEntries. 2308 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc)); 2309 } 2310 } 2311 DotDebugLocEntries.push_back(DotDebugLocEntry()); 2312 } 2313 2314 // Collect info for variables that were optimized out. 2315 const Function *F = MF->getFunction(); 2316 const Module *M = F->getParent(); 2317 if (NamedMDNode *NMD = 2318 M->getNamedMetadata(Twine("llvm.dbg.lv.", 2319 getRealLinkageName(F->getName())))) { 2320 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2321 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i))); 2322 if (!DV || !Processed.insert(DV)) 2323 continue; 2324 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext()); 2325 if (Scope) 2326 Scope->addVariable(new DbgVariable(DV)); 2327 } 2328 } 2329} 2330 2331/// getLabelBeforeInsn - Return Label preceding the instruction. 2332const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { 2333 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 2334 LabelsBeforeInsn.find(MI); 2335 if (I == LabelsBeforeInsn.end()) 2336 // FunctionBeginSym always preceeds all the instruction in current function. 2337 return FunctionBeginSym; 2338 return I->second; 2339} 2340 2341/// getLabelAfterInsn - Return Label immediately following the instruction. 2342const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { 2343 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 2344 LabelsAfterInsn.find(MI); 2345 if (I == LabelsAfterInsn.end()) 2346 return NULL; 2347 return I->second; 2348} 2349 2350/// beginScope - Process beginning of a scope. 2351void DwarfDebug::beginScope(const MachineInstr *MI) { 2352 if (InsnNeedsLabel.count(MI) == 0) { 2353 LabelsBeforeInsn[MI] = PrevLabel; 2354 return; 2355 } 2356 2357 // Check location. 2358 DebugLoc DL = MI->getDebugLoc(); 2359 if (!DL.isUnknown()) { 2360 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 2361 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope); 2362 PrevInstLoc = DL; 2363 LabelsBeforeInsn[MI] = PrevLabel; 2364 return; 2365 } 2366 2367 // If location is unknown then use temp label for this DBG_VALUE 2368 // instruction. 2369 if (MI->isDebugValue()) { 2370 PrevLabel = MMI->getContext().CreateTempSymbol(); 2371 Asm->OutStreamer.EmitLabel(PrevLabel); 2372 LabelsBeforeInsn[MI] = PrevLabel; 2373 return; 2374 } 2375 2376 if (UnknownLocations) { 2377 PrevLabel = recordSourceLine(0, 0, 0); 2378 LabelsBeforeInsn[MI] = PrevLabel; 2379 return; 2380 } 2381 2382 assert (0 && "Instruction is not processed!"); 2383} 2384 2385/// endScope - Process end of a scope. 2386void DwarfDebug::endScope(const MachineInstr *MI) { 2387 if (InsnsEndScopeSet.count(MI) != 0) { 2388 // Emit a label if this instruction ends a scope. 2389 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2390 Asm->OutStreamer.EmitLabel(Label); 2391 LabelsAfterInsn[MI] = Label; 2392 } 2393} 2394 2395/// getOrCreateDbgScope - Create DbgScope for the scope. 2396DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, 2397 const MDNode *InlinedAt) { 2398 if (!InlinedAt) { 2399 DbgScope *WScope = DbgScopeMap.lookup(Scope); 2400 if (WScope) 2401 return WScope; 2402 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL); 2403 DbgScopeMap.insert(std::make_pair(Scope, WScope)); 2404 if (DIDescriptor(Scope).isLexicalBlock()) { 2405 DbgScope *Parent = 2406 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL); 2407 WScope->setParent(Parent); 2408 Parent->addScope(WScope); 2409 } 2410 2411 if (!WScope->getParent()) { 2412 StringRef SPName = DISubprogram(Scope).getLinkageName(); 2413 // We used to check only for a linkage name, but that fails 2414 // since we began omitting the linkage name for private 2415 // functions. The new way is to check for the name in metadata, 2416 // but that's not supported in old .ll test cases. Ergo, we 2417 // check both. 2418 if (SPName == Asm->MF->getFunction()->getName() || 2419 DISubprogram(Scope).getFunction() == Asm->MF->getFunction()) 2420 CurrentFnDbgScope = WScope; 2421 } 2422 2423 return WScope; 2424 } 2425 2426 getOrCreateAbstractScope(Scope); 2427 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt); 2428 if (WScope) 2429 return WScope; 2430 2431 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt); 2432 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope)); 2433 DILocation DL(InlinedAt); 2434 DbgScope *Parent = 2435 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation()); 2436 WScope->setParent(Parent); 2437 Parent->addScope(WScope); 2438 2439 ConcreteScopes[InlinedAt] = WScope; 2440 2441 return WScope; 2442} 2443 2444/// hasValidLocation - Return true if debug location entry attached with 2445/// machine instruction encodes valid location info. 2446static bool hasValidLocation(LLVMContext &Ctx, 2447 const MachineInstr *MInsn, 2448 const MDNode *&Scope, const MDNode *&InlinedAt) { 2449 DebugLoc DL = MInsn->getDebugLoc(); 2450 if (DL.isUnknown()) return false; 2451 2452 const MDNode *S = DL.getScope(Ctx); 2453 2454 // There is no need to create another DIE for compile unit. For all 2455 // other scopes, create one DbgScope now. This will be translated 2456 // into a scope DIE at the end. 2457 if (DIScope(S).isCompileUnit()) return false; 2458 2459 Scope = S; 2460 InlinedAt = DL.getInlinedAt(Ctx); 2461 return true; 2462} 2463 2464/// calculateDominanceGraph - Calculate dominance graph for DbgScope 2465/// hierarchy. 2466static void calculateDominanceGraph(DbgScope *Scope) { 2467 assert (Scope && "Unable to calculate scop edominance graph!"); 2468 SmallVector<DbgScope *, 4> WorkStack; 2469 WorkStack.push_back(Scope); 2470 unsigned Counter = 0; 2471 while (!WorkStack.empty()) { 2472 DbgScope *WS = WorkStack.back(); 2473 const SmallVector<DbgScope *, 4> &Children = WS->getScopes(); 2474 bool visitedChildren = false; 2475 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2476 SE = Children.end(); SI != SE; ++SI) { 2477 DbgScope *ChildScope = *SI; 2478 if (!ChildScope->getDFSOut()) { 2479 WorkStack.push_back(ChildScope); 2480 visitedChildren = true; 2481 ChildScope->setDFSIn(++Counter); 2482 break; 2483 } 2484 } 2485 if (!visitedChildren) { 2486 WorkStack.pop_back(); 2487 WS->setDFSOut(++Counter); 2488 } 2489 } 2490} 2491 2492/// printDbgScopeInfo - Print DbgScope info for each machine instruction. 2493static 2494void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF, 2495 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap) 2496{ 2497#ifndef NDEBUG 2498 unsigned PrevDFSIn = 0; 2499 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2500 I != E; ++I) { 2501 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2502 II != IE; ++II) { 2503 const MachineInstr *MInsn = II; 2504 const MDNode *Scope = NULL; 2505 const MDNode *InlinedAt = NULL; 2506 2507 // Check if instruction has valid location information. 2508 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2509 dbgs() << " [ "; 2510 if (InlinedAt) 2511 dbgs() << "*"; 2512 DenseMap<const MachineInstr *, DbgScope *>::iterator DI = 2513 MI2ScopeMap.find(MInsn); 2514 if (DI != MI2ScopeMap.end()) { 2515 DbgScope *S = DI->second; 2516 dbgs() << S->getDFSIn(); 2517 PrevDFSIn = S->getDFSIn(); 2518 } else 2519 dbgs() << PrevDFSIn; 2520 } else 2521 dbgs() << " [ x" << PrevDFSIn; 2522 dbgs() << " ]"; 2523 MInsn->dump(); 2524 } 2525 dbgs() << "\n"; 2526 } 2527#endif 2528} 2529/// extractScopeInformation - Scan machine instructions in this function 2530/// and collect DbgScopes. Return true, if at least one scope was found. 2531bool DwarfDebug::extractScopeInformation() { 2532 // If scope information was extracted using .dbg intrinsics then there is not 2533 // any need to extract these information by scanning each instruction. 2534 if (!DbgScopeMap.empty()) 2535 return false; 2536 2537 // Scan each instruction and create scopes. First build working set of scopes. 2538 LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2539 SmallVector<DbgRange, 4> MIRanges; 2540 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap; 2541 const MDNode *PrevScope = NULL; 2542 const MDNode *PrevInlinedAt = NULL; 2543 const MachineInstr *RangeBeginMI = NULL; 2544 const MachineInstr *PrevMI = NULL; 2545 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 2546 I != E; ++I) { 2547 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2548 II != IE; ++II) { 2549 const MachineInstr *MInsn = II; 2550 const MDNode *Scope = NULL; 2551 const MDNode *InlinedAt = NULL; 2552 2553 // Check if instruction has valid location information. 2554 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2555 PrevMI = MInsn; 2556 continue; 2557 } 2558 2559 // If scope has not changed then skip this instruction. 2560 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) { 2561 PrevMI = MInsn; 2562 continue; 2563 } 2564 2565 if (RangeBeginMI) { 2566 // If we have alread seen a beginning of a instruction range and 2567 // current instruction scope does not match scope of first instruction 2568 // in this range then create a new instruction range. 2569 DbgRange R(RangeBeginMI, PrevMI); 2570 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, 2571 PrevInlinedAt); 2572 MIRanges.push_back(R); 2573 } 2574 2575 // This is a beginning of a new instruction range. 2576 RangeBeginMI = MInsn; 2577 2578 // Reset previous markers. 2579 PrevMI = MInsn; 2580 PrevScope = Scope; 2581 PrevInlinedAt = InlinedAt; 2582 } 2583 } 2584 2585 // Create last instruction range. 2586 if (RangeBeginMI && PrevMI && PrevScope) { 2587 DbgRange R(RangeBeginMI, PrevMI); 2588 MIRanges.push_back(R); 2589 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt); 2590 } 2591 2592 if (!CurrentFnDbgScope) 2593 return false; 2594 2595 calculateDominanceGraph(CurrentFnDbgScope); 2596 if (PrintDbgScope) 2597 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap); 2598 2599 // Find ranges of instructions covered by each DbgScope; 2600 DbgScope *PrevDbgScope = NULL; 2601 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(), 2602 RE = MIRanges.end(); RI != RE; ++RI) { 2603 const DbgRange &R = *RI; 2604 DbgScope *S = MI2ScopeMap.lookup(R.first); 2605 assert (S && "Lost DbgScope for a machine instruction!"); 2606 if (PrevDbgScope && !PrevDbgScope->dominates(S)) 2607 PrevDbgScope->closeInsnRange(S); 2608 S->openInsnRange(R.first); 2609 S->extendInsnRange(R.second); 2610 PrevDbgScope = S; 2611 } 2612 2613 if (PrevDbgScope) 2614 PrevDbgScope->closeInsnRange(); 2615 2616 identifyScopeMarkers(); 2617 2618 return !DbgScopeMap.empty(); 2619} 2620 2621/// identifyScopeMarkers() - 2622/// Each DbgScope has first instruction and last instruction to mark beginning 2623/// and end of a scope respectively. Create an inverse map that list scopes 2624/// starts (and ends) with an instruction. One instruction may start (or end) 2625/// multiple scopes. Ignore scopes that are not reachable. 2626void DwarfDebug::identifyScopeMarkers() { 2627 SmallVector<DbgScope *, 4> WorkList; 2628 WorkList.push_back(CurrentFnDbgScope); 2629 while (!WorkList.empty()) { 2630 DbgScope *S = WorkList.pop_back_val(); 2631 2632 const SmallVector<DbgScope *, 4> &Children = S->getScopes(); 2633 if (!Children.empty()) 2634 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2635 SE = Children.end(); SI != SE; ++SI) 2636 WorkList.push_back(*SI); 2637 2638 if (S->isAbstractScope()) 2639 continue; 2640 2641 const SmallVector<DbgRange, 4> &Ranges = S->getRanges(); 2642 if (Ranges.empty()) 2643 continue; 2644 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 2645 RE = Ranges.end(); RI != RE; ++RI) { 2646 assert(RI->first && "DbgRange does not have first instruction!"); 2647 assert(RI->second && "DbgRange does not have second instruction!"); 2648 InsnsEndScopeSet.insert(RI->second); 2649 } 2650 } 2651} 2652 2653/// FindFirstDebugLoc - Find the first debug location in the function. This 2654/// is intended to be an approximation for the source position of the 2655/// beginning of the function. 2656static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) { 2657 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2658 I != E; ++I) 2659 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end(); 2660 MBBI != MBBE; ++MBBI) { 2661 DebugLoc DL = MBBI->getDebugLoc(); 2662 if (!DL.isUnknown()) 2663 return DL; 2664 } 2665 return DebugLoc(); 2666} 2667 2668/// beginFunction - Gather pre-function debug information. Assumes being 2669/// emitted immediately after the function entry point. 2670void DwarfDebug::beginFunction(const MachineFunction *MF) { 2671 if (!MMI->hasDebugInfo()) return; 2672 if (!extractScopeInformation()) return; 2673 2674 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 2675 Asm->getFunctionNumber()); 2676 // Assumes in correct section after the entry point. 2677 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 2678 2679 // Emit label for the implicitly defined dbg.stoppoint at the start of the 2680 // function. 2681 DebugLoc FDL = FindFirstDebugLoc(MF); 2682 if (FDL.isUnknown()) return; 2683 2684 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext()); 2685 2686 DISubprogram SP = getDISubprogram(Scope); 2687 unsigned Line, Col; 2688 if (SP.Verify()) { 2689 Line = SP.getLineNumber(); 2690 Col = 0; 2691 } else { 2692 Line = FDL.getLine(); 2693 Col = FDL.getCol(); 2694 } 2695 2696 recordSourceLine(Line, Col, Scope); 2697 2698 /// ProcessedArgs - Collection of arguments already processed. 2699 SmallPtrSet<const MDNode *, 8> ProcessedArgs; 2700 2701 DebugLoc PrevLoc; 2702 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2703 I != E; ++I) 2704 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2705 II != IE; ++II) { 2706 const MachineInstr *MI = II; 2707 DebugLoc DL = MI->getDebugLoc(); 2708 if (MI->isDebugValue()) { 2709 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!"); 2710 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata()); 2711 if (!DV.Verify()) continue; 2712 // If DBG_VALUE is for a local variable then it needs a label. 2713 if (DV.getTag() != dwarf::DW_TAG_arg_variable 2714 && isDbgValueInUndefinedReg(MI) == false) 2715 InsnNeedsLabel.insert(MI); 2716 // DBG_VALUE for inlined functions argument needs a label. 2717 else if (!DISubprogram(getDISubprogram(DV.getContext())). 2718 describes(MF->getFunction())) 2719 InsnNeedsLabel.insert(MI); 2720 // DBG_VALUE indicating argument location change needs a label. 2721 else if (isDbgValueInUndefinedReg(MI) == false && !ProcessedArgs.insert(DV)) 2722 InsnNeedsLabel.insert(MI); 2723 } else { 2724 // If location is unknown then instruction needs a location only if 2725 // UnknownLocations flag is set. 2726 if (DL.isUnknown()) { 2727 if (UnknownLocations && !PrevLoc.isUnknown()) 2728 InsnNeedsLabel.insert(MI); 2729 } else if (DL != PrevLoc) 2730 // Otherwise, instruction needs a location only if it is new location. 2731 InsnNeedsLabel.insert(MI); 2732 } 2733 2734 if (!DL.isUnknown() || UnknownLocations) 2735 PrevLoc = DL; 2736 } 2737 2738 PrevLabel = FunctionBeginSym; 2739} 2740 2741/// endFunction - Gather and emit post-function debug information. 2742/// 2743void DwarfDebug::endFunction(const MachineFunction *MF) { 2744 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return; 2745 2746 if (CurrentFnDbgScope) { 2747 2748 // Define end label for subprogram. 2749 FunctionEndSym = Asm->GetTempSymbol("func_end", 2750 Asm->getFunctionNumber()); 2751 // Assumes in correct section after the entry point. 2752 Asm->OutStreamer.EmitLabel(FunctionEndSym); 2753 2754 SmallPtrSet<const MDNode *, 16> ProcessedVars; 2755 collectVariableInfo(MF, ProcessedVars); 2756 2757 // Get function line info. 2758 if (!Lines.empty()) { 2759 // Get section line info. 2760 unsigned ID = SectionMap.insert(Asm->getCurrentSection()); 2761 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID); 2762 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1]; 2763 // Append the function info to section info. 2764 SectionLineInfos.insert(SectionLineInfos.end(), 2765 Lines.begin(), Lines.end()); 2766 } 2767 2768 // Construct abstract scopes. 2769 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2770 AE = AbstractScopesList.end(); AI != AE; ++AI) { 2771 DISubprogram SP((*AI)->getScopeNode()); 2772 if (SP.Verify()) { 2773 // Collect info for variables that were optimized out. 2774 StringRef FName = SP.getLinkageName(); 2775 if (FName.empty()) 2776 FName = SP.getName(); 2777 const Module *M = MF->getFunction()->getParent(); 2778 if (NamedMDNode *NMD = 2779 M->getNamedMetadata(Twine("llvm.dbg.lv.", 2780 getRealLinkageName(FName)))) { 2781 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2782 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i))); 2783 if (!DV || !ProcessedVars.insert(DV)) 2784 continue; 2785 DbgScope *Scope = AbstractScopes.lookup(DV.getContext()); 2786 if (Scope) 2787 Scope->addVariable(new DbgVariable(DV)); 2788 } 2789 } 2790 } 2791 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0) 2792 constructScopeDIE(*AI); 2793 } 2794 2795 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope); 2796 2797 if (!DisableFramePointerElim(*MF)) 2798 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr, 2799 dwarf::DW_FORM_flag, 1); 2800 2801 2802 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(), 2803 MMI->getFrameMoves())); 2804 } 2805 2806 // Clear debug info 2807 CurrentFnDbgScope = NULL; 2808 InsnNeedsLabel.clear(); 2809 DbgVariableToFrameIndexMap.clear(); 2810 VarToAbstractVarMap.clear(); 2811 DbgVariableToDbgInstMap.clear(); 2812 DbgVariableLabelsMap.clear(); 2813 DeleteContainerSeconds(DbgScopeMap); 2814 InsnsEndScopeSet.clear(); 2815 ConcreteScopes.clear(); 2816 DeleteContainerSeconds(AbstractScopes); 2817 AbstractScopesList.clear(); 2818 AbstractVariables.clear(); 2819 LabelsBeforeInsn.clear(); 2820 LabelsAfterInsn.clear(); 2821 Lines.clear(); 2822 PrevLabel = NULL; 2823} 2824 2825/// recordVariableFrameIndex - Record a variable's index. 2826void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) { 2827 assert (V && "Invalid DbgVariable!"); 2828 DbgVariableToFrameIndexMap[V] = Index; 2829} 2830 2831/// findVariableFrameIndex - Return true if frame index for the variable 2832/// is found. Update FI to hold value of the index. 2833bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) { 2834 assert (V && "Invalid DbgVariable!"); 2835 DenseMap<const DbgVariable *, int>::iterator I = 2836 DbgVariableToFrameIndexMap.find(V); 2837 if (I == DbgVariableToFrameIndexMap.end()) 2838 return false; 2839 *FI = I->second; 2840 return true; 2841} 2842 2843/// findVariableLabel - Find MCSymbol for the variable. 2844const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) { 2845 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I 2846 = DbgVariableLabelsMap.find(V); 2847 if (I == DbgVariableLabelsMap.end()) 2848 return NULL; 2849 else return I->second; 2850} 2851 2852/// findDbgScope - Find DbgScope for the debug loc attached with an 2853/// instruction. 2854DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) { 2855 DbgScope *Scope = NULL; 2856 LLVMContext &Ctx = 2857 MInsn->getParent()->getParent()->getFunction()->getContext(); 2858 DebugLoc DL = MInsn->getDebugLoc(); 2859 2860 if (DL.isUnknown()) 2861 return Scope; 2862 2863 if (const MDNode *IA = DL.getInlinedAt(Ctx)) 2864 Scope = ConcreteScopes.lookup(IA); 2865 if (Scope == 0) 2866 Scope = DbgScopeMap.lookup(DL.getScope(Ctx)); 2867 2868 return Scope; 2869} 2870 2871 2872/// recordSourceLine - Register a source line with debug info. Returns the 2873/// unique label that was emitted and which provides correspondence to 2874/// the source line list. 2875MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, 2876 const MDNode *S) { 2877 StringRef Dir; 2878 StringRef Fn; 2879 2880 unsigned Src = 1; 2881 if (S) { 2882 DIDescriptor Scope(S); 2883 2884 if (Scope.isCompileUnit()) { 2885 DICompileUnit CU(S); 2886 Dir = CU.getDirectory(); 2887 Fn = CU.getFilename(); 2888 } else if (Scope.isSubprogram()) { 2889 DISubprogram SP(S); 2890 Dir = SP.getDirectory(); 2891 Fn = SP.getFilename(); 2892 } else if (Scope.isLexicalBlock()) { 2893 DILexicalBlock DB(S); 2894 Dir = DB.getDirectory(); 2895 Fn = DB.getFilename(); 2896 } else 2897 assert(0 && "Unexpected scope info"); 2898 2899 Src = GetOrCreateSourceID(Dir, Fn); 2900 } 2901 2902#if 0 2903 if (!Lines.empty()) { 2904 SrcLineInfo lastSrcLineInfo = Lines.back(); 2905 // Emitting sequential line records with the same line number (but 2906 // different addresses) seems to confuse GDB. Avoid this. 2907 if (lastSrcLineInfo.getLine() == Line) 2908 return NULL; 2909 } 2910#endif 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