DwarfDebug.cpp revision fd311dffa36fe6e48734ba28e6439dcb5b22f7fb
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. Ignore scopes that are not reachable. 2046 SmallVector<DbgScope *, 4> WorkList; 2047 WorkList.push_back(CurrentFnDbgScope); 2048 while (!WorkList.empty()) { 2049 DbgScope *S = WorkList.back(); WorkList.pop_back(); 2050 2051 SmallVector<DbgScope *, 4> &Children = S->getScopes(); 2052 if (!Children.empty()) 2053 for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(), 2054 SE = Children.end(); SI != SE; ++SI) 2055 WorkList.push_back(*SI); 2056 2057 if (S->isAbstractScope()) 2058 continue; 2059 const MachineInstr *MI = S->getFirstInsn(); 2060 assert (MI && "DbgScope does not have first instruction!"); 2061 2062 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI); 2063 if (IDI != DbgScopeBeginMap.end()) 2064 IDI->second.push_back(S); 2065 else 2066 DbgScopeBeginMap[MI].push_back(S); 2067 2068 MI = S->getLastInsn(); 2069 assert (MI && "DbgScope does not have last instruction!"); 2070 IDI = DbgScopeEndMap.find(MI); 2071 if (IDI != DbgScopeEndMap.end()) 2072 IDI->second.push_back(S); 2073 else 2074 DbgScopeEndMap[MI].push_back(S); 2075 } 2076 2077 return !DbgScopeMap.empty(); 2078} 2079 2080/// beginFunction - Gather pre-function debug information. Assumes being 2081/// emitted immediately after the function entry point. 2082void DwarfDebug::beginFunction(MachineFunction *MF) { 2083 this->MF = MF; 2084 2085 if (!ShouldEmitDwarfDebug()) return; 2086 2087 if (TimePassesIsEnabled) 2088 DebugTimer->startTimer(); 2089 2090 if (!extractScopeInformation(MF)) 2091 return; 2092 2093 collectVariableInfo(); 2094 2095 // Begin accumulating function debug information. 2096 MMI->BeginFunction(MF); 2097 2098 // Assumes in correct section after the entry point. 2099 EmitLabel("func_begin", ++SubprogramCount); 2100 2101 // Emit label for the implicitly defined dbg.stoppoint at the start of the 2102 // function. 2103 DebugLoc FDL = MF->getDefaultDebugLoc(); 2104 if (!FDL.isUnknown()) { 2105 DILocation DLT = MF->getDILocation(FDL); 2106 unsigned LabelID = 0; 2107 DISubprogram SP = getDISubprogram(DLT.getScope().getNode()); 2108 if (!SP.isNull()) 2109 LabelID = recordSourceLine(SP.getLineNumber(), 0, 2110 DLT.getScope().getNode()); 2111 else 2112 LabelID = recordSourceLine(DLT.getLineNumber(), 2113 DLT.getColumnNumber(), 2114 DLT.getScope().getNode()); 2115 Asm->printLabel(LabelID); 2116 O << '\n'; 2117 } 2118 if (TimePassesIsEnabled) 2119 DebugTimer->stopTimer(); 2120} 2121 2122/// endFunction - Gather and emit post-function debug information. 2123/// 2124void DwarfDebug::endFunction(MachineFunction *MF) { 2125 if (!ShouldEmitDwarfDebug()) return; 2126 2127 if (TimePassesIsEnabled) 2128 DebugTimer->startTimer(); 2129 2130 if (DbgScopeMap.empty()) 2131 return; 2132 2133 if (CurrentFnDbgScope) { 2134 // Define end label for subprogram. 2135 EmitLabel("func_end", SubprogramCount); 2136 2137 // Get function line info. 2138 if (!Lines.empty()) { 2139 // Get section line info. 2140 unsigned ID = SectionMap.insert(Asm->getCurrentSection()); 2141 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID); 2142 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1]; 2143 // Append the function info to section info. 2144 SectionLineInfos.insert(SectionLineInfos.end(), 2145 Lines.begin(), Lines.end()); 2146 } 2147 2148 // Construct abstract scopes. 2149 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2150 AE = AbstractScopesList.end(); AI != AE; ++AI) 2151 constructScopeDIE(*AI); 2152 2153 constructScopeDIE(CurrentFnDbgScope); 2154 2155 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount, 2156 MMI->getFrameMoves())); 2157 } 2158 2159 // Clear debug info 2160 CurrentFnDbgScope = NULL; 2161 DbgScopeMap.clear(); 2162 DbgScopeBeginMap.clear(); 2163 DbgScopeEndMap.clear(); 2164 ConcreteScopes.clear(); 2165 AbstractScopesList.clear(); 2166 Lines.clear(); 2167 2168 if (TimePassesIsEnabled) 2169 DebugTimer->stopTimer(); 2170} 2171 2172/// recordSourceLine - Records location information and associates it with a 2173/// label. Returns a unique label ID used to generate a label and provide 2174/// correspondence to the source line list. 2175unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, 2176 MDNode *S) { 2177 if (!MMI) 2178 return 0; 2179 2180 if (TimePassesIsEnabled) 2181 DebugTimer->startTimer(); 2182 2183 StringRef Dir; 2184 StringRef Fn; 2185 2186 DIDescriptor Scope(S); 2187 if (Scope.isCompileUnit()) { 2188 DICompileUnit CU(S); 2189 Dir = CU.getDirectory(); 2190 Fn = CU.getFilename(); 2191 } else if (Scope.isSubprogram()) { 2192 DISubprogram SP(S); 2193 Dir = SP.getDirectory(); 2194 Fn = SP.getFilename(); 2195 } else if (Scope.isLexicalBlock()) { 2196 DILexicalBlock DB(S); 2197 Dir = DB.getDirectory(); 2198 Fn = DB.getFilename(); 2199 } else 2200 assert (0 && "Unexpected scope info"); 2201 2202 unsigned Src = GetOrCreateSourceID(Dir, Fn); 2203 unsigned ID = MMI->NextLabelID(); 2204 Lines.push_back(SrcLineInfo(Line, Col, Src, ID)); 2205 2206 if (TimePassesIsEnabled) 2207 DebugTimer->stopTimer(); 2208 2209 return ID; 2210} 2211 2212/// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be 2213/// timed. Look up the source id with the given directory and source file 2214/// names. If none currently exists, create a new id and insert it in the 2215/// SourceIds map. This can update DirectoryNames and SourceFileNames maps as 2216/// well. 2217unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName, 2218 const std::string &FileName) { 2219 if (TimePassesIsEnabled) 2220 DebugTimer->startTimer(); 2221 2222 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str()); 2223 2224 if (TimePassesIsEnabled) 2225 DebugTimer->stopTimer(); 2226 2227 return SrcId; 2228} 2229 2230//===----------------------------------------------------------------------===// 2231// Emit Methods 2232//===----------------------------------------------------------------------===// 2233 2234/// computeSizeAndOffset - Compute the size and offset of a DIE. 2235/// 2236unsigned 2237DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) { 2238 // Get the children. 2239 const std::vector<DIE *> &Children = Die->getChildren(); 2240 2241 // If not last sibling and has children then add sibling offset attribute. 2242 if (!Last && !Children.empty()) Die->addSiblingOffset(); 2243 2244 // Record the abbreviation. 2245 assignAbbrevNumber(Die->getAbbrev()); 2246 2247 // Get the abbreviation for this DIE. 2248 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2249 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2250 2251 // Set DIE offset 2252 Die->setOffset(Offset); 2253 2254 // Start the size with the size of abbreviation code. 2255 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 2256 2257 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2258 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2259 2260 // Size the DIE attribute values. 2261 for (unsigned i = 0, N = Values.size(); i < N; ++i) 2262 // Size attribute value. 2263 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm()); 2264 2265 // Size the DIE children if any. 2266 if (!Children.empty()) { 2267 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 2268 "Children flag not set"); 2269 2270 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2271 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M); 2272 2273 // End of children marker. 2274 Offset += sizeof(int8_t); 2275 } 2276 2277 Die->setSize(Offset - Die->getOffset()); 2278 return Offset; 2279} 2280 2281/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 2282/// 2283void DwarfDebug::computeSizeAndOffsets() { 2284 // Compute size of compile unit header. 2285 static unsigned Offset = 2286 sizeof(int32_t) + // Length of Compilation Unit Info 2287 sizeof(int16_t) + // DWARF version number 2288 sizeof(int32_t) + // Offset Into Abbrev. Section 2289 sizeof(int8_t); // Pointer Size (in bytes) 2290 2291 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true); 2292 CompileUnitOffsets[ModuleCU] = 0; 2293} 2294 2295/// emitInitial - Emit initial Dwarf declarations. This is necessary for cc 2296/// tools to recognize the object file contains Dwarf information. 2297void DwarfDebug::emitInitial() { 2298 // Check to see if we already emitted intial headers. 2299 if (didInitial) return; 2300 didInitial = true; 2301 2302 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 2303 2304 // Dwarf sections base addresses. 2305 if (MAI->doesDwarfRequireFrameSection()) { 2306 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection()); 2307 EmitLabel("section_debug_frame", 0); 2308 } 2309 2310 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection()); 2311 EmitLabel("section_info", 0); 2312 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection()); 2313 EmitLabel("section_abbrev", 0); 2314 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection()); 2315 EmitLabel("section_aranges", 0); 2316 2317 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) { 2318 Asm->OutStreamer.SwitchSection(LineInfoDirective); 2319 EmitLabel("section_macinfo", 0); 2320 } 2321 2322 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection()); 2323 EmitLabel("section_line", 0); 2324 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection()); 2325 EmitLabel("section_loc", 0); 2326 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection()); 2327 EmitLabel("section_pubnames", 0); 2328 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection()); 2329 EmitLabel("section_pubtypes", 0); 2330 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection()); 2331 EmitLabel("section_str", 0); 2332 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection()); 2333 EmitLabel("section_ranges", 0); 2334 2335 Asm->OutStreamer.SwitchSection(TLOF.getTextSection()); 2336 EmitLabel("text_begin", 0); 2337 Asm->OutStreamer.SwitchSection(TLOF.getDataSection()); 2338 EmitLabel("data_begin", 0); 2339} 2340 2341/// emitDIE - Recusively Emits a debug information entry. 2342/// 2343void DwarfDebug::emitDIE(DIE *Die) { 2344 // Get the abbreviation for this DIE. 2345 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2346 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2347 2348 Asm->EOL(); 2349 2350 // Emit the code (index) for the abbreviation. 2351 Asm->EmitULEB128Bytes(AbbrevNumber); 2352 2353 Asm->EOL("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 2354 Twine::utohexstr(Die->getOffset()) + ":0x" + 2355 Twine::utohexstr(Die->getSize()) + " " + 2356 dwarf::TagString(Abbrev->getTag())); 2357 2358 SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2359 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2360 2361 // Emit the DIE attribute values. 2362 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 2363 unsigned Attr = AbbrevData[i].getAttribute(); 2364 unsigned Form = AbbrevData[i].getForm(); 2365 assert(Form && "Too many attributes for DIE (check abbreviation)"); 2366 2367 switch (Attr) { 2368 case dwarf::DW_AT_sibling: 2369 Asm->EmitInt32(Die->getSiblingOffset()); 2370 break; 2371 case dwarf::DW_AT_abstract_origin: { 2372 DIEEntry *E = cast<DIEEntry>(Values[i]); 2373 DIE *Origin = E->getEntry(); 2374 unsigned Addr = Origin->getOffset(); 2375 Asm->EmitInt32(Addr); 2376 break; 2377 } 2378 default: 2379 // Emit an attribute using the defined form. 2380 Values[i]->EmitValue(this, Form); 2381 break; 2382 } 2383 2384 Asm->EOL(dwarf::AttributeString(Attr)); 2385 } 2386 2387 // Emit the DIE children if any. 2388 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 2389 const std::vector<DIE *> &Children = Die->getChildren(); 2390 2391 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2392 emitDIE(Children[j]); 2393 2394 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark"); 2395 } 2396} 2397 2398/// emitDebugInfo - Emit the debug info section. 2399/// 2400void DwarfDebug::emitDebugInfo() { 2401 // Start debug info section. 2402 Asm->OutStreamer.SwitchSection( 2403 Asm->getObjFileLowering().getDwarfInfoSection()); 2404 DIE *Die = ModuleCU->getCUDie(); 2405 2406 // Emit the compile units header. 2407 EmitLabel("info_begin", ModuleCU->getID()); 2408 2409 // Emit size of content not including length itself 2410 unsigned ContentSize = Die->getSize() + 2411 sizeof(int16_t) + // DWARF version number 2412 sizeof(int32_t) + // Offset Into Abbrev. Section 2413 sizeof(int8_t) + // Pointer Size (in bytes) 2414 sizeof(int32_t); // FIXME - extra pad for gdb bug. 2415 2416 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info"); 2417 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number"); 2418 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false); 2419 Asm->EOL("Offset Into Abbrev. Section"); 2420 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)"); 2421 2422 emitDIE(Die); 2423 // FIXME - extra padding for gdb bug. 2424 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2425 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2426 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2427 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2428 EmitLabel("info_end", ModuleCU->getID()); 2429 2430 Asm->EOL(); 2431} 2432 2433/// emitAbbreviations - Emit the abbreviation section. 2434/// 2435void DwarfDebug::emitAbbreviations() const { 2436 // Check to see if it is worth the effort. 2437 if (!Abbreviations.empty()) { 2438 // Start the debug abbrev section. 2439 Asm->OutStreamer.SwitchSection( 2440 Asm->getObjFileLowering().getDwarfAbbrevSection()); 2441 2442 EmitLabel("abbrev_begin", 0); 2443 2444 // For each abbrevation. 2445 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 2446 // Get abbreviation data 2447 const DIEAbbrev *Abbrev = Abbreviations[i]; 2448 2449 // Emit the abbrevations code (base 1 index.) 2450 Asm->EmitULEB128Bytes(Abbrev->getNumber()); 2451 Asm->EOL("Abbreviation Code"); 2452 2453 // Emit the abbreviations data. 2454 Abbrev->Emit(Asm); 2455 2456 Asm->EOL(); 2457 } 2458 2459 // Mark end of abbreviations. 2460 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)"); 2461 2462 EmitLabel("abbrev_end", 0); 2463 Asm->EOL(); 2464 } 2465} 2466 2467/// emitEndOfLineMatrix - Emit the last address of the section and the end of 2468/// the line matrix. 2469/// 2470void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 2471 // Define last address of section. 2472 Asm->EmitInt8(0); Asm->EOL("Extended Op"); 2473 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size"); 2474 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address"); 2475 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label"); 2476 2477 // Mark end of matrix. 2478 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence"); 2479 Asm->EmitULEB128Bytes(1); Asm->EOL(); 2480 Asm->EmitInt8(1); Asm->EOL(); 2481} 2482 2483/// emitDebugLines - Emit source line information. 2484/// 2485void DwarfDebug::emitDebugLines() { 2486 // If the target is using .loc/.file, the assembler will be emitting the 2487 // .debug_line table automatically. 2488 if (MAI->hasDotLocAndDotFile()) 2489 return; 2490 2491 // Minimum line delta, thus ranging from -10..(255-10). 2492 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1); 2493 // Maximum line delta, thus ranging from -10..(255-10). 2494 const int MaxLineDelta = 255 + MinLineDelta; 2495 2496 // Start the dwarf line section. 2497 Asm->OutStreamer.SwitchSection( 2498 Asm->getObjFileLowering().getDwarfLineSection()); 2499 2500 // Construct the section header. 2501 EmitDifference("line_end", 0, "line_begin", 0, true); 2502 Asm->EOL("Length of Source Line Info"); 2503 EmitLabel("line_begin", 0); 2504 2505 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number"); 2506 2507 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true); 2508 Asm->EOL("Prolog Length"); 2509 EmitLabel("line_prolog_begin", 0); 2510 2511 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length"); 2512 2513 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag"); 2514 2515 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)"); 2516 2517 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)"); 2518 2519 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base"); 2520 2521 // Line number standard opcode encodings argument count 2522 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count"); 2523 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count"); 2524 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count"); 2525 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count"); 2526 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count"); 2527 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count"); 2528 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count"); 2529 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count"); 2530 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count"); 2531 2532 // Emit directories. 2533 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) { 2534 Asm->EmitString(getSourceDirectoryName(DI)); 2535 Asm->EOL("Directory"); 2536 } 2537 2538 Asm->EmitInt8(0); Asm->EOL("End of directories"); 2539 2540 // Emit files. 2541 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) { 2542 // Remember source id starts at 1. 2543 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI); 2544 Asm->EmitString(getSourceFileName(Id.second)); 2545 Asm->EOL("Source"); 2546 Asm->EmitULEB128Bytes(Id.first); 2547 Asm->EOL("Directory #"); 2548 Asm->EmitULEB128Bytes(0); 2549 Asm->EOL("Mod date"); 2550 Asm->EmitULEB128Bytes(0); 2551 Asm->EOL("File size"); 2552 } 2553 2554 Asm->EmitInt8(0); Asm->EOL("End of files"); 2555 2556 EmitLabel("line_prolog_end", 0); 2557 2558 // A sequence for each text section. 2559 unsigned SecSrcLinesSize = SectionSourceLines.size(); 2560 2561 for (unsigned j = 0; j < SecSrcLinesSize; ++j) { 2562 // Isolate current sections line info. 2563 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j]; 2564 2565 /*if (Asm->isVerbose()) { 2566 const MCSection *S = SectionMap[j + 1]; 2567 O << '\t' << MAI->getCommentString() << " Section" 2568 << S->getName() << '\n'; 2569 }*/ 2570 Asm->EOL(); 2571 2572 // Dwarf assumes we start with first line of first source file. 2573 unsigned Source = 1; 2574 unsigned Line = 1; 2575 2576 // Construct rows of the address, source, line, column matrix. 2577 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) { 2578 const SrcLineInfo &LineInfo = LineInfos[i]; 2579 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID()); 2580 if (!LabelID) continue; 2581 2582 if (LineInfo.getLine() == 0) continue; 2583 2584 if (!Asm->isVerbose()) 2585 Asm->EOL(); 2586 else { 2587 std::pair<unsigned, unsigned> SourceID = 2588 getSourceDirectoryAndFileIds(LineInfo.getSourceID()); 2589 O << '\t' << MAI->getCommentString() << ' ' 2590 << getSourceDirectoryName(SourceID.first) << '/' 2591 << getSourceFileName(SourceID.second) 2592 << ':' << utostr_32(LineInfo.getLine()) << '\n'; 2593 } 2594 2595 // Define the line address. 2596 Asm->EmitInt8(0); Asm->EOL("Extended Op"); 2597 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size"); 2598 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address"); 2599 EmitReference("label", LabelID); Asm->EOL("Location label"); 2600 2601 // If change of source, then switch to the new source. 2602 if (Source != LineInfo.getSourceID()) { 2603 Source = LineInfo.getSourceID(); 2604 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file"); 2605 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source"); 2606 } 2607 2608 // If change of line. 2609 if (Line != LineInfo.getLine()) { 2610 // Determine offset. 2611 int Offset = LineInfo.getLine() - Line; 2612 int Delta = Offset - MinLineDelta; 2613 2614 // Update line. 2615 Line = LineInfo.getLine(); 2616 2617 // If delta is small enough and in range... 2618 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { 2619 // ... then use fast opcode. 2620 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta"); 2621 } else { 2622 // ... otherwise use long hand. 2623 Asm->EmitInt8(dwarf::DW_LNS_advance_line); 2624 Asm->EOL("DW_LNS_advance_line"); 2625 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset"); 2626 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy"); 2627 } 2628 } else { 2629 // Copy the previous row (different address or source) 2630 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy"); 2631 } 2632 } 2633 2634 emitEndOfLineMatrix(j + 1); 2635 } 2636 2637 if (SecSrcLinesSize == 0) 2638 // Because we're emitting a debug_line section, we still need a line 2639 // table. The linker and friends expect it to exist. If there's nothing to 2640 // put into it, emit an empty table. 2641 emitEndOfLineMatrix(1); 2642 2643 EmitLabel("line_end", 0); 2644 Asm->EOL(); 2645} 2646 2647/// emitCommonDebugFrame - Emit common frame info into a debug frame section. 2648/// 2649void DwarfDebug::emitCommonDebugFrame() { 2650 if (!MAI->doesDwarfRequireFrameSection()) 2651 return; 2652 2653 int stackGrowth = 2654 Asm->TM.getFrameInfo()->getStackGrowthDirection() == 2655 TargetFrameInfo::StackGrowsUp ? 2656 TD->getPointerSize() : -TD->getPointerSize(); 2657 2658 // Start the dwarf frame section. 2659 Asm->OutStreamer.SwitchSection( 2660 Asm->getObjFileLowering().getDwarfFrameSection()); 2661 2662 EmitLabel("debug_frame_common", 0); 2663 EmitDifference("debug_frame_common_end", 0, 2664 "debug_frame_common_begin", 0, true); 2665 Asm->EOL("Length of Common Information Entry"); 2666 2667 EmitLabel("debug_frame_common_begin", 0); 2668 Asm->EmitInt32((int)dwarf::DW_CIE_ID); 2669 Asm->EOL("CIE Identifier Tag"); 2670 Asm->EmitInt8(dwarf::DW_CIE_VERSION); 2671 Asm->EOL("CIE Version"); 2672 Asm->EmitString(""); 2673 Asm->EOL("CIE Augmentation"); 2674 Asm->EmitULEB128Bytes(1); 2675 Asm->EOL("CIE Code Alignment Factor"); 2676 Asm->EmitSLEB128Bytes(stackGrowth); 2677 Asm->EOL("CIE Data Alignment Factor"); 2678 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); 2679 Asm->EOL("CIE RA Column"); 2680 2681 std::vector<MachineMove> Moves; 2682 RI->getInitialFrameState(Moves); 2683 2684 EmitFrameMoves(NULL, 0, Moves, false); 2685 2686 Asm->EmitAlignment(2, 0, 0, false); 2687 EmitLabel("debug_frame_common_end", 0); 2688 2689 Asm->EOL(); 2690} 2691 2692/// emitFunctionDebugFrame - Emit per function frame info into a debug frame 2693/// section. 2694void 2695DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){ 2696 if (!MAI->doesDwarfRequireFrameSection()) 2697 return; 2698 2699 // Start the dwarf frame section. 2700 Asm->OutStreamer.SwitchSection( 2701 Asm->getObjFileLowering().getDwarfFrameSection()); 2702 2703 EmitDifference("debug_frame_end", DebugFrameInfo.Number, 2704 "debug_frame_begin", DebugFrameInfo.Number, true); 2705 Asm->EOL("Length of Frame Information Entry"); 2706 2707 EmitLabel("debug_frame_begin", DebugFrameInfo.Number); 2708 2709 EmitSectionOffset("debug_frame_common", "section_debug_frame", 2710 0, 0, true, false); 2711 Asm->EOL("FDE CIE offset"); 2712 2713 EmitReference("func_begin", DebugFrameInfo.Number); 2714 Asm->EOL("FDE initial location"); 2715 EmitDifference("func_end", DebugFrameInfo.Number, 2716 "func_begin", DebugFrameInfo.Number); 2717 Asm->EOL("FDE address range"); 2718 2719 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves, 2720 false); 2721 2722 Asm->EmitAlignment(2, 0, 0, false); 2723 EmitLabel("debug_frame_end", DebugFrameInfo.Number); 2724 2725 Asm->EOL(); 2726} 2727 2728/// emitDebugPubNames - Emit visible names into a debug pubnames section. 2729/// 2730void DwarfDebug::emitDebugPubNames() { 2731 // Start the dwarf pubnames section. 2732 Asm->OutStreamer.SwitchSection( 2733 Asm->getObjFileLowering().getDwarfPubNamesSection()); 2734 2735 EmitDifference("pubnames_end", ModuleCU->getID(), 2736 "pubnames_begin", ModuleCU->getID(), true); 2737 Asm->EOL("Length of Public Names Info"); 2738 2739 EmitLabel("pubnames_begin", ModuleCU->getID()); 2740 2741 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version"); 2742 2743 EmitSectionOffset("info_begin", "section_info", 2744 ModuleCU->getID(), 0, true, false); 2745 Asm->EOL("Offset of Compilation Unit Info"); 2746 2747 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(), 2748 true); 2749 Asm->EOL("Compilation Unit Length"); 2750 2751 const StringMap<DIE*> &Globals = ModuleCU->getGlobals(); 2752 for (StringMap<DIE*>::const_iterator 2753 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2754 const char *Name = GI->getKeyData(); 2755 DIE * Entity = GI->second; 2756 2757 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset"); 2758 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name"); 2759 } 2760 2761 Asm->EmitInt32(0); Asm->EOL("End Mark"); 2762 EmitLabel("pubnames_end", ModuleCU->getID()); 2763 2764 Asm->EOL(); 2765} 2766 2767void DwarfDebug::emitDebugPubTypes() { 2768 // Start the dwarf pubnames section. 2769 Asm->OutStreamer.SwitchSection( 2770 Asm->getObjFileLowering().getDwarfPubTypesSection()); 2771 EmitDifference("pubtypes_end", ModuleCU->getID(), 2772 "pubtypes_begin", ModuleCU->getID(), true); 2773 Asm->EOL("Length of Public Types Info"); 2774 2775 EmitLabel("pubtypes_begin", ModuleCU->getID()); 2776 2777 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version"); 2778 2779 EmitSectionOffset("info_begin", "section_info", 2780 ModuleCU->getID(), 0, true, false); 2781 Asm->EOL("Offset of Compilation ModuleCU Info"); 2782 2783 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(), 2784 true); 2785 Asm->EOL("Compilation ModuleCU Length"); 2786 2787 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes(); 2788 for (StringMap<DIE*>::const_iterator 2789 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2790 const char *Name = GI->getKeyData(); 2791 DIE * Entity = GI->second; 2792 2793 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset"); 2794 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name"); 2795 } 2796 2797 Asm->EmitInt32(0); Asm->EOL("End Mark"); 2798 EmitLabel("pubtypes_end", ModuleCU->getID()); 2799 2800 Asm->EOL(); 2801} 2802 2803/// emitDebugStr - Emit visible names into a debug str section. 2804/// 2805void DwarfDebug::emitDebugStr() { 2806 // Check to see if it is worth the effort. 2807 if (!StringPool.empty()) { 2808 // Start the dwarf str section. 2809 Asm->OutStreamer.SwitchSection( 2810 Asm->getObjFileLowering().getDwarfStrSection()); 2811 2812 // For each of strings in the string pool. 2813 for (unsigned StringID = 1, N = StringPool.size(); 2814 StringID <= N; ++StringID) { 2815 // Emit a label for reference from debug information entries. 2816 EmitLabel("string", StringID); 2817 2818 // Emit the string itself. 2819 const std::string &String = StringPool[StringID]; 2820 Asm->EmitString(String); Asm->EOL(); 2821 } 2822 2823 Asm->EOL(); 2824 } 2825} 2826 2827/// emitDebugLoc - Emit visible names into a debug loc section. 2828/// 2829void DwarfDebug::emitDebugLoc() { 2830 // Start the dwarf loc section. 2831 Asm->OutStreamer.SwitchSection( 2832 Asm->getObjFileLowering().getDwarfLocSection()); 2833 Asm->EOL(); 2834} 2835 2836/// EmitDebugARanges - Emit visible names into a debug aranges section. 2837/// 2838void DwarfDebug::EmitDebugARanges() { 2839 // Start the dwarf aranges section. 2840 Asm->OutStreamer.SwitchSection( 2841 Asm->getObjFileLowering().getDwarfARangesSection()); 2842 2843 // FIXME - Mock up 2844#if 0 2845 CompileUnit *Unit = GetBaseCompileUnit(); 2846 2847 // Don't include size of length 2848 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info"); 2849 2850 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version"); 2851 2852 EmitReference("info_begin", Unit->getID()); 2853 Asm->EOL("Offset of Compilation Unit Info"); 2854 2855 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address"); 2856 2857 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor"); 2858 2859 Asm->EmitInt16(0); Asm->EOL("Pad (1)"); 2860 Asm->EmitInt16(0); Asm->EOL("Pad (2)"); 2861 2862 // Range 1 2863 EmitReference("text_begin", 0); Asm->EOL("Address"); 2864 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length"); 2865 2866 Asm->EmitInt32(0); Asm->EOL("EOM (1)"); 2867 Asm->EmitInt32(0); Asm->EOL("EOM (2)"); 2868#endif 2869 2870 Asm->EOL(); 2871} 2872 2873/// emitDebugRanges - Emit visible names into a debug ranges section. 2874/// 2875void DwarfDebug::emitDebugRanges() { 2876 // Start the dwarf ranges section. 2877 Asm->OutStreamer.SwitchSection( 2878 Asm->getObjFileLowering().getDwarfRangesSection()); 2879 Asm->EOL(); 2880} 2881 2882/// emitDebugMacInfo - Emit visible names into a debug macinfo section. 2883/// 2884void DwarfDebug::emitDebugMacInfo() { 2885 if (const MCSection *LineInfo = 2886 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 2887 // Start the dwarf macinfo section. 2888 Asm->OutStreamer.SwitchSection(LineInfo); 2889 Asm->EOL(); 2890 } 2891} 2892 2893/// emitDebugInlineInfo - Emit inline info using following format. 2894/// Section Header: 2895/// 1. length of section 2896/// 2. Dwarf version number 2897/// 3. address size. 2898/// 2899/// Entries (one "entry" for each function that was inlined): 2900/// 2901/// 1. offset into __debug_str section for MIPS linkage name, if exists; 2902/// otherwise offset into __debug_str for regular function name. 2903/// 2. offset into __debug_str section for regular function name. 2904/// 3. an unsigned LEB128 number indicating the number of distinct inlining 2905/// instances for the function. 2906/// 2907/// The rest of the entry consists of a {die_offset, low_pc} pair for each 2908/// inlined instance; the die_offset points to the inlined_subroutine die in the 2909/// __debug_info section, and the low_pc is the starting address for the 2910/// inlining instance. 2911void DwarfDebug::emitDebugInlineInfo() { 2912 if (!MAI->doesDwarfUsesInlineInfoSection()) 2913 return; 2914 2915 if (!ModuleCU) 2916 return; 2917 2918 Asm->OutStreamer.SwitchSection( 2919 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 2920 Asm->EOL(); 2921 EmitDifference("debug_inlined_end", 1, 2922 "debug_inlined_begin", 1, true); 2923 Asm->EOL("Length of Debug Inlined Information Entry"); 2924 2925 EmitLabel("debug_inlined_begin", 1); 2926 2927 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version"); 2928 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)"); 2929 2930 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 2931 E = InlinedSPNodes.end(); I != E; ++I) { 2932 2933 MDNode *Node = *I; 2934 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 2935 = InlineInfo.find(Node); 2936 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 2937 DISubprogram SP(Node); 2938 StringRef LName = SP.getLinkageName(); 2939 StringRef Name = SP.getName(); 2940 2941 if (LName.empty()) 2942 Asm->EmitString(Name); 2943 else 2944 EmitSectionOffset("string", "section_str", 2945 StringPool.idFor(getRealLinkageName(LName)), false, true); 2946 2947 Asm->EOL("MIPS linkage name"); 2948 EmitSectionOffset("string", "section_str", 2949 StringPool.idFor(Name), false, true); 2950 Asm->EOL("Function name"); 2951 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count"); 2952 2953 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 2954 LE = Labels.end(); LI != LE; ++LI) { 2955 DIE *SP = LI->second; 2956 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset"); 2957 2958 if (TD->getPointerSize() == sizeof(int32_t)) 2959 O << MAI->getData32bitsDirective(); 2960 else 2961 O << MAI->getData64bitsDirective(); 2962 2963 PrintLabelName("label", LI->first); Asm->EOL("low_pc"); 2964 } 2965 } 2966 2967 EmitLabel("debug_inlined_end", 1); 2968 Asm->EOL(); 2969} 2970