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