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