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