DwarfDebug.cpp revision a6871afa41a2f40b6c1c3d8ef087c474d999ffc7
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 DbgScope *Scope = NULL; 1815 DenseMap<MDNode *, DbgScope *>::iterator DSI = 1816 DbgScopeMap.find(DV.getContext().getNode()); 1817 if (DSI != DbgScopeMap.end()) 1818 Scope = DSI->second; 1819 else 1820 // There is not any instruction assocated with this scope, so get 1821 // a new scope. 1822 Scope = getDbgScope(DV.getContext().getNode(), 1823 NULL /* Not an instruction */, 1824 NULL /* Not inlined */); 1825 assert (Scope && "Unable to find variable scope!"); 1826 Scope->AddVariable(new DbgVariable(DV, VSlot, false)); 1827 } 1828} 1829 1830/// SetDbgScopeBeginLabels - Update DbgScope begin labels for the scopes that 1831/// start with this machine instruction. 1832void DwarfDebug::SetDbgScopeBeginLabels(const MachineInstr *MI, unsigned Label) { 1833 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI); 1834 if (I == DbgScopeBeginMap.end()) 1835 return; 1836 SmallVector<DbgScope *, 2> &SD = I->second; 1837 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end(); 1838 SDI != SDE; ++SDI) 1839 (*SDI)->setStartLabelID(Label); 1840} 1841 1842/// SetDbgScopeEndLabels - Update DbgScope end labels for the scopes that 1843/// end with this machine instruction. 1844void DwarfDebug::SetDbgScopeEndLabels(const MachineInstr *MI, unsigned Label) { 1845 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI); 1846 if (I == DbgScopeEndMap.end()) 1847 return; 1848 SmallVector<DbgScope *, 2> &SD = I->second; 1849 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end(); 1850 SDI != SDE; ++SDI) 1851 (*SDI)->setEndLabelID(Label); 1852} 1853 1854/// ExtractScopeInformation - Scan machine instructions in this function 1855/// and collect DbgScopes. Return true, if atleast one scope was found. 1856bool DwarfDebug::ExtractScopeInformation(MachineFunction *MF) { 1857 // If scope information was extracted using .dbg intrinsics then there is not 1858 // any need to extract these information by scanning each instruction. 1859 if (!DbgScopeMap.empty()) 1860 return false; 1861 1862 // Scan each instruction and create scopes. 1863 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 1864 I != E; ++I) { 1865 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1866 II != IE; ++II) { 1867 const MachineInstr *MInsn = II; 1868 DebugLoc DL = MInsn->getDebugLoc(); 1869 if (DL.isUnknown()) 1870 continue; 1871 DebugLocTuple DLT = MF->getDebugLocTuple(DL); 1872 if (!DLT.Scope) 1873 continue; 1874 // There is no need to create another DIE for compile unit. For all 1875 // other scopes, create one DbgScope now. This will be translated 1876 // into a scope DIE at the end. 1877 DIDescriptor D(DLT.Scope); 1878 if (!D.isCompileUnit()) { 1879 DbgScope *Scope = getDbgScope(DLT.Scope, MInsn, DLT.InlinedAtLoc); 1880 Scope->setLastInsn(MInsn); 1881 } 1882 } 1883 } 1884 1885 // If a scope's last instruction is not set then use its child scope's 1886 // last instruction as this scope's last instrunction. 1887 for (DenseMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(), 1888 DE = DbgScopeMap.end(); DI != DE; ++DI) { 1889 assert (DI->second->getFirstInsn() && "Invalid first instruction!"); 1890 DI->second->FixInstructionMarkers(); 1891 assert (DI->second->getLastInsn() && "Invalid last instruction!"); 1892 } 1893 1894 // Each scope has first instruction and last instruction to mark beginning 1895 // and end of a scope respectively. Create an inverse map that list scopes 1896 // starts (and ends) with an instruction. One instruction may start (or end) 1897 // multiple scopes. 1898 for (DenseMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(), 1899 DE = DbgScopeMap.end(); DI != DE; ++DI) { 1900 DbgScope *S = DI->second; 1901 assert (S && "DbgScope is missing!"); 1902 const MachineInstr *MI = S->getFirstInsn(); 1903 assert (MI && "DbgScope does not have first instruction!"); 1904 1905 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI); 1906 if (IDI != DbgScopeBeginMap.end()) 1907 IDI->second.push_back(S); 1908 else 1909 DbgScopeBeginMap.insert(std::make_pair(MI, 1910 SmallVector<DbgScope *, 2>(2, S))); 1911 1912 MI = S->getLastInsn(); 1913 assert (MI && "DbgScope does not have last instruction!"); 1914 IDI = DbgScopeEndMap.find(MI); 1915 if (IDI != DbgScopeEndMap.end()) 1916 IDI->second.push_back(S); 1917 else 1918 DbgScopeEndMap.insert(std::make_pair(MI, 1919 SmallVector<DbgScope *, 2>(2, S))); 1920 } 1921 1922 return !DbgScopeMap.empty(); 1923} 1924 1925static DISubprogram getDISubprogram(MDNode *N) { 1926 1927 DIDescriptor D(N); 1928 if (D.isNull()) 1929 return DISubprogram(); 1930 1931 if (D.isCompileUnit()) 1932 return DISubprogram(); 1933 1934 if (D.isSubprogram()) 1935 return DISubprogram(N); 1936 1937 if (D.isLexicalBlock()) 1938 return getDISubprogram(DILexicalBlock(N).getContext().getNode()); 1939 1940 llvm_unreachable("Unexpected Descriptor!"); 1941} 1942 1943/// BeginFunction - Gather pre-function debug information. Assumes being 1944/// emitted immediately after the function entry point. 1945void DwarfDebug::BeginFunction(MachineFunction *MF) { 1946 this->MF = MF; 1947 1948 if (!ShouldEmitDwarfDebug()) return; 1949 1950 if (TimePassesIsEnabled) 1951 DebugTimer->startTimer(); 1952 1953#ifdef ATTACH_DEBUG_INFO_TO_AN_INSN 1954 if (!ExtractScopeInformation(MF)) 1955 return; 1956 CollectVariableInfo(); 1957#endif 1958 1959 // Begin accumulating function debug information. 1960 MMI->BeginFunction(MF); 1961 1962 // Assumes in correct section after the entry point. 1963 EmitLabel("func_begin", ++SubprogramCount); 1964 1965 // Emit label for the implicitly defined dbg.stoppoint at the start of the 1966 // function. 1967#ifdef ATTACH_DEBUG_INFO_TO_AN_INSN 1968 DebugLoc FDL = MF->getDefaultDebugLoc(); 1969 if (!FDL.isUnknown()) { 1970 DebugLocTuple DLT = MF->getDebugLocTuple(FDL); 1971 unsigned LabelID = 0; 1972 DISubprogram SP = getDISubprogram(DLT.Scope); 1973 if (!SP.isNull()) 1974 LabelID = RecordSourceLine(SP.getLineNumber(), 0, DLT.Scope); 1975 else 1976 LabelID = RecordSourceLine(DLT.Line, DLT.Col, DLT.Scope); 1977 Asm->printLabel(LabelID); 1978 O << '\n'; 1979 } 1980#else 1981 DebugLoc FDL = MF->getDefaultDebugLoc(); 1982 if (!FDL.isUnknown()) { 1983 DebugLocTuple DLT = MF->getDebugLocTuple(FDL); 1984 unsigned LabelID = RecordSourceLine(DLT.Line, DLT.Col, DLT.Scope); 1985 Asm->printLabel(LabelID); 1986 O << '\n'; 1987 } 1988#endif 1989 if (TimePassesIsEnabled) 1990 DebugTimer->stopTimer(); 1991} 1992 1993/// EndFunction - Gather and emit post-function debug information. 1994/// 1995void DwarfDebug::EndFunction(MachineFunction *MF) { 1996 if (!ShouldEmitDwarfDebug()) return; 1997 1998 if (TimePassesIsEnabled) 1999 DebugTimer->startTimer(); 2000 2001#ifdef ATTACH_DEBUG_INFO_TO_AN_INSN 2002 if (DbgScopeMap.empty()) 2003 return; 2004#endif 2005 // Define end label for subprogram. 2006 EmitLabel("func_end", SubprogramCount); 2007 2008 // Get function line info. 2009 if (!Lines.empty()) { 2010 // Get section line info. 2011 unsigned ID = SectionMap.insert(Asm->getCurrentSection()); 2012 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID); 2013 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1]; 2014 // Append the function info to section info. 2015 SectionLineInfos.insert(SectionLineInfos.end(), 2016 Lines.begin(), Lines.end()); 2017 } 2018 2019 // Construct the DbgScope for abstract instances. 2020 for (SmallVector<DbgScope *, 32>::iterator 2021 I = AbstractInstanceRootList.begin(), 2022 E = AbstractInstanceRootList.end(); I != E; ++I) 2023 ConstructFunctionDbgScope(*I); 2024 2025 // Construct scopes for subprogram. 2026 if (FunctionDbgScope) 2027 ConstructFunctionDbgScope(FunctionDbgScope); 2028 else 2029 // FIXME: This is wrong. We are essentially getting past a problem with 2030 // debug information not being able to handle unreachable blocks that have 2031 // debug information in them. In particular, those unreachable blocks that 2032 // have "region end" info in them. That situation results in the "root 2033 // scope" not being created. If that's the case, then emit a "default" 2034 // scope, i.e., one that encompasses the whole function. This isn't 2035 // desirable. And a better way of handling this (and all of the debugging 2036 // information) needs to be explored. 2037 ConstructDefaultDbgScope(MF); 2038 2039 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount, 2040 MMI->getFrameMoves())); 2041 2042 // Clear debug info 2043 if (FunctionDbgScope) { 2044 delete FunctionDbgScope; 2045 DbgScopeMap.clear(); 2046 DbgScopeBeginMap.clear(); 2047 DbgScopeEndMap.clear(); 2048 DbgAbstractScopeMap.clear(); 2049 DbgConcreteScopeMap.clear(); 2050 FunctionDbgScope = NULL; 2051 LexicalScopeStack.clear(); 2052 AbstractInstanceRootList.clear(); 2053 AbstractInstanceRootMap.clear(); 2054 } 2055 2056 Lines.clear(); 2057 2058 if (TimePassesIsEnabled) 2059 DebugTimer->stopTimer(); 2060} 2061 2062/// RecordSourceLine - Records location information and associates it with a 2063/// label. Returns a unique label ID used to generate a label and provide 2064/// correspondence to the source line list. 2065unsigned DwarfDebug::RecordSourceLine(unsigned Line, unsigned Col, 2066 MDNode *S) { 2067 if (!MMI) 2068 return 0; 2069 2070 if (TimePassesIsEnabled) 2071 DebugTimer->startTimer(); 2072 2073 const char *Dir = NULL; 2074 const char *Fn = NULL; 2075 2076 DIDescriptor Scope(S); 2077 if (Scope.isCompileUnit()) { 2078 DICompileUnit CU(S); 2079 Dir = CU.getDirectory(); 2080 Fn = CU.getFilename(); 2081 } else if (Scope.isSubprogram()) { 2082 DISubprogram SP(S); 2083 Dir = SP.getDirectory(); 2084 Fn = SP.getFilename(); 2085 } else if (Scope.isLexicalBlock()) { 2086 DILexicalBlock DB(S); 2087 Dir = DB.getDirectory(); 2088 Fn = DB.getFilename(); 2089 } else 2090 assert (0 && "Unexpected scope info"); 2091 2092 unsigned Src = GetOrCreateSourceID(Dir, Fn); 2093 unsigned ID = MMI->NextLabelID(); 2094 Lines.push_back(SrcLineInfo(Line, Col, Src, ID)); 2095 2096 if (TimePassesIsEnabled) 2097 DebugTimer->stopTimer(); 2098 2099 return ID; 2100} 2101 2102/// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be 2103/// timed. Look up the source id with the given directory and source file 2104/// names. If none currently exists, create a new id and insert it in the 2105/// SourceIds map. This can update DirectoryNames and SourceFileNames maps as 2106/// well. 2107unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName, 2108 const std::string &FileName) { 2109 if (TimePassesIsEnabled) 2110 DebugTimer->startTimer(); 2111 2112 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str()); 2113 2114 if (TimePassesIsEnabled) 2115 DebugTimer->stopTimer(); 2116 2117 return SrcId; 2118} 2119 2120/// RecordRegionStart - Indicate the start of a region. 2121unsigned DwarfDebug::RecordRegionStart(MDNode *N) { 2122 if (TimePassesIsEnabled) 2123 DebugTimer->startTimer(); 2124 2125 DbgScope *Scope = getOrCreateScope(N); 2126 unsigned ID = MMI->NextLabelID(); 2127 if (!Scope->getStartLabelID()) Scope->setStartLabelID(ID); 2128 LexicalScopeStack.push_back(Scope); 2129 2130 if (TimePassesIsEnabled) 2131 DebugTimer->stopTimer(); 2132 2133 return ID; 2134} 2135 2136/// RecordRegionEnd - Indicate the end of a region. 2137unsigned DwarfDebug::RecordRegionEnd(MDNode *N) { 2138 if (TimePassesIsEnabled) 2139 DebugTimer->startTimer(); 2140 2141 DbgScope *Scope = getOrCreateScope(N); 2142 unsigned ID = MMI->NextLabelID(); 2143 Scope->setEndLabelID(ID); 2144 // FIXME : region.end() may not be in the last basic block. 2145 // For now, do not pop last lexical scope because next basic 2146 // block may start new inlined function's body. 2147 unsigned LSSize = LexicalScopeStack.size(); 2148 if (LSSize != 0 && LSSize != 1) 2149 LexicalScopeStack.pop_back(); 2150 2151 if (TimePassesIsEnabled) 2152 DebugTimer->stopTimer(); 2153 2154 return ID; 2155} 2156 2157/// RecordVariable - Indicate the declaration of a local variable. 2158void DwarfDebug::RecordVariable(MDNode *N, unsigned FrameIndex) { 2159 if (TimePassesIsEnabled) 2160 DebugTimer->startTimer(); 2161 2162 DIDescriptor Desc(N); 2163 DbgScope *Scope = NULL; 2164 bool InlinedFnVar = false; 2165 2166 if (Desc.getTag() == dwarf::DW_TAG_variable) 2167 Scope = getOrCreateScope(DIGlobalVariable(N).getContext().getNode()); 2168 else { 2169 bool InlinedVar = false; 2170 MDNode *Context = DIVariable(N).getContext().getNode(); 2171 DISubprogram SP(Context); 2172 if (!SP.isNull()) { 2173 // SP is inserted into DbgAbstractScopeMap when inlined function 2174 // start was recorded by RecordInlineFnStart. 2175 DenseMap<MDNode *, DbgScope *>::iterator 2176 I = DbgAbstractScopeMap.find(SP.getNode()); 2177 if (I != DbgAbstractScopeMap.end()) { 2178 InlinedVar = true; 2179 Scope = I->second; 2180 } 2181 } 2182 if (!InlinedVar) 2183 Scope = getOrCreateScope(Context); 2184 } 2185 2186 assert(Scope && "Unable to find the variable's scope"); 2187 DbgVariable *DV = new DbgVariable(DIVariable(N), FrameIndex, InlinedFnVar); 2188 Scope->AddVariable(DV); 2189 2190 if (TimePassesIsEnabled) 2191 DebugTimer->stopTimer(); 2192} 2193 2194//// RecordInlinedFnStart - Indicate the start of inlined subroutine. 2195unsigned DwarfDebug::RecordInlinedFnStart(DISubprogram &SP, DICompileUnit CU, 2196 unsigned Line, unsigned Col) { 2197 unsigned LabelID = MMI->NextLabelID(); 2198 2199 if (!MAI->doesDwarfUsesInlineInfoSection()) 2200 return LabelID; 2201 2202 if (TimePassesIsEnabled) 2203 DebugTimer->startTimer(); 2204 2205 MDNode *Node = SP.getNode(); 2206 DenseMap<const MDNode *, DbgScope *>::iterator 2207 II = AbstractInstanceRootMap.find(Node); 2208 2209 if (II == AbstractInstanceRootMap.end()) { 2210 // Create an abstract instance entry for this inlined function if it doesn't 2211 // already exist. 2212 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(Node)); 2213 2214 // Get the compile unit context. 2215 DIE *SPDie = ModuleCU->getDieMapSlotFor(Node); 2216 if (!SPDie) 2217 SPDie = CreateSubprogramDIE(ModuleCU, SP, false, true); 2218 2219 // Mark as being inlined. This makes this subprogram entry an abstract 2220 // instance root. 2221 // FIXME: Our debugger doesn't care about the value of DW_AT_inline, only 2222 // that it's defined. That probably won't change in the future. However, 2223 // this could be more elegant. 2224 AddUInt(SPDie, dwarf::DW_AT_inline, 0, dwarf::DW_INL_declared_not_inlined); 2225 2226 // Keep track of the abstract scope for this function. 2227 DbgAbstractScopeMap[Node] = Scope; 2228 2229 AbstractInstanceRootMap[Node] = Scope; 2230 AbstractInstanceRootList.push_back(Scope); 2231 } 2232 2233 // Create a concrete inlined instance for this inlined function. 2234 DbgConcreteScope *ConcreteScope = new DbgConcreteScope(DIDescriptor(Node)); 2235 DIE *ScopeDie = new DIE(dwarf::DW_TAG_inlined_subroutine); 2236 ScopeDie->setAbstractCompileUnit(ModuleCU); 2237 2238 DIE *Origin = ModuleCU->getDieMapSlotFor(Node); 2239 AddDIEEntry(ScopeDie, dwarf::DW_AT_abstract_origin, 2240 dwarf::DW_FORM_ref4, Origin); 2241 AddUInt(ScopeDie, dwarf::DW_AT_call_file, 0, ModuleCU->getID()); 2242 AddUInt(ScopeDie, dwarf::DW_AT_call_line, 0, Line); 2243 AddUInt(ScopeDie, dwarf::DW_AT_call_column, 0, Col); 2244 2245 ConcreteScope->setDie(ScopeDie); 2246 ConcreteScope->setStartLabelID(LabelID); 2247 MMI->RecordUsedDbgLabel(LabelID); 2248 2249 LexicalScopeStack.back()->AddConcreteInst(ConcreteScope); 2250 2251 // Keep track of the concrete scope that's inlined into this function. 2252 DenseMap<MDNode *, SmallVector<DbgScope *, 8> >::iterator 2253 SI = DbgConcreteScopeMap.find(Node); 2254 2255 if (SI == DbgConcreteScopeMap.end()) 2256 DbgConcreteScopeMap[Node].push_back(ConcreteScope); 2257 else 2258 SI->second.push_back(ConcreteScope); 2259 2260 // Track the start label for this inlined function. 2261 DenseMap<MDNode *, SmallVector<unsigned, 4> >::iterator 2262 I = InlineInfo.find(Node); 2263 2264 if (I == InlineInfo.end()) 2265 InlineInfo[Node].push_back(LabelID); 2266 else 2267 I->second.push_back(LabelID); 2268 2269 if (TimePassesIsEnabled) 2270 DebugTimer->stopTimer(); 2271 2272 return LabelID; 2273} 2274 2275/// RecordInlinedFnEnd - Indicate the end of inlined subroutine. 2276unsigned DwarfDebug::RecordInlinedFnEnd(DISubprogram &SP) { 2277 if (!MAI->doesDwarfUsesInlineInfoSection()) 2278 return 0; 2279 2280 if (TimePassesIsEnabled) 2281 DebugTimer->startTimer(); 2282 2283 MDNode *Node = SP.getNode(); 2284 DenseMap<MDNode *, SmallVector<DbgScope *, 8> >::iterator 2285 I = DbgConcreteScopeMap.find(Node); 2286 2287 if (I == DbgConcreteScopeMap.end()) { 2288 // FIXME: Can this situation actually happen? And if so, should it? 2289 if (TimePassesIsEnabled) 2290 DebugTimer->stopTimer(); 2291 2292 return 0; 2293 } 2294 2295 SmallVector<DbgScope *, 8> &Scopes = I->second; 2296 if (Scopes.empty()) { 2297 // Returned ID is 0 if this is unbalanced "end of inlined 2298 // scope". This could happen if optimizer eats dbg intrinsics 2299 // or "beginning of inlined scope" is not recoginized due to 2300 // missing location info. In such cases, ignore this region.end. 2301 return 0; 2302 } 2303 2304 DbgScope *Scope = Scopes.back(); Scopes.pop_back(); 2305 unsigned ID = MMI->NextLabelID(); 2306 MMI->RecordUsedDbgLabel(ID); 2307 Scope->setEndLabelID(ID); 2308 2309 if (TimePassesIsEnabled) 2310 DebugTimer->stopTimer(); 2311 2312 return ID; 2313} 2314 2315//===----------------------------------------------------------------------===// 2316// Emit Methods 2317//===----------------------------------------------------------------------===// 2318 2319/// SizeAndOffsetDie - Compute the size and offset of a DIE. 2320/// 2321unsigned DwarfDebug::SizeAndOffsetDie(DIE *Die, unsigned Offset, bool Last) { 2322 // Get the children. 2323 const std::vector<DIE *> &Children = Die->getChildren(); 2324 2325 // If not last sibling and has children then add sibling offset attribute. 2326 if (!Last && !Children.empty()) Die->AddSiblingOffset(); 2327 2328 // Record the abbreviation. 2329 AssignAbbrevNumber(Die->getAbbrev()); 2330 2331 // Get the abbreviation for this DIE. 2332 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2333 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2334 2335 // Set DIE offset 2336 Die->setOffset(Offset); 2337 2338 // Start the size with the size of abbreviation code. 2339 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 2340 2341 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2342 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2343 2344 // Size the DIE attribute values. 2345 for (unsigned i = 0, N = Values.size(); i < N; ++i) 2346 // Size attribute value. 2347 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm()); 2348 2349 // Size the DIE children if any. 2350 if (!Children.empty()) { 2351 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 2352 "Children flag not set"); 2353 2354 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2355 Offset = SizeAndOffsetDie(Children[j], Offset, (j + 1) == M); 2356 2357 // End of children marker. 2358 Offset += sizeof(int8_t); 2359 } 2360 2361 Die->setSize(Offset - Die->getOffset()); 2362 return Offset; 2363} 2364 2365/// SizeAndOffsets - Compute the size and offset of all the DIEs. 2366/// 2367void DwarfDebug::SizeAndOffsets() { 2368 // Compute size of compile unit header. 2369 static unsigned Offset = 2370 sizeof(int32_t) + // Length of Compilation Unit Info 2371 sizeof(int16_t) + // DWARF version number 2372 sizeof(int32_t) + // Offset Into Abbrev. Section 2373 sizeof(int8_t); // Pointer Size (in bytes) 2374 2375 SizeAndOffsetDie(ModuleCU->getDie(), Offset, true); 2376 CompileUnitOffsets[ModuleCU] = 0; 2377} 2378 2379/// EmitInitial - Emit initial Dwarf declarations. This is necessary for cc 2380/// tools to recognize the object file contains Dwarf information. 2381void DwarfDebug::EmitInitial() { 2382 // Check to see if we already emitted intial headers. 2383 if (didInitial) return; 2384 didInitial = true; 2385 2386 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 2387 2388 // Dwarf sections base addresses. 2389 if (MAI->doesDwarfRequireFrameSection()) { 2390 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection()); 2391 EmitLabel("section_debug_frame", 0); 2392 } 2393 2394 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection()); 2395 EmitLabel("section_info", 0); 2396 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection()); 2397 EmitLabel("section_abbrev", 0); 2398 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection()); 2399 EmitLabel("section_aranges", 0); 2400 2401 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) { 2402 Asm->OutStreamer.SwitchSection(LineInfoDirective); 2403 EmitLabel("section_macinfo", 0); 2404 } 2405 2406 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection()); 2407 EmitLabel("section_line", 0); 2408 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection()); 2409 EmitLabel("section_loc", 0); 2410 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection()); 2411 EmitLabel("section_pubnames", 0); 2412 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection()); 2413 EmitLabel("section_str", 0); 2414 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection()); 2415 EmitLabel("section_ranges", 0); 2416 2417 Asm->OutStreamer.SwitchSection(TLOF.getTextSection()); 2418 EmitLabel("text_begin", 0); 2419 Asm->OutStreamer.SwitchSection(TLOF.getDataSection()); 2420 EmitLabel("data_begin", 0); 2421} 2422 2423/// EmitDIE - Recusively Emits a debug information entry. 2424/// 2425void DwarfDebug::EmitDIE(DIE *Die) { 2426 // Get the abbreviation for this DIE. 2427 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2428 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2429 2430 Asm->EOL(); 2431 2432 // Emit the code (index) for the abbreviation. 2433 Asm->EmitULEB128Bytes(AbbrevNumber); 2434 2435 if (Asm->isVerbose()) 2436 Asm->EOL(std::string("Abbrev [" + 2437 utostr(AbbrevNumber) + 2438 "] 0x" + utohexstr(Die->getOffset()) + 2439 ":0x" + utohexstr(Die->getSize()) + " " + 2440 dwarf::TagString(Abbrev->getTag()))); 2441 else 2442 Asm->EOL(); 2443 2444 SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2445 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2446 2447 // Emit the DIE attribute values. 2448 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 2449 unsigned Attr = AbbrevData[i].getAttribute(); 2450 unsigned Form = AbbrevData[i].getForm(); 2451 assert(Form && "Too many attributes for DIE (check abbreviation)"); 2452 2453 switch (Attr) { 2454 case dwarf::DW_AT_sibling: 2455 Asm->EmitInt32(Die->SiblingOffset()); 2456 break; 2457 case dwarf::DW_AT_abstract_origin: { 2458 DIEEntry *E = cast<DIEEntry>(Values[i]); 2459 DIE *Origin = E->getEntry(); 2460 unsigned Addr = 2461 CompileUnitOffsets[Die->getAbstractCompileUnit()] + 2462 Origin->getOffset(); 2463 2464 Asm->EmitInt32(Addr); 2465 break; 2466 } 2467 default: 2468 // Emit an attribute using the defined form. 2469 Values[i]->EmitValue(this, Form); 2470 break; 2471 } 2472 2473 Asm->EOL(dwarf::AttributeString(Attr)); 2474 } 2475 2476 // Emit the DIE children if any. 2477 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 2478 const std::vector<DIE *> &Children = Die->getChildren(); 2479 2480 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2481 EmitDIE(Children[j]); 2482 2483 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark"); 2484 } 2485} 2486 2487/// EmitDebugInfo / EmitDebugInfoPerCU - Emit the debug info section. 2488/// 2489void DwarfDebug::EmitDebugInfoPerCU(CompileUnit *Unit) { 2490 DIE *Die = Unit->getDie(); 2491 2492 // Emit the compile units header. 2493 EmitLabel("info_begin", Unit->getID()); 2494 2495 // Emit size of content not including length itself 2496 unsigned ContentSize = Die->getSize() + 2497 sizeof(int16_t) + // DWARF version number 2498 sizeof(int32_t) + // Offset Into Abbrev. Section 2499 sizeof(int8_t) + // Pointer Size (in bytes) 2500 sizeof(int32_t); // FIXME - extra pad for gdb bug. 2501 2502 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info"); 2503 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number"); 2504 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false); 2505 Asm->EOL("Offset Into Abbrev. Section"); 2506 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)"); 2507 2508 EmitDIE(Die); 2509 // FIXME - extra padding for gdb bug. 2510 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2511 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2512 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2513 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); 2514 EmitLabel("info_end", Unit->getID()); 2515 2516 Asm->EOL(); 2517} 2518 2519void DwarfDebug::EmitDebugInfo() { 2520 // Start debug info section. 2521 Asm->OutStreamer.SwitchSection( 2522 Asm->getObjFileLowering().getDwarfInfoSection()); 2523 2524 EmitDebugInfoPerCU(ModuleCU); 2525} 2526 2527/// EmitAbbreviations - Emit the abbreviation section. 2528/// 2529void DwarfDebug::EmitAbbreviations() const { 2530 // Check to see if it is worth the effort. 2531 if (!Abbreviations.empty()) { 2532 // Start the debug abbrev section. 2533 Asm->OutStreamer.SwitchSection( 2534 Asm->getObjFileLowering().getDwarfAbbrevSection()); 2535 2536 EmitLabel("abbrev_begin", 0); 2537 2538 // For each abbrevation. 2539 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 2540 // Get abbreviation data 2541 const DIEAbbrev *Abbrev = Abbreviations[i]; 2542 2543 // Emit the abbrevations code (base 1 index.) 2544 Asm->EmitULEB128Bytes(Abbrev->getNumber()); 2545 Asm->EOL("Abbreviation Code"); 2546 2547 // Emit the abbreviations data. 2548 Abbrev->Emit(Asm); 2549 2550 Asm->EOL(); 2551 } 2552 2553 // Mark end of abbreviations. 2554 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)"); 2555 2556 EmitLabel("abbrev_end", 0); 2557 Asm->EOL(); 2558 } 2559} 2560 2561/// EmitEndOfLineMatrix - Emit the last address of the section and the end of 2562/// the line matrix. 2563/// 2564void DwarfDebug::EmitEndOfLineMatrix(unsigned SectionEnd) { 2565 // Define last address of section. 2566 Asm->EmitInt8(0); Asm->EOL("Extended Op"); 2567 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size"); 2568 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address"); 2569 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label"); 2570 2571 // Mark end of matrix. 2572 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence"); 2573 Asm->EmitULEB128Bytes(1); Asm->EOL(); 2574 Asm->EmitInt8(1); Asm->EOL(); 2575} 2576 2577/// EmitDebugLines - Emit source line information. 2578/// 2579void DwarfDebug::EmitDebugLines() { 2580 // If the target is using .loc/.file, the assembler will be emitting the 2581 // .debug_line table automatically. 2582 if (MAI->hasDotLocAndDotFile()) 2583 return; 2584 2585 // Minimum line delta, thus ranging from -10..(255-10). 2586 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1); 2587 // Maximum line delta, thus ranging from -10..(255-10). 2588 const int MaxLineDelta = 255 + MinLineDelta; 2589 2590 // Start the dwarf line section. 2591 Asm->OutStreamer.SwitchSection( 2592 Asm->getObjFileLowering().getDwarfLineSection()); 2593 2594 // Construct the section header. 2595 EmitDifference("line_end", 0, "line_begin", 0, true); 2596 Asm->EOL("Length of Source Line Info"); 2597 EmitLabel("line_begin", 0); 2598 2599 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number"); 2600 2601 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true); 2602 Asm->EOL("Prolog Length"); 2603 EmitLabel("line_prolog_begin", 0); 2604 2605 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length"); 2606 2607 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag"); 2608 2609 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)"); 2610 2611 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)"); 2612 2613 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base"); 2614 2615 // Line number standard opcode encodings argument count 2616 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count"); 2617 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count"); 2618 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count"); 2619 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count"); 2620 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count"); 2621 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count"); 2622 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count"); 2623 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count"); 2624 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count"); 2625 2626 // Emit directories. 2627 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) { 2628 Asm->EmitString(getSourceDirectoryName(DI)); 2629 Asm->EOL("Directory"); 2630 } 2631 2632 Asm->EmitInt8(0); Asm->EOL("End of directories"); 2633 2634 // Emit files. 2635 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) { 2636 // Remember source id starts at 1. 2637 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI); 2638 Asm->EmitString(getSourceFileName(Id.second)); 2639 Asm->EOL("Source"); 2640 Asm->EmitULEB128Bytes(Id.first); 2641 Asm->EOL("Directory #"); 2642 Asm->EmitULEB128Bytes(0); 2643 Asm->EOL("Mod date"); 2644 Asm->EmitULEB128Bytes(0); 2645 Asm->EOL("File size"); 2646 } 2647 2648 Asm->EmitInt8(0); Asm->EOL("End of files"); 2649 2650 EmitLabel("line_prolog_end", 0); 2651 2652 // A sequence for each text section. 2653 unsigned SecSrcLinesSize = SectionSourceLines.size(); 2654 2655 for (unsigned j = 0; j < SecSrcLinesSize; ++j) { 2656 // Isolate current sections line info. 2657 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j]; 2658 2659 /*if (Asm->isVerbose()) { 2660 const MCSection *S = SectionMap[j + 1]; 2661 O << '\t' << MAI->getCommentString() << " Section" 2662 << S->getName() << '\n'; 2663 }*/ 2664 Asm->EOL(); 2665 2666 // Dwarf assumes we start with first line of first source file. 2667 unsigned Source = 1; 2668 unsigned Line = 1; 2669 2670 // Construct rows of the address, source, line, column matrix. 2671 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) { 2672 const SrcLineInfo &LineInfo = LineInfos[i]; 2673 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID()); 2674 if (!LabelID) continue; 2675 2676 if (LineInfo.getLine() == 0) continue; 2677 2678 if (!Asm->isVerbose()) 2679 Asm->EOL(); 2680 else { 2681 std::pair<unsigned, unsigned> SourceID = 2682 getSourceDirectoryAndFileIds(LineInfo.getSourceID()); 2683 O << '\t' << MAI->getCommentString() << ' ' 2684 << getSourceDirectoryName(SourceID.first) << ' ' 2685 << getSourceFileName(SourceID.second) 2686 <<" :" << utostr_32(LineInfo.getLine()) << '\n'; 2687 } 2688 2689 // Define the line address. 2690 Asm->EmitInt8(0); Asm->EOL("Extended Op"); 2691 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size"); 2692 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address"); 2693 EmitReference("label", LabelID); Asm->EOL("Location label"); 2694 2695 // If change of source, then switch to the new source. 2696 if (Source != LineInfo.getSourceID()) { 2697 Source = LineInfo.getSourceID(); 2698 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file"); 2699 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source"); 2700 } 2701 2702 // If change of line. 2703 if (Line != LineInfo.getLine()) { 2704 // Determine offset. 2705 int Offset = LineInfo.getLine() - Line; 2706 int Delta = Offset - MinLineDelta; 2707 2708 // Update line. 2709 Line = LineInfo.getLine(); 2710 2711 // If delta is small enough and in range... 2712 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { 2713 // ... then use fast opcode. 2714 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta"); 2715 } else { 2716 // ... otherwise use long hand. 2717 Asm->EmitInt8(dwarf::DW_LNS_advance_line); 2718 Asm->EOL("DW_LNS_advance_line"); 2719 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset"); 2720 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy"); 2721 } 2722 } else { 2723 // Copy the previous row (different address or source) 2724 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy"); 2725 } 2726 } 2727 2728 EmitEndOfLineMatrix(j + 1); 2729 } 2730 2731 if (SecSrcLinesSize == 0) 2732 // Because we're emitting a debug_line section, we still need a line 2733 // table. The linker and friends expect it to exist. If there's nothing to 2734 // put into it, emit an empty table. 2735 EmitEndOfLineMatrix(1); 2736 2737 EmitLabel("line_end", 0); 2738 Asm->EOL(); 2739} 2740 2741/// EmitCommonDebugFrame - Emit common frame info into a debug frame section. 2742/// 2743void DwarfDebug::EmitCommonDebugFrame() { 2744 if (!MAI->doesDwarfRequireFrameSection()) 2745 return; 2746 2747 int stackGrowth = 2748 Asm->TM.getFrameInfo()->getStackGrowthDirection() == 2749 TargetFrameInfo::StackGrowsUp ? 2750 TD->getPointerSize() : -TD->getPointerSize(); 2751 2752 // Start the dwarf frame section. 2753 Asm->OutStreamer.SwitchSection( 2754 Asm->getObjFileLowering().getDwarfFrameSection()); 2755 2756 EmitLabel("debug_frame_common", 0); 2757 EmitDifference("debug_frame_common_end", 0, 2758 "debug_frame_common_begin", 0, true); 2759 Asm->EOL("Length of Common Information Entry"); 2760 2761 EmitLabel("debug_frame_common_begin", 0); 2762 Asm->EmitInt32((int)dwarf::DW_CIE_ID); 2763 Asm->EOL("CIE Identifier Tag"); 2764 Asm->EmitInt8(dwarf::DW_CIE_VERSION); 2765 Asm->EOL("CIE Version"); 2766 Asm->EmitString(""); 2767 Asm->EOL("CIE Augmentation"); 2768 Asm->EmitULEB128Bytes(1); 2769 Asm->EOL("CIE Code Alignment Factor"); 2770 Asm->EmitSLEB128Bytes(stackGrowth); 2771 Asm->EOL("CIE Data Alignment Factor"); 2772 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); 2773 Asm->EOL("CIE RA Column"); 2774 2775 std::vector<MachineMove> Moves; 2776 RI->getInitialFrameState(Moves); 2777 2778 EmitFrameMoves(NULL, 0, Moves, false); 2779 2780 Asm->EmitAlignment(2, 0, 0, false); 2781 EmitLabel("debug_frame_common_end", 0); 2782 2783 Asm->EOL(); 2784} 2785 2786/// EmitFunctionDebugFrame - Emit per function frame info into a debug frame 2787/// section. 2788void 2789DwarfDebug::EmitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){ 2790 if (!MAI->doesDwarfRequireFrameSection()) 2791 return; 2792 2793 // Start the dwarf frame section. 2794 Asm->OutStreamer.SwitchSection( 2795 Asm->getObjFileLowering().getDwarfFrameSection()); 2796 2797 EmitDifference("debug_frame_end", DebugFrameInfo.Number, 2798 "debug_frame_begin", DebugFrameInfo.Number, true); 2799 Asm->EOL("Length of Frame Information Entry"); 2800 2801 EmitLabel("debug_frame_begin", DebugFrameInfo.Number); 2802 2803 EmitSectionOffset("debug_frame_common", "section_debug_frame", 2804 0, 0, true, false); 2805 Asm->EOL("FDE CIE offset"); 2806 2807 EmitReference("func_begin", DebugFrameInfo.Number); 2808 Asm->EOL("FDE initial location"); 2809 EmitDifference("func_end", DebugFrameInfo.Number, 2810 "func_begin", DebugFrameInfo.Number); 2811 Asm->EOL("FDE address range"); 2812 2813 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves, 2814 false); 2815 2816 Asm->EmitAlignment(2, 0, 0, false); 2817 EmitLabel("debug_frame_end", DebugFrameInfo.Number); 2818 2819 Asm->EOL(); 2820} 2821 2822void DwarfDebug::EmitDebugPubNamesPerCU(CompileUnit *Unit) { 2823 EmitDifference("pubnames_end", Unit->getID(), 2824 "pubnames_begin", Unit->getID(), true); 2825 Asm->EOL("Length of Public Names Info"); 2826 2827 EmitLabel("pubnames_begin", Unit->getID()); 2828 2829 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version"); 2830 2831 EmitSectionOffset("info_begin", "section_info", 2832 Unit->getID(), 0, true, false); 2833 Asm->EOL("Offset of Compilation Unit Info"); 2834 2835 EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(), 2836 true); 2837 Asm->EOL("Compilation Unit Length"); 2838 2839 StringMap<DIE*> &Globals = Unit->getGlobals(); 2840 for (StringMap<DIE*>::const_iterator 2841 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2842 const char *Name = GI->getKeyData(); 2843 DIE * Entity = GI->second; 2844 2845 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset"); 2846 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name"); 2847 } 2848 2849 Asm->EmitInt32(0); Asm->EOL("End Mark"); 2850 EmitLabel("pubnames_end", Unit->getID()); 2851 2852 Asm->EOL(); 2853} 2854 2855/// EmitDebugPubNames - Emit visible names into a debug pubnames section. 2856/// 2857void DwarfDebug::EmitDebugPubNames() { 2858 // Start the dwarf pubnames section. 2859 Asm->OutStreamer.SwitchSection( 2860 Asm->getObjFileLowering().getDwarfPubNamesSection()); 2861 2862 EmitDebugPubNamesPerCU(ModuleCU); 2863} 2864 2865/// EmitDebugStr - Emit visible names into a debug str section. 2866/// 2867void DwarfDebug::EmitDebugStr() { 2868 // Check to see if it is worth the effort. 2869 if (!StringPool.empty()) { 2870 // Start the dwarf str section. 2871 Asm->OutStreamer.SwitchSection( 2872 Asm->getObjFileLowering().getDwarfStrSection()); 2873 2874 // For each of strings in the string pool. 2875 for (unsigned StringID = 1, N = StringPool.size(); 2876 StringID <= N; ++StringID) { 2877 // Emit a label for reference from debug information entries. 2878 EmitLabel("string", StringID); 2879 2880 // Emit the string itself. 2881 const std::string &String = StringPool[StringID]; 2882 Asm->EmitString(String); Asm->EOL(); 2883 } 2884 2885 Asm->EOL(); 2886 } 2887} 2888 2889/// EmitDebugLoc - Emit visible names into a debug loc section. 2890/// 2891void DwarfDebug::EmitDebugLoc() { 2892 // Start the dwarf loc section. 2893 Asm->OutStreamer.SwitchSection( 2894 Asm->getObjFileLowering().getDwarfLocSection()); 2895 Asm->EOL(); 2896} 2897 2898/// EmitDebugARanges - Emit visible names into a debug aranges section. 2899/// 2900void DwarfDebug::EmitDebugARanges() { 2901 // Start the dwarf aranges section. 2902 Asm->OutStreamer.SwitchSection( 2903 Asm->getObjFileLowering().getDwarfARangesSection()); 2904 2905 // FIXME - Mock up 2906#if 0 2907 CompileUnit *Unit = GetBaseCompileUnit(); 2908 2909 // Don't include size of length 2910 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info"); 2911 2912 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version"); 2913 2914 EmitReference("info_begin", Unit->getID()); 2915 Asm->EOL("Offset of Compilation Unit Info"); 2916 2917 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address"); 2918 2919 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor"); 2920 2921 Asm->EmitInt16(0); Asm->EOL("Pad (1)"); 2922 Asm->EmitInt16(0); Asm->EOL("Pad (2)"); 2923 2924 // Range 1 2925 EmitReference("text_begin", 0); Asm->EOL("Address"); 2926 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length"); 2927 2928 Asm->EmitInt32(0); Asm->EOL("EOM (1)"); 2929 Asm->EmitInt32(0); Asm->EOL("EOM (2)"); 2930#endif 2931 2932 Asm->EOL(); 2933} 2934 2935/// EmitDebugRanges - Emit visible names into a debug ranges section. 2936/// 2937void DwarfDebug::EmitDebugRanges() { 2938 // Start the dwarf ranges section. 2939 Asm->OutStreamer.SwitchSection( 2940 Asm->getObjFileLowering().getDwarfRangesSection()); 2941 Asm->EOL(); 2942} 2943 2944/// EmitDebugMacInfo - Emit visible names into a debug macinfo section. 2945/// 2946void DwarfDebug::EmitDebugMacInfo() { 2947 if (const MCSection *LineInfo = 2948 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 2949 // Start the dwarf macinfo section. 2950 Asm->OutStreamer.SwitchSection(LineInfo); 2951 Asm->EOL(); 2952 } 2953} 2954 2955/// EmitDebugInlineInfo - Emit inline info using following format. 2956/// Section Header: 2957/// 1. length of section 2958/// 2. Dwarf version number 2959/// 3. address size. 2960/// 2961/// Entries (one "entry" for each function that was inlined): 2962/// 2963/// 1. offset into __debug_str section for MIPS linkage name, if exists; 2964/// otherwise offset into __debug_str for regular function name. 2965/// 2. offset into __debug_str section for regular function name. 2966/// 3. an unsigned LEB128 number indicating the number of distinct inlining 2967/// instances for the function. 2968/// 2969/// The rest of the entry consists of a {die_offset, low_pc} pair for each 2970/// inlined instance; the die_offset points to the inlined_subroutine die in the 2971/// __debug_info section, and the low_pc is the starting address for the 2972/// inlining instance. 2973void DwarfDebug::EmitDebugInlineInfo() { 2974 if (!MAI->doesDwarfUsesInlineInfoSection()) 2975 return; 2976 2977 if (!ModuleCU) 2978 return; 2979 2980 Asm->OutStreamer.SwitchSection( 2981 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 2982 Asm->EOL(); 2983 EmitDifference("debug_inlined_end", 1, 2984 "debug_inlined_begin", 1, true); 2985 Asm->EOL("Length of Debug Inlined Information Entry"); 2986 2987 EmitLabel("debug_inlined_begin", 1); 2988 2989 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version"); 2990 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)"); 2991 2992 for (DenseMap<MDNode *, SmallVector<unsigned, 4> >::iterator 2993 I = InlineInfo.begin(), E = InlineInfo.end(); I != E; ++I) { 2994 MDNode *Node = I->first; 2995 SmallVector<unsigned, 4> &Labels = I->second; 2996 DISubprogram SP(Node); 2997 const char *LName = SP.getLinkageName(); 2998 const char *Name = SP.getName(); 2999 3000 if (!LName) 3001 Asm->EmitString(Name); 3002 else { 3003 // Skip special LLVM prefix that is used to inform the asm printer to not 3004 // emit usual symbol prefix before the symbol name. This happens for 3005 // Objective-C symbol names and symbol whose name is replaced using GCC's 3006 // __asm__ attribute. 3007 if (LName[0] == 1) 3008 LName = &LName[1]; 3009 Asm->EmitString(LName); 3010 } 3011 Asm->EOL("MIPS linkage name"); 3012 3013 Asm->EmitString(Name); Asm->EOL("Function name"); 3014 3015 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count"); 3016 3017 for (SmallVector<unsigned, 4>::iterator LI = Labels.begin(), 3018 LE = Labels.end(); LI != LE; ++LI) { 3019 DIE *SP = ModuleCU->getDieMapSlotFor(Node); 3020 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset"); 3021 3022 if (TD->getPointerSize() == sizeof(int32_t)) 3023 O << MAI->getData32bitsDirective(); 3024 else 3025 O << MAI->getData64bitsDirective(); 3026 3027 PrintLabelName("label", *LI); Asm->EOL("low_pc"); 3028 } 3029 } 3030 3031 EmitLabel("debug_inlined_end", 1); 3032 Asm->EOL(); 3033} 3034