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