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