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