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