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