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