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