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