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