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