DwarfDebug.cpp revision e72aba9c0ff5b19128f54b09a36d2f4c2a53b40b
1//===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file contains support for writing dwarf debug info into asm files. 11// 12//===----------------------------------------------------------------------===// 13 14#define DEBUG_TYPE "dwarfdebug" 15#include "DwarfDebug.h" 16#include "DIE.h" 17#include "DIEHash.h" 18#include "DwarfAccelTable.h" 19#include "DwarfCompileUnit.h" 20#include "llvm/ADT/STLExtras.h" 21#include "llvm/ADT/Statistic.h" 22#include "llvm/ADT/StringExtras.h" 23#include "llvm/ADT/Triple.h" 24#include "llvm/CodeGen/MachineFunction.h" 25#include "llvm/CodeGen/MachineModuleInfo.h" 26#include "llvm/DIBuilder.h" 27#include "llvm/DebugInfo.h" 28#include "llvm/IR/Constants.h" 29#include "llvm/IR/DataLayout.h" 30#include "llvm/IR/Instructions.h" 31#include "llvm/IR/Module.h" 32#include "llvm/MC/MCAsmInfo.h" 33#include "llvm/MC/MCSection.h" 34#include "llvm/MC/MCStreamer.h" 35#include "llvm/MC/MCSymbol.h" 36#include "llvm/Support/CommandLine.h" 37#include "llvm/Support/Debug.h" 38#include "llvm/Support/Dwarf.h" 39#include "llvm/Support/ErrorHandling.h" 40#include "llvm/Support/FormattedStream.h" 41#include "llvm/Support/MD5.h" 42#include "llvm/Support/Path.h" 43#include "llvm/Support/Timer.h" 44#include "llvm/Support/ValueHandle.h" 45#include "llvm/Target/TargetFrameLowering.h" 46#include "llvm/Target/TargetLoweringObjectFile.h" 47#include "llvm/Target/TargetMachine.h" 48#include "llvm/Target/TargetOptions.h" 49#include "llvm/Target/TargetRegisterInfo.h" 50using namespace llvm; 51 52static cl::opt<bool> 53DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden, 54 cl::desc("Disable debug info printing")); 55 56static cl::opt<bool> UnknownLocations( 57 "use-unknown-locations", cl::Hidden, 58 cl::desc("Make an absence of debug location information explicit."), 59 cl::init(false)); 60 61static cl::opt<bool> 62GenerateODRHash("generate-odr-hash", cl::Hidden, 63 cl::desc("Add an ODR hash to external type DIEs."), 64 cl::init(false)); 65 66static cl::opt<bool> 67GenerateCUHash("generate-cu-hash", cl::Hidden, 68 cl::desc("Add the CU hash as the dwo_id."), 69 cl::init(false)); 70 71namespace { 72enum DefaultOnOff { 73 Default, 74 Enable, 75 Disable 76}; 77} 78 79static cl::opt<DefaultOnOff> 80DwarfAccelTables("dwarf-accel-tables", cl::Hidden, 81 cl::desc("Output prototype dwarf accelerator tables."), 82 cl::values(clEnumVal(Default, "Default for platform"), 83 clEnumVal(Enable, "Enabled"), 84 clEnumVal(Disable, "Disabled"), clEnumValEnd), 85 cl::init(Default)); 86 87static cl::opt<DefaultOnOff> 88SplitDwarf("split-dwarf", cl::Hidden, 89 cl::desc("Output prototype dwarf split debug info."), 90 cl::values(clEnumVal(Default, "Default for platform"), 91 clEnumVal(Enable, "Enabled"), 92 clEnumVal(Disable, "Disabled"), clEnumValEnd), 93 cl::init(Default)); 94 95static cl::opt<DefaultOnOff> 96DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden, 97 cl::desc("Generate DWARF pubnames and pubtypes sections"), 98 cl::values(clEnumVal(Default, "Default for platform"), 99 clEnumVal(Enable, "Enabled"), 100 clEnumVal(Disable, "Disabled"), clEnumValEnd), 101 cl::init(Default)); 102 103static const char *const DWARFGroupName = "DWARF Emission"; 104static const char *const DbgTimerName = "DWARF Debug Writer"; 105 106//===----------------------------------------------------------------------===// 107 108// Configuration values for initial hash set sizes (log2). 109// 110static const unsigned InitAbbreviationsSetSize = 9; // log2(512) 111 112namespace llvm { 113 114DIType DbgVariable::getType() const { 115 DIType Ty = Var.getType(); 116 // FIXME: isBlockByrefVariable should be reformulated in terms of complex 117 // addresses instead. 118 if (Var.isBlockByrefVariable()) { 119 /* Byref variables, in Blocks, are declared by the programmer as 120 "SomeType VarName;", but the compiler creates a 121 __Block_byref_x_VarName struct, and gives the variable VarName 122 either the struct, or a pointer to the struct, as its type. This 123 is necessary for various behind-the-scenes things the compiler 124 needs to do with by-reference variables in blocks. 125 126 However, as far as the original *programmer* is concerned, the 127 variable should still have type 'SomeType', as originally declared. 128 129 The following function dives into the __Block_byref_x_VarName 130 struct to find the original type of the variable. This will be 131 passed back to the code generating the type for the Debug 132 Information Entry for the variable 'VarName'. 'VarName' will then 133 have the original type 'SomeType' in its debug information. 134 135 The original type 'SomeType' will be the type of the field named 136 'VarName' inside the __Block_byref_x_VarName struct. 137 138 NOTE: In order for this to not completely fail on the debugger 139 side, the Debug Information Entry for the variable VarName needs to 140 have a DW_AT_location that tells the debugger how to unwind through 141 the pointers and __Block_byref_x_VarName struct to find the actual 142 value of the variable. The function addBlockByrefType does this. */ 143 DIType subType = Ty; 144 uint16_t tag = Ty.getTag(); 145 146 if (tag == dwarf::DW_TAG_pointer_type) 147 subType = DIDerivedType(Ty).getTypeDerivedFrom(); 148 149 DIArray Elements = DICompositeType(subType).getTypeArray(); 150 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 151 DIDerivedType DT = DIDerivedType(Elements.getElement(i)); 152 if (getName() == DT.getName()) 153 return (DT.getTypeDerivedFrom()); 154 } 155 } 156 return Ty; 157} 158 159} // end llvm namespace 160 161/// Return Dwarf Version by checking module flags. 162static unsigned getDwarfVersionFromModule(const Module *M) { 163 Value *Val = M->getModuleFlag("Dwarf Version"); 164 if (!Val) 165 return dwarf::DWARF_VERSION; 166 return cast<ConstantInt>(Val)->getZExtValue(); 167} 168 169DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M) 170 : Asm(A), MMI(Asm->MMI), FirstCU(0), 171 AbbreviationsSet(InitAbbreviationsSetSize), 172 SourceIdMap(DIEValueAllocator), 173 PrevLabel(NULL), GlobalCUIndexCount(0), 174 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string", 175 DIEValueAllocator), 176 SkeletonAbbrevSet(InitAbbreviationsSetSize), 177 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string", 178 DIEValueAllocator) { 179 180 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0; 181 DwarfStrSectionSym = TextSectionSym = 0; 182 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0; 183 DwarfAddrSectionSym = 0; 184 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0; 185 FunctionBeginSym = FunctionEndSym = 0; 186 187 // Turn on accelerator tables and older gdb compatibility 188 // for Darwin by default, pubnames by default for non-Darwin, 189 // and handle split dwarf. 190 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin(); 191 192 if (DwarfAccelTables == Default) 193 HasDwarfAccelTables = IsDarwin; 194 else 195 HasDwarfAccelTables = DwarfAccelTables == Enable; 196 197 if (SplitDwarf == Default) 198 HasSplitDwarf = false; 199 else 200 HasSplitDwarf = SplitDwarf == Enable; 201 202 if (DwarfPubSections == Default) 203 HasDwarfPubSections = !IsDarwin; 204 else 205 HasDwarfPubSections = DwarfPubSections == Enable; 206 207 DwarfVersion = getDwarfVersionFromModule(MMI->getModule()); 208 209 { 210 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled); 211 beginModule(); 212 } 213} 214DwarfDebug::~DwarfDebug() { 215} 216 217// Switch to the specified MCSection and emit an assembler 218// temporary label to it if SymbolStem is specified. 219static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section, 220 const char *SymbolStem = 0) { 221 Asm->OutStreamer.SwitchSection(Section); 222 if (!SymbolStem) return 0; 223 224 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem); 225 Asm->OutStreamer.EmitLabel(TmpSym); 226 return TmpSym; 227} 228 229MCSymbol *DwarfUnits::getStringPoolSym() { 230 return Asm->GetTempSymbol(StringPref); 231} 232 233MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) { 234 std::pair<MCSymbol*, unsigned> &Entry = 235 StringPool.GetOrCreateValue(Str).getValue(); 236 if (Entry.first) return Entry.first; 237 238 Entry.second = NextStringPoolNumber++; 239 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second); 240} 241 242unsigned DwarfUnits::getStringPoolIndex(StringRef Str) { 243 std::pair<MCSymbol*, unsigned> &Entry = 244 StringPool.GetOrCreateValue(Str).getValue(); 245 if (Entry.first) return Entry.second; 246 247 Entry.second = NextStringPoolNumber++; 248 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second); 249 return Entry.second; 250} 251 252unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) { 253 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext)); 254} 255 256unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) { 257 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P = 258 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber)); 259 if (P.second) 260 ++NextAddrPoolNumber; 261 return P.first->second; 262} 263 264// Define a unique number for the abbreviation. 265// 266void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) { 267 // Check the set for priors. 268 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev); 269 270 // If it's newly added. 271 if (InSet == &Abbrev) { 272 // Add to abbreviation list. 273 Abbreviations->push_back(&Abbrev); 274 275 // Assign the vector position + 1 as its number. 276 Abbrev.setNumber(Abbreviations->size()); 277 } else { 278 // Assign existing abbreviation number. 279 Abbrev.setNumber(InSet->getNumber()); 280 } 281} 282 283static bool isObjCClass(StringRef Name) { 284 return Name.startswith("+") || Name.startswith("-"); 285} 286 287static bool hasObjCCategory(StringRef Name) { 288 if (!isObjCClass(Name)) return false; 289 290 return Name.find(") ") != StringRef::npos; 291} 292 293static void getObjCClassCategory(StringRef In, StringRef &Class, 294 StringRef &Category) { 295 if (!hasObjCCategory(In)) { 296 Class = In.slice(In.find('[') + 1, In.find(' ')); 297 Category = ""; 298 return; 299 } 300 301 Class = In.slice(In.find('[') + 1, In.find('(')); 302 Category = In.slice(In.find('[') + 1, In.find(' ')); 303 return; 304} 305 306static StringRef getObjCMethodName(StringRef In) { 307 return In.slice(In.find(' ') + 1, In.find(']')); 308} 309 310// Add the various names to the Dwarf accelerator table names. 311static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP, 312 DIE* Die) { 313 if (!SP.isDefinition()) return; 314 315 TheCU->addAccelName(SP.getName(), Die); 316 317 // If the linkage name is different than the name, go ahead and output 318 // that as well into the name table. 319 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName()) 320 TheCU->addAccelName(SP.getLinkageName(), Die); 321 322 // If this is an Objective-C selector name add it to the ObjC accelerator 323 // too. 324 if (isObjCClass(SP.getName())) { 325 StringRef Class, Category; 326 getObjCClassCategory(SP.getName(), Class, Category); 327 TheCU->addAccelObjC(Class, Die); 328 if (Category != "") 329 TheCU->addAccelObjC(Category, Die); 330 // Also add the base method name to the name table. 331 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die); 332 } 333} 334 335/// isSubprogramContext - Return true if Context is either a subprogram 336/// or another context nested inside a subprogram. 337bool DwarfDebug::isSubprogramContext(const MDNode *Context) { 338 if (!Context) 339 return false; 340 DIDescriptor D(Context); 341 if (D.isSubprogram()) 342 return true; 343 if (D.isType()) 344 return isSubprogramContext(resolve(DIType(Context).getContext())); 345 return false; 346} 347 348// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc 349// and DW_AT_high_pc attributes. If there are global variables in this 350// scope then create and insert DIEs for these variables. 351DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU, 352 const MDNode *SPNode) { 353 DIE *SPDie = SPCU->getDIE(SPNode); 354 355 assert(SPDie && "Unable to find subprogram DIE!"); 356 DISubprogram SP(SPNode); 357 358 // If we're updating an abstract DIE, then we will be adding the children and 359 // object pointer later on. But what we don't want to do is process the 360 // concrete DIE twice. 361 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode); 362 if (AbsSPDIE) { 363 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie()); 364 // Pick up abstract subprogram DIE. 365 SPDie = new DIE(dwarf::DW_TAG_subprogram); 366 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of 367 // DW_FORM_ref4. 368 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, 369 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr, 370 AbsSPDIE); 371 SPCU->addDie(SPDie); 372 } else { 373 DISubprogram SPDecl = SP.getFunctionDeclaration(); 374 if (!SPDecl.isSubprogram()) { 375 // There is not any need to generate specification DIE for a function 376 // defined at compile unit level. If a function is defined inside another 377 // function then gdb prefers the definition at top level and but does not 378 // expect specification DIE in parent function. So avoid creating 379 // specification DIE for a function defined inside a function. 380 if (SP.isDefinition() && !SP.getContext().isCompileUnit() && 381 !SP.getContext().isFile() && 382 !isSubprogramContext(SP.getContext())) { 383 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration); 384 385 // Add arguments. 386 DICompositeType SPTy = SP.getType(); 387 DIArray Args = SPTy.getTypeArray(); 388 uint16_t SPTag = SPTy.getTag(); 389 if (SPTag == dwarf::DW_TAG_subroutine_type) 390 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 391 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 392 DIType ATy = DIType(Args.getElement(i)); 393 SPCU->addType(Arg, ATy); 394 if (ATy.isArtificial()) 395 SPCU->addFlag(Arg, dwarf::DW_AT_artificial); 396 if (ATy.isObjectPointer()) 397 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, 398 dwarf::DW_FORM_ref4, Arg); 399 SPDie->addChild(Arg); 400 } 401 DIE *SPDeclDie = SPDie; 402 SPDie = new DIE(dwarf::DW_TAG_subprogram); 403 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, 404 dwarf::DW_FORM_ref4, SPDeclDie); 405 SPCU->addDie(SPDie); 406 } 407 } 408 } 409 410 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, 411 Asm->GetTempSymbol("func_begin", 412 Asm->getFunctionNumber())); 413 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, 414 Asm->GetTempSymbol("func_end", 415 Asm->getFunctionNumber())); 416 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 417 MachineLocation Location(RI->getFrameRegister(*Asm->MF)); 418 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location); 419 420 // Add name to the name table, we do this here because we're guaranteed 421 // to have concrete versions of our DW_TAG_subprogram nodes. 422 addSubprogramNames(SPCU, SP, SPDie); 423 424 return SPDie; 425} 426 427// Construct new DW_TAG_lexical_block for this scope and attach 428// DW_AT_low_pc/DW_AT_high_pc labels. 429DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU, 430 LexicalScope *Scope) { 431 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block); 432 if (Scope->isAbstractScope()) 433 return ScopeDIE; 434 435 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges(); 436 if (Ranges.empty()) 437 return 0; 438 439 // If we have multiple ranges, emit them into the range section. 440 if (Ranges.size() > 1) { 441 // .debug_range section has not been laid out yet. Emit offset in 442 // .debug_range as a uint, size 4, for now. emitDIE will handle 443 // DW_AT_ranges appropriately. 444 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4, 445 DebugRangeSymbols.size() 446 * Asm->getDataLayout().getPointerSize()); 447 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(), 448 RE = Ranges.end(); RI != RE; ++RI) { 449 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first)); 450 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second)); 451 } 452 453 // Terminate the range list. 454 DebugRangeSymbols.push_back(NULL); 455 DebugRangeSymbols.push_back(NULL); 456 return ScopeDIE; 457 } 458 459 // Construct the address range for this DIE. 460 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(); 461 MCSymbol *Start = getLabelBeforeInsn(RI->first); 462 MCSymbol *End = getLabelAfterInsn(RI->second); 463 464 if (End == 0) return 0; 465 466 assert(Start->isDefined() && "Invalid starting label for an inlined scope!"); 467 assert(End->isDefined() && "Invalid end label for an inlined scope!"); 468 469 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start); 470 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End); 471 472 return ScopeDIE; 473} 474 475// This scope represents inlined body of a function. Construct DIE to 476// represent this concrete inlined copy of the function. 477DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU, 478 LexicalScope *Scope) { 479 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges(); 480 assert(Ranges.empty() == false && 481 "LexicalScope does not have instruction markers!"); 482 483 if (!Scope->getScopeNode()) 484 return NULL; 485 DIScope DS(Scope->getScopeNode()); 486 DISubprogram InlinedSP = getDISubprogram(DS); 487 DIE *OriginDIE = TheCU->getDIE(InlinedSP); 488 if (!OriginDIE) { 489 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram."); 490 return NULL; 491 } 492 493 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine); 494 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, 495 dwarf::DW_FORM_ref4, OriginDIE); 496 497 if (Ranges.size() > 1) { 498 // .debug_range section has not been laid out yet. Emit offset in 499 // .debug_range as a uint, size 4, for now. emitDIE will handle 500 // DW_AT_ranges appropriately. 501 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4, 502 DebugRangeSymbols.size() 503 * Asm->getDataLayout().getPointerSize()); 504 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(), 505 RE = Ranges.end(); RI != RE; ++RI) { 506 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first)); 507 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second)); 508 } 509 DebugRangeSymbols.push_back(NULL); 510 DebugRangeSymbols.push_back(NULL); 511 } else { 512 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(); 513 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first); 514 MCSymbol *EndLabel = getLabelAfterInsn(RI->second); 515 516 if (StartLabel == 0 || EndLabel == 0) 517 llvm_unreachable("Unexpected Start and End labels for an inlined scope!"); 518 519 assert(StartLabel->isDefined() && 520 "Invalid starting label for an inlined scope!"); 521 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!"); 522 523 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel); 524 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel); 525 } 526 527 InlinedSubprogramDIEs.insert(OriginDIE); 528 529 // Add the call site information to the DIE. 530 DILocation DL(Scope->getInlinedAt()); 531 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, 532 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(), 533 TheCU->getUniqueID())); 534 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber()); 535 536 // Add name to the name table, we do this here because we're guaranteed 537 // to have concrete versions of our DW_TAG_inlined_subprogram nodes. 538 addSubprogramNames(TheCU, InlinedSP, ScopeDIE); 539 540 return ScopeDIE; 541} 542 543// Construct a DIE for this scope. 544DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) { 545 if (!Scope || !Scope->getScopeNode()) 546 return NULL; 547 548 DIScope DS(Scope->getScopeNode()); 549 // Early return to avoid creating dangling variable|scope DIEs. 550 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() && 551 !TheCU->getDIE(DS)) 552 return NULL; 553 554 SmallVector<DIE *, 8> Children; 555 DIE *ObjectPointer = NULL; 556 557 // Collect arguments for current function. 558 if (LScopes.isCurrentFunctionScope(Scope)) 559 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i) 560 if (DbgVariable *ArgDV = CurrentFnArguments[i]) 561 if (DIE *Arg = 562 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) { 563 Children.push_back(Arg); 564 if (ArgDV->isObjectPointer()) ObjectPointer = Arg; 565 } 566 567 // Collect lexical scope children first. 568 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope); 569 for (unsigned i = 0, N = Variables.size(); i < N; ++i) 570 if (DIE *Variable = 571 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) { 572 Children.push_back(Variable); 573 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable; 574 } 575 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren(); 576 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) 577 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j])) 578 Children.push_back(Nested); 579 DIE *ScopeDIE = NULL; 580 if (Scope->getInlinedAt()) 581 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope); 582 else if (DS.isSubprogram()) { 583 ProcessedSPNodes.insert(DS); 584 if (Scope->isAbstractScope()) { 585 ScopeDIE = TheCU->getDIE(DS); 586 // Note down abstract DIE. 587 if (ScopeDIE) 588 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE)); 589 } 590 else 591 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS); 592 } 593 else { 594 // There is no need to emit empty lexical block DIE. 595 std::pair<ImportedEntityMap::const_iterator, 596 ImportedEntityMap::const_iterator> Range = std::equal_range( 597 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(), 598 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0), 599 less_first()); 600 if (Children.empty() && Range.first == Range.second) 601 return NULL; 602 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope); 603 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second; 604 ++i) 605 constructImportedEntityDIE(TheCU, i->second, ScopeDIE); 606 } 607 608 if (!ScopeDIE) { 609 std::for_each(Children.begin(), Children.end(), deleter<DIE>); 610 return NULL; 611 } 612 613 // Add children 614 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(), 615 E = Children.end(); I != E; ++I) 616 ScopeDIE->addChild(*I); 617 618 if (DS.isSubprogram() && ObjectPointer != NULL) 619 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, 620 dwarf::DW_FORM_ref4, ObjectPointer); 621 622 if (DS.isSubprogram()) 623 TheCU->addPubTypes(DISubprogram(DS)); 624 625 return ScopeDIE; 626} 627 628// Look up the source id with the given directory and source file names. 629// If none currently exists, create a new id and insert it in the 630// SourceIds map. This can update DirectoryNames and SourceFileNames maps 631// as well. 632unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, 633 StringRef DirName, unsigned CUID) { 634 // If we use .loc in assembly, we can't separate .file entries according to 635 // compile units. Thus all files will belong to the default compile unit. 636 if (Asm->TM.hasMCUseLoc() && 637 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) 638 CUID = 0; 639 640 // If FE did not provide a file name, then assume stdin. 641 if (FileName.empty()) 642 return getOrCreateSourceID("<stdin>", StringRef(), CUID); 643 644 // TODO: this might not belong here. See if we can factor this better. 645 if (DirName == CompilationDir) 646 DirName = ""; 647 648 // FileIDCUMap stores the current ID for the given compile unit. 649 unsigned SrcId = FileIDCUMap[CUID] + 1; 650 651 // We look up the CUID/file/dir by concatenating them with a zero byte. 652 SmallString<128> NamePair; 653 NamePair += utostr(CUID); 654 NamePair += '\0'; 655 NamePair += DirName; 656 NamePair += '\0'; // Zero bytes are not allowed in paths. 657 NamePair += FileName; 658 659 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId); 660 if (Ent.getValue() != SrcId) 661 return Ent.getValue(); 662 663 FileIDCUMap[CUID] = SrcId; 664 // Print out a .file directive to specify files for .loc directives. 665 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID); 666 667 return SrcId; 668} 669 670// Create new CompileUnit for the given metadata node with tag 671// DW_TAG_compile_unit. 672CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) { 673 DICompileUnit DIUnit(N); 674 StringRef FN = DIUnit.getFilename(); 675 CompilationDir = DIUnit.getDirectory(); 676 677 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 678 CompileUnit *NewCU = 679 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder); 680 681 FileIDCUMap[NewCU->getUniqueID()] = 0; 682 // Call this to emit a .file directive if it wasn't emitted for the source 683 // file this CU comes from yet. 684 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID()); 685 686 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer()); 687 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2, 688 DIUnit.getLanguage()); 689 NewCU->addString(Die, dwarf::DW_AT_name, FN); 690 691 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point 692 // into an entity. We're using 0 (or a NULL label) for this. For 693 // split dwarf it's in the skeleton CU so omit it here. 694 if (!useSplitDwarf()) 695 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL); 696 697 // Define start line table label for each Compile Unit. 698 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start", 699 NewCU->getUniqueID()); 700 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym, 701 NewCU->getUniqueID()); 702 703 // Use a single line table if we are using .loc and generating assembly. 704 bool UseTheFirstCU = 705 (Asm->TM.hasMCUseLoc() && 706 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) || 707 (NewCU->getUniqueID() == 0); 708 709 // DW_AT_stmt_list is a offset of line number information for this 710 // compile unit in debug_line section. For split dwarf this is 711 // left in the skeleton CU and so not included. 712 // The line table entries are not always emitted in assembly, so it 713 // is not okay to use line_table_start here. 714 if (!useSplitDwarf()) { 715 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 716 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 717 UseTheFirstCU ? 718 Asm->GetTempSymbol("section_line") : LineTableStartSym); 719 else if (UseTheFirstCU) 720 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0); 721 else 722 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 723 LineTableStartSym, DwarfLineSectionSym); 724 } 725 726 // If we're using split dwarf the compilation dir is going to be in the 727 // skeleton CU and so we don't need to duplicate it here. 728 if (!useSplitDwarf() && !CompilationDir.empty()) 729 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir); 730 if (DIUnit.isOptimized()) 731 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized); 732 733 StringRef Flags = DIUnit.getFlags(); 734 if (!Flags.empty()) 735 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags); 736 737 if (unsigned RVer = DIUnit.getRunTimeVersion()) 738 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers, 739 dwarf::DW_FORM_data1, RVer); 740 741 if (!FirstCU) 742 FirstCU = NewCU; 743 744 InfoHolder.addUnit(NewCU); 745 746 CUMap.insert(std::make_pair(N, NewCU)); 747 return NewCU; 748} 749 750// Construct subprogram DIE. 751void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, 752 const MDNode *N) { 753 CompileUnit *&CURef = SPMap[N]; 754 if (CURef) 755 return; 756 CURef = TheCU; 757 758 DISubprogram SP(N); 759 if (!SP.isDefinition()) 760 // This is a method declaration which will be handled while constructing 761 // class type. 762 return; 763 764 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP); 765 766 // Add to map. 767 TheCU->insertDIE(N, SubprogramDie); 768 769 // Add to context owner. 770 TheCU->addToContextOwner(SubprogramDie, SP.getContext()); 771 772 // Expose as a global name. 773 TheCU->addGlobalName(SP.getName(), SubprogramDie); 774} 775 776void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, 777 const MDNode *N) { 778 DIImportedEntity Module(N); 779 if (!Module.Verify()) 780 return; 781 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext())) 782 constructImportedEntityDIE(TheCU, Module, D); 783} 784 785void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N, 786 DIE *Context) { 787 DIImportedEntity Module(N); 788 if (!Module.Verify()) 789 return; 790 return constructImportedEntityDIE(TheCU, Module, Context); 791} 792 793void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, 794 const DIImportedEntity &Module, 795 DIE *Context) { 796 assert(Module.Verify() && 797 "Use one of the MDNode * overloads to handle invalid metadata"); 798 assert(Context && "Should always have a context for an imported_module"); 799 DIE *IMDie = new DIE(Module.getTag()); 800 TheCU->insertDIE(Module, IMDie); 801 DIE *EntityDie; 802 DIDescriptor Entity = Module.getEntity(); 803 if (Entity.isNameSpace()) 804 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity)); 805 else if (Entity.isSubprogram()) 806 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity)); 807 else if (Entity.isType()) 808 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity)); 809 else 810 EntityDie = TheCU->getDIE(Entity); 811 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(), 812 Module.getContext().getDirectory(), 813 TheCU->getUniqueID()); 814 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID); 815 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber()); 816 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4, 817 EntityDie); 818 StringRef Name = Module.getName(); 819 if (!Name.empty()) 820 TheCU->addString(IMDie, dwarf::DW_AT_name, Name); 821 Context->addChild(IMDie); 822} 823 824// Emit all Dwarf sections that should come prior to the content. Create 825// global DIEs and emit initial debug info sections. This is invoked by 826// the target AsmPrinter. 827void DwarfDebug::beginModule() { 828 if (DisableDebugInfoPrinting) 829 return; 830 831 const Module *M = MMI->getModule(); 832 833 // If module has named metadata anchors then use them, otherwise scan the 834 // module using debug info finder to collect debug info. 835 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu"); 836 if (!CU_Nodes) 837 return; 838 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes); 839 840 // Emit initial sections so we can reference labels later. 841 emitSectionLabels(); 842 843 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 844 DICompileUnit CUNode(CU_Nodes->getOperand(i)); 845 CompileUnit *CU = constructCompileUnit(CUNode); 846 DIArray ImportedEntities = CUNode.getImportedEntities(); 847 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i) 848 ScopesWithImportedEntities.push_back(std::make_pair( 849 DIImportedEntity(ImportedEntities.getElement(i)).getContext(), 850 ImportedEntities.getElement(i))); 851 std::sort(ScopesWithImportedEntities.begin(), 852 ScopesWithImportedEntities.end(), less_first()); 853 DIArray GVs = CUNode.getGlobalVariables(); 854 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) 855 CU->createGlobalVariableDIE(GVs.getElement(i)); 856 DIArray SPs = CUNode.getSubprograms(); 857 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) 858 constructSubprogramDIE(CU, SPs.getElement(i)); 859 DIArray EnumTypes = CUNode.getEnumTypes(); 860 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) 861 CU->getOrCreateTypeDIE(EnumTypes.getElement(i)); 862 DIArray RetainedTypes = CUNode.getRetainedTypes(); 863 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) 864 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i)); 865 // Emit imported_modules last so that the relevant context is already 866 // available. 867 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i) 868 constructImportedEntityDIE(CU, ImportedEntities.getElement(i)); 869 } 870 871 // Tell MMI that we have debug info. 872 MMI->setDebugInfoAvailability(true); 873 874 // Prime section data. 875 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 876} 877 878// Attach DW_AT_inline attribute with inlined subprogram DIEs. 879void DwarfDebug::computeInlinedDIEs() { 880 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 881 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 882 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 883 DIE *ISP = *AI; 884 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 885 } 886 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(), 887 AE = AbstractSPDies.end(); AI != AE; ++AI) { 888 DIE *ISP = AI->second; 889 if (InlinedSubprogramDIEs.count(ISP)) 890 continue; 891 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 892 } 893} 894 895// Collect info for variables that were optimized out. 896void DwarfDebug::collectDeadVariables() { 897 const Module *M = MMI->getModule(); 898 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap; 899 900 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) { 901 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 902 DICompileUnit TheCU(CU_Nodes->getOperand(i)); 903 DIArray Subprograms = TheCU.getSubprograms(); 904 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) { 905 DISubprogram SP(Subprograms.getElement(i)); 906 if (ProcessedSPNodes.count(SP) != 0) continue; 907 if (!SP.isSubprogram()) continue; 908 if (!SP.isDefinition()) continue; 909 DIArray Variables = SP.getVariables(); 910 if (Variables.getNumElements() == 0) continue; 911 912 LexicalScope *Scope = 913 new LexicalScope(NULL, DIDescriptor(SP), NULL, false); 914 DeadFnScopeMap[SP] = Scope; 915 916 // Construct subprogram DIE and add variables DIEs. 917 CompileUnit *SPCU = CUMap.lookup(TheCU); 918 assert(SPCU && "Unable to find Compile Unit!"); 919 constructSubprogramDIE(SPCU, SP); 920 DIE *ScopeDIE = SPCU->getDIE(SP); 921 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) { 922 DIVariable DV(Variables.getElement(vi)); 923 if (!DV.isVariable()) continue; 924 DbgVariable NewVar(DV, NULL); 925 if (DIE *VariableDIE = 926 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope())) 927 ScopeDIE->addChild(VariableDIE); 928 } 929 } 930 } 931 } 932 DeleteContainerSeconds(DeadFnScopeMap); 933} 934 935// Type Signature [7.27] and ODR Hash code. 936 937/// \brief Grabs the string in whichever attribute is passed in and returns 938/// a reference to it. Returns "" if the attribute doesn't exist. 939static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) { 940 DIEValue *V = Die->findAttribute(Attr); 941 942 if (DIEString *S = dyn_cast_or_null<DIEString>(V)) 943 return S->getString(); 944 945 return StringRef(""); 946} 947 948/// Return true if the current DIE is contained within an anonymous namespace. 949static bool isContainedInAnonNamespace(DIE *Die) { 950 DIE *Parent = Die->getParent(); 951 952 while (Parent) { 953 if (Parent->getTag() == dwarf::DW_TAG_namespace && 954 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "") 955 return true; 956 Parent = Parent->getParent(); 957 } 958 959 return false; 960} 961 962/// Test if the current CU language is C++ and that we have 963/// a named type that is not contained in an anonymous namespace. 964static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) { 965 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus && 966 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" && 967 !isContainedInAnonNamespace(Die); 968} 969 970void DwarfDebug::finalizeModuleInfo() { 971 // Collect info for variables that were optimized out. 972 collectDeadVariables(); 973 974 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 975 computeInlinedDIEs(); 976 977 // Split out type units and conditionally add an ODR tag to the split 978 // out type. 979 // FIXME: Do type splitting. 980 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) { 981 DIE *Die = TypeUnits[i]; 982 DIEHash Hash; 983 // If we've requested ODR hashes and it's applicable for an ODR hash then 984 // add the ODR signature now. 985 // FIXME: This should be added onto the type unit, not the type, but this 986 // works as an intermediate stage. 987 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die)) 988 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature, 989 dwarf::DW_FORM_data8, 990 Hash.computeDIEODRSignature(Die)); 991 } 992 993 // Handle anything that needs to be done on a per-cu basis. 994 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(), 995 CUE = CUMap.end(); 996 CUI != CUE; ++CUI) { 997 CompileUnit *TheCU = CUI->second; 998 // Emit DW_AT_containing_type attribute to connect types with their 999 // vtable holding type. 1000 TheCU->constructContainingTypeDIEs(); 1001 1002 // If we're splitting the dwarf out now that we've got the entire 1003 // CU then construct a skeleton CU based upon it. 1004 if (useSplitDwarf()) { 1005 uint64_t ID = 0; 1006 if (GenerateCUHash) { 1007 DIEHash CUHash; 1008 ID = CUHash.computeCUSignature(TheCU->getCUDie()); 1009 } 1010 // This should be a unique identifier when we want to build .dwp files. 1011 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id, 1012 dwarf::DW_FORM_data8, ID); 1013 // Now construct the skeleton CU associated. 1014 CompileUnit *SkCU = constructSkeletonCU(TheCU); 1015 // This should be a unique identifier when we want to build .dwp files. 1016 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id, 1017 dwarf::DW_FORM_data8, ID); 1018 } 1019 } 1020 1021 // Compute DIE offsets and sizes. 1022 InfoHolder.computeSizeAndOffsets(); 1023 if (useSplitDwarf()) 1024 SkeletonHolder.computeSizeAndOffsets(); 1025} 1026 1027void DwarfDebug::endSections() { 1028 // Standard sections final addresses. 1029 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 1030 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end")); 1031 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 1032 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end")); 1033 1034 // End text sections. 1035 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) { 1036 Asm->OutStreamer.SwitchSection(SectionMap[I]); 1037 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1)); 1038 } 1039} 1040 1041// Emit all Dwarf sections that should come after the content. 1042void DwarfDebug::endModule() { 1043 1044 if (!FirstCU) return; 1045 1046 // End any existing sections. 1047 // TODO: Does this need to happen? 1048 endSections(); 1049 1050 // Finalize the debug info for the module. 1051 finalizeModuleInfo(); 1052 1053 if (!useSplitDwarf()) { 1054 // Emit all the DIEs into a debug info section. 1055 emitDebugInfo(); 1056 1057 // Corresponding abbreviations into a abbrev section. 1058 emitAbbreviations(); 1059 1060 // Emit info into a debug loc section. 1061 emitDebugLoc(); 1062 1063 // Emit info into a debug aranges section. 1064 emitDebugARanges(); 1065 1066 // Emit info into a debug ranges section. 1067 emitDebugRanges(); 1068 1069 // Emit info into a debug macinfo section. 1070 emitDebugMacInfo(); 1071 1072 } else { 1073 // TODO: Fill this in for separated debug sections and separate 1074 // out information into new sections. 1075 1076 // Emit the debug info section and compile units. 1077 emitDebugInfo(); 1078 emitDebugInfoDWO(); 1079 1080 // Corresponding abbreviations into a abbrev section. 1081 emitAbbreviations(); 1082 emitDebugAbbrevDWO(); 1083 1084 // Emit info into a debug loc section. 1085 emitDebugLoc(); 1086 1087 // Emit info into a debug aranges section. 1088 emitDebugARanges(); 1089 1090 // Emit info into a debug ranges section. 1091 emitDebugRanges(); 1092 1093 // Emit info into a debug macinfo section. 1094 emitDebugMacInfo(); 1095 1096 // Emit DWO addresses. 1097 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection()); 1098 1099 } 1100 1101 // Emit info into the dwarf accelerator table sections. 1102 if (useDwarfAccelTables()) { 1103 emitAccelNames(); 1104 emitAccelObjC(); 1105 emitAccelNamespaces(); 1106 emitAccelTypes(); 1107 } 1108 1109 // Emit the pubnames and pubtypes sections if requested. 1110 if (HasDwarfPubSections) { 1111 emitDebugPubNames(); 1112 emitDebugPubTypes(); 1113 } 1114 1115 // Finally emit string information into a string table. 1116 emitDebugStr(); 1117 if (useSplitDwarf()) 1118 emitDebugStrDWO(); 1119 1120 // clean up. 1121 SPMap.clear(); 1122 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 1123 E = CUMap.end(); I != E; ++I) 1124 delete I->second; 1125 1126 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(), 1127 E = SkeletonCUs.end(); I != E; ++I) 1128 delete *I; 1129 1130 // Reset these for the next Module if we have one. 1131 FirstCU = NULL; 1132} 1133 1134// Find abstract variable, if any, associated with Var. 1135DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV, 1136 DebugLoc ScopeLoc) { 1137 LLVMContext &Ctx = DV->getContext(); 1138 // More then one inlined variable corresponds to one abstract variable. 1139 DIVariable Var = cleanseInlinedVariable(DV, Ctx); 1140 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var); 1141 if (AbsDbgVariable) 1142 return AbsDbgVariable; 1143 1144 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx)); 1145 if (!Scope) 1146 return NULL; 1147 1148 AbsDbgVariable = new DbgVariable(Var, NULL); 1149 addScopeVariable(Scope, AbsDbgVariable); 1150 AbstractVariables[Var] = AbsDbgVariable; 1151 return AbsDbgVariable; 1152} 1153 1154// If Var is a current function argument then add it to CurrentFnArguments list. 1155bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF, 1156 DbgVariable *Var, LexicalScope *Scope) { 1157 if (!LScopes.isCurrentFunctionScope(Scope)) 1158 return false; 1159 DIVariable DV = Var->getVariable(); 1160 if (DV.getTag() != dwarf::DW_TAG_arg_variable) 1161 return false; 1162 unsigned ArgNo = DV.getArgNumber(); 1163 if (ArgNo == 0) 1164 return false; 1165 1166 size_t Size = CurrentFnArguments.size(); 1167 if (Size == 0) 1168 CurrentFnArguments.resize(MF->getFunction()->arg_size()); 1169 // llvm::Function argument size is not good indicator of how many 1170 // arguments does the function have at source level. 1171 if (ArgNo > Size) 1172 CurrentFnArguments.resize(ArgNo * 2); 1173 CurrentFnArguments[ArgNo - 1] = Var; 1174 return true; 1175} 1176 1177// Collect variable information from side table maintained by MMI. 1178void 1179DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF, 1180 SmallPtrSet<const MDNode *, 16> &Processed) { 1181 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 1182 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 1183 VE = VMap.end(); VI != VE; ++VI) { 1184 const MDNode *Var = VI->first; 1185 if (!Var) continue; 1186 Processed.insert(Var); 1187 DIVariable DV(Var); 1188 const std::pair<unsigned, DebugLoc> &VP = VI->second; 1189 1190 LexicalScope *Scope = LScopes.findLexicalScope(VP.second); 1191 1192 // If variable scope is not found then skip this variable. 1193 if (Scope == 0) 1194 continue; 1195 1196 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second); 1197 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable); 1198 RegVar->setFrameIndex(VP.first); 1199 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1200 addScopeVariable(Scope, RegVar); 1201 if (AbsDbgVariable) 1202 AbsDbgVariable->setFrameIndex(VP.first); 1203 } 1204} 1205 1206// Return true if debug value, encoded by DBG_VALUE instruction, is in a 1207// defined reg. 1208static bool isDbgValueInDefinedReg(const MachineInstr *MI) { 1209 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 1210 return MI->getNumOperands() == 3 && 1211 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() && 1212 (MI->getOperand(1).isImm() || 1213 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U)); 1214} 1215 1216// Get .debug_loc entry for the instruction range starting at MI. 1217static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm, 1218 const MCSymbol *FLabel, 1219 const MCSymbol *SLabel, 1220 const MachineInstr *MI) { 1221 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1222 1223 assert(MI->getNumOperands() == 3); 1224 if (MI->getOperand(0).isReg()) { 1225 MachineLocation MLoc; 1226 // If the second operand is an immediate, this is a 1227 // register-indirect address. 1228 if (!MI->getOperand(1).isImm()) 1229 MLoc.set(MI->getOperand(0).getReg()); 1230 else 1231 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm()); 1232 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var); 1233 } 1234 if (MI->getOperand(0).isImm()) 1235 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm()); 1236 if (MI->getOperand(0).isFPImm()) 1237 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm()); 1238 if (MI->getOperand(0).isCImm()) 1239 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm()); 1240 1241 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!"); 1242} 1243 1244// Find variables for each lexical scope. 1245void 1246DwarfDebug::collectVariableInfo(const MachineFunction *MF, 1247 SmallPtrSet<const MDNode *, 16> &Processed) { 1248 1249 // Grab the variable info that was squirreled away in the MMI side-table. 1250 collectVariableInfoFromMMITable(MF, Processed); 1251 1252 for (SmallVectorImpl<const MDNode*>::const_iterator 1253 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE; 1254 ++UVI) { 1255 const MDNode *Var = *UVI; 1256 if (Processed.count(Var)) 1257 continue; 1258 1259 // History contains relevant DBG_VALUE instructions for Var and instructions 1260 // clobbering it. 1261 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1262 if (History.empty()) 1263 continue; 1264 const MachineInstr *MInsn = History.front(); 1265 1266 DIVariable DV(Var); 1267 LexicalScope *Scope = NULL; 1268 if (DV.getTag() == dwarf::DW_TAG_arg_variable && 1269 DISubprogram(DV.getContext()).describes(MF->getFunction())) 1270 Scope = LScopes.getCurrentFunctionScope(); 1271 else if (MDNode *IA = DV.getInlinedAt()) 1272 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA)); 1273 else 1274 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1))); 1275 // If variable scope is not found then skip this variable. 1276 if (!Scope) 1277 continue; 1278 1279 Processed.insert(DV); 1280 assert(MInsn->isDebugValue() && "History must begin with debug value"); 1281 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc()); 1282 DbgVariable *RegVar = new DbgVariable(DV, AbsVar); 1283 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1284 addScopeVariable(Scope, RegVar); 1285 if (AbsVar) 1286 AbsVar->setMInsn(MInsn); 1287 1288 // Simplify ranges that are fully coalesced. 1289 if (History.size() <= 1 || (History.size() == 2 && 1290 MInsn->isIdenticalTo(History.back()))) { 1291 RegVar->setMInsn(MInsn); 1292 continue; 1293 } 1294 1295 // Handle multiple DBG_VALUE instructions describing one variable. 1296 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size()); 1297 1298 for (SmallVectorImpl<const MachineInstr*>::const_iterator 1299 HI = History.begin(), HE = History.end(); HI != HE; ++HI) { 1300 const MachineInstr *Begin = *HI; 1301 assert(Begin->isDebugValue() && "Invalid History entry"); 1302 1303 // Check if DBG_VALUE is truncating a range. 1304 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() 1305 && !Begin->getOperand(0).getReg()) 1306 continue; 1307 1308 // Compute the range for a register location. 1309 const MCSymbol *FLabel = getLabelBeforeInsn(Begin); 1310 const MCSymbol *SLabel = 0; 1311 1312 if (HI + 1 == HE) 1313 // If Begin is the last instruction in History then its value is valid 1314 // until the end of the function. 1315 SLabel = FunctionEndSym; 1316 else { 1317 const MachineInstr *End = HI[1]; 1318 DEBUG(dbgs() << "DotDebugLoc Pair:\n" 1319 << "\t" << *Begin << "\t" << *End << "\n"); 1320 if (End->isDebugValue()) 1321 SLabel = getLabelBeforeInsn(End); 1322 else { 1323 // End is a normal instruction clobbering the range. 1324 SLabel = getLabelAfterInsn(End); 1325 assert(SLabel && "Forgot label after clobber instruction"); 1326 ++HI; 1327 } 1328 } 1329 1330 // The value is valid until the next DBG_VALUE or clobber. 1331 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, 1332 Begin)); 1333 } 1334 DotDebugLocEntries.push_back(DotDebugLocEntry()); 1335 } 1336 1337 // Collect info for variables that were optimized out. 1338 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1339 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables(); 1340 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) { 1341 DIVariable DV(Variables.getElement(i)); 1342 if (!DV || !DV.isVariable() || !Processed.insert(DV)) 1343 continue; 1344 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) 1345 addScopeVariable(Scope, new DbgVariable(DV, NULL)); 1346 } 1347} 1348 1349// Return Label preceding the instruction. 1350MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { 1351 MCSymbol *Label = LabelsBeforeInsn.lookup(MI); 1352 assert(Label && "Didn't insert label before instruction"); 1353 return Label; 1354} 1355 1356// Return Label immediately following the instruction. 1357MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { 1358 return LabelsAfterInsn.lookup(MI); 1359} 1360 1361// Process beginning of an instruction. 1362void DwarfDebug::beginInstruction(const MachineInstr *MI) { 1363 // Check if source location changes, but ignore DBG_VALUE locations. 1364 if (!MI->isDebugValue()) { 1365 DebugLoc DL = MI->getDebugLoc(); 1366 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) { 1367 unsigned Flags = 0; 1368 PrevInstLoc = DL; 1369 if (DL == PrologEndLoc) { 1370 Flags |= DWARF2_FLAG_PROLOGUE_END; 1371 PrologEndLoc = DebugLoc(); 1372 } 1373 if (PrologEndLoc.isUnknown()) 1374 Flags |= DWARF2_FLAG_IS_STMT; 1375 1376 if (!DL.isUnknown()) { 1377 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 1378 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags); 1379 } else 1380 recordSourceLine(0, 0, 0, 0); 1381 } 1382 } 1383 1384 // Insert labels where requested. 1385 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1386 LabelsBeforeInsn.find(MI); 1387 1388 // No label needed. 1389 if (I == LabelsBeforeInsn.end()) 1390 return; 1391 1392 // Label already assigned. 1393 if (I->second) 1394 return; 1395 1396 if (!PrevLabel) { 1397 PrevLabel = MMI->getContext().CreateTempSymbol(); 1398 Asm->OutStreamer.EmitLabel(PrevLabel); 1399 } 1400 I->second = PrevLabel; 1401} 1402 1403// Process end of an instruction. 1404void DwarfDebug::endInstruction(const MachineInstr *MI) { 1405 // Don't create a new label after DBG_VALUE instructions. 1406 // They don't generate code. 1407 if (!MI->isDebugValue()) 1408 PrevLabel = 0; 1409 1410 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1411 LabelsAfterInsn.find(MI); 1412 1413 // No label needed. 1414 if (I == LabelsAfterInsn.end()) 1415 return; 1416 1417 // Label already assigned. 1418 if (I->second) 1419 return; 1420 1421 // We need a label after this instruction. 1422 if (!PrevLabel) { 1423 PrevLabel = MMI->getContext().CreateTempSymbol(); 1424 Asm->OutStreamer.EmitLabel(PrevLabel); 1425 } 1426 I->second = PrevLabel; 1427} 1428 1429// Each LexicalScope has first instruction and last instruction to mark 1430// beginning and end of a scope respectively. Create an inverse map that list 1431// scopes starts (and ends) with an instruction. One instruction may start (or 1432// end) multiple scopes. Ignore scopes that are not reachable. 1433void DwarfDebug::identifyScopeMarkers() { 1434 SmallVector<LexicalScope *, 4> WorkList; 1435 WorkList.push_back(LScopes.getCurrentFunctionScope()); 1436 while (!WorkList.empty()) { 1437 LexicalScope *S = WorkList.pop_back_val(); 1438 1439 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren(); 1440 if (!Children.empty()) 1441 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(), 1442 SE = Children.end(); SI != SE; ++SI) 1443 WorkList.push_back(*SI); 1444 1445 if (S->isAbstractScope()) 1446 continue; 1447 1448 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges(); 1449 if (Ranges.empty()) 1450 continue; 1451 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(), 1452 RE = Ranges.end(); RI != RE; ++RI) { 1453 assert(RI->first && "InsnRange does not have first instruction!"); 1454 assert(RI->second && "InsnRange does not have second instruction!"); 1455 requestLabelBeforeInsn(RI->first); 1456 requestLabelAfterInsn(RI->second); 1457 } 1458 } 1459} 1460 1461// Get MDNode for DebugLoc's scope. 1462static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) { 1463 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx)) 1464 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx); 1465 return DL.getScope(Ctx); 1466} 1467 1468// Walk up the scope chain of given debug loc and find line number info 1469// for the function. 1470static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) { 1471 const MDNode *Scope = getScopeNode(DL, Ctx); 1472 DISubprogram SP = getDISubprogram(Scope); 1473 if (SP.isSubprogram()) { 1474 // Check for number of operands since the compatibility is 1475 // cheap here. 1476 if (SP->getNumOperands() > 19) 1477 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP); 1478 else 1479 return DebugLoc::get(SP.getLineNumber(), 0, SP); 1480 } 1481 1482 return DebugLoc(); 1483} 1484 1485// Gather pre-function debug information. Assumes being called immediately 1486// after the function entry point has been emitted. 1487void DwarfDebug::beginFunction(const MachineFunction *MF) { 1488 if (!MMI->hasDebugInfo()) return; 1489 LScopes.initialize(*MF); 1490 if (LScopes.empty()) return; 1491 identifyScopeMarkers(); 1492 1493 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function 1494 // belongs to. 1495 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1496 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode()); 1497 assert(TheCU && "Unable to find compile unit!"); 1498 if (Asm->TM.hasMCUseLoc() && 1499 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) 1500 // Use a single line table if we are using .loc and generating assembly. 1501 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0); 1502 else 1503 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID()); 1504 1505 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 1506 Asm->getFunctionNumber()); 1507 // Assumes in correct section after the entry point. 1508 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 1509 1510 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned"); 1511 1512 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 1513 // LiveUserVar - Map physreg numbers to the MDNode they contain. 1514 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs()); 1515 1516 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 1517 I != E; ++I) { 1518 bool AtBlockEntry = true; 1519 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1520 II != IE; ++II) { 1521 const MachineInstr *MI = II; 1522 1523 if (MI->isDebugValue()) { 1524 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!"); 1525 1526 // Keep track of user variables. 1527 const MDNode *Var = 1528 MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1529 1530 // Variable is in a register, we need to check for clobbers. 1531 if (isDbgValueInDefinedReg(MI)) 1532 LiveUserVar[MI->getOperand(0).getReg()] = Var; 1533 1534 // Check the history of this variable. 1535 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1536 if (History.empty()) { 1537 UserVariables.push_back(Var); 1538 // The first mention of a function argument gets the FunctionBeginSym 1539 // label, so arguments are visible when breaking at function entry. 1540 DIVariable DV(Var); 1541 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable && 1542 DISubprogram(getDISubprogram(DV.getContext())) 1543 .describes(MF->getFunction())) 1544 LabelsBeforeInsn[MI] = FunctionBeginSym; 1545 } else { 1546 // We have seen this variable before. Try to coalesce DBG_VALUEs. 1547 const MachineInstr *Prev = History.back(); 1548 if (Prev->isDebugValue()) { 1549 // Coalesce identical entries at the end of History. 1550 if (History.size() >= 2 && 1551 Prev->isIdenticalTo(History[History.size() - 2])) { 1552 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n" 1553 << "\t" << *Prev 1554 << "\t" << *History[History.size() - 2] << "\n"); 1555 History.pop_back(); 1556 } 1557 1558 // Terminate old register assignments that don't reach MI; 1559 MachineFunction::const_iterator PrevMBB = Prev->getParent(); 1560 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) && 1561 isDbgValueInDefinedReg(Prev)) { 1562 // Previous register assignment needs to terminate at the end of 1563 // its basic block. 1564 MachineBasicBlock::const_iterator LastMI = 1565 PrevMBB->getLastNonDebugInstr(); 1566 if (LastMI == PrevMBB->end()) { 1567 // Drop DBG_VALUE for empty range. 1568 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n" 1569 << "\t" << *Prev << "\n"); 1570 History.pop_back(); 1571 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end()) 1572 // Terminate after LastMI. 1573 History.push_back(LastMI); 1574 } 1575 } 1576 } 1577 History.push_back(MI); 1578 } else { 1579 // Not a DBG_VALUE instruction. 1580 if (!MI->isLabel()) 1581 AtBlockEntry = false; 1582 1583 // First known non-DBG_VALUE and non-frame setup location marks 1584 // the beginning of the function body. 1585 if (!MI->getFlag(MachineInstr::FrameSetup) && 1586 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())) 1587 PrologEndLoc = MI->getDebugLoc(); 1588 1589 // Check if the instruction clobbers any registers with debug vars. 1590 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(), 1591 MOE = MI->operands_end(); MOI != MOE; ++MOI) { 1592 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg()) 1593 continue; 1594 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); 1595 AI.isValid(); ++AI) { 1596 unsigned Reg = *AI; 1597 const MDNode *Var = LiveUserVar[Reg]; 1598 if (!Var) 1599 continue; 1600 // Reg is now clobbered. 1601 LiveUserVar[Reg] = 0; 1602 1603 // Was MD last defined by a DBG_VALUE referring to Reg? 1604 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var); 1605 if (HistI == DbgValues.end()) 1606 continue; 1607 SmallVectorImpl<const MachineInstr*> &History = HistI->second; 1608 if (History.empty()) 1609 continue; 1610 const MachineInstr *Prev = History.back(); 1611 // Sanity-check: Register assignments are terminated at the end of 1612 // their block. 1613 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent()) 1614 continue; 1615 // Is the variable still in Reg? 1616 if (!isDbgValueInDefinedReg(Prev) || 1617 Prev->getOperand(0).getReg() != Reg) 1618 continue; 1619 // Var is clobbered. Make sure the next instruction gets a label. 1620 History.push_back(MI); 1621 } 1622 } 1623 } 1624 } 1625 } 1626 1627 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end(); 1628 I != E; ++I) { 1629 SmallVectorImpl<const MachineInstr*> &History = I->second; 1630 if (History.empty()) 1631 continue; 1632 1633 // Make sure the final register assignments are terminated. 1634 const MachineInstr *Prev = History.back(); 1635 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) { 1636 const MachineBasicBlock *PrevMBB = Prev->getParent(); 1637 MachineBasicBlock::const_iterator LastMI = 1638 PrevMBB->getLastNonDebugInstr(); 1639 if (LastMI == PrevMBB->end()) 1640 // Drop DBG_VALUE for empty range. 1641 History.pop_back(); 1642 else if (PrevMBB != &PrevMBB->getParent()->back()) { 1643 // Terminate after LastMI. 1644 History.push_back(LastMI); 1645 } 1646 } 1647 // Request labels for the full history. 1648 for (unsigned i = 0, e = History.size(); i != e; ++i) { 1649 const MachineInstr *MI = History[i]; 1650 if (MI->isDebugValue()) 1651 requestLabelBeforeInsn(MI); 1652 else 1653 requestLabelAfterInsn(MI); 1654 } 1655 } 1656 1657 PrevInstLoc = DebugLoc(); 1658 PrevLabel = FunctionBeginSym; 1659 1660 // Record beginning of function. 1661 if (!PrologEndLoc.isUnknown()) { 1662 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc, 1663 MF->getFunction()->getContext()); 1664 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(), 1665 FnStartDL.getScope(MF->getFunction()->getContext()), 1666 // We'd like to list the prologue as "not statements" but GDB behaves 1667 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing. 1668 DWARF2_FLAG_IS_STMT); 1669 } 1670} 1671 1672void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) { 1673 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS]; 1674 DIVariable DV = Var->getVariable(); 1675 // Variables with positive arg numbers are parameters. 1676 if (unsigned ArgNum = DV.getArgNumber()) { 1677 // Keep all parameters in order at the start of the variable list to ensure 1678 // function types are correct (no out-of-order parameters) 1679 // 1680 // This could be improved by only doing it for optimized builds (unoptimized 1681 // builds have the right order to begin with), searching from the back (this 1682 // would catch the unoptimized case quickly), or doing a binary search 1683 // rather than linear search. 1684 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin(); 1685 while (I != Vars.end()) { 1686 unsigned CurNum = (*I)->getVariable().getArgNumber(); 1687 // A local (non-parameter) variable has been found, insert immediately 1688 // before it. 1689 if (CurNum == 0) 1690 break; 1691 // A later indexed parameter has been found, insert immediately before it. 1692 if (CurNum > ArgNum) 1693 break; 1694 ++I; 1695 } 1696 Vars.insert(I, Var); 1697 return; 1698 } 1699 1700 Vars.push_back(Var); 1701} 1702 1703// Gather and emit post-function debug information. 1704void DwarfDebug::endFunction(const MachineFunction *MF) { 1705 if (!MMI->hasDebugInfo() || LScopes.empty()) return; 1706 1707 // Define end label for subprogram. 1708 FunctionEndSym = Asm->GetTempSymbol("func_end", 1709 Asm->getFunctionNumber()); 1710 // Assumes in correct section after the entry point. 1711 Asm->OutStreamer.EmitLabel(FunctionEndSym); 1712 // Set DwarfCompileUnitID in MCContext to default value. 1713 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0); 1714 1715 SmallPtrSet<const MDNode *, 16> ProcessedVars; 1716 collectVariableInfo(MF, ProcessedVars); 1717 1718 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1719 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode()); 1720 assert(TheCU && "Unable to find compile unit!"); 1721 1722 // Construct abstract scopes. 1723 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList(); 1724 for (unsigned i = 0, e = AList.size(); i != e; ++i) { 1725 LexicalScope *AScope = AList[i]; 1726 DISubprogram SP(AScope->getScopeNode()); 1727 if (SP.isSubprogram()) { 1728 // Collect info for variables that were optimized out. 1729 DIArray Variables = SP.getVariables(); 1730 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) { 1731 DIVariable DV(Variables.getElement(i)); 1732 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV)) 1733 continue; 1734 // Check that DbgVariable for DV wasn't created earlier, when 1735 // findAbstractVariable() was called for inlined instance of DV. 1736 LLVMContext &Ctx = DV->getContext(); 1737 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx); 1738 if (AbstractVariables.lookup(CleanDV)) 1739 continue; 1740 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext())) 1741 addScopeVariable(Scope, new DbgVariable(DV, NULL)); 1742 } 1743 } 1744 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0) 1745 constructScopeDIE(TheCU, AScope); 1746 } 1747 1748 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope); 1749 1750 if (!MF->getTarget().Options.DisableFramePointerElim(*MF)) 1751 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr); 1752 1753 // Clear debug info 1754 for (ScopeVariablesMap::iterator 1755 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I) 1756 DeleteContainerPointers(I->second); 1757 ScopeVariables.clear(); 1758 DeleteContainerPointers(CurrentFnArguments); 1759 UserVariables.clear(); 1760 DbgValues.clear(); 1761 AbstractVariables.clear(); 1762 LabelsBeforeInsn.clear(); 1763 LabelsAfterInsn.clear(); 1764 PrevLabel = NULL; 1765} 1766 1767// Register a source line with debug info. Returns the unique label that was 1768// emitted and which provides correspondence to the source line list. 1769void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S, 1770 unsigned Flags) { 1771 StringRef Fn; 1772 StringRef Dir; 1773 unsigned Src = 1; 1774 if (S) { 1775 DIDescriptor Scope(S); 1776 1777 if (Scope.isCompileUnit()) { 1778 DICompileUnit CU(S); 1779 Fn = CU.getFilename(); 1780 Dir = CU.getDirectory(); 1781 } else if (Scope.isFile()) { 1782 DIFile F(S); 1783 Fn = F.getFilename(); 1784 Dir = F.getDirectory(); 1785 } else if (Scope.isSubprogram()) { 1786 DISubprogram SP(S); 1787 Fn = SP.getFilename(); 1788 Dir = SP.getDirectory(); 1789 } else if (Scope.isLexicalBlockFile()) { 1790 DILexicalBlockFile DBF(S); 1791 Fn = DBF.getFilename(); 1792 Dir = DBF.getDirectory(); 1793 } else if (Scope.isLexicalBlock()) { 1794 DILexicalBlock DB(S); 1795 Fn = DB.getFilename(); 1796 Dir = DB.getDirectory(); 1797 } else 1798 llvm_unreachable("Unexpected scope info"); 1799 1800 Src = getOrCreateSourceID(Fn, Dir, 1801 Asm->OutStreamer.getContext().getDwarfCompileUnitID()); 1802 } 1803 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn); 1804} 1805 1806//===----------------------------------------------------------------------===// 1807// Emit Methods 1808//===----------------------------------------------------------------------===// 1809 1810// Compute the size and offset of a DIE. 1811unsigned 1812DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) { 1813 // Get the children. 1814 const std::vector<DIE *> &Children = Die->getChildren(); 1815 1816 // Record the abbreviation. 1817 assignAbbrevNumber(Die->getAbbrev()); 1818 1819 // Get the abbreviation for this DIE. 1820 unsigned AbbrevNumber = Die->getAbbrevNumber(); 1821 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1); 1822 1823 // Set DIE offset 1824 Die->setOffset(Offset); 1825 1826 // Start the size with the size of abbreviation code. 1827 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 1828 1829 const SmallVectorImpl<DIEValue*> &Values = Die->getValues(); 1830 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData(); 1831 1832 // Size the DIE attribute values. 1833 for (unsigned i = 0, N = Values.size(); i < N; ++i) 1834 // Size attribute value. 1835 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm()); 1836 1837 // Size the DIE children if any. 1838 if (!Children.empty()) { 1839 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 1840 "Children flag not set"); 1841 1842 for (unsigned j = 0, M = Children.size(); j < M; ++j) 1843 Offset = computeSizeAndOffset(Children[j], Offset); 1844 1845 // End of children marker. 1846 Offset += sizeof(int8_t); 1847 } 1848 1849 Die->setSize(Offset - Die->getOffset()); 1850 return Offset; 1851} 1852 1853// Compute the size and offset of all the DIEs. 1854void DwarfUnits::computeSizeAndOffsets() { 1855 // Offset from the beginning of debug info section. 1856 unsigned SecOffset = 0; 1857 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), 1858 E = CUs.end(); I != E; ++I) { 1859 (*I)->setDebugInfoOffset(SecOffset); 1860 unsigned Offset = 1861 sizeof(int32_t) + // Length of Compilation Unit Info 1862 sizeof(int16_t) + // DWARF version number 1863 sizeof(int32_t) + // Offset Into Abbrev. Section 1864 sizeof(int8_t); // Pointer Size (in bytes) 1865 1866 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset); 1867 SecOffset += EndOffset; 1868 } 1869} 1870 1871// Emit initial Dwarf sections with a label at the start of each one. 1872void DwarfDebug::emitSectionLabels() { 1873 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 1874 1875 // Dwarf sections base addresses. 1876 DwarfInfoSectionSym = 1877 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 1878 DwarfAbbrevSectionSym = 1879 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 1880 if (useSplitDwarf()) 1881 DwarfAbbrevDWOSectionSym = 1882 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(), 1883 "section_abbrev_dwo"); 1884 emitSectionSym(Asm, TLOF.getDwarfARangesSection()); 1885 1886 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 1887 emitSectionSym(Asm, MacroInfo); 1888 1889 DwarfLineSectionSym = 1890 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line"); 1891 emitSectionSym(Asm, TLOF.getDwarfLocSection()); 1892 if (HasDwarfPubSections) { 1893 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 1894 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 1895 } 1896 DwarfStrSectionSym = 1897 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string"); 1898 if (useSplitDwarf()) { 1899 DwarfStrDWOSectionSym = 1900 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string"); 1901 DwarfAddrSectionSym = 1902 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec"); 1903 } 1904 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(), 1905 "debug_range"); 1906 1907 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(), 1908 "section_debug_loc"); 1909 1910 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 1911 emitSectionSym(Asm, TLOF.getDataSection()); 1912} 1913 1914// Recursively emits a debug information entry. 1915void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) { 1916 // Get the abbreviation for this DIE. 1917 unsigned AbbrevNumber = Die->getAbbrevNumber(); 1918 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1); 1919 1920 // Emit the code (index) for the abbreviation. 1921 if (Asm->isVerbose()) 1922 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 1923 Twine::utohexstr(Die->getOffset()) + ":0x" + 1924 Twine::utohexstr(Die->getSize()) + " " + 1925 dwarf::TagString(Abbrev->getTag())); 1926 Asm->EmitULEB128(AbbrevNumber); 1927 1928 const SmallVectorImpl<DIEValue*> &Values = Die->getValues(); 1929 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData(); 1930 1931 // Emit the DIE attribute values. 1932 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 1933 unsigned Attr = AbbrevData[i].getAttribute(); 1934 unsigned Form = AbbrevData[i].getForm(); 1935 assert(Form && "Too many attributes for DIE (check abbreviation)"); 1936 1937 if (Asm->isVerbose()) 1938 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 1939 1940 switch (Attr) { 1941 case dwarf::DW_AT_abstract_origin: { 1942 DIEEntry *E = cast<DIEEntry>(Values[i]); 1943 DIE *Origin = E->getEntry(); 1944 unsigned Addr = Origin->getOffset(); 1945 if (Form == dwarf::DW_FORM_ref_addr) { 1946 // For DW_FORM_ref_addr, output the offset from beginning of debug info 1947 // section. Origin->getOffset() returns the offset from start of the 1948 // compile unit. 1949 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 1950 Addr += Holder.getCUOffset(Origin->getCompileUnit()); 1951 } 1952 Asm->OutStreamer.EmitIntValue(Addr, 1953 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4); 1954 break; 1955 } 1956 case dwarf::DW_AT_ranges: { 1957 // DW_AT_range Value encodes offset in debug_range section. 1958 DIEInteger *V = cast<DIEInteger>(Values[i]); 1959 1960 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) { 1961 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym, 1962 V->getValue(), 1963 4); 1964 } else { 1965 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym, 1966 V->getValue(), 1967 DwarfDebugRangeSectionSym, 1968 4); 1969 } 1970 break; 1971 } 1972 case dwarf::DW_AT_location: { 1973 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) { 1974 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 1975 Asm->EmitLabelReference(L->getValue(), 4); 1976 else 1977 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4); 1978 } else { 1979 Values[i]->EmitValue(Asm, Form); 1980 } 1981 break; 1982 } 1983 case dwarf::DW_AT_accessibility: { 1984 if (Asm->isVerbose()) { 1985 DIEInteger *V = cast<DIEInteger>(Values[i]); 1986 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue())); 1987 } 1988 Values[i]->EmitValue(Asm, Form); 1989 break; 1990 } 1991 default: 1992 // Emit an attribute using the defined form. 1993 Values[i]->EmitValue(Asm, Form); 1994 break; 1995 } 1996 } 1997 1998 // Emit the DIE children if any. 1999 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 2000 const std::vector<DIE *> &Children = Die->getChildren(); 2001 2002 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2003 emitDIE(Children[j], Abbrevs); 2004 2005 if (Asm->isVerbose()) 2006 Asm->OutStreamer.AddComment("End Of Children Mark"); 2007 Asm->EmitInt8(0); 2008 } 2009} 2010 2011// Emit the various dwarf units to the unit section USection with 2012// the abbreviations going into ASection. 2013void DwarfUnits::emitUnits(DwarfDebug *DD, 2014 const MCSection *USection, 2015 const MCSection *ASection, 2016 const MCSymbol *ASectionSym) { 2017 Asm->OutStreamer.SwitchSection(USection); 2018 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), 2019 E = CUs.end(); I != E; ++I) { 2020 CompileUnit *TheCU = *I; 2021 DIE *Die = TheCU->getCUDie(); 2022 2023 // Emit the compile units header. 2024 Asm->OutStreamer 2025 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(), 2026 TheCU->getUniqueID())); 2027 2028 // Emit size of content not including length itself 2029 unsigned ContentSize = Die->getSize() + 2030 sizeof(int16_t) + // DWARF version number 2031 sizeof(int32_t) + // Offset Into Abbrev. Section 2032 sizeof(int8_t); // Pointer Size (in bytes) 2033 2034 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 2035 Asm->EmitInt32(ContentSize); 2036 Asm->OutStreamer.AddComment("DWARF version number"); 2037 Asm->EmitInt16(DD->getDwarfVersion()); 2038 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 2039 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()), 2040 ASectionSym); 2041 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2042 Asm->EmitInt8(Asm->getDataLayout().getPointerSize()); 2043 2044 DD->emitDIE(Die, Abbreviations); 2045 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(), 2046 TheCU->getUniqueID())); 2047 } 2048} 2049 2050/// For a given compile unit DIE, returns offset from beginning of debug info. 2051unsigned DwarfUnits::getCUOffset(DIE *Die) { 2052 assert(Die->getTag() == dwarf::DW_TAG_compile_unit && 2053 "Input DIE should be compile unit in getCUOffset."); 2054 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end(); 2055 I != E; ++I) { 2056 CompileUnit *TheCU = *I; 2057 if (TheCU->getCUDie() == Die) 2058 return TheCU->getDebugInfoOffset(); 2059 } 2060 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits."); 2061} 2062 2063// Emit the debug info section. 2064void DwarfDebug::emitDebugInfo() { 2065 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 2066 2067 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(), 2068 Asm->getObjFileLowering().getDwarfAbbrevSection(), 2069 DwarfAbbrevSectionSym); 2070} 2071 2072// Emit the abbreviation section. 2073void DwarfDebug::emitAbbreviations() { 2074 if (!useSplitDwarf()) 2075 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(), 2076 &Abbreviations); 2077 else 2078 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection()); 2079} 2080 2081void DwarfDebug::emitAbbrevs(const MCSection *Section, 2082 std::vector<DIEAbbrev *> *Abbrevs) { 2083 // Check to see if it is worth the effort. 2084 if (!Abbrevs->empty()) { 2085 // Start the debug abbrev section. 2086 Asm->OutStreamer.SwitchSection(Section); 2087 2088 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName()); 2089 Asm->OutStreamer.EmitLabel(Begin); 2090 2091 // For each abbrevation. 2092 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) { 2093 // Get abbreviation data 2094 const DIEAbbrev *Abbrev = Abbrevs->at(i); 2095 2096 // Emit the abbrevations code (base 1 index.) 2097 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 2098 2099 // Emit the abbreviations data. 2100 Abbrev->Emit(Asm); 2101 } 2102 2103 // Mark end of abbreviations. 2104 Asm->EmitULEB128(0, "EOM(3)"); 2105 2106 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName()); 2107 Asm->OutStreamer.EmitLabel(End); 2108 } 2109} 2110 2111// Emit the last address of the section and the end of the line matrix. 2112void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 2113 // Define last address of section. 2114 Asm->OutStreamer.AddComment("Extended Op"); 2115 Asm->EmitInt8(0); 2116 2117 Asm->OutStreamer.AddComment("Op size"); 2118 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1); 2119 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 2120 Asm->EmitInt8(dwarf::DW_LNE_set_address); 2121 2122 Asm->OutStreamer.AddComment("Section end label"); 2123 2124 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 2125 Asm->getDataLayout().getPointerSize()); 2126 2127 // Mark end of matrix. 2128 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 2129 Asm->EmitInt8(0); 2130 Asm->EmitInt8(1); 2131 Asm->EmitInt8(1); 2132} 2133 2134// Emit visible names into a hashed accelerator table section. 2135void DwarfDebug::emitAccelNames() { 2136 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, 2137 dwarf::DW_FORM_data4)); 2138 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2139 E = CUMap.end(); I != E; ++I) { 2140 CompileUnit *TheCU = I->second; 2141 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames(); 2142 for (StringMap<std::vector<DIE*> >::const_iterator 2143 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2144 StringRef Name = GI->getKey(); 2145 const std::vector<DIE *> &Entities = GI->second; 2146 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 2147 DE = Entities.end(); DI != DE; ++DI) 2148 AT.AddName(Name, (*DI)); 2149 } 2150 } 2151 2152 AT.FinalizeTable(Asm, "Names"); 2153 Asm->OutStreamer.SwitchSection( 2154 Asm->getObjFileLowering().getDwarfAccelNamesSection()); 2155 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin"); 2156 Asm->OutStreamer.EmitLabel(SectionBegin); 2157 2158 // Emit the full data. 2159 AT.Emit(Asm, SectionBegin, &InfoHolder); 2160} 2161 2162// Emit objective C classes and categories into a hashed accelerator table 2163// section. 2164void DwarfDebug::emitAccelObjC() { 2165 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, 2166 dwarf::DW_FORM_data4)); 2167 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2168 E = CUMap.end(); I != E; ++I) { 2169 CompileUnit *TheCU = I->second; 2170 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC(); 2171 for (StringMap<std::vector<DIE*> >::const_iterator 2172 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2173 StringRef Name = GI->getKey(); 2174 const std::vector<DIE *> &Entities = GI->second; 2175 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 2176 DE = Entities.end(); DI != DE; ++DI) 2177 AT.AddName(Name, (*DI)); 2178 } 2179 } 2180 2181 AT.FinalizeTable(Asm, "ObjC"); 2182 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2183 .getDwarfAccelObjCSection()); 2184 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin"); 2185 Asm->OutStreamer.EmitLabel(SectionBegin); 2186 2187 // Emit the full data. 2188 AT.Emit(Asm, SectionBegin, &InfoHolder); 2189} 2190 2191// Emit namespace dies into a hashed accelerator table. 2192void DwarfDebug::emitAccelNamespaces() { 2193 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, 2194 dwarf::DW_FORM_data4)); 2195 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2196 E = CUMap.end(); I != E; ++I) { 2197 CompileUnit *TheCU = I->second; 2198 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace(); 2199 for (StringMap<std::vector<DIE*> >::const_iterator 2200 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2201 StringRef Name = GI->getKey(); 2202 const std::vector<DIE *> &Entities = GI->second; 2203 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 2204 DE = Entities.end(); DI != DE; ++DI) 2205 AT.AddName(Name, (*DI)); 2206 } 2207 } 2208 2209 AT.FinalizeTable(Asm, "namespac"); 2210 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2211 .getDwarfAccelNamespaceSection()); 2212 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin"); 2213 Asm->OutStreamer.EmitLabel(SectionBegin); 2214 2215 // Emit the full data. 2216 AT.Emit(Asm, SectionBegin, &InfoHolder); 2217} 2218 2219// Emit type dies into a hashed accelerator table. 2220void DwarfDebug::emitAccelTypes() { 2221 std::vector<DwarfAccelTable::Atom> Atoms; 2222 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, 2223 dwarf::DW_FORM_data4)); 2224 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, 2225 dwarf::DW_FORM_data2)); 2226 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, 2227 dwarf::DW_FORM_data1)); 2228 DwarfAccelTable AT(Atoms); 2229 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2230 E = CUMap.end(); I != E; ++I) { 2231 CompileUnit *TheCU = I->second; 2232 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names 2233 = TheCU->getAccelTypes(); 2234 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator 2235 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2236 StringRef Name = GI->getKey(); 2237 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second; 2238 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI 2239 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI) 2240 AT.AddName(Name, (*DI).first, (*DI).second); 2241 } 2242 } 2243 2244 AT.FinalizeTable(Asm, "types"); 2245 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2246 .getDwarfAccelTypesSection()); 2247 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin"); 2248 Asm->OutStreamer.EmitLabel(SectionBegin); 2249 2250 // Emit the full data. 2251 AT.Emit(Asm, SectionBegin, &InfoHolder); 2252} 2253 2254/// emitDebugPubNames - Emit visible names into a debug pubnames section. 2255/// 2256void DwarfDebug::emitDebugPubNames() { 2257 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection(); 2258 2259 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType; 2260 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) { 2261 CompileUnit *TheCU = I->second; 2262 unsigned ID = TheCU->getUniqueID(); 2263 2264 if (TheCU->getGlobalNames().empty()) 2265 continue; 2266 2267 // Start the dwarf pubnames section. 2268 Asm->OutStreamer 2269 .SwitchSection(Asm->getObjFileLowering().getDwarfPubNamesSection()); 2270 2271 Asm->OutStreamer.AddComment("Length of Public Names Info"); 2272 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID), 2273 Asm->GetTempSymbol("pubnames_begin", ID), 4); 2274 2275 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID)); 2276 2277 Asm->OutStreamer.AddComment("DWARF Version"); 2278 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION); 2279 2280 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2281 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID), 2282 DwarfInfoSectionSym); 2283 2284 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2285 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID), 2286 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID), 2287 4); 2288 2289 const StringMap<DIE*> &Globals = TheCU->getGlobalNames(); 2290 for (StringMap<DIE*>::const_iterator 2291 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2292 const char *Name = GI->getKeyData(); 2293 const DIE *Entity = GI->second; 2294 2295 Asm->OutStreamer.AddComment("DIE offset"); 2296 Asm->EmitInt32(Entity->getOffset()); 2297 2298 if (Asm->isVerbose()) 2299 Asm->OutStreamer.AddComment("External Name"); 2300 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1)); 2301 } 2302 2303 Asm->OutStreamer.AddComment("End Mark"); 2304 Asm->EmitInt32(0); 2305 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID)); 2306 } 2307} 2308 2309void DwarfDebug::emitDebugPubTypes() { 2310 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2311 E = CUMap.end(); I != E; ++I) { 2312 CompileUnit *TheCU = I->second; 2313 // Start the dwarf pubtypes section. 2314 Asm->OutStreamer.SwitchSection( 2315 Asm->getObjFileLowering().getDwarfPubTypesSection()); 2316 Asm->OutStreamer.AddComment("Length of Public Types Info"); 2317 Asm->EmitLabelDifference( 2318 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()), 2319 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4); 2320 2321 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 2322 TheCU->getUniqueID())); 2323 2324 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 2325 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION); 2326 2327 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2328 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection(); 2329 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), 2330 TheCU->getUniqueID()), 2331 DwarfInfoSectionSym); 2332 2333 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2334 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), 2335 TheCU->getUniqueID()), 2336 Asm->GetTempSymbol(ISec->getLabelBeginName(), 2337 TheCU->getUniqueID()), 2338 4); 2339 2340 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes(); 2341 for (StringMap<DIE*>::const_iterator 2342 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2343 const char *Name = GI->getKeyData(); 2344 DIE *Entity = GI->second; 2345 2346 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 2347 Asm->EmitInt32(Entity->getOffset()); 2348 2349 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 2350 // Emit the name with a terminating null byte. 2351 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1)); 2352 } 2353 2354 Asm->OutStreamer.AddComment("End Mark"); 2355 Asm->EmitInt32(0); 2356 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 2357 TheCU->getUniqueID())); 2358 } 2359} 2360 2361// Emit strings into a string section. 2362void DwarfUnits::emitStrings(const MCSection *StrSection, 2363 const MCSection *OffsetSection = NULL, 2364 const MCSymbol *StrSecSym = NULL) { 2365 2366 if (StringPool.empty()) return; 2367 2368 // Start the dwarf str section. 2369 Asm->OutStreamer.SwitchSection(StrSection); 2370 2371 // Get all of the string pool entries and put them in an array by their ID so 2372 // we can sort them. 2373 SmallVector<std::pair<unsigned, 2374 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 2375 2376 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 2377 I = StringPool.begin(), E = StringPool.end(); 2378 I != E; ++I) 2379 Entries.push_back(std::make_pair(I->second.second, &*I)); 2380 2381 array_pod_sort(Entries.begin(), Entries.end()); 2382 2383 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2384 // Emit a label for reference from debug information entries. 2385 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 2386 2387 // Emit the string itself with a terminating null byte. 2388 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(), 2389 Entries[i].second->getKeyLength()+1)); 2390 } 2391 2392 // If we've got an offset section go ahead and emit that now as well. 2393 if (OffsetSection) { 2394 Asm->OutStreamer.SwitchSection(OffsetSection); 2395 unsigned offset = 0; 2396 unsigned size = 4; // FIXME: DWARF64 is 8. 2397 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2398 Asm->OutStreamer.EmitIntValue(offset, size); 2399 offset += Entries[i].second->getKeyLength() + 1; 2400 } 2401 } 2402} 2403 2404// Emit strings into a string section. 2405void DwarfUnits::emitAddresses(const MCSection *AddrSection) { 2406 2407 if (AddressPool.empty()) return; 2408 2409 // Start the dwarf addr section. 2410 Asm->OutStreamer.SwitchSection(AddrSection); 2411 2412 // Order the address pool entries by ID 2413 SmallVector<const MCExpr *, 64> Entries(AddressPool.size()); 2414 2415 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(), 2416 E = AddressPool.end(); 2417 I != E; ++I) 2418 Entries[I->second] = I->first; 2419 2420 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2421 // Emit an expression for reference from debug information entries. 2422 if (const MCExpr *Expr = Entries[i]) 2423 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize()); 2424 else 2425 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize()); 2426 } 2427 2428} 2429 2430// Emit visible names into a debug str section. 2431void DwarfDebug::emitDebugStr() { 2432 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 2433 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection()); 2434} 2435 2436// Emit locations into the debug loc section. 2437void DwarfDebug::emitDebugLoc() { 2438 if (DotDebugLocEntries.empty()) 2439 return; 2440 2441 for (SmallVectorImpl<DotDebugLocEntry>::iterator 2442 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2443 I != E; ++I) { 2444 DotDebugLocEntry &Entry = *I; 2445 if (I + 1 != DotDebugLocEntries.end()) 2446 Entry.Merge(I+1); 2447 } 2448 2449 // Start the dwarf loc section. 2450 Asm->OutStreamer.SwitchSection( 2451 Asm->getObjFileLowering().getDwarfLocSection()); 2452 unsigned char Size = Asm->getDataLayout().getPointerSize(); 2453 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0)); 2454 unsigned index = 1; 2455 for (SmallVectorImpl<DotDebugLocEntry>::iterator 2456 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2457 I != E; ++I, ++index) { 2458 DotDebugLocEntry &Entry = *I; 2459 if (Entry.isMerged()) continue; 2460 if (Entry.isEmpty()) { 2461 Asm->OutStreamer.EmitIntValue(0, Size); 2462 Asm->OutStreamer.EmitIntValue(0, Size); 2463 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index)); 2464 } else { 2465 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size); 2466 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size); 2467 DIVariable DV(Entry.getVariable()); 2468 Asm->OutStreamer.AddComment("Loc expr size"); 2469 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol(); 2470 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol(); 2471 Asm->EmitLabelDifference(end, begin, 2); 2472 Asm->OutStreamer.EmitLabel(begin); 2473 if (Entry.isInt()) { 2474 DIBasicType BTy(DV.getType()); 2475 if (BTy.Verify() && 2476 (BTy.getEncoding() == dwarf::DW_ATE_signed 2477 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) { 2478 Asm->OutStreamer.AddComment("DW_OP_consts"); 2479 Asm->EmitInt8(dwarf::DW_OP_consts); 2480 Asm->EmitSLEB128(Entry.getInt()); 2481 } else { 2482 Asm->OutStreamer.AddComment("DW_OP_constu"); 2483 Asm->EmitInt8(dwarf::DW_OP_constu); 2484 Asm->EmitULEB128(Entry.getInt()); 2485 } 2486 } else if (Entry.isLocation()) { 2487 MachineLocation Loc = Entry.getLoc(); 2488 if (!DV.hasComplexAddress()) 2489 // Regular entry. 2490 Asm->EmitDwarfRegOp(Loc, DV.isIndirect()); 2491 else { 2492 // Complex address entry. 2493 unsigned N = DV.getNumAddrElements(); 2494 unsigned i = 0; 2495 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) { 2496 if (Loc.getOffset()) { 2497 i = 2; 2498 Asm->EmitDwarfRegOp(Loc, DV.isIndirect()); 2499 Asm->OutStreamer.AddComment("DW_OP_deref"); 2500 Asm->EmitInt8(dwarf::DW_OP_deref); 2501 Asm->OutStreamer.AddComment("DW_OP_plus_uconst"); 2502 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2503 Asm->EmitSLEB128(DV.getAddrElement(1)); 2504 } else { 2505 // If first address element is OpPlus then emit 2506 // DW_OP_breg + Offset instead of DW_OP_reg + Offset. 2507 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1)); 2508 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect()); 2509 i = 2; 2510 } 2511 } else { 2512 Asm->EmitDwarfRegOp(Loc, DV.isIndirect()); 2513 } 2514 2515 // Emit remaining complex address elements. 2516 for (; i < N; ++i) { 2517 uint64_t Element = DV.getAddrElement(i); 2518 if (Element == DIBuilder::OpPlus) { 2519 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2520 Asm->EmitULEB128(DV.getAddrElement(++i)); 2521 } else if (Element == DIBuilder::OpDeref) { 2522 if (!Loc.isReg()) 2523 Asm->EmitInt8(dwarf::DW_OP_deref); 2524 } else 2525 llvm_unreachable("unknown Opcode found in complex address"); 2526 } 2527 } 2528 } 2529 // else ... ignore constant fp. There is not any good way to 2530 // to represent them here in dwarf. 2531 Asm->OutStreamer.EmitLabel(end); 2532 } 2533 } 2534} 2535 2536// Emit visible names into a debug aranges section. 2537void DwarfDebug::emitDebugARanges() { 2538 // Start the dwarf aranges section. 2539 Asm->OutStreamer 2540 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection()); 2541} 2542 2543// Emit visible names into a debug ranges section. 2544void DwarfDebug::emitDebugRanges() { 2545 // Start the dwarf ranges section. 2546 Asm->OutStreamer 2547 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection()); 2548 unsigned char Size = Asm->getDataLayout().getPointerSize(); 2549 for (SmallVectorImpl<const MCSymbol *>::iterator 2550 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end(); 2551 I != E; ++I) { 2552 if (*I) 2553 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size); 2554 else 2555 Asm->OutStreamer.EmitIntValue(0, Size); 2556 } 2557} 2558 2559// Emit visible names into a debug macinfo section. 2560void DwarfDebug::emitDebugMacInfo() { 2561 if (const MCSection *LineInfo = 2562 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 2563 // Start the dwarf macinfo section. 2564 Asm->OutStreamer.SwitchSection(LineInfo); 2565 } 2566} 2567 2568// DWARF5 Experimental Separate Dwarf emitters. 2569 2570// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list, 2571// DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id, 2572// DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present, 2573// DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa. 2574CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) { 2575 2576 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 2577 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(), 2578 Asm, this, &SkeletonHolder); 2579 2580 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name, 2581 DICompileUnit(CU->getNode()).getSplitDebugFilename()); 2582 2583 // Relocate to the beginning of the addr_base section, else 0 for the 2584 // beginning of the one for this compile unit. 2585 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 2586 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset, 2587 DwarfAddrSectionSym); 2588 else 2589 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base, 2590 dwarf::DW_FORM_sec_offset, 0); 2591 2592 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point 2593 // into an entity. We're using 0, or a NULL label for this. 2594 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0); 2595 2596 // DW_AT_stmt_list is a offset of line number information for this 2597 // compile unit in debug_line section. 2598 // FIXME: Should handle multiple compile units. 2599 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 2600 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 2601 DwarfLineSectionSym); 2602 else 2603 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0); 2604 2605 if (!CompilationDir.empty()) 2606 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir); 2607 2608 SkeletonHolder.addUnit(NewCU); 2609 SkeletonCUs.push_back(NewCU); 2610 2611 return NewCU; 2612} 2613 2614void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) { 2615 assert(useSplitDwarf() && "No split dwarf debug info?"); 2616 emitAbbrevs(Section, &SkeletonAbbrevs); 2617} 2618 2619// Emit the .debug_info.dwo section for separated dwarf. This contains the 2620// compile units that would normally be in debug_info. 2621void DwarfDebug::emitDebugInfoDWO() { 2622 assert(useSplitDwarf() && "No split dwarf debug info?"); 2623 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(), 2624 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(), 2625 DwarfAbbrevDWOSectionSym); 2626} 2627 2628// Emit the .debug_abbrev.dwo section for separated dwarf. This contains the 2629// abbreviations for the .debug_info.dwo section. 2630void DwarfDebug::emitDebugAbbrevDWO() { 2631 assert(useSplitDwarf() && "No split dwarf?"); 2632 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(), 2633 &Abbreviations); 2634} 2635 2636// Emit the .debug_str.dwo section for separated dwarf. This contains the 2637// string section and is identical in format to traditional .debug_str 2638// sections. 2639void DwarfDebug::emitDebugStrDWO() { 2640 assert(useSplitDwarf() && "No split dwarf?"); 2641 const MCSection *OffSec = Asm->getObjFileLowering() 2642 .getDwarfStrOffDWOSection(); 2643 const MCSymbol *StrSym = DwarfStrSectionSym; 2644 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(), 2645 OffSec, StrSym); 2646} 2647 2648/// Find the MDNode for the given scope reference. 2649DIScope DwarfDebug::resolve(DIScopeRef SRef) const { 2650 return SRef.resolve(TypeIdentifierMap); 2651} 2652