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