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