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