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