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