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