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