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