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