DwarfDebug.cpp revision f8b72ca6c80d7fb242d23d9b2aebb1937e6fff60
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/TargetData.h" 22#include "llvm/Target/TargetFrameInfo.h" 23#include "llvm/Target/TargetLoweringObjectFile.h" 24#include "llvm/Target/TargetRegisterInfo.h" 25#include "llvm/ADT/StringExtras.h" 26#include "llvm/Support/Debug.h" 27#include "llvm/Support/ErrorHandling.h" 28#include "llvm/Support/Mangler.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 ValueMap<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 ValueMap<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 ValueMap<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 WeakVH 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 std::string &Label) { 365 DIEValue *Value = new DIEObjectLabel(Label); 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, WeakVH(SP.getContainingType().getNode()))); 1166 } 1167 1168 if (MakeDecl || !SP.isDefinition()) { 1169 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1170 1171 // Add arguments. Do not add arguments for subprogram definition. They will 1172 // be handled while processing variables. 1173 DICompositeType SPTy = SP.getType(); 1174 DIArray Args = SPTy.getTypeArray(); 1175 unsigned SPTag = SPTy.getTag(); 1176 1177 if (SPTag == dwarf::DW_TAG_subroutine_type) 1178 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1179 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1180 addType(Arg, DIType(Args.getElement(i).getNode())); 1181 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ?? 1182 SPDie->addChild(Arg); 1183 } 1184 } 1185 1186 // DW_TAG_inlined_subroutine may refer to this DIE. 1187 ModuleCU->insertDIE(SP.getNode(), SPDie); 1188 return SPDie; 1189} 1190 1191/// findCompileUnit - Get the compile unit for the given descriptor. 1192/// 1193CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) { 1194 DenseMap<Value *, CompileUnit *>::const_iterator I = 1195 CompileUnitMap.find(Unit.getNode()); 1196 if (I == CompileUnitMap.end()) 1197 return constructCompileUnit(Unit.getNode()); 1198 return I->second; 1199} 1200 1201/// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction. 1202/// Initialize scope and update scope hierarchy. 1203DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI, 1204 MDNode *InlinedAt) { 1205 assert (N && "Invalid Scope encoding!"); 1206 assert (MI && "Missing machine instruction!"); 1207 bool GetConcreteScope = (MI && InlinedAt); 1208 1209 DbgScope *NScope = NULL; 1210 1211 if (InlinedAt) 1212 NScope = DbgScopeMap.lookup(InlinedAt); 1213 else 1214 NScope = DbgScopeMap.lookup(N); 1215 assert (NScope && "Unable to find working scope!"); 1216 1217 if (NScope->getFirstInsn()) 1218 return NScope; 1219 1220 DbgScope *Parent = NULL; 1221 if (GetConcreteScope) { 1222 DILocation IL(InlinedAt); 1223 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI, 1224 IL.getOrigLocation().getNode()); 1225 assert (Parent && "Unable to find Parent scope!"); 1226 NScope->setParent(Parent); 1227 Parent->addScope(NScope); 1228 } else if (DIDescriptor(N).isLexicalBlock()) { 1229 DILexicalBlock DB(N); 1230 if (!DB.getContext().isNull()) { 1231 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt); 1232 NScope->setParent(Parent); 1233 Parent->addScope(NScope); 1234 } 1235 } 1236 1237 NScope->setFirstInsn(MI); 1238 1239 if (!Parent && !InlinedAt) { 1240 StringRef SPName = DISubprogram(N).getLinkageName(); 1241 if (SPName == MF->getFunction()->getName()) 1242 CurrentFnDbgScope = NScope; 1243 } 1244 1245 if (GetConcreteScope) { 1246 ConcreteScopes[InlinedAt] = NScope; 1247 getOrCreateAbstractScope(N); 1248 } 1249 1250 return NScope; 1251} 1252 1253DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) { 1254 assert (N && "Invalid Scope encoding!"); 1255 1256 DbgScope *AScope = AbstractScopes.lookup(N); 1257 if (AScope) 1258 return AScope; 1259 1260 DbgScope *Parent = NULL; 1261 1262 DIDescriptor Scope(N); 1263 if (Scope.isLexicalBlock()) { 1264 DILexicalBlock DB(N); 1265 DIDescriptor ParentDesc = DB.getContext(); 1266 if (!ParentDesc.isNull()) 1267 Parent = getOrCreateAbstractScope(ParentDesc.getNode()); 1268 } 1269 1270 AScope = new DbgScope(Parent, DIDescriptor(N), NULL); 1271 1272 if (Parent) 1273 Parent->addScope(AScope); 1274 AScope->setAbstractScope(); 1275 AbstractScopes[N] = AScope; 1276 if (DIDescriptor(N).isSubprogram()) 1277 AbstractScopesList.push_back(AScope); 1278 return AScope; 1279} 1280 1281/// updateSubprogramScopeDIE - Find DIE for the given subprogram and 1282/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes. 1283/// If there are global variables in this scope then create and insert 1284/// DIEs for these variables. 1285DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) { 1286 1287 DIE *SPDie = ModuleCU->getDIE(SPNode); 1288 assert (SPDie && "Unable to find subprogram DIE!"); 1289 DISubprogram SP(SPNode); 1290 if (SP.isDefinition() && !SP.getContext().isCompileUnit()) { 1291 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1292 // Add arguments. 1293 DICompositeType SPTy = SP.getType(); 1294 DIArray Args = SPTy.getTypeArray(); 1295 unsigned SPTag = SPTy.getTag(); 1296 if (SPTag == dwarf::DW_TAG_subroutine_type) 1297 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1298 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1299 addType(Arg, DIType(Args.getElement(i).getNode())); 1300 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ?? 1301 SPDie->addChild(Arg); 1302 } 1303 DIE *SPDeclDie = SPDie; 1304 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1305 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4, 1306 SPDeclDie); 1307 ModuleCU->addDie(SPDie); 1308 } 1309 1310 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 1311 DWLabel("func_begin", SubprogramCount)); 1312 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, 1313 DWLabel("func_end", SubprogramCount)); 1314 MachineLocation Location(RI->getFrameRegister(*MF)); 1315 addAddress(SPDie, dwarf::DW_AT_frame_base, Location); 1316 1317 if (!DISubprogram(SPNode).isLocalToUnit()) 1318 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 1319 1320 return SPDie; 1321} 1322 1323/// constructLexicalScope - Construct new DW_TAG_lexical_block 1324/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels. 1325DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) { 1326 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID()); 1327 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID()); 1328 1329 // Ignore empty scopes. 1330 if (StartID == EndID && StartID != 0) 1331 return NULL; 1332 1333 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block); 1334 if (Scope->isAbstractScope()) 1335 return ScopeDIE; 1336 1337 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 1338 StartID ? 1339 DWLabel("label", StartID) 1340 : DWLabel("func_begin", SubprogramCount)); 1341 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, 1342 EndID ? 1343 DWLabel("label", EndID) 1344 : DWLabel("func_end", SubprogramCount)); 1345 1346 1347 1348 return ScopeDIE; 1349} 1350 1351/// constructInlinedScopeDIE - This scope represents inlined body of 1352/// a function. Construct DIE to represent this concrete inlined copy 1353/// of the function. 1354DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) { 1355 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID()); 1356 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID()); 1357 assert (StartID && "Invalid starting label for an inlined scope!"); 1358 assert (EndID && "Invalid end label for an inlined scope!"); 1359 // Ignore empty scopes. 1360 if (StartID == EndID && StartID != 0) 1361 return NULL; 1362 1363 DIScope DS(Scope->getScopeNode()); 1364 if (DS.isNull()) 1365 return NULL; 1366 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine); 1367 1368 DISubprogram InlinedSP = getDISubprogram(DS.getNode()); 1369 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode()); 1370 assert (OriginDIE && "Unable to find Origin DIE!"); 1371 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, 1372 dwarf::DW_FORM_ref4, OriginDIE); 1373 1374 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 1375 DWLabel("label", StartID)); 1376 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, 1377 DWLabel("label", EndID)); 1378 1379 InlinedSubprogramDIEs.insert(OriginDIE); 1380 1381 // Track the start label for this inlined function. 1382 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator 1383 I = InlineInfo.find(InlinedSP.getNode()); 1384 1385 if (I == InlineInfo.end()) { 1386 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID, 1387 ScopeDIE)); 1388 InlinedSPNodes.push_back(InlinedSP.getNode()); 1389 } else 1390 I->second.push_back(std::make_pair(StartID, ScopeDIE)); 1391 1392 StringPool.insert(InlinedSP.getName()); 1393 StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName())); 1394 1395 DILocation DL(Scope->getInlinedAt()); 1396 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID()); 1397 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber()); 1398 1399 return ScopeDIE; 1400} 1401 1402 1403/// constructVariableDIE - Construct a DIE for the given DbgVariable. 1404DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) { 1405 // Get the descriptor. 1406 const DIVariable &VD = DV->getVariable(); 1407 StringRef Name = VD.getName(); 1408 if (Name.empty()) 1409 return NULL; 1410 1411 // Translate tag to proper Dwarf tag. The result variable is dropped for 1412 // now. 1413 unsigned Tag; 1414 switch (VD.getTag()) { 1415 case dwarf::DW_TAG_return_variable: 1416 return NULL; 1417 case dwarf::DW_TAG_arg_variable: 1418 Tag = dwarf::DW_TAG_formal_parameter; 1419 break; 1420 case dwarf::DW_TAG_auto_variable: // fall thru 1421 default: 1422 Tag = dwarf::DW_TAG_variable; 1423 break; 1424 } 1425 1426 // Define variable debug information entry. 1427 DIE *VariableDie = new DIE(Tag); 1428 1429 1430 DIE *AbsDIE = NULL; 1431 if (DbgVariable *AV = DV->getAbstractVariable()) 1432 AbsDIE = AV->getDIE(); 1433 1434 if (AbsDIE) { 1435 DIScope DS(Scope->getScopeNode()); 1436 DISubprogram InlinedSP = getDISubprogram(DS.getNode()); 1437 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode()); 1438 (void) OriginSPDIE; 1439 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!"); 1440 DIE *AbsDIE = DV->getAbstractVariable()->getDIE(); 1441 assert (AbsDIE && "Unable to find Origin DIE for the Variable!"); 1442 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, 1443 dwarf::DW_FORM_ref4, AbsDIE); 1444 } 1445 else { 1446 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 1447 addSourceLine(VariableDie, &VD); 1448 1449 // Add variable type. 1450 // FIXME: isBlockByrefVariable should be reformulated in terms of complex 1451 // addresses instead. 1452 if (VD.isBlockByrefVariable()) 1453 addType(VariableDie, getBlockByrefType(VD.getType(), Name)); 1454 else 1455 addType(VariableDie, VD.getType()); 1456 } 1457 1458 // Add variable address. 1459 if (!Scope->isAbstractScope()) { 1460 MachineLocation Location; 1461 unsigned FrameReg; 1462 int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg); 1463 Location.set(FrameReg, Offset); 1464 1465 if (VD.hasComplexAddress()) 1466 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location); 1467 else if (VD.isBlockByrefVariable()) 1468 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location); 1469 else 1470 addAddress(VariableDie, dwarf::DW_AT_location, Location); 1471 } 1472 DV->setDIE(VariableDie); 1473 return VariableDie; 1474 1475} 1476 1477void DwarfDebug::addPubTypes(DISubprogram SP) { 1478 DICompositeType SPTy = SP.getType(); 1479 unsigned SPTag = SPTy.getTag(); 1480 if (SPTag != dwarf::DW_TAG_subroutine_type) 1481 return; 1482 1483 DIArray Args = SPTy.getTypeArray(); 1484 if (Args.isNull()) 1485 return; 1486 1487 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) { 1488 DIType ATy(Args.getElement(i).getNode()); 1489 if (ATy.isNull()) 1490 continue; 1491 DICompositeType CATy = getDICompositeType(ATy); 1492 if (!CATy.isNull() && !CATy.getName().empty()) { 1493 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode())) 1494 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry()); 1495 } 1496 } 1497} 1498 1499/// constructScopeDIE - Construct a DIE for this scope. 1500DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) { 1501 if (!Scope) 1502 return NULL; 1503 DIScope DS(Scope->getScopeNode()); 1504 if (DS.isNull()) 1505 return NULL; 1506 1507 DIE *ScopeDIE = NULL; 1508 if (Scope->getInlinedAt()) 1509 ScopeDIE = constructInlinedScopeDIE(Scope); 1510 else if (DS.isSubprogram()) { 1511 if (Scope->isAbstractScope()) 1512 ScopeDIE = ModuleCU->getDIE(DS.getNode()); 1513 else 1514 ScopeDIE = updateSubprogramScopeDIE(DS.getNode()); 1515 } 1516 else { 1517 ScopeDIE = constructLexicalScopeDIE(Scope); 1518 if (!ScopeDIE) return NULL; 1519 } 1520 1521 // Add variables to scope. 1522 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables(); 1523 for (unsigned i = 0, N = Variables.size(); i < N; ++i) { 1524 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope); 1525 if (VariableDIE) 1526 ScopeDIE->addChild(VariableDIE); 1527 } 1528 1529 // Add nested scopes. 1530 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes(); 1531 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) { 1532 // Define the Scope debug information entry. 1533 DIE *NestedDIE = constructScopeDIE(Scopes[j]); 1534 if (NestedDIE) 1535 ScopeDIE->addChild(NestedDIE); 1536 } 1537 1538 if (DS.isSubprogram()) 1539 addPubTypes(DISubprogram(DS.getNode())); 1540 1541 return ScopeDIE; 1542} 1543 1544/// GetOrCreateSourceID - Look up the source id with the given directory and 1545/// source file names. If none currently exists, create a new id and insert it 1546/// in the SourceIds map. This can update DirectoryNames and SourceFileNames 1547/// maps as well. 1548unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) { 1549 unsigned DId; 1550 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName); 1551 if (DI != DirectoryIdMap.end()) { 1552 DId = DI->getValue(); 1553 } else { 1554 DId = DirectoryNames.size() + 1; 1555 DirectoryIdMap[DirName] = DId; 1556 DirectoryNames.push_back(DirName); 1557 } 1558 1559 unsigned FId; 1560 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName); 1561 if (FI != SourceFileIdMap.end()) { 1562 FId = FI->getValue(); 1563 } else { 1564 FId = SourceFileNames.size() + 1; 1565 SourceFileIdMap[FileName] = FId; 1566 SourceFileNames.push_back(FileName); 1567 } 1568 1569 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI = 1570 SourceIdMap.find(std::make_pair(DId, FId)); 1571 if (SI != SourceIdMap.end()) 1572 return SI->second; 1573 1574 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0. 1575 SourceIdMap[std::make_pair(DId, FId)] = SrcId; 1576 SourceIds.push_back(std::make_pair(DId, FId)); 1577 1578 return SrcId; 1579} 1580 1581/// getOrCreateNameSpace - Create a DIE for DINameSpace. 1582DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) { 1583 DIE *NDie = ModuleCU->getDIE(NS.getNode()); 1584 if (NDie) 1585 return NDie; 1586 NDie = new DIE(dwarf::DW_TAG_namespace); 1587 ModuleCU->insertDIE(NS.getNode(), NDie); 1588 if (!NS.getName().empty()) 1589 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName()); 1590 addSourceLine(NDie, &NS); 1591 addToContextOwner(NDie, NS.getContext()); 1592 return NDie; 1593} 1594 1595CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) { 1596 DICompileUnit DIUnit(N); 1597 StringRef FN = DIUnit.getFilename(); 1598 StringRef Dir = DIUnit.getDirectory(); 1599 unsigned ID = GetOrCreateSourceID(Dir, FN); 1600 1601 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 1602 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 1603 DWLabel("section_line", 0), DWLabel("section_line", 0), 1604 false); 1605 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string, 1606 DIUnit.getProducer()); 1607 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1, 1608 DIUnit.getLanguage()); 1609 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN); 1610 1611 if (!Dir.empty()) 1612 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir); 1613 if (DIUnit.isOptimized()) 1614 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 1615 1616 StringRef Flags = DIUnit.getFlags(); 1617 if (!Flags.empty()) 1618 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags); 1619 1620 unsigned RVer = DIUnit.getRunTimeVersion(); 1621 if (RVer) 1622 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers, 1623 dwarf::DW_FORM_data1, RVer); 1624 1625 CompileUnit *Unit = new CompileUnit(ID, Die); 1626 if (!ModuleCU && DIUnit.isMain()) { 1627 // Use first compile unit marked as isMain as the compile unit 1628 // for this module. 1629 ModuleCU = Unit; 1630 } 1631 1632 CompileUnitMap[DIUnit.getNode()] = Unit; 1633 CompileUnits.push_back(Unit); 1634 return Unit; 1635} 1636 1637void DwarfDebug::constructGlobalVariableDIE(MDNode *N) { 1638 DIGlobalVariable DI_GV(N); 1639 1640 // If debug information is malformed then ignore it. 1641 if (DI_GV.Verify() == false) 1642 return; 1643 1644 // Check for pre-existence. 1645 if (ModuleCU->getDIE(DI_GV.getNode())) 1646 return; 1647 1648 DIE *VariableDie = createGlobalVariableDIE(DI_GV); 1649 if (!VariableDie) 1650 return; 1651 1652 // Add to map. 1653 ModuleCU->insertDIE(N, VariableDie); 1654 1655 // Add to context owner. 1656 if (DI_GV.isDefinition() 1657 && !DI_GV.getContext().isCompileUnit()) { 1658 // Create specification DIE. 1659 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable); 1660 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, 1661 dwarf::DW_FORM_ref4, VariableDie); 1662 DIEBlock *Block = new DIEBlock(); 1663 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 1664 addObjectLabel(Block, 0, dwarf::DW_FORM_udata, 1665 Asm->Mang->getMangledName(DI_GV.getGlobal())); 1666 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block); 1667 ModuleCU->addDie(VariableSpecDIE); 1668 } else { 1669 DIEBlock *Block = new DIEBlock(); 1670 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 1671 addObjectLabel(Block, 0, dwarf::DW_FORM_udata, 1672 Asm->Mang->getMangledName(DI_GV.getGlobal())); 1673 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block); 1674 } 1675 addToContextOwner(VariableDie, DI_GV.getContext()); 1676 1677 // Expose as global. FIXME - need to check external flag. 1678 ModuleCU->addGlobal(DI_GV.getName(), VariableDie); 1679 1680 DIType GTy = DI_GV.getType(); 1681 if (GTy.isCompositeType() && !GTy.getName().empty()) { 1682 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode()); 1683 assert (Entry && "Missing global type!"); 1684 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry()); 1685 } 1686 return; 1687} 1688 1689void DwarfDebug::constructSubprogramDIE(MDNode *N) { 1690 DISubprogram SP(N); 1691 1692 // Check for pre-existence. 1693 if (ModuleCU->getDIE(N)) 1694 return; 1695 1696 if (!SP.isDefinition()) 1697 // This is a method declaration which will be handled while constructing 1698 // class type. 1699 return; 1700 1701 DIE *SubprogramDie = createSubprogramDIE(SP); 1702 1703 // Add to map. 1704 ModuleCU->insertDIE(N, SubprogramDie); 1705 1706 // Add to context owner. 1707 addToContextOwner(SubprogramDie, SP.getContext()); 1708 1709 // Expose as global. 1710 ModuleCU->addGlobal(SP.getName(), SubprogramDie); 1711 1712 return; 1713} 1714 1715/// beginModule - Emit all Dwarf sections that should come prior to the 1716/// content. Create global DIEs and emit initial debug info sections. 1717/// This is inovked by the target AsmPrinter. 1718void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) { 1719 this->M = M; 1720 1721 if (TimePassesIsEnabled) 1722 DebugTimer->startTimer(); 1723 1724 if (!MAI->doesSupportDebugInformation()) 1725 return; 1726 1727 DebugInfoFinder DbgFinder; 1728 DbgFinder.processModule(*M); 1729 1730 // Create all the compile unit DIEs. 1731 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 1732 E = DbgFinder.compile_unit_end(); I != E; ++I) 1733 constructCompileUnit(*I); 1734 1735 if (CompileUnits.empty()) { 1736 if (TimePassesIsEnabled) 1737 DebugTimer->stopTimer(); 1738 1739 return; 1740 } 1741 1742 // If main compile unit for this module is not seen than randomly 1743 // select first compile unit. 1744 if (!ModuleCU) 1745 ModuleCU = CompileUnits[0]; 1746 1747 // Create DIEs for each subprogram. 1748 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(), 1749 E = DbgFinder.subprogram_end(); I != E; ++I) 1750 constructSubprogramDIE(*I); 1751 1752 // Create DIEs for each global variable. 1753 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(), 1754 E = DbgFinder.global_variable_end(); I != E; ++I) 1755 constructGlobalVariableDIE(*I); 1756 1757 MMI = mmi; 1758 shouldEmit = true; 1759 MMI->setDebugInfoAvailability(true); 1760 1761 // Prime section data. 1762 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 1763 1764 // Print out .file directives to specify files for .loc directives. These are 1765 // printed out early so that they precede any .loc directives. 1766 if (MAI->hasDotLocAndDotFile()) { 1767 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) { 1768 // Remember source id starts at 1. 1769 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i); 1770 sys::Path FullPath(getSourceDirectoryName(Id.first)); 1771 bool AppendOk = 1772 FullPath.appendComponent(getSourceFileName(Id.second)); 1773 assert(AppendOk && "Could not append filename to directory!"); 1774 AppendOk = false; 1775 Asm->EmitFile(i, FullPath.str()); 1776 Asm->EOL(); 1777 } 1778 } 1779 1780 // Emit initial sections 1781 emitInitial(); 1782 1783 if (TimePassesIsEnabled) 1784 DebugTimer->stopTimer(); 1785} 1786 1787/// endModule - Emit all Dwarf sections that should come after the content. 1788/// 1789void DwarfDebug::endModule() { 1790 if (!ModuleCU) 1791 return; 1792 1793 if (TimePassesIsEnabled) 1794 DebugTimer->startTimer(); 1795 1796 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 1797 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 1798 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 1799 DIE *ISP = *AI; 1800 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 1801 } 1802 1803 // Insert top level DIEs. 1804 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(), 1805 TE = TopLevelDIEsVector.end(); TI != TE; ++TI) 1806 ModuleCU->getCUDie()->addChild(*TI); 1807 1808 for (DenseMap<DIE *, WeakVH>::iterator CI = ContainingTypeMap.begin(), 1809 CE = ContainingTypeMap.end(); CI != CE; ++CI) { 1810 DIE *SPDie = CI->first; 1811 MDNode *N = dyn_cast_or_null<MDNode>(CI->second); 1812 if (!N) continue; 1813 DIE *NDie = ModuleCU->getDIE(N); 1814 if (!NDie) continue; 1815 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie); 1816 // FIXME - This is not the correct approach. 1817 // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie); 1818 } 1819 1820 // Standard sections final addresses. 1821 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 1822 EmitLabel("text_end", 0); 1823 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 1824 EmitLabel("data_end", 0); 1825 1826 // End text sections. 1827 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) { 1828 Asm->OutStreamer.SwitchSection(SectionMap[i]); 1829 EmitLabel("section_end", i); 1830 } 1831 1832 // Emit common frame information. 1833 emitCommonDebugFrame(); 1834 1835 // Emit function debug frame information 1836 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(), 1837 E = DebugFrames.end(); I != E; ++I) 1838 emitFunctionDebugFrame(*I); 1839 1840 // Compute DIE offsets and sizes. 1841 computeSizeAndOffsets(); 1842 1843 // Emit all the DIEs into a debug info section 1844 emitDebugInfo(); 1845 1846 // Corresponding abbreviations into a abbrev section. 1847 emitAbbreviations(); 1848 1849 // Emit source line correspondence into a debug line section. 1850 emitDebugLines(); 1851 1852 // Emit info into a debug pubnames section. 1853 emitDebugPubNames(); 1854 1855 // Emit info into a debug pubtypes section. 1856 emitDebugPubTypes(); 1857 1858 // Emit info into a debug str section. 1859 emitDebugStr(); 1860 1861 // Emit info into a debug loc section. 1862 emitDebugLoc(); 1863 1864 // Emit info into a debug aranges section. 1865 EmitDebugARanges(); 1866 1867 // Emit info into a debug ranges section. 1868 emitDebugRanges(); 1869 1870 // Emit info into a debug macinfo section. 1871 emitDebugMacInfo(); 1872 1873 // Emit inline info. 1874 emitDebugInlineInfo(); 1875 1876 if (TimePassesIsEnabled) 1877 DebugTimer->stopTimer(); 1878} 1879 1880/// findAbstractVariable - Find abstract variable, if any, associated with Var. 1881DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var, 1882 unsigned FrameIdx, 1883 DILocation &ScopeLoc) { 1884 1885 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode()); 1886 if (AbsDbgVariable) 1887 return AbsDbgVariable; 1888 1889 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode()); 1890 if (!Scope) 1891 return NULL; 1892 1893 AbsDbgVariable = new DbgVariable(Var, FrameIdx); 1894 Scope->addVariable(AbsDbgVariable); 1895 AbstractVariables[Var.getNode()] = AbsDbgVariable; 1896 return AbsDbgVariable; 1897} 1898 1899/// collectVariableInfo - Populate DbgScope entries with variables' info. 1900void DwarfDebug::collectVariableInfo() { 1901 if (!MMI) return; 1902 1903 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 1904 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 1905 VE = VMap.end(); VI != VE; ++VI) { 1906 MetadataBase *MB = VI->first; 1907 MDNode *Var = dyn_cast_or_null<MDNode>(MB); 1908 if (!Var) continue; 1909 DIVariable DV (Var); 1910 std::pair< unsigned, MDNode *> VP = VI->second; 1911 DILocation ScopeLoc(VP.second); 1912 1913 DbgScope *Scope = 1914 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode()); 1915 if (!Scope) 1916 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode()); 1917 // If variable scope is not found then skip this variable. 1918 if (!Scope) 1919 continue; 1920 1921 DbgVariable *RegVar = new DbgVariable(DV, VP.first); 1922 Scope->addVariable(RegVar); 1923 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, 1924 ScopeLoc)) 1925 RegVar->setAbstractVariable(AbsDbgVariable); 1926 } 1927} 1928 1929/// beginScope - Process beginning of a scope starting at Label. 1930void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) { 1931 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI); 1932 if (I == DbgScopeBeginMap.end()) 1933 return; 1934 ScopeVector &SD = I->second; 1935 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end(); 1936 SDI != SDE; ++SDI) 1937 (*SDI)->setStartLabelID(Label); 1938} 1939 1940/// endScope - Process end of a scope. 1941void DwarfDebug::endScope(const MachineInstr *MI) { 1942 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI); 1943 if (I == DbgScopeEndMap.end()) 1944 return; 1945 1946 unsigned Label = MMI->NextLabelID(); 1947 Asm->printLabel(Label); 1948 O << '\n'; 1949 1950 SmallVector<DbgScope *, 2> &SD = I->second; 1951 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end(); 1952 SDI != SDE; ++SDI) 1953 (*SDI)->setEndLabelID(Label); 1954 return; 1955} 1956 1957/// createDbgScope - Create DbgScope for the scope. 1958void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) { 1959 1960 if (!InlinedAt) { 1961 DbgScope *WScope = DbgScopeMap.lookup(Scope); 1962 if (WScope) 1963 return; 1964 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL); 1965 DbgScopeMap.insert(std::make_pair(Scope, WScope)); 1966 if (DIDescriptor(Scope).isLexicalBlock()) 1967 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL); 1968 return; 1969 } 1970 1971 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt); 1972 if (WScope) 1973 return; 1974 1975 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt); 1976 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope)); 1977 DILocation DL(InlinedAt); 1978 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode()); 1979} 1980 1981/// extractScopeInformation - Scan machine instructions in this function 1982/// and collect DbgScopes. Return true, if atleast one scope was found. 1983bool DwarfDebug::extractScopeInformation(MachineFunction *MF) { 1984 // If scope information was extracted using .dbg intrinsics then there is not 1985 // any need to extract these information by scanning each instruction. 1986 if (!DbgScopeMap.empty()) 1987 return false; 1988 1989 DenseMap<const MachineInstr *, unsigned> MIIndexMap; 1990 unsigned MIIndex = 0; 1991 // Scan each instruction and create scopes. First build working set of scopes. 1992 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 1993 I != E; ++I) { 1994 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1995 II != IE; ++II) { 1996 const MachineInstr *MInsn = II; 1997 MIIndexMap[MInsn] = MIIndex++; 1998 DebugLoc DL = MInsn->getDebugLoc(); 1999 if (DL.isUnknown()) continue; 2000 DebugLocTuple DLT = MF->getDebugLocTuple(DL); 2001 if (!DLT.Scope) continue; 2002 // There is no need to create another DIE for compile unit. For all 2003 // other scopes, create one DbgScope now. This will be translated 2004 // into a scope DIE at the end. 2005 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue; 2006 createDbgScope(DLT.Scope, DLT.InlinedAtLoc); 2007 } 2008 } 2009 2010 2011 // Build scope hierarchy using working set of scopes. 2012 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 2013 I != E; ++I) { 2014 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 2015 II != IE; ++II) { 2016 const MachineInstr *MInsn = II; 2017 DebugLoc DL = MInsn->getDebugLoc(); 2018 if (DL.isUnknown()) continue; 2019 DebugLocTuple DLT = MF->getDebugLocTuple(DL); 2020 if (!DLT.Scope) continue; 2021 // There is no need to create another DIE for compile unit. For all 2022 // other scopes, create one DbgScope now. This will be translated 2023 // into a scope DIE at the end. 2024 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue; 2025 DbgScope *Scope = getUpdatedDbgScope(DLT.Scope, MInsn, DLT.InlinedAtLoc); 2026 Scope->setLastInsn(MInsn); 2027 } 2028 } 2029 2030 if (!CurrentFnDbgScope) 2031 return false; 2032 2033 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap); 2034 2035 // Each scope has first instruction and last instruction to mark beginning 2036 // and end of a scope respectively. Create an inverse map that list scopes 2037 // starts (and ends) with an instruction. One instruction may start (or end) 2038 // multiple scopes. 2039 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(), 2040 DE = DbgScopeMap.end(); DI != DE; ++DI) { 2041 DbgScope *S = DI->second; 2042 if (S->isAbstractScope()) 2043 continue; 2044 const MachineInstr *MI = S->getFirstInsn(); 2045 assert (MI && "DbgScope does not have first instruction!"); 2046 2047 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI); 2048 if (IDI != DbgScopeBeginMap.end()) 2049 IDI->second.push_back(S); 2050 else 2051 DbgScopeBeginMap[MI].push_back(S); 2052 2053 MI = S->getLastInsn(); 2054 assert (MI && "DbgScope does not have last instruction!"); 2055 IDI = DbgScopeEndMap.find(MI); 2056 if (IDI != DbgScopeEndMap.end()) 2057 IDI->second.push_back(S); 2058 else 2059 DbgScopeEndMap[MI].push_back(S); 2060 } 2061 2062 return !DbgScopeMap.empty(); 2063} 2064 2065/// beginFunction - Gather pre-function debug information. Assumes being 2066/// emitted immediately after the function entry point. 2067void DwarfDebug::beginFunction(MachineFunction *MF) { 2068 this->MF = MF; 2069 2070 if (!ShouldEmitDwarfDebug()) return; 2071 2072 if (TimePassesIsEnabled) 2073 DebugTimer->startTimer(); 2074 2075 if (!extractScopeInformation(MF)) 2076 return; 2077 2078 collectVariableInfo(); 2079 2080 // Begin accumulating function debug information. 2081 MMI->BeginFunction(MF); 2082 2083 // Assumes in correct section after the entry point. 2084 EmitLabel("func_begin", ++SubprogramCount); 2085 2086 // Emit label for the implicitly defined dbg.stoppoint at the start of the 2087 // function. 2088 DebugLoc FDL = MF->getDefaultDebugLoc(); 2089 if (!FDL.isUnknown()) { 2090 DebugLocTuple DLT = MF->getDebugLocTuple(FDL); 2091 unsigned LabelID = 0; 2092 DISubprogram SP = getDISubprogram(DLT.Scope); 2093 if (!SP.isNull()) 2094 LabelID = recordSourceLine(SP.getLineNumber(), 0, DLT.Scope); 2095 else 2096 LabelID = recordSourceLine(DLT.Line, DLT.Col, DLT.Scope); 2097 Asm->printLabel(LabelID); 2098 O << '\n'; 2099 } 2100 if (TimePassesIsEnabled) 2101 DebugTimer->stopTimer(); 2102} 2103 2104/// endFunction - Gather and emit post-function debug information. 2105/// 2106void DwarfDebug::endFunction(MachineFunction *MF) { 2107 if (!ShouldEmitDwarfDebug()) return; 2108 2109 if (TimePassesIsEnabled) 2110 DebugTimer->startTimer(); 2111 2112 if (DbgScopeMap.empty()) 2113 return; 2114 2115 if (CurrentFnDbgScope) { 2116 // Define end label for subprogram. 2117 EmitLabel("func_end", SubprogramCount); 2118 2119 // Get function line info. 2120 if (!Lines.empty()) { 2121 // Get section line info. 2122 unsigned ID = SectionMap.insert(Asm->getCurrentSection()); 2123 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID); 2124 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1]; 2125 // Append the function info to section info. 2126 SectionLineInfos.insert(SectionLineInfos.end(), 2127 Lines.begin(), Lines.end()); 2128 } 2129 2130 // Construct abstract scopes. 2131 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2132 AE = AbstractScopesList.end(); AI != AE; ++AI) 2133 constructScopeDIE(*AI); 2134 2135 constructScopeDIE(CurrentFnDbgScope); 2136 2137 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount, 2138 MMI->getFrameMoves())); 2139 } 2140 2141 // Clear debug info 2142 if (CurrentFnDbgScope) { 2143 CurrentFnDbgScope = NULL; 2144 DbgScopeMap.clear(); 2145 DbgScopeBeginMap.clear(); 2146 DbgScopeEndMap.clear(); 2147 ConcreteScopes.clear(); 2148 AbstractScopesList.clear(); 2149 } 2150 Lines.clear(); 2151 2152 if (TimePassesIsEnabled) 2153 DebugTimer->stopTimer(); 2154} 2155 2156/// recordSourceLine - Records location information and associates it with a 2157/// label. Returns a unique label ID used to generate a label and provide 2158/// correspondence to the source line list. 2159unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, 2160 MDNode *S) { 2161 if (!MMI) 2162 return 0; 2163 2164 if (TimePassesIsEnabled) 2165 DebugTimer->startTimer(); 2166 2167 StringRef Dir; 2168 StringRef Fn; 2169 2170 DIDescriptor Scope(S); 2171 if (Scope.isCompileUnit()) { 2172 DICompileUnit CU(S); 2173 Dir = CU.getDirectory(); 2174 Fn = CU.getFilename(); 2175 } else if (Scope.isSubprogram()) { 2176 DISubprogram SP(S); 2177 Dir = SP.getDirectory(); 2178 Fn = SP.getFilename(); 2179 } else if (Scope.isLexicalBlock()) { 2180 DILexicalBlock DB(S); 2181 Dir = DB.getDirectory(); 2182 Fn = DB.getFilename(); 2183 } else 2184 assert (0 && "Unexpected scope info"); 2185 2186 unsigned Src = GetOrCreateSourceID(Dir, Fn); 2187 unsigned ID = MMI->NextLabelID(); 2188 Lines.push_back(SrcLineInfo(Line, Col, Src, ID)); 2189 2190 if (TimePassesIsEnabled) 2191 DebugTimer->stopTimer(); 2192 2193 return ID; 2194} 2195 2196/// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be 2197/// timed. Look up the source id with the given directory and source file 2198/// names. If none currently exists, create a new id and insert it in the 2199/// SourceIds map. This can update DirectoryNames and SourceFileNames maps as 2200/// well. 2201unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName, 2202 const std::string &FileName) { 2203 if (TimePassesIsEnabled) 2204 DebugTimer->startTimer(); 2205 2206 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str()); 2207 2208 if (TimePassesIsEnabled) 2209 DebugTimer->stopTimer(); 2210 2211 return SrcId; 2212} 2213 2214//===----------------------------------------------------------------------===// 2215// Emit Methods 2216//===----------------------------------------------------------------------===// 2217 2218/// computeSizeAndOffset - Compute the size and offset of a DIE. 2219/// 2220unsigned 2221DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) { 2222 // Get the children. 2223 const std::vector<DIE *> &Children = Die->getChildren(); 2224 2225 // If not last sibling and has children then add sibling offset attribute. 2226 if (!Last && !Children.empty()) Die->addSiblingOffset(); 2227 2228 // Record the abbreviation. 2229 assignAbbrevNumber(Die->getAbbrev()); 2230 2231 // Get the abbreviation for this DIE. 2232 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2233 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2234 2235 // Set DIE offset 2236 Die->setOffset(Offset); 2237 2238 // Start the size with the size of abbreviation code. 2239 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 2240 2241 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2242 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2243 2244 // Size the DIE attribute values. 2245 for (unsigned i = 0, N = Values.size(); i < N; ++i) 2246 // Size attribute value. 2247 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm()); 2248 2249 // Size the DIE children if any. 2250 if (!Children.empty()) { 2251 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 2252 "Children flag not set"); 2253 2254 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2255 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M); 2256 2257 // End of children marker. 2258 Offset += sizeof(int8_t); 2259 } 2260 2261 Die->setSize(Offset - Die->getOffset()); 2262 return Offset; 2263} 2264 2265/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 2266/// 2267void DwarfDebug::computeSizeAndOffsets() { 2268 // Compute size of compile unit header. 2269 static unsigned Offset = 2270 sizeof(int32_t) + // Length of Compilation Unit Info 2271 sizeof(int16_t) + // DWARF version number 2272 sizeof(int32_t) + // Offset Into Abbrev. Section 2273 sizeof(int8_t); // Pointer Size (in bytes) 2274 2275 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true); 2276 CompileUnitOffsets[ModuleCU] = 0; 2277} 2278 2279/// emitInitial - Emit initial Dwarf declarations. This is necessary for cc 2280/// tools to recognize the object file contains Dwarf information. 2281void DwarfDebug::emitInitial() { 2282 // Check to see if we already emitted intial headers. 2283 if (didInitial) return; 2284 didInitial = true; 2285 2286 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 2287 2288 // Dwarf sections base addresses. 2289 if (MAI->doesDwarfRequireFrameSection()) { 2290 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection()); 2291 EmitLabel("section_debug_frame", 0); 2292 } 2293 2294 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection()); 2295 EmitLabel("section_info", 0); 2296 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection()); 2297 EmitLabel("section_abbrev", 0); 2298 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection()); 2299 EmitLabel("section_aranges", 0); 2300 2301 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) { 2302 Asm->OutStreamer.SwitchSection(LineInfoDirective); 2303 EmitLabel("section_macinfo", 0); 2304 } 2305 2306 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection()); 2307 EmitLabel("section_line", 0); 2308 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection()); 2309 EmitLabel("section_loc", 0); 2310 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection()); 2311 EmitLabel("section_pubnames", 0); 2312 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection()); 2313 EmitLabel("section_pubtypes", 0); 2314 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection()); 2315 EmitLabel("section_str", 0); 2316 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection()); 2317 EmitLabel("section_ranges", 0); 2318 2319 Asm->OutStreamer.SwitchSection(TLOF.getTextSection()); 2320 EmitLabel("text_begin", 0); 2321 Asm->OutStreamer.SwitchSection(TLOF.getDataSection()); 2322 EmitLabel("data_begin", 0); 2323} 2324 2325/// emitDIE - Recusively Emits a debug information entry. 2326/// 2327void DwarfDebug::emitDIE(DIE *Die) { 2328 // Get the abbreviation for this DIE. 2329 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2330 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2331 2332 Asm->EOL(); 2333 2334 // Emit the code (index) for the abbreviation. 2335 Asm->EmitULEB128Bytes(AbbrevNumber); 2336 2337 if (Asm->isVerbose()) 2338 Asm->EOL(std::string("Abbrev [" + 2339 utostr(AbbrevNumber) + 2340 "] 0x" + utohexstr(Die->getOffset()) + 2341 ":0x" + utohexstr(Die->getSize()) + " " + 2342 dwarf::TagString(Abbrev->getTag()))); 2343 else 2344 Asm->EOL(); 2345 2346 SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2347 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2348 2349 // Emit the DIE attribute values. 2350 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 2351 unsigned Attr = AbbrevData[i].getAttribute(); 2352 unsigned Form = AbbrevData[i].getForm(); 2353 assert(Form && "Too many attributes for DIE (check abbreviation)"); 2354 2355 switch (Attr) { 2356 case dwarf::DW_AT_sibling: 2357 Asm->EmitInt32(Die->getSiblingOffset()); 2358 break; 2359 case dwarf::DW_AT_abstract_origin: { 2360 DIEEntry *E = cast<DIEEntry>(Values[i]); 2361 DIE *Origin = E->getEntry(); 2362 unsigned Addr = Origin->getOffset(); 2363 Asm->EmitInt32(Addr); 2364 break; 2365 } 2366 default: 2367 // Emit an attribute using the defined form. 2368 Values[i]->EmitValue(this, Form); 2369 break; 2370 } 2371 2372 Asm->EOL(dwarf::AttributeString(Attr)); 2373 } 2374 2375 // Emit the DIE children if any. 2376 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 2377 const std::vector<DIE *> &Children = Die->getChildren(); 2378 2379 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2380 emitDIE(Children[j]); 2381 2382 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark"); 2383 } 2384} 2385 2386/// emitDebugInfo - Emit the debug info section. 2387/// 2388void DwarfDebug::emitDebugInfo() { 2389 // Start debug info section. 2390 Asm->OutStreamer.SwitchSection( 2391 Asm->getObjFileLowering().getDwarfInfoSection()); 2392 DIE *Die = ModuleCU->getCUDie(); 2393 2394 // Emit the compile units header. 2395 EmitLabel("info_begin", ModuleCU->getID()); 2396 2397 // Emit size of content not including length itself 2398 unsigned ContentSize = Die->getSize() + 2399 sizeof(int16_t) + // DWARF version number 2400 sizeof(int32_t) + // Offset Into Abbrev. Section 2401 sizeof(int8_t) + // Pointer Size (in bytes) 2402 sizeof(int32_t); // FIXME - extra pad for gdb bug. 2403 2404 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info"); 2405 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number"); 2406 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false); 2407 Asm->EOL("Offset Into Abbrev. Section"); 2408 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)"); 2409 2410 emitDIE(Die); 2411 // FIXME - extra padding for gdb bug. 2412 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2413 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2414 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2415 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2416 EmitLabel("info_end", ModuleCU->getID()); 2417 2418 Asm->EOL(); 2419} 2420 2421/// emitAbbreviations - Emit the abbreviation section. 2422/// 2423void DwarfDebug::emitAbbreviations() const { 2424 // Check to see if it is worth the effort. 2425 if (!Abbreviations.empty()) { 2426 // Start the debug abbrev section. 2427 Asm->OutStreamer.SwitchSection( 2428 Asm->getObjFileLowering().getDwarfAbbrevSection()); 2429 2430 EmitLabel("abbrev_begin", 0); 2431 2432 // For each abbrevation. 2433 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 2434 // Get abbreviation data 2435 const DIEAbbrev *Abbrev = Abbreviations[i]; 2436 2437 // Emit the abbrevations code (base 1 index.) 2438 Asm->EmitULEB128Bytes(Abbrev->getNumber()); 2439 Asm->EOL("Abbreviation Code"); 2440 2441 // Emit the abbreviations data. 2442 Abbrev->Emit(Asm); 2443 2444 Asm->EOL(); 2445 } 2446 2447 // Mark end of abbreviations. 2448 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)"); 2449 2450 EmitLabel("abbrev_end", 0); 2451 Asm->EOL(); 2452 } 2453} 2454 2455/// emitEndOfLineMatrix - Emit the last address of the section and the end of 2456/// the line matrix. 2457/// 2458void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 2459 // Define last address of section. 2460 Asm->EmitInt8(0); Asm->EOL("Extended Op"); 2461 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size"); 2462 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address"); 2463 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label"); 2464 2465 // Mark end of matrix. 2466 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence"); 2467 Asm->EmitULEB128Bytes(1); Asm->EOL(); 2468 Asm->EmitInt8(1); Asm->EOL(); 2469} 2470 2471/// emitDebugLines - Emit source line information. 2472/// 2473void DwarfDebug::emitDebugLines() { 2474 // If the target is using .loc/.file, the assembler will be emitting the 2475 // .debug_line table automatically. 2476 if (MAI->hasDotLocAndDotFile()) 2477 return; 2478 2479 // Minimum line delta, thus ranging from -10..(255-10). 2480 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1); 2481 // Maximum line delta, thus ranging from -10..(255-10). 2482 const int MaxLineDelta = 255 + MinLineDelta; 2483 2484 // Start the dwarf line section. 2485 Asm->OutStreamer.SwitchSection( 2486 Asm->getObjFileLowering().getDwarfLineSection()); 2487 2488 // Construct the section header. 2489 EmitDifference("line_end", 0, "line_begin", 0, true); 2490 Asm->EOL("Length of Source Line Info"); 2491 EmitLabel("line_begin", 0); 2492 2493 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number"); 2494 2495 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true); 2496 Asm->EOL("Prolog Length"); 2497 EmitLabel("line_prolog_begin", 0); 2498 2499 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length"); 2500 2501 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag"); 2502 2503 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)"); 2504 2505 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)"); 2506 2507 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base"); 2508 2509 // Line number standard opcode encodings argument count 2510 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count"); 2511 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count"); 2512 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count"); 2513 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count"); 2514 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count"); 2515 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count"); 2516 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count"); 2517 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count"); 2518 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count"); 2519 2520 // Emit directories. 2521 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) { 2522 Asm->EmitString(getSourceDirectoryName(DI)); 2523 Asm->EOL("Directory"); 2524 } 2525 2526 Asm->EmitInt8(0); Asm->EOL("End of directories"); 2527 2528 // Emit files. 2529 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) { 2530 // Remember source id starts at 1. 2531 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI); 2532 Asm->EmitString(getSourceFileName(Id.second)); 2533 Asm->EOL("Source"); 2534 Asm->EmitULEB128Bytes(Id.first); 2535 Asm->EOL("Directory #"); 2536 Asm->EmitULEB128Bytes(0); 2537 Asm->EOL("Mod date"); 2538 Asm->EmitULEB128Bytes(0); 2539 Asm->EOL("File size"); 2540 } 2541 2542 Asm->EmitInt8(0); Asm->EOL("End of files"); 2543 2544 EmitLabel("line_prolog_end", 0); 2545 2546 // A sequence for each text section. 2547 unsigned SecSrcLinesSize = SectionSourceLines.size(); 2548 2549 for (unsigned j = 0; j < SecSrcLinesSize; ++j) { 2550 // Isolate current sections line info. 2551 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j]; 2552 2553 /*if (Asm->isVerbose()) { 2554 const MCSection *S = SectionMap[j + 1]; 2555 O << '\t' << MAI->getCommentString() << " Section" 2556 << S->getName() << '\n'; 2557 }*/ 2558 Asm->EOL(); 2559 2560 // Dwarf assumes we start with first line of first source file. 2561 unsigned Source = 1; 2562 unsigned Line = 1; 2563 2564 // Construct rows of the address, source, line, column matrix. 2565 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) { 2566 const SrcLineInfo &LineInfo = LineInfos[i]; 2567 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID()); 2568 if (!LabelID) continue; 2569 2570 if (LineInfo.getLine() == 0) continue; 2571 2572 if (!Asm->isVerbose()) 2573 Asm->EOL(); 2574 else { 2575 std::pair<unsigned, unsigned> SourceID = 2576 getSourceDirectoryAndFileIds(LineInfo.getSourceID()); 2577 O << '\t' << MAI->getCommentString() << ' ' 2578 << getSourceDirectoryName(SourceID.first) << '/' 2579 << getSourceFileName(SourceID.second) 2580 << ':' << utostr_32(LineInfo.getLine()) << '\n'; 2581 } 2582 2583 // Define the line address. 2584 Asm->EmitInt8(0); Asm->EOL("Extended Op"); 2585 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size"); 2586 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address"); 2587 EmitReference("label", LabelID); Asm->EOL("Location label"); 2588 2589 // If change of source, then switch to the new source. 2590 if (Source != LineInfo.getSourceID()) { 2591 Source = LineInfo.getSourceID(); 2592 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file"); 2593 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source"); 2594 } 2595 2596 // If change of line. 2597 if (Line != LineInfo.getLine()) { 2598 // Determine offset. 2599 int Offset = LineInfo.getLine() - Line; 2600 int Delta = Offset - MinLineDelta; 2601 2602 // Update line. 2603 Line = LineInfo.getLine(); 2604 2605 // If delta is small enough and in range... 2606 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { 2607 // ... then use fast opcode. 2608 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta"); 2609 } else { 2610 // ... otherwise use long hand. 2611 Asm->EmitInt8(dwarf::DW_LNS_advance_line); 2612 Asm->EOL("DW_LNS_advance_line"); 2613 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset"); 2614 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy"); 2615 } 2616 } else { 2617 // Copy the previous row (different address or source) 2618 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy"); 2619 } 2620 } 2621 2622 emitEndOfLineMatrix(j + 1); 2623 } 2624 2625 if (SecSrcLinesSize == 0) 2626 // Because we're emitting a debug_line section, we still need a line 2627 // table. The linker and friends expect it to exist. If there's nothing to 2628 // put into it, emit an empty table. 2629 emitEndOfLineMatrix(1); 2630 2631 EmitLabel("line_end", 0); 2632 Asm->EOL(); 2633} 2634 2635/// emitCommonDebugFrame - Emit common frame info into a debug frame section. 2636/// 2637void DwarfDebug::emitCommonDebugFrame() { 2638 if (!MAI->doesDwarfRequireFrameSection()) 2639 return; 2640 2641 int stackGrowth = 2642 Asm->TM.getFrameInfo()->getStackGrowthDirection() == 2643 TargetFrameInfo::StackGrowsUp ? 2644 TD->getPointerSize() : -TD->getPointerSize(); 2645 2646 // Start the dwarf frame section. 2647 Asm->OutStreamer.SwitchSection( 2648 Asm->getObjFileLowering().getDwarfFrameSection()); 2649 2650 EmitLabel("debug_frame_common", 0); 2651 EmitDifference("debug_frame_common_end", 0, 2652 "debug_frame_common_begin", 0, true); 2653 Asm->EOL("Length of Common Information Entry"); 2654 2655 EmitLabel("debug_frame_common_begin", 0); 2656 Asm->EmitInt32((int)dwarf::DW_CIE_ID); 2657 Asm->EOL("CIE Identifier Tag"); 2658 Asm->EmitInt8(dwarf::DW_CIE_VERSION); 2659 Asm->EOL("CIE Version"); 2660 Asm->EmitString(""); 2661 Asm->EOL("CIE Augmentation"); 2662 Asm->EmitULEB128Bytes(1); 2663 Asm->EOL("CIE Code Alignment Factor"); 2664 Asm->EmitSLEB128Bytes(stackGrowth); 2665 Asm->EOL("CIE Data Alignment Factor"); 2666 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); 2667 Asm->EOL("CIE RA Column"); 2668 2669 std::vector<MachineMove> Moves; 2670 RI->getInitialFrameState(Moves); 2671 2672 EmitFrameMoves(NULL, 0, Moves, false); 2673 2674 Asm->EmitAlignment(2, 0, 0, false); 2675 EmitLabel("debug_frame_common_end", 0); 2676 2677 Asm->EOL(); 2678} 2679 2680/// emitFunctionDebugFrame - Emit per function frame info into a debug frame 2681/// section. 2682void 2683DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){ 2684 if (!MAI->doesDwarfRequireFrameSection()) 2685 return; 2686 2687 // Start the dwarf frame section. 2688 Asm->OutStreamer.SwitchSection( 2689 Asm->getObjFileLowering().getDwarfFrameSection()); 2690 2691 EmitDifference("debug_frame_end", DebugFrameInfo.Number, 2692 "debug_frame_begin", DebugFrameInfo.Number, true); 2693 Asm->EOL("Length of Frame Information Entry"); 2694 2695 EmitLabel("debug_frame_begin", DebugFrameInfo.Number); 2696 2697 EmitSectionOffset("debug_frame_common", "section_debug_frame", 2698 0, 0, true, false); 2699 Asm->EOL("FDE CIE offset"); 2700 2701 EmitReference("func_begin", DebugFrameInfo.Number); 2702 Asm->EOL("FDE initial location"); 2703 EmitDifference("func_end", DebugFrameInfo.Number, 2704 "func_begin", DebugFrameInfo.Number); 2705 Asm->EOL("FDE address range"); 2706 2707 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves, 2708 false); 2709 2710 Asm->EmitAlignment(2, 0, 0, false); 2711 EmitLabel("debug_frame_end", DebugFrameInfo.Number); 2712 2713 Asm->EOL(); 2714} 2715 2716/// emitDebugPubNames - Emit visible names into a debug pubnames section. 2717/// 2718void DwarfDebug::emitDebugPubNames() { 2719 // Start the dwarf pubnames section. 2720 Asm->OutStreamer.SwitchSection( 2721 Asm->getObjFileLowering().getDwarfPubNamesSection()); 2722 2723 EmitDifference("pubnames_end", ModuleCU->getID(), 2724 "pubnames_begin", ModuleCU->getID(), true); 2725 Asm->EOL("Length of Public Names Info"); 2726 2727 EmitLabel("pubnames_begin", ModuleCU->getID()); 2728 2729 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version"); 2730 2731 EmitSectionOffset("info_begin", "section_info", 2732 ModuleCU->getID(), 0, true, false); 2733 Asm->EOL("Offset of Compilation Unit Info"); 2734 2735 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(), 2736 true); 2737 Asm->EOL("Compilation Unit Length"); 2738 2739 const StringMap<DIE*> &Globals = ModuleCU->getGlobals(); 2740 for (StringMap<DIE*>::const_iterator 2741 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2742 const char *Name = GI->getKeyData(); 2743 DIE * Entity = GI->second; 2744 2745 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset"); 2746 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name"); 2747 } 2748 2749 Asm->EmitInt32(0); Asm->EOL("End Mark"); 2750 EmitLabel("pubnames_end", ModuleCU->getID()); 2751 2752 Asm->EOL(); 2753} 2754 2755void DwarfDebug::emitDebugPubTypes() { 2756 // Start the dwarf pubnames section. 2757 Asm->OutStreamer.SwitchSection( 2758 Asm->getObjFileLowering().getDwarfPubTypesSection()); 2759 EmitDifference("pubtypes_end", ModuleCU->getID(), 2760 "pubtypes_begin", ModuleCU->getID(), true); 2761 Asm->EOL("Length of Public Types Info"); 2762 2763 EmitLabel("pubtypes_begin", ModuleCU->getID()); 2764 2765 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version"); 2766 2767 EmitSectionOffset("info_begin", "section_info", 2768 ModuleCU->getID(), 0, true, false); 2769 Asm->EOL("Offset of Compilation ModuleCU Info"); 2770 2771 EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(), 2772 true); 2773 Asm->EOL("Compilation ModuleCU Length"); 2774 2775 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes(); 2776 for (StringMap<DIE*>::const_iterator 2777 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2778 const char *Name = GI->getKeyData(); 2779 DIE * Entity = GI->second; 2780 2781 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset"); 2782 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name"); 2783 } 2784 2785 Asm->EmitInt32(0); Asm->EOL("End Mark"); 2786 EmitLabel("pubtypes_end", ModuleCU->getID()); 2787 2788 Asm->EOL(); 2789} 2790 2791/// emitDebugStr - Emit visible names into a debug str section. 2792/// 2793void DwarfDebug::emitDebugStr() { 2794 // Check to see if it is worth the effort. 2795 if (!StringPool.empty()) { 2796 // Start the dwarf str section. 2797 Asm->OutStreamer.SwitchSection( 2798 Asm->getObjFileLowering().getDwarfStrSection()); 2799 2800 // For each of strings in the string pool. 2801 for (unsigned StringID = 1, N = StringPool.size(); 2802 StringID <= N; ++StringID) { 2803 // Emit a label for reference from debug information entries. 2804 EmitLabel("string", StringID); 2805 2806 // Emit the string itself. 2807 const std::string &String = StringPool[StringID]; 2808 Asm->EmitString(String); Asm->EOL(); 2809 } 2810 2811 Asm->EOL(); 2812 } 2813} 2814 2815/// emitDebugLoc - Emit visible names into a debug loc section. 2816/// 2817void DwarfDebug::emitDebugLoc() { 2818 // Start the dwarf loc section. 2819 Asm->OutStreamer.SwitchSection( 2820 Asm->getObjFileLowering().getDwarfLocSection()); 2821 Asm->EOL(); 2822} 2823 2824/// EmitDebugARanges - Emit visible names into a debug aranges section. 2825/// 2826void DwarfDebug::EmitDebugARanges() { 2827 // Start the dwarf aranges section. 2828 Asm->OutStreamer.SwitchSection( 2829 Asm->getObjFileLowering().getDwarfARangesSection()); 2830 2831 // FIXME - Mock up 2832#if 0 2833 CompileUnit *Unit = GetBaseCompileUnit(); 2834 2835 // Don't include size of length 2836 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info"); 2837 2838 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version"); 2839 2840 EmitReference("info_begin", Unit->getID()); 2841 Asm->EOL("Offset of Compilation Unit Info"); 2842 2843 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address"); 2844 2845 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor"); 2846 2847 Asm->EmitInt16(0); Asm->EOL("Pad (1)"); 2848 Asm->EmitInt16(0); Asm->EOL("Pad (2)"); 2849 2850 // Range 1 2851 EmitReference("text_begin", 0); Asm->EOL("Address"); 2852 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length"); 2853 2854 Asm->EmitInt32(0); Asm->EOL("EOM (1)"); 2855 Asm->EmitInt32(0); Asm->EOL("EOM (2)"); 2856#endif 2857 2858 Asm->EOL(); 2859} 2860 2861/// emitDebugRanges - Emit visible names into a debug ranges section. 2862/// 2863void DwarfDebug::emitDebugRanges() { 2864 // Start the dwarf ranges section. 2865 Asm->OutStreamer.SwitchSection( 2866 Asm->getObjFileLowering().getDwarfRangesSection()); 2867 Asm->EOL(); 2868} 2869 2870/// emitDebugMacInfo - Emit visible names into a debug macinfo section. 2871/// 2872void DwarfDebug::emitDebugMacInfo() { 2873 if (const MCSection *LineInfo = 2874 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 2875 // Start the dwarf macinfo section. 2876 Asm->OutStreamer.SwitchSection(LineInfo); 2877 Asm->EOL(); 2878 } 2879} 2880 2881/// emitDebugInlineInfo - Emit inline info using following format. 2882/// Section Header: 2883/// 1. length of section 2884/// 2. Dwarf version number 2885/// 3. address size. 2886/// 2887/// Entries (one "entry" for each function that was inlined): 2888/// 2889/// 1. offset into __debug_str section for MIPS linkage name, if exists; 2890/// otherwise offset into __debug_str for regular function name. 2891/// 2. offset into __debug_str section for regular function name. 2892/// 3. an unsigned LEB128 number indicating the number of distinct inlining 2893/// instances for the function. 2894/// 2895/// The rest of the entry consists of a {die_offset, low_pc} pair for each 2896/// inlined instance; the die_offset points to the inlined_subroutine die in the 2897/// __debug_info section, and the low_pc is the starting address for the 2898/// inlining instance. 2899void DwarfDebug::emitDebugInlineInfo() { 2900 if (!MAI->doesDwarfUsesInlineInfoSection()) 2901 return; 2902 2903 if (!ModuleCU) 2904 return; 2905 2906 Asm->OutStreamer.SwitchSection( 2907 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 2908 Asm->EOL(); 2909 EmitDifference("debug_inlined_end", 1, 2910 "debug_inlined_begin", 1, true); 2911 Asm->EOL("Length of Debug Inlined Information Entry"); 2912 2913 EmitLabel("debug_inlined_begin", 1); 2914 2915 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version"); 2916 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)"); 2917 2918 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 2919 E = InlinedSPNodes.end(); I != E; ++I) { 2920 2921 MDNode *Node = *I; 2922 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 2923 = InlineInfo.find(Node); 2924 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 2925 DISubprogram SP(Node); 2926 StringRef LName = SP.getLinkageName(); 2927 StringRef Name = SP.getName(); 2928 2929 if (LName.empty()) 2930 Asm->EmitString(Name); 2931 else 2932 EmitSectionOffset("string", "section_str", 2933 StringPool.idFor(getRealLinkageName(LName)), false, true); 2934 2935 Asm->EOL("MIPS linkage name"); 2936 EmitSectionOffset("string", "section_str", 2937 StringPool.idFor(Name), false, true); 2938 Asm->EOL("Function name"); 2939 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count"); 2940 2941 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 2942 LE = Labels.end(); LI != LE; ++LI) { 2943 DIE *SP = LI->second; 2944 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset"); 2945 2946 if (TD->getPointerSize() == sizeof(int32_t)) 2947 O << MAI->getData32bitsDirective(); 2948 else 2949 O << MAI->getData64bitsDirective(); 2950 2951 PrintLabelName("label", LI->first); Asm->EOL("low_pc"); 2952 } 2953 } 2954 2955 EmitLabel("debug_inlined_end", 1); 2956 Asm->EOL(); 2957} 2958