DwarfDebug.cpp revision f4ccaeaef93c56af7017b7e503888e8a0f6d8851
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 LabelsBeforeInsn[MI] = Label; 2234 } 2235 } 2236 2237 return; 2238 } 2239 2240 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 2241 2242 // FIXME: Should only verify each scope once! 2243 if (!DIScope(Scope).Verify()) 2244 return; 2245 2246 // DBG_VALUE instruction establishes new value. 2247 if (MI->isDebugValue()) { 2248 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI 2249 = DbgValueStartMap.find(MI); 2250 if (DI != DbgValueStartMap.end()) { 2251 MCSymbol *Label = NULL; 2252 if (DL == PrevInstLoc) 2253 Label = PrevLabel; 2254 else { 2255 Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope); 2256 PrevInstLoc = DL; 2257 PrevLabel = Label; 2258 LabelsBeforeInsn[MI] = Label; 2259 } 2260 DI->second->setDbgValueLabel(Label); 2261 } 2262 return; 2263 } 2264 2265 // Emit a label to indicate location change. This is used for line 2266 // table even if this instruction does not start a new scope. 2267 MCSymbol *Label = NULL; 2268 if (DL == PrevInstLoc) 2269 Label = PrevLabel; 2270 else { 2271 Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope); 2272 PrevInstLoc = DL; 2273 PrevLabel = Label; 2274 LabelsBeforeInsn[MI] = Label; 2275 } 2276 2277} 2278 2279/// endScope - Process end of a scope. 2280void DwarfDebug::endScope(const MachineInstr *MI) { 2281 if (InsnsEndScopeSet.count(MI) != 0) { 2282 // Emit a label if this instruction ends a scope. 2283 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2284 Asm->OutStreamer.EmitLabel(Label); 2285 LabelsAfterInsn[MI] = Label; 2286 } 2287} 2288 2289/// getOrCreateDbgScope - Create DbgScope for the scope. 2290DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope, const MDNode *InlinedAt) { 2291 if (!InlinedAt) { 2292 DbgScope *WScope = DbgScopeMap.lookup(Scope); 2293 if (WScope) 2294 return WScope; 2295 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL); 2296 DbgScopeMap.insert(std::make_pair(Scope, WScope)); 2297 if (DIDescriptor(Scope).isLexicalBlock()) { 2298 DbgScope *Parent = 2299 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL); 2300 WScope->setParent(Parent); 2301 Parent->addScope(WScope); 2302 } 2303 2304 if (!WScope->getParent()) { 2305 StringRef SPName = DISubprogram(Scope).getLinkageName(); 2306 if (SPName == Asm->MF->getFunction()->getName()) 2307 CurrentFnDbgScope = WScope; 2308 } 2309 2310 return WScope; 2311 } 2312 2313 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt); 2314 if (WScope) 2315 return WScope; 2316 2317 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt); 2318 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope)); 2319 DILocation DL(InlinedAt); 2320 DbgScope *Parent = 2321 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation()); 2322 WScope->setParent(Parent); 2323 Parent->addScope(WScope); 2324 2325 ConcreteScopes[InlinedAt] = WScope; 2326 getOrCreateAbstractScope(Scope); 2327 2328 return WScope; 2329} 2330 2331/// hasValidLocation - Return true if debug location entry attached with 2332/// machine instruction encodes valid location info. 2333static bool hasValidLocation(LLVMContext &Ctx, 2334 const MachineInstr *MInsn, 2335 const MDNode *&Scope, const MDNode *&InlinedAt) { 2336 if (MInsn->isDebugValue()) 2337 return false; 2338 DebugLoc DL = MInsn->getDebugLoc(); 2339 if (DL.isUnknown()) return false; 2340 2341 const MDNode *S = DL.getScope(Ctx); 2342 2343 // There is no need to create another DIE for compile unit. For all 2344 // other scopes, create one DbgScope now. This will be translated 2345 // into a scope DIE at the end. 2346 if (DIScope(S).isCompileUnit()) return false; 2347 2348 Scope = S; 2349 InlinedAt = DL.getInlinedAt(Ctx); 2350 return true; 2351} 2352 2353/// calculateDominanceGraph - Calculate dominance graph for DbgScope 2354/// hierarchy. 2355static void calculateDominanceGraph(DbgScope *Scope) { 2356 assert (Scope && "Unable to calculate scop edominance graph!"); 2357 SmallVector<DbgScope *, 4> WorkStack; 2358 WorkStack.push_back(Scope); 2359 unsigned Counter = 0; 2360 while (!WorkStack.empty()) { 2361 DbgScope *WS = WorkStack.back(); 2362 const SmallVector<DbgScope *, 4> &Children = WS->getScopes(); 2363 bool visitedChildren = false; 2364 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2365 SE = Children.end(); SI != SE; ++SI) { 2366 DbgScope *ChildScope = *SI; 2367 if (!ChildScope->getDFSOut()) { 2368 WorkStack.push_back(ChildScope); 2369 visitedChildren = true; 2370 ChildScope->setDFSIn(++Counter); 2371 break; 2372 } 2373 } 2374 if (!visitedChildren) { 2375 WorkStack.pop_back(); 2376 WS->setDFSOut(++Counter); 2377 } 2378 } 2379} 2380 2381/// printDbgScopeInfo - Print DbgScope info for each machine instruction. 2382static 2383void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF, 2384 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap) 2385{ 2386#ifndef NDEBUG 2387 unsigned PrevDFSIn = 0; 2388 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2389 I != E; ++I) { 2390 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2391 II != IE; ++II) { 2392 const MachineInstr *MInsn = II; 2393 const MDNode *Scope = NULL; 2394 const MDNode *InlinedAt = NULL; 2395 2396 // Check if instruction has valid location information. 2397 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2398 dbgs() << " [ "; 2399 if (InlinedAt) 2400 dbgs() << "*"; 2401 DenseMap<const MachineInstr *, DbgScope *>::iterator DI = 2402 MI2ScopeMap.find(MInsn); 2403 if (DI != MI2ScopeMap.end()) { 2404 DbgScope *S = DI->second; 2405 dbgs() << S->getDFSIn(); 2406 PrevDFSIn = S->getDFSIn(); 2407 } else 2408 dbgs() << PrevDFSIn; 2409 } else 2410 dbgs() << " [ x" << PrevDFSIn; 2411 dbgs() << " ]"; 2412 MInsn->dump(); 2413 } 2414 dbgs() << "\n"; 2415 } 2416#endif 2417} 2418/// extractScopeInformation - Scan machine instructions in this function 2419/// and collect DbgScopes. Return true, if at least one scope was found. 2420bool DwarfDebug::extractScopeInformation() { 2421 // If scope information was extracted using .dbg intrinsics then there is not 2422 // any need to extract these information by scanning each instruction. 2423 if (!DbgScopeMap.empty()) 2424 return false; 2425 2426 // Scan each instruction and create scopes. First build working set of scopes. 2427 LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2428 SmallVector<DbgRange, 4> MIRanges; 2429 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap; 2430 const MDNode *PrevScope = NULL; 2431 const MDNode *PrevInlinedAt = NULL; 2432 const MachineInstr *RangeBeginMI = NULL; 2433 const MachineInstr *PrevMI = NULL; 2434 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 2435 I != E; ++I) { 2436 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2437 II != IE; ++II) { 2438 const MachineInstr *MInsn = II; 2439 const MDNode *Scope = NULL; 2440 const MDNode *InlinedAt = NULL; 2441 2442 // Check if instruction has valid location information. 2443 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) { 2444 PrevMI = MInsn; 2445 continue; 2446 } 2447 2448 // If scope has not changed then skip this instruction. 2449 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) { 2450 PrevMI = MInsn; 2451 continue; 2452 } 2453 2454 if (RangeBeginMI) { 2455 // If we have alread seen a beginning of a instruction range and 2456 // current instruction scope does not match scope of first instruction 2457 // in this range then create a new instruction range. 2458 DbgRange R(RangeBeginMI, PrevMI); 2459 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt); 2460 MIRanges.push_back(R); 2461 } 2462 2463 // This is a beginning of a new instruction range. 2464 RangeBeginMI = MInsn; 2465 2466 // Reset previous markers. 2467 PrevMI = MInsn; 2468 PrevScope = Scope; 2469 PrevInlinedAt = InlinedAt; 2470 } 2471 } 2472 2473 // Create last instruction range. 2474 if (RangeBeginMI && PrevMI && PrevScope) { 2475 DbgRange R(RangeBeginMI, PrevMI); 2476 MIRanges.push_back(R); 2477 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt); 2478 } 2479 2480 if (!CurrentFnDbgScope) 2481 return false; 2482 2483 calculateDominanceGraph(CurrentFnDbgScope); 2484 if (PrintDbgScope) 2485 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap); 2486 2487 // Find ranges of instructions covered by each DbgScope; 2488 DbgScope *PrevDbgScope = NULL; 2489 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(), 2490 RE = MIRanges.end(); RI != RE; ++RI) { 2491 const DbgRange &R = *RI; 2492 DbgScope *S = MI2ScopeMap.lookup(R.first); 2493 assert (S && "Lost DbgScope for a machine instruction!"); 2494 if (PrevDbgScope && !PrevDbgScope->dominates(S)) 2495 PrevDbgScope->closeInsnRange(S); 2496 S->openInsnRange(R.first); 2497 S->extendInsnRange(R.second); 2498 PrevDbgScope = S; 2499 } 2500 2501 if (PrevDbgScope) 2502 PrevDbgScope->closeInsnRange(); 2503 2504 identifyScopeMarkers(); 2505 2506 return !DbgScopeMap.empty(); 2507} 2508 2509/// identifyScopeMarkers() - 2510/// Each DbgScope has first instruction and last instruction to mark beginning 2511/// and end of a scope respectively. Create an inverse map that list scopes 2512/// starts (and ends) with an instruction. One instruction may start (or end) 2513/// multiple scopes. Ignore scopes that are not reachable. 2514void DwarfDebug::identifyScopeMarkers() { 2515 SmallVector<DbgScope *, 4> WorkList; 2516 WorkList.push_back(CurrentFnDbgScope); 2517 while (!WorkList.empty()) { 2518 DbgScope *S = WorkList.pop_back_val(); 2519 2520 const SmallVector<DbgScope *, 4> &Children = S->getScopes(); 2521 if (!Children.empty()) 2522 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 2523 SE = Children.end(); SI != SE; ++SI) 2524 WorkList.push_back(*SI); 2525 2526 if (S->isAbstractScope()) 2527 continue; 2528 2529 const SmallVector<DbgRange, 4> &Ranges = S->getRanges(); 2530 if (Ranges.empty()) 2531 continue; 2532 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 2533 RE = Ranges.end(); RI != RE; ++RI) { 2534 assert(RI->first && "DbgRange does not have first instruction!"); 2535 assert(RI->second && "DbgRange does not have second instruction!"); 2536 InsnsEndScopeSet.insert(RI->second); 2537 } 2538 } 2539} 2540 2541/// FindFirstDebugLoc - Find the first debug location in the function. This 2542/// is intended to be an approximation for the source position of the 2543/// beginning of the function. 2544static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) { 2545 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2546 I != E; ++I) 2547 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end(); 2548 MBBI != MBBE; ++MBBI) { 2549 DebugLoc DL = MBBI->getDebugLoc(); 2550 if (!DL.isUnknown()) 2551 return DL; 2552 } 2553 return DebugLoc(); 2554} 2555 2556/// beginFunction - Gather pre-function debug information. Assumes being 2557/// emitted immediately after the function entry point. 2558void DwarfDebug::beginFunction(const MachineFunction *MF) { 2559 if (!MMI->hasDebugInfo()) return; 2560 if (!extractScopeInformation()) return; 2561 2562 collectVariableInfo(MF); 2563 2564 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 2565 Asm->getFunctionNumber()); 2566 // Assumes in correct section after the entry point. 2567 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 2568 2569 // Emit label for the implicitly defined dbg.stoppoint at the start of the 2570 // function. 2571 DebugLoc FDL = FindFirstDebugLoc(MF); 2572 if (FDL.isUnknown()) return; 2573 2574 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext()); 2575 2576 DISubprogram SP = getDISubprogram(Scope); 2577 unsigned Line, Col; 2578 if (SP.Verify()) { 2579 Line = SP.getLineNumber(); 2580 Col = 0; 2581 } else { 2582 Line = FDL.getLine(); 2583 Col = FDL.getCol(); 2584 } 2585 2586 recordSourceLine(Line, Col, Scope); 2587} 2588 2589/// endFunction - Gather and emit post-function debug information. 2590/// 2591void DwarfDebug::endFunction(const MachineFunction *MF) { 2592 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return; 2593 2594 if (CurrentFnDbgScope) { 2595 // Define end label for subprogram. 2596 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end", 2597 Asm->getFunctionNumber())); 2598 2599 // Get function line info. 2600 if (!Lines.empty()) { 2601 // Get section line info. 2602 unsigned ID = SectionMap.insert(Asm->getCurrentSection()); 2603 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID); 2604 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1]; 2605 // Append the function info to section info. 2606 SectionLineInfos.insert(SectionLineInfos.end(), 2607 Lines.begin(), Lines.end()); 2608 } 2609 2610 // Construct abstract scopes. 2611 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2612 AE = AbstractScopesList.end(); AI != AE; ++AI) 2613 constructScopeDIE(*AI); 2614 2615 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope); 2616 2617 if (!DisableFramePointerElim(*MF)) 2618 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr, 2619 dwarf::DW_FORM_flag, 1); 2620 2621 2622 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(), 2623 MMI->getFrameMoves())); 2624 } 2625 2626 // Clear debug info 2627 CurrentFnDbgScope = NULL; 2628 DeleteContainerSeconds(DbgScopeMap); 2629 InsnsEndScopeSet.clear(); 2630 DbgValueStartMap.clear(); 2631 ConcreteScopes.clear(); 2632 DeleteContainerSeconds(AbstractScopes); 2633 AbstractScopesList.clear(); 2634 AbstractVariables.clear(); 2635 LabelsBeforeInsn.clear(); 2636 LabelsAfterInsn.clear(); 2637 Lines.clear(); 2638 PrevLabel = NULL; 2639} 2640 2641/// recordSourceLine - Register a source line with debug info. Returns the 2642/// unique label that was emitted and which provides correspondence to 2643/// the source line list. 2644MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S) { 2645 StringRef Dir; 2646 StringRef Fn; 2647 2648 unsigned Src = 1; 2649 if (S) { 2650 DIDescriptor Scope(S); 2651 2652 if (Scope.isCompileUnit()) { 2653 DICompileUnit CU(S); 2654 Dir = CU.getDirectory(); 2655 Fn = CU.getFilename(); 2656 } else if (Scope.isSubprogram()) { 2657 DISubprogram SP(S); 2658 Dir = SP.getDirectory(); 2659 Fn = SP.getFilename(); 2660 } else if (Scope.isLexicalBlock()) { 2661 DILexicalBlock DB(S); 2662 Dir = DB.getDirectory(); 2663 Fn = DB.getFilename(); 2664 } else 2665 assert(0 && "Unexpected scope info"); 2666 2667 Src = GetOrCreateSourceID(Dir, Fn); 2668 } 2669 2670 MCSymbol *Label = MMI->getContext().CreateTempSymbol(); 2671 Lines.push_back(SrcLineInfo(Line, Col, Src, Label)); 2672 2673 Asm->OutStreamer.EmitLabel(Label); 2674 return Label; 2675} 2676 2677//===----------------------------------------------------------------------===// 2678// Emit Methods 2679//===----------------------------------------------------------------------===// 2680 2681/// computeSizeAndOffset - Compute the size and offset of a DIE. 2682/// 2683unsigned 2684DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) { 2685 // Get the children. 2686 const std::vector<DIE *> &Children = Die->getChildren(); 2687 2688 // If not last sibling and has children then add sibling offset attribute. 2689 if (!Last && !Children.empty()) 2690 Die->addSiblingOffset(DIEValueAllocator); 2691 2692 // Record the abbreviation. 2693 assignAbbrevNumber(Die->getAbbrev()); 2694 2695 // Get the abbreviation for this DIE. 2696 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2697 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2698 2699 // Set DIE offset 2700 Die->setOffset(Offset); 2701 2702 // Start the size with the size of abbreviation code. 2703 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 2704 2705 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2706 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2707 2708 // Size the DIE attribute values. 2709 for (unsigned i = 0, N = Values.size(); i < N; ++i) 2710 // Size attribute value. 2711 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm()); 2712 2713 // Size the DIE children if any. 2714 if (!Children.empty()) { 2715 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 2716 "Children flag not set"); 2717 2718 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2719 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M); 2720 2721 // End of children marker. 2722 Offset += sizeof(int8_t); 2723 } 2724 2725 Die->setSize(Offset - Die->getOffset()); 2726 return Offset; 2727} 2728 2729/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 2730/// 2731void DwarfDebug::computeSizeAndOffsets() { 2732 unsigned PrevOffset = 0; 2733 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2734 E = CUMap.end(); I != E; ++I) { 2735 // Compute size of compile unit header. 2736 static unsigned Offset = PrevOffset + 2737 sizeof(int32_t) + // Length of Compilation Unit Info 2738 sizeof(int16_t) + // DWARF version number 2739 sizeof(int32_t) + // Offset Into Abbrev. Section 2740 sizeof(int8_t); // Pointer Size (in bytes) 2741 computeSizeAndOffset(I->second->getCUDie(), Offset, true); 2742 PrevOffset = Offset; 2743 } 2744} 2745 2746/// EmitSectionSym - Switch to the specified MCSection and emit an assembler 2747/// temporary label to it if SymbolStem is specified. 2748static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section, 2749 const char *SymbolStem = 0) { 2750 Asm->OutStreamer.SwitchSection(Section); 2751 if (!SymbolStem) return 0; 2752 2753 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem); 2754 Asm->OutStreamer.EmitLabel(TmpSym); 2755 return TmpSym; 2756} 2757 2758/// EmitSectionLabels - Emit initial Dwarf sections with a label at 2759/// the start of each one. 2760void DwarfDebug::EmitSectionLabels() { 2761 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 2762 2763 // Dwarf sections base addresses. 2764 if (Asm->MAI->doesDwarfRequireFrameSection()) { 2765 DwarfFrameSectionSym = 2766 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame"); 2767 } 2768 2769 DwarfInfoSectionSym = 2770 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 2771 DwarfAbbrevSectionSym = 2772 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 2773 EmitSectionSym(Asm, TLOF.getDwarfARangesSection()); 2774 2775 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 2776 EmitSectionSym(Asm, MacroInfo); 2777 2778 EmitSectionSym(Asm, TLOF.getDwarfLineSection()); 2779 EmitSectionSym(Asm, TLOF.getDwarfLocSection()); 2780 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 2781 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 2782 DwarfStrSectionSym = 2783 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str"); 2784 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(), 2785 "debug_range"); 2786 2787 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 2788 EmitSectionSym(Asm, TLOF.getDataSection()); 2789} 2790 2791/// emitDIE - Recusively Emits a debug information entry. 2792/// 2793void DwarfDebug::emitDIE(DIE *Die) { 2794 // Get the abbreviation for this DIE. 2795 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2796 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2797 2798 // Emit the code (index) for the abbreviation. 2799 if (Asm->isVerbose()) 2800 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 2801 Twine::utohexstr(Die->getOffset()) + ":0x" + 2802 Twine::utohexstr(Die->getSize()) + " " + 2803 dwarf::TagString(Abbrev->getTag())); 2804 Asm->EmitULEB128(AbbrevNumber); 2805 2806 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2807 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2808 2809 // Emit the DIE attribute values. 2810 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 2811 unsigned Attr = AbbrevData[i].getAttribute(); 2812 unsigned Form = AbbrevData[i].getForm(); 2813 assert(Form && "Too many attributes for DIE (check abbreviation)"); 2814 2815 if (Asm->isVerbose()) 2816 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 2817 2818 switch (Attr) { 2819 case dwarf::DW_AT_sibling: 2820 Asm->EmitInt32(Die->getSiblingOffset()); 2821 break; 2822 case dwarf::DW_AT_abstract_origin: { 2823 DIEEntry *E = cast<DIEEntry>(Values[i]); 2824 DIE *Origin = E->getEntry(); 2825 unsigned Addr = Origin->getOffset(); 2826 Asm->EmitInt32(Addr); 2827 break; 2828 } 2829 case dwarf::DW_AT_ranges: { 2830 // DW_AT_range Value encodes offset in debug_range section. 2831 DIEInteger *V = cast<DIEInteger>(Values[i]); 2832 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym, 2833 V->getValue(), 2834 DwarfDebugRangeSectionSym, 2835 4); 2836 break; 2837 } 2838 default: 2839 // Emit an attribute using the defined form. 2840 Values[i]->EmitValue(Asm, Form); 2841 break; 2842 } 2843 } 2844 2845 // Emit the DIE children if any. 2846 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 2847 const std::vector<DIE *> &Children = Die->getChildren(); 2848 2849 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2850 emitDIE(Children[j]); 2851 2852 if (Asm->isVerbose()) 2853 Asm->OutStreamer.AddComment("End Of Children Mark"); 2854 Asm->EmitInt8(0); 2855 } 2856} 2857 2858/// emitDebugInfo - Emit the debug info section. 2859/// 2860void DwarfDebug::emitDebugInfo() { 2861 // Start debug info section. 2862 Asm->OutStreamer.SwitchSection( 2863 Asm->getObjFileLowering().getDwarfInfoSection()); 2864 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2865 E = CUMap.end(); I != E; ++I) { 2866 CompileUnit *TheCU = I->second; 2867 DIE *Die = TheCU->getCUDie(); 2868 2869 // Emit the compile units header. 2870 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin", 2871 TheCU->getID())); 2872 2873 // Emit size of content not including length itself 2874 unsigned ContentSize = Die->getSize() + 2875 sizeof(int16_t) + // DWARF version number 2876 sizeof(int32_t) + // Offset Into Abbrev. Section 2877 sizeof(int8_t) + // Pointer Size (in bytes) 2878 sizeof(int32_t); // FIXME - extra pad for gdb bug. 2879 2880 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 2881 Asm->EmitInt32(ContentSize); 2882 Asm->OutStreamer.AddComment("DWARF version number"); 2883 Asm->EmitInt16(dwarf::DWARF_VERSION); 2884 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 2885 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"), 2886 DwarfAbbrevSectionSym); 2887 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2888 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 2889 2890 emitDIE(Die); 2891 // FIXME - extra padding for gdb bug. 2892 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB"); 2893 Asm->EmitInt8(0); 2894 Asm->EmitInt8(0); 2895 Asm->EmitInt8(0); 2896 Asm->EmitInt8(0); 2897 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID())); 2898 } 2899} 2900 2901/// emitAbbreviations - Emit the abbreviation section. 2902/// 2903void DwarfDebug::emitAbbreviations() const { 2904 // Check to see if it is worth the effort. 2905 if (!Abbreviations.empty()) { 2906 // Start the debug abbrev section. 2907 Asm->OutStreamer.SwitchSection( 2908 Asm->getObjFileLowering().getDwarfAbbrevSection()); 2909 2910 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin")); 2911 2912 // For each abbrevation. 2913 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 2914 // Get abbreviation data 2915 const DIEAbbrev *Abbrev = Abbreviations[i]; 2916 2917 // Emit the abbrevations code (base 1 index.) 2918 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 2919 2920 // Emit the abbreviations data. 2921 Abbrev->Emit(Asm); 2922 } 2923 2924 // Mark end of abbreviations. 2925 Asm->EmitULEB128(0, "EOM(3)"); 2926 2927 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end")); 2928 } 2929} 2930 2931/// emitEndOfLineMatrix - Emit the last address of the section and the end of 2932/// the line matrix. 2933/// 2934void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 2935 // Define last address of section. 2936 Asm->OutStreamer.AddComment("Extended Op"); 2937 Asm->EmitInt8(0); 2938 2939 Asm->OutStreamer.AddComment("Op size"); 2940 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1); 2941 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 2942 Asm->EmitInt8(dwarf::DW_LNE_set_address); 2943 2944 Asm->OutStreamer.AddComment("Section end label"); 2945 2946 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 2947 Asm->getTargetData().getPointerSize(), 2948 0/*AddrSpace*/); 2949 2950 // Mark end of matrix. 2951 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 2952 Asm->EmitInt8(0); 2953 Asm->EmitInt8(1); 2954 Asm->EmitInt8(1); 2955} 2956 2957/// emitDebugLines - Emit source line information. 2958/// 2959void DwarfDebug::emitDebugLines() { 2960 // If the target is using .loc/.file, the assembler will be emitting the 2961 // .debug_line table automatically. 2962 if (Asm->MAI->hasDotLocAndDotFile()) 2963 return; 2964 2965 // Minimum line delta, thus ranging from -10..(255-10). 2966 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1); 2967 // Maximum line delta, thus ranging from -10..(255-10). 2968 const int MaxLineDelta = 255 + MinLineDelta; 2969 2970 // Start the dwarf line section. 2971 Asm->OutStreamer.SwitchSection( 2972 Asm->getObjFileLowering().getDwarfLineSection()); 2973 2974 // Construct the section header. 2975 Asm->OutStreamer.AddComment("Length of Source Line Info"); 2976 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"), 2977 Asm->GetTempSymbol("line_begin"), 4); 2978 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin")); 2979 2980 Asm->OutStreamer.AddComment("DWARF version number"); 2981 Asm->EmitInt16(dwarf::DWARF_VERSION); 2982 2983 Asm->OutStreamer.AddComment("Prolog Length"); 2984 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"), 2985 Asm->GetTempSymbol("line_prolog_begin"), 4); 2986 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin")); 2987 2988 Asm->OutStreamer.AddComment("Minimum Instruction Length"); 2989 Asm->EmitInt8(1); 2990 Asm->OutStreamer.AddComment("Default is_stmt_start flag"); 2991 Asm->EmitInt8(1); 2992 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)"); 2993 Asm->EmitInt8(MinLineDelta); 2994 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)"); 2995 Asm->EmitInt8(MaxLineDelta); 2996 Asm->OutStreamer.AddComment("Special Opcode Base"); 2997 Asm->EmitInt8(-MinLineDelta); 2998 2999 // Line number standard opcode encodings argument count 3000 Asm->OutStreamer.AddComment("DW_LNS_copy arg count"); 3001 Asm->EmitInt8(0); 3002 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count"); 3003 Asm->EmitInt8(1); 3004 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count"); 3005 Asm->EmitInt8(1); 3006 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count"); 3007 Asm->EmitInt8(1); 3008 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count"); 3009 Asm->EmitInt8(1); 3010 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count"); 3011 Asm->EmitInt8(0); 3012 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count"); 3013 Asm->EmitInt8(0); 3014 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count"); 3015 Asm->EmitInt8(0); 3016 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count"); 3017 Asm->EmitInt8(1); 3018 3019 // Emit directories. 3020 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) { 3021 const std::string &Dir = getSourceDirectoryName(DI); 3022 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory"); 3023 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0); 3024 } 3025 3026 Asm->OutStreamer.AddComment("End of directories"); 3027 Asm->EmitInt8(0); 3028 3029 // Emit files. 3030 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) { 3031 // Remember source id starts at 1. 3032 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI); 3033 const std::string &FN = getSourceFileName(Id.second); 3034 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source"); 3035 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0); 3036 3037 Asm->EmitULEB128(Id.first, "Directory #"); 3038 Asm->EmitULEB128(0, "Mod date"); 3039 Asm->EmitULEB128(0, "File size"); 3040 } 3041 3042 Asm->OutStreamer.AddComment("End of files"); 3043 Asm->EmitInt8(0); 3044 3045 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end")); 3046 3047 // A sequence for each text section. 3048 unsigned SecSrcLinesSize = SectionSourceLines.size(); 3049 3050 for (unsigned j = 0; j < SecSrcLinesSize; ++j) { 3051 // Isolate current sections line info. 3052 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j]; 3053 3054 // Dwarf assumes we start with first line of first source file. 3055 unsigned Source = 1; 3056 unsigned Line = 1; 3057 3058 // Construct rows of the address, source, line, column matrix. 3059 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) { 3060 const SrcLineInfo &LineInfo = LineInfos[i]; 3061 MCSymbol *Label = LineInfo.getLabel(); 3062 if (!Label->isDefined()) continue; // Not emitted, in dead code. 3063 3064 if (Asm->isVerbose()) { 3065 std::pair<unsigned, unsigned> SrcID = 3066 getSourceDirectoryAndFileIds(LineInfo.getSourceID()); 3067 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) + 3068 "/" + 3069 Twine(getSourceFileName(SrcID.second)) + 3070 ":" + Twine(LineInfo.getLine())); 3071 } 3072 3073 // Define the line address. 3074 Asm->OutStreamer.AddComment("Extended Op"); 3075 Asm->EmitInt8(0); 3076 Asm->OutStreamer.AddComment("Op size"); 3077 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1); 3078 3079 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 3080 Asm->EmitInt8(dwarf::DW_LNE_set_address); 3081 3082 Asm->OutStreamer.AddComment("Location label"); 3083 Asm->OutStreamer.EmitSymbolValue(Label, 3084 Asm->getTargetData().getPointerSize(), 3085 0/*AddrSpace*/); 3086 3087 // If change of source, then switch to the new source. 3088 if (Source != LineInfo.getSourceID()) { 3089 Source = LineInfo.getSourceID(); 3090 Asm->OutStreamer.AddComment("DW_LNS_set_file"); 3091 Asm->EmitInt8(dwarf::DW_LNS_set_file); 3092 Asm->EmitULEB128(Source, "New Source"); 3093 } 3094 3095 // If change of line. 3096 if (Line != LineInfo.getLine()) { 3097 // Determine offset. 3098 int Offset = LineInfo.getLine() - Line; 3099 int Delta = Offset - MinLineDelta; 3100 3101 // Update line. 3102 Line = LineInfo.getLine(); 3103 3104 // If delta is small enough and in range... 3105 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { 3106 // ... then use fast opcode. 3107 Asm->OutStreamer.AddComment("Line Delta"); 3108 Asm->EmitInt8(Delta - MinLineDelta); 3109 } else { 3110 // ... otherwise use long hand. 3111 Asm->OutStreamer.AddComment("DW_LNS_advance_line"); 3112 Asm->EmitInt8(dwarf::DW_LNS_advance_line); 3113 Asm->EmitSLEB128(Offset, "Line Offset"); 3114 Asm->OutStreamer.AddComment("DW_LNS_copy"); 3115 Asm->EmitInt8(dwarf::DW_LNS_copy); 3116 } 3117 } else { 3118 // Copy the previous row (different address or source) 3119 Asm->OutStreamer.AddComment("DW_LNS_copy"); 3120 Asm->EmitInt8(dwarf::DW_LNS_copy); 3121 } 3122 } 3123 3124 emitEndOfLineMatrix(j + 1); 3125 } 3126 3127 if (SecSrcLinesSize == 0) 3128 // Because we're emitting a debug_line section, we still need a line 3129 // table. The linker and friends expect it to exist. If there's nothing to 3130 // put into it, emit an empty table. 3131 emitEndOfLineMatrix(1); 3132 3133 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end")); 3134} 3135 3136/// emitCommonDebugFrame - Emit common frame info into a debug frame section. 3137/// 3138void DwarfDebug::emitCommonDebugFrame() { 3139 if (!Asm->MAI->doesDwarfRequireFrameSection()) 3140 return; 3141 3142 int stackGrowth = Asm->getTargetData().getPointerSize(); 3143 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() == 3144 TargetFrameInfo::StackGrowsDown) 3145 stackGrowth *= -1; 3146 3147 // Start the dwarf frame section. 3148 Asm->OutStreamer.SwitchSection( 3149 Asm->getObjFileLowering().getDwarfFrameSection()); 3150 3151 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common")); 3152 Asm->OutStreamer.AddComment("Length of Common Information Entry"); 3153 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"), 3154 Asm->GetTempSymbol("debug_frame_common_begin"), 4); 3155 3156 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin")); 3157 Asm->OutStreamer.AddComment("CIE Identifier Tag"); 3158 Asm->EmitInt32((int)dwarf::DW_CIE_ID); 3159 Asm->OutStreamer.AddComment("CIE Version"); 3160 Asm->EmitInt8(dwarf::DW_CIE_VERSION); 3161 Asm->OutStreamer.AddComment("CIE Augmentation"); 3162 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator. 3163 Asm->EmitULEB128(1, "CIE Code Alignment Factor"); 3164 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor"); 3165 Asm->OutStreamer.AddComment("CIE RA Column"); 3166 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 3167 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); 3168 3169 std::vector<MachineMove> Moves; 3170 RI->getInitialFrameState(Moves); 3171 3172 Asm->EmitFrameMoves(Moves, 0, false); 3173 3174 Asm->EmitAlignment(2); 3175 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end")); 3176} 3177 3178/// emitFunctionDebugFrame - Emit per function frame info into a debug frame 3179/// section. 3180void DwarfDebug:: 3181emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) { 3182 if (!Asm->MAI->doesDwarfRequireFrameSection()) 3183 return; 3184 3185 // Start the dwarf frame section. 3186 Asm->OutStreamer.SwitchSection( 3187 Asm->getObjFileLowering().getDwarfFrameSection()); 3188 3189 Asm->OutStreamer.AddComment("Length of Frame Information Entry"); 3190 MCSymbol *DebugFrameBegin = 3191 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number); 3192 MCSymbol *DebugFrameEnd = 3193 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number); 3194 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4); 3195 3196 Asm->OutStreamer.EmitLabel(DebugFrameBegin); 3197 3198 Asm->OutStreamer.AddComment("FDE CIE offset"); 3199 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"), 3200 DwarfFrameSectionSym); 3201 3202 Asm->OutStreamer.AddComment("FDE initial location"); 3203 MCSymbol *FuncBeginSym = 3204 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number); 3205 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym, 3206 Asm->getTargetData().getPointerSize(), 3207 0/*AddrSpace*/); 3208 3209 3210 Asm->OutStreamer.AddComment("FDE address range"); 3211 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number), 3212 FuncBeginSym, Asm->getTargetData().getPointerSize()); 3213 3214 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false); 3215 3216 Asm->EmitAlignment(2); 3217 Asm->OutStreamer.EmitLabel(DebugFrameEnd); 3218} 3219 3220/// emitDebugPubNames - Emit visible names into a debug pubnames section. 3221/// 3222void DwarfDebug::emitDebugPubNames() { 3223 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3224 E = CUMap.end(); I != E; ++I) { 3225 CompileUnit *TheCU = I->second; 3226 // Start the dwarf pubnames section. 3227 Asm->OutStreamer.SwitchSection( 3228 Asm->getObjFileLowering().getDwarfPubNamesSection()); 3229 3230 Asm->OutStreamer.AddComment("Length of Public Names Info"); 3231 Asm->EmitLabelDifference( 3232 Asm->GetTempSymbol("pubnames_end", TheCU->getID()), 3233 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4); 3234 3235 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", 3236 TheCU->getID())); 3237 3238 Asm->OutStreamer.AddComment("DWARF Version"); 3239 Asm->EmitInt16(dwarf::DWARF_VERSION); 3240 3241 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 3242 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 3243 DwarfInfoSectionSym); 3244 3245 Asm->OutStreamer.AddComment("Compilation Unit Length"); 3246 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 3247 Asm->GetTempSymbol("info_begin", TheCU->getID()), 3248 4); 3249 3250 const StringMap<DIE*> &Globals = TheCU->getGlobals(); 3251 for (StringMap<DIE*>::const_iterator 3252 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 3253 const char *Name = GI->getKeyData(); 3254 DIE *Entity = GI->second; 3255 3256 Asm->OutStreamer.AddComment("DIE offset"); 3257 Asm->EmitInt32(Entity->getOffset()); 3258 3259 if (Asm->isVerbose()) 3260 Asm->OutStreamer.AddComment("External Name"); 3261 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0); 3262 } 3263 3264 Asm->OutStreamer.AddComment("End Mark"); 3265 Asm->EmitInt32(0); 3266 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", 3267 TheCU->getID())); 3268 } 3269} 3270 3271void DwarfDebug::emitDebugPubTypes() { 3272 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 3273 E = CUMap.end(); I != E; ++I) { 3274 CompileUnit *TheCU = I->second; 3275 // Start the dwarf pubnames section. 3276 Asm->OutStreamer.SwitchSection( 3277 Asm->getObjFileLowering().getDwarfPubTypesSection()); 3278 Asm->OutStreamer.AddComment("Length of Public Types Info"); 3279 Asm->EmitLabelDifference( 3280 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()), 3281 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4); 3282 3283 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 3284 TheCU->getID())); 3285 3286 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 3287 Asm->EmitInt16(dwarf::DWARF_VERSION); 3288 3289 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 3290 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 3291 DwarfInfoSectionSym); 3292 3293 Asm->OutStreamer.AddComment("Compilation Unit Length"); 3294 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 3295 Asm->GetTempSymbol("info_begin", TheCU->getID()), 3296 4); 3297 3298 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes(); 3299 for (StringMap<DIE*>::const_iterator 3300 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 3301 const char *Name = GI->getKeyData(); 3302 DIE * Entity = GI->second; 3303 3304 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 3305 Asm->EmitInt32(Entity->getOffset()); 3306 3307 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 3308 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0); 3309 } 3310 3311 Asm->OutStreamer.AddComment("End Mark"); 3312 Asm->EmitInt32(0); 3313 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 3314 TheCU->getID())); 3315 } 3316} 3317 3318/// emitDebugStr - Emit visible names into a debug str section. 3319/// 3320void DwarfDebug::emitDebugStr() { 3321 // Check to see if it is worth the effort. 3322 if (StringPool.empty()) return; 3323 3324 // Start the dwarf str section. 3325 Asm->OutStreamer.SwitchSection( 3326 Asm->getObjFileLowering().getDwarfStrSection()); 3327 3328 // Get all of the string pool entries and put them in an array by their ID so 3329 // we can sort them. 3330 SmallVector<std::pair<unsigned, 3331 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 3332 3333 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 3334 I = StringPool.begin(), E = StringPool.end(); I != E; ++I) 3335 Entries.push_back(std::make_pair(I->second.second, &*I)); 3336 3337 array_pod_sort(Entries.begin(), Entries.end()); 3338 3339 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 3340 // Emit a label for reference from debug information entries. 3341 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 3342 3343 // Emit the string itself. 3344 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/); 3345 } 3346} 3347 3348/// emitDebugLoc - Emit visible names into a debug loc section. 3349/// 3350void DwarfDebug::emitDebugLoc() { 3351 // Start the dwarf loc section. 3352 Asm->OutStreamer.SwitchSection( 3353 Asm->getObjFileLowering().getDwarfLocSection()); 3354} 3355 3356/// EmitDebugARanges - Emit visible names into a debug aranges section. 3357/// 3358void DwarfDebug::EmitDebugARanges() { 3359 // Start the dwarf aranges section. 3360 Asm->OutStreamer.SwitchSection( 3361 Asm->getObjFileLowering().getDwarfARangesSection()); 3362} 3363 3364/// emitDebugRanges - Emit visible names into a debug ranges section. 3365/// 3366void DwarfDebug::emitDebugRanges() { 3367 // Start the dwarf ranges section. 3368 Asm->OutStreamer.SwitchSection( 3369 Asm->getObjFileLowering().getDwarfRangesSection()); 3370 unsigned char Size = Asm->getTargetData().getPointerSize(); 3371 for (SmallVector<const MCSymbol *, 8>::iterator 3372 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end(); 3373 I != E; ++I) { 3374 if (*I) 3375 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0); 3376 else 3377 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 3378 } 3379} 3380 3381/// emitDebugMacInfo - Emit visible names into a debug macinfo section. 3382/// 3383void DwarfDebug::emitDebugMacInfo() { 3384 if (const MCSection *LineInfo = 3385 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 3386 // Start the dwarf macinfo section. 3387 Asm->OutStreamer.SwitchSection(LineInfo); 3388 } 3389} 3390 3391/// emitDebugInlineInfo - Emit inline info using following format. 3392/// Section Header: 3393/// 1. length of section 3394/// 2. Dwarf version number 3395/// 3. address size. 3396/// 3397/// Entries (one "entry" for each function that was inlined): 3398/// 3399/// 1. offset into __debug_str section for MIPS linkage name, if exists; 3400/// otherwise offset into __debug_str for regular function name. 3401/// 2. offset into __debug_str section for regular function name. 3402/// 3. an unsigned LEB128 number indicating the number of distinct inlining 3403/// instances for the function. 3404/// 3405/// The rest of the entry consists of a {die_offset, low_pc} pair for each 3406/// inlined instance; the die_offset points to the inlined_subroutine die in the 3407/// __debug_info section, and the low_pc is the starting address for the 3408/// inlining instance. 3409void DwarfDebug::emitDebugInlineInfo() { 3410 if (!Asm->MAI->doesDwarfUsesInlineInfoSection()) 3411 return; 3412 3413 if (!FirstCU) 3414 return; 3415 3416 Asm->OutStreamer.SwitchSection( 3417 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 3418 3419 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry"); 3420 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1), 3421 Asm->GetTempSymbol("debug_inlined_begin", 1), 4); 3422 3423 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1)); 3424 3425 Asm->OutStreamer.AddComment("Dwarf Version"); 3426 Asm->EmitInt16(dwarf::DWARF_VERSION); 3427 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 3428 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 3429 3430 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 3431 E = InlinedSPNodes.end(); I != E; ++I) { 3432 3433 const MDNode *Node = *I; 3434 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 3435 = InlineInfo.find(Node); 3436 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 3437 DISubprogram SP(Node); 3438 StringRef LName = SP.getLinkageName(); 3439 StringRef Name = SP.getName(); 3440 3441 Asm->OutStreamer.AddComment("MIPS linkage name"); 3442 if (LName.empty()) { 3443 Asm->OutStreamer.EmitBytes(Name, 0); 3444 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator. 3445 } else 3446 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)), 3447 DwarfStrSectionSym); 3448 3449 Asm->OutStreamer.AddComment("Function name"); 3450 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym); 3451 Asm->EmitULEB128(Labels.size(), "Inline count"); 3452 3453 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 3454 LE = Labels.end(); LI != LE; ++LI) { 3455 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 3456 Asm->EmitInt32(LI->second->getOffset()); 3457 3458 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc"); 3459 Asm->OutStreamer.EmitSymbolValue(LI->first, 3460 Asm->getTargetData().getPointerSize(),0); 3461 } 3462 } 3463 3464 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1)); 3465} 3466