DwarfDebug.cpp revision 218893
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 SmallVector <DIE *, 8> Children; 1804 // Collect lexical scope childrens first. 1805 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables(); 1806 for (unsigned i = 0, N = Variables.size(); i < N; ++i) 1807 if (DIE *Variable = constructVariableDIE(Variables[i], Scope)) 1808 Children.push_back(Variable); 1809 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes(); 1810 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) 1811 if (DIE *Nested = constructScopeDIE(Scopes[j])) 1812 Children.push_back(Nested); 1813 DIScope DS(Scope->getScopeNode()); 1814 DIE *ScopeDIE = NULL; 1815 if (Scope->getInlinedAt()) 1816 ScopeDIE = constructInlinedScopeDIE(Scope); 1817 else if (DS.isSubprogram()) { 1818 ProcessedSPNodes.insert(DS); 1819 if (Scope->isAbstractScope()) { 1820 ScopeDIE = getCompileUnit(DS)->getDIE(DS); 1821 // Note down abstract DIE. 1822 if (ScopeDIE) 1823 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE)); 1824 } 1825 else 1826 ScopeDIE = updateSubprogramScopeDIE(DS); 1827 } 1828 else { 1829 // There is no need to emit empty lexical block DIE. 1830 if (Children.empty()) 1831 return NULL; 1832 ScopeDIE = constructLexicalScopeDIE(Scope); 1833 } 1834 1835 if (!ScopeDIE) return NULL; 1836 1837 // Add children 1838 for (SmallVector<DIE *, 8>::iterator I = Children.begin(), 1839 E = Children.end(); I != E; ++I) 1840 ScopeDIE->addChild(*I); 1841 1842 if (DS.isSubprogram()) 1843 addPubTypes(DISubprogram(DS)); 1844 1845 return ScopeDIE; 1846} 1847 1848/// GetOrCreateSourceID - Look up the source id with the given directory and 1849/// source file names. If none currently exists, create a new id and insert it 1850/// in the SourceIds map. This can update DirectoryNames and SourceFileNames 1851/// maps as well. 1852 1853unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName){ 1854 // If FE did not provide a file name, then assume stdin. 1855 if (FileName.empty()) 1856 return GetOrCreateSourceID("<stdin>"); 1857 1858 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName); 1859 if (Entry.getValue()) 1860 return Entry.getValue(); 1861 1862 unsigned SrcId = SourceIdMap.size(); 1863 Entry.setValue(SrcId); 1864 1865 // Print out a .file directive to specify files for .loc directives. 1866 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, FileName); 1867 1868 return SrcId; 1869} 1870 1871/// getOrCreateNameSpace - Create a DIE for DINameSpace. 1872DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) { 1873 CompileUnit *TheCU = getCompileUnit(NS); 1874 DIE *NDie = TheCU->getDIE(NS); 1875 if (NDie) 1876 return NDie; 1877 NDie = new DIE(dwarf::DW_TAG_namespace); 1878 TheCU->insertDIE(NS, NDie); 1879 if (!NS.getName().empty()) 1880 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName()); 1881 addSourceLine(NDie, NS); 1882 addToContextOwner(NDie, NS.getContext()); 1883 return NDie; 1884} 1885 1886/// constructCompileUnit - Create new CompileUnit for the given 1887/// metadata node with tag DW_TAG_compile_unit. 1888void DwarfDebug::constructCompileUnit(const MDNode *N) { 1889 DICompileUnit DIUnit(N); 1890 StringRef FN = DIUnit.getFilename(); 1891 StringRef Dir = DIUnit.getDirectory(); 1892 unsigned ID = GetOrCreateSourceID(FN); 1893 1894 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 1895 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string, 1896 DIUnit.getProducer()); 1897 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1, 1898 DIUnit.getLanguage()); 1899 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN); 1900 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This 1901 // simplifies debug range entries. 1902 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0); 1903 // DW_AT_stmt_list is a offset of line number information for this 1904 // compile unit in debug_line section. 1905 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList()) 1906 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr, 1907 Asm->GetTempSymbol("section_line")); 1908 else 1909 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0); 1910 1911 if (!Dir.empty()) 1912 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir); 1913 if (DIUnit.isOptimized()) 1914 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 1915 1916 StringRef Flags = DIUnit.getFlags(); 1917 if (!Flags.empty()) 1918 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags); 1919 1920 unsigned RVer = DIUnit.getRunTimeVersion(); 1921 if (RVer) 1922 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers, 1923 dwarf::DW_FORM_data1, RVer); 1924 1925 CompileUnit *NewCU = new CompileUnit(ID, Die); 1926 if (!FirstCU) 1927 FirstCU = NewCU; 1928 CUMap.insert(std::make_pair(N, NewCU)); 1929} 1930 1931/// getCompielUnit - Get CompileUnit DIE. 1932CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const { 1933 assert (N && "Invalid DwarfDebug::getCompileUnit argument!"); 1934 DIDescriptor D(N); 1935 const MDNode *CUNode = NULL; 1936 if (D.isCompileUnit()) 1937 CUNode = N; 1938 else if (D.isSubprogram()) 1939 CUNode = DISubprogram(N).getCompileUnit(); 1940 else if (D.isType()) 1941 CUNode = DIType(N).getCompileUnit(); 1942 else if (D.isGlobalVariable()) 1943 CUNode = DIGlobalVariable(N).getCompileUnit(); 1944 else if (D.isVariable()) 1945 CUNode = DIVariable(N).getCompileUnit(); 1946 else if (D.isNameSpace()) 1947 CUNode = DINameSpace(N).getCompileUnit(); 1948 else if (D.isFile()) 1949 CUNode = DIFile(N).getCompileUnit(); 1950 else 1951 return FirstCU; 1952 1953 DenseMap<const MDNode *, CompileUnit *>::const_iterator I 1954 = CUMap.find(CUNode); 1955 if (I == CUMap.end()) 1956 return FirstCU; 1957 return I->second; 1958} 1959 1960/// isUnsignedDIType - Return true if type encoding is unsigned. 1961static bool isUnsignedDIType(DIType Ty) { 1962 DIDerivedType DTy(Ty); 1963 if (DTy.Verify()) 1964 return isUnsignedDIType(DTy.getTypeDerivedFrom()); 1965 1966 DIBasicType BTy(Ty); 1967 if (BTy.Verify()) { 1968 unsigned Encoding = BTy.getEncoding(); 1969 if (Encoding == dwarf::DW_ATE_unsigned || 1970 Encoding == dwarf::DW_ATE_unsigned_char) 1971 return true; 1972 } 1973 return false; 1974} 1975 1976// Return const exprssion if value is a GEP to access merged global 1977// constant. e.g. 1978// i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0) 1979static const ConstantExpr *getMergedGlobalExpr(const Value *V) { 1980 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V); 1981 if (!CE || CE->getNumOperands() != 3 || 1982 CE->getOpcode() != Instruction::GetElementPtr) 1983 return NULL; 1984 1985 // First operand points to a global value. 1986 if (!isa<GlobalValue>(CE->getOperand(0))) 1987 return NULL; 1988 1989 // Second operand is zero. 1990 const ConstantInt *CI = 1991 dyn_cast_or_null<ConstantInt>(CE->getOperand(1)); 1992 if (!CI || !CI->isZero()) 1993 return NULL; 1994 1995 // Third operand is offset. 1996 if (!isa<ConstantInt>(CE->getOperand(2))) 1997 return NULL; 1998 1999 return CE; 2000} 2001 2002/// constructGlobalVariableDIE - Construct global variable DIE. 2003void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) { 2004 DIGlobalVariable GV(N); 2005 2006 // If debug information is malformed then ignore it. 2007 if (GV.Verify() == false) 2008 return; 2009 2010 // Check for pre-existence. 2011 CompileUnit *TheCU = getCompileUnit(N); 2012 if (TheCU->getDIE(GV)) 2013 return; 2014 2015 DIType GTy = GV.getType(); 2016 DIE *VariableDIE = new DIE(GV.getTag()); 2017 2018 bool isGlobalVariable = GV.getGlobal() != NULL; 2019 2020 // Add name. 2021 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, 2022 GV.getDisplayName()); 2023 StringRef LinkageName = GV.getLinkageName(); 2024 if (!LinkageName.empty() && isGlobalVariable) 2025 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string, 2026 getRealLinkageName(LinkageName)); 2027 // Add type. 2028 addType(VariableDIE, GTy); 2029 if (GTy.isCompositeType() && !GTy.getName().empty() 2030 && !GTy.isForwardDecl()) { 2031 DIEEntry *Entry = TheCU->getDIEEntry(GTy); 2032 assert(Entry && "Missing global type!"); 2033 TheCU->addGlobalType(GTy.getName(), Entry->getEntry()); 2034 } 2035 // Add scoping info. 2036 if (!GV.isLocalToUnit()) { 2037 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 2038 // Expose as global. 2039 TheCU->addGlobal(GV.getName(), VariableDIE); 2040 } 2041 // Add line number info. 2042 addSourceLine(VariableDIE, GV); 2043 // Add to map. 2044 TheCU->insertDIE(N, VariableDIE); 2045 // Add to context owner. 2046 DIDescriptor GVContext = GV.getContext(); 2047 addToContextOwner(VariableDIE, GVContext); 2048 // Add location. 2049 if (isGlobalVariable) { 2050 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 2051 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 2052 addLabel(Block, 0, dwarf::DW_FORM_udata, 2053 Asm->Mang->getSymbol(GV.getGlobal())); 2054 // Do not create specification DIE if context is either compile unit 2055 // or a subprogram. 2056 if (GV.isDefinition() && !GVContext.isCompileUnit() && 2057 !GVContext.isFile() && !isSubprogramContext(GVContext)) { 2058 // Create specification DIE. 2059 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable); 2060 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, 2061 dwarf::DW_FORM_ref4, VariableDIE); 2062 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block); 2063 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 2064 TheCU->addDie(VariableSpecDIE); 2065 } else { 2066 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block); 2067 } 2068 } else if (ConstantInt *CI = 2069 dyn_cast_or_null<ConstantInt>(GV.getConstant())) 2070 addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy)); 2071 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) { 2072 // GV is a merged global. 2073 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 2074 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 2075 addLabel(Block, 0, dwarf::DW_FORM_udata, 2076 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0)))); 2077 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2)); 2078 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 2079 addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue()); 2080 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 2081 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block); 2082 } 2083 2084 return; 2085} 2086 2087/// construct SubprogramDIE - Construct subprogram DIE. 2088void DwarfDebug::constructSubprogramDIE(const MDNode *N) { 2089 DISubprogram SP(N); 2090 2091 // Check for pre-existence. 2092 CompileUnit *TheCU = getCompileUnit(N); 2093 if (TheCU->getDIE(N)) 2094 return; 2095 2096 if (!SP.isDefinition()) 2097 // This is a method declaration which will be handled while constructing 2098 // class type. 2099 return; 2100 2101 DIE *SubprogramDie = createSubprogramDIE(SP); 2102 2103 // Add to map. 2104 TheCU->insertDIE(N, SubprogramDie); 2105 2106 // Add to context owner. 2107 addToContextOwner(SubprogramDie, SP.getContext()); 2108 2109 // Expose as global. 2110 TheCU->addGlobal(SP.getName(), SubprogramDie); 2111 2112 return; 2113} 2114 2115/// beginModule - Emit all Dwarf sections that should come prior to the 2116/// content. Create global DIEs and emit initial debug info sections. 2117/// This is inovked by the target AsmPrinter. 2118void DwarfDebug::beginModule(Module *M) { 2119 if (DisableDebugInfoPrinting) 2120 return; 2121 2122 DebugInfoFinder DbgFinder; 2123 DbgFinder.processModule(*M); 2124 2125 bool HasDebugInfo = false; 2126 2127 // Scan all the compile-units to see if there are any marked as the main unit. 2128 // if not, we do not generate debug info. 2129 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 2130 E = DbgFinder.compile_unit_end(); I != E; ++I) { 2131 if (DICompileUnit(*I).isMain()) { 2132 HasDebugInfo = true; 2133 break; 2134 } 2135 } 2136 2137 if (!HasDebugInfo) return; 2138 2139 // Tell MMI that we have debug info. 2140 MMI->setDebugInfoAvailability(true); 2141 2142 // Emit initial sections. 2143 EmitSectionLabels(); 2144 2145 // Create all the compile unit DIEs. 2146 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 2147 E = DbgFinder.compile_unit_end(); I != E; ++I) 2148 constructCompileUnit(*I); 2149 2150 // Create DIEs for each subprogram. 2151 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(), 2152 E = DbgFinder.subprogram_end(); I != E; ++I) 2153 constructSubprogramDIE(*I); 2154 2155 // Create DIEs for each global variable. 2156 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(), 2157 E = DbgFinder.global_variable_end(); I != E; ++I) 2158 constructGlobalVariableDIE(*I); 2159 2160 //getOrCreateTypeDIE 2161 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum")) 2162 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) 2163 getOrCreateTypeDIE(DIType(NMD->getOperand(i))); 2164 2165 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty")) 2166 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) 2167 getOrCreateTypeDIE(DIType(NMD->getOperand(i))); 2168 2169 // Prime section data. 2170 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 2171} 2172 2173/// endModule - Emit all Dwarf sections that should come after the content. 2174/// 2175void DwarfDebug::endModule() { 2176 if (!FirstCU) return; 2177 const Module *M = MMI->getModule(); 2178 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap; 2179 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) { 2180 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) { 2181 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue; 2182 DISubprogram SP(AllSPs->getOperand(SI)); 2183 if (!SP.Verify()) continue; 2184 2185 // Collect info for variables that were optimized out. 2186 if (!SP.isDefinition()) continue; 2187 StringRef FName = SP.getLinkageName(); 2188 if (FName.empty()) 2189 FName = SP.getName(); 2190 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName); 2191 if (!NMD) continue; 2192 unsigned E = NMD->getNumOperands(); 2193 if (!E) continue; 2194 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL); 2195 DeadFnScopeMap[SP] = Scope; 2196 for (unsigned I = 0; I != E; ++I) { 2197 DIVariable DV(NMD->getOperand(I)); 2198 if (!DV.Verify()) continue; 2199 Scope->addVariable(new DbgVariable(DV)); 2200 } 2201 2202 // Construct subprogram DIE and add variables DIEs. 2203 constructSubprogramDIE(SP); 2204 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP); 2205 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables(); 2206 for (unsigned i = 0, N = Variables.size(); i < N; ++i) { 2207 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope); 2208 if (VariableDIE) 2209 ScopeDIE->addChild(VariableDIE); 2210 } 2211 } 2212 } 2213 2214 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 2215 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 2216 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 2217 DIE *ISP = *AI; 2218 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 2219 } 2220 2221 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(), 2222 CE = ContainingTypeMap.end(); CI != CE; ++CI) { 2223 DIE *SPDie = CI->first; 2224 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second); 2225 if (!N) continue; 2226 DIE *NDie = getCompileUnit(N)->getDIE(N); 2227 if (!NDie) continue; 2228 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie); 2229 } 2230 2231 // Standard sections final addresses. 2232 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 2233 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end")); 2234 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 2235 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end")); 2236 2237 // End text sections. 2238 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) { 2239 Asm->OutStreamer.SwitchSection(SectionMap[i]); 2240 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i)); 2241 } 2242 2243 // Emit common frame information. 2244 emitCommonDebugFrame(); 2245 2246 // Emit function debug frame information 2247 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(), 2248 E = DebugFrames.end(); I != E; ++I) 2249 emitFunctionDebugFrame(*I); 2250 2251 // Compute DIE offsets and sizes. 2252 computeSizeAndOffsets(); 2253 2254 // Emit all the DIEs into a debug info section 2255 emitDebugInfo(); 2256 2257 // Corresponding abbreviations into a abbrev section. 2258 emitAbbreviations(); 2259 2260 // Emit info into a debug pubnames section. 2261 emitDebugPubNames(); 2262 2263 // Emit info into a debug pubtypes section. 2264 emitDebugPubTypes(); 2265 2266 // Emit info into a debug loc section. 2267 emitDebugLoc(); 2268 2269 // Emit info into a debug aranges section. 2270 EmitDebugARanges(); 2271 2272 // Emit info into a debug ranges section. 2273 emitDebugRanges(); 2274 2275 // Emit info into a debug macinfo section. 2276 emitDebugMacInfo(); 2277 2278 // Emit inline info. 2279 emitDebugInlineInfo(); 2280 2281 // Emit info into a debug str section. 2282 emitDebugStr(); 2283 2284 // clean up. 2285 DeleteContainerSeconds(DeadFnScopeMap); 2286 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2287 E = CUMap.end(); I != E; ++I) 2288 delete I->second; 2289 FirstCU = NULL; // Reset for the next Module, if any. 2290} 2291 2292/// findAbstractVariable - Find abstract variable, if any, associated with Var. 2293DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var, 2294 DebugLoc ScopeLoc) { 2295 2296 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var); 2297 if (AbsDbgVariable) 2298 return AbsDbgVariable; 2299 2300 LLVMContext &Ctx = Var->getContext(); 2301 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx)); 2302 if (!Scope) 2303 return NULL; 2304 2305 AbsDbgVariable = new DbgVariable(Var); 2306 Scope->addVariable(AbsDbgVariable); 2307 AbstractVariables[Var] = AbsDbgVariable; 2308 return AbsDbgVariable; 2309} 2310 2311/// collectVariableInfoFromMMITable - Collect variable information from 2312/// side table maintained by MMI. 2313void 2314DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF, 2315 SmallPtrSet<const MDNode *, 16> &Processed) { 2316 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2317 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 2318 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 2319 VE = VMap.end(); VI != VE; ++VI) { 2320 const MDNode *Var = VI->first; 2321 if (!Var) continue; 2322 Processed.insert(Var); 2323 DIVariable DV(Var); 2324 const std::pair<unsigned, DebugLoc> &VP = VI->second; 2325 2326 DbgScope *Scope = 0; 2327 if (const MDNode *IA = VP.second.getInlinedAt(Ctx)) 2328 Scope = ConcreteScopes.lookup(IA); 2329 if (Scope == 0) 2330 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx)); 2331 2332 // If variable scope is not found then skip this variable. 2333 if (Scope == 0) 2334 continue; 2335 2336 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second); 2337 DbgVariable *RegVar = new DbgVariable(DV); 2338 recordVariableFrameIndex(RegVar, VP.first); 2339 Scope->addVariable(RegVar); 2340 if (AbsDbgVariable) { 2341 recordVariableFrameIndex(AbsDbgVariable, VP.first); 2342 VarToAbstractVarMap[RegVar] = AbsDbgVariable; 2343 } 2344 } 2345} 2346 2347/// isDbgValueInDefinedReg - Return true if debug value, encoded by 2348/// DBG_VALUE instruction, is in a defined reg. 2349static bool isDbgValueInDefinedReg(const MachineInstr *MI) { 2350 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 2351 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg()) 2352 return true; 2353 return false; 2354} 2355 2356/// collectVariableInfo - Populate DbgScope entries with variables' info. 2357void 2358DwarfDebug::collectVariableInfo(const MachineFunction *MF, 2359 SmallPtrSet<const MDNode *, 16> &Processed) { 2360 2361 /// collection info from MMI table. 2362 collectVariableInfoFromMMITable(MF, Processed); 2363 2364 SmallVector<const MachineInstr *, 8> DbgValues; 2365 // Collect variable information from DBG_VALUE machine instructions; 2366 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 2367 I != E; ++I) 2368 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2369 II != IE; ++II) { 2370 const MachineInstr *MInsn = II; 2371 if (!MInsn->isDebugValue()) 2372 continue; 2373 DbgValues.push_back(MInsn); 2374 } 2375 2376 // This is a collection of DBV_VALUE instructions describing same variable. 2377 SmallVector<const MachineInstr *, 4> MultipleValues; 2378 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(), 2379 E = DbgValues.end(); I != E; ++I) { 2380 const MachineInstr *MInsn = *I; 2381 MultipleValues.clear(); 2382 if (isDbgValueInDefinedReg(MInsn)) 2383 MultipleValues.push_back(MInsn); 2384 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata()); 2385 if (Processed.count(DV) != 0) 2386 continue; 2387 2388 const MachineInstr *PrevMI = MInsn; 2389 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1, 2390 ME = DbgValues.end(); MI != ME; ++MI) { 2391 const MDNode *Var = 2392 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata(); 2393 if (Var == DV && 2394 !PrevMI->isIdenticalTo(*MI)) 2395 MultipleValues.push_back(*MI); 2396 PrevMI = *MI; 2397 } 2398 2399 DbgScope *Scope = NULL; 2400 if (DV.getTag() == dwarf::DW_TAG_arg_variable && 2401 DISubprogram(DV.getContext()).describes(MF->getFunction())) 2402 Scope = CurrentFnDbgScope; 2403 else 2404 Scope = findDbgScope(MInsn); 2405 // If variable scope is not found then skip this variable. 2406 if (!Scope) 2407 continue; 2408 2409 Processed.insert(DV); 2410 DbgVariable *RegVar = new DbgVariable(DV); 2411 Scope->addVariable(RegVar); 2412 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) { 2413 DbgVariableToDbgInstMap[AbsVar] = MInsn; 2414 VarToAbstractVarMap[RegVar] = AbsVar; 2415 } 2416 if (MultipleValues.size() <= 1) { 2417 DbgVariableToDbgInstMap[RegVar] = MInsn; 2418 continue; 2419 } 2420 2421 // handle multiple DBG_VALUE instructions describing one variable. 2422 if (DotDebugLocEntries.empty()) 2423 RegVar->setDotDebugLocOffset(0); 2424 else 2425 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size()); 2426 const MachineInstr *Begin = NULL; 2427 const MachineInstr *End = NULL; 2428 for (SmallVector<const MachineInstr *, 4>::iterator 2429 MVI = MultipleValues.begin(), MVE = MultipleValues.end(); 2430 MVI != MVE; ++MVI) { 2431 if (!Begin) { 2432 Begin = *MVI; 2433 continue; 2434 } 2435 End = *MVI; 2436 MachineLocation MLoc; 2437 if (Begin->getNumOperands() == 3) { 2438 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm()) 2439 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm()); 2440 } else 2441 MLoc = Asm->getDebugValueLocation(Begin); 2442 2443 const MCSymbol *FLabel = getLabelBeforeInsn(Begin); 2444 const MCSymbol *SLabel = getLabelBeforeInsn(End); 2445 if (MLoc.getReg()) 2446 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc)); 2447 2448 Begin = End; 2449 if (MVI + 1 == MVE) { 2450 // If End is the last instruction then its value is valid 2451 // until the end of the funtion. 2452 MachineLocation EMLoc; 2453 if (End->getNumOperands() == 3) { 2454 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm()) 2455 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm()); 2456 } else 2457 EMLoc = Asm->getDebugValueLocation(End); 2458 if (EMLoc.getReg()) 2459 DotDebugLocEntries. 2460 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc)); 2461 } 2462 } 2463 DotDebugLocEntries.push_back(DotDebugLocEntry()); 2464 } 2465 2466 // Collect info for variables that were optimized out. 2467 const Function *F = MF->getFunction(); 2468 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) { 2469 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2470 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 2471 if (!DV || !Processed.insert(DV)) 2472 continue; 2473 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext()); 2474 if (Scope) 2475 Scope->addVariable(new DbgVariable(DV)); 2476 } 2477 } 2478} 2479 2480/// getLabelBeforeInsn - Return Label preceding the instruction. 2481const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { 2482 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 2483 LabelsBeforeInsn.find(MI); 2484 if (I == LabelsBeforeInsn.end()) 2485 // FunctionBeginSym always preceeds all the instruction in current function. 2486 return FunctionBeginSym; 2487 return I->second; 2488} 2489 2490/// getLabelAfterInsn - Return Label immediately following the instruction. 2491const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { 2492 DenseMap<const MachineInstr *, MCSymbol *>::iterator I = 2493 LabelsAfterInsn.find(MI); 2494 if (I == LabelsAfterInsn.end()) 2495 return NULL; 2496 return I->second; 2497} 2498 2499/// beginInstruction - Process beginning of an instruction. 2500void DwarfDebug::beginInstruction(const MachineInstr *MI) { 2501 if (InsnNeedsLabel.count(MI) == 0) { 2502 LabelsBeforeInsn[MI] = PrevLabel; 2503 return; 2504 } 2505 2506 // Check location. 2507 DebugLoc DL = MI->getDebugLoc(); 2508 if (!DL.isUnknown()) { 2509 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 2510 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope); 2511 PrevInstLoc = DL; 2512 LabelsBeforeInsn[MI] = PrevLabel; 2513 return; 2514 } 2515 2516 // If location is unknown then use temp label for this DBG_VALUE 2517 // instruction. 2518 if (MI->isDebugValue()) { 2519 PrevLabel = MMI->getContext().CreateTempSymbol(); 2520 Asm->OutStreamer.EmitLabel(PrevLabel); 2521 LabelsBeforeInsn[MI] = PrevLabel; 2522 return; 2523 } 2524 2525 if (UnknownLocations) { 2526 PrevLabel = recordSourceLine(0, 0, 0); 2527 LabelsBeforeInsn[MI] = PrevLabel; 2528 return; 2529 } 2530 2531 assert (0 && "Instruction is not processed!"); 2532} 2533 2534/// endInstruction - Process end of an instruction. 2535void DwarfDebug::endInstruction(const MachineInstr *MI) { 2536 if (InsnsEndScopeSet.count(MI) != 0) { 2537 // Emit a label if this instruction ends a scope. 2538 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2539 Asm->OutStreamer.EmitLabel(Label); 2540 LabelsAfterInsn[MI] = Label; 2541 } 2542} 2543 2544/// getOrCreateDbgScope - Create DbgScope for the scope. 2545DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, 2546 const MDNode *InlinedAt) { 2547 if (!InlinedAt) { 2548 DbgScope *WScope = DbgScopeMap.lookup(Scope); 2549 if (WScope) 2550 return WScope; 2551 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL); 2552 DbgScopeMap.insert(std::make_pair(Scope, WScope)); 2553 if (DIDescriptor(Scope).isLexicalBlock()) { 2554 DbgScope *Parent = 2555 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL); 2556 WScope->setParent(Parent); 2557 Parent->addScope(WScope); 2558 } 2559 2560 if (!WScope->getParent()) { 2561 StringRef SPName = DISubprogram(Scope).getLinkageName(); 2562 // We used to check only for a linkage name, but that fails 2563 // since we began omitting the linkage name for private 2564 // functions. The new way is to check for the name in metadata, 2565 // but that's not supported in old .ll test cases. Ergo, we 2566 // check both. 2567 if (SPName == Asm->MF->getFunction()->getName() || 2568 DISubprogram(Scope).getFunction() == Asm->MF->getFunction()) 2569 CurrentFnDbgScope = WScope; 2570 } 2571 2572 return WScope; 2573 } 2574 2575 getOrCreateAbstractScope(Scope); 2576 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt); 2577 if (WScope) 2578 return WScope; 2579 2580 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt); 2581 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope)); 2582 DILocation DL(InlinedAt); 2583 DbgScope *Parent = 2584 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation()); 2585 WScope->setParent(Parent); 2586 Parent->addScope(WScope); 2587 2588 ConcreteScopes[InlinedAt] = WScope; 2589 2590 return WScope; 2591} 2592 2593/// hasValidLocation - Return true if debug location entry attached with 2594/// machine instruction encodes valid location info. 2595static bool hasValidLocation(LLVMContext &Ctx, 2596 const MachineInstr *MInsn, 2597 const MDNode *&Scope, const MDNode *&InlinedAt) { 2598 DebugLoc DL = MInsn->getDebugLoc(); 2599 if (DL.isUnknown()) return false; 2600 2601 const MDNode *S = DL.getScope(Ctx); 2602 2603 // There is no need to create another DIE for compile unit. For all 2604 // other scopes, create one DbgScope now. This will be translated 2605 // into a scope DIE at the end. 2606 if (DIScope(S).isCompileUnit()) return false; 2607 2608 Scope = S; 2609 InlinedAt = DL.getInlinedAt(Ctx); 2610 return true; 2611} 2612 2613/// calculateDominanceGraph - Calculate dominance graph for DbgScope 2614/// hierarchy. 2615static void calculateDominanceGraph(DbgScope *Scope) { 2616 assert (Scope && "Unable to calculate scop edominance graph!"); 2617 SmallVector<DbgScope *, 4> WorkStack; 2618 WorkStack.push_back(Scope); 2619 unsigned Counter = 0; 2620 while (!WorkStack.empty()) { 2621 DbgScope *WS = WorkStack.back(); 2622 const SmallVector<DbgScope *, 4> &Children = WS->getScopes(); 2623 bool visitedChildren = false; 2624 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2625 SE = Children.end(); SI != SE; ++SI) { 2626 DbgScope *ChildScope = *SI; 2627 if (!ChildScope->getDFSOut()) { 2628 WorkStack.push_back(ChildScope); 2629 visitedChildren = true; 2630 ChildScope->setDFSIn(++Counter); 2631 break; 2632 } 2633 } 2634 if (!visitedChildren) { 2635 WorkStack.pop_back(); 2636 WS->setDFSOut(++Counter); 2637 } 2638 } 2639} 2640 2641/// printDbgScopeInfo - Print DbgScope info for each machine instruction. 2642static 2643void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF, 2644 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap) 2645{ 2646#ifndef NDEBUG 2647 unsigned PrevDFSIn = 0; 2648 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2649 I != E; ++I) { 2650 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2651 II != IE; ++II) { 2652 const MachineInstr *MInsn = II; 2653 const MDNode *Scope = NULL; 2654 const MDNode *InlinedAt = NULL; 2655 2656 // Check if instruction has valid location information. 2657 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2658 dbgs() << " [ "; 2659 if (InlinedAt) 2660 dbgs() << "*"; 2661 DenseMap<const MachineInstr *, DbgScope *>::iterator DI = 2662 MI2ScopeMap.find(MInsn); 2663 if (DI != MI2ScopeMap.end()) { 2664 DbgScope *S = DI->second; 2665 dbgs() << S->getDFSIn(); 2666 PrevDFSIn = S->getDFSIn(); 2667 } else 2668 dbgs() << PrevDFSIn; 2669 } else 2670 dbgs() << " [ x" << PrevDFSIn; 2671 dbgs() << " ]"; 2672 MInsn->dump(); 2673 } 2674 dbgs() << "\n"; 2675 } 2676#endif 2677} 2678/// extractScopeInformation - Scan machine instructions in this function 2679/// and collect DbgScopes. Return true, if at least one scope was found. 2680bool DwarfDebug::extractScopeInformation() { 2681 // If scope information was extracted using .dbg intrinsics then there is not 2682 // any need to extract these information by scanning each instruction. 2683 if (!DbgScopeMap.empty()) 2684 return false; 2685 2686 // Scan each instruction and create scopes. First build working set of scopes. 2687 LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2688 SmallVector<DbgRange, 4> MIRanges; 2689 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap; 2690 const MDNode *PrevScope = NULL; 2691 const MDNode *PrevInlinedAt = NULL; 2692 const MachineInstr *RangeBeginMI = NULL; 2693 const MachineInstr *PrevMI = NULL; 2694 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 2695 I != E; ++I) { 2696 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2697 II != IE; ++II) { 2698 const MachineInstr *MInsn = II; 2699 const MDNode *Scope = NULL; 2700 const MDNode *InlinedAt = NULL; 2701 2702 // Check if instruction has valid location information. 2703 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2704 PrevMI = MInsn; 2705 continue; 2706 } 2707 2708 // If scope has not changed then skip this instruction. 2709 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) { 2710 PrevMI = MInsn; 2711 continue; 2712 } 2713 2714 // Ignore DBG_VALUE. It does not contribute any instruction in output. 2715 if (MInsn->isDebugValue()) 2716 continue; 2717 2718 if (RangeBeginMI) { 2719 // If we have alread seen a beginning of a instruction range and 2720 // current instruction scope does not match scope of first instruction 2721 // in this range then create a new instruction range. 2722 DbgRange R(RangeBeginMI, PrevMI); 2723 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, 2724 PrevInlinedAt); 2725 MIRanges.push_back(R); 2726 } 2727 2728 // This is a beginning of a new instruction range. 2729 RangeBeginMI = MInsn; 2730 2731 // Reset previous markers. 2732 PrevMI = MInsn; 2733 PrevScope = Scope; 2734 PrevInlinedAt = InlinedAt; 2735 } 2736 } 2737 2738 // Create last instruction range. 2739 if (RangeBeginMI && PrevMI && PrevScope) { 2740 DbgRange R(RangeBeginMI, PrevMI); 2741 MIRanges.push_back(R); 2742 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt); 2743 } 2744 2745 if (!CurrentFnDbgScope) 2746 return false; 2747 2748 calculateDominanceGraph(CurrentFnDbgScope); 2749 if (PrintDbgScope) 2750 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap); 2751 2752 // Find ranges of instructions covered by each DbgScope; 2753 DbgScope *PrevDbgScope = NULL; 2754 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(), 2755 RE = MIRanges.end(); RI != RE; ++RI) { 2756 const DbgRange &R = *RI; 2757 DbgScope *S = MI2ScopeMap.lookup(R.first); 2758 assert (S && "Lost DbgScope for a machine instruction!"); 2759 if (PrevDbgScope && !PrevDbgScope->dominates(S)) 2760 PrevDbgScope->closeInsnRange(S); 2761 S->openInsnRange(R.first); 2762 S->extendInsnRange(R.second); 2763 PrevDbgScope = S; 2764 } 2765 2766 if (PrevDbgScope) 2767 PrevDbgScope->closeInsnRange(); 2768 2769 identifyScopeMarkers(); 2770 2771 return !DbgScopeMap.empty(); 2772} 2773 2774/// identifyScopeMarkers() - 2775/// Each DbgScope has first instruction and last instruction to mark beginning 2776/// and end of a scope respectively. Create an inverse map that list scopes 2777/// starts (and ends) with an instruction. One instruction may start (or end) 2778/// multiple scopes. Ignore scopes that are not reachable. 2779void DwarfDebug::identifyScopeMarkers() { 2780 SmallVector<DbgScope *, 4> WorkList; 2781 WorkList.push_back(CurrentFnDbgScope); 2782 while (!WorkList.empty()) { 2783 DbgScope *S = WorkList.pop_back_val(); 2784 2785 const SmallVector<DbgScope *, 4> &Children = S->getScopes(); 2786 if (!Children.empty()) 2787 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2788 SE = Children.end(); SI != SE; ++SI) 2789 WorkList.push_back(*SI); 2790 2791 if (S->isAbstractScope()) 2792 continue; 2793 2794 const SmallVector<DbgRange, 4> &Ranges = S->getRanges(); 2795 if (Ranges.empty()) 2796 continue; 2797 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 2798 RE = Ranges.end(); RI != RE; ++RI) { 2799 assert(RI->first && "DbgRange does not have first instruction!"); 2800 assert(RI->second && "DbgRange does not have second instruction!"); 2801 InsnsEndScopeSet.insert(RI->second); 2802 } 2803 } 2804} 2805 2806/// FindFirstDebugLoc - Find the first debug location in the function. This 2807/// is intended to be an approximation for the source position of the 2808/// beginning of the function. 2809static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) { 2810 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2811 I != E; ++I) 2812 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end(); 2813 MBBI != MBBE; ++MBBI) { 2814 DebugLoc DL = MBBI->getDebugLoc(); 2815 if (!DL.isUnknown()) 2816 return DL; 2817 } 2818 return DebugLoc(); 2819} 2820 2821#ifndef NDEBUG 2822/// CheckLineNumbers - Count basicblocks whose instructions do not have any 2823/// line number information. 2824static void CheckLineNumbers(const MachineFunction *MF) { 2825 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2826 I != E; ++I) { 2827 bool FoundLineNo = false; 2828 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2829 II != IE; ++II) { 2830 const MachineInstr *MI = II; 2831 if (!MI->getDebugLoc().isUnknown()) { 2832 FoundLineNo = true; 2833 break; 2834 } 2835 } 2836 if (!FoundLineNo && I->size()) 2837 ++BlocksWithoutLineNo; 2838 } 2839} 2840#endif 2841 2842/// beginFunction - Gather pre-function debug information. Assumes being 2843/// emitted immediately after the function entry point. 2844void DwarfDebug::beginFunction(const MachineFunction *MF) { 2845 if (!MMI->hasDebugInfo()) return; 2846 if (!extractScopeInformation()) return; 2847 2848#ifndef NDEBUG 2849 CheckLineNumbers(MF); 2850#endif 2851 2852 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 2853 Asm->getFunctionNumber()); 2854 // Assumes in correct section after the entry point. 2855 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 2856 2857 // Emit label for the implicitly defined dbg.stoppoint at the start of the 2858 // function. 2859 DebugLoc FDL = FindFirstDebugLoc(MF); 2860 if (FDL.isUnknown()) return; 2861 2862 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext()); 2863 const MDNode *TheScope = 0; 2864 2865 DISubprogram SP = getDISubprogram(Scope); 2866 unsigned Line, Col; 2867 if (SP.Verify()) { 2868 Line = SP.getLineNumber(); 2869 Col = 0; 2870 TheScope = SP; 2871 } else { 2872 Line = FDL.getLine(); 2873 Col = FDL.getCol(); 2874 TheScope = Scope; 2875 } 2876 2877 recordSourceLine(Line, Col, TheScope); 2878 2879 /// ProcessedArgs - Collection of arguments already processed. 2880 SmallPtrSet<const MDNode *, 8> ProcessedArgs; 2881 2882 DebugLoc PrevLoc; 2883 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2884 I != E; ++I) 2885 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2886 II != IE; ++II) { 2887 const MachineInstr *MI = II; 2888 DebugLoc DL = MI->getDebugLoc(); 2889 if (MI->isDebugValue()) { 2890 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!"); 2891 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata()); 2892 if (!DV.Verify()) continue; 2893 // If DBG_VALUE is for a local variable then it needs a label. 2894 if (DV.getTag() != dwarf::DW_TAG_arg_variable) 2895 InsnNeedsLabel.insert(MI); 2896 // DBG_VALUE for inlined functions argument needs a label. 2897 else if (!DISubprogram(getDISubprogram(DV.getContext())). 2898 describes(MF->getFunction())) 2899 InsnNeedsLabel.insert(MI); 2900 // DBG_VALUE indicating argument location change needs a label. 2901 else if (!ProcessedArgs.insert(DV)) 2902 InsnNeedsLabel.insert(MI); 2903 } else { 2904 // If location is unknown then instruction needs a location only if 2905 // UnknownLocations flag is set. 2906 if (DL.isUnknown()) { 2907 if (UnknownLocations && !PrevLoc.isUnknown()) 2908 InsnNeedsLabel.insert(MI); 2909 } else if (DL != PrevLoc) 2910 // Otherwise, instruction needs a location only if it is new location. 2911 InsnNeedsLabel.insert(MI); 2912 } 2913 2914 if (!DL.isUnknown() || UnknownLocations) 2915 PrevLoc = DL; 2916 } 2917 2918 PrevLabel = FunctionBeginSym; 2919} 2920 2921/// endFunction - Gather and emit post-function debug information. 2922/// 2923void DwarfDebug::endFunction(const MachineFunction *MF) { 2924 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return; 2925 2926 if (CurrentFnDbgScope) { 2927 2928 // Define end label for subprogram. 2929 FunctionEndSym = Asm->GetTempSymbol("func_end", 2930 Asm->getFunctionNumber()); 2931 // Assumes in correct section after the entry point. 2932 Asm->OutStreamer.EmitLabel(FunctionEndSym); 2933 2934 SmallPtrSet<const MDNode *, 16> ProcessedVars; 2935 collectVariableInfo(MF, ProcessedVars); 2936 2937 // Construct abstract scopes. 2938 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2939 AE = AbstractScopesList.end(); AI != AE; ++AI) { 2940 DISubprogram SP((*AI)->getScopeNode()); 2941 if (SP.Verify()) { 2942 // Collect info for variables that were optimized out. 2943 StringRef FName = SP.getLinkageName(); 2944 if (FName.empty()) 2945 FName = SP.getName(); 2946 if (NamedMDNode *NMD = 2947 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) { 2948 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2949 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 2950 if (!DV || !ProcessedVars.insert(DV)) 2951 continue; 2952 DbgScope *Scope = AbstractScopes.lookup(DV.getContext()); 2953 if (Scope) 2954 Scope->addVariable(new DbgVariable(DV)); 2955 } 2956 } 2957 } 2958 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0) 2959 constructScopeDIE(*AI); 2960 } 2961 2962 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope); 2963 2964 if (!DisableFramePointerElim(*MF)) 2965 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr, 2966 dwarf::DW_FORM_flag, 1); 2967 2968 2969 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(), 2970 MMI->getFrameMoves())); 2971 } 2972 2973 // Clear debug info 2974 CurrentFnDbgScope = NULL; 2975 InsnNeedsLabel.clear(); 2976 DbgVariableToFrameIndexMap.clear(); 2977 VarToAbstractVarMap.clear(); 2978 DbgVariableToDbgInstMap.clear(); 2979 DeleteContainerSeconds(DbgScopeMap); 2980 InsnsEndScopeSet.clear(); 2981 ConcreteScopes.clear(); 2982 DeleteContainerSeconds(AbstractScopes); 2983 AbstractScopesList.clear(); 2984 AbstractVariables.clear(); 2985 LabelsBeforeInsn.clear(); 2986 LabelsAfterInsn.clear(); 2987 PrevLabel = NULL; 2988} 2989 2990/// recordVariableFrameIndex - Record a variable's index. 2991void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) { 2992 assert (V && "Invalid DbgVariable!"); 2993 DbgVariableToFrameIndexMap[V] = Index; 2994} 2995 2996/// findVariableFrameIndex - Return true if frame index for the variable 2997/// is found. Update FI to hold value of the index. 2998bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) { 2999 assert (V && "Invalid DbgVariable!"); 3000 DenseMap<const DbgVariable *, int>::iterator I = 3001 DbgVariableToFrameIndexMap.find(V); 3002 if (I == DbgVariableToFrameIndexMap.end()) 3003 return false; 3004 *FI = I->second; 3005 return true; 3006} 3007 3008/// findDbgScope - Find DbgScope for the debug loc attached with an 3009/// instruction. 3010DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) { 3011 DbgScope *Scope = NULL; 3012 LLVMContext &Ctx = 3013 MInsn->getParent()->getParent()->getFunction()->getContext(); 3014 DebugLoc DL = MInsn->getDebugLoc(); 3015 3016 if (DL.isUnknown()) 3017 return Scope; 3018 3019 if (const MDNode *IA = DL.getInlinedAt(Ctx)) 3020 Scope = ConcreteScopes.lookup(IA); 3021 if (Scope == 0) 3022 Scope = DbgScopeMap.lookup(DL.getScope(Ctx)); 3023 3024 return Scope; 3025} 3026 3027 3028/// recordSourceLine - Register a source line with debug info. Returns the 3029/// unique label that was emitted and which provides correspondence to 3030/// the source line list. 3031MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, 3032 const MDNode *S) { 3033 StringRef Fn; 3034 3035 unsigned Src = 1; 3036 if (S) { 3037 DIDescriptor Scope(S); 3038 3039 if (Scope.isCompileUnit()) { 3040 DICompileUnit CU(S); 3041 Fn = CU.getFilename(); 3042 } else if (Scope.isFile()) { 3043 DIFile F(S); 3044 Fn = F.getFilename(); 3045 } else if (Scope.isSubprogram()) { 3046 DISubprogram SP(S); 3047 Fn = SP.getFilename(); 3048 } else if (Scope.isLexicalBlock()) { 3049 DILexicalBlock DB(S); 3050 Fn = DB.getFilename(); 3051 } else 3052 assert(0 && "Unexpected scope info"); 3053 3054 Src = GetOrCreateSourceID(Fn); 3055 } 3056 3057 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, DWARF2_FLAG_IS_STMT, 3058 0, 0); 3059 3060 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 3061 Asm->OutStreamer.EmitLabel(Label); 3062 return Label; 3063} 3064 3065//===----------------------------------------------------------------------===// 3066// Emit Methods 3067//===----------------------------------------------------------------------===// 3068 3069/// computeSizeAndOffset - Compute the size and offset of a DIE. 3070/// 3071unsigned 3072DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) { 3073 // Get the children. 3074 const std::vector<DIE *> &Children = Die->getChildren(); 3075 3076 // If not last sibling and has children then add sibling offset attribute. 3077 if (!Last && !Children.empty()) 3078 Die->addSiblingOffset(DIEValueAllocator); 3079 3080 // Record the abbreviation. 3081 assignAbbrevNumber(Die->getAbbrev()); 3082 3083 // Get the abbreviation for this DIE. 3084 unsigned AbbrevNumber = Die->getAbbrevNumber(); 3085 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 3086 3087 // Set DIE offset 3088 Die->setOffset(Offset); 3089 3090 // Start the size with the size of abbreviation code. 3091 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 3092 3093 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 3094 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 3095 3096 // Size the DIE attribute values. 3097 for (unsigned i = 0, N = Values.size(); i < N; ++i) 3098 // Size attribute value. 3099 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm()); 3100 3101 // Size the DIE children if any. 3102 if (!Children.empty()) { 3103 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 3104 "Children flag not set"); 3105 3106 for (unsigned j = 0, M = Children.size(); j < M; ++j) 3107 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M); 3108 3109 // End of children marker. 3110 Offset += sizeof(int8_t); 3111 } 3112 3113 Die->setSize(Offset - Die->getOffset()); 3114 return Offset; 3115} 3116 3117/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 3118/// 3119void DwarfDebug::computeSizeAndOffsets() { 3120 unsigned PrevOffset = 0; 3121 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3122 E = CUMap.end(); I != E; ++I) { 3123 // Compute size of compile unit header. 3124 static unsigned Offset = PrevOffset + 3125 sizeof(int32_t) + // Length of Compilation Unit Info 3126 sizeof(int16_t) + // DWARF version number 3127 sizeof(int32_t) + // Offset Into Abbrev. Section 3128 sizeof(int8_t); // Pointer Size (in bytes) 3129 computeSizeAndOffset(I->second->getCUDie(), Offset, true); 3130 PrevOffset = Offset; 3131 } 3132} 3133 3134/// EmitSectionSym - Switch to the specified MCSection and emit an assembler 3135/// temporary label to it if SymbolStem is specified. 3136static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section, 3137 const char *SymbolStem = 0) { 3138 Asm->OutStreamer.SwitchSection(Section); 3139 if (!SymbolStem) return 0; 3140 3141 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem); 3142 Asm->OutStreamer.EmitLabel(TmpSym); 3143 return TmpSym; 3144} 3145 3146/// EmitSectionLabels - Emit initial Dwarf sections with a label at 3147/// the start of each one. 3148void DwarfDebug::EmitSectionLabels() { 3149 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 3150 3151 // Dwarf sections base addresses. 3152 if (Asm->MAI->doesDwarfRequireFrameSection()) { 3153 DwarfFrameSectionSym = 3154 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame"); 3155 } 3156 3157 DwarfInfoSectionSym = 3158 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 3159 DwarfAbbrevSectionSym = 3160 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 3161 EmitSectionSym(Asm, TLOF.getDwarfARangesSection()); 3162 3163 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 3164 EmitSectionSym(Asm, MacroInfo); 3165 3166 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line"); 3167 EmitSectionSym(Asm, TLOF.getDwarfLocSection()); 3168 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 3169 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 3170 DwarfStrSectionSym = 3171 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str"); 3172 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(), 3173 "debug_range"); 3174 3175 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(), 3176 "section_debug_loc"); 3177 3178 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 3179 EmitSectionSym(Asm, TLOF.getDataSection()); 3180} 3181 3182/// emitDIE - Recusively Emits a debug information entry. 3183/// 3184void DwarfDebug::emitDIE(DIE *Die) { 3185 // Get the abbreviation for this DIE. 3186 unsigned AbbrevNumber = Die->getAbbrevNumber(); 3187 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 3188 3189 // Emit the code (index) for the abbreviation. 3190 if (Asm->isVerbose()) 3191 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 3192 Twine::utohexstr(Die->getOffset()) + ":0x" + 3193 Twine::utohexstr(Die->getSize()) + " " + 3194 dwarf::TagString(Abbrev->getTag())); 3195 Asm->EmitULEB128(AbbrevNumber); 3196 3197 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 3198 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 3199 3200 // Emit the DIE attribute values. 3201 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 3202 unsigned Attr = AbbrevData[i].getAttribute(); 3203 unsigned Form = AbbrevData[i].getForm(); 3204 assert(Form && "Too many attributes for DIE (check abbreviation)"); 3205 3206 if (Asm->isVerbose()) 3207 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 3208 3209 switch (Attr) { 3210 case dwarf::DW_AT_sibling: 3211 Asm->EmitInt32(Die->getSiblingOffset()); 3212 break; 3213 case dwarf::DW_AT_abstract_origin: { 3214 DIEEntry *E = cast<DIEEntry>(Values[i]); 3215 DIE *Origin = E->getEntry(); 3216 unsigned Addr = Origin->getOffset(); 3217 Asm->EmitInt32(Addr); 3218 break; 3219 } 3220 case dwarf::DW_AT_ranges: { 3221 // DW_AT_range Value encodes offset in debug_range section. 3222 DIEInteger *V = cast<DIEInteger>(Values[i]); 3223 3224 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) { 3225 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym, 3226 V->getValue(), 3227 4); 3228 } else { 3229 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym, 3230 V->getValue(), 3231 DwarfDebugRangeSectionSym, 3232 4); 3233 } 3234 break; 3235 } 3236 case dwarf::DW_AT_location: { 3237 if (UseDotDebugLocEntry.count(Die) != 0) { 3238 DIELabel *L = cast<DIELabel>(Values[i]); 3239 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4); 3240 } else 3241 Values[i]->EmitValue(Asm, Form); 3242 break; 3243 } 3244 case dwarf::DW_AT_accessibility: { 3245 if (Asm->isVerbose()) { 3246 DIEInteger *V = cast<DIEInteger>(Values[i]); 3247 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue())); 3248 } 3249 Values[i]->EmitValue(Asm, Form); 3250 break; 3251 } 3252 default: 3253 // Emit an attribute using the defined form. 3254 Values[i]->EmitValue(Asm, Form); 3255 break; 3256 } 3257 } 3258 3259 // Emit the DIE children if any. 3260 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 3261 const std::vector<DIE *> &Children = Die->getChildren(); 3262 3263 for (unsigned j = 0, M = Children.size(); j < M; ++j) 3264 emitDIE(Children[j]); 3265 3266 if (Asm->isVerbose()) 3267 Asm->OutStreamer.AddComment("End Of Children Mark"); 3268 Asm->EmitInt8(0); 3269 } 3270} 3271 3272/// emitDebugInfo - Emit the debug info section. 3273/// 3274void DwarfDebug::emitDebugInfo() { 3275 // Start debug info section. 3276 Asm->OutStreamer.SwitchSection( 3277 Asm->getObjFileLowering().getDwarfInfoSection()); 3278 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3279 E = CUMap.end(); I != E; ++I) { 3280 CompileUnit *TheCU = I->second; 3281 DIE *Die = TheCU->getCUDie(); 3282 3283 // Emit the compile units header. 3284 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin", 3285 TheCU->getID())); 3286 3287 // Emit size of content not including length itself 3288 unsigned ContentSize = Die->getSize() + 3289 sizeof(int16_t) + // DWARF version number 3290 sizeof(int32_t) + // Offset Into Abbrev. Section 3291 sizeof(int8_t) + // Pointer Size (in bytes) 3292 sizeof(int32_t); // FIXME - extra pad for gdb bug. 3293 3294 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 3295 Asm->EmitInt32(ContentSize); 3296 Asm->OutStreamer.AddComment("DWARF version number"); 3297 Asm->EmitInt16(dwarf::DWARF_VERSION); 3298 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 3299 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"), 3300 DwarfAbbrevSectionSym); 3301 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 3302 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 3303 3304 emitDIE(Die); 3305 // FIXME - extra padding for gdb bug. 3306 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB"); 3307 Asm->EmitInt8(0); 3308 Asm->EmitInt8(0); 3309 Asm->EmitInt8(0); 3310 Asm->EmitInt8(0); 3311 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID())); 3312 } 3313} 3314 3315/// emitAbbreviations - Emit the abbreviation section. 3316/// 3317void DwarfDebug::emitAbbreviations() const { 3318 // Check to see if it is worth the effort. 3319 if (!Abbreviations.empty()) { 3320 // Start the debug abbrev section. 3321 Asm->OutStreamer.SwitchSection( 3322 Asm->getObjFileLowering().getDwarfAbbrevSection()); 3323 3324 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin")); 3325 3326 // For each abbrevation. 3327 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 3328 // Get abbreviation data 3329 const DIEAbbrev *Abbrev = Abbreviations[i]; 3330 3331 // Emit the abbrevations code (base 1 index.) 3332 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 3333 3334 // Emit the abbreviations data. 3335 Abbrev->Emit(Asm); 3336 } 3337 3338 // Mark end of abbreviations. 3339 Asm->EmitULEB128(0, "EOM(3)"); 3340 3341 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end")); 3342 } 3343} 3344 3345/// emitEndOfLineMatrix - Emit the last address of the section and the end of 3346/// the line matrix. 3347/// 3348void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 3349 // Define last address of section. 3350 Asm->OutStreamer.AddComment("Extended Op"); 3351 Asm->EmitInt8(0); 3352 3353 Asm->OutStreamer.AddComment("Op size"); 3354 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1); 3355 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 3356 Asm->EmitInt8(dwarf::DW_LNE_set_address); 3357 3358 Asm->OutStreamer.AddComment("Section end label"); 3359 3360 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 3361 Asm->getTargetData().getPointerSize(), 3362 0/*AddrSpace*/); 3363 3364 // Mark end of matrix. 3365 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 3366 Asm->EmitInt8(0); 3367 Asm->EmitInt8(1); 3368 Asm->EmitInt8(1); 3369} 3370 3371/// emitCommonDebugFrame - Emit common frame info into a debug frame section. 3372/// 3373void DwarfDebug::emitCommonDebugFrame() { 3374 if (!Asm->MAI->doesDwarfRequireFrameSection()) 3375 return; 3376 3377 int stackGrowth = Asm->getTargetData().getPointerSize(); 3378 if (Asm->TM.getFrameLowering()->getStackGrowthDirection() == 3379 TargetFrameLowering::StackGrowsDown) 3380 stackGrowth *= -1; 3381 3382 // Start the dwarf frame section. 3383 Asm->OutStreamer.SwitchSection( 3384 Asm->getObjFileLowering().getDwarfFrameSection()); 3385 3386 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common")); 3387 Asm->OutStreamer.AddComment("Length of Common Information Entry"); 3388 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"), 3389 Asm->GetTempSymbol("debug_frame_common_begin"), 4); 3390 3391 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin")); 3392 Asm->OutStreamer.AddComment("CIE Identifier Tag"); 3393 Asm->EmitInt32((int)dwarf::DW_CIE_ID); 3394 Asm->OutStreamer.AddComment("CIE Version"); 3395 Asm->EmitInt8(dwarf::DW_CIE_VERSION); 3396 Asm->OutStreamer.AddComment("CIE Augmentation"); 3397 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator. 3398 Asm->EmitULEB128(1, "CIE Code Alignment Factor"); 3399 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor"); 3400 Asm->OutStreamer.AddComment("CIE RA Column"); 3401 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 3402 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering(); 3403 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); 3404 3405 std::vector<MachineMove> Moves; 3406 TFI->getInitialFrameState(Moves); 3407 3408 Asm->EmitFrameMoves(Moves, 0, false); 3409 3410 Asm->EmitAlignment(2); 3411 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end")); 3412} 3413 3414/// emitFunctionDebugFrame - Emit per function frame info into a debug frame 3415/// section. 3416void DwarfDebug:: 3417emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) { 3418 if (!Asm->MAI->doesDwarfRequireFrameSection()) 3419 return; 3420 3421 // Start the dwarf frame section. 3422 Asm->OutStreamer.SwitchSection( 3423 Asm->getObjFileLowering().getDwarfFrameSection()); 3424 3425 Asm->OutStreamer.AddComment("Length of Frame Information Entry"); 3426 MCSymbol *DebugFrameBegin = 3427 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number); 3428 MCSymbol *DebugFrameEnd = 3429 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number); 3430 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4); 3431 3432 Asm->OutStreamer.EmitLabel(DebugFrameBegin); 3433 3434 Asm->OutStreamer.AddComment("FDE CIE offset"); 3435 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"), 3436 DwarfFrameSectionSym); 3437 3438 Asm->OutStreamer.AddComment("FDE initial location"); 3439 MCSymbol *FuncBeginSym = 3440 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number); 3441 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym, 3442 Asm->getTargetData().getPointerSize(), 3443 0/*AddrSpace*/); 3444 3445 3446 Asm->OutStreamer.AddComment("FDE address range"); 3447 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number), 3448 FuncBeginSym, Asm->getTargetData().getPointerSize()); 3449 3450 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false); 3451 3452 Asm->EmitAlignment(2); 3453 Asm->OutStreamer.EmitLabel(DebugFrameEnd); 3454} 3455 3456/// emitDebugPubNames - Emit visible names into a debug pubnames section. 3457/// 3458void DwarfDebug::emitDebugPubNames() { 3459 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3460 E = CUMap.end(); I != E; ++I) { 3461 CompileUnit *TheCU = I->second; 3462 // Start the dwarf pubnames section. 3463 Asm->OutStreamer.SwitchSection( 3464 Asm->getObjFileLowering().getDwarfPubNamesSection()); 3465 3466 Asm->OutStreamer.AddComment("Length of Public Names Info"); 3467 Asm->EmitLabelDifference( 3468 Asm->GetTempSymbol("pubnames_end", TheCU->getID()), 3469 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4); 3470 3471 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", 3472 TheCU->getID())); 3473 3474 Asm->OutStreamer.AddComment("DWARF Version"); 3475 Asm->EmitInt16(dwarf::DWARF_VERSION); 3476 3477 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 3478 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 3479 DwarfInfoSectionSym); 3480 3481 Asm->OutStreamer.AddComment("Compilation Unit Length"); 3482 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 3483 Asm->GetTempSymbol("info_begin", TheCU->getID()), 3484 4); 3485 3486 const StringMap<DIE*> &Globals = TheCU->getGlobals(); 3487 for (StringMap<DIE*>::const_iterator 3488 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 3489 const char *Name = GI->getKeyData(); 3490 DIE *Entity = GI->second; 3491 3492 Asm->OutStreamer.AddComment("DIE offset"); 3493 Asm->EmitInt32(Entity->getOffset()); 3494 3495 if (Asm->isVerbose()) 3496 Asm->OutStreamer.AddComment("External Name"); 3497 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0); 3498 } 3499 3500 Asm->OutStreamer.AddComment("End Mark"); 3501 Asm->EmitInt32(0); 3502 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", 3503 TheCU->getID())); 3504 } 3505} 3506 3507void DwarfDebug::emitDebugPubTypes() { 3508 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3509 E = CUMap.end(); I != E; ++I) { 3510 CompileUnit *TheCU = I->second; 3511 // Start the dwarf pubnames section. 3512 Asm->OutStreamer.SwitchSection( 3513 Asm->getObjFileLowering().getDwarfPubTypesSection()); 3514 Asm->OutStreamer.AddComment("Length of Public Types Info"); 3515 Asm->EmitLabelDifference( 3516 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()), 3517 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4); 3518 3519 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 3520 TheCU->getID())); 3521 3522 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 3523 Asm->EmitInt16(dwarf::DWARF_VERSION); 3524 3525 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 3526 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 3527 DwarfInfoSectionSym); 3528 3529 Asm->OutStreamer.AddComment("Compilation Unit Length"); 3530 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 3531 Asm->GetTempSymbol("info_begin", TheCU->getID()), 3532 4); 3533 3534 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes(); 3535 for (StringMap<DIE*>::const_iterator 3536 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 3537 const char *Name = GI->getKeyData(); 3538 DIE * Entity = GI->second; 3539 3540 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 3541 Asm->EmitInt32(Entity->getOffset()); 3542 3543 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 3544 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0); 3545 } 3546 3547 Asm->OutStreamer.AddComment("End Mark"); 3548 Asm->EmitInt32(0); 3549 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 3550 TheCU->getID())); 3551 } 3552} 3553 3554/// emitDebugStr - Emit visible names into a debug str section. 3555/// 3556void DwarfDebug::emitDebugStr() { 3557 // Check to see if it is worth the effort. 3558 if (StringPool.empty()) return; 3559 3560 // Start the dwarf str section. 3561 Asm->OutStreamer.SwitchSection( 3562 Asm->getObjFileLowering().getDwarfStrSection()); 3563 3564 // Get all of the string pool entries and put them in an array by their ID so 3565 // we can sort them. 3566 SmallVector<std::pair<unsigned, 3567 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 3568 3569 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 3570 I = StringPool.begin(), E = StringPool.end(); I != E; ++I) 3571 Entries.push_back(std::make_pair(I->second.second, &*I)); 3572 3573 array_pod_sort(Entries.begin(), Entries.end()); 3574 3575 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 3576 // Emit a label for reference from debug information entries. 3577 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 3578 3579 // Emit the string itself. 3580 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/); 3581 } 3582} 3583 3584/// emitDebugLoc - Emit visible names into a debug loc section. 3585/// 3586void DwarfDebug::emitDebugLoc() { 3587 if (DotDebugLocEntries.empty()) 3588 return; 3589 3590 for (SmallVector<DotDebugLocEntry, 4>::iterator 3591 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 3592 I != E; ++I) { 3593 DotDebugLocEntry &Entry = *I; 3594 if (I + 1 != DotDebugLocEntries.end()) 3595 Entry.Merge(I+1); 3596 } 3597 3598 // Start the dwarf loc section. 3599 Asm->OutStreamer.SwitchSection( 3600 Asm->getObjFileLowering().getDwarfLocSection()); 3601 unsigned char Size = Asm->getTargetData().getPointerSize(); 3602 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0)); 3603 unsigned index = 1; 3604 for (SmallVector<DotDebugLocEntry, 4>::iterator 3605 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 3606 I != E; ++I, ++index) { 3607 DotDebugLocEntry &Entry = *I; 3608 if (Entry.isMerged()) continue; 3609 if (Entry.isEmpty()) { 3610 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3611 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3612 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index)); 3613 } else { 3614 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0); 3615 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0); 3616 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 3617 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false); 3618 if (int Offset = Entry.Loc.getOffset()) { 3619 // If the value is at a certain offset from frame register then 3620 // use DW_OP_fbreg. 3621 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1; 3622 Asm->OutStreamer.AddComment("Loc expr size"); 3623 Asm->EmitInt16(1 + OffsetSize); 3624 Asm->OutStreamer.AddComment( 3625 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg)); 3626 Asm->EmitInt8(dwarf::DW_OP_fbreg); 3627 Asm->OutStreamer.AddComment("Offset"); 3628 Asm->EmitSLEB128(Offset); 3629 } else { 3630 if (Reg < 32) { 3631 Asm->OutStreamer.AddComment("Loc expr size"); 3632 Asm->EmitInt16(1); 3633 Asm->OutStreamer.AddComment( 3634 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg)); 3635 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg); 3636 } else { 3637 Asm->OutStreamer.AddComment("Loc expr size"); 3638 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg)); 3639 Asm->EmitInt8(dwarf::DW_OP_regx); 3640 Asm->EmitULEB128(Reg); 3641 } 3642 } 3643 } 3644 } 3645} 3646 3647/// EmitDebugARanges - Emit visible names into a debug aranges section. 3648/// 3649void DwarfDebug::EmitDebugARanges() { 3650 // Start the dwarf aranges section. 3651 Asm->OutStreamer.SwitchSection( 3652 Asm->getObjFileLowering().getDwarfARangesSection()); 3653} 3654 3655/// emitDebugRanges - Emit visible names into a debug ranges section. 3656/// 3657void DwarfDebug::emitDebugRanges() { 3658 // Start the dwarf ranges section. 3659 Asm->OutStreamer.SwitchSection( 3660 Asm->getObjFileLowering().getDwarfRangesSection()); 3661 unsigned char Size = Asm->getTargetData().getPointerSize(); 3662 for (SmallVector<const MCSymbol *, 8>::iterator 3663 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end(); 3664 I != E; ++I) { 3665 if (*I) 3666 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0); 3667 else 3668 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3669 } 3670} 3671 3672/// emitDebugMacInfo - Emit visible names into a debug macinfo section. 3673/// 3674void DwarfDebug::emitDebugMacInfo() { 3675 if (const MCSection *LineInfo = 3676 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 3677 // Start the dwarf macinfo section. 3678 Asm->OutStreamer.SwitchSection(LineInfo); 3679 } 3680} 3681 3682/// emitDebugInlineInfo - Emit inline info using following format. 3683/// Section Header: 3684/// 1. length of section 3685/// 2. Dwarf version number 3686/// 3. address size. 3687/// 3688/// Entries (one "entry" for each function that was inlined): 3689/// 3690/// 1. offset into __debug_str section for MIPS linkage name, if exists; 3691/// otherwise offset into __debug_str for regular function name. 3692/// 2. offset into __debug_str section for regular function name. 3693/// 3. an unsigned LEB128 number indicating the number of distinct inlining 3694/// instances for the function. 3695/// 3696/// The rest of the entry consists of a {die_offset, low_pc} pair for each 3697/// inlined instance; the die_offset points to the inlined_subroutine die in the 3698/// __debug_info section, and the low_pc is the starting address for the 3699/// inlining instance. 3700void DwarfDebug::emitDebugInlineInfo() { 3701 if (!Asm->MAI->doesDwarfUsesInlineInfoSection()) 3702 return; 3703 3704 if (!FirstCU) 3705 return; 3706 3707 Asm->OutStreamer.SwitchSection( 3708 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 3709 3710 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry"); 3711 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1), 3712 Asm->GetTempSymbol("debug_inlined_begin", 1), 4); 3713 3714 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1)); 3715 3716 Asm->OutStreamer.AddComment("Dwarf Version"); 3717 Asm->EmitInt16(dwarf::DWARF_VERSION); 3718 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 3719 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 3720 3721 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 3722 E = InlinedSPNodes.end(); I != E; ++I) { 3723 3724 const MDNode *Node = *I; 3725 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 3726 = InlineInfo.find(Node); 3727 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 3728 DISubprogram SP(Node); 3729 StringRef LName = SP.getLinkageName(); 3730 StringRef Name = SP.getName(); 3731 3732 Asm->OutStreamer.AddComment("MIPS linkage name"); 3733 if (LName.empty()) { 3734 Asm->OutStreamer.EmitBytes(Name, 0); 3735 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator. 3736 } else 3737 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)), 3738 DwarfStrSectionSym); 3739 3740 Asm->OutStreamer.AddComment("Function name"); 3741 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym); 3742 Asm->EmitULEB128(Labels.size(), "Inline count"); 3743 3744 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 3745 LE = Labels.end(); LI != LE; ++LI) { 3746 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 3747 Asm->EmitInt32(LI->second->getOffset()); 3748 3749 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc"); 3750 Asm->OutStreamer.EmitSymbolValue(LI->first, 3751 Asm->getTargetData().getPointerSize(),0); 3752 } 3753 } 3754 3755 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1)); 3756} 3757